Add bool input tests for unary realb to float ops

Reviewed By: digantdesai

Differential Revision: D47118017

fbshipit-source-id: 9ec8f819b577f15fc2758353f43deedc582c3ad8

Author: manuelcandales

kernels/test/op_acos_test.cpp

@@ -20,6 +20,19 @@ Tensor& _acos_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::acos_outf(context, self, out);
 }
 
+TEST(OpAcosOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{1.570796, 0.000000});
+
+  EXPECT_TENSOR_CLOSE(_acos_out(a, out), res);
+}
+
 // Common testing for acos operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_acos_out(

kernels/test/op_acosh_test.cpp

@@ -20,6 +20,19 @@ Tensor& _acosh_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::acosh_outf(context, self, out);
 }
 
+TEST(OpAcoshOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{NAN, 0.000000});
+
+  EXPECT_TENSOR_CLOSE(_acosh_out(a, out), res);
+}
+
 // Common testing for acosh operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_acosh_out(

kernels/test/op_asin_test.cpp

@@ -20,6 +20,19 @@ Tensor& _asin_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::asin_outf(context, self, out);
 }
 
+TEST(OpAsinOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.000000, 1.5707960});
+
+  EXPECT_TENSOR_CLOSE(_asin_out(a, out), res);
+}
+
 // Common testing for asin operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_asin_out(

kernels/test/op_asinh_test.cpp

@@ -20,6 +20,19 @@ Tensor& _asinh_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::asinh_outf(context, self, out);
 }
 
+TEST(OpAsinhOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.000000, 0.881374});
+
+  EXPECT_TENSOR_CLOSE(_asinh_out(a, out), res);
+}
+
 // Common testing for asinh operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_asinh_out(

kernels/test/op_atan_test.cpp

@@ -20,6 +20,19 @@ Tensor& _atan_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::atan_outf(context, self, out);
 }
 
+TEST(OpAtanOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.000000, 0.785398});
+
+  EXPECT_TENSOR_CLOSE(_atan_out(a, out), res);
+}
+
 // Common testing for atan operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_atan_out(

kernels/test/op_atanh_test.cpp

@@ -20,6 +20,19 @@ Tensor& _atanh_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::atanh_outf(context, self, out);
 }
 
+TEST(OpAtanhOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.000000, INFINITY});
+
+  EXPECT_TENSOR_CLOSE(_atanh_out(a, out), res);
+}
+
 // Common testing for atanh operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_atanh_out(

kernels/test/op_cos_test.cpp

@@ -20,6 +20,19 @@ Tensor& _cos_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::cos_outf(context, self, out);
 }
 
+TEST(OpCosOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{1.000000, 0.540302});
+
+  EXPECT_TENSOR_CLOSE(_cos_out(a, out), res);
+}
+
 // Common testing for cos operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_cos_out(

kernels/test/op_cosh_test.cpp

@@ -20,6 +20,19 @@ Tensor& _cosh_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::cosh_outf(context, self, out);
 }
 
+TEST(OpCoshOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{1.000000, 1.543081});
+
+  EXPECT_TENSOR_CLOSE(_cosh_out(a, out), res);
+}
+
 // Common testing for cosh operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_cosh_out(

kernels/test/op_erf_test.cpp

@@ -32,3 +32,16 @@ TEST(OpErfTest, SanityCheck) {
   EXPECT_TENSOR_EQ(out, ret);
   EXPECT_TENSOR_CLOSE(out, expected);
 }
+
+TEST(OpErfTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.000000, 0.842701});
+
+  EXPECT_TENSOR_CLOSE(_erf_out(a, out), res);
+}

kernels/test/op_reciprocal_test.cpp

@@ -32,3 +32,16 @@ TEST(OpReciprocalTest, SanityCheck) {
   EXPECT_TENSOR_EQ(out, ret);
   EXPECT_TENSOR_CLOSE(out, expected);
 }
+
+TEST(OpReciprocalTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{INFINITY, 1.0});
+
+  EXPECT_TENSOR_CLOSE(_reciprocal_out(a, out), res);
+}

kernels/test/op_rsqrt_test.cpp

@@ -32,3 +32,16 @@ TEST(OpRsqrtTest, SanityCheck) {
   EXPECT_TENSOR_EQ(out, ret);
   EXPECT_TENSOR_CLOSE(out, expected);
 }
+
+TEST(OpRsqrtTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{INFINITY, 1.0});
+
+  EXPECT_TENSOR_CLOSE(_rsqrt_out(a, out), res);
+}

kernels/test/op_sin_test.cpp

@@ -20,6 +20,19 @@ Tensor& _sin_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::sin_outf(context, self, out);
 }
 
+TEST(OpSinOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.000000, 0.841471});
+
+  EXPECT_TENSOR_CLOSE(_sin_out(a, out), res);
+}
+
 // Common testing for sin operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_sin_out(

kernels/test/op_sinh_test.cpp

@@ -20,6 +20,19 @@ Tensor& _sinh_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::sinh_outf(context, self, out);
 }
 
+TEST(OpSinhOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.000000, 1.175201});
+
+  EXPECT_TENSOR_CLOSE(_sinh_out(a, out), res);
+}
+
 // Common testing for sinh operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_sinh_out(

kernels/test/op_sqrt_test.cpp

@@ -32,3 +32,16 @@ TEST(OpSqrtTest, SanityCheck) {
   EXPECT_TENSOR_EQ(out, ret);
   EXPECT_TENSOR_CLOSE(out, expected);
 }
+
+TEST(OpSqrtTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.0, 1.0});
+
+  EXPECT_TENSOR_CLOSE(_sqrt_out(a, out), res);
+}

kernels/test/op_tan_test.cpp

@@ -20,6 +20,19 @@ Tensor& _tan_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::tan_outf(context, self, out);
 }
 
+TEST(OpTanOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.000000, 1.557408});
+
+  EXPECT_TENSOR_CLOSE(_tan_out(a, out), res);
+}
+
 // Common testing for tan operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_tan_out(

kernels/test/op_tanh_test.cpp

@@ -19,6 +19,19 @@ Tensor& _tanh_out(const Tensor& self, Tensor& out) {
   return torch::executor::aten::tanh_outf(context, self, out);
 }
 
+TEST(OpTanhOutKernelTest, HandleBoolInput) {
+  TensorFactory<ScalarType::Bool> tf_bool;
+  TensorFactory<ScalarType::Float> tf_float;
+
+  const std::vector<int32_t> sizes = {1, 2};
+
+  Tensor a = tf_bool.make(sizes, /*data=*/{false, true});
+  Tensor out = tf_float.zeros(sizes);
+  Tensor res = tf_float.make(sizes, /*data=*/{0.000000, 0.761594});
+
+  EXPECT_TENSOR_CLOSE(_tanh_out(a, out), res);
+}
+
 // Common testing for tanh operator and all kinds of supported input types
 template <ScalarType IN_DTYPE, ScalarType OUT_DTYPE>
 void test_floating_point_tanh_out() {