Avoid trusting the length encoded in the Snapshot if there is an

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 18 matching lines @@
   if (expected.IsDouble()) {
     if (actual.IsDouble()) {
       Double& dbl1 = Double::Handle();
       Double& dbl2 = Double::Handle();
       dbl1 ^= expected.raw();
       dbl2 ^= actual.raw();
       return dbl1.value() == dbl2.value();
     }
     return false;
   }
+  if (expected.IsBool()) {
+    if (actual.IsBool()) {
+      Bool& bl1 = Bool::Handle();
+      Bool& bl2 = Bool::Handle();
+      bl1 ^= expected.raw();
+      bl2 ^= actual.raw();
+      return bl1.value() == bl2.value();
+    }
+    return false;
+  }
   return false;
 }
 
 
 static uint8_t* malloc_allocator(
     uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   return reinterpret_cast<uint8_t*>(realloc(ptr, new_size));
 }
 
 
 static uint8_t* zone_allocator(
     uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   Zone* zone = Isolate::Current()->current_zone();
   return zone->Realloc<uint8_t>(ptr, old_size, new_size);
 }
 
 
-static Dart_CObject* DecodeMessage(uint8_t* message,
-                                   intptr_t length,
-                                   ReAlloc allocator) {
-  ApiMessageReader message_reader(message, length, allocator);
-  return message_reader.ReadMessage();
-}
-
-
 // Compare two Dart_CObject object graphs rooted in first and
 // second. The second graph will be destroyed by this operation no matter
 // whether the graphs are equal or not.
 static void CompareDartCObjects(Dart_CObject* first, Dart_CObject* second) {
   // Return immediately if entering a cycle.
   if (second->type == Dart_CObject::kNumberOfTypes) return;
 
   EXPECT_NE(first, second);
   EXPECT_EQ(first->type, second->type);
   switch (first->type) {
@@ skipping 41 matching lines @@
   }
 }
 
 
 static void CheckEncodeDecodeMessage(Dart_CObject* root) {
   // Encode and decode the message.
   uint8_t* buffer = NULL;
   ApiMessageWriter writer(&buffer, &malloc_allocator);
   writer.WriteCMessage(root);
 
-  Dart_CObject* new_root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                         writer.BytesWritten(),
-                                         &zone_allocator);
+  ApiMessageReader api_reader(buffer, writer.BytesWritten(), &zone_allocator);
+  Dart_CObject* new_root = api_reader.ReadMessage();
 
   // Check that the two messages are the same.
   CompareDartCObjects(root, new_root);
 }
 
 TEST_CASE(SerializeNull) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_allocator);
   const Object& null_object = Object::Handle();
-  writer.WriteObject(null_object.raw());
-  writer.FinalizeBuffer();
-
-  // Create a snapshot object using the buffer.
-  const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
+  writer.WriteMessage(null_object);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, 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.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject::kNull, root->type);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeSmi1) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_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);
+  writer.WriteMessage(smi);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, 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.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject::kInt32, root->type);
   EXPECT_EQ(smi.Value(), root->value.as_int32);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeSmi2) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_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);
+  writer.WriteMessage(smi);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, 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.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject::kInt32, root->type);
   EXPECT_EQ(smi.Value(), root->value.as_int32);
   CheckEncodeDecodeMessage(root);
 }
 
 
 Dart_CObject* SerializeAndDeserializeMint(const Mint& mint) {
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
-  writer.WriteObject(mint.raw());
-  writer.FinalizeBuffer();
-
-  // Create a snapshot object using the buffer.
-  const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
+  MessageWriter writer(&buffer, &zone_allocator);
+  writer.WriteMessage(mint);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, Isolate::Current());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(serialized_object.IsMint());
 
   // Read object back from the snapshot into a C structure.
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   CheckEncodeDecodeMessage(root);
   return root;
 }
 
 
 void CheckMint(int64_t value) {
   Zone zone(Isolate::Current());
 
   const Mint& mint = Mint::Handle(Mint::New(value));
@@ skipping 36 matching lines @@
   // Min negative mint + 1.
   CheckMint(kMinInt64 + 1);
 }
 
 
 TEST_CASE(SerializeDouble) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_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);
+  writer.WriteMessage(dbl);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, 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.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject::kDouble, root->type);
   EXPECT_EQ(dbl.value(), root->value.as_double);
   CheckEncodeDecodeMessage(root);
 }
 
 
-TEST_CASE(SerializeBool) {
-  Zone zone(Isolate::Current());
-
-  // Write snapshot with object content.
-  uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_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());
-}
-
-
 TEST_CASE(SerializeTrue) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with true object.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_allocator);
   const Bool& bl = Bool::Handle(Bool::True());
