database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-04-18 21:44:02 +03:00
Code
mariadb-columnstore-engine/tests/dataconvert-tests.cpp
Leonid Fedorov 04752ec546 clang format apply
2022-01-21 16:43:49 +00:00

610 lines
22 KiB
C++
Raw Permalink Blame History

/* Copyright (C) 2020 MariaDB Corporation
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of
the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
#include <bitset>
using namespace std;
#include "gtest/gtest.h"
#include "dataconvert.h"
using namespace dataconvert;
#include "joblisttypes.h"
#include "columnwidth.h"
TEST(DataConvertTest, Strtoll128)
{
char* ep = NULL;
bool saturate = false;
string str;
int128_t val, valMax;
bitset<64> b1, b2, b3, b4;
// test empty
str = "";
val = strtoll128(str.c_str(), saturate, &ep);
EXPECT_EQ(val, 0);
EXPECT_EQ(*ep, '\0');
EXPECT_FALSE(saturate);
// test simple values
str = "123";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
EXPECT_EQ(val, 123);
EXPECT_EQ(*ep, '\0');
EXPECT_FALSE(saturate);
str = " 123";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
EXPECT_EQ(val, 123);
EXPECT_EQ(*ep, '\0');
EXPECT_FALSE(saturate);
str = " 123.45";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
EXPECT_EQ(val, 123);
EXPECT_NE(*ep, '\0');
EXPECT_FALSE(saturate);
str = "-123";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
EXPECT_EQ(val, -123);
EXPECT_EQ(*ep, '\0');
EXPECT_FALSE(saturate);
str = " -123";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
EXPECT_EQ(val, -123);
EXPECT_EQ(*ep, '\0');
EXPECT_FALSE(saturate);
str = " -123.45";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
EXPECT_EQ(val, -123);
EXPECT_NE(*ep, '\0');
EXPECT_FALSE(saturate);
// test max/min values
// test max
str = "170141183460469231731687303715884105727";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
b1 = *(reinterpret_cast<const uint64_t*>(&val));
b2 = *(reinterpret_cast<const uint64_t*>(&val) + 1);
valMax = ((((((((int128_t)170141183 * 1000000000) + 460469231) * 1000000000) + 731687303) * 1000000000) +
715884105) *
1000) +
727;
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_EQ(*ep, '\0');
EXPECT_FALSE(saturate);
// test min
str = "-170141183460469231731687303715884105728";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
b1 = *(reinterpret_cast<const uint64_t*>(&val));
b2 = *(reinterpret_cast<const uint64_t*>(&val) + 1);
valMax = ((((((((int128_t)170141183 * 1000000000) + 460469231) * 1000000000) + 731687303) * 1000000000) +
715884105) *
1000) +
727;
valMax = -valMax - 1;
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_EQ(*ep, '\0');
EXPECT_FALSE(saturate);
// test saturation
// test saturation to max
str = "170141183460469231731687303715884105728";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
b1 = *(reinterpret_cast<const uint64_t*>(&val));
b2 = *(reinterpret_cast<const uint64_t*>(&val) + 1);
valMax = ((((((((int128_t)170141183 * 1000000000) + 460469231) * 1000000000) + 731687303) * 1000000000) +
715884105) *
1000) +
727;
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_EQ(*ep, '\0');
EXPECT_TRUE(saturate);
// test saturation to min
str = "-170141183460469231731687303715884105729";
saturate = false;
val = strtoll128(str.c_str(), saturate, &ep);
b1 = *(reinterpret_cast<const uint64_t*>(&val));
b2 = *(reinterpret_cast<const uint64_t*>(&val) + 1);
valMax = ((((((((int128_t)170141183 * 1000000000) + 460469231) * 1000000000) + 731687303) * 1000000000) +
715884105) *
1000) +
727;
valMax = -valMax - 1;
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_EQ(*ep, '\0');
EXPECT_TRUE(saturate);
}
TEST(DataConvertTest, NumberIntValue)
{
datatypes::SystemCatalog::TypeAttributesStd ct;
int128_t res, valMax;
string data;
bool noRoundup = false;
bool pushWarning;
bitset<64> b1, b2, b3, b4;
// tests for signed decimal
// behaviour of number_int_value for unsigned decimal
// is similar to the signed case.
datatypes::SystemCatalog::ColDataType typecode = datatypes::SystemCatalog::DECIMAL;
// test with decimal(38,0)
ct.precision = 38;
ct.scale = 0;
// test simple values
// data = "";
data = "0";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 0);
EXPECT_FALSE(pushWarning);
data = "1234";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 1234);
EXPECT_FALSE(pushWarning);
data = "12.0";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 12);
EXPECT_FALSE(pushWarning);
data = "12.34";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 12);
EXPECT_TRUE(pushWarning);
data = "-1234";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, -1234);
EXPECT_FALSE(pushWarning);
data = "-12.34";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, -12);
EXPECT_TRUE(pushWarning);
// test max
data = "99999999999999999999999999999999999999";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
// test min
data = "-99999999999999999999999999999999999999";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
valMax = -valMax;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
// test rounding
data = "12.56";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 13);
EXPECT_TRUE(pushWarning);
data = "-12.56";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, -13);
EXPECT_TRUE(pushWarning);
// test saturation
data = "999999999999999999999999999999999999999"; // data has 39 9's
// valMax has 38 9's
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
data = "-999999999999999999999999999999999999999"; // data has 39 9's
// valMax has 38 9's
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
valMax = -valMax;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
// test scientific notation
data = "1.23e37";
valMax = ((((((((int128_t)123000000 * 1000000000) + 0) * 1000000000) + 0) * 1000000000) + 0) * 100) + 0;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
data = "1.23e38";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
// test with decimal(38,10)
ct.scale = 10;
data = "0";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 0);
EXPECT_FALSE(pushWarning);
data = "1234";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 12340000000000);
EXPECT_FALSE(pushWarning);
data = "12.0";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 120000000000);
EXPECT_FALSE(pushWarning);
data = "12.34";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 123400000000);
EXPECT_FALSE(pushWarning);
data = "-1234";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, -12340000000000);
EXPECT_FALSE(pushWarning);
data = "-12.34";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, -123400000000);
EXPECT_FALSE(pushWarning);
// test max
data = "9999999999999999999999999999.9999999999";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
// test min
data = "-9999999999999999999999999999.9999999999";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
valMax = -valMax;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
// test rounding
data = "12.11111111119";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 121111111112);
EXPECT_TRUE(pushWarning);
data = "-12.11111111119";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, -121111111112);
EXPECT_TRUE(pushWarning);
// test saturation
data = "99999999999999999999999999999"; // data has 29 9's
// valMax has 38 9's
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
data = "-99999999999999999999999999999"; // data has 29 9's
// valMax has 38 9's
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
valMax = -valMax;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
// test scientific notation
data = "1.23e9";
valMax = ((((int128_t)123000000 * 1000000000) + 0) * 100);
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
data = "1.23e28";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
// test with decimal(38,38)
ct.scale = 38;
data = "0";
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
EXPECT_EQ(res, 0);
EXPECT_FALSE(pushWarning);
data = "1.234";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
data = "0.123";
valMax = ((((((((int128_t)123000000 * 1000000000) + 0) * 1000000000) + 0) * 1000000000) + 0) * 100) + 0;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
data = "-1.234";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
valMax = -valMax;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
data = "-0.123";
valMax = ((((((((int128_t)123000000 * 1000000000) + 0) * 1000000000) + 0) * 1000000000) + 0) * 100) + 0;
valMax = -valMax;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
// test max
data = "0.99999999999999999999999999999999999999";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
// test min
data = "-0.99999999999999999999999999999999999999";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
valMax = -valMax;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
// test rounding
data = "0.199999999999999999999999999999999999999";
valMax = ((((((((int128_t)200000000 * 1000000000) + 0) * 1000000000) + 0) * 1000000000) + 0) * 100) + 0;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
data = "-0.199999999999999999999999999999999999999";
valMax = ((((((((int128_t)200000000 * 1000000000) + 0) * 1000000000) + 0) * 1000000000) + 0) * 100) + 0;
valMax = -valMax;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
// test saturation
data = "99999999999999999999999999999"; // data has 29 9's
// valMax has 38 9's
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
data = "-99999999999999999999999999999"; // data has 29 9's
// valMax has 38 9's
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
valMax = -valMax;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
// test scientific notation
data = "123e-4";
valMax = ((((((((int128_t)123000000 * 1000000000) + 0) * 1000000000) + 0) * 1000000000) + 0) * 10) + 0;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_FALSE(pushWarning);
data = "123e-2";
valMax = ((((((((int128_t)999999999 * 1000000000) + 999999999) * 1000000000) + 999999999) * 1000000000) +
999999999) *
100) +
99;
pushWarning = false;
number_int_value(data, typecode, ct, pushWarning, noRoundup, res);
b1 = *(reinterpret_cast<const uint64_t*>(&res));
b2 = *(reinterpret_cast<const uint64_t*>(&res) + 1);
b3 = *(reinterpret_cast<const uint64_t*>(&valMax));
b4 = *(reinterpret_cast<const uint64_t*>(&valMax) + 1);
EXPECT_EQ(b1, b3);
EXPECT_EQ(b2, b4);
EXPECT_TRUE(pushWarning);
}
TEST(DataConvertTest, ConvertColumnData)
{
}
View Git Blame Copy Permalink