Index: runtime/vm/intermediate_language_test.cc |
diff --git a/runtime/vm/intermediate_language_test.cc b/runtime/vm/intermediate_language_test.cc |
index 67f304efbbce2263b050fdc47a4fc109b486d9b4..61b9e0507e342459d93266a9fc31cc5245222465 100644 |
--- a/runtime/vm/intermediate_language_test.cc |
+++ b/runtime/vm/intermediate_language_test.cc |
@@ -40,634 +40,4 @@ TEST_CASE(OptimizationTests) { |
} |
-TEST_CASE(RangeTests) { |
- Range* zero = new Range( |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::FromConstant(0)); |
- Range* positive = new Range( |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::FromConstant(100)); |
- Range* negative = new Range( |
- RangeBoundary::FromConstant(-1), |
- RangeBoundary::FromConstant(-100)); |
- Range* range_x = new Range( |
- RangeBoundary::FromConstant(-15), |
- RangeBoundary::FromConstant(100)); |
- EXPECT(positive->IsPositive()); |
- EXPECT(zero->Overlaps(0, 0)); |
- EXPECT(positive->Overlaps(0, 0)); |
- EXPECT(!negative->Overlaps(0, 0)); |
- EXPECT(range_x->Overlaps(0, 0)); |
- EXPECT(range_x->IsWithin(-15, 100)); |
- EXPECT(!range_x->IsWithin(-15, 99)); |
- EXPECT(!range_x->IsWithin(-14, 100)); |
- |
-#define TEST_RANGE_OP_(Op, l_min, l_max, r_min, r_max, Clamp, res_min, res_max)\ |
- { \ |
- RangeBoundary min, max; \ |
- Range* left_range = new Range( \ |
- RangeBoundary::FromConstant(l_min), \ |
- RangeBoundary::FromConstant(l_max)); \ |
- Range* shift_range = new Range( \ |
- RangeBoundary::FromConstant(r_min), \ |
- RangeBoundary::FromConstant(r_max)); \ |
- Op(left_range, shift_range, &min, &max); \ |
- min = Clamp(min); \ |
- max = Clamp(max); \ |
- EXPECT(min.Equals(res_min)); \ |
- if (!min.Equals(res_min)) OS::Print("%s\n", min.ToCString()); \ |
- EXPECT(max.Equals(res_max)); \ |
- if (!max.Equals(res_max)) OS::Print("%s\n", max.ToCString()); \ |
- } |
- |
-#define NO_CLAMP(b) (b) |
-#define TEST_RANGE_OP(Op, l_min, l_max, r_min, r_max, result_min, result_max) \ |
- TEST_RANGE_OP_(Op, l_min, l_max, r_min, r_max, \ |
- NO_CLAMP, result_min, result_max) |
- |
-#define CLAMP_TO_SMI(b) (b.Clamp(RangeBoundary::kRangeBoundarySmi)) |
-#define TEST_RANGE_OP_SMI(Op, l_min, l_max, r_min, r_max, res_min, res_max) \ |
- TEST_RANGE_OP_(Op, l_min, l_max, r_min, r_max, \ |
- CLAMP_TO_SMI, res_min, res_max) |
- |
- TEST_RANGE_OP(Range::Shl, -15, 100, 0, 2, |
- RangeBoundary(-60), RangeBoundary(400)); |
- TEST_RANGE_OP(Range::Shl, -15, 100, -2, 2, |
- RangeBoundary(-60), RangeBoundary(400)); |
- TEST_RANGE_OP(Range::Shl, -15, -10, 1, 2, |
- RangeBoundary(-60), RangeBoundary(-20)); |
- TEST_RANGE_OP(Range::Shl, 5, 10, -2, 2, |
- RangeBoundary(5), RangeBoundary(40)); |
- TEST_RANGE_OP(Range::Shl, -15, 100, 0, 64, |
- RangeBoundary::NegativeInfinity(), |
- RangeBoundary::PositiveInfinity()); |
- TEST_RANGE_OP(Range::Shl, -1, 1, 63, 63, |
- RangeBoundary(kMinInt64), |
- RangeBoundary::PositiveInfinity()); |
- if (kBitsPerWord == 64) { |
- TEST_RANGE_OP_SMI(Range::Shl, -1, 1, 62, 62, |
- RangeBoundary(kSmiMin), |
- RangeBoundary(kSmiMax)); |
- TEST_RANGE_OP_SMI(Range::Shl, -1, 1, 30, 30, |
- RangeBoundary(-1 << 30), |
- RangeBoundary(1 << 30)); |
- } else { |
- TEST_RANGE_OP_SMI(Range::Shl, -1, 1, 30, 30, |
- RangeBoundary(kSmiMin), |
- RangeBoundary(kSmiMax)); |
- TEST_RANGE_OP_SMI(Range::Shl, -1, 1, 62, 62, |
- RangeBoundary(kSmiMin), |
- RangeBoundary(kSmiMax)); |
- } |
- TEST_RANGE_OP(Range::Shl, 0, 100, 0, 64, |
- RangeBoundary(0), RangeBoundary::PositiveInfinity()); |
- TEST_RANGE_OP(Range::Shl, -100, 0, 0, 64, |
- RangeBoundary::NegativeInfinity(), RangeBoundary(0)); |
- |
- TEST_RANGE_OP(Range::Shr, -8, 8, 1, 2, RangeBoundary(-4), RangeBoundary(4)); |
- TEST_RANGE_OP(Range::Shr, 1, 8, 1, 2, RangeBoundary(0), RangeBoundary(4)); |
- TEST_RANGE_OP(Range::Shr, -16, -8, 1, 2, |
- RangeBoundary(-8), RangeBoundary(-2)); |
- TEST_RANGE_OP(Range::Shr, 2, 4, -1, 1, RangeBoundary(1), RangeBoundary(4)); |
- TEST_RANGE_OP(Range::Shr, kMaxInt64, kMaxInt64, 0, 1, |
- RangeBoundary(kMaxInt64 >> 1), RangeBoundary(kMaxInt64)); |
- TEST_RANGE_OP(Range::Shr, kMinInt64, kMinInt64, 0, 1, |
- RangeBoundary(kMinInt64), RangeBoundary(kMinInt64 >> 1)); |
-#undef TEST_RANGE_OP |
-} |
- |
- |
-TEST_CASE(RangeTestsInfinity) { |
- // +/- inf overflowed. |
- EXPECT(RangeBoundary::NegativeInfinity().OverflowedSmi()); |
- EXPECT(RangeBoundary::PositiveInfinity().OverflowedSmi()); |
- |
- EXPECT(RangeBoundary::NegativeInfinity().OverflowedMint()); |
- EXPECT(RangeBoundary::PositiveInfinity().OverflowedMint()); |
- |
- Range* all = new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::PositiveInfinity()); |
- EXPECT(all->Overlaps(0, 0)); |
- EXPECT(all->Overlaps(-1, 1)); |
- EXPECT(!all->IsWithin(0, 100)); |
- Range* positive = new Range(RangeBoundary::FromConstant(0), |
- RangeBoundary::PositiveInfinity()); |
- EXPECT(positive->IsPositive()); |
- EXPECT(positive->Overlaps(0, 1)); |
- EXPECT(positive->Overlaps(1, 100)); |
- EXPECT(positive->Overlaps(-1, 0)); |
- EXPECT(!positive->Overlaps(-2, -1)); |
- Range* negative = new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::FromConstant(-1)); |
- EXPECT(!negative->IsPositive()); |
- EXPECT(!negative->Overlaps(0, 1)); |
- EXPECT(!negative->Overlaps(1, 100)); |
- EXPECT(negative->Overlaps(-1, 0)); |
- EXPECT(negative->Overlaps(-2, -1)); |
- Range* negpos = new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::FromConstant(0)); |
- EXPECT(!negpos->IsPositive()); |
- |
- Range* a = new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::FromConstant(1)); |
- |
- Range* b = new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::FromConstant(31)); |
- |
- Range* c = new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::FromConstant(32)); |
- |
- EXPECT(a->OnlyLessThanOrEqualTo(31)); |
- EXPECT(b->OnlyLessThanOrEqualTo(31)); |
- EXPECT(!c->OnlyLessThanOrEqualTo(31)); |
- |
- Range* unsatisfiable = new Range(RangeBoundary::PositiveInfinity(), |
- RangeBoundary::NegativeInfinity()); |
- EXPECT(unsatisfiable->IsUnsatisfiable()); |
- |
- Range* unsatisfiable_right = new Range(RangeBoundary::PositiveInfinity(), |
- RangeBoundary::FromConstant(0)); |
- EXPECT(unsatisfiable_right->IsUnsatisfiable()); |
- |
- Range* unsatisfiable_left = new Range(RangeBoundary::FromConstant(0), |
- RangeBoundary::NegativeInfinity()); |
- EXPECT(unsatisfiable_left->IsUnsatisfiable()); |
-} |
- |
- |
-TEST_CASE(RangeUtils) { |
- // [-inf, +inf]. |
- const Range& range_0 = *(new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::PositiveInfinity())); |
- // [-inf, -1]. |
- const Range& range_a = *(new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::FromConstant(-1))); |
- // [-inf, 0]. |
- const Range& range_b = *(new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::FromConstant(0))); |
- // [-inf, 1]. |
- const Range& range_c = *(new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::FromConstant(1))); |
- // [-1, +inf] |
- const Range& range_d = *(new Range(RangeBoundary::FromConstant(-1), |
- RangeBoundary::PositiveInfinity())); |
- // [0, +inf] |
- const Range& range_e = *(new Range(RangeBoundary::FromConstant(0), |
- RangeBoundary::PositiveInfinity())); |
- // [1, +inf]. |
- const Range& range_f = *(new Range(RangeBoundary::FromConstant(1), |
- RangeBoundary::PositiveInfinity())); |
- // [1, 2]. |
- const Range& range_g = *(new Range(RangeBoundary::FromConstant(1), |
- RangeBoundary::FromConstant(2))); |
- // [-1, -2]. |
- const Range& range_h = *(new Range(RangeBoundary::FromConstant(-1), |
- RangeBoundary::FromConstant(-2))); |
- // [-1, 1]. |
- const Range& range_i = *(new Range(RangeBoundary::FromConstant(-1), |
- RangeBoundary::FromConstant(1))); |
- |
- // OnlyPositiveOrZero. |
- EXPECT(!Range::OnlyPositiveOrZero(range_a, range_b)); |
- EXPECT(!Range::OnlyPositiveOrZero(range_b, range_c)); |
- EXPECT(!Range::OnlyPositiveOrZero(range_c, range_d)); |
- EXPECT(!Range::OnlyPositiveOrZero(range_d, range_e)); |
- EXPECT(Range::OnlyPositiveOrZero(range_e, range_f)); |
- EXPECT(!Range::OnlyPositiveOrZero(range_d, range_d)); |
- EXPECT(Range::OnlyPositiveOrZero(range_e, range_e)); |
- EXPECT(Range::OnlyPositiveOrZero(range_f, range_g)); |
- EXPECT(!Range::OnlyPositiveOrZero(range_g, range_h)); |
- EXPECT(!Range::OnlyPositiveOrZero(range_i, range_i)); |
- |
- // OnlyNegativeOrZero. |
- EXPECT(Range::OnlyNegativeOrZero(range_a, range_b)); |
- EXPECT(!Range::OnlyNegativeOrZero(range_b, range_c)); |
- EXPECT(Range::OnlyNegativeOrZero(range_b, range_b)); |
- EXPECT(!Range::OnlyNegativeOrZero(range_c, range_c)); |
- EXPECT(!Range::OnlyNegativeOrZero(range_c, range_d)); |
- EXPECT(!Range::OnlyNegativeOrZero(range_d, range_e)); |
- EXPECT(!Range::OnlyNegativeOrZero(range_e, range_f)); |
- EXPECT(!Range::OnlyNegativeOrZero(range_f, range_g)); |
- EXPECT(!Range::OnlyNegativeOrZero(range_g, range_h)); |
- EXPECT(Range::OnlyNegativeOrZero(range_h, range_h)); |
- EXPECT(!Range::OnlyNegativeOrZero(range_i, range_i)); |
- |
- // [-inf, +inf]. |
- EXPECT(!Range::OnlyNegativeOrZero(range_0, range_0)); |
- EXPECT(!Range::OnlyPositiveOrZero(range_0, range_0)); |
- |
- EXPECT(Range::ConstantAbsMax(&range_0) == RangeBoundary::kMax); |
- EXPECT(Range::ConstantAbsMax(&range_h) == 2); |
- EXPECT(Range::ConstantAbsMax(&range_i) == 1); |
- |
- // RangeBOundary.Equals. |
- EXPECT(RangeBoundary::FromConstant(1).Equals( |
- RangeBoundary::FromConstant(1))); |
- EXPECT(!RangeBoundary::FromConstant(2).Equals( |
- RangeBoundary::FromConstant(1))); |
- EXPECT(RangeBoundary::PositiveInfinity().Equals( |
- RangeBoundary::PositiveInfinity())); |
- EXPECT(!RangeBoundary::PositiveInfinity().Equals( |
- RangeBoundary::NegativeInfinity())); |
- EXPECT(RangeBoundary::NegativeInfinity().Equals( |
- RangeBoundary::NegativeInfinity())); |
- EXPECT(!RangeBoundary::NegativeInfinity().Equals( |
- RangeBoundary::PositiveInfinity())); |
- EXPECT(!RangeBoundary::FromConstant(1).Equals( |
- RangeBoundary::NegativeInfinity())); |
- EXPECT(!RangeBoundary::FromConstant(1).Equals( |
- RangeBoundary::NegativeInfinity())); |
- EXPECT(!RangeBoundary::FromConstant(2).Equals( |
- RangeBoundary::PositiveInfinity())); |
-} |
- |
- |
-TEST_CASE(RangeBinaryOp) { |
- Range* range_a = new Range(RangeBoundary::FromConstant(-1), |
- RangeBoundary::PositiveInfinity()); |
- range_a->Clamp(RangeBoundary::kRangeBoundaryInt64); |
- EXPECT(range_a->min().ConstantValue() == -1); |
- EXPECT(range_a->max().ConstantValue() == RangeBoundary::kMax); |
- Range* range_b = new Range(RangeBoundary::NegativeInfinity(), |
- RangeBoundary::FromConstant(1)); |
- range_b->Clamp(RangeBoundary::kRangeBoundaryInt64); |
- EXPECT(range_b->min().ConstantValue() == RangeBoundary::kMin); |
- EXPECT(range_b->max().ConstantValue() == 1); |
- Range* result = Range::BinaryOp(Token::kADD, |
- range_a, |
- range_b, |
- NULL); |
- ASSERT(result != NULL); |
- EXPECT(result->min().IsNegativeInfinity()); |
- EXPECT(result->max().IsPositiveInfinity()); |
- |
- // Test that [5, 10] + [0, 5] = [5, 15]. |
- Range* range_c = new Range(RangeBoundary::FromConstant(5), |
- RangeBoundary::FromConstant(10)); |
- Range* range_d = new Range(RangeBoundary::FromConstant(0), |
- RangeBoundary::FromConstant(5)); |
- result = Range::BinaryOp(Token::kADD, |
- range_c, |
- range_d, |
- NULL); |
- ASSERT(result != NULL); |
- EXPECT(result->min().ConstantValue() == 5); |
- EXPECT(result->max().ConstantValue() == 15); |
- |
- |
- // Test that [0xff, 0xfff] & [0xf, 0xf] = [0x0, 0xf]. |
- Range* range_e = new Range(RangeBoundary::FromConstant(0xff), |
- RangeBoundary::FromConstant(0xfff)); |
- Range* range_f = new Range(RangeBoundary::FromConstant(0xf), |
- RangeBoundary::FromConstant(0xf)); |
- result = Range::BinaryOp(Token::kBIT_AND, |
- range_e, |
- range_f, |
- NULL); |
- ASSERT(result != NULL); |
- EXPECT(result->min().ConstantValue() == 0x0); |
- EXPECT(result->max().ConstantValue() == 0xf); |
-} |
- |
- |
-TEST_CASE(RangeAdd) { |
-#define TEST_RANGE_ADD(l_min, l_max, r_min, r_max, result_min, result_max) \ |
- { \ |
- RangeBoundary min, max; \ |
- Range* left_range = new Range( \ |
- RangeBoundary::FromConstant(l_min), \ |
- RangeBoundary::FromConstant(l_max)); \ |
- Range* right_range = new Range( \ |
- RangeBoundary::FromConstant(r_min), \ |
- RangeBoundary::FromConstant(r_max)); \ |
- EXPECT(left_range->min().ConstantValue() == l_min); \ |
- EXPECT(left_range->max().ConstantValue() == l_max); \ |
- EXPECT(right_range->min().ConstantValue() == r_min); \ |
- EXPECT(right_range->max().ConstantValue() == r_max); \ |
- Range::Add(left_range, right_range, &min, &max, NULL); \ |
- EXPECT(min.Equals(result_min)); \ |
- if (!min.Equals(result_min)) { \ |
- OS::Print("%s != %s\n", min.ToCString(), result_min.ToCString()); \ |
- } \ |
- EXPECT(max.Equals(result_max)); \ |
- if (!max.Equals(result_max)) { \ |
- OS::Print("%s != %s\n", max.ToCString(), result_max.ToCString()); \ |
- } \ |
- } |
- |
- // [kMaxInt32, kMaxInt32 + 15] + [10, 20] = [kMaxInt32 + 10, kMaxInt32 + 35]. |
- TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt32), |
- static_cast<int64_t>(kMaxInt32) + 15, |
- static_cast<int64_t>(10), |
- static_cast<int64_t>(20), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32) + 10), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32) + 35)); |
- |
- // [kMaxInt32 - 15, kMaxInt32 + 15] + [15, -15] = [kMaxInt32, kMaxInt32]. |
- TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt32) - 15, |
- static_cast<int64_t>(kMaxInt32) + 15, |
- static_cast<int64_t>(15), |
- static_cast<int64_t>(-15), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32)), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32))); |
- |
- // [kMaxInt32, kMaxInt32 + 15] + [10, kMaxInt64] = [kMaxInt32 + 10, +inf]. |
- TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt32), |
- static_cast<int64_t>(kMaxInt32) + 15, |
- static_cast<int64_t>(10), |
- static_cast<int64_t>(kMaxInt64), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32) + 10), |
- RangeBoundary::PositiveInfinity()); |
- |
- // [kMinInt64, kMaxInt32 + 15] + [10, 20] = [kMinInt64 + 10, kMaxInt32 + 35]. |
- TEST_RANGE_ADD(static_cast<int64_t>(kMinInt64), |
- static_cast<int64_t>(kMaxInt32) + 15, |
- static_cast<int64_t>(10), |
- static_cast<int64_t>(20), |
- RangeBoundary(static_cast<int64_t>(kMinInt64) + 10), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32) + 35)); |
- |
- // [0, 0] + [kMinInt64, kMaxInt64] = [kMinInt64, kMaxInt64]. |
- TEST_RANGE_ADD(static_cast<int64_t>(0), |
- static_cast<int64_t>(0), |
- static_cast<int64_t>(kMinInt64), |
- static_cast<int64_t>(kMaxInt64), |
- RangeBoundary(kMinInt64), |
- RangeBoundary(kMaxInt64)); |
- |
- // Overflows. |
- |
- // [-1, 1] + [kMinInt64, kMaxInt64] = [-inf, +inf]. |
- TEST_RANGE_ADD(static_cast<int64_t>(-1), |
- static_cast<int64_t>(1), |
- static_cast<int64_t>(kMinInt64), |
- static_cast<int64_t>(kMaxInt64), |
- RangeBoundary::NegativeInfinity(), |
- RangeBoundary::PositiveInfinity()); |
- |
- // [kMaxInt64, kMaxInt64] + [kMaxInt64, kMaxInt64] = [-inf, +inf]. |
- TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt64), |
- static_cast<int64_t>(kMaxInt64), |
- static_cast<int64_t>(kMaxInt64), |
- static_cast<int64_t>(kMaxInt64), |
- RangeBoundary::NegativeInfinity(), |
- RangeBoundary::PositiveInfinity()); |
- |
- // [kMaxInt64, kMaxInt64] + [1, 1] = [-inf, +inf]. |
- TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt64), |
- static_cast<int64_t>(kMaxInt64), |
- static_cast<int64_t>(1), |
- static_cast<int64_t>(1), |
- RangeBoundary::NegativeInfinity(), |
- RangeBoundary::PositiveInfinity()); |
- |
-#undef TEST_RANGE_ADD |
-} |
- |
- |
-TEST_CASE(RangeSub) { |
-#define TEST_RANGE_SUB(l_min, l_max, r_min, r_max, result_min, result_max) \ |
- { \ |
- RangeBoundary min, max; \ |
- Range* left_range = new Range( \ |
- RangeBoundary::FromConstant(l_min), \ |
- RangeBoundary::FromConstant(l_max)); \ |
- Range* right_range = new Range( \ |
- RangeBoundary::FromConstant(r_min), \ |
- RangeBoundary::FromConstant(r_max)); \ |
- EXPECT(left_range->min().ConstantValue() == l_min); \ |
- EXPECT(left_range->max().ConstantValue() == l_max); \ |
- EXPECT(right_range->min().ConstantValue() == r_min); \ |
- EXPECT(right_range->max().ConstantValue() == r_max); \ |
- Range::Sub(left_range, right_range, &min, &max, NULL); \ |
- EXPECT(min.Equals(result_min)); \ |
- if (!min.Equals(result_min)) { \ |
- OS::Print("%s != %s\n", min.ToCString(), result_min.ToCString()); \ |
- } \ |
- EXPECT(max.Equals(result_max)); \ |
- if (!max.Equals(result_max)) { \ |
- OS::Print("%s != %s\n", max.ToCString(), result_max.ToCString()); \ |
- } \ |
- } |
- |
- // [kMaxInt32, kMaxInt32 + 15] - [10, 20] = [kMaxInt32 - 20, kMaxInt32 + 5]. |
- TEST_RANGE_SUB(static_cast<int64_t>(kMaxInt32), |
- static_cast<int64_t>(kMaxInt32) + 15, |
- static_cast<int64_t>(10), |
- static_cast<int64_t>(20), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32) - 20), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32) + 5)); |
- |
- // [kMintInt64, kMintInt64] - [1, 1] = [-inf, +inf]. |
- TEST_RANGE_SUB(static_cast<int64_t>(kMinInt64), |
- static_cast<int64_t>(kMinInt64), |
- static_cast<int64_t>(1), |
- static_cast<int64_t>(1), |
- RangeBoundary::NegativeInfinity(), |
- RangeBoundary::PositiveInfinity()); |
- |
- // [1, 1] - [kMintInt64, kMintInt64] = [-inf, +inf]. |
- TEST_RANGE_SUB(static_cast<int64_t>(1), |
- static_cast<int64_t>(1), |
- static_cast<int64_t>(kMinInt64), |
- static_cast<int64_t>(kMinInt64), |
- RangeBoundary::NegativeInfinity(), |
- RangeBoundary::PositiveInfinity()); |
- |
- // [kMaxInt32 + 10, kMaxInt32 + 20] - [-20, -20] = |
- // [kMaxInt32 + 30, kMaxInt32 + 40]. |
- TEST_RANGE_SUB(static_cast<int64_t>(kMaxInt32) + 10, |
- static_cast<int64_t>(kMaxInt32) + 20, |
- static_cast<int64_t>(-20), |
- static_cast<int64_t>(-20), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32) + 30), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32) + 40)); |
- |
- |
-#undef TEST_RANGE_SUB |
-} |
- |
- |
-TEST_CASE(RangeAnd) { |
-#define TEST_RANGE_AND(l_min, l_max, r_min, r_max, result_min, result_max) \ |
- { \ |
- RangeBoundary min, max; \ |
- Range* left_range = new Range( \ |
- RangeBoundary::FromConstant(l_min), \ |
- RangeBoundary::FromConstant(l_max)); \ |
- Range* right_range = new Range( \ |
- RangeBoundary::FromConstant(r_min), \ |
- RangeBoundary::FromConstant(r_max)); \ |
- EXPECT(left_range->min().ConstantValue() == l_min); \ |
- EXPECT(left_range->max().ConstantValue() == l_max); \ |
- EXPECT(right_range->min().ConstantValue() == r_min); \ |
- EXPECT(right_range->max().ConstantValue() == r_max); \ |
- Range::And(left_range, right_range, &min, &max); \ |
- EXPECT(min.Equals(result_min)); \ |
- if (!min.Equals(result_min)) { \ |
- OS::Print("%s != %s\n", min.ToCString(), result_min.ToCString()); \ |
- } \ |
- EXPECT(max.Equals(result_max)); \ |
- if (!max.Equals(result_max)) { \ |
- OS::Print("%s != %s\n", max.ToCString(), result_max.ToCString()); \ |
- } \ |
- } |
- |
- // [0xff, 0xfff] & [0xf, 0xf] = [0x0, 0xf]. |
- TEST_RANGE_AND(static_cast<int64_t>(0xff), |
- static_cast<int64_t>(0xfff), |
- static_cast<int64_t>(0xf), |
- static_cast<int64_t>(0xf), |
- RangeBoundary(0), |
- RangeBoundary(0xf)); |
- |
- // [0xffffffff, 0xffffffff] & [0xfffffffff, 0xfffffffff] = [0x0, 0xfffffffff]. |
- TEST_RANGE_AND(static_cast<int64_t>(0xffffffff), |
- static_cast<int64_t>(0xffffffff), |
- static_cast<int64_t>(0xfffffffff), |
- static_cast<int64_t>(0xfffffffff), |
- RangeBoundary(0), |
- RangeBoundary(static_cast<int64_t>(0xfffffffff))); |
- |
- // [0xffffffff, 0xffffffff] & [-20, 20] = [0x0, 0xffffffff]. |
- TEST_RANGE_AND(static_cast<int64_t>(0xffffffff), |
- static_cast<int64_t>(0xffffffff), |
- static_cast<int64_t>(-20), |
- static_cast<int64_t>(20), |
- RangeBoundary(0), |
- RangeBoundary(static_cast<int64_t>(0xffffffff))); |
- |
- // [-20, 20] & [0xffffffff, 0xffffffff] = [0x0, 0xffffffff]. |
- TEST_RANGE_AND(static_cast<int64_t>(-20), |
- static_cast<int64_t>(20), |
- static_cast<int64_t>(0xffffffff), |
- static_cast<int64_t>(0xffffffff), |
- RangeBoundary(0), |
- RangeBoundary(static_cast<int64_t>(0xffffffff))); |
- |
- // Test that [-20, 20] & [-20, 20] = [Unknown, Unknown]. |
- TEST_RANGE_AND(static_cast<int64_t>(-20), |
- static_cast<int64_t>(20), |
- static_cast<int64_t>(-20), |
- static_cast<int64_t>(20), |
- RangeBoundary(), |
- RangeBoundary()); |
- |
-#undef TEST_RANGE_AND |
-} |
- |
- |
-TEST_CASE(RangeMinMax) { |
- // Constants. |
- // MIN(0, 1) == 0 |
- EXPECT(RangeBoundary::Min( |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::FromConstant(1), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 0); |
- // MIN(0, -1) == -1 |
- EXPECT(RangeBoundary::Min( |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::FromConstant(-1), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == -1); |
- |
- // MIN(1, 0) == 0 |
- EXPECT(RangeBoundary::Min( |
- RangeBoundary::FromConstant(1), |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 0); |
- // MIN(-1, 0) == -1 |
- EXPECT(RangeBoundary::Min( |
- RangeBoundary::FromConstant(-1), |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == -1); |
- |
- // MAX(0, 1) == 1 |
- EXPECT(RangeBoundary::Max( |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::FromConstant(1), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 1); |
- |
- // MAX(0, -1) == 0 |
- EXPECT(RangeBoundary::Max( |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::FromConstant(-1), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 0); |
- |
- // MAX(1, 0) == 1 |
- EXPECT(RangeBoundary::Max( |
- RangeBoundary::FromConstant(1), |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 1); |
- // MAX(-1, 0) == 0 |
- EXPECT(RangeBoundary::Max( |
- RangeBoundary::FromConstant(-1), |
- RangeBoundary::FromConstant(0), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 0); |
- |
- RangeBoundary n_infinity = RangeBoundary::NegativeInfinity(); |
- RangeBoundary p_infinity = RangeBoundary::PositiveInfinity(); |
- |
- // Constants vs. infinity. |
- EXPECT(RangeBoundary::Max( |
- n_infinity, |
- RangeBoundary::FromConstant(-1), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == -1); |
- |
- EXPECT(RangeBoundary::Max( |
- RangeBoundary::FromConstant(-1), |
- n_infinity, |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == -1); |
- |
- EXPECT(RangeBoundary::Max( |
- RangeBoundary::FromConstant(1), |
- n_infinity, |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 1); |
- |
- EXPECT(RangeBoundary::Max( |
- n_infinity, |
- RangeBoundary::FromConstant(1), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 1); |
- |
- EXPECT(RangeBoundary::Min( |
- p_infinity, |
- RangeBoundary::FromConstant(-1), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == -1); |
- |
- EXPECT(RangeBoundary::Min( |
- RangeBoundary::FromConstant(-1), |
- p_infinity, |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == -1); |
- |
- EXPECT(RangeBoundary::Min( |
- RangeBoundary::FromConstant(1), |
- p_infinity, |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 1); |
- |
- EXPECT(RangeBoundary::Min( |
- p_infinity, |
- RangeBoundary::FromConstant(1), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == 1); |
- |
- // 64-bit values. |
- EXPECT(RangeBoundary::Min( |
- RangeBoundary(static_cast<int64_t>(kMinInt64)), |
- RangeBoundary(static_cast<int64_t>(kMinInt32)), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == kMinInt64); |
- |
- EXPECT(RangeBoundary::Max( |
- RangeBoundary(static_cast<int64_t>(kMinInt64)), |
- RangeBoundary(static_cast<int64_t>(kMinInt32)), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == kMinInt32); |
- |
- EXPECT(RangeBoundary::Min( |
- RangeBoundary(static_cast<int64_t>(kMaxInt64)), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32)), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == kMaxInt32); |
- |
- EXPECT(RangeBoundary::Max( |
- RangeBoundary(static_cast<int64_t>(kMaxInt64)), |
- RangeBoundary(static_cast<int64_t>(kMaxInt32)), |
- RangeBoundary::kRangeBoundaryInt64).ConstantValue() == kMaxInt64); |
-} |
- |
} // namespace dart |