-  writer.WriteObject(bl.raw());
-  writer.FinalizeBuffer();
+  writer.WriteMessage(bl);
+  intptr_t buffer_len = writer.BytesWritten();
 
-  // Create a snapshot object using the buffer.
-  Snapshot::SetupFromBuffer(buffer);
+  // Read object back from the snapshot.
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, Isolate::Current());
+  const Object& serialized_object = Object::Handle(reader.ReadObject());
+  fprintf(stderr, "%s / %s\n", bl.ToCString(), serialized_object.ToCString());
+
+  EXPECT(Equals(bl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject::kBool, root->type);
   EXPECT_EQ(true, root->value.as_bool);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeFalse) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with false object.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_allocator);
   const Bool& bl = Bool::Handle(Bool::False());
-  writer.WriteObject(bl.raw());
-  writer.FinalizeBuffer();
+  writer.WriteMessage(bl);
+  intptr_t buffer_len = writer.BytesWritten();
 
-  // Create a snapshot object using the buffer.
-  Snapshot::SetupFromBuffer(buffer);
+  // Read object back from the snapshot.
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, Isolate::Current());
+  const Object& serialized_object = Object::Handle(reader.ReadObject());
+  EXPECT(Equals(bl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   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);
+  MessageWriter writer(&buffer, &zone_allocator);
   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);
+  writer.WriteMessage(bigint);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, Isolate::Current());
   Bigint& obj = Bigint::Handle();
   obj ^= reader.ReadObject();
 
   EXPECT_EQ(BigintOperations::ToMint(bigint), BigintOperations::ToMint(obj));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   // Bigint not supported.
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject::kBigint, root->type);
   EXPECT_STREQ("FFFFFFFFF", 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);
+  MessageWriter writer(&buffer, &zone_allocator);
+  writer.WriteMessage(bigint);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, Isolate::Current());
   Bigint& serialized_bigint = Bigint::Handle();
   serialized_bigint ^= reader.ReadObject();
   const char *str1 = BigintOperations::ToHexCString(bigint, allocator);
   const char *str2 =
       BigintOperations::ToHexCString(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.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   // Bigint not supported.
   EXPECT_NOTNULL(root);
   CheckEncodeDecodeMessage(root);
   return root;
 }
 
 
 void CheckBigint(const char* bigint_value) {
   Zone zone(Isolate::Current());
 
@@ skipping 16 matching lines @@
   CheckBigint("0x1");
   CheckBigint("-0x1");
   CheckBigint("0x11111111111111111111");
   CheckBigint("-0x11111111111111111111");
   CheckBigint("0x9876543210987654321098765432109876543210");
   CheckBigint("-0x9876543210987654321098765432109876543210");
 }
 
 
 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::type_arguments_class());
-  writer.WriteObject(Object::instantiated_type_arguments_class());
-  writer.WriteObject(Object::function_class());
-  writer.WriteObject(Object::field_class());
-  writer.WriteObject(Object::token_stream_class());
-  writer.WriteObject(Object::script_class());
-  writer.WriteObject(Object::library_class());
-  writer.WriteObject(Object::code_class());
-  writer.WriteObject(Object::instructions_class());
-  writer.WriteObject(Object::pc_descriptors_class());
-  writer.WriteObject(Object::exception_handlers_class());
-  writer.WriteObject(Object::context_class());
-  writer.WriteObject(Object::context_scope_class());
-  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(Object::class_class() == reader.ReadObject());
-  EXPECT(Object::null_class() == reader.ReadObject());
-  EXPECT(Object::type_class() == reader.ReadObject());
-  EXPECT(Object::type_parameter_class() == reader.ReadObject());
-  EXPECT(Object::type_arguments_class() == reader.ReadObject());
-  EXPECT(Object::instantiated_type_arguments_class() == reader.ReadObject());
-  EXPECT(Object::function_class() == reader.ReadObject());
-  EXPECT(Object::field_class() == reader.ReadObject());
-  EXPECT(Object::token_stream_class() == reader.ReadObject());
-  EXPECT(Object::script_class() == reader.ReadObject());
-  EXPECT(Object::library_class() == reader.ReadObject());
-  EXPECT(Object::code_class() == reader.ReadObject());
-  EXPECT(Object::instructions_class() == reader.ReadObject());
-  EXPECT(Object::pc_descriptors_class() == reader.ReadObject());
-  EXPECT(Object::exception_handlers_class() == reader.ReadObject());
-  EXPECT(Object::context_class() == reader.ReadObject());
-  EXPECT(Object::context_scope_class() == reader.ReadObject());
-
-  free(buffer);
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::class_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::class_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::null_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::null_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::type_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::type_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::type_parameter_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::type_parameter_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::type_arguments_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::type_arguments_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(
+        Object::Handle(Object::instantiated_type_arguments_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::instantiated_type_arguments_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::function_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::function_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::field_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::field_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::token_stream_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::token_stream_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::script_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::script_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::library_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::library_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::code_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::code_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::instructions_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::instructions_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::pc_descriptors_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::pc_descriptors_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::exception_handlers_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::exception_handlers_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::context_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::context_class() == reader.ReadObject());
+  }
+  {
+    Zone zone(Isolate::Current());
+    MessageWriter writer(&buffer, &zone_allocator);
+    writer.WriteMessage(Object::Handle(Object::context_scope_class()));
+    SnapshotReader reader(buffer, writer.BytesWritten(),
+                          Snapshot::kMessage, Isolate::Current());
+    EXPECT(Object::context_scope_class() == reader.ReadObject());
+  }

