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
22 struct VariableStorageData {
23 const char* input;
24 ast::StorageClass storage_class;
25 ast::Access access;
26 };
operator <<(std::ostream & out,VariableStorageData data)27 inline std::ostream& operator<<(std::ostream& out, VariableStorageData data) {
28 out << std::string(data.input);
29 return out;
30 }
31
32 class VariableQualifierTest
33 : public ParserImplTestWithParam<VariableStorageData> {};
34
TEST_P(VariableQualifierTest,ParsesStorageClass)35 TEST_P(VariableQualifierTest, ParsesStorageClass) {
36 auto params = GetParam();
37 auto p = parser(std::string("<") + params.input + ">");
38
39 auto sc = p->variable_qualifier();
40 EXPECT_FALSE(p->has_error());
41 EXPECT_FALSE(sc.errored);
42 EXPECT_TRUE(sc.matched);
43 EXPECT_EQ(sc->storage_class, params.storage_class);
44 EXPECT_EQ(sc->access, params.access);
45
46 auto t = p->next();
47 EXPECT_TRUE(t.IsEof());
48 }
49 INSTANTIATE_TEST_SUITE_P(
50 ParserImplTest,
51 VariableQualifierTest,
52 testing::Values(
53 VariableStorageData{"uniform", ast::StorageClass::kUniform,
54 ast::Access::kUndefined},
55 VariableStorageData{"workgroup", ast::StorageClass::kWorkgroup,
56 ast::Access::kUndefined},
57 VariableStorageData{"storage", ast::StorageClass::kStorage,
58 ast::Access::kUndefined},
59 VariableStorageData{"storage_buffer", ast::StorageClass::kStorage,
60 ast::Access::kUndefined},
61 VariableStorageData{"image", ast::StorageClass::kImage,
62 ast::Access::kUndefined},
63 VariableStorageData{"private", ast::StorageClass::kPrivate,
64 ast::Access::kUndefined},
65 VariableStorageData{"function", ast::StorageClass::kFunction,
66 ast::Access::kUndefined},
67 VariableStorageData{"storage, read", ast::StorageClass::kStorage,
68 ast::Access::kRead},
69 VariableStorageData{"storage, write", ast::StorageClass::kStorage,
70 ast::Access::kWrite},
71 VariableStorageData{"storage, read_write", ast::StorageClass::kStorage,
72 ast::Access::kReadWrite}));
73
TEST_F(ParserImplTest,VariableQualifier_NoMatch)74 TEST_F(ParserImplTest, VariableQualifier_NoMatch) {
75 auto p = parser("<not-a-storage-class>");
76 auto sc = p->variable_qualifier();
77 EXPECT_TRUE(p->has_error());
78 EXPECT_TRUE(sc.errored);
79 EXPECT_FALSE(sc.matched);
80 EXPECT_EQ(p->error(), "1:2: invalid storage class for variable declaration");
81 }
82
TEST_F(ParserImplTest,VariableQualifier_Empty)83 TEST_F(ParserImplTest, VariableQualifier_Empty) {
84 auto p = parser("<>");
85 auto sc = p->variable_qualifier();
86 EXPECT_TRUE(p->has_error());
87 EXPECT_TRUE(sc.errored);
88 EXPECT_FALSE(sc.matched);
89 EXPECT_EQ(p->error(), "1:2: invalid storage class for variable declaration");
90 }
91
TEST_F(ParserImplTest,VariableQualifier_MissingLessThan)92 TEST_F(ParserImplTest, VariableQualifier_MissingLessThan) {
93 auto p = parser("private>");
94 auto sc = p->variable_qualifier();
95 EXPECT_FALSE(p->has_error());
96 EXPECT_FALSE(sc.errored);
97 EXPECT_FALSE(sc.matched);
98
99 auto t = p->next();
100 ASSERT_TRUE(t.Is(Token::Type::kPrivate));
101 }
102
TEST_F(ParserImplTest,VariableQualifier_MissingLessThan_AfterSC)103 TEST_F(ParserImplTest, VariableQualifier_MissingLessThan_AfterSC) {
104 auto p = parser("private, >");
105 auto sc = p->variable_qualifier();
106 EXPECT_FALSE(p->has_error());
107 EXPECT_FALSE(sc.errored);
108 EXPECT_FALSE(sc.matched);
109
110 auto t = p->next();
111 ASSERT_TRUE(t.Is(Token::Type::kPrivate));
112 }
113
TEST_F(ParserImplTest,VariableQualifier_MissingGreaterThan)114 TEST_F(ParserImplTest, VariableQualifier_MissingGreaterThan) {
115 auto p = parser("<private");
116 auto sc = p->variable_qualifier();
117 EXPECT_TRUE(p->has_error());
118 EXPECT_TRUE(sc.errored);
119 EXPECT_FALSE(sc.matched);
120 EXPECT_EQ(p->error(), "1:9: expected '>' for variable declaration");
121 }
122
123 } // namespace
124 } // namespace wgsl
125 } // namespace reader
126 } // namespace tint
127