1 // Copyright 2020 The Tint Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "src/writer/hlsl/test_helper.h"
16
17 namespace tint {
18 namespace writer {
19 namespace hlsl {
20 namespace {
21
22 using HlslGeneratorImplTest_Import = TestHelper;
23
24 struct HlslImportData {
25 const char* name;
26 const char* hlsl_name;
27 };
operator <<(std::ostream & out,HlslImportData data)28 inline std::ostream& operator<<(std::ostream& out, HlslImportData data) {
29 out << data.name;
30 return out;
31 }
32
33 using HlslImportData_SingleParamTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_SingleParamTest,FloatScalar)34 TEST_P(HlslImportData_SingleParamTest, FloatScalar) {
35 auto param = GetParam();
36
37 auto* ident = Expr(param.name);
38 auto* expr = Call(ident, 1.f);
39 WrapInFunction(expr);
40
41 GeneratorImpl& gen = Build();
42
43 std::stringstream out;
44 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
45 EXPECT_EQ(out.str(), std::string(param.hlsl_name) + "(1.0f)");
46 }
47 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
48 HlslImportData_SingleParamTest,
49 testing::Values(HlslImportData{"abs", "abs"},
50 HlslImportData{"acos", "acos"},
51 HlslImportData{"asin", "asin"},
52 HlslImportData{"atan", "atan"},
53 HlslImportData{"cos", "cos"},
54 HlslImportData{"cosh", "cosh"},
55 HlslImportData{"ceil", "ceil"},
56 HlslImportData{"exp", "exp"},
57 HlslImportData{"exp2", "exp2"},
58 HlslImportData{"floor", "floor"},
59 HlslImportData{"fract", "frac"},
60 HlslImportData{"inverseSqrt", "rsqrt"},
61 HlslImportData{"length", "length"},
62 HlslImportData{"log", "log"},
63 HlslImportData{"log2", "log2"},
64 HlslImportData{"round", "round"},
65 HlslImportData{"sign", "sign"},
66 HlslImportData{"sin", "sin"},
67 HlslImportData{"sinh", "sinh"},
68 HlslImportData{"sqrt", "sqrt"},
69 HlslImportData{"tan", "tan"},
70 HlslImportData{"tanh", "tanh"},
71 HlslImportData{"trunc", "trunc"}));
72
73 using HlslImportData_SingleIntParamTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_SingleIntParamTest,IntScalar)74 TEST_P(HlslImportData_SingleIntParamTest, IntScalar) {
75 auto param = GetParam();
76
77 auto* expr = Call(param.name, Expr(1));
78 WrapInFunction(expr);
79
80 GeneratorImpl& gen = Build();
81
82 std::stringstream out;
83 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
84 EXPECT_EQ(out.str(), std::string(param.hlsl_name) + "(1)");
85 }
86 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
87 HlslImportData_SingleIntParamTest,
88 testing::Values(HlslImportData{"abs", "abs"}));
89
90 using HlslImportData_SingleVectorParamTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_SingleVectorParamTest,FloatVector)91 TEST_P(HlslImportData_SingleVectorParamTest, FloatVector) {
92 auto param = GetParam();
93
94 auto* ident = Expr(param.name);
95 auto* expr = Call(ident, vec3<f32>(1.f, 2.f, 3.f));
96 WrapInFunction(expr);
97
98 GeneratorImpl& gen = Build();
99
100 std::stringstream out;
101 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
102 EXPECT_EQ(out.str(),
103 std::string(param.hlsl_name) + "(float3(1.0f, 2.0f, 3.0f))");
104 }
105 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
106 HlslImportData_SingleVectorParamTest,
107 testing::Values(HlslImportData{"abs", "abs"},
108 HlslImportData{"acos", "acos"},
109 HlslImportData{"asin", "asin"},
110 HlslImportData{"atan", "atan"},
111 HlslImportData{"cos", "cos"},
112 HlslImportData{"cosh", "cosh"},
113 HlslImportData{"ceil", "ceil"},
114 HlslImportData{"exp", "exp"},
115 HlslImportData{"exp2", "exp2"},
116 HlslImportData{"floor", "floor"},
117 HlslImportData{"fract", "frac"},
118 HlslImportData{"inverseSqrt", "rsqrt"},
119 HlslImportData{"length", "length"},
120 HlslImportData{"log", "log"},
121 HlslImportData{"log2", "log2"},
122 HlslImportData{"normalize",
123 "normalize"},
124 HlslImportData{"round", "round"},
125 HlslImportData{"sign", "sign"},
126 HlslImportData{"sin", "sin"},
127 HlslImportData{"sinh", "sinh"},
128 HlslImportData{"sqrt", "sqrt"},
129 HlslImportData{"tan", "tan"},
130 HlslImportData{"tanh", "tanh"},
131 HlslImportData{"trunc", "trunc"}));
132
133 using HlslImportData_DualParam_ScalarTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_DualParam_ScalarTest,Float)134 TEST_P(HlslImportData_DualParam_ScalarTest, Float) {
135 auto param = GetParam();
136
137 auto* expr = Call(param.name, 1.f, 2.f);
138 WrapInFunction(expr);
139
140 GeneratorImpl& gen = Build();
141
142 std::stringstream out;
143 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
144 EXPECT_EQ(out.str(), std::string(param.hlsl_name) + "(1.0f, 2.0f)");
145 }
146 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
147 HlslImportData_DualParam_ScalarTest,
148 testing::Values(HlslImportData{"atan2", "atan2"},
149 HlslImportData{"distance", "distance"},
150 HlslImportData{"max", "max"},
151 HlslImportData{"min", "min"},
152 HlslImportData{"pow", "pow"},
153 HlslImportData{"step", "step"}));
154
155 using HlslImportData_DualParam_VectorTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_DualParam_VectorTest,Float)156 TEST_P(HlslImportData_DualParam_VectorTest, Float) {
157 auto param = GetParam();
158
159 auto* expr =
160 Call(param.name, vec3<f32>(1.f, 2.f, 3.f), vec3<f32>(4.f, 5.f, 6.f));
161 WrapInFunction(expr);
162
163 GeneratorImpl& gen = Build();
164
165 std::stringstream out;
166 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
167 EXPECT_EQ(out.str(),
168 std::string(param.hlsl_name) +
169 "(float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f))");
170 }
171 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
172 HlslImportData_DualParam_VectorTest,
173 testing::Values(HlslImportData{"atan2", "atan2"},
174 HlslImportData{"cross", "cross"},
175 HlslImportData{"distance", "distance"},
176 HlslImportData{"max", "max"},
177 HlslImportData{"min", "min"},
178 HlslImportData{"pow", "pow"},
179 HlslImportData{"reflect", "reflect"},
180 HlslImportData{"step", "step"}));
181
182 using HlslImportData_DualParam_Int_Test = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_DualParam_Int_Test,IntScalar)183 TEST_P(HlslImportData_DualParam_Int_Test, IntScalar) {
184 auto param = GetParam();
185
186 auto* expr = Call(param.name, 1, 2);
187 WrapInFunction(expr);
188
189 GeneratorImpl& gen = Build();
190
191 std::stringstream out;
192 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
193 EXPECT_EQ(out.str(), std::string(param.hlsl_name) + "(1, 2)");
194 }
195 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
196 HlslImportData_DualParam_Int_Test,
197 testing::Values(HlslImportData{"max", "max"},
198 HlslImportData{"min", "min"}));
199
200 using HlslImportData_TripleParam_ScalarTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_TripleParam_ScalarTest,Float)201 TEST_P(HlslImportData_TripleParam_ScalarTest, Float) {
202 auto param = GetParam();
203
204 auto* expr = Call(param.name, 1.f, 2.f, 3.f);
205 WrapInFunction(expr);
206
207 GeneratorImpl& gen = Build();
208
209 std::stringstream out;
210 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
211 EXPECT_EQ(out.str(), std::string(param.hlsl_name) + "(1.0f, 2.0f, 3.0f)");
212 }
213 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
214 HlslImportData_TripleParam_ScalarTest,
215 testing::Values(HlslImportData{"fma", "mad"},
216 HlslImportData{"mix", "lerp"},
217 HlslImportData{"clamp", "clamp"},
218 HlslImportData{"smoothStep",
219 "smoothstep"}));
220
221 using HlslImportData_TripleParam_VectorTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_TripleParam_VectorTest,Float)222 TEST_P(HlslImportData_TripleParam_VectorTest, Float) {
223 auto param = GetParam();
224
225 auto* expr = Call(param.name, vec3<f32>(1.f, 2.f, 3.f),
226 vec3<f32>(4.f, 5.f, 6.f), vec3<f32>(7.f, 8.f, 9.f));
227 WrapInFunction(expr);
228
229 GeneratorImpl& gen = Build();
230
231 std::stringstream out;
232 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
233 EXPECT_EQ(
234 out.str(),
235 std::string(param.hlsl_name) +
236 R"((float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))");
237 }
238 INSTANTIATE_TEST_SUITE_P(
239 HlslGeneratorImplTest_Import,
240 HlslImportData_TripleParam_VectorTest,
241 testing::Values(HlslImportData{"faceForward", "faceforward"},
242 HlslImportData{"fma", "mad"},
243 HlslImportData{"clamp", "clamp"},
244 HlslImportData{"smoothStep", "smoothstep"}));
245
TEST_F(HlslGeneratorImplTest_Import,DISABLED_HlslImportData_FMix)246 TEST_F(HlslGeneratorImplTest_Import, DISABLED_HlslImportData_FMix) {
247 FAIL();
248 }
249
250 using HlslImportData_TripleParam_Int_Test = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_TripleParam_Int_Test,IntScalar)251 TEST_P(HlslImportData_TripleParam_Int_Test, IntScalar) {
252 auto param = GetParam();
253
254 auto* expr = Call(param.name, 1, 2, 3);
255 WrapInFunction(expr);
256
257 GeneratorImpl& gen = Build();
258
259 std::stringstream out;
260 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
261 EXPECT_EQ(out.str(), std::string(param.hlsl_name) + "(1, 2, 3)");
262 }
263 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
264 HlslImportData_TripleParam_Int_Test,
265 testing::Values(HlslImportData{"clamp", "clamp"}));
266
TEST_F(HlslGeneratorImplTest_Import,HlslImportData_Determinant)267 TEST_F(HlslGeneratorImplTest_Import, HlslImportData_Determinant) {
268 Global("var", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
269
270 auto* expr = Call("determinant", "var");
271 WrapInFunction(expr);
272
273 GeneratorImpl& gen = Build();
274
275 std::stringstream out;
276 ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
277 EXPECT_EQ(out.str(), std::string("determinant(var)"));
278 }
279
280 } // namespace
281 } // namespace hlsl
282 } // namespace writer
283 } // namespace tint
284