[siva, 2012/08/27 16:31:17]

This has changed the model of the test itself. It used to serialize all
singleton objects into one snapshot and read from that snapshot but now it seems
to create individual snapshots for each of them and read them.

[turnidge, 2012/08/27 17:43:05]

Yes, it has.  I didn't think that putting them in the same snapshot was an
important aspect of the test.  My opinion was that if they can
serialize/deserialize individually, they can probably do it together.  I figured
that the existing FullSnapshot test provided a fine test of multiple object
serialization/deserialization.

Is it important to you to have it as it originally was?  If so, I either need to
(a) throw all of the singletons into an object array and serialize that as a
single message or  (b) make my own testing subclass of SnapshotWriter that
exposes UnmarkAll() publicly.

Let me know what you'd like me to do.

[siva, 2012/08/27 18:41:03]

This test was trying to test both the singleton aspect as well as the
possibility of having only singletons (more than one) in the snapshot. (i.e no
code in writer assumed it will see an object to be serialized).

On 2012/08/27 17:43:05, turnidge wrote:

[turnidge, 2012/08/27 20:09:16]

Ok, I've revert it to its original form.

On 2012/08/27 18:41:03, asiva wrote:

 }
 
 
 TEST_CASE(SerializeString) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_allocator);
   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);
+  writer.WriteMessage(str);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, 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.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject::kString, root->type);
   EXPECT_STREQ(cstr, root->value.as_string);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeArray) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_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);
+  writer.WriteMessage(array);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, 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.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject::kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
   for (int i = 0; i < kArrayLength; i++) {
     Dart_CObject* element = root->value.as_array.values[i];
     EXPECT_EQ(Dart_CObject::kInt32, element->type);
     EXPECT_EQ(i, element->value.as_int32);
   }
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeEmptyArray) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_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);
+  writer.WriteMessage(array);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, 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.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject::kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
   EXPECT(root->value.as_array.values == NULL);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeByteArray) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_allocator);
   const int kByteArrayLength = 256;
   Uint8Array& byte_array =
       Uint8Array::Handle(Uint8Array::New(kByteArrayLength));
   for (int i = 0; i < kByteArrayLength; i++) {
     byte_array.SetAt(i, i);
   }
-  writer.WriteObject(byte_array.raw());
-  writer.FinalizeBuffer();
-
-  // Create a snapshot object using the buffer.
-  const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
+  writer.WriteMessage(byte_array);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, Isolate::Current());
   ByteArray& serialized_byte_array = ByteArray::Handle();
   serialized_byte_array ^= reader.ReadObject();
   EXPECT(serialized_byte_array.IsByteArray());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject::kUint8Array, root->type);
   EXPECT_EQ(kByteArrayLength, root->value.as_byte_array.length);
   for (int i = 0; i < kByteArrayLength; i++) {
     EXPECT(root->value.as_byte_array.values[i] == i);
   }
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeEmptyByteArray) {
   Zone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_allocator);
   const int kByteArrayLength = 0;
   Uint8Array& byte_array =
       Uint8Array::Handle(Uint8Array::New(kByteArrayLength));
