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 "gmock/gmock.h"
16 #include "src/ast/variable_decl_statement.h"
17 #include "src/writer/msl/test_helper.h"
18
19 namespace tint {
20 namespace writer {
21 namespace msl {
22 namespace {
23
24 using ::testing::HasSubstr;
25
26 using MslGeneratorImplTest = TestHelper;
27
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement)28 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement) {
29 auto* var = Var("a", ty.f32(), ast::StorageClass::kNone);
30 auto* stmt = Decl(var);
31 WrapInFunction(stmt);
32
33 GeneratorImpl& gen = Build();
34
35 gen.increment_indent();
36
37 ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
38 EXPECT_EQ(gen.result(), " float a = 0.0f;\n");
39 }
40
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement_Const)41 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Const) {
42 auto* var = Const("a", ty.f32(), Construct(ty.f32()));
43 auto* stmt = Decl(var);
44 WrapInFunction(stmt);
45
46 GeneratorImpl& gen = Build();
47
48 gen.increment_indent();
49
50 ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
51 EXPECT_EQ(gen.result(), " float const a = float();\n");
52 }
53
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement_Array)54 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Array) {
55 auto* var = Var("a", ty.array<f32, 5>(), ast::StorageClass::kNone);
56 auto* stmt = Decl(var);
57 WrapInFunction(stmt);
58
59 GeneratorImpl& gen = Build();
60
61 gen.increment_indent();
62
63 ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
64 EXPECT_EQ(gen.result(), " float a[5] = {0.0f};\n");
65 }
66
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement_Struct)67 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Struct) {
68 auto* s = Structure("S", {
69 Member("a", ty.f32()),
70 Member("b", ty.f32()),
71 });
72
73 auto* var = Var("a", ty.Of(s), ast::StorageClass::kNone);
74 auto* stmt = Decl(var);
75 WrapInFunction(stmt);
76
77 GeneratorImpl& gen = Build();
78
79 gen.increment_indent();
80
81 ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
82 EXPECT_EQ(gen.result(), R"( S a = {};
83 )");
84 }
85
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement_Vector)86 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Vector) {
87 auto* var = Var("a", ty.vec2<f32>());
88 auto* stmt = Decl(var);
89 WrapInFunction(stmt);
90
91 GeneratorImpl& gen = Build();
92
93 gen.increment_indent();
94
95 ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
96 EXPECT_EQ(gen.result(), " float2 a = 0.0f;\n");
97 }
98
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement_Matrix)99 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Matrix) {
100 auto* var = Var("a", ty.mat3x2<f32>());
101
102 auto* stmt = Decl(var);
103 WrapInFunction(stmt);
104
105 GeneratorImpl& gen = Build();
106
107 gen.increment_indent();
108
109 ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
110 EXPECT_EQ(gen.result(), " float3x2 a = float3x2(0.0f);\n");
111 }
112
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement_Private)113 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
114 Global("a", ty.f32(), ast::StorageClass::kPrivate);
115
116 WrapInFunction(Expr("a"));
117
118 GeneratorImpl& gen = SanitizeAndBuild();
119
120 gen.increment_indent();
121
122 ASSERT_TRUE(gen.Generate()) << gen.error();
123 EXPECT_THAT(gen.result(), HasSubstr("thread float tint_symbol_1 = 0.0f;\n"));
124 }
125
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement_Initializer_Private)126 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_Private) {
127 GlobalConst("initializer", ty.f32(), Expr(0.f));
128 Global("a", ty.f32(), ast::StorageClass::kPrivate, Expr("initializer"));
129
130 WrapInFunction(Expr("a"));
131
132 GeneratorImpl& gen = SanitizeAndBuild();
133
134 ASSERT_TRUE(gen.Generate()) << gen.error();
135 EXPECT_THAT(gen.result(),
136 HasSubstr("thread float tint_symbol_1 = initializer;\n"));
137 }
138
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement_Workgroup)139 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Workgroup) {
140 Global("a", ty.f32(), ast::StorageClass::kWorkgroup);
141
142 WrapInFunction(Expr("a"));
143
144 GeneratorImpl& gen = SanitizeAndBuild();
145
146 gen.increment_indent();
147
148 ASSERT_TRUE(gen.Generate()) << gen.error();
149 EXPECT_THAT(gen.result(), HasSubstr("threadgroup float tint_symbol_2;\n"));
150 }
151
TEST_F(MslGeneratorImplTest,Emit_VariableDeclStatement_Initializer_ZeroVec)152 TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_ZeroVec) {
153 auto* zero_vec = vec3<f32>();
154
155 auto* var = Var("a", ty.vec3<f32>(), ast::StorageClass::kNone, zero_vec);
156 auto* stmt = Decl(var);
157 WrapInFunction(stmt);
158
159 GeneratorImpl& gen = Build();
160
161 ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
162 EXPECT_EQ(gen.result(), R"(float3 a = float3();
163 )");
164 }
165
166 } // namespace
167 } // namespace msl
168 } // namespace writer
169 } // namespace tint
170