/** * Copyright (c) 2021 OceanBase * OceanBase CE is licensed under Mulan PubL v2. * You can use this software according to the terms and conditions of the Mulan PubL v2. * You may obtain a copy of Mulan PubL v2 at: * http://license.coscl.org.cn/MulanPubL-2.0 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. * See the Mulan PubL v2 for more details. */ #include #include "sql/engine/expr/ob_expr_abs.h" #include "sql/engine/expr/ob_expr_test_utils.h" #include using namespace oceanbase::common; using namespace oceanbase::sql; TEST_OPERATOR(ObExprAbs); class TestObExprAbsTest : public ::testing::Test { public: TestObExprAbsTest(); virtual ~TestObExprAbsTest(); virtual void SetUp(); virtual void TearDown(); private: // disallow copy TestObExprAbsTest(const TestObExprAbsTest& other); TestObExprAbsTest& operator=(const TestObExprAbsTest& other); protected: // data members }; TestObExprAbsTest::TestObExprAbsTest() {} TestObExprAbsTest::~TestObExprAbsTest() {} void TestObExprAbsTest::SetUp() {} void TestObExprAbsTest::TearDown() {} #define EV 0.00001 #define ARITH_EXPECT_TYPE_WITH_ROW(cmp_op, func, type1, res) \ { \ ObExprResType t1; \ ObExprResType vres; \ ObExprTypeCtx ctx; \ cmp_op op; \ op.set_row_dimension(1); \ t1.set_type(type1); \ int err = op.func(vres, t1, ctx); \ ASSERT_EQ(res, err); \ } \ while (0) #define ARITH_EXPECT_TYPE(cmp_op, func, type1, res) \ { \ ObExprResType t1; \ ObExprResType vres; \ ObExprTypeCtx ctx; \ cmp_op op; \ t1.set_type(type1); \ int err = op.func(vres, t1, ctx); \ ASSERT_EQ(OB_SUCCESS, err); \ ASSERT_EQ(res, vres.get_type()); \ } \ while (0) #define ARITH_EXPECT_TYPE_ERROR(cmp_op, func, type1) \ { \ ObExprResType t1; \ ObExprResType vres; \ ObExprTypeCtx ctx; \ cmp_op op; \ t1.set_type(type1); \ int err = op.func(vres, t1, ctx); \ ASSERT_EQ(OB_ERR_INVALID_TYPE_FOR_OP, err); \ } \ while (0) #define ARITH_ERROR(cmp_op, str_buf, func, type1, v1, res) \ { \ ObObj t1; \ ObObj vres; \ cmp_op op; \ t1.set_##type1(v1); \ int err = op.func(vres, t1, str_buf); \ ASSERT_EQ(res, err); \ } \ while (0) #define ARITH_EXPECT(cmp_op, str_buf, func, type1, v1, res) \ { \ ObObj t1; \ ObObj vres; \ cmp_op op; \ t1.set_##type1(v1); \ int err = op.func(vres, t1, str_buf); \ if (OB_SUCCESS != err) { \ ASSERT_EQ(res, err); \ } else { \ ASSERT_EQ(OB_SUCCESS, err); \ switch (vres.get_type()) { \ case ObIntType: \ ASSERT_EQ(res, vres.get_int()); \ break; \ case ObDateTimeType: \ ASSERT_EQ(res, vres.get_datetime()); \ break; \ case ObPreciseDateTimeType: \ ASSERT_EQ(res, vres.get_precise_datetime()); \ break; \ case ObCreateTimeType: \ ASSERT_EQ(res, vres.get_ctime()); \ break; \ case ObModifyTimeType: \ ASSERT_EQ(res, vres.get_mtime()); \ break; \ case ObBoolType: \ ASSERT_EQ(res, vres.get_bool()); \ break; \ case ObFloatType: \ ASSERT_TRUE(fabsf(res - vres.get_float() < EV)); \ break; \ case ObDoubleType: \ ASSERT_TRUE(fabs(res - vres.get_double()) < EV); \ break; \ case ObMaxType: \ ASSERT_EQ(res, vres.get_type()); \ break; \ case ObNullType: \ ASSERT_EQ(res, vres.get_type()); \ break; \ default: \ ASSERT_TRUE(vres.is_null()); \ break; \ } \ } \ } \ while (0) #define ARITH_ABS_VARCHAR_EXPECT(cmp_op, str_buf, func, type1, v1, res, sprintf_type) \ { \ ObObj t1; \ ObObj vres; \ cmp_op op; \ t1.set_##type1(v1); \ ObExprStringBuf temp_buf; \ char num_str[512]; \ sprintf(num_str, sprintf_type, res); \ number::ObNumber res_num; \ res_num.from(num_str, temp_buf); \ \ int err = op.func(vres, t1, str_buf); \ if (OB_SUCCESS != err) { \ ASSERT_EQ(res, err); \ } else { \ ASSERT_EQ(OB_SUCCESS, err); \ switch (vres.get_type()) { \ case ObNumberType: \ ASSERT_EQ(res_num, vres.nmb_); \ break; \ default: \ ASSERT_TRUE(vres.is_null()); \ break; \ } \ } \ } \ while (0) #define R(t1, v1, res) ARITH_EXPECT(TestObExprAbs, &buf, calc_result1, t1, v1, res) #define E(t1, v1, res) ARITH_ERROR(TestObExprAbs, &buf, calc_result1, t1, v1, res) #define T(t1, res) ARITH_EXPECT_TYPE(TestObExprAbs, calc_result_type1, t1, res) #define TE(t1, res) ARITH_EXPECT_TYPE_WITH_ROW(TestObExprAbs, calc_result_type1, t1, res) #define TYE(t1) ARITH_EXPECT_TYPE_ERROR(TestObExprAbs, calc_result_type1, t1) #define AAVE(t1, v1, res, sprintf_type) \ ARITH_ABS_VARCHAR_EXPECT(TestObExprAbs, &buf, calc_result1, t1, v1, res, sprintf_type) TEST_F(TestObExprAbsTest, type_test) { T(ObNullType, ObDoubleType); T(ObTinyIntType, ObIntType); T(ObSmallIntType, ObIntType); T(ObMediumIntType, ObIntType); T(ObInt32Type, ObIntType); T(ObIntType, ObIntType); T(ObUTinyIntType, ObIntType); T(ObUSmallIntType, ObIntType); T(ObUMediumIntType, ObIntType); T(ObUInt32Type, ObIntType); T(ObUInt64Type, ObIntType); T(ObFloatType, ObDoubleType); T(ObDoubleType, ObDoubleType); T(ObUFloatType, ObDoubleType); T(ObUDoubleType, ObDoubleType); T(ObNumberType, ObNumberType); T(ObUNumberType, ObNumberType); T(ObDateTimeType, ObDoubleType); T(ObTimestampType, ObDoubleType); T(ObDateType, ObDoubleType); T(ObTimeType, ObDoubleType); T(ObYearType, ObIntType); T(ObVarcharType, ObDoubleType); T(ObCharType, ObDoubleType); // TE(ObHexStringType, OB_ERR_INVALID_TYPE_FOR_OP); // TE(ObExtendType, OB_ERR_INVALID_TYPE_FOR_OP); // TE(ObUnknownType, OB_ERR_INVALID_TYPE_FOR_OP); } TEST_F(TestObExprAbsTest, result_test) { ObExprStringBuf buf; R(null, 0, ObNullType); R(int, 1, 1); R(int, -1, 1); R(int, 0, 0); R(float, float(1.2), 1.2); R(float, float(-2.1), 2.1); R(float, float(-0.0), 0.0); R(double, 1.2, 1.2); R(double, -2.1, 2.1); R(double, -0.0, 0.0); R(datetime, 1, OB_ERR_INVALID_TYPE_FOR_OP); R(datetime, -1, OB_ERR_INVALID_TYPE_FOR_OP); R(datetime, 0, OB_ERR_INVALID_TYPE_FOR_OP); R(precise_datetime, 1, OB_ERR_INVALID_TYPE_FOR_OP); R(precise_datetime, -1, OB_ERR_INVALID_TYPE_FOR_OP); R(precise_datetime, 0, OB_ERR_INVALID_TYPE_FOR_OP); AAVE(varchar, "-34", 34, "%d"); AAVE(varchar, "dfer", OB_ERR_CAST_VARCHAR_TO_NUMBER, "%d"); AAVE(varchar, "-0.3434dgfg", OB_ERR_CAST_VARCHAR_TO_NUMBER, "%d"); AAVE(varchar, "-0.0", 0.0, "%f"); AAVE(varchar, "-1.9999", 1.9999, "%lf"); AAVE(varchar, "7777777777777777", 7777777777777777, "%ld"); R(ctime, 1, OB_ERR_INVALID_TYPE_FOR_OP); R(ctime, -1, OB_ERR_INVALID_TYPE_FOR_OP); R(ctime, 0, OB_ERR_INVALID_TYPE_FOR_OP); R(mtime, 1, OB_ERR_INVALID_TYPE_FOR_OP); R(mtime, -1, OB_ERR_INVALID_TYPE_FOR_OP); R(mtime, 0, OB_ERR_INVALID_TYPE_FOR_OP); E(ext, 0, OB_ERR_INVALID_TYPE_FOR_OP); R(bool, 1, OB_ERR_INVALID_TYPE_FOR_OP); R(bool, 0, OB_ERR_INVALID_TYPE_FOR_OP); R(bool, -122, OB_ERR_INVALID_TYPE_FOR_OP); R(bool, 122, OB_ERR_INVALID_TYPE_FOR_OP); } int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); }