VM: Re-format to use at most one newline between functions

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/globals.h"
 
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
 #include "vm/clustered_snapshot.h"
@@ skipping 32 matching lines @@
   }
   if (expected.IsBool()) {
     if (actual.IsBool()) {
       return expected.raw() == actual.raw();
     }
     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 void malloc_deallocator(uint8_t* ptr) {
   free(ptr);
 }
 
-
 static uint8_t* zone_allocator(uint8_t* ptr,
                                intptr_t old_size,
                                intptr_t new_size) {
   Zone* zone = Thread::Current()->zone();
   return zone->Realloc<uint8_t>(ptr, old_size, new_size);
 }
 
-
 static void zone_deallocator(uint8_t* ptr) {}
 
-
 // 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 42 matching lines @@
       }
       break;
     case Dart_CObject_kCapability:
       EXPECT_EQ(first->value.as_capability.id, second->value.as_capability.id);
       break;
     default:
       EXPECT(false);
   }
 }
 
-
 static void CheckEncodeDecodeMessage(Dart_CObject* root) {
   // Encode and decode the message.
   uint8_t* buffer = NULL;
   ApiMessageWriter writer(&buffer, &malloc_allocator);
   writer.WriteCMessage(root);
 
   ApiMessageReader api_reader(buffer, writer.BytesWritten());
   Dart_CObject* new_root = api_reader.ReadMessage();
 
   // Check that the two messages are the same.
   CompareDartCObjects(root, new_root);
 
   free(buffer);
 }
 
-
 static void ExpectEncodeFail(Dart_CObject* root) {
   uint8_t* buffer = NULL;
   ApiMessageWriter writer(&buffer, &malloc_allocator);
   const bool result = writer.WriteCMessage(root);
   EXPECT_EQ(false, result);
   free(buffer);
 }
 
-
 TEST_CASE(SerializeNull) {
   StackZone zone(thread);
 
   // Write snapshot with object content.
   const Object& null_object = Object::Handle();
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(null_object);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   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;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kNull, root->type);
   CheckEncodeDecodeMessage(root);
 }
 
-
 TEST_CASE(SerializeSmi1) {
   StackZone zone(thread);
 
   // Write snapshot with object content.
   const Smi& smi = Smi::Handle(Smi::New(124));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(smi);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   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;
   ApiMessageReader api_reader(buffer, buffer_len);
   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) {
   StackZone zone(thread);
 
   // Write snapshot with object content.
   const Smi& smi = Smi::Handle(Smi::New(-1));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(smi);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   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;
   ApiMessageReader api_reader(buffer, buffer_len);
   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;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(mint);
   intptr_t buffer_len = writer.BytesWritten();
 
   {
     // Switch to a regular zone, where VM handle allocation is allowed.
     Thread* thread = Thread::Current();
     StackZone zone(thread);
     // Read object back from the snapshot.
     MessageSnapshotReader reader(buffer, buffer_len, thread);
     const Object& serialized_object = Object::Handle(reader.ReadObject());
     EXPECT(serialized_object.IsMint());
   }
 
   // Read object back from the snapshot into a C structure.
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   CheckEncodeDecodeMessage(root);
   return root;
 }
 
-
 void CheckMint(int64_t value) {
   ApiNativeScope scope;
   StackZone zone(Thread::Current());
 
   Mint& mint = Mint::Handle();
   mint ^= Integer::New(value);
   Dart_CObject* mint_cobject = SerializeAndDeserializeMint(mint);
 // On 64-bit platforms mints always require 64-bits as the smi range
 // here covers most of the 64-bit range. On 32-bit platforms the smi
 // range covers most of the 32-bit range and values outside that
 // range are also represented as mints.
 #if defined(ARCH_IS_64_BIT)
   EXPECT_EQ(Dart_CObject_kInt64, mint_cobject->type);
   EXPECT_EQ(value, mint_cobject->value.as_int64);
 #else
   if (kMinInt32 < value && value < kMaxInt32) {
     EXPECT_EQ(Dart_CObject_kInt32, mint_cobject->type);
     EXPECT_EQ(value, mint_cobject->value.as_int32);
   } else {
     EXPECT_EQ(Dart_CObject_kInt64, mint_cobject->type);
     EXPECT_EQ(value, mint_cobject->value.as_int64);
   }
 #endif
 }
 