-  writer.WriteObject(byte_array.raw());
-  writer.FinalizeBuffer();
-
-  // Create a snapshot object using the buffer.
-  const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
+  writer.WriteMessage(byte_array);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, buffer_len,
+                        Snapshot::kMessage, Isolate::Current());
   ByteArray& serialized_byte_array = ByteArray::Handle();
   serialized_byte_array ^= reader.ReadObject();
   EXPECT(serialized_byte_array.IsByteArray());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject::kUint8Array, root->type);
   EXPECT_EQ(kByteArrayLength, root->value.as_byte_array.length);
   EXPECT(root->value.as_byte_array.values == NULL);
   CheckEncodeDecodeMessage(root);
 }
 
 
+class TestSnapshotWriter : public SnapshotWriter {
+ public:
+  TestSnapshotWriter(uint8_t** buffer, ReAlloc alloc)
+      : SnapshotWriter(Snapshot::kScript, buffer, alloc) {
+    ASSERT(buffer != NULL);
+    ASSERT(alloc != NULL);
+  }
+  ~TestSnapshotWriter() { }
+
+  // Writes just a script object
+  void WriteScript(const Script& script) {
+    WriteObject(script.raw());
+    UnmarkAll();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestSnapshotWriter);
+};
+
+
 TEST_CASE(SerializeScript) {
   const char* kScriptChars =
       "class A {\n"
       "  static bar() { return 42; }\n"
       "  static fly() { return 5; }\n"
       "  static s1() { return 'this is a string in the source'; }\n"
       "  static s2() { return 'this is a \"string\" in the source'; }\n"
       "  static s3() { return 'this is a \\\'string\\\' in \"the\" source'; }\n"
       "  static s4() { return 'this \"is\" a \"string\" in \"the\" source'; }\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::kSourceTag));
   const String& lib_url = String::Handle(Symbols::New("TestLib"));
   Library& lib = Library::Handle(Library::New(lib_url));
   lib.Register();
   EXPECT(CompilerTest::TestCompileScript(lib, script));
 
-  // Write snapshot with object content.
+  // Write snapshot with script content.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kScript, &buffer, &malloc_allocator);
-  writer.WriteObject(script.raw());
-  writer.FinalizeBuffer();
-
-  // Create a snapshot object using the buffer.
-  const Snapshot* snapshot = Snapshot::SetupFromBuffer(buffer);
+  TestSnapshotWriter writer(&buffer, &malloc_allocator);
+  writer.WriteScript(script);
 
   // Read object back from the snapshot.
-  SnapshotReader reader(snapshot, Isolate::Current());
+  SnapshotReader reader(buffer, writer.BytesWritten(),
+                        Snapshot::kScript, Isolate::Current());
   Script& serialized_script = Script::Handle();
   serialized_script ^= reader.ReadObject();
 
   // Check if the serialized script object matches the original script.
   String& expected_literal = String::Handle();
   String& actual_literal = String::Handle();
   String& str = String::Handle();
   str ^= serialized_script.url();
   EXPECT(url.Equals(str));
 
@@ skipping 76 matching lines @@
 
     // Create a test library and Load up a test script in it.
     TestCase::LoadTestScript(kScriptChars, NULL);
     timer1.Stop();
     OS::PrintErr("Without Snapshot: %dus\n", timer1.TotalElapsedTime());
 
     // Write snapshot with object content.
     Isolate* isolate = Isolate::Current();
     Zone zone(isolate);
     HandleScope scope(isolate);
-    SnapshotWriter writer(Snapshot::kFull, &buffer, &malloc_allocator);
+    FullSnapshotWriter writer(&buffer, &malloc_allocator);
     writer.WriteFullSnapshot();
   }
 
   // Now Create another isolate using the snapshot and execute a method
   // from the script.
   Timer timer2(true, "Snapshot_test");
   timer2.Start();
   TestCase::CreateTestIsolateFromSnapshot(buffer);
   {
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
@@ skipping 33 matching lines @@
     Zone zone(isolate);
     HandleScope scope(isolate);
 
     // Create a test library and Load up a test script in it.
     Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
     ClassFinalizer::FinalizePendingClasses();
     timer1.Stop();
     OS::PrintErr("Without Snapshot: %dus\n", timer1.TotalElapsedTime());
 
     // Write snapshot with object content.
-    SnapshotWriter writer(Snapshot::kFull, &buffer, &malloc_allocator);
+    FullSnapshotWriter writer(&buffer, &malloc_allocator);
     writer.WriteFullSnapshot();
 
     // Invoke a function which returns an object.
     Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("FieldsTest"));
     Dart_Handle result = Dart_Invoke(cls, Dart_NewString("testMain"), 0, NULL);
     EXPECT_VALID(result);
   }
 
   // Now Create another isolate using the snapshot and execute a method
   // from the script.
