Implementation of message reader for converting a message snapshot into a C structure

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 "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
+#include "vm/dart_api_impl.h"
+#include "vm/dart_api_state.h"
 #include "vm/snapshot.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 // Check if serialized and deserialized objects are equal.
 static bool Equals(const Object& expected, const Object& actual) {
   if (expected.IsNull()) {
     return actual.IsNull();
   }
@@ skipping 30 matching lines @@
   writer.WriteObject(null_object.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());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(null_object, serialized_object));
+
+  // Read object back from the snapshot into a C structure.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                        writer.BytesWritten(),
+                        &allocator);
+  Dart_CObject* cobject = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kNull, cobject->type);
+  free(cobject);
 }
 
 
 TEST_CASE(SerializeSmi1) {
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
   const Smi& smi = Smi::Handle(Smi::New(124));
   writer.WriteObject(smi.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());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(smi, serialized_object));
+
+  // Read object back from the snapshot into a C structure.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                         writer.BytesWritten(),
+                         &allocator);
+  Dart_CObject* cobject = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kInt32, cobject->type);
+  EXPECT_EQ(smi.Value(), cobject->value.as_int32);
+  free(cobject);
 }
 
 
 TEST_CASE(SerializeSmi2) {
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
   const Smi& smi = Smi::Handle(Smi::New(-1));
   writer.WriteObject(smi.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());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(smi, serialized_object));
+
+  // Read object back from the snapshot into a C structure.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                         writer.BytesWritten(),
+                         &allocator);
+  Dart_CObject* cobject = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kInt32, cobject->type);
+  EXPECT_EQ(smi.Value(), cobject->value.as_int32);
+  free(cobject);
 }
 
 
 TEST_CASE(SerializeDouble) {
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
   const Double& dbl = Double::Handle(Double::New(101.29));
   writer.WriteObject(dbl.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());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(dbl, serialized_object));
+
+  // Read object back from the snapshot into a C structure.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                         writer.BytesWritten(),
+                         &allocator);
+  Dart_CObject* cobject = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kDouble, cobject->type);
+  EXPECT_EQ(dbl.value(), cobject->value.as_double);
+  free(cobject);
 }
 
 
 TEST_CASE(SerializeBool) {
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
   const Bool& bool1 = Bool::Handle(Bool::True());
   const Bool& bool2 = Bool::Handle(Bool::False());
   writer.WriteObject(bool1.raw());
   writer.WriteObject(bool2.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());
   EXPECT(Bool::True() == reader.ReadObject());
   EXPECT(Bool::False() == reader.ReadObject());
+
+  // Read object back from the snapshot into a C structure.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                         writer.BytesWritten(),
+                         &allocator);
+  Dart_CObject* cobject1 = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kBool, cobject1->type);
+  EXPECT_EQ(true, cobject1->value.as_bool);
+  Dart_CObject* cobject2 = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kBool, cobject2->type);
+  EXPECT_EQ(false, cobject2->value.as_bool);
+  free(cobject1);
+  free(cobject2);
 }
 
 
 TEST_CASE(SerializeBigint) {
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
   const Bigint& bigint = Bigint::Handle(Bigint::New(0xfffffffffLL));
   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.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                         writer.BytesWritten(),
+                         &allocator);
+  Dart_CObject* cobject = mreader.ReadObject();
+  // Bigint not supported.
+  EXPECT(cobject == NULL);
 }
 
 
 TEST_CASE(SerializeSingletons) {
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
   writer.WriteObject(Object::class_class());
   writer.WriteObject(Object::null_class());
   writer.WriteObject(Object::type_class());
@@ skipping 39 matching lines @@
   EXPECT(Object::exception_handlers_class() == reader.ReadObject());
   EXPECT(Object::context_class() == reader.ReadObject());
   EXPECT(Object::context_scope_class() == reader.ReadObject());
 }
 
 
 TEST_CASE(SerializeString) {
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
-  String& str = String::Handle(String::New("This string shall be serialized"));
+  static const char* cstr = "This string shall be serialized";
+  String& str = String::Handle(String::New(cstr));
   writer.WriteObject(str.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());
   String& serialized_str = String::Handle();
   serialized_str ^= reader.ReadObject();
   EXPECT(str.Equals(serialized_str));
+
+  // Read object back from the snapshot into a C structure.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                         writer.BytesWritten(),
+                         &allocator);
+  Dart_CObject* cobject = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kString, cobject->type);
+  EXPECT_STREQ(cstr, cobject->value.as_string);
+  free(cobject);
 }
 
 
 TEST_CASE(SerializeArray) {
   // Write snapshot with object content.
   uint8_t* buffer;
   SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
   const int kArrayLength = 10;
   Array& array = Array::Handle(Array::New(kArrayLength));
   Smi& smi = Smi::Handle();
   for (int i = 0; i < kArrayLength; i++) {
     smi ^= Smi::New(i);
     array.SetAt(i, smi);
   }
   writer.WriteObject(array.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());
   Array& serialized_array = Array::Handle();
   serialized_array ^= reader.ReadObject();
   EXPECT(array.Equals(serialized_array));
+
+  // Read object back from the snapshot into a C structure.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                         writer.BytesWritten(),
+                         &allocator);
+  Dart_CObject* cobject = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kArray, cobject->type);
+  EXPECT_EQ(kArrayLength, cobject->value.as_array.length);
+  for (int i = 0; i < kArrayLength; i++) {
+    Dart_CObject* element = cobject->value.as_array.values[i];
+    EXPECT_EQ(Dart_CObject::kInt32, element->type);
+    EXPECT_EQ(i, element->value.as_int32);
+    free(element);
+  }
+  free(cobject);
 }
 
 