-
 TEST_CASE(SerializeMints) {
   // Min positive mint.
   CheckMint(Smi::kMaxValue + 1);
   // Min positive mint + 1.
   CheckMint(Smi::kMaxValue + 2);
   // Max negative mint.
   CheckMint(Smi::kMinValue - 1);
   // Max negative mint - 1.
   CheckMint(Smi::kMinValue - 2);
   // Max positive mint.
   CheckMint(kMaxInt64);
   // Max positive mint - 1.
   CheckMint(kMaxInt64 - 1);
   // Min negative mint.
   CheckMint(kMinInt64);
   // Min negative mint + 1.
   CheckMint(kMinInt64 + 1);
 }
 
-
 TEST_CASE(SerializeDouble) {
   StackZone zone(thread);
 
   // Write snapshot with object content.
   const Double& dbl = Double::Handle(Double::New(101.29));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(dbl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   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;
   ApiMessageReader api_reader(buffer, buffer_len);
   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(SerializeTrue) {
   StackZone zone(thread);
 
   // Write snapshot with true object.
   const Bool& bl = Bool::True();
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(bl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   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;
   ApiMessageReader api_reader(buffer, buffer_len);
   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) {
   StackZone zone(thread);
 
   // Write snapshot with false object.
   const Bool& bl = Bool::False();
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(bl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   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;
   ApiMessageReader api_reader(buffer, buffer_len);
   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);
 }
 
-
 TEST_CASE(SerializeCapability) {
   // Write snapshot with object content.
   const Capability& capability = Capability::Handle(Capability::New(12345));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(capability);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   Capability& obj = Capability::Handle();
   obj ^= reader.ReadObject();
 
   EXPECT_STREQ(12345, obj.Id());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kCapability, root->type);
   int64_t id = root->value.as_capability.id;
   EXPECT_EQ(12345, id);
   CheckEncodeDecodeMessage(root);
 }
 
-
 TEST_CASE(SerializeBigint) {
   // Write snapshot with object content.
   const char* cstr = "0x270FFFFFFFFFFFFFD8F0";
   const String& str = String::Handle(String::New(cstr));
   Bigint& bigint = Bigint::Handle();
   bigint ^= Integer::NewCanonical(str);
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(bigint);
   intptr_t buffer_len = writer.BytesWritten();
@@ skipping 11 matching lines @@
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kBigint, root->type);
   char* hex_value = TestCase::BigintToHexValue(root);
   EXPECT_STREQ(cstr, hex_value);
   free(hex_value);
   CheckEncodeDecodeMessage(root);
 }
 
-
 Dart_CObject* SerializeAndDeserializeBigint(const Bigint& bigint) {
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(bigint);
   intptr_t buffer_len = writer.BytesWritten();
 
   {
     // Switch to a regular zone, where VM handle allocation is allowed.
     Thread* thread = Thread::Current();
     StackZone zone(thread);
     // Read object back from the snapshot.
     MessageSnapshotReader reader(buffer, buffer_len, thread);
     Bigint& serialized_bigint = Bigint::Handle();
     serialized_bigint ^= reader.ReadObject();
     const char* str1 = bigint.ToHexCString(thread->zone());
     const char* str2 = serialized_bigint.ToHexCString(thread->zone());
     EXPECT_STREQ(str1, str2);
   }
 
   // Read object back from the snapshot into a C structure.
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   // Bigint not supported.
   EXPECT_NOTNULL(root);
   CheckEncodeDecodeMessage(root);
   return root;
 }
 
-
 void CheckBigint(const char* bigint_value) {
   ApiNativeScope scope;
   StackZone zone(Thread::Current());
   Bigint& bigint = Bigint::Handle();
   bigint ^= Bigint::NewFromCString(bigint_value);
   Dart_CObject* bigint_cobject = SerializeAndDeserializeBigint(bigint);
   EXPECT_EQ(Dart_CObject_kBigint, bigint_cobject->type);
   char* hex_value = TestCase::BigintToHexValue(bigint_cobject);
   EXPECT_STREQ(bigint_value, hex_value);
   free(hex_value);
 }
 
-
 TEST_CASE(SerializeBigint2) {
   CheckBigint("0x0");
   CheckBigint("0x1");
   CheckBigint("-0x1");
   CheckBigint("0x11111111111111111111");
   CheckBigint("-0x11111111111111111111");
   CheckBigint("0x9876543210987654321098765432109876543210");
   CheckBigint("-0x9876543210987654321098765432109876543210");
 }
 
@@ skipping 28 matching lines @@
   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);
 }
 
