Fix issue 5275: The VM must always generate the most compact form of an integer (Smi, Mint or Bigin…

runtime/vm/object_test.cc

 // Copyright (c) 2012, 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/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 218 matching lines @@
   EXPECT_EQ(5.0, smi.AsDoubleValue());
 
   Smi& a = Smi::Handle(Smi::New(5));
   Smi& b = Smi::Handle(Smi::New(3));
   EXPECT_EQ(1, a.CompareWith(b));
   EXPECT_EQ(-1, b.CompareWith(a));
   EXPECT_EQ(0, a.CompareWith(a));
 
   Smi& c = Smi::Handle(Smi::New(-1));
 
-  Mint& mint1 = Mint::Handle(
-      Mint::New(DART_2PART_UINT64_C(0x7FFFFFFF, 100)));
-  Mint& mint2 = Mint::Handle(
-      Mint::New(-DART_2PART_UINT64_C(0x7FFFFFFF, 100)));
+  Mint& mint1 = Mint::Handle();
+  mint1 ^= Integer::New(DART_2PART_UINT64_C(0x7FFFFFFF, 100));
+  Mint& mint2 = Mint::Handle();
+  mint2 ^= Integer::New(-DART_2PART_UINT64_C(0x7FFFFFFF, 100));
   EXPECT_EQ(-1, a.CompareWith(mint1));
   EXPECT_EQ(1, a.CompareWith(mint2));
   EXPECT_EQ(-1, c.CompareWith(mint1));
   EXPECT_EQ(1, c.CompareWith(mint2));
 
   Bigint& big1 = Bigint::Handle(BigintOperations::NewFromCString(
       "10000000000000000000"));
   Bigint& big2 = Bigint::Handle(BigintOperations::NewFromCString(
       "-10000000000000000000"));
   EXPECT_EQ(-1, a.CompareWith(big1));
@@ skipping 47 matching lines @@
 }
 
 
 TEST_CASE(Mint) {
 // On 64-bit architectures a Smi is stored in a 64 bit word. A Midint cannot
 // be allocated if it does fit into a Smi.
 #if !defined(ARCH_IS_64_BIT)
   { Mint& med = Mint::Handle();
     EXPECT(med.IsNull());
     int64_t v = DART_2PART_UINT64_C(1, 0);
-    med = Mint::New(v);
+    med ^= Integer::New(v);
     EXPECT_EQ(v, med.value());
     const String& smi_str = String::Handle(String::New("1"));
     const String& mint1_str = String::Handle(String::New("2147419168"));
     const String& mint2_str = String::Handle(String::New("-2147419168"));
     Integer& i = Integer::Handle(Integer::NewCanonical(smi_str));
     EXPECT(i.IsSmi());
     i = Integer::NewCanonical(mint1_str);
     EXPECT(i.IsMint());
     EXPECT(!i.IsZero());
     EXPECT(!i.IsNegative());
     i = Integer::NewCanonical(mint2_str);
     EXPECT(i.IsMint());
     EXPECT(!i.IsZero());
     EXPECT(i.IsNegative());
   }
-  Integer& i = Integer::Handle(Mint::New(DART_2PART_UINT64_C(1, 0)));
+  Integer& i = Integer::Handle(Integer::New(DART_2PART_UINT64_C(1, 0)));
   EXPECT(i.IsMint());
   EXPECT(!i.IsZero());
   EXPECT(!i.IsNegative());
-  Integer& i1 = Integer::Handle(Mint::New(DART_2PART_UINT64_C(1010, 0)));
-  Mint& i2 = Mint::Handle(Mint::New(DART_2PART_UINT64_C(1010, 0)));
+  Integer& i1 = Integer::Handle(Integer::New(DART_2PART_UINT64_C(1010, 0)));
+  Mint& i2 = Mint::Handle();
+  i2 ^= Integer::New(DART_2PART_UINT64_C(1010, 0));
   EXPECT(i1.Equals(i2));
   EXPECT(!i.Equals(i1));
   int64_t test = DART_2PART_UINT64_C(1010, 0);
   EXPECT_EQ(test, i2.value());
 
-  Mint& a = Mint::Handle(Mint::New(DART_2PART_UINT64_C(5, 0)));
-  Mint& b = Mint::Handle(Mint::New(DART_2PART_UINT64_C(3, 0)));
+  Mint& a = Mint::Handle();
+  a ^= Integer::New(DART_2PART_UINT64_C(5, 0));
+  Mint& b = Mint::Handle();
+  b ^= Integer::New(DART_2PART_UINT64_C(3, 0));
   EXPECT_EQ(1, a.CompareWith(b));
   EXPECT_EQ(-1, b.CompareWith(a));
   EXPECT_EQ(0, a.CompareWith(a));
 
-  Mint& c = Mint::Handle(Mint::New(-DART_2PART_UINT64_C(3, 0)));
+  Mint& c = Mint::Handle();
+  c ^= Integer::New(-DART_2PART_UINT64_C(3, 0));
   Smi& smi1 = Smi::Handle(Smi::New(4));
   Smi& smi2 = Smi::Handle(Smi::New(-4));
   EXPECT_EQ(1, a.CompareWith(smi1));
   EXPECT_EQ(1, a.CompareWith(smi2));
   EXPECT_EQ(-1, c.CompareWith(smi1));
   EXPECT_EQ(-1, c.CompareWith(smi2));
 
   Bigint& big1 = Bigint::Handle(BigintOperations::NewFromCString(
       "10000000000000000000"));
   Bigint& big2 = Bigint::Handle(BigintOperations::NewFromCString(
       "-10000000000000000000"));
   EXPECT_EQ(-1, a.CompareWith(big1));
   EXPECT_EQ(1, a.CompareWith(big2));
   EXPECT_EQ(-1, c.CompareWith(big1));
   EXPECT_EQ(1, c.CompareWith(big2));
 
-  int64_t mint_value = DART_2PART_UINT64_C(0x7FFFFFFF, 100);
-  Mint& mint1 = Mint::Handle(Mint::NewCanonical(mint_value));
-  Mint& mint2 = Mint::Handle(Mint::NewCanonical(mint_value));
+  int64_t mint_value = DART_2PART_UINT64_C(0x7FFFFFFF, 64);
+  const String& mint_string = String::Handle(String::New("0x7FFFFFFF00000064"));
+  Mint& mint1 = Mint::Handle();
+  mint1 ^= Integer::NewCanonical(mint_string);
+  Mint& mint2 = Mint::Handle();
+  mint2 ^= Integer::NewCanonical(mint_string);
   EXPECT_EQ(mint1.value(), mint_value);
   EXPECT_EQ(mint2.value(), mint_value);
   EXPECT_EQ(mint1.raw(), mint2.raw());
 #endif
 }
 
 
 TEST_CASE(Double) {
   {
     const double dbl_const = 5.0;
@@ skipping 60 matching lines @@
     EXPECT(dbl2.IsNull());
   }
 }
 
 
 TEST_CASE(Bigint) {
   Bigint& b = Bigint::Handle();
   EXPECT(b.IsNull());
   const char* cstr = "18446744073709551615000";
   const String& test = String::Handle(String::New(cstr));
-  b = Bigint::NewCanonical(test);
+  b ^= Integer::NewCanonical(test);
   const char* str = b.ToCString();
   EXPECT_STREQ(cstr, str);
 
   int64_t t64 = DART_2PART_UINT64_C(1, 0);
   Bigint& big = Bigint::Handle();
   big = BigintOperations::NewFromInt64(t64);
   EXPECT_EQ(t64, big.AsInt64Value());
   big = BigintOperations::NewFromCString("10000000000000000000");
   EXPECT_EQ(1e19, big.AsDoubleValue());
 
@@ skipping 2744 matching lines @@
   const Function& test7 = Function::Handle(GetFunction(class_a, "test7"));
   EXPECT_EQ(test1.SourceFingerprint(), test2.SourceFingerprint());
   EXPECT_NE(test1.SourceFingerprint(), test3.SourceFingerprint());
   EXPECT_NE(test3.SourceFingerprint(), test4.SourceFingerprint());
   EXPECT_NE(test4.SourceFingerprint(), test5.SourceFingerprint());
   EXPECT_NE(test5.SourceFingerprint(), test6.SourceFingerprint());
   EXPECT_EQ(test6.SourceFingerprint(), test7.SourceFingerprint());
 }
 
 }  // namespace dart