Add support for big integers to the native message format

runtime/vm/snapshot_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 "include/dart_debugger_api.h"
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_message.h"
@@ skipping 62 matching lines @@
   switch (first->type) {
     case Dart_CObject::kNull:
       // Nothing more to compare.
       break;
     case Dart_CObject::kBool:
       EXPECT_EQ(first->value.as_bool, second->value.as_bool);
       break;
     case Dart_CObject::kInt32:
       EXPECT_EQ(first->value.as_int32, second->value.as_int32);
       break;
+    case Dart_CObject::kBigint:
+      EXPECT_STREQ(first->value.as_bigint, second->value.as_bigint);
+      break;
     case Dart_CObject::kDouble:
       EXPECT_EQ(first->value.as_double, second->value.as_double);
       break;
     case Dart_CObject::kString:
       EXPECT_STREQ(first->value.as_string, second->value.as_string);
       break;
     case Dart_CObject::kArray:
       // Use invalid type as a visited marker to avoid infinite
       // recursion on graphs with cycles.
       second->type = Dart_CObject::kNumberOfTypes;
@@ skipping 202 matching lines @@
   Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
                                      writer.BytesWritten(),
                                      &zone_allocator);
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject::kBool, root->type);
   EXPECT_EQ(false, root->value.as_bool);
   CheckEncodeDecodeMessage(root);
 }
 
 
+static uword allocator(intptr_t size) {
+  return reinterpret_cast<uword>(malloc(size));
+}
+
+
 TEST_CASE(SerializeBigint) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
-  const Bigint& bigint = Bigint::Handle(Bigint::New(0xfffffffffLL));
+  const Bigint& bigint = Bigint::Handle(Bigint::New(DART_INT64_C(0xfffffffff)));
   writer.WriteObject(bigint.raw());
   writer.FinalizeBuffer();
 
   // Create a snapshot object using the buffer.
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
 
   // Read object back from the snapshot.
   SnapshotReader reader(snapshot, Isolate::Current());
   Bigint& obj = Bigint::Handle();
   obj ^= reader.ReadObject();
-  OS::Print("%lld", BigintOperations::ToInt64(obj));
+
   EXPECT_EQ(BigintOperations::ToInt64(bigint), BigintOperations::ToInt64(obj));
 
   // Read object back from the snapshot into a C structure.
   Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
                                      writer.BytesWritten(),
                                      &zone_allocator);
   // Bigint not supported.
-  EXPECT(root == NULL);
+  EXPECT_NOTNULL(root);
+  EXPECT_EQ(Dart_CObject::kBigint, root->type);
+  EXPECT_STREQ("68719476735", root->value.as_bigint);
+  CheckEncodeDecodeMessage(root);
 }
 
 
+Dart_CObject* SerializeAndDeserializeBigint(const Bigint& bigint) {
+  // Write snapshot with object content.
+  uint8_t* buffer;
+  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  writer.WriteObject(bigint.raw());
+  writer.FinalizeBuffer();
+
+  // Create a snapshot object using the buffer.
+  const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
+
+  // Read object back from the snapshot.
+  SnapshotReader reader(snapshot, Isolate::Current());
+  Bigint& serialized_bigint = Bigint::Handle();
+  serialized_bigint ^= reader.ReadObject();
+  const char *str1 = BigintOperations::ToDecCString(bigint, allocator);
+  const char *str2 =
+      BigintOperations::ToDecCString(serialized_bigint, allocator);
+  EXPECT_STREQ(str1, str2);
+  free(const_cast<char*>(str1));
+  free(const_cast<char*>(str2));
+
+  // Read object back from the snapshot into a C structure.
+  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
+                                     writer.BytesWritten(),
+                                     &zone_allocator);
+  // Bigint not supported.
+  EXPECT_NOTNULL(root);
+  CheckEncodeDecodeMessage(root);
+  return root;
+}
+
+
+void CheckBigint(const char* bigint_value) {
+  Zone zone(Isolate::Current());
+
+  Bigint& bigint = Bigint::Handle();
+  bigint ^= BigintOperations::NewFromCString(bigint_value);
+  Dart_CObject* bigint_cobject = SerializeAndDeserializeBigint(bigint);
+  EXPECT_EQ(Dart_CObject::kBigint, bigint_cobject->type);
+  EXPECT_STREQ(bigint_value, bigint_cobject->value.as_bigint);
+}
+
+
+TEST_CASE(SerializeBigint2) {
+  CheckBigint("0");
+  CheckBigint("1");
+  CheckBigint("-1");
+  CheckBigint("11111111111111111111");
+  CheckBigint("-11111111111111111111");
+  CheckBigint("9876543210987654321098765432109876543210");
+  CheckBigint("-9876543210987654321098765432109876543210");
+}
+
+
 TEST_CASE(SerializeSingletons) {
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &malloc_allocator);
   writer.WriteObject(Object::class_class());
   writer.WriteObject(Object::null_class());
   writer.WriteObject(Object::type_class());
   writer.WriteObject(Object::type_parameter_class());
   writer.WriteObject(Object::instantiated_type_class());
   writer.WriteObject(Object::abstract_type_arguments_class());