-
 static void TestString(const char* cstr) {
   Thread* thread = Thread::Current();
   EXPECT(Utf8::IsValid(reinterpret_cast<const uint8_t*>(cstr), strlen(cstr)));
   // Write snapshot with object content.
   String& str = String::Handle(String::New(cstr));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(str);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   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;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kString, root->type);
   EXPECT_STREQ(cstr, root->value.as_string);
   CheckEncodeDecodeMessage(root);
 }
 
-
 TEST_CASE(SerializeString) {
   TestString("This string shall be serialized");
   TestString("æøå");  // This file is UTF-8 encoded.
   const char* data =
       "\x01"
       "\x7F"
       "\xC2\x80"       // U+0080
       "\xDF\xBF"       // U+07FF
       "\xE0\xA0\x80"   // U+0800
       "\xEF\xBF\xBF";  // U+FFFF
 
   TestString(data);
   // TODO(sgjesse): Add tests with non-BMP characters.
 }
 
-
 TEST_CASE(SerializeArray) {
   // Write snapshot with object content.
   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);
   }
   uint8_t* buffer;
@@ skipping 14 matching lines @@
   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(FailSerializeLargeArray) {
   Dart_CObject root;
   root.type = Dart_CObject_kArray;
   root.value.as_array.length = Array::kMaxElements + 1;
   root.value.as_array.values = NULL;
   ExpectEncodeFail(&root);
 }
 
-
 TEST_CASE(FailSerializeLargeNestedArray) {
   Dart_CObject parent;
   Dart_CObject child;
   Dart_CObject* values[1] = {&child};
 
   parent.type = Dart_CObject_kArray;
   parent.value.as_array.length = 1;
   parent.value.as_array.values = values;
   child.type = Dart_CObject_kArray;
   child.value.as_array.length = Array::kMaxElements + 1;
   ExpectEncodeFail(&parent);
 }
 
-
 TEST_CASE(FailSerializeLargeTypedDataInt8) {
   Dart_CObject root;
   root.type = Dart_CObject_kTypedData;
   root.value.as_typed_data.type = Dart_TypedData_kInt8;
   root.value.as_typed_data.length =
       TypedData::MaxElements(kTypedDataInt8ArrayCid) + 1;
   ExpectEncodeFail(&root);
 }
 
-
 TEST_CASE(FailSerializeLargeTypedDataUint8) {
   Dart_CObject root;
   root.type = Dart_CObject_kTypedData;
   root.value.as_typed_data.type = Dart_TypedData_kUint8;
   root.value.as_typed_data.length =
       TypedData::MaxElements(kTypedDataUint8ArrayCid) + 1;
   ExpectEncodeFail(&root);
 }
 
-
 TEST_CASE(FailSerializeLargeExternalTypedData) {
   Dart_CObject root;
   root.type = Dart_CObject_kExternalTypedData;
   root.value.as_typed_data.length =
       ExternalTypedData::MaxElements(kExternalTypedDataUint8ArrayCid) + 1;
   ExpectEncodeFail(&root);
 }
 
-
 TEST_CASE(SerializeEmptyArray) {
   // Write snapshot with object content.
   const int kArrayLength = 0;
   Array& array = Array::Handle(Array::New(kArrayLength));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(array);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   Array& serialized_array = Array::Handle();
   serialized_array ^= reader.ReadObject();
   EXPECT(array.CanonicalizeEquals(serialized_array));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   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) {
   // Write snapshot with object content.
   const int kTypedDataLength = 256;
   TypedData& typed_data = TypedData::Handle(
       TypedData::New(kTypedDataUint8ArrayCid, kTypedDataLength));
   for (int i = 0; i < kTypedDataLength; i++) {
     typed_data.SetUint8(i, i);
   }
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
@@ skipping 11 matching lines @@
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kTypedData, root->type);
   EXPECT_EQ(kTypedDataLength, root->value.as_typed_data.length);
   for (int i = 0; i < kTypedDataLength; i++) {
     EXPECT(root->value.as_typed_data.values[i] == i);
   }
   CheckEncodeDecodeMessage(root);
 }
 
