summaryrefslogtreecommitdiff
path: root/src/mongo/util/safe_num_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/mongo/util/safe_num_test.cpp')
-rw-r--r--src/mongo/util/safe_num_test.cpp122
1 files changed, 61 insertions, 61 deletions
diff --git a/src/mongo/util/safe_num_test.cpp b/src/mongo/util/safe_num_test.cpp
index 7d679bdb3d1..cf70af01670 100644
--- a/src/mongo/util/safe_num_test.cpp
+++ b/src/mongo/util/safe_num_test.cpp
@@ -45,7 +45,7 @@ TEST(Basics, Initialization) {
const SafeNum numInt(0);
ASSERT_EQUALS(numInt.type(), mongo::NumberInt);
- const SafeNum numLong(0LL);
+ const SafeNum numLong(static_cast<int64_t>(0));
ASSERT_EQUALS(numLong.type(), mongo::NumberLong);
const SafeNum numDouble(0.0);
@@ -97,7 +97,7 @@ TEST(Comparison, EOO) {
TEST(Comparison, StrictTypeComparison) {
const SafeNum one(1);
- const SafeNum oneLong(1LL);
+ const SafeNum oneLong((static_cast<int64_t>(1)));
const SafeNum oneDouble(1.0);
ASSERT_FALSE(one.isIdentical(oneLong));
ASSERT_FALSE(oneLong.isIdentical(oneDouble));
@@ -113,7 +113,7 @@ TEST(Comparison, StrictTypeComparison) {
TEST(Comparison, EquivalenceComparisonNormal) {
const SafeNum one(1);
- const SafeNum oneLong(1LL);
+ const SafeNum oneLong(static_cast<int64_t>(1));
const SafeNum oneDouble(1.0);
ASSERT_EQUALS(one, oneLong);
ASSERT_EQUALS(oneLong, oneDouble);
@@ -148,7 +148,7 @@ TEST(Addition, Zero) {
TEST(Addition, UpConvertion) {
const SafeNum zeroInt32(0);
- const SafeNum zeroInt64(0LL);
+ const SafeNum zeroInt64(static_cast<int64_t>(0));
const SafeNum zeroDouble(0.0);
ASSERT_EQUALS((zeroInt32 + zeroInt64).type(), mongo::NumberLong);
ASSERT_EQUALS((zeroInt64 + zeroInt32).type(), mongo::NumberLong);
@@ -178,7 +178,7 @@ TEST(Addition, UpConvertion) {
}
TEST(Addition, Overflow32to64) {
- const SafeNum maxInt32(std::numeric_limits<int>::max());
+ const SafeNum maxInt32(std::numeric_limits<int32_t>::max());
ASSERT_EQUALS(maxInt32.type(), mongo::NumberInt);
const SafeNum int32PlusOne(maxInt32 + 1);
@@ -187,12 +187,12 @@ TEST(Addition, Overflow32to64) {
const SafeNum int32MinusOne(maxInt32 + -1);
ASSERT_EQUALS(int32MinusOne.type(), mongo::NumberInt);
- const SafeNum longResult(std::numeric_limits<int>::max() + static_cast<long long>(1));
+ const SafeNum longResult(std::numeric_limits<int32_t>::max() + static_cast<int64_t>(1));
ASSERT_EQUALS(int32PlusOne, longResult);
}
TEST(Addition, Overflow64toDouble) {
- const SafeNum maxInt64(std::numeric_limits<long long>::max());
+ const SafeNum maxInt64(std::numeric_limits<int64_t>::max());
ASSERT_EQUALS(maxInt64.type(), mongo::NumberLong);
// We don't overflow int64 to double.
@@ -202,7 +202,7 @@ TEST(Addition, Overflow64toDouble) {
const SafeNum int64MinusOne(maxInt64 + -1);
ASSERT_EQUALS(int64MinusOne.type(), mongo::NumberLong);
- const SafeNum doubleResult(std::numeric_limits<long long>::max() + static_cast<double>(1));
+ const SafeNum doubleResult(std::numeric_limits<int64_t>::max() + static_cast<double>(1));
ASSERT_EQUALS(doubleResult.type(), mongo::NumberDouble);
ASSERT_NOT_EQUALS(int64PlusOne, doubleResult);
}
@@ -220,7 +220,7 @@ TEST(Addition, OverflowDouble) {
}
TEST(Addition, Negative32to64) {
- const SafeNum minInt32(std::numeric_limits<int>::min());
+ const SafeNum minInt32(std::numeric_limits<int32_t>::min());
ASSERT_EQUALS(minInt32.type(), mongo::NumberInt);
const SafeNum int32MinusOne(minInt32 + -1);
@@ -229,12 +229,12 @@ TEST(Addition, Negative32to64) {
const SafeNum int32PlusOne(minInt32 + 1);
ASSERT_EQUALS(int32PlusOne.type(), mongo::NumberInt);
- const SafeNum longResult(std::numeric_limits<int>::min() - static_cast<long long>(1));
+ const SafeNum longResult(std::numeric_limits<int32_t>::min() - static_cast<int64_t>(1));
ASSERT_EQUALS(int32MinusOne, longResult);
}
TEST(Addition, Negative64toDouble) {
- const SafeNum minInt64(std::numeric_limits<long long>::min());
+ const SafeNum minInt64(std::numeric_limits<int64_t>::min());
ASSERT_EQUALS(minInt64.type(), mongo::NumberLong);
// We don't overflow int64 to double.
@@ -244,14 +244,14 @@ TEST(Addition, Negative64toDouble) {
const SafeNum int64PlusOne(minInt64 + 1);
ASSERT_EQUALS(int64PlusOne.type(), mongo::NumberLong);
- const SafeNum doubleResult(std::numeric_limits<long long>::min() - static_cast<double>(1));
+ const SafeNum doubleResult(std::numeric_limits<int64_t>::min() - static_cast<double>(1));
ASSERT_EQUALS(doubleResult.type(), mongo::NumberDouble);
ASSERT_NOT_EQUALS(int64MinusOne, doubleResult);
}
TEST(BitAnd, FloatingPointIsIgnored) {
- const SafeNum val_int(static_cast<int>(1));
- const SafeNum val_ll(static_cast<long long>(1));
+ const SafeNum val_int(static_cast<int32_t>(1));
+ const SafeNum val_ll(static_cast<int64_t>(1));
const SafeNum val_double(1.0);
ASSERT_FALSE((val_int & val_double).isValid());
ASSERT_FALSE((val_double & val_int).isValid());
@@ -271,9 +271,9 @@ TEST(BitAnd, FloatingPointIsIgnored) {
}
TEST(BitAnd, 32and32) {
- const SafeNum val1(static_cast<int>(0xE0F1U));
- const SafeNum val2(static_cast<int>(0xDF01U));
- const SafeNum expected(static_cast<int>(0xC001U));
+ const SafeNum val1(static_cast<int32_t>(0xE0F1));
+ const SafeNum val2(static_cast<int32_t>(0xDF01));
+ const SafeNum expected(static_cast<int32_t>(0xC001));
const SafeNum result = val1 & val2;
ASSERT_EQUALS(mongo::NumberInt, result.type());
@@ -281,18 +281,18 @@ TEST(BitAnd, 32and32) {
}
TEST(BitAnd, 64and64) {
- const SafeNum val1(static_cast<long long>(0xE0F1E0F1E0F1ULL));
- const SafeNum val2(static_cast<long long>(0xDF01DF01DF01ULL));
- const SafeNum expected(static_cast<long long>(0xC001C001C001ULL));
+ const SafeNum val1(static_cast<int64_t>(0xE0F1E0F1E0F1));
+ const SafeNum val2(static_cast<int64_t>(0xDF01DF01DF01));
+ const SafeNum expected(static_cast<int64_t>(0xC001C001C001));
const SafeNum result = val1 & val2;
ASSERT_EQUALS(mongo::NumberLong, result.type());
ASSERT_TRUE(expected.isIdentical(result));
}
TEST(BitAnd, MixedSize) {
- const SafeNum val_small(static_cast<int>(0xE0F1U));
- const SafeNum val_big(static_cast<long long>(0xDF01U));
- const SafeNum expected(static_cast<long long>(0xC001U));
+ const SafeNum val_small(static_cast<int32_t>(0xE0F1));
+ const SafeNum val_big(static_cast<int64_t>(0xDF01));
+ const SafeNum expected(static_cast<int64_t>(0xC001));
const SafeNum result_s_b = val_small & val_big;
const SafeNum result_b_s = val_big & val_small;
@@ -304,8 +304,8 @@ TEST(BitAnd, MixedSize) {
}
TEST(BitOr, FloatingPointIsIgnored) {
- const SafeNum val_int(static_cast<int>(1));
- const SafeNum val_ll(static_cast<long long>(1));
+ const SafeNum val_int(static_cast<int32_t>(1));
+ const SafeNum val_ll(static_cast<int64_t>(1));
const SafeNum val_double(1.0);
ASSERT_FALSE((val_int | val_double).isValid());
ASSERT_FALSE((val_double | val_int).isValid());
@@ -325,27 +325,27 @@ TEST(BitOr, FloatingPointIsIgnored) {
}
TEST(BitOr, 32and32) {
- const SafeNum val1(static_cast<int>(0xE0F1U));
- const SafeNum val2(static_cast<int>(0xDF01U));
+ const SafeNum val1(static_cast<int32_t>(0xE0F1));
+ const SafeNum val2(static_cast<int32_t>(0xDF01));
const SafeNum result = val1 | val2;
- const SafeNum expected(static_cast<int>(0xFFF1U));
+ const SafeNum expected(static_cast<int32_t>(0xFFF1));
ASSERT_EQUALS(mongo::NumberInt, result.type());
ASSERT_TRUE(expected.isIdentical(result));
}
TEST(BitOr, 64and64) {
- const SafeNum val1(static_cast<long long>(0xE0F1E0F1E0F1ULL));
- const SafeNum val2(static_cast<long long>(0xDF01DF01DF01ULL));
+ const SafeNum val1(static_cast<int64_t>(0xE0F1E0F1E0F1));
+ const SafeNum val2(static_cast<int64_t>(0xDF01DF01DF01));
const SafeNum result = val1 | val2;
- const SafeNum expected(static_cast<long long>(0xFFF1FFF1FFF1ULL));
+ const SafeNum expected(static_cast<int64_t>(0xFFF1FFF1FFF1));
ASSERT_EQUALS(mongo::NumberLong, result.type());
ASSERT_TRUE(expected.isIdentical(result));
}
TEST(BitOr, MixedSize) {
- const SafeNum val_small(static_cast<int>(0xE0F1U));
- const SafeNum val_big(static_cast<long long>(0xDF01U));
- const SafeNum expected(static_cast<long long>(0xFFF1U));
+ const SafeNum val_small(static_cast<int32_t>(0xE0F1));
+ const SafeNum val_big(static_cast<int64_t>(0xDF01));
+ const SafeNum expected(static_cast<int64_t>(0xFFF1));
const SafeNum result_s_b = val_small | val_big;
const SafeNum result_b_s = val_big | val_small;
@@ -357,8 +357,8 @@ TEST(BitOr, MixedSize) {
}
TEST(BitXor, FloatingPointIsIgnored) {
- const SafeNum val_int(static_cast<int>(1));
- const SafeNum val_ll(static_cast<long long>(1));
+ const SafeNum val_int(static_cast<int32_t>(1));
+ const SafeNum val_ll(static_cast<int64_t>(1));
const SafeNum val_double(1.0);
ASSERT_FALSE((val_int ^ val_double).isValid());
ASSERT_FALSE((val_double ^ val_int).isValid());
@@ -378,27 +378,27 @@ TEST(BitXor, FloatingPointIsIgnored) {
}
TEST(BitXor, 32and32) {
- const SafeNum val1(static_cast<int>(0xE0F1U));
- const SafeNum val2(static_cast<int>(0xDF01U));
+ const SafeNum val1(static_cast<int32_t>(0xE0F1));
+ const SafeNum val2(static_cast<int32_t>(0xDF01));
const SafeNum result = val1 ^ val2;
- const SafeNum expected(static_cast<int>(0x3FF0U));
+ const SafeNum expected(static_cast<int32_t>(0x3FF0));
ASSERT_EQUALS(mongo::NumberInt, result.type());
ASSERT_TRUE(expected.isIdentical(result));
}
TEST(BitXor, 64and64) {
- const SafeNum val1(static_cast<long long>(0xE0F1E0F1E0F1ULL));
- const SafeNum val2(static_cast<long long>(0xDF01DF01DF01ULL));
+ const SafeNum val1(static_cast<int64_t>(0xE0F1E0F1E0F1));
+ const SafeNum val2(static_cast<int64_t>(0xDF01DF01DF01));
const SafeNum result = val1 ^ val2;
- const SafeNum expected(static_cast<long long>(0x3FF03FF03FF0ULL));
+ const SafeNum expected(static_cast<int64_t>(0x3FF03FF03FF0));
ASSERT_EQUALS(mongo::NumberLong, result.type());
ASSERT_TRUE(expected.isIdentical(result));
}
TEST(BitXor, MixedSize) {
- const SafeNum val_small(static_cast<int>(0xE0F1U));
- const SafeNum val_big(static_cast<long long>(0xDF01U));
- const SafeNum expected(static_cast<long long>(0x3FF0U));
+ const SafeNum val_small(static_cast<int32_t>(0xE0F1));
+ const SafeNum val_big(static_cast<int64_t>(0xDF01));
+ const SafeNum expected(static_cast<int64_t>(0x3FF0));
const SafeNum result_s_b = val_small ^ val_big;
const SafeNum result_b_s = val_big ^ val_small;
@@ -416,8 +416,8 @@ TEST(Multiplication, Zero) {
}
TEST(Multiplication, LongZero) {
- const SafeNum zero(0LL);
- ASSERT_EQUALS(zero * 0LL, zero);
+ const SafeNum zero(static_cast<int64_t>(0));
+ ASSERT_EQUALS(zero * static_cast<int64_t>(0), zero);
ASSERT_EQUALS(zero * zero, zero);
}
@@ -434,8 +434,8 @@ TEST(Multiplication, One) {
}
TEST(Multiplication, LongOne) {
- const SafeNum plusOne(1LL);
- ASSERT_EQUALS(plusOne * 1LL, plusOne);
+ const SafeNum plusOne(static_cast<int64_t>(1));
+ ASSERT_EQUALS(plusOne * static_cast<int64_t>(1), plusOne);
ASSERT_EQUALS(plusOne * plusOne, plusOne);
}
@@ -447,7 +447,7 @@ TEST(Multiplication, DoubleOne) {
TEST(Multiplication, UpConvertion) {
const SafeNum zeroInt32(0);
- const SafeNum zeroInt64(0LL);
+ const SafeNum zeroInt64(static_cast<int64_t>(0));
const SafeNum zeroDouble(0.0);
ASSERT_EQUALS((zeroInt32 * zeroInt64).type(), mongo::NumberLong);
ASSERT_EQUALS((zeroInt64 * zeroInt32).type(), mongo::NumberLong);
@@ -477,7 +477,7 @@ TEST(Multiplication, UpConvertion) {
}
TEST(Multiplication, Overflow32to64) {
- const SafeNum maxInt32(std::numeric_limits<int>::max());
+ const SafeNum maxInt32(std::numeric_limits<int32_t>::max());
ASSERT_EQUALS(maxInt32.type(), mongo::NumberInt);
const SafeNum int32TimesOne(maxInt32 * 1);
@@ -488,14 +488,14 @@ TEST(Multiplication, Overflow32to64) {
}
TEST(Multiplication, Overflow64toDouble) {
- const SafeNum maxInt64(std::numeric_limits<long long>::max());
+ const SafeNum maxInt64(std::numeric_limits<int64_t>::max());
ASSERT_EQUALS(maxInt64.type(), mongo::NumberLong);
// We don't overflow int64 to double.
const SafeNum int64TimesTwo(maxInt64 * 2);
ASSERT_EQUALS(int64TimesTwo.type(), mongo::EOO);
- const SafeNum doubleResult(std::numeric_limits<long long>::max() * static_cast<double>(2));
+ const SafeNum doubleResult(std::numeric_limits<int64_t>::max() * static_cast<double>(2));
ASSERT_EQUALS(doubleResult.type(), mongo::NumberDouble);
ASSERT_NOT_EQUALS(int64TimesTwo, doubleResult);
}
@@ -512,7 +512,7 @@ TEST(Multiplication, OverflowDouble) {
}
TEST(Multiplication, Negative32to64) {
- const SafeNum minInt32(std::numeric_limits<int>::min());
+ const SafeNum minInt32(std::numeric_limits<int32_t>::min());
ASSERT_EQUALS(minInt32.type(), mongo::NumberInt);
const SafeNum int32TimesOne(minInt32 * 1);
@@ -523,7 +523,7 @@ TEST(Multiplication, Negative32to64) {
}
TEST(Multiplication, Negative64toDouble) {
- const SafeNum minInt64(std::numeric_limits<long long>::min());
+ const SafeNum minInt64(std::numeric_limits<int64_t>::min());
ASSERT_EQUALS(minInt64.type(), mongo::NumberLong);
// We don't overflow int64 to double.
@@ -533,14 +533,14 @@ TEST(Multiplication, Negative64toDouble) {
const SafeNum int64TimesOne(minInt64 * 1);
ASSERT_EQUALS(int64TimesOne.type(), mongo::NumberLong);
- const SafeNum doubleResult(std::numeric_limits<long long>::min() * static_cast<double>(2));
+ const SafeNum doubleResult(std::numeric_limits<int64_t>::min() * static_cast<double>(2));
ASSERT_EQUALS(doubleResult.type(), mongo::NumberDouble);
ASSERT_NOT_EQUALS(int64TimesTwo, doubleResult);
}
TEST(Multiplication, 64OverflowsFourWays) {
- const SafeNum maxInt64(std::numeric_limits<long long>::max());
- const SafeNum minInt64(std::numeric_limits<long long>::min());
+ const SafeNum maxInt64(std::numeric_limits<int64_t>::max());
+ const SafeNum minInt64(std::numeric_limits<int64_t>::min());
ASSERT_EQUALS(mongo::EOO, (maxInt64 * maxInt64).type());
ASSERT_EQUALS(mongo::EOO, (maxInt64 * minInt64).type());
ASSERT_EQUALS(mongo::EOO, (minInt64 * maxInt64).type());
@@ -548,9 +548,9 @@ TEST(Multiplication, 64OverflowsFourWays) {
}
TEST(Multiplication, BoundsWithNegativeOne) {
- const SafeNum maxInt64(std::numeric_limits<long long>::max());
- const SafeNum minInt64(std::numeric_limits<long long>::min());
- const SafeNum minusOneInt64(-1LL);
+ const SafeNum maxInt64(std::numeric_limits<int64_t>::max());
+ const SafeNum minInt64(std::numeric_limits<int64_t>::min());
+ const SafeNum minusOneInt64(static_cast<int64_t>(-1));
ASSERT_NOT_EQUALS(mongo::EOO, (maxInt64 * minusOneInt64).type());
ASSERT_NOT_EQUALS(mongo::EOO, (minusOneInt64 * maxInt64).type());
ASSERT_EQUALS(mongo::EOO, (minInt64 * minusOneInt64).type());
View Lorry Controller Status