clang-format runtime/vm

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) {
+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) {
+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);
 }
 
 
 // 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.
@@ skipping 180 matching lines @@
 }
 
 
 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.
+// 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);
@@ skipping 275 matching lines @@
   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
+  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));
@@ skipping 33 matching lines @@
   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 };
+  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);
 }
 
 
@@ skipping 96 matching lines @@
     }                                                                          \
     uint8_t* buffer;                                                           \
     MessageWriter writer(&buffer, &zone_allocator, 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));                      \
+                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 };                          \
+    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, 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));                      \
+                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);
@@ skipping 55 matching lines @@
                        Snapshot::kScript,
                        buffer,
                        alloc,
                        kInitialSize,
                        &forward_list_,
                        true /* can_send_any_object */),
         forward_list_(thread(), kMaxPredefinedObjectIds) {
     ASSERT(buffer != NULL);
     ASSERT(alloc != NULL);
   }
-  ~TestSnapshotWriter() { }
+  ~TestSnapshotWriter() {}
 
   // Writes just a script object
-  void WriteScript(const Script& script) {
-    WriteObject(script.raw());
-  }
+  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);
+  TokenStream::Iterator expected_iterator(zone, expected_tokens,
+                                          TokenPosition::kMinSource,
+                                          TokenStream::Iterator::kAllTokens);
   const String& str = String::Handle(zone, expected_tokens.GenerateSource());
   const String& private_key =
       String::Handle(zone, expected_tokens.PrivateKey());
   const TokenStream& reconstructed_tokens =
-      TokenStream::Handle(zone, TokenStream::New(str,
-                                                 private_key,
-                                                 false));
+      TokenStream::Handle(zone, TokenStream::New(str, private_key, false));
   expected_iterator.SetCurrentPosition(TokenPosition::kMinSource);
   TokenStream::Iterator reconstructed_iterator(
-      zone,
-      reconstructed_tokens,
-      TokenPosition::kMinSource,
+      zone, reconstructed_tokens, TokenPosition::kMinSource,
       TokenStream::Iterator::kAllTokens);
   Token::Kind expected_kind = expected_iterator.CurrentTokenKind();
   Token::Kind reconstructed_kind = reconstructed_iterator.CurrentTokenKind();
   String& expected_literal = String::Handle(zone);
   String& actual_literal = String::Handle(zone);
   while (expected_kind != Token::kEOS && reconstructed_kind != Token::kEOS) {
     EXPECT_EQ(expected_kind, reconstructed_kind);
     expected_literal ^= expected_iterator.CurrentLiteral();
     actual_literal ^= reconstructed_iterator.CurrentLiteral();
     EXPECT_STREQ(expected_literal.ToCString(), actual_literal.ToCString());
@@ skipping 45 matching lines @@
       "g h i''';\n"
       "  }\n"
       "  static ms6() {\n"
       "    return '\\t \\n \\x00 \\xFF';\n"
       "  }\n"
       "}\n";
 
   Zone* zone = thread->zone();
   String& url = String::Handle(zone, String::New("dart-test:SerializeScript"));
   String& source = String::Handle(zone, String::New(kScriptChars));
-  Script& script = Script::Handle(zone, Script::New(url,
-                                                    source,
-                                                    RawScript::kScriptTag));
+  Script& script =
+      Script::Handle(zone, Script::New(url, source, RawScript::kScriptTag));
   const String& lib_url = String::Handle(zone, Symbols::New(thread, "TestLib"));
   Library& lib = Library::Handle(zone, Library::New(lib_url));
   lib.Register(thread);
   EXPECT(CompilerTest::TestCompileScript(lib, script));
 
   // Write snapshot with script content.
   uint8_t* buffer;
   TestSnapshotWriter writer(&buffer, &malloc_allocator);
   writer.WriteScript(script);
 
@@ skipping 11 matching lines @@
 
   const TokenStream& expected_tokens =
       TokenStream::Handle(zone, script.tokens());
   const TokenStream& serialized_tokens =
       TokenStream::Handle(zone, serialized_script.tokens());
   const ExternalTypedData& expected_data =
       ExternalTypedData::Handle(zone, expected_tokens.GetStream());
   const ExternalTypedData& serialized_data =
       ExternalTypedData::Handle(zone, serialized_tokens.GetStream());
   EXPECT_EQ(expected_data.Length(), serialized_data.Length());
-  TokenStream::Iterator expected_iterator(zone,
-                                          expected_tokens,
+  TokenStream::Iterator expected_iterator(zone, expected_tokens,
                                           TokenPosition::kMinSource);
-  TokenStream::Iterator serialized_iterator(zone,
-                                            serialized_tokens,
+  TokenStream::Iterator serialized_iterator(zone, serialized_tokens,
                                             TokenPosition::kMinSource);
   Token::Kind expected_kind = expected_iterator.CurrentTokenKind();
   Token::Kind serialized_kind = serialized_iterator.CurrentTokenKind();
   while (expected_kind != Token::kEOS && serialized_kind != Token::kEOS) {
     EXPECT_EQ(expected_kind, serialized_kind);
     expected_literal ^= expected_iterator.CurrentLiteral();
     actual_literal ^= serialized_iterator.CurrentLiteral();
     EXPECT(expected_literal.Equals(actual_literal));
     expected_iterator.Advance();
     serialized_iterator.Advance();
@@ skipping 40 matching lines @@
   uint8_t* script_snapshot = NULL;
 
   bool saved_load_deferred_eagerly_mode = FLAG_load_deferred_eagerly;
   FLAG_load_deferred_eagerly = true;
   {
     // Start an Isolate, and create a full snapshot of it.
     TestIsolateScope __test_isolate__;
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Write out the script snapshot.
-    result = Dart_CreateSnapshot(NULL,
-                                 &vm_isolate_snapshot_size,
-                                 &isolate_snapshot,
-                                 &isolate_snapshot_size);
+    result = Dart_CreateSnapshot(NULL, &vm_isolate_snapshot_size,
+                                 &isolate_snapshot, &isolate_snapshot_size);
     EXPECT_VALID(result);
     full_snapshot = reinterpret_cast<uint8_t*>(malloc(isolate_snapshot_size));
     memmove(full_snapshot, isolate_snapshot, isolate_snapshot_size);
     Dart_ExitScope();
   }
   FLAG_load_deferred_eagerly = saved_load_deferred_eagerly_mode;
 
   {
     // Now Create an Isolate using the full snapshot and load the
     // script  and execute it.
@@ skipping 64 matching lines @@
     EXPECT(!script.IsNull());
     uri = script.url();
     OS::Print("Generating source for part: %s\n", uri.ToCString());
     GenerateSourceAndCheck(script);
   }
 }
 
 VM_TEST_CASE(GenerateSource) {
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
-  const GrowableObjectArray& libs = GrowableObjectArray::Handle(
-      zone, isolate->object_store()->libraries());
+  const GrowableObjectArray& libs =
+      GrowableObjectArray::Handle(zone, isolate->object_store()->libraries());
   Library& lib = Library::Handle();
   String& uri = String::Handle();
   for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     EXPECT(!lib.IsNull());
     uri = lib.url();
     OS::Print("Generating source for library: %s\n", uri.ToCString());
     IterateScripts(lib);
   }
 }
@@ skipping 38 matching lines @@
     HandleScope scope(thread);
 
     // Create a test library and Load up a test script in it.
     TestCase::LoadTestScript(kScriptChars, NULL);
     EXPECT_VALID(Api::CheckAndFinalizePendingClasses(thread));
     timer1.Stop();
     OS::PrintErr("Without Snapshot: %" Pd64 "us\n", timer1.TotalElapsedTime());
 
     // Write snapshot with object content.
     {
-      FullSnapshotWriter writer(Snapshot::kCore,
-                                NULL,
-                                &isolate_snapshot_buffer,
+      FullSnapshotWriter writer(Snapshot::kCore, NULL, &isolate_snapshot_buffer,
                                 &malloc_allocator,
                                 NULL /* instructions_writer */);
       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(isolate_snapshot_buffer);
   {
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
     timer2.Stop();
     OS::PrintErr("From Snapshot: %" Pd64 "us\n", timer2.TotalElapsedTime());
 
     // Invoke a function which returns an object.
-    Dart_Handle cls =
-        Dart_GetClass(TestCase::lib(), NewString("FieldsTest"));
+    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_buffer);
 }
 
 
 UNIT_TEST_CASE(FullSnapshot1) {
@@ skipping 18 matching lines @@
     HandleScope scope(thread);
 
     // Create a test library and Load up a test script in it.
     Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
     EXPECT_VALID(Api::CheckAndFinalizePendingClasses(thread));
     timer1.Stop();
     OS::PrintErr("Without Snapshot: %" Pd64 "us\n", timer1.TotalElapsedTime());
 
     // Write snapshot with object content.
     {
-      FullSnapshotWriter writer(Snapshot::kCore,
-                                NULL,
-                                &isolate_snapshot_buffer,
+      FullSnapshotWriter writer(Snapshot::kCore, NULL, &isolate_snapshot_buffer,
                                 &malloc_allocator,
                                 NULL /* instructions_writer */);
       writer.WriteFullSnapshot();
     }
 
     // Invoke a function which returns an object.
     Dart_Handle cls = Dart_GetClass(lib, NewString("FieldsTest"));
     Dart_Handle result = Dart_Invoke(cls, NewString("testMain"), 0, NULL);
     EXPECT_VALID(result);
   }
 
   // Now Create another isolate using the snapshot and execute a method
   // from the script.
   Timer timer2(true, "Snapshot_test");
   timer2.Start();
   TestCase::CreateTestIsolateFromSnapshot(isolate_snapshot_buffer);
   {
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
     timer2.Stop();
     OS::PrintErr("From Snapshot: %" Pd64 "us\n", timer2.TotalElapsedTime());
 
     // Invoke a function which returns an object.
-    Dart_Handle cls = Dart_GetClass(TestCase::lib(),
-                                    NewString("FieldsTest"));
+    Dart_Handle cls = Dart_GetClass(TestCase::lib(), NewString("FieldsTest"));
     Dart_Handle result = Dart_Invoke(cls, NewString("testMain"), 0, NULL);
     if (Dart_IsError(result)) {
       // 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_buffer);
@@ skipping 58 matching lines @@
   intptr_t actual_num_libs;
 
   bool saved_load_deferred_eagerly_mode = FLAG_load_deferred_eagerly;
   FLAG_load_deferred_eagerly = true;
   {
     // Start an Isolate, and create a full snapshot of it.
     TestIsolateScope __test_isolate__;
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Write out the script snapshot.
-    result = Dart_CreateSnapshot(NULL,
-                                 &vm_isolate_snapshot_size,
-                                 &isolate_snapshot,
-                                 &isolate_snapshot_size);
+    result = Dart_CreateSnapshot(NULL, &vm_isolate_snapshot_size,
+                                 &isolate_snapshot, &isolate_snapshot_size);
     EXPECT_VALID(result);
     full_snapshot = reinterpret_cast<uint8_t*>(malloc(isolate_snapshot_size));
     memmove(full_snapshot, isolate_snapshot, isolate_snapshot_size);
     Dart_ExitScope();
   }
   FLAG_load_deferred_eagerly = saved_load_deferred_eagerly_mode;
 
   // Test for Dart_CreateScriptSnapshot.
   {
     // Create an Isolate using the full snapshot, load a script and create
     // a script snapshot of the script.
     TestCase::CreateTestIsolateFromSnapshot(full_snapshot);
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Load the library.
-    Dart_Handle import_lib = Dart_LoadLibrary(NewString("dart_import_lib"),
-                                              Dart_Null(),
-                                              NewString(kLibScriptChars),
-                                              0, 0);
+    Dart_Handle import_lib =
+        Dart_LoadLibrary(NewString("dart_import_lib"), Dart_Null(),
+                         NewString(kLibScriptChars), 0, 0);
     EXPECT_VALID(import_lib);
 
     // Create a test library and Load up a test script in it.
     TestCase::LoadTestScript(kScriptChars, NULL);
 
-    EXPECT_VALID(Dart_LibraryImportLibrary(TestCase::lib(),
-                                           import_lib,
-                                           Dart_Null()));
+    EXPECT_VALID(
+        Dart_LibraryImportLibrary(TestCase::lib(), import_lib, Dart_Null()));
     EXPECT_VALID(Api::CheckAndFinalizePendingClasses(Thread::Current()));
 
     // Get list of library URLs loaded and save the count.
     Dart_Handle libs = Dart_GetLibraryIds();
     EXPECT(Dart_IsList(libs));
     Dart_ListLength(libs, &expected_num_libs);
 
     // Write out the script snapshot.
     result = Dart_CreateScriptSnapshot(&buffer, &size);
     EXPECT_VALID(result);
@@ skipping 31 matching lines @@
   free(script_snapshot);
 
   // Test for Dart_CreateLibrarySnapshot.
   {
     // Create an Isolate using the full snapshot, load a script and create
     // a script snapshot of the script.
     TestCase::CreateTestIsolateFromSnapshot(full_snapshot);
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Load the library.
-    Dart_Handle lib = Dart_LoadLibrary(NewString("dart_lib"),
-                                       Dart_Null(),
-                                       NewString(kScriptChars),
-                                       0, 0);
+    Dart_Handle lib = Dart_LoadLibrary(NewString("dart_lib"), Dart_Null(),
+                                       NewString(kScriptChars), 0, 0);
     EXPECT_VALID(lib);
 
     // Write out the script snapshot.
     result = Dart_CreateLibrarySnapshot(lib, &buffer, &size);
     EXPECT_VALID(result);
     script_snapshot = reinterpret_cast<uint8_t*>(malloc(size));
     memmove(script_snapshot, buffer, size);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
   }
@@ skipping 16 matching lines @@
     Dart_ExitScope();
     Dart_ShutdownIsolate();
   }
   free(full_snapshot);
   free(script_snapshot);
 }
 
 
 UNIT_TEST_CASE(ScriptSnapshot1) {
   const char* kScriptChars =
-    "class _SimpleNumEnumerable<T extends num> {"
+      "class _SimpleNumEnumerable<T extends num> {"
       "final Iterable<T> _source;"
       "const _SimpleNumEnumerable(this._source) : super();"
-    "}";
+      "}";
 
   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;
   uint8_t* script_snapshot = NULL;
 
   bool saved_load_deferred_eagerly_mode = FLAG_load_deferred_eagerly;
   FLAG_load_deferred_eagerly = true;
   bool saved_concurrent_sweep_mode = FLAG_concurrent_sweep;
   FLAG_concurrent_sweep = false;
   {
     // Start an Isolate, and create a full snapshot of it.
     TestIsolateScope __test_isolate__;
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Write out the script snapshot.
-    result = Dart_CreateSnapshot(NULL,
-                                 &vm_isolate_snapshot_size,
-                                 &isolate_snapshot,
-                                 &isolate_snapshot_size);
+    result = Dart_CreateSnapshot(NULL, &vm_isolate_snapshot_size,
+                                 &isolate_snapshot, &isolate_snapshot_size);
     EXPECT_VALID(result);
     full_snapshot = reinterpret_cast<uint8_t*>(malloc(isolate_snapshot_size));
     memmove(full_snapshot, isolate_snapshot, isolate_snapshot_size);
     Dart_ExitScope();
   }
   FLAG_concurrent_sweep = saved_concurrent_sweep_mode;
 
   {
     // Create an Isolate using the full snapshot, load a script and create
     // a script snapshot of the script.
@@ skipping 70 matching lines @@
   bool saved_load_deferred_eagerly_mode = FLAG_load_deferred_eagerly;
   FLAG_load_deferred_eagerly = true;
   bool saved_concurrent_sweep_mode = FLAG_concurrent_sweep;
   FLAG_concurrent_sweep = false;
   {
     // Start an Isolate, and create a full snapshot of it.
     TestIsolateScope __test_isolate__;
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Write out the script snapshot.
-    result = Dart_CreateSnapshot(NULL,
-                                 &vm_isolate_snapshot_size,
-                                 &isolate_snapshot,
-                                 &isolate_snapshot_size);
+    result = Dart_CreateSnapshot(NULL, &vm_isolate_snapshot_size,
+                                 &isolate_snapshot, &isolate_snapshot_size);
     EXPECT_VALID(result);
     full_snapshot = reinterpret_cast<uint8_t*>(malloc(isolate_snapshot_size));
     memmove(full_snapshot, isolate_snapshot, isolate_snapshot_size);
     Dart_ExitScope();
   }
   FLAG_concurrent_sweep = saved_concurrent_sweep_mode;
 
   {
     // Create an Isolate using the full snapshot, load a script and create
     // a script snapshot of the script.
     TestCase::CreateTestIsolateFromSnapshot(full_snapshot);
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Load the library.
-    Dart_Handle import_lib = Dart_LoadLibrary(NewString("dart_import_lib"),
-                                              Dart_Null(),
-                                              NewString(kLibScriptChars),
-                                              0, 0);
+    Dart_Handle import_lib =
+        Dart_LoadLibrary(NewString("dart_import_lib"), Dart_Null(),
+                         NewString(kLibScriptChars), 0, 0);
     EXPECT_VALID(import_lib);
 
     // Create a test library and Load up a test script in it.
     TestCase::LoadTestScript(kScriptChars, NULL);
 
-    EXPECT_VALID(Dart_LibraryImportLibrary(TestCase::lib(),
-                                           import_lib,
-                                           Dart_Null()));
+    EXPECT_VALID(
+        Dart_LibraryImportLibrary(TestCase::lib(), import_lib, Dart_Null()));
     EXPECT_VALID(Api::CheckAndFinalizePendingClasses(Thread::Current()));
 
     // Write out the script snapshot.
     result = Dart_CreateScriptSnapshot(&buffer, &size);
     EXPECT_VALID(result);
     script_snapshot = reinterpret_cast<uint8_t*>(malloc(size));
     memmove(script_snapshot, buffer, size);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
   }
@@ skipping 155 matching lines @@
       "}\n"
       "getList() {\n"
       "  return new List(kArrayLength);\n"
       "}\n";
 
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   Dart_EnterScope();
 
-  Dart_Handle lib = TestCase::LoadTestScript(kCustomIsolateScriptChars,
-                                             NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(kCustomIsolateScriptChars, NULL);
   EXPECT_VALID(lib);
   Dart_Handle smi_result;
   smi_result = Dart_Invoke(lib, NewString("getSmi"), 0, NULL);
   EXPECT_VALID(smi_result);
   Dart_Handle bigint_result;
   bigint_result = Dart_Invoke(lib, NewString("getBigint"), 0, NULL);
   EXPECT_VALID(bigint_result);
 
   Dart_Handle ascii_string_result;
   ascii_string_result = Dart_Invoke(lib, NewString("getAsciiString"), 0, NULL);
@@ skipping 871 matching lines @@
     }
   }
   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);
+  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);
 }
 
 UNIT_TEST_CASE(DartGeneratedListMessagesWithTypedData) {
   static const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "getTypedDataList() {\n"
       "  var list = new List(10);\n"
       "  var index = 0;\n"
       "  list[index++] = new Int8List(256);\n"
       "  list[index++] = new Uint8List(256);\n"
@@ skipping 78 matching lines @@
       // Generate a list of Uint8Lists from Dart code.
       uint8_t* buf = GetSerialized(lib, "getTypedDataList", &buf_len);
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserialized(buf, buf_len);
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject_kArray, root->type);
       struct {
         Dart_TypedData_Type type;
         int size;
       } expected[] = {
-        { Dart_TypedData_kInt8, 256},
-        { Dart_TypedData_kUint8, 256},
-        { Dart_TypedData_kInt16, 512},
-        { Dart_TypedData_kUint16, 512},
-        { Dart_TypedData_kInt32, 1024},
-        { Dart_TypedData_kUint32, 1024},
-        { Dart_TypedData_kInt64, 2048},
-        { Dart_TypedData_kUint64, 2048},
-        { Dart_TypedData_kFloat32, 1024},
-        { Dart_TypedData_kFloat64, 2048},
-        { Dart_TypedData_kInvalid, -1 }
-      };
+          {Dart_TypedData_kInt8, 256},     {Dart_TypedData_kUint8, 256},
+          {Dart_TypedData_kInt16, 512},    {Dart_TypedData_kUint16, 512},
+          {Dart_TypedData_kInt32, 1024},   {Dart_TypedData_kUint32, 1024},
+          {Dart_TypedData_kInt64, 2048},   {Dart_TypedData_kUint64, 2048},
+          {Dart_TypedData_kFloat32, 1024}, {Dart_TypedData_kFloat64, 2048},
+          {Dart_TypedData_kInvalid, -1}};
 
       int i = 0;
       while (expected[i].type != Dart_TypedData_kInvalid) {
-        CheckTypedData(root->value.as_array.values[i],
-                       expected[i].type,
+        CheckTypedData(root->value.as_array.values[i], expected[i].type,
                        expected[i].size);
         i++;
       }
       EXPECT_EQ(i, root->value.as_array.length);
     }
     {
       // Generate a list of Uint8List views from Dart code.
       uint8_t* buf = GetSerialized(lib, "getTypedDataViewList", &buf_len);
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserialized(buf, buf_len);
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject_kArray, root->type);
       struct {
         Dart_TypedData_Type type;
         int size;
       } expected[] = {
-        { Dart_TypedData_kInt8, 256},
-        { Dart_TypedData_kUint8, 256},
-        { Dart_TypedData_kInt16, 512},
-        { Dart_TypedData_kUint16, 512},
-        { Dart_TypedData_kInt32, 1024},
-        { Dart_TypedData_kUint32, 1024},
-        { Dart_TypedData_kInt64, 2048},
-        { Dart_TypedData_kUint64, 2048},
-        { Dart_TypedData_kFloat32, 1024},
-        { Dart_TypedData_kFloat64, 2048},
+          {Dart_TypedData_kInt8, 256},     {Dart_TypedData_kUint8, 256},
+          {Dart_TypedData_kInt16, 512},    {Dart_TypedData_kUint16, 512},
+          {Dart_TypedData_kInt32, 1024},   {Dart_TypedData_kUint32, 1024},
+          {Dart_TypedData_kInt64, 2048},   {Dart_TypedData_kUint64, 2048},
+          {Dart_TypedData_kFloat32, 1024}, {Dart_TypedData_kFloat64, 2048},
 
-        { Dart_TypedData_kInt8, 512},
-        { Dart_TypedData_kUint8, 512},
-        { Dart_TypedData_kInt8, 1024},
-        { Dart_TypedData_kUint8, 1024},
-        { Dart_TypedData_kInt8, 2048},
-        { Dart_TypedData_kUint8, 2048},
-        { Dart_TypedData_kInt8, 1024},
-        { Dart_TypedData_kUint8, 1024},
-        { Dart_TypedData_kInt8, 2048},
-        { Dart_TypedData_kUint8, 2048},
+          {Dart_TypedData_kInt8, 512},     {Dart_TypedData_kUint8, 512},
+          {Dart_TypedData_kInt8, 1024},    {Dart_TypedData_kUint8, 1024},
+          {Dart_TypedData_kInt8, 2048},    {Dart_TypedData_kUint8, 2048},
+          {Dart_TypedData_kInt8, 1024},    {Dart_TypedData_kUint8, 1024},
+          {Dart_TypedData_kInt8, 2048},    {Dart_TypedData_kUint8, 2048},
 
-        { Dart_TypedData_kInt16, 256},
-        { Dart_TypedData_kUint16, 256},
-        { Dart_TypedData_kInt16, 1024},
-        { Dart_TypedData_kUint16, 1024},
-        { Dart_TypedData_kInt16, 2048},
-        { Dart_TypedData_kUint16, 2048},
-        { Dart_TypedData_kInt16, 1024},
-        { Dart_TypedData_kUint16, 1024},
-        { Dart_TypedData_kInt16, 2048},
-        { Dart_TypedData_kUint16, 2048},
+          {Dart_TypedData_kInt16, 256},    {Dart_TypedData_kUint16, 256},
+          {Dart_TypedData_kInt16, 1024},   {Dart_TypedData_kUint16, 1024},
+          {Dart_TypedData_kInt16, 2048},   {Dart_TypedData_kUint16, 2048},
+          {Dart_TypedData_kInt16, 1024},   {Dart_TypedData_kUint16, 1024},
+          {Dart_TypedData_kInt16, 2048},   {Dart_TypedData_kUint16, 2048},
 
-        { Dart_TypedData_kInvalid, -1 }
-      };
+          {Dart_TypedData_kInvalid, -1}};
 
       int i = 0;
       while (expected[i].type != Dart_TypedData_kInvalid) {
-        CheckTypedData(root->value.as_array.values[i],
-                       expected[i].type,
+        CheckTypedData(root->value.as_array.values[i], expected[i].type,
                        expected[i].size);
         i++;
       }
       EXPECT_EQ(i, root->value.as_array.length);
     }
     {
       // Generate a list of Uint8Lists from Dart code.
       uint8_t* buf =
           GetSerialized(lib, "getMultipleTypedDataViewList", &buf_len);
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserialized(buf, buf_len);
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject_kArray, root->type);
       struct {
         Dart_TypedData_Type type;
         int size;
       } expected[] = {
-        { Dart_TypedData_kInt8, 256},
-        { Dart_TypedData_kUint8, 256},
-        { Dart_TypedData_kInt16, 256},
-        { Dart_TypedData_kUint16, 256},
-        { Dart_TypedData_kInt32, 256},
-        { Dart_TypedData_kUint32, 256},
-        { Dart_TypedData_kInt64, 256},
-        { Dart_TypedData_kUint64, 256},
-        { Dart_TypedData_kFloat32, 256},
-        { Dart_TypedData_kFloat64, 256},
-        { Dart_TypedData_kInvalid, -1 }
-      };
+          {Dart_TypedData_kInt8, 256},    {Dart_TypedData_kUint8, 256},
+          {Dart_TypedData_kInt16, 256},   {Dart_TypedData_kUint16, 256},
+          {Dart_TypedData_kInt32, 256},   {Dart_TypedData_kUint32, 256},
+          {Dart_TypedData_kInt64, 256},   {Dart_TypedData_kUint64, 256},
+          {Dart_TypedData_kFloat32, 256}, {Dart_TypedData_kFloat64, 256},
+          {Dart_TypedData_kInvalid, -1}};
 
       int i = 0;
       while (expected[i].type != Dart_TypedData_kInvalid) {
-        CheckTypedData(root->value.as_array.values[i],
-                       expected[i].type,
+        CheckTypedData(root->value.as_array.values[i], expected[i].type,
                        expected[i].size);
 
         // All views point to the same data.
         EXPECT_EQ(root->value.as_array.values[0]->value.as_typed_data.values,
                   root->value.as_array.values[i]->value.as_typed_data.values);
         i++;
       }
       EXPECT_EQ(i, root->value.as_array.length);
     }
   }
@@ skipping 67 matching lines @@
 
   object.type = Dart_CObject_kDouble;
   object.value.as_double = 3.14;
   EXPECT(Dart_PostCObject(port_id, &object));
 
   object.type = Dart_CObject_kArray;
   object.value.as_array.length = 0;
   EXPECT(Dart_PostCObject(port_id, &object));
 
   static const int kArrayLength = 10;
-  Dart_CObject* array =
-      reinterpret_cast<Dart_CObject*>(
-          Dart_ScopeAllocate(
-              sizeof(Dart_CObject) + sizeof(Dart_CObject*) * kArrayLength));  // NOLINT
+  Dart_CObject* array = reinterpret_cast<Dart_CObject*>(Dart_ScopeAllocate(
+      sizeof(Dart_CObject) + sizeof(Dart_CObject*) * kArrayLength));  // NOLINT
   array->type = Dart_CObject_kArray;
   array->value.as_array.length = kArrayLength;
-  array->value.as_array.values =
-      reinterpret_cast<Dart_CObject**>(array + 1);
+  array->value.as_array.values = reinterpret_cast<Dart_CObject**>(array + 1);
   for (int i = 0; i < kArrayLength; i++) {
-    Dart_CObject* element =
-        reinterpret_cast<Dart_CObject*>(
-            Dart_ScopeAllocate(sizeof(Dart_CObject)));
+    Dart_CObject* element = reinterpret_cast<Dart_CObject*>(
+        Dart_ScopeAllocate(sizeof(Dart_CObject)));
     element->type = Dart_CObject_kInt32;
     element->value.as_int32 = i;
     array->value.as_array.values[i] = element;
   }
   EXPECT(Dart_PostCObject(port_id, array));
 
   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, 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