-
 #define TEST_TYPED_ARRAY(darttype, ctype)                                      \
   {                                                                            \
     StackZone zone(thread);                                                    \
     const int kArrayLength = 127;                                              \
     TypedData& array = TypedData::Handle(                                      \
         TypedData::New(kTypedData##darttype##ArrayCid, kArrayLength));         \
     intptr_t scale = array.ElementSizeInBytes();                               \
     for (int i = 0; i < kArrayLength; i++) {                                   \
       array.Set##darttype((i * scale), i);                                     \
     }                                                                          \
     uint8_t* buffer;                                                           \
     MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);   \
     writer.WriteMessage(array);                                                \
     intptr_t buffer_len = writer.BytesWritten();                               \
     MessageSnapshotReader reader(buffer, buffer_len, thread);                  \
     TypedData& serialized_array = TypedData::Handle();                         \
     serialized_array ^= reader.ReadObject();                                   \
     for (int i = 0; i < kArrayLength; i++) {                                   \
       EXPECT_EQ(static_cast<ctype>(i),                                         \
                 serialized_array.Get##darttype(i* scale));                     \
     }                                                                          \
   }
 
-
 #define TEST_EXTERNAL_TYPED_ARRAY(darttype, ctype)                             \
   {                                                                            \
     StackZone zone(thread);                                                    \
     ctype data[] = {0, 11, 22, 33, 44, 55, 66, 77};                            \
     intptr_t length = ARRAY_SIZE(data);                                        \
     ExternalTypedData& array = ExternalTypedData::Handle(                      \
         ExternalTypedData::New(kExternalTypedData##darttype##ArrayCid,         \
                                reinterpret_cast<uint8_t*>(data), length));     \
     intptr_t scale = array.ElementSizeInBytes();                               \
     uint8_t* buffer;                                                           \
     MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);   \
     writer.WriteMessage(array);                                                \
     intptr_t buffer_len = writer.BytesWritten();                               \
     MessageSnapshotReader reader(buffer, buffer_len, thread);                  \
     TypedData& serialized_array = TypedData::Handle();                         \
     serialized_array ^= reader.ReadObject();                                   \
     for (int i = 0; i < length; i++) {                                         \
       EXPECT_EQ(static_cast<ctype>(data[i]),                                   \
                 serialized_array.Get##darttype(i* scale));                     \
     }                                                                          \
   }
 
-
 TEST_CASE(SerializeTypedArray) {
   TEST_TYPED_ARRAY(Int8, int8_t);
   TEST_TYPED_ARRAY(Uint8, uint8_t);
   TEST_TYPED_ARRAY(Int16, int16_t);
   TEST_TYPED_ARRAY(Uint16, uint16_t);
   TEST_TYPED_ARRAY(Int32, int32_t);
   TEST_TYPED_ARRAY(Uint32, uint32_t);
   TEST_TYPED_ARRAY(Int64, int64_t);
   TEST_TYPED_ARRAY(Uint64, uint64_t);
   TEST_TYPED_ARRAY(Float32, float);
   TEST_TYPED_ARRAY(Float64, double);
 }
 
-
 TEST_CASE(SerializeExternalTypedArray) {
   TEST_EXTERNAL_TYPED_ARRAY(Int8, int8_t);
   TEST_EXTERNAL_TYPED_ARRAY(Uint8, uint8_t);
   TEST_EXTERNAL_TYPED_ARRAY(Int16, int16_t);
   TEST_EXTERNAL_TYPED_ARRAY(Uint16, uint16_t);
   TEST_EXTERNAL_TYPED_ARRAY(Int32, int32_t);
   TEST_EXTERNAL_TYPED_ARRAY(Uint32, uint32_t);
   TEST_EXTERNAL_TYPED_ARRAY(Int64, int64_t);
   TEST_EXTERNAL_TYPED_ARRAY(Uint64, uint64_t);
   TEST_EXTERNAL_TYPED_ARRAY(Float32, float);
   TEST_EXTERNAL_TYPED_ARRAY(Float64, double);
 }
 
-
 TEST_CASE(SerializeEmptyByteArray) {
   // Write snapshot with object content.
   const int kTypedDataLength = 0;
   TypedData& typed_data = TypedData::Handle(
       TypedData::New(kTypedDataUint8ArrayCid, kTypedDataLength));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteMessage(typed_data);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
   MessageSnapshotReader reader(buffer, buffer_len, thread);
   TypedData& serialized_typed_data = TypedData::Handle();
   serialized_typed_data ^= reader.ReadObject();
   EXPECT(serialized_typed_data.IsTypedData());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kTypedData, root->type);
   EXPECT_EQ(Dart_TypedData_kUint8, root->value.as_typed_data.type);
   EXPECT_EQ(kTypedDataLength, root->value.as_typed_data.length);
   EXPECT(root->value.as_typed_data.values == NULL);
   CheckEncodeDecodeMessage(root);
 }
 
-
 class TestSnapshotWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
   TestSnapshotWriter(uint8_t** buffer, ReAlloc alloc)
       : SnapshotWriter(Thread::Current(),
                        Snapshot::kScript,
                        buffer,
                        alloc,
                        NULL,
                        kInitialSize,
                        &forward_list_,
                        true /* can_send_any_object */),
         forward_list_(thread(), kMaxPredefinedObjectIds) {
     ASSERT(buffer != NULL);
     ASSERT(alloc != NULL);
   }
   ~TestSnapshotWriter() {}
 
   // Writes just a script object
   void WriteScript(const Script& script) { WriteObject(script.raw()); }
 
  private:
   ForwardList forward_list_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSnapshotWriter);
 };
 