@@ skipping 146 matching lines @@
   uint8_t* buffer = NULL;
   ApiMessageWriter writer(&buffer, &zone_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.
   ApiNativeScope scope;
-  Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                     writer.BytesWritten(),
-                                     &zone_allocator);
+  ApiMessageReader api_reader(buffer, writer.BytesWritten(), &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject::kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
   for (int i = 0; i < kArrayLength; i++) {
     Dart_CObject* element = root->value.as_array.values[i];
     EXPECT_EQ(Dart_CObject::kInt32, element->type);
     EXPECT_EQ(i + 1, element->value.as_int32);
   }
   CheckEncodeDecodeMessage(root);
 }
 
 
 // Helper function to call a top level Dart function, serialize the
 // result and deserialize the result into a Dart_CObject structure.
 static Dart_CObject* GetDeserializedDartMessage(Dart_Handle lib,
                                                 const char* dart_function) {
   Dart_Handle result;
   result = Dart_Invoke(lib, Dart_NewString(dart_function), 0, NULL);
   EXPECT_VALID(result);
 
   // Serialize the list into a message.
   uint8_t* buffer;
-  SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+  MessageWriter writer(&buffer, &zone_allocator);
   const Object& list = Object::Handle(Api::UnwrapHandle(result));
-  writer.WriteObject(list.raw());
-  writer.FinalizeBuffer();
+  writer.WriteMessage(list);
+  intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot into a C structure.
-  return DecodeMessage(buffer + Snapshot::kHeaderSize,
-                       writer.BytesWritten(),
-                       &zone_allocator);
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  return api_reader.ReadMessage();
 }
 
 
 UNIT_TEST_CASE(DartGeneratedMessages) {
   static const char* kCustomIsolateScriptChars =
       "getSmi() {\n"
       "  return 42;\n"
       "}\n"
       "getBigint() {\n"
       "  return -0x424242424242424242424242424242424242;\n"
@@ skipping 23 matching lines @@
   string_result = Dart_Invoke(lib, Dart_NewString("getString"), 0, NULL);
   EXPECT_VALID(string_result);
   EXPECT(Dart_IsString(string_result));
 
   {
     DARTSCOPE_NOCHECKS(isolate);
 
     {
       Zone zone(Isolate::Current());
       uint8_t* buffer;
-      SnapshotWriter writer(Snapshot::kMessage, &buffer, &zone_allocator);
+      MessageWriter writer(&buffer, &zone_allocator);
       Smi& smi = Smi::Handle();
       smi ^= Api::UnwrapHandle(smi_result);
-      writer.WriteObject(smi.raw());
-      writer.FinalizeBuffer();
+      writer.WriteMessage(smi);
+      intptr_t buffer_len = writer.BytesWritten();
 
       // Read object back from the snapshot into a C structure.
       ApiNativeScope scope;
-      Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                         writer.BytesWritten(),
-                                         &zone_allocator);
+      ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+      Dart_CObject* root = api_reader.ReadMessage();
       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);
+      MessageWriter writer(&buffer, &zone_allocator);
       Bigint& bigint = Bigint::Handle();
       bigint ^= Api::UnwrapHandle(bigint_result);
-      writer.WriteObject(bigint.raw());
-      writer.FinalizeBuffer();
+      writer.WriteMessage(bigint);
+      intptr_t buffer_len = writer.BytesWritten();
 
       // Read object back from the snapshot into a C structure.
       ApiNativeScope scope;
-      Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                         writer.BytesWritten(),
-                                         &zone_allocator);
+      ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+      Dart_CObject* root = api_reader.ReadMessage();
       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);
+      MessageWriter writer(&buffer, &zone_allocator);
       String& str = String::Handle();
       str ^= Api::UnwrapHandle(string_result);
-      writer.WriteObject(str.raw());
-      writer.FinalizeBuffer();
+      writer.WriteMessage(str);
+      intptr_t buffer_len = writer.BytesWritten();
 
       // Read object back from the snapshot into a C structure.
       ApiNativeScope scope;
-      Dart_CObject* root = DecodeMessage(buffer + Snapshot::kHeaderSize,
-                                         writer.BytesWritten(),
-                                         &zone_allocator);
+      ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+      Dart_CObject* root = api_reader.ReadMessage();
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject::kString, root->type);
       EXPECT_STREQ("Hello, world!", root->value.as_string);
       CheckEncodeDecodeMessage(root);
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
@@ skipping 359 matching lines @@
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: nulltruefalse1234563.14[]100123456789\n",
                    Dart_GetError(result));
 
   Dart_ExitScope();
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart