Add UnaryDerivativeExpression tests

This CL adds tests for the UnaryDerivativeExpression AST element.

Bug: tint:11
Change-Id: Ieabfdcb7940aedc58a3455b74c0ddb508b4859ff
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/16673
Reviewed-by: Sarah Mashayekhi <sarahmashay@google.com>

src/CMakeLists.txt

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 4be66da..8483f55 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -245,6 +245,7 @@
   ast/type/vector_type_test.cc
   ast/type_initializer_expression_test.cc
   ast/uint_literal_test.cc
+  ast/unary_derivative_expression_test.cc
   ast/variable_test.cc
   reader/wgsl/lexer_test.cc
   reader/wgsl/parser_test.cc

src/ast/unary_derivative_expression.cc

diff --git a/src/ast/unary_derivative_expression.cc b/src/ast/unary_derivative_expression.cc
index 1ae9a86..b2416f3 100644
--- a/src/ast/unary_derivative_expression.cc
+++ b/src/ast/unary_derivative_expression.cc
@@ -17,6 +17,8 @@
 namespace tint {
 namespace ast {
 
+UnaryDerivativeExpression::UnaryDerivativeExpression() : Expression() {}
+
 UnaryDerivativeExpression::UnaryDerivativeExpression(
     UnaryDerivative op,
     DerivativeModifier mod,
@@ -33,6 +35,9 @@
 UnaryDerivativeExpression::~UnaryDerivativeExpression() = default;
 
 bool UnaryDerivativeExpression::IsValid() const {
+  if (param_ == nullptr || !param_->IsValid()) {
+    return false;
+  }
   return true;
 }
 
@@ -43,9 +48,9 @@
   out << op_ << std::endl;
   make_indent(out, indent + 2);
   out << modifier_ << std::endl;
-  param_->to_str(out, indent);
+  param_->to_str(out, indent + 2);
   make_indent(out, indent);
-  out << "}";
+  out << "}" << std::endl;
 }
 
 }  // namespace ast

src/ast/unary_derivative_expression.h

diff --git a/src/ast/unary_derivative_expression.h b/src/ast/unary_derivative_expression.h
index f601286..d8568f2 100644
--- a/src/ast/unary_derivative_expression.h
+++ b/src/ast/unary_derivative_expression.h
@@ -30,6 +30,8 @@
 class UnaryDerivativeExpression : public Expression {
  public:
   /// Constructor
+  UnaryDerivativeExpression();
+  /// Constructor
   /// @param op the op
   /// @param mod the derivative modifier
   /// @param param the param

src/ast/unary_derivative_expression_test.cc

diff --git a/src/ast/unary_derivative_expression_test.cc b/src/ast/unary_derivative_expression_test.cc
new file mode 100644
index 0000000..17f43b3
--- /dev/null
+++ b/src/ast/unary_derivative_expression_test.cc
@@ -0,0 +1,88 @@
+// 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/unary_derivative_expression.h"
+
+#include <sstream>
+
+#include "gtest/gtest.h"
+#include "src/ast/identifier_expression.h"
+
+namespace tint {
+namespace ast {
+
+using UnaryDerivativeExpressionTest = testing::Test;
+
+TEST_F(UnaryDerivativeExpressionTest, Creation) {
+  auto ident = std::make_unique<IdentifierExpression>("ident");
+  auto ident_ptr = ident.get();
+
+  UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
+                              DerivativeModifier::kCoarse, std::move(ident));
+  EXPECT_EQ(d.param(), ident_ptr);
+  EXPECT_EQ(d.modifier(), DerivativeModifier::kCoarse);
+  EXPECT_EQ(d.op(), UnaryDerivative::kDpdy);
+}
+
+TEST_F(UnaryDerivativeExpressionTest, Creation_WithSource) {
+  auto ident = std::make_unique<IdentifierExpression>("ident");
+
+  UnaryDerivativeExpression d(Source{20, 2}, UnaryDerivative::kDpdy,
+                              DerivativeModifier::kCoarse, std::move(ident));
+  auto src = d.source();
+  EXPECT_EQ(src.line, 20);
+  EXPECT_EQ(src.column, 2);
+}
+
+TEST_F(UnaryDerivativeExpressionTest, IsUnaryDerivative) {
+  UnaryDerivativeExpression d;
+  EXPECT_TRUE(d.IsUnaryDerivative());
+}
+
+TEST_F(UnaryDerivativeExpressionTest, IsValid) {
+  auto ident = std::make_unique<IdentifierExpression>("ident");
+  UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
+                              DerivativeModifier::kCoarse, std::move(ident));
+  EXPECT_TRUE(d.IsValid());
+}
+
+TEST_F(UnaryDerivativeExpressionTest, IsValid_NullParam) {
+  UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
+                              DerivativeModifier::kCoarse, nullptr);
+  EXPECT_FALSE(d.IsValid());
+}
+
+TEST_F(UnaryDerivativeExpressionTest, IsValid_InvalidParam) {
+  auto ident = std::make_unique<IdentifierExpression>("");
+  UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
+                              DerivativeModifier::kCoarse, std::move(ident));
+  EXPECT_FALSE(d.IsValid());
+}
+
+TEST_F(UnaryDerivativeExpressionTest, ToStr) {
+  auto ident = std::make_unique<IdentifierExpression>("ident");
+  UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
+                              DerivativeModifier::kCoarse, std::move(ident));
+  std::ostringstream out;
+  d.to_str(out, 2);
+  EXPECT_EQ(out.str(), R"(  UnaryDerivative{
+    dpdy
+    coarse
+    Identifier{ident}
+  }
+)");
+}
+
+}  // namespace ast
+}  // namespace tint