-
 static void GenerateSourceAndCheck(const Script& script) {
   // Check if we are able to generate the source from the token stream.
   // Rescan this source and compare the token stream to see if they are
   // the same.
   Zone* zone = Thread::Current()->zone();
   const TokenStream& expected_tokens =
       TokenStream::Handle(zone, script.tokens());
   TokenStream::Iterator expected_iterator(zone, expected_tokens,
                                           TokenPosition::kMinSource,
                                           TokenStream::Iterator::kAllTokens);
@@ skipping 15 matching lines @@
     expected_literal ^= expected_iterator.CurrentLiteral();
     actual_literal ^= reconstructed_iterator.CurrentLiteral();
     EXPECT_STREQ(expected_literal.ToCString(), actual_literal.ToCString());
     expected_iterator.Advance();
     reconstructed_iterator.Advance();
     expected_kind = expected_iterator.CurrentTokenKind();
     reconstructed_kind = reconstructed_iterator.CurrentTokenKind();
   }
 }
 
-
 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"
       "  static ms1() {\n"
@@ skipping 85 matching lines @@
   }
 
   // Check if we are able to generate the source from the token stream.
   // Rescan this source and compare the token stream to see if they are
   // the same.
   GenerateSourceAndCheck(serialized_script);
 
   free(buffer);
 }
 
-
 #if !defined(PRODUCT)  // Uses mirrors.
 VM_UNIT_TEST_CASE(CanonicalizationInScriptSnapshots) {
   const char* kScriptChars =
       "\n"
       "import 'dart:mirrors';"
       "import 'dart:isolate';"
       "void main() {"
       "  if (reflectClass(MyException).superclass.reflectedType != "
       "      IsolateSpawnException) {"
       "    throw new Exception('Canonicalization failure');"
@@ skipping 86 matching lines @@
     result = Dart_Invoke(result, NewString("main"), 0, NULL);
     EXPECT_VALID(result);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
   }
   free(script_snapshot);
   free(full_snapshot);
 }
 #endif
 
-
 VM_UNIT_TEST_CASE(ScriptSnapshotsUpdateSubclasses) {
   const char* kScriptChars =
       "class _DebugDuration extends Duration {\n"
       "  const _DebugDuration() : super(milliseconds: 42);\n"
       "}\n"
       "foo(x, y) {\n"
       "  for (var i = 0; i < 1000000; i++) {\n"
       "    if (x != y) {\n"
       "      throw 'Boom!';\n"
       "    }\n"
@@ skipping 93 matching lines @@
   }
   free(script_snapshot);
   free(full_snapshot);
 
   FLAG_max_polymorphic_checks = saved_max_polymorphic_checks;
 #if !defined(PRODUCT)
   FLAG_load_deferred_eagerly = saved_load_deferred_eagerly_mode;
 #endif
 }
 
-
 static void IterateScripts(const Library& lib) {
   const Array& lib_scripts = Array::Handle(lib.LoadedScripts());
   Script& script = Script::Handle();
   String& uri = String::Handle();
   for (intptr_t i = 0; i < lib_scripts.Length(); i++) {
     script ^= lib_scripts.At(i);
     EXPECT(!script.IsNull());
     uri = script.url();
     OS::Print("Generating source for part: %s\n", uri.ToCString());
     GenerateSourceAndCheck(script);
@@ skipping 17 matching lines @@
     EXPECT(!lib.IsNull());
     uri = lib.url();
     OS::Print("Generating source for library: %s\n", uri.ToCString());
     IterateScripts(lib);
   }
 
   MallocHooks::set_stack_trace_collection_enabled(
       stack_trace_collection_enabled);
 }
 
-
 VM_UNIT_TEST_CASE(FullSnapshot) {
   const char* kScriptChars =
       "class Fields  {\n"
       "  Fields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  final int bigint_fld = 0xfffffffffff;\n"
       "  static int fld3;\n"
       "  static const int smi_sfld = 10;\n"
       "  static const int bigint_sfld = 0xfffffffffff;\n"
@@ skipping 53 matching lines @@
     // Invoke a function which returns an object.
     Dart_Handle cls = Dart_GetClass(TestCase::lib(), NewString("FieldsTest"));
     result = Dart_Invoke(cls, NewString("testMain"), 0, NULL);
     EXPECT_VALID(result);
     Dart_ExitScope();
   }
   Dart_ShutdownIsolate();
   free(isolate_snapshot_data_buffer);
 }
 
-
 VM_UNIT_TEST_CASE(FullSnapshot1) {
   // This buffer has to be static for this to compile with Visual Studio.
   // If it is not static compilation of this file with Visual Studio takes
   // more than 30 minutes!
   static const char kFullSnapshotScriptChars[] = {
 #include "snapshot_test.dat"
   };
   const char* kScriptChars = kFullSnapshotScriptChars;
 
   uint8_t* isolate_snapshot_data_buffer;
@@ skipping 45 matching lines @@
       // Print the error.  It is probably an unhandled exception.
       fprintf(stderr, "%s\n", Dart_GetError(result));
     }
     EXPECT_VALID(result);
     Dart_ExitScope();
   }
   Dart_ShutdownIsolate();
   free(isolate_snapshot_data_buffer);
 }
 
-
 #ifndef PRODUCT
 
-
 VM_UNIT_TEST_CASE(ScriptSnapshot) {
   const char* kLibScriptChars =
       "library dart_import_lib;"
       "class LibFields  {"
       "  LibFields(int i, int j) : fld1 = i, fld2 = j {}"
       "  int fld1;"
       "  final int fld2;"
       "}";
   const char* kScriptChars =
       "class TestTrace implements StackTrace {"
@@ skipping 114 matching lines @@
     Dart_Handle cls = Dart_GetClass(result, NewString("FieldsTest"));
     result = Dart_Invoke(cls, NewString("testMain"), 0, NULL);
     EXPECT_VALID(result);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
   }
   free(full_snapshot);
   free(script_snapshot);
 }
 
-
 VM_UNIT_TEST_CASE(ScriptSnapshot1) {
   const char* kScriptChars =
       "class _SimpleNumEnumerable<T extends num> {"
       "final Iterable<T> _source;"
       "const _SimpleNumEnumerable(this._source) : super();"
       "}";
 
   Dart_Handle result;
   uint8_t* buffer;
   intptr_t size;
@@ skipping 52 matching lines @@
     EXPECT_VALID(result);
     Dart_ExitScope();
   }
 
   FLAG_load_deferred_eagerly = saved_load_deferred_eagerly_mode;
   Dart_ShutdownIsolate();
   free(full_snapshot);
   free(script_snapshot);
 }
 
-
 VM_UNIT_TEST_CASE(ScriptSnapshot2) {
   // The snapshot of this library is always created in production mode, but
   // loaded and executed in both production and checked modes.
   // This test verifies that type information is still contained in the snapshot
   // although it was created in production mode and that type errors and
   // compilation errors (for const fields) are correctly reported according to
   // the execution mode.
   const char* kLibScriptChars =
       "library dart_import_lib;"
       "const String s = 1.0;"
@@ skipping 95 matching lines @@
     // Invoke the test_b function.
     result = Dart_Invoke(lib, NewString("test_b"), 0, NULL);
     EXPECT(Dart_IsError(result) == saved_enable_type_checks_mode);
     Dart_ExitScope();
   }
   Dart_ShutdownIsolate();
   free(full_snapshot);
   free(script_snapshot);
 }
 
-
 VM_UNIT_TEST_CASE(MismatchedSnapshotKinds) {
   const char* kScriptChars = "main() { print('Hello, world!'); }";
   Dart_Handle result;
 
   uint8_t* buffer;
   intptr_t size;
   intptr_t vm_isolate_snapshot_size;
   uint8_t* isolate_snapshot = NULL;
   intptr_t isolate_snapshot_size;
   uint8_t* full_snapshot = NULL;
@@ skipping 63 matching lines @@
                  "Dart_LoadScriptFromSnapshot expects parameter"
                  " 'buffer' to be a script type snapshot.");
 
     Dart_ExitScope();
   }
   Dart_ShutdownIsolate();
   free(full_snapshot);
   free(script_snapshot);
 }
 
-
 #endif  // !PRODUCT
 
-
 TEST_CASE(IntArrayMessage) {
   StackZone zone(Thread::Current());
   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;
   ApiMessageReader api_reader(buffer, writer.BytesWritten());
   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 and serialize the result.
 static uint8_t* GetSerialized(Dart_Handle lib,
                               const char* dart_function,
                               intptr_t* buffer_len) {
   Dart_Handle result;
   result = Dart_Invoke(lib, NewString(dart_function), 0, NULL);
   EXPECT_VALID(result);
   Object& obj = Object::Handle(Api::UnwrapHandle(result));
 
   // Serialize the object into a message.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, false);
   writer.WriteMessage(obj);
   *buffer_len = writer.BytesWritten();
   return buffer;
 }
 
-
 // Helper function to deserialize the result into a Dart_CObject structure.
 static Dart_CObject* GetDeserialized(uint8_t* buffer, intptr_t buffer_len) {
   // Read object back from the snapshot into a C structure.
   ApiMessageReader api_reader(buffer, buffer_len);
   return api_reader.ReadMessage();
 }
 
-
 static void CheckString(Dart_Handle dart_string, const char* expected) {
   StackZone zone(Thread::Current());
   String& str = String::Handle();
   str ^= Api::UnwrapHandle(dart_string);
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, false);
   writer.WriteMessage(str);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kString, root->type);
   EXPECT_STREQ(expected, root->value.as_string);
   CheckEncodeDecodeMessage(root);
 }
 
-
 static void CheckStringInvalid(Dart_Handle dart_string) {
   StackZone zone(Thread::Current());
   String& str = String::Handle();
   str ^= Api::UnwrapHandle(dart_string);
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, false);
   writer.WriteMessage(str);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kUnsupported, root->type);
 }
 