+TEST_CASE(SerializeEmptyArray) {
+  // Write snapshot with object content.
+  uint8_t* buffer;
+  SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
+  const int kArrayLength = 0;
+  Array& array = Array::Handle(Array::New(kArrayLength));
+  writer.WriteObject(array.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());
+  Array& serialized_array = Array::Handle();
+  serialized_array ^= reader.ReadObject();
+  EXPECT(array.Equals(serialized_array));
+
+  // Read object back from the snapshot into a C structure.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                         writer.BytesWritten(),
+                         &allocator);
+  Dart_CObject* cobject = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kArray, cobject->type);
+  EXPECT_EQ(kArrayLength, cobject->value.as_array.length);
+  EXPECT(cobject->value.as_array.values == NULL);
+  free(cobject);
+}
+
+
 TEST_CASE(SerializeScript) {
   const char* kScriptChars =
       "class A {\n"
       "  static bar() { return 42; }\n"
       "  static fly() { return 5; }\n"
       "}\n";
 
   String& url = String::Handle(String::New("dart-test:SerializeScript"));
   String& source = String::Handle(String::New(kScriptChars));
   Script& script = Script::Handle(Script::New(url, source, RawScript::kSource));
@@ skipping 256 matching lines @@
                                0,
                                NULL);
     EXPECT_VALID(result);
     Dart_ExitScope();
   }
   Dart_ShutdownIsolate();
   free(full_snapshot);
   free(script_snapshot);
 }
 
+
+TEST_CASE(IntArrayMessage) {
+  uint8_t* buffer = NULL;
+  MessageWriter writer(&buffer, &allocator);
+
+  static const int kArrayLength = 2;
+  intptr_t data[kArrayLength] = {1, 2};
+  int len = kArrayLength;
+  writer.WriteMessage(len, data);
+
+  // Read object back from the snapshot into a C structure.
+  CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                         writer.BytesWritten(),
+                         &allocator);
+  Dart_CObject* value = mreader.ReadObject();
+  EXPECT_EQ(Dart_CObject::kArray, value->type);
+  EXPECT_EQ(kArrayLength, value->value.as_array.length);
+  for (int i = 0; i < kArrayLength; i++) {
+    Dart_CObject* element = value->value.as_array.values[i];
+    EXPECT_EQ(Dart_CObject::kInt32, element->type);
+    EXPECT_EQ(i + 1, element->value.as_int32);
+    free(element);
+  }
+  free(value);
+}
+
+
+// Unit test for creating and deleting persistent handles.

[siva, 2012/01/27 18:34:54]

The comment for this tests seems off.

[Søren Gjesse, 2012/01/30 08:26:03]

Absolutely, removed.

+UNIT_TEST_CASE(DartGeneratedMessages) {
+  const int kArrayLength = 10;
+  static const char* kCustomIsolateScriptChars =
+    "getSmi() {\n"
+    "  return 42;\n"
+    "}\n"
+    "getString() {\n"
+      "  return \"Hello, world!\";\n"
+    "}\n"
+    "getList() {\n"
+    "  return [1,2,3,4,5,6,7,8,9,10];\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 string_result;
+  string_result = Dart_InvokeStatic(lib,
+                                    Dart_NewString(""),
+                                    Dart_NewString("getString"),
+                                    0,
+                                    NULL);
+  EXPECT_VALID(string_result);
+  EXPECT(Dart_IsString(string_result));
+  Dart_Handle list_result;
+  list_result = Dart_InvokeStatic(lib,
+                                  Dart_NewString(""),
+                                  Dart_NewString("getList"),
+                                  0,
+                                  NULL);
+  EXPECT_VALID(list_result);
+  EXPECT(Dart_IsList(list_result));
+  intptr_t result_len = 0;
+  EXPECT_VALID(Dart_ListLength(list_result, &result_len));
+  EXPECT_EQ(kArrayLength, result_len);
+  {
+    DARTSCOPE_NOCHECKS(isolate);
+
+    {
+      uint8_t* buffer;
+      SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
+      Smi& smi = Smi::Handle();
+      smi ^= Api::UnwrapHandle(smi_result);
+      writer.WriteObject(smi.raw());
+      writer.FinalizeBuffer();
+
+      // Read object back from the snapshot into a C structure.
+      CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                             writer.BytesWritten(),
+                             &allocator);
+      Dart_CObject* value = mreader.ReadObject();
+      EXPECT_EQ(Dart_CObject::kInt32, value->type);
+      EXPECT_EQ(42, value->value.as_int32);
+      free(value);
+      free(buffer);
+    }
+    {
+      uint8_t* buffer;
+      SnapshotWriter writer(Snapshot::kMessage, &buffer, &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.
+      CMessageReader mreader(buffer + Snapshot::kHeaderSize,
+                             writer.BytesWritten(),
+                             &allocator);
+      Dart_CObject* value = mreader.ReadObject();
+      EXPECT_EQ(Dart_CObject::kString, value->type);
+      EXPECT_STREQ("Hello, world!", value->value.as_string);
+      free(value);
+      free(buffer);
+    }
+    {
+      uint8_t* buffer;
+      SnapshotWriter writer(Snapshot::kMessage, &buffer, &allocator);
+      const Object& list = Object::Handle(Api::UnwrapHandle(list_result));
+      writer.WriteObject(list.raw());
+      writer.FinalizeBuffer();
+      // TODO(sgjesse): Make this work!
+      free(buffer);
+    }
+  }
+  Dart_ExitScope();
+  Dart_ShutdownIsolate();
+}
+
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart