Add unit tests for AsExpression
This CL adds unit tests for the as expression and fixes up a few issues
along the way.
Change-Id: I4591f31c1a48ea5580a87a129c728ef3c9be2c7c
Bug: tint:11
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/16340
Reviewed-by: Sarah Mashayekhi <sarahmashay@google.com>
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9d6cad9..a79ceba 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -194,6 +194,7 @@
set(TINT_TEST_SRCS
ast/array_accessor_expression_test.cc
+ ast/as_expression_test.cc
ast/binding_decoration_test.cc
ast/bool_literal_test.cc
ast/builtin_decoration_test.cc
diff --git a/src/ast/array_accessor_expression_test.cc b/src/ast/array_accessor_expression_test.cc
index 9e29322..c3c643b 100644
--- a/src/ast/array_accessor_expression_test.cc
+++ b/src/ast/array_accessor_expression_test.cc
@@ -48,7 +48,6 @@
EXPECT_TRUE(exp.IsArrayAccessor());
}
-
TEST_F(ArrayAccessorExpressionTest, IsValid) {
auto ary = std::make_unique<IdentifierExpression>("ary");
auto idx = std::make_unique<IdentifierExpression>("idx");
@@ -79,12 +78,12 @@
ArrayAccessorExpression exp(std::move(ary), std::move(idx));
std::ostringstream out;
- exp.to_str(out, 0);
+ exp.to_str(out, 2);
- EXPECT_EQ(out.str(), R"(ArrayAccessor{
- Identifier{ary}
- Identifier{idx}
-}
+ EXPECT_EQ(out.str(), R"( ArrayAccessor{
+ Identifier{ary}
+ Identifier{idx}
+ }
)");
}
diff --git a/src/ast/as_expression.cc b/src/ast/as_expression.cc
index deb9564..a7b34e4 100644
--- a/src/ast/as_expression.cc
+++ b/src/ast/as_expression.cc
@@ -17,6 +17,8 @@
namespace tint {
namespace ast {
+AsExpression::AsExpression() : Expression() {}
+
AsExpression::AsExpression(type::Type* type, std::unique_ptr<Expression> expr)
: Expression(), type_(type), expr_(std::move(expr)) {}
@@ -28,13 +30,17 @@
AsExpression::~AsExpression() = default;
bool AsExpression::IsValid() const {
- return type_ != nullptr && expr_ != nullptr;
+ if (expr_ == nullptr || !expr_->IsValid())
+ return false;
+ return type_ != nullptr;
}
void AsExpression::to_str(std::ostream& out, size_t indent) const {
- out << "as<" << type_->type_name() << ">(";
- expr_->to_str(out, indent);
- out << ")";
+ make_indent(out, indent);
+ out << "As<" << type_->type_name() << ">{" << std::endl;
+ expr_->to_str(out, indent + 2);
+ make_indent(out, indent);
+ out << "}" << std::endl;
}
} // namespace ast
diff --git a/src/ast/as_expression.h b/src/ast/as_expression.h
index 93036f8..0a7649b 100644
--- a/src/ast/as_expression.h
+++ b/src/ast/as_expression.h
@@ -30,6 +30,8 @@
class AsExpression : public Expression {
public:
/// Constructor
+ AsExpression();
+ /// Constructor
/// @param type the type
/// @param expr the expr
AsExpression(type::Type* type, std::unique_ptr<Expression> expr);
@@ -70,7 +72,7 @@
private:
AsExpression(const AsExpression&) = delete;
- type::Type* type_;
+ type::Type* type_ = nullptr;
std::unique_ptr<Expression> expr_;
};
diff --git a/src/ast/as_expression_test.cc b/src/ast/as_expression_test.cc
new file mode 100644
index 0000000..c49942d3
--- /dev/null
+++ b/src/ast/as_expression_test.cc
@@ -0,0 +1,98 @@
+// Copyright 2020 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/ast/as_expression.h"
+
+#include "gtest/gtest.h"
+#include "src/ast/identifier_expression.h"
+#include "src/ast/type/f32_type.h"
+
+namespace tint {
+namespace ast {
+
+using AsExpressionTest = testing::Test;
+
+TEST_F(AsExpressionTest, Create) {
+ type::F32Type f32;
+ auto expr = std::make_unique<IdentifierExpression>("expr");
+
+ auto expr_ptr = expr.get();
+
+ AsExpression exp(&f32, std::move(expr));
+ ASSERT_EQ(exp.type(), &f32);
+ ASSERT_EQ(exp.expr(), expr_ptr);
+}
+
+TEST_F(AsExpressionTest, CreateWithSource) {
+ type::F32Type f32;
+ auto expr = std::make_unique<IdentifierExpression>("expr");
+
+ AsExpression exp(Source{20, 2}, &f32, std::move(expr));
+ auto src = exp.source();
+ EXPECT_EQ(src.line, 20);
+ EXPECT_EQ(src.column, 2);
+}
+
+TEST_F(AsExpressionTest, IsAs) {
+ AsExpression exp;
+ EXPECT_TRUE(exp.IsAs());
+}
+
+TEST_F(AsExpressionTest, IsValid) {
+ type::F32Type f32;
+ auto expr = std::make_unique<IdentifierExpression>("expr");
+
+ AsExpression exp(&f32, std::move(expr));
+ EXPECT_TRUE(exp.IsValid());
+}
+
+TEST_F(AsExpressionTest, IsValid_MissingType) {
+ auto expr = std::make_unique<IdentifierExpression>("expr");
+
+ AsExpression exp;
+ exp.set_expr(std::move(expr));
+ EXPECT_FALSE(exp.IsValid());
+}
+
+TEST_F(AsExpressionTest, IsValid_MissingExpr) {
+ type::F32Type f32;
+
+ AsExpression exp;
+ exp.set_type(&f32);
+ EXPECT_FALSE(exp.IsValid());
+}
+
+TEST_F(AsExpressionTest, IsValid_InvalidExpr) {
+ type::F32Type f32;
+ auto expr = std::make_unique<IdentifierExpression>("");
+ AsExpression e(&f32, std::move(expr));
+ EXPECT_FALSE(e.IsValid());
+}
+
+TEST_F(AsExpressionTest, ToStr) {
+ type::F32Type f32;
+ auto expr = std::make_unique<IdentifierExpression>("expr");
+
+ AsExpression exp(&f32, std::move(expr));
+ std::ostringstream out;
+ exp.to_str(out, 2);
+
+ EXPECT_EQ(out.str(), R"( As<__f32>{
+ Identifier{expr}
+ }
+)");
+}
+
+} // namespace ast
+} // namespace tint
diff --git a/src/ast/identifier_expression.cc b/src/ast/identifier_expression.cc
index 9fcf4c5..986920a 100644
--- a/src/ast/identifier_expression.cc
+++ b/src/ast/identifier_expression.cc
@@ -34,7 +34,7 @@
IdentifierExpression::~IdentifierExpression() = default;
bool IdentifierExpression::IsValid() const {
- return name_.size() > 0 && name_[1].size() > 0;
+ return name_.size() > 0 && name_[0].size() > 0;
}
void IdentifierExpression::to_str(std::ostream& out, size_t indent) const {