-
 VM_UNIT_TEST_CASE(DartGeneratedMessages) {
   static const char* kCustomIsolateScriptChars =
       "getSmi() {\n"
       "  return 42;\n"
       "}\n"
       "getBigint() {\n"
       "  return -0x424242424242424242424242424242424242;\n"
       "}\n"
       "getAsciiString() {\n"
       "  return \"Hello, world!\";\n"
@@ skipping 127 matching lines @@
                 "\xf0\xa0\x80\x80");
     CheckStringInvalid(lead_surrogate_string_result);
     CheckStringInvalid(trail_surrogate_string_result);
     CheckStringInvalid(crappy_string_result);
     CheckStringInvalid(surrogates_string_result);
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
-
 VM_UNIT_TEST_CASE(DartGeneratedListMessages) {
   const int kArrayLength = 10;
   static const char* kScriptChars =
       "final int kArrayLength = 10;\n"
       "getList() {\n"
       "  return new List(kArrayLength);\n"
       "}\n"
       "getIntList() {\n"
       "  var list = new List<int>(kArrayLength);\n"
       "  for (var i = 0; i < kArrayLength; i++) list[i] = i;\n"
@@ skipping 90 matching lines @@
         if (i > 3) {
           EXPECT_EQ(Dart_CObject_kNull, root->value.as_array.values[i]->type);
         }
       }
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
-
 VM_UNIT_TEST_CASE(DartGeneratedArrayLiteralMessages) {
   const int kArrayLength = 10;
   static const char* kScriptChars =
       "final int kArrayLength = 10;\n"
       "getList() {\n"
       "  return [null, null, null, null, null, null, null, null, null, null];\n"
       "}\n"
       "getIntList() {\n"
       "  return [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n"
       "}\n"
@@ skipping 200 matching lines @@
         e = element->value.as_array.values[i];
         EXPECT_EQ(Dart_CObject_kInt32, e->type);
         EXPECT_EQ(i + 1, e->value.as_int32);
       }
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
-
 VM_UNIT_TEST_CASE(DartGeneratedListMessagesWithBackref) {
   const int kArrayLength = 10;
   static const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "final int kArrayLength = 10;\n"
       "getStringList() {\n"
       "  var s = 'Hello, world!';\n"
       "  var list = new List<String>(kArrayLength);\n"
       "  for (var i = 0; i < kArrayLength; i++) list[i] = s;\n"
       "  return list;\n"
@@ skipping 199 matching lines @@
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(Dart_CObject_kArray, element->type);
         EXPECT_EQ(root, element);
       }
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
-
 VM_UNIT_TEST_CASE(DartGeneratedArrayLiteralMessagesWithBackref) {
   const int kArrayLength = 10;
   static const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "final int kArrayLength = 10;\n"
       "getStringList() {\n"
       "  var s = 'Hello, world!';\n"
       "  var list = [s, s, s, s, s, s, s, s, s, s];\n"
       "  return list;\n"
       "}\n"
@@ skipping 206 matching lines @@
         Dart_CObject* element = root->value.as_array.values[i];
         EXPECT_EQ(Dart_CObject_kArray, element->type);
         EXPECT_EQ(root, element);
       }
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
-
 static void CheckTypedData(Dart_CObject* object,
                            Dart_TypedData_Type typed_data_type,
                            int len) {
   EXPECT_EQ(Dart_CObject_kTypedData, object->type);
   EXPECT_EQ(typed_data_type, object->value.as_typed_data.type);
   EXPECT_EQ(len, object->value.as_typed_data.length);
 }
 
 VM_UNIT_TEST_CASE(DartGeneratedListMessagesWithTypedData) {
   static const char* kScriptChars =
@@ skipping 174 matching lines @@
                   root->value.as_array.values[i]->value.as_typed_data.values);
         i++;
       }
       EXPECT_EQ(i, root->value.as_array.length);
     }
   }
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
-
 VM_UNIT_TEST_CASE(PostCObject) {
   // Create a native port for posting from C to Dart
   TestIsolateScope __test_isolate__;
   const char* kScriptChars =
       "import 'dart:isolate';\n"
       "main() {\n"
       "  var messageCount = 0;\n"
       "  var exception = '';\n"
       "  var port = new RawReceivePort();\n"
       "  var sendPort = port.sendPort;\n"
@@ skipping 75 matching lines @@
 
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: nulltruefalse123456æøå3.14[]100123456789\n",
                    Dart_GetError(result));
 
   Dart_ExitScope();
 }
 
-
 TEST_CASE(OmittedObjectEncodingLength) {
   StackZone zone(Thread::Current());
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
   writer.WriteInlinedObjectHeader(kOmittedObjectId);
   // For performance, we'd like single-byte headers when ids are omitted.
   // If this starts failing, consider renumbering the snapshot ids.
   EXPECT_EQ(1, writer.BytesWritten());
 }
 
 }  // namespace dart