feat: add term test

Author: zhjwpku

src/iceberg/test/CMakeLists.txt

@@ -90,7 +90,8 @@ add_iceberg_test(expression_test
                  SOURCES
                  expression_test.cc
                  literal_test.cc
-                 predicate_test.cc)
+                 predicate_test.cc
+                 term_test.cc)
 
 add_iceberg_test(json_serde_test
                  SOURCES

src/iceberg/test/meson.build

@@ -58,6 +58,7 @@ iceberg_tests = {
             'expression_test.cc',
             'literal_test.cc',
             'predicate_test.cc',
+            'term_test.cc',
         ),
     },
     'json_serde_test': {

src/iceberg/test/term_test.cc

@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "iceberg/expression/term.h"
+
+#include <memory>
+
+#include <gtest/gtest.h>
+
+#include "iceberg/expression/expressions.h"
+#include "iceberg/schema.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/transform.h"
+#include "iceberg/util/checked_cast.h"
+
+namespace iceberg {
+class TermTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    field1_ = std::make_unique<SchemaField>(1, "x", int32(), true);
+    field2_ = std::make_unique<SchemaField>(2, "y", string(), true);
+    field3_ = std::make_unique<SchemaField>(3, "time", timestamp(), true);
+
+    schema_ = std::make_unique<Schema>(
+        std::vector<SchemaField>{*field1_, *field2_, *field3_}, 1);
+
+    term1_ = Expressions::Ref("x");
+    term2_ = Expressions::Ref("y");
+    term3_ = Expressions::Bucket("x", 10);
+    term4_ = Expressions::Day("time");
+  }
+
+  std::unique_ptr<Schema> schema_;
+  std::unique_ptr<SchemaField> field1_;
+  std::unique_ptr<SchemaField> field2_;
+  std::unique_ptr<SchemaField> field3_;
+
+  // NamedReference
+  std::shared_ptr<Term> term1_;
+  std::shared_ptr<Term> term2_;
+
+  // UnboundTransform
+  std::shared_ptr<Term> term3_;
+  std::shared_ptr<Term> term4_;
+};
+
+TEST_F(TermTest, NamedReference) {
+  auto nr1 = internal::checked_pointer_cast<NamedReference>(term1_);
+  auto bound_ref = nr1->Bind(*schema_, true);
+  ASSERT_THAT(bound_ref, IsOk());
+  ASSERT_EQ(bound_ref.value()->field(), *field1_);
+
+  auto nr2 = internal::checked_pointer_cast<NamedReference>(term2_);
+  auto bound_ref2 = nr2->Bind(*schema_, true);
+  ASSERT_THAT(bound_ref2, IsOk());
+  ASSERT_EQ(bound_ref2.value()->field(), *field2_);
+}
+
+TEST_F(TermTest, UnboundTransform) {
+  auto ut1 = internal::checked_pointer_cast<UnboundTransform>(term3_);
+  auto bound_transform = ut1->Bind(*schema_, true);
+  ASSERT_THAT(bound_transform, IsOk());
+  ASSERT_EQ(bound_transform.value()->reference()->field(), *field1_);
+  ASSERT_EQ(*bound_transform.value()->transform(), *Transform::Bucket(10));
+
+  auto ut2 = internal::checked_pointer_cast<UnboundTransform>(term4_);
+  auto bound_transform2 = ut2->Bind(*schema_, true);
+  ASSERT_THAT(bound_transform2, IsOk());
+  ASSERT_EQ(bound_transform2.value()->reference()->field(), *field3_);
+  ASSERT_EQ(*bound_transform2.value()->transform(), *Transform::Day());
+}
+
+}  // namespace iceberg