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,RelationalExpression_Parses_LessThan)22 TEST_F(ParserImplTest, RelationalExpression_Parses_LessThan) {
23 auto p = parser("a < true");
24 auto e = p->relational_expression();
25 EXPECT_TRUE(e.matched);
26 EXPECT_FALSE(e.errored);
27 EXPECT_FALSE(p->has_error()) << p->error();
28 ASSERT_NE(e.value, nullptr);
29
30 ASSERT_TRUE(e->Is<ast::BinaryExpression>());
31 auto* rel = e->As<ast::BinaryExpression>();
32 EXPECT_EQ(ast::BinaryOp::kLessThan, rel->op);
33
34 ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
35 auto* ident = rel->lhs->As<ast::IdentifierExpression>();
36 EXPECT_EQ(ident->symbol, p->builder().Symbols().Register("a"));
37
38 ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
39 ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
40 }
41
TEST_F(ParserImplTest,RelationalExpression_Parses_GreaterThan)42 TEST_F(ParserImplTest, RelationalExpression_Parses_GreaterThan) {
43 auto p = parser("a > true");
44 auto e = p->relational_expression();
45 EXPECT_TRUE(e.matched);
46 EXPECT_FALSE(e.errored);
47 EXPECT_FALSE(p->has_error()) << p->error();
48 ASSERT_NE(e.value, nullptr);
49
50 ASSERT_TRUE(e->Is<ast::BinaryExpression>());
51 auto* rel = e->As<ast::BinaryExpression>();
52 EXPECT_EQ(ast::BinaryOp::kGreaterThan, rel->op);
53
54 ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
55 auto* ident = rel->lhs->As<ast::IdentifierExpression>();
56 EXPECT_EQ(ident->symbol, p->builder().Symbols().Register("a"));
57
58 ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
59 ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
60 }
61
TEST_F(ParserImplTest,RelationalExpression_Parses_LessThanEqual)62 TEST_F(ParserImplTest, RelationalExpression_Parses_LessThanEqual) {
63 auto p = parser("a <= true");
64 auto e = p->relational_expression();
65 EXPECT_TRUE(e.matched);
66 EXPECT_FALSE(e.errored);
67 EXPECT_FALSE(p->has_error()) << p->error();
68 ASSERT_NE(e.value, nullptr);
69
70 ASSERT_TRUE(e->Is<ast::BinaryExpression>());
71 auto* rel = e->As<ast::BinaryExpression>();
72 EXPECT_EQ(ast::BinaryOp::kLessThanEqual, rel->op);
73
74 ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
75 auto* ident = rel->lhs->As<ast::IdentifierExpression>();
76 EXPECT_EQ(ident->symbol, p->builder().Symbols().Register("a"));
77
78 ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
79 ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
80 }
81
TEST_F(ParserImplTest,RelationalExpression_Parses_GreaterThanEqual)82 TEST_F(ParserImplTest, RelationalExpression_Parses_GreaterThanEqual) {
83 auto p = parser("a >= true");
84 auto e = p->relational_expression();
85 EXPECT_TRUE(e.matched);
86 EXPECT_FALSE(e.errored);
87 EXPECT_FALSE(p->has_error()) << p->error();
88 ASSERT_NE(e.value, nullptr);
89
90 ASSERT_TRUE(e->Is<ast::BinaryExpression>());
91 auto* rel = e->As<ast::BinaryExpression>();
92 EXPECT_EQ(ast::BinaryOp::kGreaterThanEqual, rel->op);
93
94 ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
95 auto* ident = rel->lhs->As<ast::IdentifierExpression>();
96 EXPECT_EQ(ident->symbol, p->builder().Symbols().Register("a"));
97
98 ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
99 ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
100 }
101
TEST_F(ParserImplTest,RelationalExpression_InvalidLHS)102 TEST_F(ParserImplTest, RelationalExpression_InvalidLHS) {
103 auto p = parser("if (a) {} < true");
104 auto e = p->relational_expression();
105 EXPECT_FALSE(e.matched);
106 EXPECT_FALSE(e.errored);
107 EXPECT_FALSE(p->has_error()) << p->error();
108 EXPECT_EQ(e.value, nullptr);
109 }
110
TEST_F(ParserImplTest,RelationalExpression_InvalidRHS)111 TEST_F(ParserImplTest, RelationalExpression_InvalidRHS) {
112 auto p = parser("true < if (a) {}");
113 auto e = p->relational_expression();
114 ASSERT_TRUE(p->has_error());
115 EXPECT_EQ(e.value, nullptr);
116 EXPECT_EQ(p->error(), "1:8: unable to parse right side of < expression");
117 }
118
TEST_F(ParserImplTest,RelationalExpression_NoOr_ReturnsLHS)119 TEST_F(ParserImplTest, RelationalExpression_NoOr_ReturnsLHS) {
120 auto p = parser("a true");
121 auto e = p->relational_expression();
122 EXPECT_TRUE(e.matched);
123 EXPECT_FALSE(e.errored);
124 EXPECT_FALSE(p->has_error()) << p->error();
125 ASSERT_NE(e.value, nullptr);
126 ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
127 }
128
129 } // namespace
130 } // namespace wgsl
131 } // namespace reader
132 } // namespace tint
133