Add EXPECT_CLOSE macros with tol arguments

Reviewed By: SS-JIA

Differential Revision: D48483563

fbshipit-source-id: 67db90b068aeb68f3f3662aa877d6079024a6ad8

Author: manuelcandales

runtime/core/exec_aten/testing_util/tensor_util.h

@@ -117,6 +117,18 @@ MATCHER_P(IsCloseTo, other, "") {
   return tensors_are_close(arg, other);
 }
 
+/**
+ * Lets gtest users write
+ * `EXPECT_THAT(tensor1, IsCloseToWithTol(tensor2, rtol, atol))`
+ * or `EXPECT_THAT(tensor1, Not(IsCloseToWithTol(tensor2, rtol, atol)))`.
+ *
+ * See also `EXPECT_TENSOR_CLOSE_WITH_TOL()` and
+ * `EXPECT_TENSOR_NOT_CLOSE_WITH_TOL()`.
+ */
+MATCHER_P3(IsCloseToWithTol, other, rtol, atol, "") {
+  return tensors_are_close(arg, other, rtol, atol);
+}
+
 /**
  * Lets gtest users write `EXPECT_THAT(tensor1, IsEqualTo(tensor2))` or
  * `EXPECT_THAT(tensor1, Not(IsEqualTo(tensor2)))`.
@@ -136,6 +148,19 @@ MATCHER_P(IsEqualTo, other, "") {
 MATCHER_P(IsDataCloseTo, other, "") {
   return tensor_data_is_close(arg, other);
 }
+
+/**
+ * Lets gtest users write
+ * `EXPECT_THAT(tensor1, IsDataCloseToWithTol(tensor2, rtol, atol))`
+ * or `EXPECT_THAT(tensor1, Not(IsDataCloseToWithTol(tensor2, rtol, atol)))`.
+ *
+ * See also `EXPECT_TENSOR_CLOSE_WITH_TOL()` and
+ * `EXPECT_TENSOR_NOT_CLOSE_WITH_TOL()`.
+ */
+MATCHER_P3(IsDataCloseToWithTol, other, rtol, atol, "") {
+  return tensor_data_is_close(arg, other, rtol, atol);
+}
+
 /**
  * Lets gtest users write `EXPECT_THAT(tensor1, IsDataEqualTo(tensor2))` or
  * `EXPECT_THAT(tensor1, Not(IsDataEqualTo(tensor2)))`.
@@ -205,6 +230,23 @@ MATCHER_P(IsListEqualTo, other, "") {
 #define ASSERT_TENSOR_NOT_CLOSE(t1, t2) \
   ASSERT_THAT((t1), ::testing::Not(torch::executor::testing::IsCloseTo(t2)))
 
+#define EXPECT_TENSOR_CLOSE_WITH_TOL(t1, t2, rtol, atol) \
+  EXPECT_THAT(                                           \
+      (t1), ::torch::executor::testing::IsCloseToWithTol(t2, rtol, atol))
+#define EXPECT_TENSOR_NOT_CLOSE_WITH_TOL(t1, t2, rtol, atol) \
+  EXPECT_THAT(                                               \
+      (t1),                                                  \
+      ::testing::Not(                                        \
+          torch::executor::testing::IsCloseToWithTol(t2, rtol, atol)))
+#define ASSERT_TENSOR_CLOSE_WITH_TOL(t1, t2, rtol, atol) \
+  ASSERT_THAT(                                           \
+      (t1), ::torch::executor::testing::IsCloseToWithTol(t2, rtol, atol))
+#define ASSERT_TENSOR_NOT_CLOSE_WITH_TOL(t1, t2, rtol, atol) \
+  ASSERT_THAT(                                               \
+      (t1),                                                  \
+      ::testing::Not(                                        \
+          torch::executor::testing::IsCloseToWithTol(t2, rtol, atol)))
+
 #define EXPECT_TENSOR_DATA_EQ(t1, t2) \
   EXPECT_THAT((t1), ::torch::executor::testing::IsDataEqualTo(t2))
 #define EXPECT_TENSOR_DATA_NE(t1, t2) \
@@ -223,6 +265,23 @@ MATCHER_P(IsListEqualTo, other, "") {
 #define ASSERT_TENSOR_DATA_NOT_CLOSE(t1, t2) \
   ASSERT_THAT((t1), ::testing::Not(torch::executor::testing::IsDataCloseTo(t2)))
 
+#define EXPECT_TENSOR_DATA_CLOSE_WITH_TOL(t1, t2, rtol, atol) \
+  EXPECT_THAT(                                                \
+      (t1), ::torch::executor::testing::IsDataCloseToWithTol(t2, rtol, atol))
+#define EXPECT_TENSOR_DATA_NOT_CLOSE_WITH_TOL(t1, t2, rtol, atol) \
+  EXPECT_THAT(                                                    \
+      (t1),                                                       \
+      ::testing::Not(                                             \
+          torch::executor::testing::IsDataCloseToWithTol(t2, rtol, atol)))
+#define ASSERT_TENSOR_DATA_CLOSE_WITH_TOL(t1, t2, rtol, atol) \
+  ASSERT_THAT(                                                \
+      (t1), ::torch::executor::testing::IsDataCloseToWithTol(t2, rtol, atol))
+#define ASSERT_TENSOR_DATA_NOT_CLOSE_WITH_TOL(t1, t2, rtol, atol) \
+  ASSERT_THAT(                                                    \
+      (t1),                                                       \
+      ::testing::Not(                                             \
+          torch::executor::testing::IsDataCloseToWithTol(t2, rtol, atol)))
+
 /*
  * Helpers for comparing lists of Tensors.
  */

