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/reader/wgsl/parser_impl_test_helper.h"
16
17 namespace tint {
18 namespace reader {
19 namespace wgsl {
20 namespace {
21
TEST_F(ParserImplTest,SwitchBody_Case)22 TEST_F(ParserImplTest, SwitchBody_Case) {
23 auto p = parser("case 1: { a = 4; }");
24 auto e = p->switch_body();
25 EXPECT_FALSE(p->has_error()) << p->error();
26 EXPECT_TRUE(e.matched);
27 EXPECT_FALSE(e.errored);
28 ASSERT_NE(e.value, nullptr);
29 ASSERT_TRUE(e->Is<ast::CaseStatement>());
30 EXPECT_FALSE(e->IsDefault());
31 auto* stmt = e->As<ast::CaseStatement>();
32 ASSERT_EQ(stmt->selectors.size(), 1u);
33 EXPECT_EQ(stmt->selectors[0]->ValueAsU32(), 1u);
34 ASSERT_EQ(e->body->statements.size(), 1u);
35 EXPECT_TRUE(e->body->statements[0]->Is<ast::AssignmentStatement>());
36 }
37
TEST_F(ParserImplTest,SwitchBody_Case_TrailingComma)38 TEST_F(ParserImplTest, SwitchBody_Case_TrailingComma) {
39 auto p = parser("case 1, 2,: { }");
40 auto e = p->switch_body();
41 EXPECT_FALSE(p->has_error()) << p->error();
42 EXPECT_TRUE(e.matched);
43 EXPECT_FALSE(e.errored);
44 ASSERT_NE(e.value, nullptr);
45 ASSERT_TRUE(e->Is<ast::CaseStatement>());
46 EXPECT_FALSE(e->IsDefault());
47 auto* stmt = e->As<ast::CaseStatement>();
48 ASSERT_EQ(stmt->selectors.size(), 2u);
49 EXPECT_EQ(stmt->selectors[0]->ValueAsU32(), 1u);
50 EXPECT_EQ(stmt->selectors[1]->ValueAsU32(), 2u);
51 }
52
TEST_F(ParserImplTest,SwitchBody_Case_InvalidConstLiteral)53 TEST_F(ParserImplTest, SwitchBody_Case_InvalidConstLiteral) {
54 auto p = parser("case a == 4: { a = 4; }");
55 auto e = p->switch_body();
56 EXPECT_TRUE(p->has_error());
57 EXPECT_TRUE(e.errored);
58 EXPECT_FALSE(e.matched);
59 EXPECT_EQ(e.value, nullptr);
60 EXPECT_EQ(p->error(), "1:6: unable to parse case selectors");
61 }
62
TEST_F(ParserImplTest,SwitchBody_Case_InvalidSelector_bool)63 TEST_F(ParserImplTest, SwitchBody_Case_InvalidSelector_bool) {
64 auto p = parser("case true: { a = 4; }");
65 auto e = p->switch_body();
66 EXPECT_TRUE(p->has_error());
67 EXPECT_TRUE(e.errored);
68 EXPECT_FALSE(e.matched);
69 EXPECT_EQ(e.value, nullptr);
70 EXPECT_EQ(p->error(), "1:6: invalid case selector must be an integer value");
71 }
72
TEST_F(ParserImplTest,SwitchBody_Case_MissingConstLiteral)73 TEST_F(ParserImplTest, SwitchBody_Case_MissingConstLiteral) {
74 auto p = parser("case: { a = 4; }");
75 auto e = p->switch_body();
76 EXPECT_TRUE(p->has_error());
77 EXPECT_TRUE(e.errored);
78 EXPECT_FALSE(e.matched);
79 EXPECT_EQ(e.value, nullptr);
80 EXPECT_EQ(p->error(), "1:5: unable to parse case selectors");
81 }
82
TEST_F(ParserImplTest,SwitchBody_Case_MissingColon)83 TEST_F(ParserImplTest, SwitchBody_Case_MissingColon) {
84 auto p = parser("case 1 { a = 4; }");
85 auto e = p->switch_body();
86 EXPECT_TRUE(p->has_error());
87 EXPECT_TRUE(e.errored);
88 EXPECT_FALSE(e.matched);
89 EXPECT_EQ(e.value, nullptr);
90 EXPECT_EQ(p->error(), "1:8: expected ':' for case statement");
91 }
92
TEST_F(ParserImplTest,SwitchBody_Case_MissingBracketLeft)93 TEST_F(ParserImplTest, SwitchBody_Case_MissingBracketLeft) {
94 auto p = parser("case 1: a = 4; }");
95 auto e = p->switch_body();
96 EXPECT_TRUE(p->has_error());
97 EXPECT_TRUE(e.errored);
98 EXPECT_FALSE(e.matched);
99 EXPECT_EQ(e.value, nullptr);
100 EXPECT_EQ(p->error(), "1:9: expected '{' for case statement");
101 }
102
TEST_F(ParserImplTest,SwitchBody_Case_MissingBracketRight)103 TEST_F(ParserImplTest, SwitchBody_Case_MissingBracketRight) {
104 auto p = parser("case 1: { a = 4; ");
105 auto e = p->switch_body();
106 EXPECT_TRUE(p->has_error());
107 EXPECT_TRUE(e.errored);
108 EXPECT_FALSE(e.matched);
109 EXPECT_EQ(e.value, nullptr);
110 EXPECT_EQ(p->error(), "1:18: expected '}' for case statement");
111 }
112
TEST_F(ParserImplTest,SwitchBody_Case_InvalidCaseBody)113 TEST_F(ParserImplTest, SwitchBody_Case_InvalidCaseBody) {
114 auto p = parser("case 1: { fn main() {} }");
115 auto e = p->switch_body();
116 EXPECT_TRUE(p->has_error());
117 EXPECT_TRUE(e.errored);
118 EXPECT_FALSE(e.matched);
119 EXPECT_EQ(e.value, nullptr);
120 EXPECT_EQ(p->error(), "1:11: expected '}' for case statement");
121 }
122
TEST_F(ParserImplTest,SwitchBody_Case_MultipleSelectors)123 TEST_F(ParserImplTest, SwitchBody_Case_MultipleSelectors) {
124 auto p = parser("case 1, 2: { }");
125 auto e = p->switch_body();
126 EXPECT_FALSE(p->has_error()) << p->error();
127 EXPECT_TRUE(e.matched);
128 EXPECT_FALSE(e.errored);
129 ASSERT_NE(e.value, nullptr);
130 ASSERT_TRUE(e->Is<ast::CaseStatement>());
131 EXPECT_FALSE(e->IsDefault());
132 ASSERT_EQ(e->body->statements.size(), 0u);
133 ASSERT_EQ(e->selectors.size(), 2u);
134 ASSERT_EQ(e->selectors[0]->ValueAsI32(), 1);
135 ASSERT_EQ(e->selectors[1]->ValueAsI32(), 2);
136 }
137
TEST_F(ParserImplTest,SwitchBody_Case_MultipleSelectorsMissingColon)138 TEST_F(ParserImplTest, SwitchBody_Case_MultipleSelectorsMissingColon) {
139 auto p = parser("case 1, 2 { }");
140 auto e = p->switch_body();
141 EXPECT_TRUE(p->has_error());
142 EXPECT_TRUE(e.errored);
143 EXPECT_FALSE(e.matched);
144 EXPECT_EQ(e.value, nullptr);
145 EXPECT_EQ(p->error(), "1:11: expected ':' for case statement");
146 }
147
TEST_F(ParserImplTest,SwitchBody_Case_MultipleSelectorsMissingComma)148 TEST_F(ParserImplTest, SwitchBody_Case_MultipleSelectorsMissingComma) {
149 auto p = parser("case 1 2: { }");
150 auto e = p->switch_body();
151 EXPECT_TRUE(p->has_error());
152 EXPECT_TRUE(e.errored);
153 EXPECT_FALSE(e.matched);
154 EXPECT_EQ(e.value, nullptr);
155 EXPECT_EQ(p->error(), "1:8: expected ':' for case statement");
156 }
157
TEST_F(ParserImplTest,SwitchBody_Case_MultipleSelectorsStartsWithComma)158 TEST_F(ParserImplTest, SwitchBody_Case_MultipleSelectorsStartsWithComma) {
159 auto p = parser("case , 1, 2: { }");
160 auto e = p->switch_body();
161 EXPECT_TRUE(p->has_error());
162 EXPECT_TRUE(e.errored);
163 EXPECT_FALSE(e.matched);
164 EXPECT_EQ(e.value, nullptr);
165 EXPECT_EQ(p->error(), "1:6: unable to parse case selectors");
166 }
167
TEST_F(ParserImplTest,SwitchBody_Default)168 TEST_F(ParserImplTest, SwitchBody_Default) {
169 auto p = parser("default: { a = 4; }");
170 auto e = p->switch_body();
171 EXPECT_FALSE(p->has_error()) << p->error();
172 EXPECT_TRUE(e.matched);
173 EXPECT_FALSE(e.errored);
174 ASSERT_NE(e.value, nullptr);
175 ASSERT_TRUE(e->Is<ast::CaseStatement>());
176 EXPECT_TRUE(e->IsDefault());
177 ASSERT_EQ(e->body->statements.size(), 1u);
178 EXPECT_TRUE(e->body->statements[0]->Is<ast::AssignmentStatement>());
179 }
180
TEST_F(ParserImplTest,SwitchBody_Default_MissingColon)181 TEST_F(ParserImplTest, SwitchBody_Default_MissingColon) {
182 auto p = parser("default { a = 4; }");
183 auto e = p->switch_body();
184 EXPECT_TRUE(p->has_error());
185 EXPECT_TRUE(e.errored);
186 EXPECT_FALSE(e.matched);
187 EXPECT_EQ(e.value, nullptr);
188 EXPECT_EQ(p->error(), "1:9: expected ':' for case statement");
189 }
190
TEST_F(ParserImplTest,SwitchBody_Default_MissingBracketLeft)191 TEST_F(ParserImplTest, SwitchBody_Default_MissingBracketLeft) {
192 auto p = parser("default: a = 4; }");
193 auto e = p->switch_body();
194 EXPECT_TRUE(p->has_error());
195 EXPECT_TRUE(e.errored);
196 EXPECT_FALSE(e.matched);
197 EXPECT_EQ(e.value, nullptr);
198 EXPECT_EQ(p->error(), "1:10: expected '{' for case statement");
199 }
200
TEST_F(ParserImplTest,SwitchBody_Default_MissingBracketRight)201 TEST_F(ParserImplTest, SwitchBody_Default_MissingBracketRight) {
202 auto p = parser("default: { a = 4; ");
203 auto e = p->switch_body();
204 EXPECT_TRUE(p->has_error());
205 EXPECT_TRUE(e.errored);
206 EXPECT_FALSE(e.matched);
207 EXPECT_EQ(e.value, nullptr);
208 EXPECT_EQ(p->error(), "1:19: expected '}' for case statement");
209 }
210
TEST_F(ParserImplTest,SwitchBody_Default_InvalidCaseBody)211 TEST_F(ParserImplTest, SwitchBody_Default_InvalidCaseBody) {
212 auto p = parser("default: { fn main() {} }");
213 auto e = p->switch_body();
214 EXPECT_TRUE(p->has_error());
215 EXPECT_TRUE(e.errored);
216 EXPECT_FALSE(e.matched);
217 EXPECT_EQ(e.value, nullptr);
218 EXPECT_EQ(p->error(), "1:12: expected '}' for case statement");
219 }
220
221 } // namespace
222 } // namespace wgsl
223 } // namespace reader
224 } // namespace tint
225