@@ skipping 498 matching lines @@
                        writer.BytesWritten(),
                        &zone_allocator);
 }
 
 
 UNIT_TEST_CASE(DartGeneratedMessages) {
   static const char* kCustomIsolateScriptChars =
       "getSmi() {\n"
       "  return 42;\n"
       "}\n"
+      "getBigint() {\n"
+      "  return -424242424242424242424242424242424242;\n"
+      "}\n"
       "getString() {\n"
       "  return \"Hello, world!\";\n"
       "}\n"
       "getList() {\n"
       "  return new List(kArrayLength);\n"
       "}\n";
 
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   Dart_EnterScope();
 
   Dart_Handle lib = TestCase::LoadTestScript(kCustomIsolateScriptChars,
                                              NULL);
   EXPECT_VALID(lib);
   Dart_Handle smi_result;
   smi_result = Dart_InvokeStatic(lib,
                                  Dart_NewString(""),
                                  Dart_NewString("getSmi"),
                                  0,
                                  NULL);
   EXPECT_VALID(smi_result);
+  Dart_Handle bigint_result;
+  bigint_result = Dart_InvokeStatic(lib,
+                                    Dart_NewString(""),
+                                    Dart_NewString("getBigint"),
+                                    0,
+                                    NULL);
+  EXPECT_VALID(bigint_result);
   Dart_Handle string_result;
   string_result = Dart_InvokeStatic(lib,
                                     Dart_NewString(""),
                                     Dart_NewString("getString"),
                                     0,
                                     NULL);
   EXPECT_VALID(string_result);
   EXPECT(Dart_IsString(string_result));
 
   {
@@ skipping 14 matching lines @@
                                          &zone_allocator);
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject::kInt32, root->type);
       EXPECT_EQ(42, root->value.as_int32);
       CheckEncodeDecodeMessage(root);
     }
     {
       Zone zone(Isolate::Current());
       uint8_t* buffer;
       SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+      Bigint& bigint = Bigint::Handle();
+      bigint ^= Api::UnwrapHandle(bigint_result);
+      writer.WriteObject(bigint.raw());
+      writer.FinalizeBuffer();
+
+      // Read object back from the snapshot into a C structure.
+      Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
+                                         writer.BytesWritten(),
+                                         &zone_allocator);
+      EXPECT_NOTNULL(root);
+      EXPECT_EQ(Dart_CObject::kBigint, root->type);
+      EXPECT_STREQ("-424242424242424242424242424242424242",
+                   root->value.as_bigint);
+      CheckEncodeDecodeMessage(root);
+    }
+    {
+      Zone zone(Isolate::Current());
+      uint8_t* buffer;
+      SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
       String& str = String::Handle();
       str ^= Api::UnwrapHandle(string_result);
       writer.WriteObject(str.raw());
       writer.FinalizeBuffer();
 
       // Read object back from the snapshot into a C structure.
       Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
                                          writer.BytesWritten(),
                                          &zone_allocator);
       EXPECT_NOTNULL(root);
@@ skipping 288 matching lines @@
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: nulltruefalse1234563.14[]\n",
                    Dart_GetError(result));
 
   Dart_ExitScope();
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart