From 91e57dd7d82631dce6a7bf5210c06db88eb18966 Mon Sep 17 00:00:00 2001 From: Dan Sinclair Date: Thu, 5 Mar 2020 16:35:40 +0000 Subject: [PATCH] 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 --- src/CMakeLists.txt | 1 + src/ast/array_accessor_expression_test.cc | 11 ++- src/ast/as_expression.cc | 14 +++- src/ast/as_expression.h | 4 +- src/ast/as_expression_test.cc | 98 +++++++++++++++++++++++ src/ast/identifier_expression.cc | 2 +- 6 files changed, 118 insertions(+), 12 deletions(-) create mode 100644 src/ast/as_expression_test.cc diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 9d6cad976d..a79ceba968 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -194,6 +194,7 @@ endif() 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 9e293227b3..c3c643bd51 100644 --- a/src/ast/array_accessor_expression_test.cc +++ b/src/ast/array_accessor_expression_test.cc @@ -48,7 +48,6 @@ TEST_F(ArrayAccessorExpressionTest, IsArrayAccessor) { EXPECT_TRUE(exp.IsArrayAccessor()); } - TEST_F(ArrayAccessorExpressionTest, IsValid) { auto ary = std::make_unique("ary"); auto idx = std::make_unique("idx"); @@ -79,12 +78,12 @@ TEST_F(ArrayAccessorExpressionTest, ToStr) { 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 deb9564c56..a7b34e45cc 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 expr) : Expression(), type_(type), expr_(std::move(expr)) {} @@ -28,13 +30,17 @@ AsExpression::AsExpression(const Source& source, 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 93036f8484..0a7649b442 100644 --- a/src/ast/as_expression.h +++ b/src/ast/as_expression.h @@ -29,6 +29,8 @@ namespace ast { /// An as expression class AsExpression : public Expression { public: + /// Constructor + AsExpression(); /// Constructor /// @param type the type /// @param expr the expr @@ -70,7 +72,7 @@ class AsExpression : public Expression { private: AsExpression(const AsExpression&) = delete; - type::Type* type_; + type::Type* type_ = nullptr; std::unique_ptr expr_; }; diff --git a/src/ast/as_expression_test.cc b/src/ast/as_expression_test.cc new file mode 100644 index 0000000000..c49942d322 --- /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("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("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("expr"); + + AsExpression exp(&f32, std::move(expr)); + EXPECT_TRUE(exp.IsValid()); +} + +TEST_F(AsExpressionTest, IsValid_MissingType) { + auto expr = std::make_unique("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(""); + AsExpression e(&f32, std::move(expr)); + EXPECT_FALSE(e.IsValid()); +} + +TEST_F(AsExpressionTest, ToStr) { + type::F32Type f32; + auto expr = std::make_unique("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 9fcf4c5008..986920a770 100644 --- a/src/ast/identifier_expression.cc +++ b/src/ast/identifier_expression.cc @@ -34,7 +34,7 @@ IdentifierExpression::IdentifierExpression(const Source& source, 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 {