runtime/core/exec_aten/testing_util/test/tensor_util_test.cpp

@@ -420,6 +420,48 @@ TEST(TensorUtilTest, DoubleAndInfinitNanElementsAreCloseAndEqual) {
   EXPECT_TENSORS_CLOSE_AND_EQUAL(a, b);
 }
 
+// Testing closeness with tolerances
+
+TEST(TensorUtilTest, TensorsAreCloseWithTol) {
+  TensorFactory<ScalarType::Float> tf;
+  TensorFactory<ScalarType::Double> td;
+
+  // Create two tensors with identical shape and dtype, but different data.
+  Tensor af = tf.make(/*sizes=*/{2, 2}, /*data=*/{1.0, 2.099999, 0.0, -0.05});
+  Tensor bf = tf.make(/*sizes=*/{2, 2}, /*data=*/{1.099999, 2.0, 0.05, 0.0});
+
+  EXPECT_TENSOR_CLOSE_WITH_TOL(af, bf, 0.0, 0.1);
+
+  // Create two tensors with identical shape and dtype, but different data.
+  Tensor ad = td.make(/*sizes=*/{2, 2}, /*data=*/{1.099, 2.199, NAN, -9.0});
+  Tensor bd = td.make(/*sizes=*/{2, 2}, /*data=*/{1.0, 2.0, NAN, -10.0});
+
+  EXPECT_TENSOR_CLOSE_WITH_TOL(ad, bd, 0.1, 0.0);
+}
+
+TEST(TensorUtilTest, TensorsAreNotCloseWithTol) {
+  TensorFactory<ScalarType::Float> tf;
+  TensorFactory<ScalarType::Double> td;
+
+  // Create two tensors with identical shape and dtype, but different data.
+  Tensor af = tf.make(/*sizes=*/{3}, /*data=*/{1.00, NAN, -10.0});
+  Tensor bf = tf.make(/*sizes=*/{3}, /*data=*/{1.11, NAN, -10.0});
+
+  EXPECT_TENSOR_NOT_CLOSE_WITH_TOL(af, bf, 0.0, 0.1);
+
+  // Create two tensors with identical shape and dtype, but different data.
+  Tensor ad = td.make(/*sizes=*/{3}, /*data=*/{1.0, 0.0, -10.0});
+  Tensor bd = td.make(/*sizes=*/{3}, /*data=*/{1.0, 0.0, -9.0});
+
+  EXPECT_TENSOR_NOT_CLOSE_WITH_TOL(ad, bd, 0.1, 0.0);
+
+  // Create two tensors with identical shape and dtype, but different data.
+  ad = tf.make(/*sizes=*/{3}, /*data=*/{1.0, 2.0, 0.00001});
+  bd = tf.make(/*sizes=*/{3}, /*data=*/{1.0, 2.0, 0.0});
+
+  EXPECT_TENSOR_NOT_CLOSE_WITH_TOL(ad, bd, 0.1, 0.0);
+}
+
 //
 // Tests for shape-agnostic data equality.
 //
