Option to truncate integers to 64 bits, part 2

runtime/vm/bigint_test.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/assert.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 TEST_CASE(BigintSmi) {
+  if (Bigint::IsDisabled()) {
+    return;
+  }
+
   {
     const Smi& smi = Smi::Handle(Smi::New(5));
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(smi.Value()));
     EXPECT_EQ(5, bigint.AsInt64Value());
     EXPECT(bigint.FitsIntoSmi());
     Smi& smi_back = Smi::Handle();
     smi_back ^= bigint.AsValidInteger();
     EXPECT_EQ(5, smi_back.Value());
   }
 
@@ skipping 35 matching lines @@
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(smi.Value()));
     EXPECT_EQ(0x10000000, bigint.AsInt64Value());
     EXPECT(bigint.FitsIntoSmi());
     Smi& smi_back = Smi::Handle();
     smi_back ^= bigint.AsValidInteger();
     EXPECT(0x10000000 == smi_back.Value());
   }
 }
 
 TEST_CASE(BigintInt64) {
+  if (Bigint::IsDisabled()) {
+    return;
+  }
+
   const int64_t kValue = 100000000;
   const int64_t kValue64 = kValue * kValue;
   Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(kValue));
   EXPECT_EQ(kValue, bigint.AsInt64Value());
   bigint = Bigint::NewFromInt64(kValue64);
   EXPECT_EQ(kValue64, bigint.AsInt64Value());
   bigint = Bigint::NewFromInt64(-kValue64);
   EXPECT_EQ(-kValue64, bigint.AsInt64Value());
   bigint = Bigint::NewFromInt64(kMinInt64);
   EXPECT(bigint.FitsIntoInt64());
   EXPECT_EQ(kMinInt64, bigint.AsInt64Value());
 }
 
 TEST_CASE(BigintUint64) {
+  if (Bigint::IsDisabled()) {
+    return;
+  }
+
   const Bigint& one = Bigint::Handle(Bigint::NewFromUint64(1));
   EXPECT(one.FitsIntoInt64());
   EXPECT(one.FitsIntoUint64());
 
   const Bigint& big = Bigint::Handle(Bigint::NewFromUint64(kMaxUint64));
   EXPECT(!big.FitsIntoInt64());
   EXPECT(big.FitsIntoUint64());
 
   uint64_t back = big.AsUint64Value();
   EXPECT_EQ(kMaxUint64, back);
 }
 
 TEST_CASE(BigintDouble) {
+  if (Bigint::IsDisabled()) {
+    return;
+  }
+
   Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(5));
   EXPECT_EQ(5.0, bigint.AsDoubleValue());
 
   bigint = Bigint::NewFromInt64(0);
   EXPECT_EQ(0.0, bigint.AsDoubleValue());
 
   bigint = Bigint::NewFromInt64(-12345678);
   EXPECT_EQ(-1.2345678e+7, bigint.AsDoubleValue());
 
   bigint = Bigint::NewFromCString("1");
@@ skipping 112 matching lines @@
   bigint =
       Bigint::NewFromCString("1844674407370955161600000000000000000000000");
   EXPECT_EQ(1.844674407370955e+42, bigint.AsDoubleValue());
 
   bigint =
       Bigint::NewFromCString("1844674407370955161600000000000000000000001");
   EXPECT_EQ(1.8446744073709553e+42, bigint.AsDoubleValue());
 }
 
 TEST_CASE(BigintHexStrings) {
+  if (Bigint::IsDisabled()) {
+    return;
+  }
+
   Zone* zone = Thread::Current()->zone();
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x0"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(0, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x1"));
     EXPECT(bigint.FitsIntoSmi());
@@ skipping 160 matching lines @@
   {
     const char* test = "-12345678901234567890";
     const char* out = "-0xAB54A98CEB1F0AD2";
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(test));
     const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ(out, str);
   }
 }
 
 TEST_CASE(BigintDecStrings) {
+  if (Bigint::IsDisabled()) {
+    return;
+  }
+
   Zone* zone = Thread::Current()->zone();
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x0"));
     const char* str = bigint.ToDecCString(zone);
     EXPECT_STREQ("0", str);
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x123"));
     const char* str = bigint.ToDecCString(zone);
@@ skipping 104 matching lines @@
     EXPECT(computed_compare < 0);
     EXPECT(inverted_compare > 0);
   } else {
     ASSERT(compare > 0);
     EXPECT(computed_compare > 0);
     EXPECT(inverted_compare < 0);
   }
 }
 
 TEST_CASE(BigintCompare) {
+  if (Bigint::IsDisabled()) {
+    return;
+  }
+
   TestBigintCompare("0x0", "0x0", 0);
   TestBigintCompare("0x1", "0x1", 0);
   TestBigintCompare("-0x1", "-0x1", 0);
   TestBigintCompare("0x1234567", "0x1234567", 0);
   TestBigintCompare("-0x1234567", "-0x1234567", 0);
   TestBigintCompare("0x12345678", "0x12345678", 0);
   TestBigintCompare("-0x12345678", "-0x12345678", 0);
   TestBigintCompare("0x123456789ABCDEF0", "0x123456789ABCDEF0", 0);
   TestBigintCompare("-0x123456789ABCDEF0", "-0x123456789ABCDEF0", 0);
   TestBigintCompare("0x123456789ABCDEF01", "0x123456789ABCDEF01", 0);
@@ skipping 28 matching lines @@
   TestBigintCompare("-0x10000000", "0xFFFFFFF", -1);
   TestBigintCompare("-0x100000000", "0xFFFFFFFF", -1);
   TestBigintCompare("-0x100000000", "0xFFFFFFFF", -1);
   TestBigintCompare("-0x10000000000000000", "0xFFFFFFFFFFFFFFFF", -1);
   TestBigintCompare("-0x10000000000000000", "0xFFFFFFFFFFFFFFFF", -1);
   TestBigintCompare("-0x10000000000000000", "0x0", -1);
   TestBigintCompare("-0x10000000000000000", "0x0", -1);
 }
 
 TEST_CASE(BigintDecimalStrings) {
+  if (Bigint::IsDisabled()) {
+    return;
+  }
+
   Zone* zone = Thread::Current()->zone();
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0"));
     EXPECT(bigint.FitsIntoSmi());
     EXPECT_EQ(0, bigint.AsInt64Value());
   }
 
   {
     const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("1"));
     EXPECT(bigint.FitsIntoSmi());
@@ skipping 45 matching lines @@
 
   {
     const Bigint& bigint =
         Bigint::Handle(Bigint::NewFromCString("-1311768467463790320"));
     const char* str = bigint.ToHexCString(zone);
     EXPECT_STREQ("-0x123456789ABCDEF0", str);
   }
 }
 
 }  // namespace dart