@@ -585,6 +627,48 @@ TEST(TensorUtilTest, TensorDataMismatched) {
   EXPECT_TENSORS_DATA_NOT_CLOSE_OR_EQUAL(t_zero_dim, t_empty);
 }
 
+// Testing data closeness with tolerances
+
+TEST(TensorUtilTest, TensorDataCloseWithTol) {
+  TensorFactory<ScalarType::Float> tf;
+  TensorFactory<ScalarType::Double> td;
+
+  // Create two tensors with identical shape and dtype, but different data.
+  Tensor af = tf.make(/*sizes=*/{4, 1}, /*data=*/{1.0, 2.099, 0.0, -0.05});
+  Tensor bf = tf.make(/*sizes=*/{2, 2}, /*data=*/{1.099, 2.0, 0.05, 0.0});
+
+  EXPECT_TENSOR_DATA_CLOSE_WITH_TOL(af, bf, 0.0, 0.1);
+
+  // Create two tensors with identical shape and dtype, but different data.
+  Tensor ad = td.make(/*sizes=*/{2, 2}, /*data=*/{1.099, 2.199, NAN, -9.0});
+  Tensor bd = td.make(/*sizes=*/{4}, /*data=*/{1.0, 2.0, NAN, -10.0});
+
+  EXPECT_TENSOR_DATA_CLOSE_WITH_TOL(ad, bd, 0.1, 0.0);
+}
+
+TEST(TensorUtilTest, TensorDataNotCloseWithTol) {
+  TensorFactory<ScalarType::Float> tf;
+  TensorFactory<ScalarType::Double> td;
+
+  // Create two tensors with identical shape and dtype, but different data.
+  Tensor af = tf.make(/*sizes=*/{3}, /*data=*/{1.00, 0.0, -10.0});
+  Tensor bf = tf.make(/*sizes=*/{3, 1}, /*data=*/{1.11, 0.0, -10.0});
+
+  EXPECT_TENSOR_DATA_NOT_CLOSE_WITH_TOL(af, bf, 0.0, 0.1);
+
+  // Create two tensors with identical shape and dtype, but different data.
+  Tensor ad = td.make(/*sizes=*/{2, 2}, /*data=*/{1.0, 0.0, -10.0, 0.0});
+  Tensor bd = td.make(/*sizes=*/{4}, /*data=*/{1.0, 0.0, -9.0, 0.0});
+
+  EXPECT_TENSOR_DATA_NOT_CLOSE_WITH_TOL(ad, bd, 0.1, 0.0);
+
+  // Create two tensors with identical shape and dtype, but different data.
+  ad = tf.make(/*sizes=*/{1, 4}, /*data=*/{1.0, 2.0, NAN, 0.00001});
+  bd = tf.make(/*sizes=*/{2, 2}, /*data=*/{1.0, 2.0, NAN, 0.0});
+
+  EXPECT_TENSOR_DATA_NOT_CLOSE_WITH_TOL(ad, bd, 0.1, 0.0);
+}
+
 //
 // Tests for TensorList helpers.
 //