clang-format runtime/vm

runtime/vm/dart_api_impl_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 "bin/builtin.h"
 #include "vm/compiler.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 19 matching lines @@
 TEST_CASE(ErrorHandleBasics) {
   const char* kScriptChars =
       "void testMain() {\n"
       "  throw new Exception(\"bad news\");\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   Dart_Handle instance = Dart_True();
   Dart_Handle error = Api::NewError("myerror");
-  Dart_Handle exception = Dart_Invoke(lib,
-                                      NewString("testMain"),
-                                      0,
-                                      NULL);
+  Dart_Handle exception = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
 
   EXPECT_VALID(instance);
   EXPECT(Dart_IsError(error));
   EXPECT(Dart_IsError(exception));
 
   EXPECT(!Dart_ErrorHasException(instance));
   EXPECT(!Dart_ErrorHasException(error));
   EXPECT(Dart_ErrorHasException(exception));
 
   EXPECT_STREQ("", Dart_GetError(instance));
@@ skipping 36 matching lines @@
 
   Dart_Handle function_name;
   Dart_Handle script_url;
   intptr_t line_number = 0;
   intptr_t column_number = 0;
   const char* cstr = "";
 
   Dart_ActivationFrame frame;
   result = Dart_GetActivationFrame(stacktrace, 0, &frame);
   EXPECT_VALID(result);
-  result = Dart_ActivationFrameInfo(
-      frame, &function_name, &script_url, &line_number, &column_number);
+  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                    &line_number, &column_number);
   EXPECT_VALID(result);
   Dart_StringToCString(function_name, &cstr);
   EXPECT_STREQ("bar", cstr);
   Dart_StringToCString(script_url, &cstr);
   EXPECT_STREQ("test-lib", cstr);
   EXPECT_EQ(1, line_number);
   EXPECT_EQ(10, column_number);
 
   result = Dart_GetActivationFrame(stacktrace, 1, &frame);
   EXPECT_VALID(result);
-  result = Dart_ActivationFrameInfo(
-      frame, &function_name, &script_url, &line_number, &column_number);
+  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                    &line_number, &column_number);
   EXPECT_VALID(result);
   Dart_StringToCString(function_name, &cstr);
   EXPECT_STREQ("foo", cstr);
   Dart_StringToCString(script_url, &cstr);
   EXPECT_STREQ("test-lib", cstr);
   EXPECT_EQ(2, line_number);
   EXPECT_EQ(10, column_number);
 
   result = Dart_GetActivationFrame(stacktrace, 2, &frame);
   EXPECT_VALID(result);
-  result = Dart_ActivationFrameInfo(
-      frame, &function_name, &script_url, &line_number, &column_number);
+  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                    &line_number, &column_number);
   EXPECT_VALID(result);
   Dart_StringToCString(function_name, &cstr);
   EXPECT_STREQ("testMain", cstr);
   Dart_StringToCString(script_url, &cstr);
   EXPECT_STREQ("test-lib", cstr);
   EXPECT_EQ(3, line_number);
   EXPECT_EQ(15, column_number);
 
   // Out-of-bounds frames.
   result = Dart_GetActivationFrame(stacktrace, frame_count, &frame);
@@ skipping 28 matching lines @@
   Dart_Handle function_name;
   Dart_Handle script_url;
   intptr_t line_number = 0;
   intptr_t column_number = 0;
   const char* cstr = "";
 
   // Top frame at positioned at throw.
   Dart_ActivationFrame frame;
   result = Dart_GetActivationFrame(stacktrace, 0, &frame);
   EXPECT_VALID(result);
-  result = Dart_ActivationFrameInfo(
-      frame, &function_name, &script_url, &line_number, &column_number);
+  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                    &line_number, &column_number);
   EXPECT_VALID(result);
   Dart_StringToCString(function_name, &cstr);
   EXPECT_STREQ("foo", cstr);
   Dart_StringToCString(script_url, &cstr);
   EXPECT_STREQ("test-lib", cstr);
   EXPECT_EQ(1, line_number);
   EXPECT_EQ(20, column_number);
 
   // Middle frames positioned at the recursive call.
-  for (intptr_t frame_index = 1;
-       frame_index < (frame_count - 1);
+  for (intptr_t frame_index = 1; frame_index < (frame_count - 1);
        frame_index++) {
     result = Dart_GetActivationFrame(stacktrace, frame_index, &frame);
     EXPECT_VALID(result);
-    result = Dart_ActivationFrameInfo(
-        frame, &function_name, &script_url, &line_number, &column_number);
+    result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                      &line_number, &column_number);
     EXPECT_VALID(result);
     Dart_StringToCString(function_name, &cstr);
     EXPECT_STREQ("foo", cstr);
     Dart_StringToCString(script_url, &cstr);
     EXPECT_STREQ("test-lib", cstr);
     EXPECT_EQ(1, line_number);
     EXPECT_EQ(40, column_number);
   }
 
   // Bottom frame positioned at testMain().
   result = Dart_GetActivationFrame(stacktrace, frame_count - 1, &frame);
   EXPECT_VALID(result);
-  result = Dart_ActivationFrameInfo(
-      frame, &function_name, &script_url, &line_number, &column_number);
+  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                    &line_number, &column_number);
   EXPECT_VALID(result);
   Dart_StringToCString(function_name, &cstr);
   EXPECT_STREQ("testMain", cstr);
   Dart_StringToCString(script_url, &cstr);
   EXPECT_STREQ("test-lib", cstr);
   EXPECT_EQ(2, line_number);
   EXPECT_EQ(15, column_number);
 
   // Out-of-bounds frames.
   result = Dart_GetActivationFrame(stacktrace, frame_count, &frame);
@@ skipping 27 matching lines @@
   Dart_Handle function_name;
   Dart_Handle script_url;
   intptr_t line_number = 0;
   intptr_t column_number = 0;
   const char* cstr = "";
 
   // Top frame at recursive call.
   Dart_ActivationFrame frame;
   result = Dart_GetActivationFrame(stacktrace, 0, &frame);
   EXPECT_VALID(result);
-  result = Dart_ActivationFrameInfo(
-      frame, &function_name, &script_url, &line_number, &column_number);
+  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                    &line_number, &column_number);
   EXPECT_VALID(result);
   Dart_StringToCString(function_name, &cstr);
   EXPECT_STREQ("C.foo", cstr);
   Dart_StringToCString(script_url, &cstr);
   EXPECT_STREQ("test-lib", cstr);
   EXPECT_EQ(2, line_number);
   EXPECT_EQ(13, column_number);
 
   // Out-of-bounds frames.
   result = Dart_GetActivationFrame(stacktrace, frame_count, &frame);
@@ skipping 39 matching lines @@
   Dart_Handle function_name;
   Dart_Handle script_url;
   intptr_t line_number = 0;
   intptr_t column_number = 0;
   const char* cstr = "";
 
   // Top frame is inspectStack().
   Dart_ActivationFrame frame;
   result = Dart_GetActivationFrame(stacktrace, 0, &frame);
   EXPECT_VALID(result);
-  result = Dart_ActivationFrameInfo(
-      frame, &function_name, &script_url, &line_number, &column_number);
+  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                    &line_number, &column_number);
   EXPECT_VALID(result);
   Dart_StringToCString(function_name, &cstr);
   EXPECT_STREQ("inspectStack", cstr);
   Dart_StringToCString(script_url, &cstr);
   EXPECT_STREQ("test-lib", cstr);
   EXPECT_EQ(1, line_number);
   EXPECT_EQ(47, column_number);
 
   // Second frame is foo() positioned at call to inspectStack().
   result = Dart_GetActivationFrame(stacktrace, 1, &frame);
   EXPECT_VALID(result);
-  result = Dart_ActivationFrameInfo(
-      frame, &function_name, &script_url, &line_number, &column_number);
+  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                    &line_number, &column_number);
   EXPECT_VALID(result);
   Dart_StringToCString(function_name, &cstr);
   EXPECT_STREQ("foo", cstr);
   Dart_StringToCString(script_url, &cstr);
   EXPECT_STREQ("test-lib", cstr);
   EXPECT_EQ(2, line_number);
   EXPECT_EQ(20, column_number);
 
   // Middle frames positioned at the recursive call.
-  for (intptr_t frame_index = 2;
-       frame_index < (frame_count - 1);
+  for (intptr_t frame_index = 2; frame_index < (frame_count - 1);
        frame_index++) {
     result = Dart_GetActivationFrame(stacktrace, frame_index, &frame);
     EXPECT_VALID(result);
-    result = Dart_ActivationFrameInfo(
-        frame, &function_name, &script_url, &line_number, &column_number);
+    result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                      &line_number, &column_number);
     EXPECT_VALID(result);
     Dart_StringToCString(function_name, &cstr);
     EXPECT_STREQ("foo", cstr);
     Dart_StringToCString(script_url, &cstr);
     EXPECT_STREQ("test-lib", cstr);
     EXPECT_EQ(2, line_number);
     EXPECT_EQ(37, column_number);
   }
 
   // Bottom frame positioned at testMain().
   result = Dart_GetActivationFrame(stacktrace, frame_count - 1, &frame);
   EXPECT_VALID(result);
-  result = Dart_ActivationFrameInfo(
-      frame, &function_name, &script_url, &line_number, &column_number);
+  result = Dart_ActivationFrameInfo(frame, &function_name, &script_url,
+                                    &line_number, &column_number);
   EXPECT_VALID(result);
   Dart_StringToCString(function_name, &cstr);
   EXPECT_STREQ("testMain", cstr);
   Dart_StringToCString(script_url, &cstr);
   EXPECT_STREQ("test-lib", cstr);
   EXPECT_EQ(3, line_number);
   EXPECT_EQ(15, column_number);
 
   // Out-of-bounds frames.
   result = Dart_GetActivationFrame(stacktrace, frame_count, &frame);
   EXPECT(Dart_IsError(result));
   result = Dart_GetActivationFrame(stacktrace, -1, &frame);
   EXPECT(Dart_IsError(result));
 
   Dart_SetReturnValue(args, Dart_NewInteger(42));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction CurrentStackTraceNativeLookup(
-    Dart_Handle name, int argument_count, bool* auto_setup_scope) {
+    Dart_Handle name,
+    int argument_count,
+    bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&CurrentStackTraceNative);
 }
 
 
 TEST_CASE(CurrentStacktraceInfo) {
   const char* kScriptChars =
       "inspectStack() native 'CurrentStackTraceNatve';\n"
       "foo(n) => n == 1 ? inspectStack() : foo(n-1);\n"
       "testMain() => foo(50);\n";
 
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
-                                             &CurrentStackTraceNativeLookup);
+  Dart_Handle lib =
+      TestCase::LoadTestScript(kScriptChars, &CurrentStackTraceNativeLookup);
   Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(42, value);
 }
 
 
 #endif  // !PRODUCT
@@ skipping 50 matching lines @@
   EXPECT_STREQ("FatalError", Dart_GetError(fatal_error));
 }
 
 
 TEST_CASE(UnhandleExceptionError) {
   const char* exception_cstr = "";
 
   // Test with an API Error.
   const char* kApiError = "Api Error Exception Test.";
   Dart_Handle api_error = Api::NewHandle(
-      thread,
-      ApiError::New(String::Handle(String::New(kApiError))));
+      thread, ApiError::New(String::Handle(String::New(kApiError))));
   Dart_Handle exception_error = Dart_NewUnhandledExceptionError(api_error);
   EXPECT(!Dart_IsApiError(exception_error));
   EXPECT(Dart_IsUnhandledExceptionError(exception_error));
   EXPECT(Dart_IsString(Dart_ErrorGetException(exception_error)));
   EXPECT_VALID(Dart_StringToCString(Dart_ErrorGetException(exception_error),
                                     &exception_cstr));
   EXPECT_STREQ(kApiError, exception_cstr);
 
   // Test with a Compilation Error.
   const char* kCompileError = "CompileError Exception Test.";
-  const String& compile_message =
-      String::Handle(String::New(kCompileError));
+  const String& compile_message = String::Handle(String::New(kCompileError));
   Dart_Handle compile_error =
       Api::NewHandle(thread, LanguageError::New(compile_message));
   exception_error = Dart_NewUnhandledExceptionError(compile_error);
   EXPECT(!Dart_IsApiError(exception_error));
   EXPECT(Dart_IsUnhandledExceptionError(exception_error));
   EXPECT(Dart_IsString(Dart_ErrorGetException(exception_error)));
   EXPECT_VALID(Dart_StringToCString(Dart_ErrorGetException(exception_error),
                                     &exception_cstr));
   EXPECT_STREQ(kCompileError, exception_cstr);
 
@@ skipping 39 matching lines @@
     UNREACHABLE();
   } else {
     result = Dart_PropagateError(result);
     EXPECT_VALID(result);  // We do not expect to reach here.
     UNREACHABLE();
   }
 }
 
 
 static Dart_NativeFunction PropagateError_native_lookup(
-    Dart_Handle name, int argument_count, bool* auto_setup_scope) {
+    Dart_Handle name,
+    int argument_count,
+    bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&PropagateErrorNative);
 }
 
 
 TEST_CASE(Dart_PropagateError) {
   const char* kScriptChars =
       "raiseCompileError() {\n"
       "  return missing_semicolon\n"
       "}\n"
       "\n"
       "void throwException() {\n"
       "  throw new Exception('myException');\n"
       "}\n"
       "\n"
       "void nativeFunc(closure) native 'Test_nativeFunc';\n"
       "\n"
       "void Func1() {\n"
       "  nativeFunc(() => raiseCompileError());\n"
       "}\n"
       "\n"
       "void Func2() {\n"
       "  nativeFunc(() => throwException());\n"
       "}\n";
-  Dart_Handle lib = TestCase::LoadTestScript(
-      kScriptChars, &PropagateError_native_lookup);
+  Dart_Handle lib =
+      TestCase::LoadTestScript(kScriptChars, &PropagateError_native_lookup);
   Dart_Handle result;
 
   // Use Dart_PropagateError to propagate the error.
   use_throw_exception = false;
   use_set_return = false;
 
   result = Dart_Invoke(lib, NewString("Func1"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT_SUBSTRING("semicolon expected", Dart_GetError(result));
 
@@ skipping 464 matching lines @@
     EXPECT_VALID(result);
     int64_t value;
     result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(i, value);
   }
 }
 
 
 TEST_CASE(IsString) {
-  uint8_t latin1[] = { 'o', 'n', 'e', 0xC2, 0xA2 };
+  uint8_t latin1[] = {'o', 'n', 'e', 0xC2, 0xA2};
 
   Dart_Handle latin1str = Dart_NewStringFromUTF8(latin1, ARRAY_SIZE(latin1));
   EXPECT_VALID(latin1str);
   EXPECT(Dart_IsString(latin1str));
   EXPECT(Dart_IsStringLatin1(latin1str));
   EXPECT(!Dart_IsExternalString(latin1str));
   intptr_t len = -1;
   EXPECT_VALID(Dart_StringLength(latin1str, &len));
   EXPECT_EQ(4, len);
   intptr_t char_size;
   intptr_t str_len;
   void* peer;
-  EXPECT_VALID(Dart_StringGetProperties(latin1str,
-                                        &char_size,
-                                        &str_len,
-                                        &peer));
+  EXPECT_VALID(
+      Dart_StringGetProperties(latin1str, &char_size, &str_len, &peer));
   EXPECT_EQ(1, char_size);
   EXPECT_EQ(4, str_len);
   EXPECT(!peer);
 
-  uint8_t data8[] = { 'o', 'n', 'e', 0x7F };
+  uint8_t data8[] = {'o', 'n', 'e', 0x7F};
 
   Dart_Handle str8 = Dart_NewStringFromUTF8(data8, ARRAY_SIZE(data8));
   EXPECT_VALID(str8);
   EXPECT(Dart_IsString(str8));
   EXPECT(Dart_IsStringLatin1(str8));
   EXPECT(!Dart_IsExternalString(str8));
 
   uint8_t latin1_array[] = {0, 0, 0, 0, 0};
   len = 5;
   Dart_Handle result = Dart_StringToLatin1(str8, latin1_array, &len);
   EXPECT_VALID(result);
   EXPECT_EQ(4, len);
   EXPECT(latin1_array != NULL);
   for (intptr_t i = 0; i < len; i++) {
     EXPECT_EQ(data8[i], latin1_array[i]);
   }
 
-  Dart_Handle ext8 = Dart_NewExternalLatin1String(data8, ARRAY_SIZE(data8),
-                                                  data8, NULL);
+  Dart_Handle ext8 =
+      Dart_NewExternalLatin1String(data8, ARRAY_SIZE(data8), data8, NULL);
   EXPECT_VALID(ext8);
   EXPECT(Dart_IsString(ext8));
   EXPECT(Dart_IsExternalString(ext8));
-  EXPECT_VALID(Dart_StringGetProperties(ext8,
-                                        &char_size,
-                                        &str_len,
-                                        &peer));
+  EXPECT_VALID(Dart_StringGetProperties(ext8, &char_size, &str_len, &peer));
   EXPECT_EQ(1, char_size);
   EXPECT_EQ(4, str_len);
   EXPECT_EQ(data8, peer);
 
-  uint16_t data16[] = { 't', 'w', 'o', 0xFFFF };
+  uint16_t data16[] = {'t', 'w', 'o', 0xFFFF};
 
   Dart_Handle str16 = Dart_NewStringFromUTF16(data16, ARRAY_SIZE(data16));
   EXPECT_VALID(str16);
   EXPECT(Dart_IsString(str16));
   EXPECT(!Dart_IsStringLatin1(str16));
   EXPECT(!Dart_IsExternalString(str16));
-  EXPECT_VALID(Dart_StringGetProperties(str16,
-                                        &char_size,
-                                        &str_len,
-                                        &peer));
+  EXPECT_VALID(Dart_StringGetProperties(str16, &char_size, &str_len, &peer));
   EXPECT_EQ(2, char_size);
   EXPECT_EQ(4, str_len);
   EXPECT(!peer);
 
-  Dart_Handle ext16 = Dart_NewExternalUTF16String(data16, ARRAY_SIZE(data16),
-                                                  data16, NULL);
+  Dart_Handle ext16 =
+      Dart_NewExternalUTF16String(data16, ARRAY_SIZE(data16), data16, NULL);
   EXPECT_VALID(ext16);
   EXPECT(Dart_IsString(ext16));
   EXPECT(Dart_IsExternalString(ext16));
-  EXPECT_VALID(Dart_StringGetProperties(ext16,
-                                        &char_size,
-                                        &str_len,
-                                        &peer));
+  EXPECT_VALID(Dart_StringGetProperties(ext16, &char_size, &str_len, &peer));
   EXPECT_EQ(2, char_size);
   EXPECT_EQ(4, str_len);
   EXPECT_EQ(data16, peer);
 
-  int32_t data32[] = { 'f', 'o', 'u', 'r', 0x10FFFF };
+  int32_t data32[] = {'f', 'o', 'u', 'r', 0x10FFFF};
 
   Dart_Handle str32 = Dart_NewStringFromUTF32(data32, ARRAY_SIZE(data32));
   EXPECT_VALID(str32);
   EXPECT(Dart_IsString(str32));
   EXPECT(!Dart_IsExternalString(str32));
 }
 
 
 TEST_CASE(NewString) {
   const char* ascii = "string";
   Dart_Handle ascii_str = NewString(ascii);
   EXPECT_VALID(ascii_str);
   EXPECT(Dart_IsString(ascii_str));
 
   const char* null = NULL;
   Dart_Handle null_str = NewString(null);
   EXPECT(Dart_IsError(null_str));
 
-  uint8_t data[] = { 0xE4, 0xBA, 0x8c };  // U+4E8C.
+  uint8_t data[] = {0xE4, 0xBA, 0x8c};  // U+4E8C.
   Dart_Handle utf8_str = Dart_NewStringFromUTF8(data, ARRAY_SIZE(data));
   EXPECT_VALID(utf8_str);
   EXPECT(Dart_IsString(utf8_str));
 
-  uint8_t invalid[] = { 0xE4, 0xBA };  // underflow.
-  Dart_Handle invalid_str = Dart_NewStringFromUTF8(invalid,
-                                                   ARRAY_SIZE(invalid));
+  uint8_t invalid[] = {0xE4, 0xBA};  // underflow.
+  Dart_Handle invalid_str =
+      Dart_NewStringFromUTF8(invalid, ARRAY_SIZE(invalid));
   EXPECT(Dart_IsError(invalid_str));
 }
 
 
 TEST_CASE(MalformedStringToUTF8) {
   // 1D11E = treble clef
   // [0] should be high surrogate D834
   // [1] should be low surrogate DD1E
   // Strings are allowed to have individual or out of order surrogates, even
   // if that doesn't make sense as renderable characters.
@@ skipping 19 matching lines @@
   EXPECT_EQ(180, static_cast<intptr_t>(utf8_encoded[1]));
   EXPECT_EQ(158, static_cast<intptr_t>(utf8_encoded[2]));
 
   Dart_Handle str2 = Dart_NewStringFromUTF8(utf8_encoded, utf8_length);
   EXPECT_VALID(str2);  // Standalone low surrogate, but still valid
 
   Dart_Handle reversed = Dart_Invoke(lib, NewString("reversed"), 0, NULL);
   EXPECT_VALID(reversed);  // This is also allowed.
   uint8_t* utf8_encoded_reversed = NULL;
   intptr_t utf8_length_reversed = 0;
-  result = Dart_StringToUTF8(reversed,
-      &utf8_encoded_reversed, &utf8_length_reversed);
+  result = Dart_StringToUTF8(reversed, &utf8_encoded_reversed,
+                             &utf8_length_reversed);
   EXPECT_VALID(result);
   EXPECT_EQ(6, utf8_length_reversed);
   uint8_t expected[6] = {237, 180, 158, 237, 160, 180};
   for (int i = 0; i < 6; i++) {
     EXPECT_EQ(expected[i], utf8_encoded_reversed[i]);
   }
 }
 
 
 // Helper class to ensure new gen GC is triggered without any side effects.
@@ skipping 23 matching lines @@
 }
 
 
 TEST_CASE(ExternalStringCallback) {
   int peer8 = 40;
   int peer16 = 41;
 
   {
     Dart_EnterScope();
 
-    uint8_t data8[] = { 'h', 'e', 'l', 'l', 'o' };
+    uint8_t data8[] = {'h', 'e', 'l', 'l', 'o'};
     Dart_Handle obj8 = Dart_NewExternalLatin1String(
-        data8,
-        ARRAY_SIZE(data8),
-        &peer8,
-        ExternalStringCallbackFinalizer);
+        data8, ARRAY_SIZE(data8), &peer8, ExternalStringCallbackFinalizer);
     EXPECT_VALID(obj8);
 
-    uint16_t data16[] = { 'h', 'e', 'l', 'l', 'o' };
+    uint16_t data16[] = {'h', 'e', 'l', 'l', 'o'};
     Dart_Handle obj16 = Dart_NewExternalUTF16String(
-        data16,
-        ARRAY_SIZE(data16),
-        &peer16,
-        ExternalStringCallbackFinalizer);
+        data16, ARRAY_SIZE(data16), &peer16, ExternalStringCallbackFinalizer);
     EXPECT_VALID(obj16);
 
     Dart_ExitScope();
   }
 
   {
     TransitionNativeToVM transition(thread);
     EXPECT_EQ(40, peer8);
     EXPECT_EQ(41, peer16);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     GCTestHelper::WaitForGCTasks();
     EXPECT_EQ(40, peer8);
     EXPECT_EQ(41, peer16);
     Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
     GCTestHelper::WaitForGCTasks();
     EXPECT_EQ(80, peer8);
     EXPECT_EQ(82, peer16);
   }
 }
 
 
 TEST_CASE(ExternalStringPretenure) {
   {
     Dart_EnterScope();
-    static const uint8_t big_data8[16*MB] = {0, };
+    static const uint8_t big_data8[16 * MB] = {
+        0,
+    };
     Dart_Handle big8 = Dart_NewExternalLatin1String(
-        big_data8,
-        ARRAY_SIZE(big_data8),
-        NULL,
-        NULL);
+        big_data8, ARRAY_SIZE(big_data8), NULL, NULL);
     EXPECT_VALID(big8);
-    static const uint16_t big_data16[16*MB/2] = {0, };
+    static const uint16_t big_data16[16 * MB / 2] = {
+        0,
+    };
     Dart_Handle big16 = Dart_NewExternalUTF16String(
-        big_data16,
-        ARRAY_SIZE(big_data16),
-        NULL,
-        NULL);
+        big_data16, ARRAY_SIZE(big_data16), NULL, NULL);
     static const uint8_t small_data8[] = {'f', 'o', 'o'};
     Dart_Handle small8 = Dart_NewExternalLatin1String(
-        small_data8,
-        ARRAY_SIZE(small_data8),
-        NULL,
-        NULL);
+        small_data8, ARRAY_SIZE(small_data8), NULL, NULL);
     EXPECT_VALID(small8);
     static const uint16_t small_data16[] = {'b', 'a', 'r'};
     Dart_Handle small16 = Dart_NewExternalUTF16String(
-        small_data16,
-        ARRAY_SIZE(small_data16),
-        NULL,
-        NULL);
+        small_data16, ARRAY_SIZE(small_data16), NULL, NULL);
     EXPECT_VALID(small16);
     {
       CHECK_API_SCOPE(thread);
       HANDLESCOPE(thread);
       String& handle = String::Handle();
       handle ^= Api::UnwrapHandle(big8);
       EXPECT(handle.IsOld());
       handle ^= Api::UnwrapHandle(big16);
       EXPECT(handle.IsOld());
       handle ^= Api::UnwrapHandle(small8);
       EXPECT(handle.IsNew());
       handle ^= Api::UnwrapHandle(small16);
       EXPECT(handle.IsNew());
     }
     Dart_ExitScope();
   }
 }
 
 
 TEST_CASE(ExternalTypedDataPretenure) {
   {
     Dart_EnterScope();
-    static const int kBigLength = 16*MB/8;
+    static const int kBigLength = 16 * MB / 8;
     int64_t* big_data = new int64_t[kBigLength]();
-    Dart_Handle big = Dart_NewExternalTypedData(
-        Dart_TypedData_kInt64,
-        big_data,
-        kBigLength);
+    Dart_Handle big =
+        Dart_NewExternalTypedData(Dart_TypedData_kInt64, big_data, kBigLength);
     EXPECT_VALID(big);
-    static const int kSmallLength = 16*KB/8;
+    static const int kSmallLength = 16 * KB / 8;
     int64_t* small_data = new int64_t[kSmallLength]();
-    Dart_Handle small = Dart_NewExternalTypedData(
-        Dart_TypedData_kInt64,
-        small_data,
-        kSmallLength);
+    Dart_Handle small = Dart_NewExternalTypedData(Dart_TypedData_kInt64,
+                                                  small_data, kSmallLength);
     EXPECT_VALID(small);
     {
       CHECK_API_SCOPE(thread);
       HANDLESCOPE(thread);
       ExternalTypedData& handle = ExternalTypedData::Handle();
       handle ^= Api::UnwrapHandle(big);
       EXPECT(handle.IsOld());
       handle ^= Api::UnwrapHandle(small);
       EXPECT(handle.IsNew());
     }
@@ skipping 120 matching lines @@
   // Check if we can get a range of values.
   result = Dart_ListGetRange(list_access_test_obj, 8, 4, NULL);
   EXPECT(Dart_IsError(result));
   const int kRangeOffset = 1;
   const int kRangeLength = 2;
   Dart_Handle values[kRangeLength];
 
   result = Dart_ListGetRange(list_access_test_obj, 8, 4, values);
   EXPECT(Dart_IsError(result));
 
-  result = Dart_ListGetRange(
-      list_access_test_obj, kRangeOffset, kRangeLength, values);
+  result = Dart_ListGetRange(list_access_test_obj, kRangeOffset, kRangeLength,
+                             values);
   EXPECT_VALID(result);
 
   result = Dart_IntegerToInt64(values[0], &value);
   EXPECT_VALID(result);
   EXPECT_EQ(20, value);
 
   result = Dart_IntegerToInt64(values[1], &value);
   EXPECT_VALID(result);
   EXPECT_EQ(30, value);
 
@@ skipping 181 matching lines @@
   Dart_Handle dart_args[1];
   dart_args[0] = Dart_NewInteger(kSize);
   Dart_Handle view_obj = Dart_Invoke(lib, NewString("main"), 1, dart_args);
   EXPECT_VALID(view_obj);
   // Test that the API considers it a TypedData object.
   EXPECT(Dart_IsTypedData(view_obj));
 }
 
 
 TEST_CASE(TypedDataAccess) {
-  EXPECT_EQ(Dart_TypedData_kInvalid,
-            Dart_GetTypeOfTypedData(Dart_True()));
+  EXPECT_EQ(Dart_TypedData_kInvalid, Dart_GetTypeOfTypedData(Dart_True()));
   EXPECT_EQ(Dart_TypedData_kInvalid,
             Dart_GetTypeOfExternalTypedData(Dart_False()));
   Dart_Handle byte_array1 = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
   EXPECT_VALID(byte_array1);
-  EXPECT_EQ(Dart_TypedData_kUint8,
-            Dart_GetTypeOfTypedData(byte_array1));
+  EXPECT_EQ(Dart_TypedData_kUint8, Dart_GetTypeOfTypedData(byte_array1));
   EXPECT_EQ(Dart_TypedData_kInvalid,
             Dart_GetTypeOfExternalTypedData(byte_array1));
   EXPECT(Dart_IsList(byte_array1));
   EXPECT(!Dart_IsTypedData(Dart_True()));
   EXPECT(Dart_IsTypedData(byte_array1));
   EXPECT(!Dart_IsByteBuffer(byte_array1));
 
   intptr_t length = 0;
   Dart_Handle result = Dart_ListLength(byte_array1, &length);
   EXPECT_VALID(result);
@@ skipping 32 matching lines @@
   }
   for (intptr_t i = 0; i < 10; ++i) {
     // Get through the List API.
     Dart_Handle e1 = Dart_ListGetAt(byte_array1, i);
     Dart_Handle e2 = Dart_ListGetAt(byte_array2, i);
     is_equal = false;
     Dart_ObjectEquals(e1, e2, &is_equal);
     EXPECT(is_equal);
   }
 
-  uint8_t data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+  uint8_t data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   for (intptr_t i = 0; i < 10; ++i) {
     EXPECT_VALID(Dart_ListSetAt(byte_array1, i, Dart_NewInteger(10 - i)));
   }
   Dart_ListGetAsBytes(byte_array1, 0, data, 10);
   for (intptr_t i = 0; i < 10; ++i) {
     Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
     EXPECT_VALID(integer_obj);
     int64_t int64_t_value = -1;
     EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
     EXPECT_EQ(10 - i, int64_t_value);
@@ skipping 96 matching lines @@
       Dart_SetNativeResolver(lib, &ByteDataNativeResolver, NULL);
   EXPECT_VALID(result);
 
   // Invoke 'main' function.
   result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
 static const intptr_t kExtLength = 16;
-static int8_t data[kExtLength] = { 0x41, 0x42, 0x41, 0x42,
-                                   0x41, 0x42, 0x41, 0x42,
-                                   0x41, 0x42, 0x41, 0x42,
-                                   0x41, 0x42, 0x41, 0x42, };
+static int8_t data[kExtLength] = {
+    0x41, 0x42, 0x41, 0x42, 0x41, 0x42, 0x41, 0x42,
+    0x41, 0x42, 0x41, 0x42, 0x41, 0x42, 0x41, 0x42,
+};
 
 static void ExternalByteDataNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
-  Dart_Handle external_byte_data = Dart_NewExternalTypedData(
-      Dart_TypedData_kByteData, data, 16);
+  Dart_Handle external_byte_data =
+      Dart_NewExternalTypedData(Dart_TypedData_kByteData, data, 16);
   EXPECT_VALID(external_byte_data);
   EXPECT_EQ(Dart_TypedData_kByteData,
             Dart_GetTypeOfTypedData(external_byte_data));
   Dart_SetReturnValue(args, external_byte_data);
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ExternalByteDataNativeResolver(
-    Dart_Handle name, int arg_count, bool* auto_setup_scope) {
+    Dart_Handle name,
+    int arg_count,
+    bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = true;
   return &ExternalByteDataNativeFunction;
 }
 
 
 TEST_CASE(ExternalByteDataAccess) {
   // TODO(asiva): Once we have getInt16LE and getInt16BE support use the
   // appropriate getter instead of the host endian format used now.
   const char* kScriptChars =
@@ skipping 18 matching lines @@
       "    a.setInt8(i + 1, 0x28);"
       "  }"
       "  for (int i = 0; i < length; i+=2) {"
       "    Expect.equals(0x2824, a.getInt16(i, Endianness.LITTLE_ENDIAN));"
       "  }"
       "  return a;"
       "}\n";
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
-  Dart_Handle result = Dart_SetNativeResolver(lib,
-                                              &ExternalByteDataNativeResolver,
-                                              NULL);
+  Dart_Handle result =
+      Dart_SetNativeResolver(lib, &ExternalByteDataNativeResolver, NULL);
   EXPECT_VALID(result);
 
   // Invoke 'main' function.
   result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 
-  for (intptr_t i = 0; i < kExtLength; i+=2) {
+  for (intptr_t i = 0; i < kExtLength; i += 2) {
     EXPECT_EQ(0x24, data[i]);
-    EXPECT_EQ(0x28, data[i+1]);
+    EXPECT_EQ(0x28, data[i + 1]);
   }
 }
 
 
 #ifndef PRODUCT
 
 
 static const intptr_t kOptExtLength = 16;
-static int8_t opt_data[kOptExtLength] = { 0x01, 0x02, 0x03, 0x04,
-                                          0x05, 0x06, 0x07, 0x08,
-                                          0x09, 0x0a, 0x0b, 0x0c,
-                                          0x0d, 0x0e, 0x0f, 0x10, };
+static int8_t opt_data[kOptExtLength] = {
+    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+    0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+};
 
 static void OptExternalByteDataNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
-  Dart_Handle external_byte_data = Dart_NewExternalTypedData(
-      Dart_TypedData_kByteData, opt_data, 16);
+  Dart_Handle external_byte_data =
+      Dart_NewExternalTypedData(Dart_TypedData_kByteData, opt_data, 16);
   EXPECT_VALID(external_byte_data);
   EXPECT_EQ(Dart_TypedData_kByteData,
             Dart_GetTypeOfTypedData(external_byte_data));
   Dart_SetReturnValue(args, external_byte_data);
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction OptExternalByteDataNativeResolver(
-    Dart_Handle name, int arg_count, bool* auto_setup_scope) {
+    Dart_Handle name,
+    int arg_count,
+    bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = true;
   return &OptExternalByteDataNativeFunction;
 }
 
 
 TEST_CASE(OptimizedExternalByteDataAccess) {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
@@ skipping 15 matching lines @@
       "  var a = createExternalByteData();"
       "  Expect.equals(length, a.lengthInBytes);"
       "  for (int i = 0; i < 20; i++) {"
       "    access(a);"
       "  }"
       "  return a;"
       "}\n";
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
-  Dart_Handle result = Dart_SetNativeResolver(
-      lib, &OptExternalByteDataNativeResolver, NULL);
+  Dart_Handle result =
+      Dart_SetNativeResolver(lib, &OptExternalByteDataNativeResolver, NULL);
   EXPECT_VALID(result);
 
   // Invoke 'main' function.
   int old_oct = FLAG_optimization_counter_threshold;
   FLAG_optimization_counter_threshold = 5;
   result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   FLAG_optimization_counter_threshold = old_oct;
 }
 
 
 #endif  // !PRODUCT
 
 
 static void TestTypedDataDirectAccess() {
   Dart_Handle str = Dart_NewStringFromCString("junk");
   Dart_Handle byte_array = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
   EXPECT_VALID(byte_array);
   Dart_Handle result;
   result = Dart_TypedDataAcquireData(byte_array, NULL, NULL, NULL);
-  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'type'"
-                       " to be non-null.");
+  EXPECT_ERROR(result,
+               "Dart_TypedDataAcquireData expects argument 'type'"
+               " to be non-null.");
   Dart_TypedData_Type type;
   result = Dart_TypedDataAcquireData(byte_array, &type, NULL, NULL);
-  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'data'"
-                       " to be non-null.");
+  EXPECT_ERROR(result,
+               "Dart_TypedDataAcquireData expects argument 'data'"
+               " to be non-null.");
   void* data;
   result = Dart_TypedDataAcquireData(byte_array, &type, &data, NULL);
-  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'len'"
-                       " to be non-null.");
+  EXPECT_ERROR(result,
+               "Dart_TypedDataAcquireData expects argument 'len'"
+               " to be non-null.");
   intptr_t len;
   result = Dart_TypedDataAcquireData(Dart_Null(), &type, &data, &len);
-  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'object'"
-                       " to be non-null.");
+  EXPECT_ERROR(result,
+               "Dart_TypedDataAcquireData expects argument 'object'"
+               " to be non-null.");
   result = Dart_TypedDataAcquireData(str, &type, &data, &len);
-  EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'object'"
-                       " to be of type 'TypedData'.");
+  EXPECT_ERROR(result,
+               "Dart_TypedDataAcquireData expects argument 'object'"
+               " to be of type 'TypedData'.");
 
   result = Dart_TypedDataReleaseData(Dart_Null());
-  EXPECT_ERROR(result, "Dart_TypedDataReleaseData expects argument 'object'"
-                       " to be non-null.");
+  EXPECT_ERROR(result,
+               "Dart_TypedDataReleaseData expects argument 'object'"
+               " to be non-null.");
   result = Dart_TypedDataReleaseData(str);
-  EXPECT_ERROR(result, "Dart_TypedDataReleaseData expects argument 'object'"
-                       " to be of type 'TypedData'.");
+  EXPECT_ERROR(result,
+               "Dart_TypedDataReleaseData expects argument 'object'"
+               " to be of type 'TypedData'.");
 }
 
 
 TEST_CASE(TypedDataDirectAccessUnverified) {
   FLAG_verify_acquired_data = false;
   TestTypedDataDirectAccess();
 }
 
 
 TEST_CASE(TypedDataDirectAccessVerified) {
@@ skipping 81 matching lines @@
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Test with an regular typed data object.
   Dart_Handle list_access_test_obj;
   list_access_test_obj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(list_access_test_obj);
   TestDirectAccess(lib, list_access_test_obj, Dart_TypedData_kInt8, false);
 
   // Test with an external typed data object.
-  uint8_t data[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+  uint8_t data[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   intptr_t data_length = ARRAY_SIZE(data);
   Dart_Handle ext_list_access_test_obj;
-  ext_list_access_test_obj = Dart_NewExternalTypedData(Dart_TypedData_kUint8,
-                                                       data, data_length);
+  ext_list_access_test_obj =
+      Dart_NewExternalTypedData(Dart_TypedData_kUint8, data, data_length);
   EXPECT_VALID(ext_list_access_test_obj);
   TestDirectAccess(lib, ext_list_access_test_obj, Dart_TypedData_kUint8, true);
 }
 
 
 TEST_CASE(TypedDataDirectAccess1Unverified) {
   FLAG_verify_acquired_data = false;
   TestTypedDataDirectAccess1();
 }
 
@@ skipping 157 matching lines @@
     EXPECT_VALID(Dart_ListSetAt(obj, i, value));
   }
   // Read them back through the underlying array.
   for (intptr_t i = 0; i < data_length; ++i) {
     EXPECT_EQ(33 * i, data[i]);
   }
 }
 
 
 TEST_CASE(ExternalTypedDataAccess) {
-  uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
+  uint8_t data[] = {0, 11, 22, 33, 44, 55, 66, 77};
   intptr_t data_length = ARRAY_SIZE(data);
 
-  Dart_Handle obj = Dart_NewExternalTypedData(
-      Dart_TypedData_kUint8, data, data_length);
+  Dart_Handle obj =
+      Dart_NewExternalTypedData(Dart_TypedData_kUint8, data, data_length);
   ExternalTypedDataAccessTests(obj, Dart_TypedData_kUint8, data, data_length);
 }
 
 
 TEST_CASE(ExternalClampedTypedDataAccess) {
-  uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
+  uint8_t data[] = {0, 11, 22, 33, 44, 55, 66, 77};
   intptr_t data_length = ARRAY_SIZE(data);
 
-  Dart_Handle obj = Dart_NewExternalTypedData(
-      Dart_TypedData_kUint8Clamped, data, data_length);
-  ExternalTypedDataAccessTests(obj, Dart_TypedData_kUint8Clamped,
-                               data, data_length);
+  Dart_Handle obj = Dart_NewExternalTypedData(Dart_TypedData_kUint8Clamped,
+                                              data, data_length);
+  ExternalTypedDataAccessTests(obj, Dart_TypedData_kUint8Clamped, data,
+                               data_length);
 }
 
 
 TEST_CASE(ExternalUint8ClampedArrayAccess) {
-    const char* kScriptChars =
+  const char* kScriptChars =
       "testClamped(List a) {\n"
       "  if (a[1] != 11) return false;\n"
       "  a[1] = 3;\n"
       "  if (a[1] != 3) return false;\n"
       "  a[1] = -12;\n"
       "  if (a[1] != 0) return false;\n"
       "  a[1] = 1200;\n"
       "  if (a[1] != 255) return false;\n"
       "  return true;\n"
       "}\n";
 
-  uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
+  uint8_t data[] = {0, 11, 22, 33, 44, 55, 66, 77};
   intptr_t data_length = ARRAY_SIZE(data);
   Dart_Handle obj = Dart_NewExternalTypedData(Dart_TypedData_kUint8Clamped,
                                               data, data_length);
   EXPECT_VALID(obj);
   Dart_Handle result;
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle args[1];
   args[0] = obj;
   result = Dart_Invoke(lib, NewString("testClamped"), 1, args);
 
   // Check that result is true.
   EXPECT_VALID(result);
   EXPECT(Dart_IsBoolean(result));
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
 static void NopCallback(void* isolate_callback_data,
                         Dart_WeakPersistentHandle handle,
-                        void* peer) {
-}
+                        void* peer) {}
 
 
 static void UnreachedCallback(void* isolate_callback_data,
                               Dart_WeakPersistentHandle handle,
                               void* peer) {
   UNREACHABLE();
 }
 
 
 static void ExternalTypedDataFinalizer(void* isolate_callback_data,
                                        Dart_WeakPersistentHandle handle,
                                        void* peer) {
   *static_cast<int*>(peer) = 42;
 }
 
 
 TEST_CASE(ExternalTypedDataCallback) {
   int peer = 0;
   {
     Dart_EnterScope();
-    uint8_t data[] = { 1, 2, 3, 4 };
-    Dart_Handle obj = Dart_NewExternalTypedData(
-        Dart_TypedData_kUint8,
-        data,
-        ARRAY_SIZE(data));
-    Dart_NewWeakPersistentHandle(
-        obj, &peer, sizeof(data), ExternalTypedDataFinalizer);
+    uint8_t data[] = {1, 2, 3, 4};
+    Dart_Handle obj = Dart_NewExternalTypedData(Dart_TypedData_kUint8, data,
+                                                ARRAY_SIZE(data));
+    Dart_NewWeakPersistentHandle(obj, &peer, sizeof(data),
+                                 ExternalTypedDataFinalizer);
     EXPECT_VALID(obj);
     Dart_ExitScope();
   }
   {
     TransitionNativeToVM transition(thread);
     EXPECT(peer == 0);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 0);
     Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
@@ skipping 46 matching lines @@
   EXPECT_EQ(len, 10);
   float* float_data = reinterpret_cast<float*>(raw_data);
   for (int i = 0; i < len * 4; i++) {
     EXPECT_EQ(0.0, float_data[i]);
   }
   EXPECT_VALID(Dart_TypedDataReleaseData(obj));
 }
 
 
 TEST_CASE(Float32x4List) {
-    const char* kScriptChars =
+  const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "Float32x4List float32x4() {\n"
       "  return new Float32x4List(10);\n"
       "}\n";
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   Dart_Handle obj = Dart_Invoke(lib, NewString("float32x4"), 0, NULL);
   EXPECT_VALID(obj);
   CheckFloat32x4Data(obj);
 
   obj = Dart_NewTypedData(Dart_TypedData_kFloat32x4, 10);
   EXPECT_VALID(obj);
   CheckFloat32x4Data(obj);
 
   int peer = 0;
-  float data[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
-                   0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
-                   0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
-                   0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+  float data[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+                  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+                  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+                  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
   // Push a scope so that we can collect the local handle created as part of
   // Dart_NewExternalTypedData.
   Dart_EnterScope();
   {
-    Dart_Handle lcl = Dart_NewExternalTypedData(
-        Dart_TypedData_kFloat32x4, data, 10);
-    Dart_NewWeakPersistentHandle(
-        lcl, &peer, sizeof(data), ExternalTypedDataFinalizer);
+    Dart_Handle lcl =
+        Dart_NewExternalTypedData(Dart_TypedData_kFloat32x4, data, 10);
+    Dart_NewWeakPersistentHandle(lcl, &peer, sizeof(data),
+                                 ExternalTypedDataFinalizer);
     CheckFloat32x4Data(lcl);
   }
   Dart_ExitScope();
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 42);
   }
 }
@@ skipping 176 matching lines @@
   if (handle == weak_new_ref) {
     weak_new_ref = NULL;
   } else if (handle == weak_old_ref) {
     weak_old_ref = NULL;
   }
 }
 
 
 TEST_CASE(WeakPersistentHandle) {
   Dart_Handle local_new_ref = Dart_Null();
-  weak_new_ref = Dart_NewWeakPersistentHandle(
-      local_new_ref, NULL, 0, WeakPersistentHandleCallback);
+  weak_new_ref = Dart_NewWeakPersistentHandle(local_new_ref, NULL, 0,
+                                              WeakPersistentHandleCallback);
 
   Dart_Handle local_old_ref = Dart_Null();
-  weak_old_ref = Dart_NewWeakPersistentHandle(
-      local_old_ref, NULL, 0, WeakPersistentHandleCallback);
+  weak_old_ref = Dart_NewWeakPersistentHandle(local_old_ref, NULL, 0,
+                                              WeakPersistentHandleCallback);
 
   {
     Dart_EnterScope();
 
     // Create an object in new space.
     Dart_Handle new_ref = NewString("new string");
     EXPECT_VALID(new_ref);
 
     // Create an object in old space.
     Dart_Handle old_ref;
     {
       CHECK_API_SCOPE(thread);
       HANDLESCOPE(thread);
       old_ref = Api::NewHandle(thread, String::New("old string", Heap::kOld));
       EXPECT_VALID(old_ref);
     }
 
     // Create a weak ref to the new space object.
-    weak_new_ref = Dart_NewWeakPersistentHandle(new_ref,
-                                                NULL,
-                                                0,
+    weak_new_ref = Dart_NewWeakPersistentHandle(new_ref, NULL, 0,
                                                 WeakPersistentHandleCallback);
     EXPECT_VALID(AsHandle(weak_new_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
 
     // Create a weak ref to the old space object.
-    weak_old_ref = Dart_NewWeakPersistentHandle(old_ref,
-                                                NULL,
-                                                0,
+    weak_old_ref = Dart_NewWeakPersistentHandle(old_ref, NULL, 0,
                                                 WeakPersistentHandleCallback);
     EXPECT_VALID(AsHandle(weak_old_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
 
     {
       TransitionNativeToVM transition(thread);
       // Garbage collect new space.
       GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
     }
 
@@ skipping 74 matching lines @@
   }
 }
 
 
 TEST_CASE(WeakPersistentHandleErrors) {
   Dart_EnterScope();
 
   // NULL callback.
   Dart_Handle obj1 = NewString("new string");
   EXPECT_VALID(obj1);
-  Dart_WeakPersistentHandle ref1 = Dart_NewWeakPersistentHandle(
-      obj1, NULL, 0, NULL);
+  Dart_WeakPersistentHandle ref1 =
+      Dart_NewWeakPersistentHandle(obj1, NULL, 0, NULL);
   EXPECT_EQ(ref1, static_cast<void*>(NULL));
 
   // Immediate object.
   Dart_Handle obj2 = Dart_NewInteger(0);
   EXPECT_VALID(obj2);
-  Dart_WeakPersistentHandle ref2 = Dart_NewWeakPersistentHandle(
-      obj2, NULL, 0, WeakPersistentHandleCallback);
+  Dart_WeakPersistentHandle ref2 =
+      Dart_NewWeakPersistentHandle(obj2, NULL, 0, WeakPersistentHandleCallback);
   EXPECT_EQ(ref2, static_cast<void*>(NULL));
 
   Dart_ExitScope();
 }
 
 
 static void WeakPersistentHandlePeerFinalizer(void* isolate_callback_data,
                                               Dart_WeakPersistentHandle handle,
                                               void* peer) {
   *static_cast<int*>(peer) = 42;
@@ skipping 49 matching lines @@
     EXPECT(peer == 0);
   }
 }
 
 
 UNIT_TEST_CASE(WeakPersistentHandlesCallbackShutdown) {
   TestCase::CreateTestIsolate();
   Dart_EnterScope();
   Dart_Handle ref = Dart_True();
   int peer = 1234;
-  Dart_NewWeakPersistentHandle(ref,
-                               &peer,
-                               0,
+  Dart_NewWeakPersistentHandle(ref, &peer, 0,
                                WeakPersistentHandlePeerFinalizer);
   Dart_ExitScope();
   Dart_ShutdownIsolate();
   EXPECT(peer == 42);
 }
 
 
 TEST_CASE(WeakPersistentHandleExternalAllocationSize) {
   Heap* heap = Isolate::Current()->heap();
   EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
   EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
   Dart_WeakPersistentHandle weak1 = NULL;
   static const intptr_t kWeak1ExternalSize = 1 * KB;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("weakly referenced string");
     EXPECT_VALID(obj);
-    weak1 = Dart_NewWeakPersistentHandle(obj,
-                                         NULL,
-                                         kWeak1ExternalSize,
+    weak1 = Dart_NewWeakPersistentHandle(obj, NULL, kWeak1ExternalSize,
                                          NopCallback);
     EXPECT_VALID(AsHandle(weak1));
     Dart_ExitScope();
   }
   Dart_PersistentHandle strong_ref = NULL;
   Dart_WeakPersistentHandle weak2 = NULL;
   static const intptr_t kWeak2ExternalSize = 2 * KB;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("strongly referenced string");
     EXPECT_VALID(obj);
     strong_ref = Dart_NewPersistentHandle(obj);
-    weak2 = Dart_NewWeakPersistentHandle(obj,
-                                         NULL,
-                                         kWeak2ExternalSize,
+    weak2 = Dart_NewWeakPersistentHandle(obj, NULL, kWeak2ExternalSize,
                                          NopCallback);
     EXPECT_VALID(AsHandle(strong_ref));
     Dart_ExitScope();
   }
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT(heap->ExternalInWords(Heap::kNew) ==
            (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
     // Collect weakly referenced string, and promote strongly referenced string.
@@ skipping 20 matching lines @@
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Heap* heap = Isolate::Current()->heap();
   Dart_WeakPersistentHandle weak1 = NULL;
   // Large enough to exceed any new space limit. Not actually allocated.
   const intptr_t kWeak1ExternalSize = 500 * MB;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("weakly referenced string");
     EXPECT_VALID(obj);
     // Triggers a scavenge immediately, since kWeak1ExternalSize is above limit.
-    weak1 = Dart_NewWeakPersistentHandle(obj,
-                                         NULL,
-                                         kWeak1ExternalSize,
+    weak1 = Dart_NewWeakPersistentHandle(obj, NULL, kWeak1ExternalSize,
                                          NopCallback);
     EXPECT_VALID(AsHandle(weak1));
     // ... but the object is still alive and not yet promoted, so external size
     // in new space is still above the limit. Thus, even the following tiny
     // external allocation will trigger another scavenge.
     Dart_WeakPersistentHandle trigger =
-      Dart_NewWeakPersistentHandle(obj, NULL, 1, NopCallback);
+        Dart_NewWeakPersistentHandle(obj, NULL, 1, NopCallback);
     EXPECT_VALID(AsHandle(trigger));
     Dart_DeleteWeakPersistentHandle(isolate, trigger);
     // After the two scavenges above, 'obj' should now be promoted, hence its
     // external size charged to old space.
     {
       CHECK_API_SCOPE(thread);
       HANDLESCOPE(thread);
       String& handle = String::Handle(thread->zone());
       handle ^= Api::UnwrapHandle(obj);
       EXPECT(handle.IsOld());
@@ skipping 18 matching lines @@
   Dart_EnterScope();
   Dart_Handle live = Api::NewHandle(thread, String::New("live", Heap::kOld));
   EXPECT_VALID(live);
   Dart_WeakPersistentHandle weak = NULL;
   EXPECT_EQ(0, isolate->heap()->ExternalInWords(Heap::kOld));
   const intptr_t kSmallExternalSize = 1 * KB;
   {
     Dart_EnterScope();
     Dart_Handle dead = Api::NewHandle(thread, String::New("dead", Heap::kOld));
     EXPECT_VALID(dead);
-    weak = Dart_NewWeakPersistentHandle(dead,
-                                        NULL,
-                                        kSmallExternalSize,
+    weak = Dart_NewWeakPersistentHandle(dead, NULL, kSmallExternalSize,
                                         NopCallback);
     EXPECT_VALID(AsHandle(weak));
     Dart_ExitScope();
   }
   EXPECT_EQ(kSmallExternalSize,
             isolate->heap()->ExternalInWords(Heap::kOld) * kWordSize);
   // Large enough to trigger GC in old space. Not actually allocated.
   const intptr_t kHugeExternalSize = (kWordSize == 4) ? 513 * MB : 1025 * MB;
-  Dart_NewWeakPersistentHandle(live,
-                               NULL,
-                               kHugeExternalSize,
-                               NopCallback);
+  Dart_NewWeakPersistentHandle(live, NULL, kHugeExternalSize, NopCallback);
   // Expect small garbage to be collected.
   EXPECT_EQ(kHugeExternalSize,
             isolate->heap()->ExternalInWords(Heap::kOld) * kWordSize);
   Dart_ExitScope();
 }
 
 
 TEST_CASE(WeakPersistentHandleExternalAllocationSizeOddReferents) {
   Heap* heap = Isolate::Current()->heap();
   Dart_WeakPersistentHandle weak1 = NULL;
   static const intptr_t kWeak1ExternalSize = 1 * KB;
   Dart_WeakPersistentHandle weak2 = NULL;
   static const intptr_t kWeak2ExternalSize = 2 * KB;
   EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
   {
     Dart_EnterScope();
     Dart_Handle dart_true = Dart_True();  // VM heap object.
     EXPECT_VALID(dart_true);
-    weak1 = Dart_NewWeakPersistentHandle(
-        dart_true, NULL, kWeak1ExternalSize, UnreachedCallback);
+    weak1 = Dart_NewWeakPersistentHandle(dart_true, NULL, kWeak1ExternalSize,
+                                         UnreachedCallback);
     EXPECT_VALID(AsHandle(weak1));
     Dart_Handle zero = Dart_False();  // VM heap object.
     EXPECT_VALID(zero);
-    weak2 = Dart_NewWeakPersistentHandle(
-        zero, NULL, kWeak2ExternalSize, UnreachedCallback);
+    weak2 = Dart_NewWeakPersistentHandle(zero, NULL, kWeak2ExternalSize,
+                                         UnreachedCallback);
     EXPECT_VALID(AsHandle(weak2));
     // Both should be charged to old space.
     EXPECT(heap->ExternalInWords(Heap::kOld) ==
            (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
     Dart_ExitScope();
   }
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Dart_DeleteWeakPersistentHandle(isolate, weak1);
   Dart_DeleteWeakPersistentHandle(isolate, weak2);
   EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
@@ skipping 25 matching lines @@
 
 TEST_CASE(ImplicitReferencesOldSpace) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_EnterScope();
   {
     CHECK_API_SCOPE(thread);
     HANDLESCOPE(thread);
 
-    Dart_Handle local = Api::NewHandle(
-        thread, String::New("strongly reachable", Heap::kOld));
+    Dart_Handle local =
+        Api::NewHandle(thread, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
     strong_weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NopCallback);
 
     EXPECT(!Dart_IsNull(AsHandle(strong)));
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
 
     weak1 = Dart_NewWeakPersistentHandle(
@@ skipping 45 matching lines @@
 TEST_CASE(ImplicitReferencesNewSpace) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
 
   Dart_EnterScope();
   {
     CHECK_API_SCOPE(thread);
     HANDLESCOPE(thread);
 
-    Dart_Handle local = Api::NewHandle(
-        thread, String::New("strongly reachable", Heap::kOld));
+    Dart_Handle local =
+        Api::NewHandle(thread, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
     strong_weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NopCallback);
 
     EXPECT(!Dart_IsNull(AsHandle(strong)));
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
 
     weak1 = Dart_NewWeakPersistentHandle(
@@ skipping 50 matching lines @@
 
 
 static void PrologueCallbackTimes3() {
   global_prologue_callback_status *= 3;
 }
 
 
 static int global_epilogue_callback_status;
 
 
-static void EpilogueCallbackNOP() {
-}
+static void EpilogueCallbackNOP() {}
 
 
 static void EpilogueCallbackTimes4() {
   global_epilogue_callback_status *= 4;
 }
 
 
 static void EpilogueCallbackTimes5() {
   global_epilogue_callback_status *= 5;
 }
 
 
 TEST_CASE(SetGarbageCollectionCallbacks) {
   // GC callback addition testing.
 
   // Add GC callbacks.
-  EXPECT_VALID(Dart_SetGcCallbacks(&PrologueCallbackTimes2,
-                                   &EpilogueCallbackTimes4));
+  EXPECT_VALID(
+      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackTimes4));
 
   // Add the same callbacks again.  This is an error.
-  EXPECT(Dart_IsError(Dart_SetGcCallbacks(&PrologueCallbackTimes2,
-                                          &EpilogueCallbackTimes4)));
+  EXPECT(Dart_IsError(
+      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackTimes4)));
 
   // Add another callback. This is an error.
-  EXPECT(Dart_IsError(Dart_SetGcCallbacks(&PrologueCallbackTimes3,
-                                          &EpilogueCallbackTimes5)));
+  EXPECT(Dart_IsError(
+      Dart_SetGcCallbacks(&PrologueCallbackTimes3, &EpilogueCallbackTimes5)));
 
   // GC callback removal testing.
 
   // Remove GC callbacks.
   EXPECT_VALID(Dart_SetGcCallbacks(NULL, NULL));
 
   // Remove GC callbacks whennone exist.  This is an error.
   EXPECT(Dart_IsError(Dart_SetGcCallbacks(NULL, NULL)));
 
-  EXPECT_VALID(Dart_SetGcCallbacks(&PrologueCallbackTimes2,
-                                   &EpilogueCallbackTimes4));
+  EXPECT_VALID(
+      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackTimes4));
   EXPECT(Dart_IsError(Dart_SetGcCallbacks(&PrologueCallbackTimes2, NULL)));
   EXPECT(Dart_IsError(Dart_SetGcCallbacks(NULL, &EpilogueCallbackTimes4)));
 }
 
 
 TEST_CASE(SingleGarbageCollectionCallback) {
   // Add a prologue callback.
-  EXPECT_VALID(Dart_SetGcCallbacks(&PrologueCallbackTimes2,
-                                   &EpilogueCallbackNOP));
+  EXPECT_VALID(
+      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackNOP));
 
   {
     TransitionNativeToVM transition(thread);
 
     // Garbage collect new space ignoring callbacks.  This should not
     // invoke the prologue callback.  No status values should change.
     global_prologue_callback_status = 3;
     global_epilogue_callback_status = 7;
     GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
     EXPECT_EQ(3, global_prologue_callback_status);
     EXPECT_EQ(7, global_epilogue_callback_status);
 
     // Garbage collect new space invoking callbacks.  This should
     // invoke the prologue callback.  No status values should change.
     global_prologue_callback_status = 3;
     global_epilogue_callback_status = 7;
     GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
     EXPECT_EQ(6, global_prologue_callback_status);
     EXPECT_EQ(7, global_epilogue_callback_status);
 
-  // Garbage collect old space ignoring callbacks.  This should invoke
-  // the prologue callback.  The prologue status value should change.
+    // Garbage collect old space ignoring callbacks.  This should invoke
+    // the prologue callback.  The prologue status value should change.
     global_prologue_callback_status = 3;
     global_epilogue_callback_status = 7;
-    Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
-                                               Heap::kIgnoreApiCallbacks,
-                                               Heap::kGCTestCase);
+    Isolate::Current()->heap()->CollectGarbage(
+        Heap::kOld, Heap::kIgnoreApiCallbacks, Heap::kGCTestCase);
     EXPECT_EQ(3, global_prologue_callback_status);
     EXPECT_EQ(7, global_epilogue_callback_status);
 
     // Garbage collect old space.  This should invoke the prologue
     // callback.  The prologue status value should change.
     global_prologue_callback_status = 3;
     global_epilogue_callback_status = 7;
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT_EQ(6, global_prologue_callback_status);
     EXPECT_EQ(7, global_epilogue_callback_status);
 
     // Garbage collect old space again.  Callbacks are persistent so the
     // prologue status value should change again.
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT_EQ(12, global_prologue_callback_status);
     EXPECT_EQ(7, global_epilogue_callback_status);
   }
 
   // Add an epilogue callback.
   EXPECT_VALID(Dart_SetGcCallbacks(NULL, NULL));
-  EXPECT_VALID(Dart_SetGcCallbacks(&PrologueCallbackTimes2,
-                                   &EpilogueCallbackTimes4));
+  EXPECT_VALID(
+      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackTimes4));
 
   {
     TransitionNativeToVM transition(thread);
     // Garbage collect new space.  This should not invoke the prologue
     // or the epilogue callback.  No status values should change.
     global_prologue_callback_status = 3;
     global_epilogue_callback_status = 7;
     GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
     EXPECT_EQ(3, global_prologue_callback_status);
     EXPECT_EQ(7, global_epilogue_callback_status);
 
     // Garbage collect new space.  This should invoke the prologue and
     // the epilogue callback.  The prologue and epilogue status values
     // should change.
     GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
     EXPECT_EQ(6, global_prologue_callback_status);
     EXPECT_EQ(28, global_epilogue_callback_status);
 
     // Garbage collect old space.  This should invoke the prologue and
     // the epilogue callbacks.  The prologue and epilogue status values
     // should change.
     global_prologue_callback_status = 3;
     global_epilogue_callback_status = 7;
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT_EQ(6, global_prologue_callback_status);
     EXPECT_EQ(28, global_epilogue_callback_status);
 
     // Garbage collect old space again without invoking callbacks.
     // Nothing should change.
-    Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
-                                               Heap::kIgnoreApiCallbacks,
-                                               Heap::kGCTestCase);
+    Isolate::Current()->heap()->CollectGarbage(
+        Heap::kOld, Heap::kIgnoreApiCallbacks, Heap::kGCTestCase);
     EXPECT_EQ(6, global_prologue_callback_status);
     EXPECT_EQ(28, global_epilogue_callback_status);
 
     // Garbage collect old space again.  Callbacks are persistent so the
     // prologue and epilogue status values should change again.
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT_EQ(12, global_prologue_callback_status);
     EXPECT_EQ(112, global_epilogue_callback_status);
   }
 
@@ skipping 144 matching lines @@
   Dart_ShutdownIsolate();
   EXPECT(NULL == Dart_CurrentIsolate());
 }
 
 
 UNIT_TEST_CASE(CurrentIsolateData) {
   intptr_t mydata = 12345;
   char* err;
   Dart_Isolate isolate =
       Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL,
-                         reinterpret_cast<void*>(mydata),
-                         &err);
+                         reinterpret_cast<void*>(mydata), &err);
   EXPECT(isolate != NULL);
   EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_CurrentIsolateData()));
   EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_IsolateData(isolate)));
   Dart_ShutdownIsolate();
 }
 
 
 UNIT_TEST_CASE(IsolateSetCheckedMode) {
   const char* kScriptChars =
       "int bad1() {\n"
       "  int foo = 'string';\n"
       "  return foo;\n"
       "}\n"
       "\n"
       "int good1() {\n"
       "  int five = 5;\n"
       "  return five;"
       "}\n";
 
   // Create an isolate with checked mode flags.
   Dart_IsolateFlags api_flags;
   api_flags.version = DART_FLAGS_CURRENT_VERSION;
   api_flags.enable_type_checks = true;
   api_flags.enable_asserts = true;
   api_flags.enable_error_on_bad_type = true;
   api_flags.enable_error_on_bad_override = true;
 
   char* err;
-  Dart_Isolate isolate = Dart_CreateIsolate(NULL, NULL,
-                                            bin::isolate_snapshot_buffer,
-                                            &api_flags,
-                                            NULL, &err);
+  Dart_Isolate isolate = Dart_CreateIsolate(
+      NULL, NULL, bin::isolate_snapshot_buffer, &api_flags, NULL, &err);
   if (isolate == NULL) {
     OS::Print("Creation of isolate failed '%s'\n", err);
     free(err);
   }
   EXPECT(isolate != NULL);
 
   {
     Dart_EnterScope();
     Dart_Handle url = NewString(TestCase::url());
     Dart_Handle source = NewString(kScriptChars);
     Dart_Handle result = Dart_SetLibraryTagHandler(TestCase::library_handler);
     EXPECT_VALID(result);
     Dart_Handle lib = Dart_LoadScript(url, Dart_Null(), source, 0, 0);
     EXPECT_VALID(lib);
     result = Dart_FinalizeLoading(false);
     EXPECT_VALID(result);
     result = Dart_Invoke(lib, NewString("bad1"), 0, NULL);
-    EXPECT_ERROR(result, "Unhandled exception:\n"
-        "type 'String' is not a subtype of type 'int' of 'foo'");
+    EXPECT_ERROR(result,
+                 "Unhandled exception:\n"
+                 "type 'String' is not a subtype of type 'int' of 'foo'");
 
     result = Dart_Invoke(lib, NewString("good1"), 0, NULL);
     EXPECT_VALID(result);
     Dart_ExitScope();
   }
 
   EXPECT(isolate != NULL);
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 }
 
 
 TEST_CASE(DebugName) {
   Dart_Handle debug_name = Dart_DebugName();
   EXPECT_VALID(debug_name);
   EXPECT(Dart_IsString(debug_name));
 }
 
 
-static void MyMessageNotifyCallback(Dart_Isolate dest_isolate) {
-}
+static void MyMessageNotifyCallback(Dart_Isolate dest_isolate) {}
 
 
 UNIT_TEST_CASE(SetMessageCallbacks) {
   Dart_Isolate dart_isolate = TestCase::CreateTestIsolate();
   Dart_SetMessageNotifyCallback(&MyMessageNotifyCallback);
   Isolate* isolate = reinterpret_cast<Isolate*>(dart_isolate);
   EXPECT_EQ(&MyMessageNotifyCallback, isolate->message_notify_callback());
   Dart_ShutdownIsolate();
 }
 
 
 TEST_CASE(SetStickyError) {
-    const char* kScriptChars =
-      "main() => throw 'HI';";
+  const char* kScriptChars = "main() => throw 'HI';";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle retobj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(retobj));
   EXPECT(Dart_IsUnhandledExceptionError(retobj));
   EXPECT(!Dart_HasStickyError());
   EXPECT(Dart_GetStickyError() == Dart_Null());
   Dart_SetStickyError(retobj);
   EXPECT(Dart_HasStickyError());
   EXPECT(Dart_GetStickyError() != Dart_Null());
   Dart_SetStickyError(Dart_Null());
@@ skipping 18 matching lines @@
       "\n"
       "abstract class MyInterface1 implements MyInterface0 {\n"
       "}\n"
       "MyClass0 getMyClass0() { return new MyClass0(); }\n"
       "MyClass1 getMyClass1() { return new MyClass1(); }\n"
       "MyClass2 getMyClass2() { return new MyClass2(); }\n"
       "Type getMyClass0Type() { return new MyClass0().runtimeType; }\n"
       "Type getMyClass1Type() { return new MyClass1().runtimeType; }\n"
       "Type getMyClass2Type() { return new MyClass2().runtimeType; }\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
-  bool instanceof = false;
+  bool instanceOf = false;
 
   // First get the type objects of these non parameterized types.
   Dart_Handle type0 = Dart_GetType(lib, NewString("MyClass0"), 0, NULL);
   EXPECT_VALID(type0);
   Dart_Handle type1 = Dart_GetType(lib, NewString("MyClass1"), 0, NULL);
   EXPECT_VALID(type1);
   Dart_Handle type2 = Dart_GetType(lib, NewString("MyClass2"), 0, NULL);
   EXPECT_VALID(type2);
   Dart_Handle type3 = Dart_GetType(lib, NewString("MyInterface0"), 0, NULL);
   EXPECT_VALID(type3);
   Dart_Handle type4 = Dart_GetType(lib, NewString("MyInterface1"), 0, NULL);
   EXPECT_VALID(type4);
 
   // Now create objects of these non parameterized types and check
   // that the validity of the type of the created object.
   // MyClass0 type.
   Dart_Handle type0_obj = Dart_Invoke(lib, NewString("getMyClass0"), 0, NULL);
   EXPECT_VALID(type0_obj);
-  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type0, &instanceof));
-  EXPECT(instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type1, &instanceof));
-  EXPECT(!instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type2, &instanceof));
-  EXPECT(!instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type3, &instanceof));
-  EXPECT(!instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type4, &instanceof));
-  EXPECT(!instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type0, &instanceOf));
+  EXPECT(instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type1, &instanceOf));
+  EXPECT(!instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type2, &instanceOf));
+  EXPECT(!instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type3, &instanceOf));
+  EXPECT(!instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type0_obj, type4, &instanceOf));
+  EXPECT(!instanceOf);
   type0_obj = Dart_Invoke(lib, NewString("getMyClass0Type"), 0, NULL);
   EXPECT_VALID(type0_obj);
   EXPECT(Dart_IdentityEquals(type0, type0_obj));
 
   // MyClass1 type.
   Dart_Handle type1_obj = Dart_Invoke(lib, NewString("getMyClass1"), 0, NULL);
   EXPECT_VALID(type1_obj);
-  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type1, &instanceof));
-  EXPECT(instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type0, &instanceof));
-  EXPECT(!instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type2, &instanceof));
-  EXPECT(!instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type3, &instanceof));
-  EXPECT(instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type4, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type1, &instanceOf));
+  EXPECT(instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type0, &instanceOf));
+  EXPECT(!instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type2, &instanceOf));
+  EXPECT(!instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type3, &instanceOf));
+  EXPECT(instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type1_obj, type4, &instanceOf));
+  EXPECT(instanceOf);
   type1_obj = Dart_Invoke(lib, NewString("getMyClass1Type"), 0, NULL);
   EXPECT_VALID(type1_obj);
   EXPECT(Dart_IdentityEquals(type1, type1_obj));
 
   // MyClass2 type.
   Dart_Handle type2_obj = Dart_Invoke(lib, NewString("getMyClass2"), 0, NULL);
   EXPECT_VALID(type2_obj);
-  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type2, &instanceof));
-  EXPECT(instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type0, &instanceof));
-  EXPECT(!instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type1, &instanceof));
-  EXPECT(!instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type3, &instanceof));
-  EXPECT(instanceof);
-  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type4, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type2, &instanceOf));
+  EXPECT(instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type0, &instanceOf));
+  EXPECT(!instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type1, &instanceOf));
+  EXPECT(!instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type3, &instanceOf));
+  EXPECT(instanceOf);
+  EXPECT_VALID(Dart_ObjectIsType(type2_obj, type4, &instanceOf));
+  EXPECT(instanceOf);
   type2_obj = Dart_Invoke(lib, NewString("getMyClass2Type"), 0, NULL);
   EXPECT_VALID(type2_obj);
   EXPECT(Dart_IdentityEquals(type2, type2_obj));
 }
 
 
 TEST_CASE(TypeGetParameterizedTypes) {
   const char* kScriptChars =
       "class MyClass0<A, B> {\n"
       "}\n"
@@ skipping 18 matching lines @@
       "Type getMyClass0_1Type() {\n"
       "  return new MyClass0<double, int>().runtimeType;\n"
       "}\n"
       "MyClass1 getMyClass1_1() {\n"
       "  return new MyClass1<List<int>, List<double>>();\n"
       "}\n"
       "Type getMyClass1_1Type() {\n"
       "  return new MyClass1<List<int>, List<double>>().runtimeType;\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
-  bool instanceof = false;
+  bool instanceOf = false;
 
   // First get type objects of some of the basic types used in the test.
   Dart_Handle int_type = Dart_GetType(lib, NewString("int"), 0, NULL);
   EXPECT_VALID(int_type);
   Dart_Handle double_type = Dart_GetType(lib, NewString("double"), 0, NULL);
   EXPECT_VALID(double_type);
   Dart_Handle list_type = Dart_GetType(lib, NewString("List"), 0, NULL);
   EXPECT_VALID(list_type);
   Dart_Handle type_args = Dart_NewList(1);
   EXPECT_VALID(Dart_ListSetAt(type_args, 0, int_type));
-  Dart_Handle list_int_type = Dart_GetType(lib,
-                                           NewString("List"),
-                                           1,
-                                           &type_args);
+  Dart_Handle list_int_type =
+      Dart_GetType(lib, NewString("List"), 1, &type_args);
   EXPECT_VALID(list_int_type);
 
   // Now instantiate MyClass0 and MyClass1 types with the same type arguments
   // used in the code above.
   type_args = Dart_NewList(2);
   EXPECT_VALID(Dart_ListSetAt(type_args, 0, int_type));
   EXPECT_VALID(Dart_ListSetAt(type_args, 1, double_type));
-  Dart_Handle myclass0_type = Dart_GetType(lib,
-                                           NewString("MyClass0"),
-                                           2,
-                                           &type_args);
+  Dart_Handle myclass0_type =
+      Dart_GetType(lib, NewString("MyClass0"), 2, &type_args);
   EXPECT_VALID(myclass0_type);
 
   type_args = Dart_NewList(2);
   EXPECT_VALID(Dart_ListSetAt(type_args, 0, list_int_type));
   EXPECT_VALID(Dart_ListSetAt(type_args, 1, list_type));
-  Dart_Handle myclass1_type = Dart_GetType(lib,
-                                           NewString("MyClass1"),
-                                           2,
-                                           &type_args);
+  Dart_Handle myclass1_type =
+      Dart_GetType(lib, NewString("MyClass1"), 2, &type_args);
   EXPECT_VALID(myclass1_type);
 
   // Now create objects of the type and validate the object type matches
   // the one returned above. Also get the runtime type of the object and
   // verify that it matches the type returned above.
   // MyClass0<int, double> type.
   Dart_Handle type0_obj = Dart_Invoke(lib, NewString("getMyClass0"), 0, NULL);
   EXPECT_VALID(type0_obj);
-  EXPECT_VALID(Dart_ObjectIsType(type0_obj, myclass0_type, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(type0_obj, myclass0_type, &instanceOf));
+  EXPECT(instanceOf);
   type0_obj = Dart_Invoke(lib, NewString("getMyClass0Type"), 0, NULL);
   EXPECT_VALID(type0_obj);
   EXPECT(Dart_IdentityEquals(type0_obj, myclass0_type));
 
   // MyClass1<List<int>, List> type.
   Dart_Handle type1_obj = Dart_Invoke(lib, NewString("getMyClass1"), 0, NULL);
   EXPECT_VALID(type1_obj);
-  EXPECT_VALID(Dart_ObjectIsType(type1_obj, myclass1_type, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(type1_obj, myclass1_type, &instanceOf));
+  EXPECT(instanceOf);
   type1_obj = Dart_Invoke(lib, NewString("getMyClass1Type"), 0, NULL);
   EXPECT_VALID(type1_obj);
   EXPECT(Dart_IdentityEquals(type1_obj, myclass1_type));
 
   // MyClass0<double, int> type.
   type0_obj = Dart_Invoke(lib, NewString("getMyClass0_1"), 0, NULL);
   EXPECT_VALID(type0_obj);
-  EXPECT_VALID(Dart_ObjectIsType(type0_obj, myclass0_type, &instanceof));
-  EXPECT(!instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(type0_obj, myclass0_type, &instanceOf));
+  EXPECT(!instanceOf);
   type0_obj = Dart_Invoke(lib, NewString("getMyClass0_1Type"), 0, NULL);
   EXPECT_VALID(type0_obj);
   EXPECT(!Dart_IdentityEquals(type0_obj, myclass0_type));
 
   // MyClass1<List<int>, List<double>> type.
   type1_obj = Dart_Invoke(lib, NewString("getMyClass1_1"), 0, NULL);
   EXPECT_VALID(type1_obj);
-  EXPECT_VALID(Dart_ObjectIsType(type1_obj, myclass1_type, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(type1_obj, myclass1_type, &instanceOf));
+  EXPECT(instanceOf);
   type1_obj = Dart_Invoke(lib, NewString("getMyClass1_1Type"), 0, NULL);
   EXPECT_VALID(type1_obj);
   EXPECT(!Dart_IdentityEquals(type1_obj, myclass1_type));
 }
 
 
 static void TestFieldOk(Dart_Handle container,
                         Dart_Handle name,
                         bool final,
                         const char* initial_value) {
@@ skipping 24 matching lines @@
   EXPECT_VALID(result);
   EXPECT_VALID(Dart_StringToCString(result, &value));
   if (final) {
     EXPECT_STREQ(initial_value, value);
   } else {
     EXPECT_STREQ(buffer, value);
   }
 }
 
 
-static void TestFieldNotFound(Dart_Handle container,
-                              Dart_Handle name) {
+static void TestFieldNotFound(Dart_Handle container, Dart_Handle name) {
   EXPECT(Dart_IsError(Dart_GetField(container, name)));
   EXPECT(Dart_IsError(Dart_SetField(container, name, Dart_Null())));
 }
 
 
 TEST_CASE(FieldAccess) {
   const char* kScriptChars =
       "class BaseFields {\n"
       "  BaseFields()\n"
       "    : this.inherited_fld = 'inherited' {\n"
@@ skipping 238 matching lines @@
 
   // Hidden imported top-level get/set field.  Not found at any level.
   name = NewString("_imported_getset_fld");
   TestFieldNotFound(type, name);
   TestFieldNotFound(instance, name);
   TestFieldNotFound(lib, name);
 }
 
 
 TEST_CASE(SetField_FunnyValue) {
-  const char* kScriptChars =
-      "var top;\n";
+  const char* kScriptChars = "var top;\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle name = NewString("top");
   bool value;
 
   // Test that you can set the field to a good value.
   EXPECT_VALID(Dart_SetField(lib, name, Dart_True()));
   Dart_Handle result = Dart_GetField(lib, name);
   EXPECT_VALID(result);
   EXPECT(Dart_IsBoolean(result));
@@ skipping 44 matching lines @@
       "}\n"
       "NativeFields testMain() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  return obj;\n"
       "}\n";
   Dart_Handle result;
 
   const int kNumNativeFields = 4;
 
   // Create a test library.
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL,
-                                             USER_TEST_URI, false);
+  Dart_Handle lib =
+      TestCase::LoadTestScript(kScriptChars, NULL, USER_TEST_URI, false);
 
   // Create a native wrapper class with native fields.
-  result = Dart_CreateNativeWrapperClass(
-      lib,
-      NewString("NativeFieldsWrapper"),
-      kNumNativeFields);
+  result = Dart_CreateNativeWrapperClass(lib, NewString("NativeFieldsWrapper"),
+                                         kNumNativeFields);
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
 
   // Load up a test script in the test library.
 
   // Invoke a function which returns an object of type NativeFields.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   CHECK_API_SCOPE(thread);
   HANDLESCOPE(thread);
   Instance& obj = Instance::Handle();
   obj ^= Api::UnwrapHandle(result);
   const Class& cls = Class::Handle(obj.clazz());
   // We expect the newly created "NativeFields" object to have
   // 2 dart instance fields (fld1, fld2) and a reference to the native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (1 + 2) * kWordSize + size of object header.
   // We check to make sure the instance size computed by the VM matches
   // our expectations.
   intptr_t header_size = sizeof(RawObject);
-  EXPECT_EQ(Utils::RoundUp(((1 + 2) * kWordSize) + header_size,
-                           kObjectAlignment),
-            cls.instance_size());
+  EXPECT_EQ(
+      Utils::RoundUp(((1 + 2) * kWordSize) + header_size, kObjectAlignment),
+      cls.instance_size());
   EXPECT_EQ(kNumNativeFields, cls.num_native_fields());
 }
 
 
 TEST_CASE(InjectNativeFields2) {
   const char* kScriptChars =
       "class NativeFields extends NativeFieldsWrapper {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static const int fld4 = 10;\n"
       "}\n"
       "NativeFields testMain() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  return obj;\n"
       "}\n";
   Dart_Handle result;
   // Create a test library and Load up a test script in it.
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL,
-                                             USER_TEST_URI, false);
+  Dart_Handle lib =
+      TestCase::LoadTestScript(kScriptChars, NULL, USER_TEST_URI, false);
 
   // Invoke a function which returns an object of type NativeFields.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
 
   // We expect this to fail as class "NativeFields" extends
   // "NativeFieldsWrapper" and there is no definition of it either
   // in the dart code or through the native field injection mechanism.
   EXPECT(Dart_IsError(result));
 }
 
 
 TEST_CASE(InjectNativeFields3) {
   const char* kScriptChars =
       "import 'dart:nativewrappers';"
       "class NativeFields extends NativeFieldWrapperClass2 {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static const int fld4 = 10;\n"
       "}\n"
       "NativeFields testMain() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  return obj;\n"
       "}\n";
   Dart_Handle result;
   const int kNumNativeFields = 2;
 
   // Load up a test script in the test library.
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
-                                             native_field_lookup);
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, native_field_lookup);
 
   // Invoke a function which returns an object of type NativeFields.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   CHECK_API_SCOPE(thread);
   HANDLESCOPE(thread);
   Instance& obj = Instance::Handle();
   obj ^= Api::UnwrapHandle(result);
   const Class& cls = Class::Handle(obj.clazz());
   // We expect the newly created "NativeFields" object to have
   // 2 dart instance fields (fld1, fld2) and a reference to the native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (1 + 2) * kWordSize + size of object header.
   // We check to make sure the instance size computed by the VM matches
   // our expectations.
   intptr_t header_size = sizeof(RawObject);
-  EXPECT_EQ(Utils::RoundUp(((1 + 2) * kWordSize) + header_size,
-                           kObjectAlignment),
-            cls.instance_size());
+  EXPECT_EQ(
+      Utils::RoundUp(((1 + 2) * kWordSize) + header_size, kObjectAlignment),
+      cls.instance_size());
   EXPECT_EQ(kNumNativeFields, cls.num_native_fields());
 }
 
 
 TEST_CASE(InjectNativeFields4) {
   const char* kScriptChars =
       "import 'dart:nativewrappers';"
       "class NativeFields extends NativeFieldWrapperClass2 {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
@@ skipping 33 matching lines @@
 
 void TestNativeFieldsAccess_init(Dart_NativeArguments args) {
   Dart_Handle receiver = Dart_GetNativeArgument(args, 0);
   Dart_SetNativeInstanceField(receiver, 0, kNativeField1Value);
   Dart_SetNativeInstanceField(receiver, 1, kNativeField2Value);
 }
 
 
 void TestNativeFieldsAccess_access(Dart_NativeArguments args) {
   intptr_t field_values[kTestNumNativeFields];
-  Dart_Handle result = Dart_GetNativeFieldsOfArgument(args,
-                                                      0,
-                                                      kTestNumNativeFields,
-                                                      field_values);
+  Dart_Handle result = Dart_GetNativeFieldsOfArgument(
+      args, 0, kTestNumNativeFields, field_values);
   EXPECT_VALID(result);
   EXPECT_EQ(kNativeField1Value, field_values[0]);
   EXPECT_EQ(kNativeField2Value, field_values[1]);
-  result = Dart_GetNativeFieldsOfArgument(args,
-                                          1,
-                                          kTestNumNativeFields,
+  result = Dart_GetNativeFieldsOfArgument(args, 1, kTestNumNativeFields,
                                           field_values);
   EXPECT_VALID(result);
   EXPECT_EQ(0, field_values[0]);
   EXPECT_EQ(0, field_values[1]);
 }
 
 
 static Dart_NativeFunction TestNativeFieldsAccess_lookup(Dart_Handle name,
                                                          int argument_count,
                                                          bool* auto_scope) {
@@ skipping 29 matching lines @@
       "  int accessNativeFlds(int i) native 'TestNativeFieldsAccess_access';\n"
       "}\n"
       "NativeFields testMain() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  obj.initNativeFlds();\n"
       "  obj.accessNativeFlds(null);\n"
       "  return obj;\n"
       "}\n";
 
   // Load up a test script in the test library.
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
-                                             TestNativeFieldsAccess_lookup);
+  Dart_Handle lib =
+      TestCase::LoadTestScript(kScriptChars, TestNativeFieldsAccess_lookup);
 
   // Invoke a function which returns an object of type NativeFields.
   Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
 TEST_CASE(InjectNativeFieldsSuperClass) {
   const char* kScriptChars =
       "import 'dart:nativewrappers';"
@@ skipping 33 matching lines @@
   EXPECT(Dart_IsNull(result));
   result = Dart_GetField(retobj, NewString("fld1"));
   EXPECT_VALID(result);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(10, value);
   result = Dart_GetField(retobj, NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(20, value);
-  result = Dart_SetField(retobj,
-                         NewString("fld2"),
-                         Dart_NewInteger(40));
+  result = Dart_SetField(retobj, NewString("fld2"), Dart_NewInteger(40));
   EXPECT(Dart_IsError(result));
-  result = Dart_SetField(retobj,
-                         NewString("fld1"),
-                         Dart_NewInteger(40));
+  result = Dart_SetField(retobj, NewString("fld1"), Dart_NewInteger(40));
   EXPECT_VALID(result);
   result = Dart_GetField(retobj, NewString("fld1"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(40, value);
 
   // Now access and set various native instance fields of the returned object.
   const int kNativeFld0 = 0;
   const int kNativeFld1 = 1;
   const int kNativeFld2 = 2;
@@ skipping 54 matching lines @@
       "  static int fld3;\n"
       "  static const int fld4 = 10;\n"
       "}\n"
       "NativeFields testMain() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  return obj;\n"
       "}\n";
   const int kNumNativeFields = 4;
 
   // Create a test library.
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
-                                             native_field_lookup,
-                                             USER_TEST_URI,
-                                             false);
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, native_field_lookup,
+                                             USER_TEST_URI, false);
 
   // Create a native wrapper class with native fields.
   Dart_Handle result = Dart_CreateNativeWrapperClass(
-      lib,
-      NewString("NativeFieldsWrapper"),
-      kNumNativeFields);
+      lib, NewString("NativeFieldsWrapper"), kNumNativeFields);
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
 
   // Load up a test script in it.
 
   // Invoke a function which returns an object of type NativeFields.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(retobj);
 
@@ skipping 23 matching lines @@
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static const int fld4 = 10;\n"
       "}\n"
       "NativeFields testMain() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  return obj;\n"
       "}\n";
   // Load up a test script in the test library.
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
-                                             native_field_lookup);
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, native_field_lookup);
 
   // Invoke a function which returns an object of type NativeFields.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(retobj);
 
   // Now access and set various instance fields of the returned object.
   TestNativeFields(retobj);
 }
 
 
@@ skipping 131 matching lines @@
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(7, value);
 
   result = Dart_GetField(type, NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(11, value);
 
   // Overwrite fld2
-  result = Dart_SetField(type,
-                         NewString("fld2"),
-                         Dart_NewInteger(13));
+  result = Dart_SetField(type, NewString("fld2"), Dart_NewInteger(13));
   EXPECT_VALID(result);
 
   // We now get the new value for fld2, not the initializer
   result = Dart_GetField(type, NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(13, value);
 }
 
 
@@ skipping 78 matching lines @@
   Dart_Handle intf = Dart_GetType(lib, NewString("MyInterface"), 0, NULL);
   EXPECT_VALID(intf);
   Dart_Handle args[1];
   args[0] = Dart_NewInteger(11);
   Dart_Handle bad_args[1];
   bad_args[0] = Dart_NewApiError("myerror");
 
   // Allocate and Invoke the unnamed constructor passing in Dart_Null.
   Dart_Handle result = Dart_New(type, Dart_Null(), 0, NULL);
   EXPECT_VALID(result);
-  bool instanceof = false;
-  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceof));
-  EXPECT(instanceof);
+  bool instanceOf = false;
+  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
+  EXPECT(instanceOf);
   int64_t int_value = 0;
   Dart_Handle foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(7, int_value);
 
   // Allocate without a constructor.
   Dart_Handle obj = Dart_Allocate(type);
   EXPECT_VALID(obj);
-  instanceof = false;
-  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceof));
-  EXPECT(instanceof);
+  instanceOf = false;
+  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
+  EXPECT(instanceOf);
   foo = Dart_GetField(obj, NewString("foo"));
   EXPECT(Dart_IsNull(foo));
 
   // Allocate and Invoke the unnamed constructor passing in an empty string.
   result = Dart_New(type, Dart_EmptyString(), 0, NULL);
   EXPECT_VALID(result);
-  instanceof = false;
-  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceof));
-  EXPECT(instanceof);
+  instanceOf = false;
+  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
+  EXPECT(instanceOf);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(7, int_value);
 
   // Allocate object and invoke the unnamed constructor with an empty string.
   obj = Dart_Allocate(type);
   EXPECT_VALID(obj);
-  instanceof = false;
-  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceof));
-  EXPECT(instanceof);
+  instanceOf = false;
+  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
+  EXPECT(instanceOf);
   // Use the empty string to invoke the unnamed constructor.
   result = Dart_InvokeConstructor(obj, Dart_EmptyString(), 0, NULL);
   EXPECT_VALID(result);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(7, int_value);
   // use Dart_Null to invoke the unnamed constructor.
   result = Dart_InvokeConstructor(obj, Dart_Null(), 0, NULL);
   EXPECT_VALID(result);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(7, int_value);
 
   // Invoke a named constructor.
   result = Dart_New(type, NewString("named"), 1, args);
   EXPECT_VALID(result);
-  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
+  EXPECT(instanceOf);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(11, int_value);
 
   // Allocate object and invoke a named constructor.
   obj = Dart_Allocate(type);
   EXPECT_VALID(obj);
-  instanceof = false;
-  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceof));
-  EXPECT(instanceof);
+  instanceOf = false;
+  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
+  EXPECT(instanceOf);
   result = Dart_InvokeConstructor(obj, NewString("named"), 1, args);
   EXPECT_VALID(result);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(11, int_value);
 
   // Invoke a hidden named constructor.
   result = Dart_New(type, NewString("_hidden"), 1, args);
   EXPECT_VALID(result);
-  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
+  EXPECT(instanceOf);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(-11, int_value);
 
   // Allocate object and invoke a hidden named constructor.
   obj = Dart_Allocate(type);
   EXPECT_VALID(obj);
-  instanceof = false;
-  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceof));
-  EXPECT(instanceof);
+  instanceOf = false;
+  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
+  EXPECT(instanceOf);
   result = Dart_InvokeConstructor(obj, NewString("_hidden"), 1, args);
   EXPECT_VALID(result);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(-11, int_value);
 
   // Allocate object and Invoke a constructor which throws an exception.
   obj = Dart_Allocate(type);
   EXPECT_VALID(obj);
-  instanceof = false;
-  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceof));
-  EXPECT(instanceof);
+  instanceOf = false;
+  EXPECT_VALID(Dart_ObjectIsType(obj, type, &instanceOf));
+  EXPECT(instanceOf);
   result = Dart_InvokeConstructor(obj, NewString("exception"), 1, args);
   EXPECT_ERROR(result, "ConstructorDeath");
 
   // Invoke a factory constructor.
   result = Dart_New(type, NewString("multiply"), 1, args);
   EXPECT_VALID(result);
-  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
+  EXPECT(instanceOf);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(1100, int_value);
 
   // Invoke a factory constructor which returns null.
   result = Dart_New(type, NewString("nullo"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsNull(result));
 
@@ skipping 33 matching lines @@
   EXPECT_ERROR(result,
                "Dart_New: could not find constructor 'MyClass.missing'.");
 
   // Invoke a constructor which throws an exception.
   result = Dart_New(type, NewString("exception"), 1, args);
   EXPECT_ERROR(result, "ConstructorDeath");
 
   // Invoke two-hop redirecting factory constructor.
   result = Dart_New(intf, NewString("named"), 1, args);
   EXPECT_VALID(result);
-  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
+  EXPECT(instanceOf);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(11, int_value);
 
   // Invoke one-hop redirecting factory constructor.
   result = Dart_New(intf, NewString("multiply"), 1, args);
   EXPECT_VALID(result);
-  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceof));
-  EXPECT(instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
+  EXPECT(instanceOf);
   int_value = 0;
   foo = Dart_GetField(result, NewString("foo"));
   EXPECT_VALID(Dart_IntegerToInt64(foo, &int_value));
   EXPECT_EQ(1100, int_value);
 
   // Invoke a constructor that is missing in the interface.
   result = Dart_New(intf, Dart_Null(), 0, NULL);
-  EXPECT_ERROR(result,
-               "Dart_New: could not find constructor 'MyInterface.'.");
+  EXPECT_ERROR(result, "Dart_New: could not find constructor 'MyInterface.'.");
 
   // Invoke abstract constructor that is present in the interface.
   result = Dart_New(intf, NewString("notfound"), 1, args);
   EXPECT_VALID(result);
-  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceof));
-  EXPECT(!instanceof);
+  EXPECT_VALID(Dart_ObjectIsType(result, type, &instanceOf));
+  EXPECT(!instanceOf);
 }
 
 
 TEST_CASE(New_Issue2971) {
   // Issue 2971: We were unable to use Dart_New to construct an
   // instance of List, due to problems implementing interface
   // factories.
   Dart_Handle core_lib = Dart_LookupLibrary(NewString("dart:core"));
   EXPECT_VALID(core_lib);
   Dart_Handle list_type = Dart_GetType(core_lib, NewString("List"), 0, NULL);
@@ skipping 157 matching lines @@
   result = Dart_Invoke(type, name, 1, args);
   EXPECT_VALID(result);
 
   const char* str = NULL;
   result = Dart_StringToCString(result, &str);
   EXPECT_STREQ("hidden static !!!", str);
 }
 
 
 TEST_CASE(Invoke_FunnyArgs) {
-  const char* kScriptChars =
-      "test(arg) => 'hello $arg';\n";
+  const char* kScriptChars = "test(arg) => 'hello $arg';\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle func_name = NewString("test");
   Dart_Handle args[1];
   const char* str;
 
   // Make sure that valid args yield valid results.
   args[0] = NewString("!!!");
   Dart_Handle result = Dart_Invoke(lib, func_name, 1, args);
   EXPECT_VALID(result);
   result = Dart_StringToCString(result, &str);
   EXPECT_STREQ("hello !!!", str);
 
   // Make sure that null is legal.
   args[0] = Dart_Null();
   result = Dart_Invoke(lib, func_name, 1, args);
   EXPECT_VALID(result);
   result = Dart_StringToCString(result, &str);
   EXPECT_STREQ("hello null", str);
 
   // Pass an error handle as the target.  The error is propagated.
-  result = Dart_Invoke(Api::NewError("myerror"),
-                       func_name, 1, args);
+  result = Dart_Invoke(Api::NewError("myerror"), func_name, 1, args);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("myerror", Dart_GetError(result));
 
   // Pass an error handle as the function name.  The error is propagated.
   result = Dart_Invoke(lib, Api::NewError("myerror"), 1, args);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("myerror", Dart_GetError(result));
 
   // Pass a non-instance handle as a parameter..
   args[0] = lib;
   result = Dart_Invoke(lib, func_name, 1, args);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_Invoke expects arguments[0] to be an Instance handle.",
                Dart_GetError(result));
 
   // Pass an error handle as a parameter.  The error is propagated.
   args[0] = Api::NewError("myerror");
   result = Dart_Invoke(lib, func_name, 1, args);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("myerror", Dart_GetError(result));
 }
 
 
 TEST_CASE(Invoke_Null) {
-  Dart_Handle result = Dart_Invoke(Dart_Null(),
-                                   NewString("toString"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(Dart_Null(), NewString("toString"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
 
   const char* value = "";
   EXPECT_VALID(Dart_StringToCString(result, &value));
   EXPECT_STREQ("null", value);
 
   Dart_Handle function_name = NewString("NoNoNo");
-  result = Dart_Invoke(Dart_Null(),
-                       function_name,
-                       0,
-                       NULL);
+  result = Dart_Invoke(Dart_Null(), function_name, 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
 }
 
 
 TEST_CASE(InvokeNoSuchMethod) {
   const char* kScriptChars =
       "import 'dart:_internal' as _internal;\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
@@ skipping 173 matching lines @@
 static Dart_NativeFunction native_lookup(Dart_Handle name,
                                          int argument_count,
                                          bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&ExceptionNative);
 }
 
 
 TEST_CASE(ThrowException) {
-  const char* kScriptChars =
-      "int test() native \"ThrowException_native\";";
+  const char* kScriptChars = "int test() native \"ThrowException_native\";";
   Dart_Handle result;
   intptr_t size = thread->ZoneSizeInBytes();
   Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
   // Load up a test script which extends the native wrapper class.
   Dart_Handle lib = TestCase::LoadTestScript(
-      kScriptChars,
-      reinterpret_cast<Dart_NativeEntryResolver>(native_lookup));
+      kScriptChars, reinterpret_cast<Dart_NativeEntryResolver>(native_lookup));
 
   // Throwing an exception here should result in an error.
   result = Dart_ThrowException(NewString("This doesn't work"));
   EXPECT_ERROR(result, "No Dart frames on stack, cannot throw exception");
   EXPECT(!Dart_ErrorHasException(result));
 
   // Invoke 'test' and check for an uncaught exception.
   result = Dart_Invoke(lib, NewString("test"), 0, NULL);
   EXPECT_ERROR(result, "Hello from ExceptionNative!");
   EXPECT(Dart_ErrorHasException(result));
 
   Dart_ExitScope();  // Exit the Dart API scope.
   EXPECT_EQ(size, thread->ZoneSizeInBytes());
 }
 
 
 static intptr_t kNativeArgumentNativeField1Value = 30;
 static intptr_t kNativeArgumentNativeField2Value = 40;
 static intptr_t native_arg_str_peer = 100;
 static void NativeArgumentCreate(Dart_NativeArguments args) {
   Dart_Handle lib = Dart_LookupLibrary(NewString(TestCase::url()));
   Dart_Handle type = Dart_GetType(lib, NewString("MyObject"), 0, NULL);
   EXPECT_VALID(type);
 
   // Allocate without a constructor.
   const int num_native_fields = 2;
-  const intptr_t native_fields[] = {
-    kNativeArgumentNativeField1Value,
-    kNativeArgumentNativeField2Value
-  };
+  const intptr_t native_fields[] = {kNativeArgumentNativeField1Value,
+                                    kNativeArgumentNativeField2Value};
   // Allocate and Setup native fields.
-  Dart_Handle obj = Dart_AllocateWithNativeFields(type,
-                                                  num_native_fields,
-                                                  native_fields);
+  Dart_Handle obj =
+      Dart_AllocateWithNativeFields(type, num_native_fields, native_fields);
   EXPECT_VALID(obj);
 
   kNativeArgumentNativeField1Value *= 2;
   kNativeArgumentNativeField2Value *= 2;
   Dart_SetReturnValue(args, obj);
 }
 
 
 static void NativeArgumentAccess(Dart_NativeArguments args) {
   const int kNumNativeFields = 2;
 
   // Test different argument types with a valid descriptor set.
   {
     const char* cstr = NULL;
     intptr_t native_fields1[kNumNativeFields];
     intptr_t native_fields2[kNumNativeFields];
     const Dart_NativeArgument_Descriptor arg_descriptors[9] = {
-      { Dart_NativeArgument_kNativeFields, 0 },
-      { Dart_NativeArgument_kInt32, 1 },
-      { Dart_NativeArgument_kUint64, 2 },
-      { Dart_NativeArgument_kBool, 3 },
-      { Dart_NativeArgument_kDouble, 4 },
-      { Dart_NativeArgument_kString, 5 },
-      { Dart_NativeArgument_kString, 6 },
-      { Dart_NativeArgument_kNativeFields, 7 },
-      { Dart_NativeArgument_kInstance, 7 },
+        {Dart_NativeArgument_kNativeFields, 0},
+        {Dart_NativeArgument_kInt32, 1},
+        {Dart_NativeArgument_kUint64, 2},
+        {Dart_NativeArgument_kBool, 3},
+        {Dart_NativeArgument_kDouble, 4},
+        {Dart_NativeArgument_kString, 5},
+        {Dart_NativeArgument_kString, 6},
+        {Dart_NativeArgument_kNativeFields, 7},
+        {Dart_NativeArgument_kInstance, 7},
     };
     Dart_NativeArgument_Value arg_values[9];
     arg_values[0].as_native_fields.num_fields = kNumNativeFields;
     arg_values[0].as_native_fields.values = native_fields1;
     arg_values[7].as_native_fields.num_fields = kNumNativeFields;
     arg_values[7].as_native_fields.values = native_fields2;
-    Dart_Handle result = Dart_GetNativeArguments(args,
-                                                 9,
-                                                 arg_descriptors,
-                                                 arg_values);
+    Dart_Handle result =
+        Dart_GetNativeArguments(args, 9, arg_descriptors, arg_values);
     EXPECT_VALID(result);
 
     EXPECT(arg_values[0].as_native_fields.values[0] == 30);
     EXPECT(arg_values[0].as_native_fields.values[1] == 40);
 
     EXPECT(arg_values[1].as_int32 == 77);
 
     EXPECT(arg_values[2].as_uint64 == 0xffffffffffffffffLL);
 
     EXPECT(arg_values[3].as_bool == true);
 
     EXPECT(arg_values[4].as_double == 3.14);
 
     EXPECT_VALID(arg_values[5].as_string.dart_str);
     EXPECT(Dart_IsString(arg_values[5].as_string.dart_str));
     EXPECT_VALID(Dart_StringToCString(arg_values[5].as_string.dart_str, &cstr));
     EXPECT_STREQ("abcdefg", cstr);
     EXPECT(arg_values[5].as_string.peer == NULL);
 
     EXPECT(arg_values[6].as_string.dart_str == NULL);
     EXPECT(arg_values[6].as_string.peer ==
            reinterpret_cast<void*>(&native_arg_str_peer));
 
     EXPECT(arg_values[7].as_native_fields.values[0] == 60);
     EXPECT(arg_values[7].as_native_fields.values[1] == 80);
 
     EXPECT_VALID(arg_values[8].as_instance);
     EXPECT(Dart_IsInstance(arg_values[8].as_instance));
     int field_count = 0;
-    EXPECT_VALID(Dart_GetNativeInstanceFieldCount(
-        arg_values[8].as_instance, &field_count));
+    EXPECT_VALID(Dart_GetNativeInstanceFieldCount(arg_values[8].as_instance,
+                                                  &field_count));
     EXPECT(field_count == 2);
   }
 
   // Test with an invalid descriptor set (invalid type).
   {
     const Dart_NativeArgument_Descriptor arg_descriptors[8] = {
-      { Dart_NativeArgument_kInt32, 1 },
-      { Dart_NativeArgument_kUint64, 2 },
-      { Dart_NativeArgument_kString, 3 },
-      { Dart_NativeArgument_kDouble, 4 },
-      { Dart_NativeArgument_kString, 5 },
-      { Dart_NativeArgument_kString, 6 },
-      { Dart_NativeArgument_kNativeFields, 0 },
-      { Dart_NativeArgument_kNativeFields, 7 },
+        {Dart_NativeArgument_kInt32, 1},
+        {Dart_NativeArgument_kUint64, 2},
+        {Dart_NativeArgument_kString, 3},
+        {Dart_NativeArgument_kDouble, 4},
+        {Dart_NativeArgument_kString, 5},
+        {Dart_NativeArgument_kString, 6},
+        {Dart_NativeArgument_kNativeFields, 0},
+        {Dart_NativeArgument_kNativeFields, 7},
     };
     Dart_NativeArgument_Value arg_values[8];
-    Dart_Handle result = Dart_GetNativeArguments(args,
-                                                 8,
-                                                 arg_descriptors,
-                                                 arg_values);
+    Dart_Handle result =
+        Dart_GetNativeArguments(args, 8, arg_descriptors, arg_values);
     EXPECT(Dart_IsError(result));
   }
 
   // Test with an invalid range error.
   {
     const Dart_NativeArgument_Descriptor arg_descriptors[8] = {
-      { Dart_NativeArgument_kInt32, 2 },
-      { Dart_NativeArgument_kUint64, 2 },
-      { Dart_NativeArgument_kBool, 3 },
-      { Dart_NativeArgument_kDouble, 4 },
-      { Dart_NativeArgument_kString, 5 },
-      { Dart_NativeArgument_kString, 6 },
-      { Dart_NativeArgument_kNativeFields, 0 },
-      { Dart_NativeArgument_kNativeFields, 7 },
+        {Dart_NativeArgument_kInt32, 2},
+        {Dart_NativeArgument_kUint64, 2},
+        {Dart_NativeArgument_kBool, 3},
+        {Dart_NativeArgument_kDouble, 4},
+        {Dart_NativeArgument_kString, 5},
+        {Dart_NativeArgument_kString, 6},
+        {Dart_NativeArgument_kNativeFields, 0},
+        {Dart_NativeArgument_kNativeFields, 7},
     };
     Dart_NativeArgument_Value arg_values[8];
-    Dart_Handle result = Dart_GetNativeArguments(args,
-                                                 8,
-                                                 arg_descriptors,
-                                                 arg_values);
+    Dart_Handle result =
+        Dart_GetNativeArguments(args, 8, arg_descriptors, arg_values);
     EXPECT(Dart_IsError(result));
   }
 
   Dart_SetIntegerReturnValue(args, 0);
 }
 
 
 static Dart_NativeFunction native_args_lookup(Dart_Handle name,
                                               int argument_count,
                                               bool* auto_scope_setup) {
@@ skipping 46 matching lines @@
   Dart_Handle lib = TestCase::LoadTestScript(
       kScriptChars,
       reinterpret_cast<Dart_NativeEntryResolver>(native_args_lookup));
 
   intptr_t size;
   Dart_Handle ascii_str = NewString("string");
   EXPECT_VALID(ascii_str);
   EXPECT_VALID(Dart_StringStorageSize(ascii_str, &size));
   uint8_t ext_ascii_str[10];
   Dart_Handle extstr = Dart_MakeExternalString(
-      ascii_str,
-      ext_ascii_str,
-      size,
-      reinterpret_cast<void*>(&native_arg_str_peer),
-      NULL);
+      ascii_str, ext_ascii_str, size,
+      reinterpret_cast<void*>(&native_arg_str_peer), NULL);
 
   Dart_Handle args[1];
   args[0] = extstr;
   Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 1, args);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
@@ skipping 19 matching lines @@
   const char* kScriptChars =
       "class MyObject {"
       "  int method1(int i, int j) native 'Name_Does_Not_Matter';"
       "}"
       "testMain() {"
       "  MyObject obj = new MyObject();"
       "  return obj.method1(77, 125);"
       "}";
 
   Dart_Handle lib = TestCase::LoadTestScript(
-      kScriptChars,
-      reinterpret_cast<Dart_NativeEntryResolver>(gnac_lookup));
+      kScriptChars, reinterpret_cast<Dart_NativeEntryResolver>(gnac_lookup));
 
   Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
 
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(3, value);
 }
@@ skipping 81 matching lines @@
 
   // Fetch OtherClass and check if instanceOfTestObj is instance of it.
   Dart_Handle otherType = Dart_GetType(lib, NewString("OtherClass"), 0, NULL);
   EXPECT_VALID(otherType);
 
   result = Dart_ObjectIsType(instanceOfTestObj, otherType, &is_instance);
   EXPECT_VALID(result);
   EXPECT(!is_instance);
 
   // Check that primitives are not instances of InstanceOfTest class.
-  result = Dart_ObjectIsType(NewString("a string"), otherType,
-                             &is_instance);
+  result = Dart_ObjectIsType(NewString("a string"), otherType, &is_instance);
   EXPECT_VALID(result);
   EXPECT(!is_instance);
 
   result = Dart_ObjectIsType(Dart_NewInteger(42), otherType, &is_instance);
   EXPECT_VALID(result);
   EXPECT(!is_instance);
 
   result = Dart_ObjectIsType(Dart_NewBoolean(true), otherType, &is_instance);
   EXPECT_VALID(result);
   EXPECT(!is_instance);
 
   // Check that null is not an instance of InstanceOfTest class.
-  Dart_Handle null = Dart_Invoke(otherType,
-                                 NewString("returnNull"),
-                                 0,
-                                 NULL);
+  Dart_Handle null = Dart_Invoke(otherType, NewString("returnNull"), 0, NULL);
   EXPECT_VALID(null);
 
   result = Dart_ObjectIsType(null, otherType, &is_instance);
   EXPECT_VALID(result);
   EXPECT(!is_instance);
 
   // Check that error is returned if null is passed as a class argument.
   result = Dart_ObjectIsType(null, null, &is_instance);
   EXPECT(Dart_IsError(result));
 }
@@ skipping 69 matching lines @@
   result = Dart_Invoke(result, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(12345, value);
 
   // Further calls to LoadScript are errors.
   result = Dart_LoadScript(url, Dart_Null(), source, 0, 0);
   EXPECT(Dart_IsError(result));
-  EXPECT_STREQ("Dart_LoadScript: "
-               "A script has already been loaded from 'test-lib'.",
-               Dart_GetError(result));
+  EXPECT_STREQ(
+      "Dart_LoadScript: "
+      "A script has already been loaded from 'test-lib'.",
+      Dart_GetError(result));
 }
 
 
 TEST_CASE(RootLibrary) {
   const char* kScriptChars =
       "library testlib;"
       "main() {"
       "  return 12345;"
       "}";
 
@@ skipping 79 matching lines @@
     default:
       EXPECT(false);
       return Api::NewError("invalid callback");
   }
   index += 1;
   return Api::Success();
 }
 
 
 TEST_CASE(LoadScript_CompileError) {
-  const char* kScriptChars =
-      ")";
+  const char* kScriptChars = ")";
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle source = NewString(kScriptChars);
   Dart_Handle result = Dart_SetLibraryTagHandler(import_library_handler);
   EXPECT_VALID(result);
   result = Dart_LoadScript(url, Dart_Null(), source, 0, 0);
   EXPECT(Dart_IsError(result));
   EXPECT(strstr(Dart_GetError(result), "unexpected token ')'"));
 }
 
 
@@ skipping 38 matching lines @@
 
   url = NewString("noodles.dart");
   result = Dart_LookupLibrary(url);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LookupLibrary: library 'noodles.dart' not found.",
                Dart_GetError(result));
 }
 
 
 TEST_CASE(LibraryName) {
-  const char* kLibrary1Chars =
-      "library library1_name;";
+  const char* kLibrary1Chars = "library library1_name;";
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   Dart_Handle error = Dart_NewApiError("incoming error");
   EXPECT_VALID(lib);
 
   Dart_Handle result = Dart_LibraryName(Dart_Null());
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LibraryName expects argument 'library' to be non-null.",
                Dart_GetError(result));
@@ skipping 14 matching lines @@
   const char* cstr = NULL;
   EXPECT_VALID(Dart_StringToCString(result, &cstr));
   EXPECT_STREQ("library1_name", cstr);
 }
 
 
 #ifndef PRODUCT
 
 
 TEST_CASE(LibraryId) {
-  const char* kLibrary1Chars =
-      "library library1_name;";
+  const char* kLibrary1Chars = "library library1_name;";
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   Dart_Handle error = Dart_NewApiError("incoming error");
   EXPECT_VALID(lib);
   intptr_t libraryId = -1;
 
   Dart_Handle result = Dart_LibraryId(Dart_Null(), &libraryId);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LibraryId expects argument 'library' to be non-null.",
@@ skipping 18 matching lines @@
   const char* cstr = NULL;
   EXPECT_VALID(Dart_StringToCString(result, &cstr));
   EXPECT_STREQ("library1_name", cstr);
 }
 
 
 #endif  // !PRODUCT
 
 
 TEST_CASE(LibraryUrl) {
-  const char* kLibrary1Chars =
-      "library library1_name;";
+  const char* kLibrary1Chars = "library library1_name;";
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   Dart_Handle error = Dart_NewApiError("incoming error");
   EXPECT_VALID(lib);
 
   Dart_Handle result = Dart_LibraryUrl(Dart_Null());
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LibraryUrl expects argument 'library' to be non-null.",
                Dart_GetError(result));
@@ skipping 122 matching lines @@
   // Check list contents.
   list_string = Dart_ToString(list);
   EXPECT_VALID(list_string);
   list_cstr = "";
   EXPECT_VALID(Dart_StringToCString(list_string, &list_cstr));
   EXPECT_STREQ("[A2, B2, C2=, MyClass, _A2, _B2, _C2=]", list_cstr);
 }
 
 
 TEST_CASE(LibraryImportLibrary) {
-  const char* kLibrary1Chars =
-      "library library1_name;";
-  const char* kLibrary2Chars =
-      "library library2_name;";
+  const char* kLibrary1Chars = "library library1_name;";
+  const char* kLibrary2Chars = "library library2_name;";
   Dart_Handle error = Dart_NewApiError("incoming error");
   Dart_Handle result;
 
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib1 = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   EXPECT_VALID(lib1);
 
   url = NewString("library2_url");
   source = NewString(kLibrary2Chars);
   Dart_Handle lib2 = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   EXPECT_VALID(lib2);
 
   result = Dart_LibraryImportLibrary(Dart_Null(), lib2, Dart_Null());
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ(
       "Dart_LibraryImportLibrary expects argument 'library' to be non-null.",
       Dart_GetError(result));
 
   result = Dart_LibraryImportLibrary(Dart_True(), lib2, Dart_Null());
   EXPECT(Dart_IsError(result));
-  EXPECT_STREQ("Dart_LibraryImportLibrary expects argument 'library' to be of "
-               "type Library.",
-               Dart_GetError(result));
+  EXPECT_STREQ(
+      "Dart_LibraryImportLibrary expects argument 'library' to be of "
+      "type Library.",
+      Dart_GetError(result));
 
   result = Dart_LibraryImportLibrary(error, lib2, Dart_Null());
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("incoming error", Dart_GetError(result));
 
   result = Dart_LibraryImportLibrary(lib1, Dart_Null(), Dart_Null());
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ(
       "Dart_LibraryImportLibrary expects argument 'import' to be non-null.",
       Dart_GetError(result));
 
   result = Dart_LibraryImportLibrary(lib1, Dart_True(), Dart_Null());
   EXPECT(Dart_IsError(result));
-  EXPECT_STREQ("Dart_LibraryImportLibrary expects argument 'import' to be of "
-               "type Library.",
-               Dart_GetError(result));
+  EXPECT_STREQ(
+      "Dart_LibraryImportLibrary expects argument 'import' to be of "
+      "type Library.",
+      Dart_GetError(result));
 
   result = Dart_LibraryImportLibrary(lib1, error, Dart_Null());
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("incoming error", Dart_GetError(result));
 
   result = Dart_LibraryImportLibrary(lib1, lib2, Dart_Null());
   EXPECT_VALID(result);
 }
 
 
@@ skipping 32 matching lines @@
   method_name = NewString("foobar");
   result = Dart_Invoke(lib2, method_name, 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(42, value);
 }
 
 
-
 TEST_CASE(LoadLibrary) {
-  const char* kLibrary1Chars =
-      "library library1_name;";
+  const char* kLibrary1Chars = "library library1_name;";
   Dart_Handle error = Dart_NewApiError("incoming error");
   Dart_Handle result;
 
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
 
   result = Dart_LoadLibrary(Dart_Null(), Dart_Null(), source, 0, 0);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LoadLibrary expects argument 'url' to be non-null.",
                Dart_GetError(result));
@@ skipping 52 matching lines @@
       ")";
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle result = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   EXPECT(Dart_IsError(result));
   EXPECT(strstr(Dart_GetError(result), "unexpected token ')'"));
 }
 
 
 TEST_CASE(LoadSource) {
-  const char* kLibrary1Chars =
-      "library library1_name;";
-  const char* kSourceChars =
-      "part of library1_name;\n// Something innocuous";
-  const char* kBadSourceChars =
-      ")";
+  const char* kLibrary1Chars = "library library1_name;";
+  const char* kSourceChars = "part of library1_name;\n// Something innocuous";
+  const char* kBadSourceChars = ")";
   Dart_Handle error = Dart_NewApiError("incoming error");
   Dart_Handle result;
 
   // Load up a library.
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   EXPECT_VALID(lib);
   EXPECT(Dart_IsLibrary(lib));
 
@@ skipping 117 matching lines @@
   result = Dart_Invoke(recv, NewString("bar"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
   result_cstr = "";
   EXPECT_VALID(Dart_StringToCString(result, &result_cstr));
   EXPECT_STREQ("bar", result_cstr);
 }
 
 
 TEST_CASE(LoadPatch) {
-  const char* kLibrary1Chars =
-      "library library1_name;";
+  const char* kLibrary1Chars = "library library1_name;";
   const char* kSourceChars =
       "part of library1_name;\n"
       "external int foo();";
-  const char* kPatchChars =
-      "@patch int foo() => 42;";
+  const char* kPatchChars = "@patch int foo() => 42;";
 
   // Load up a library.
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   EXPECT_VALID(lib);
   EXPECT(Dart_IsLibrary(lib));
 
   url = NewString("source_url");
   source = NewString(kSourceChars);
@@ skipping 14 matching lines @@
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(42, value);
 }
 
 TEST_CASE(LoadPatchSignatureMismatch) {
   // This tests the sort of APIs with intentional signature mismatches we need
   // for typed Dart-JavaScript interop where we emulated JavaScript semantics
   // for optional arguments.
-  const char* kLibrary1Chars =
-      "library library1_name;";
+  const char* kLibrary1Chars = "library library1_name;";
   const char* kSourceChars =
       "part of library1_name;\n"
       "external int foo([int x]);\n"
       "class Foo<T extends Foo> {\n"
       "  external static int addDefault10([int x, int y]);\n"
       "}";
   const char* kPatchChars =
       "const _UNDEFINED = const Object();\n"
       "@patch foo([x=_UNDEFINED]) => identical(x, _UNDEFINED) ? 42 : x;\n"
       "@patch class Foo<T> {\n"
@@ skipping 108 matching lines @@
                                                int arg_count,
                                                bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   return &PatchNativeFunction;
 }
 
 
 TEST_CASE(ParsePatchLibrary) {
   const char* kLibraryChars =
-  "library patched_library;\n"
-  "class A {\n"
-  "  final fvalue;\n"
-  "  var _f;\n"
-  "  callFunc(x, y) => x(y);\n"
-  "  external void method(var value);\n"
-  "  get field => _field;\n"
-  "}\n"
-  "class B {\n"
-  "  var val;\n"
-  "  external B.named(x);\n"
-  "  external B(v);\n"
-  "}\n"
-  "class C {\n"
-  "  external int method();\n"
-  "}\n"
-  "\n"
-  "external int unpatched();\n"
-  "external int topLevel(var value);\n"
-  "external int topLevel2(var value);\n"
-  "external int get topLevelGetter;\n"
-  "external void set topLevelSetter(int value);\n";
+      "library patched_library;\n"
+      "class A {\n"
+      "  final fvalue;\n"
+      "  var _f;\n"
+      "  callFunc(x, y) => x(y);\n"
+      "  external void method(var value);\n"
+      "  get field => _field;\n"
+      "}\n"
+      "class B {\n"
+      "  var val;\n"
+      "  external B.named(x);\n"
+      "  external B(v);\n"
+      "}\n"
+      "class C {\n"
+      "  external int method();\n"
+      "}\n"
+      "\n"
+      "external int unpatched();\n"
+      "external int topLevel(var value);\n"
+      "external int topLevel2(var value);\n"
+      "external int get topLevelGetter;\n"
+      "external void set topLevelSetter(int value);\n";
 
   const char* kPatchChars =
-  "@patch class A {\n"
-  "  var _g;\n"
-  "  A() : fvalue = 13;\n"
-  "  get _field => _g;\n"
-  "  @patch void method(var value) {\n"
-  "    int closeYourEyes(var eggs) { return eggs * -1; }\n"
-  "    value = callFunc(closeYourEyes, value);\n"
-  "    _g = value * 5;\n"
-  "  }\n"
-  "}\n"
-  "@patch class B {\n"
-  "  B._internal(x) : val = x;\n"
-  "  @patch factory B.named(x) { return new B._internal(x); }\n"
-  "  @patch factory B(v) native \"const_B_factory\";\n"
-  "}\n"
-  "var _topLevelValue = -1;\n"
-  "@patch int topLevel(var value) => value * value;\n"
-  "@patch int set topLevelSetter(value) { _topLevelValue = value; }\n"
-  "@patch int get topLevelGetter => 2 * _topLevelValue;\n"
-  // Allow top level methods named patch.
-  "patch(x) => x*3;\n"
-  ;  // NOLINT
+      "@patch class A {\n"
+      "  var _g;\n"
+      "  A() : fvalue = 13;\n"
+      "  get _field => _g;\n"
+      "  @patch void method(var value) {\n"
+      "    int closeYourEyes(var eggs) { return eggs * -1; }\n"
+      "    value = callFunc(closeYourEyes, value);\n"
+      "    _g = value * 5;\n"
+      "  }\n"
+      "}\n"
+      "@patch class B {\n"
+      "  B._internal(x) : val = x;\n"
+      "  @patch factory B.named(x) { return new B._internal(x); }\n"
+      "  @patch factory B(v) native \"const_B_factory\";\n"
+      "}\n"
+      "var _topLevelValue = -1;\n"
+      "@patch int topLevel(var value) => value * value;\n"
+      "@patch int set topLevelSetter(value) { _topLevelValue = value; }\n"
+      "@patch int get topLevelGetter => 2 * _topLevelValue;\n"
+      // Allow top level methods named patch.
+      "patch(x) => x*3;\n";  // NOLINT
 
   const char* kPatchClassOnlyChars =
-  "@patch class C {\n"
-  "  @patch int method() {\n"
-  "    return 42;\n"
-  "  }\n"
-  "}\n"
-  ;  // NOLINT
+      "@patch class C {\n"
+      "  @patch int method() {\n"
+      "    return 42;\n"
+      "  }\n"
+      "}\n";  // NOLINT
 
-  const char* kPatchNoClassChars =
-  "@patch topLevel2(x) => x * 2;\n";
+  const char* kPatchNoClassChars = "@patch topLevel2(x) => x * 2;\n";
 
   const char* kScriptChars =
-  "import 'theLibrary';\n"
-  "e1() => unpatched();\n"
-  "m1() => topLevel(2);\n"
-  "m2() {\n"
-  "  topLevelSetter = 20;\n"
-  "  return topLevelGetter;\n"
-  "}\n"
-  "m3() => patch(7);\n"
-  "m4() {\n"
-  "  var a = new A();\n"
-  "  a.method(5);\n"
-  "  return a.field;\n"
-  "}\n"
-  "m5() => new B(3);\n"
-  "m6() {\n"
-  "  var b = new B.named(8);\n"
-  "  return b.val;\n"
-  "}\n"
-  ;  // NOLINT
+      "import 'theLibrary';\n"
+      "e1() => unpatched();\n"
+      "m1() => topLevel(2);\n"
+      "m2() {\n"
+      "  topLevelSetter = 20;\n"
+      "  return topLevelGetter;\n"
+      "}\n"
+      "m3() => patch(7);\n"
+      "m4() {\n"
+      "  var a = new A();\n"
+      "  a.method(5);\n"
+      "  return a.field;\n"
+      "}\n"
+      "m5() => new B(3);\n"
+      "m6() {\n"
+      "  var b = new B.named(8);\n"
+      "  return b.val;\n"
+      "}\n";  // NOLINT
 
   bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
   bin::Builtin::SetNativeResolver(bin::Builtin::kIOLibrary);
 
   Dart_Handle result = Dart_SetLibraryTagHandler(library_handler);
   EXPECT_VALID(result);
 
   Dart_Handle url = NewString("theLibrary");
   Dart_Handle source = NewString(kLibraryChars);
   result = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   EXPECT_VALID(result);
 
-  const char* patchNames[] = { "main library patch",
-                               "patch class only",
-                               "patch no class" };
-  const char* patches[] = { kPatchChars,
-                            kPatchClassOnlyChars,
-                            kPatchNoClassChars };
+  const char* patchNames[] = {"main library patch", "patch class only",
+                              "patch no class"};
+  const char* patches[] = {kPatchChars, kPatchClassOnlyChars,
+                           kPatchNoClassChars};
   const String& lib_url = String::Handle(String::New("theLibrary"));
 
   const Library& lib = Library::Handle(Library::LookupLibrary(thread, lib_url));
 
   for (int i = 0; i < 3; i++) {
     const String& patch_url = String::Handle(String::New(patchNames[i]));
     const String& patch_source = String::Handle(String::New(patches[i]));
-    const Script& patch_script = Script::Handle(Script::New(
-        patch_url, patch_source, RawScript::kPatchTag));
+    const Script& patch_script = Script::Handle(
+        Script::New(patch_url, patch_source, RawScript::kPatchTag));
 
     const Error& err = Error::Handle(lib.Patch(patch_script));
     if (!err.IsNull()) {
       OS::Print("Patching error: %s\n", err.ToErrorCString());
       EXPECT(false);
     }
   }
   result = Dart_SetNativeResolver(result, &PatchNativeResolver, NULL);
   EXPECT_VALID(result);
 
@@ skipping 113 matching lines @@
   EXPECT_VALID(type);
 
   result = Dart_SetNativeResolver(Dart_Null(), &MyNativeResolver1, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ(
       "Dart_SetNativeResolver expects argument 'library' to be non-null.",
       Dart_GetError(result));
 
   result = Dart_SetNativeResolver(Dart_True(), &MyNativeResolver1, NULL);
   EXPECT(Dart_IsError(result));
-  EXPECT_STREQ("Dart_SetNativeResolver expects argument 'library' to be of "
-               "type Library.",
-               Dart_GetError(result));
+  EXPECT_STREQ(
+      "Dart_SetNativeResolver expects argument 'library' to be of "
+      "type Library.",
+      Dart_GetError(result));
 
   result = Dart_SetNativeResolver(error, &MyNativeResolver1, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("incoming error", Dart_GetError(result));
 
   result = Dart_SetNativeResolver(lib, &MyNativeResolver1, NULL);
   EXPECT_VALID(result);
 
   // Call a function and make sure native resolution works.
   result = Dart_Invoke(type, NewString("foo"), 0, NULL);
@@ skipping 172 matching lines @@
   url = NewString("lib.dart");
   source = NewString(kLibraryChars);
   Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   Dart_FinalizeLoading(false);
 
   result = Dart_Invoke(result, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
-void NewNativePort_send123(Dart_Port dest_port_id,
-                           Dart_CObject *message) {
+void NewNativePort_send123(Dart_Port dest_port_id, Dart_CObject* message) {
   // Gets a send port message.
   EXPECT_NOTNULL(message);
   EXPECT_EQ(Dart_CObject_kArray, message->type);
   EXPECT_EQ(Dart_CObject_kSendPort, message->value.as_array.values[0]->type);
 
   // Post integer value.
   Dart_CObject* response =
       reinterpret_cast<Dart_CObject*>(Dart_ScopeAllocate(sizeof(Dart_CObject)));
   response->type = Dart_CObject_kInt32;
   response->value.as_int32 = 123;
-  Dart_PostCObject(
-      message->value.as_array.values[0]->value.as_send_port.id, response);
+  Dart_PostCObject(message->value.as_array.values[0]->value.as_send_port.id,
+                   response);
 }
 
 
-void NewNativePort_send321(Dart_Port dest_port_id,
-                           Dart_CObject* message) {
+void NewNativePort_send321(Dart_Port dest_port_id, Dart_CObject* message) {
   // Gets a null message.
   EXPECT_NOTNULL(message);
   EXPECT_EQ(Dart_CObject_kArray, message->type);
   EXPECT_EQ(Dart_CObject_kSendPort, message->value.as_array.values[0]->type);
 
   // Post integer value.
   Dart_CObject* response =
       reinterpret_cast<Dart_CObject*>(Dart_ScopeAllocate(sizeof(Dart_CObject)));
   response->type = Dart_CObject_kInt32;
   response->value.as_int32 = 321;
-  Dart_PostCObject(
-      message->value.as_array.values[0]->value.as_send_port.id, response);
+  Dart_PostCObject(message->value.as_array.values[0]->value.as_send_port.id,
+                   response);
 }
 
 
 TEST_CASE(IllegalNewSendPort) {
   Dart_Handle error = Dart_NewSendPort(ILLEGAL_PORT);
   EXPECT(Dart_IsError(error));
   EXPECT(Dart_IsApiError(error));
 }
 
 
@@ skipping 33 matching lines @@
       Dart_NewNativePort("Port321", NewNativePort_send321, true);
 
   Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
   EXPECT_VALID(send_port1);
   Dart_Handle send_port2 = Dart_NewSendPort(port_id2);
   EXPECT_VALID(send_port2);
 
   // Test first port.
   Dart_Handle dart_args[1];
   dart_args[0] = send_port1;
-  Dart_Handle result =
-      Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
+  Dart_Handle result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
   EXPECT_VALID(result);
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: 123\n", Dart_GetError(result));
 
   // result second port.
   dart_args[0] = send_port2;
   result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
   EXPECT_VALID(result);
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: 321\n", Dart_GetError(result));
 
   Dart_ExitScope();
 
   // Delete the native ports.
   EXPECT(Dart_CloseNativePort(port_id1));
   EXPECT(Dart_CloseNativePort(port_id2));
 }
 
 
 void NewNativePort_sendInteger123(Dart_Port dest_port_id,
-                                  Dart_CObject *message) {
+                                  Dart_CObject* message) {
   // Gets a send port message.
   EXPECT_NOTNULL(message);
   EXPECT_EQ(Dart_CObject_kArray, message->type);
   EXPECT_EQ(Dart_CObject_kSendPort, message->value.as_array.values[0]->type);
 
   // Post integer value.
-  Dart_PostInteger(
-      message->value.as_array.values[0]->value.as_send_port.id, 123);
+  Dart_PostInteger(message->value.as_array.values[0]->value.as_send_port.id,
+                   123);
 }
 
 
 void NewNativePort_sendInteger321(Dart_Port dest_port_id,
                                   Dart_CObject* message) {
   // Gets a null message.
   EXPECT_NOTNULL(message);
   EXPECT_EQ(Dart_CObject_kArray, message->type);
   EXPECT_EQ(Dart_CObject_kSendPort, message->value.as_array.values[0]->type);
 
   // Post integer value.
-  Dart_PostInteger(
-      message->value.as_array.values[0]->value.as_send_port.id, 321);
+  Dart_PostInteger(message->value.as_array.values[0]->value.as_send_port.id,
+                   321);
 }
 
 
 TEST_CASE(NativePortPostInteger) {
   const char* kScriptChars =
       "import 'dart:isolate';\n"
       "void callPort(SendPort port) {\n"
       "  var receivePort = new RawReceivePort();\n"
       "  var replyPort = receivePort.sendPort;\n"
       "  port.send([replyPort]);\n"
@@ skipping 11 matching lines @@
       Dart_NewNativePort("Port321", NewNativePort_sendInteger321, true);
 
   Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
   EXPECT_VALID(send_port1);
   Dart_Handle send_port2 = Dart_NewSendPort(port_id2);
   EXPECT_VALID(send_port2);
 
   // Test first port.
   Dart_Handle dart_args[1];
   dart_args[0] = send_port1;
-  Dart_Handle result =
-      Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
+  Dart_Handle result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
   EXPECT_VALID(result);
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: 123\n", Dart_GetError(result));
 
   // result second port.
   dart_args[0] = send_port2;
   result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
   EXPECT_VALID(result);
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: 321\n", Dart_GetError(result));
 
   Dart_ExitScope();
 
   // Delete the native ports.
   EXPECT(Dart_CloseNativePort(port_id1));
   EXPECT(Dart_CloseNativePort(port_id2));
 }
 
 
 void NewNativePort_nativeReceiveNull(Dart_Port dest_port_id,
-                                     Dart_CObject *message) {
+                                     Dart_CObject* message) {
   EXPECT_NOTNULL(message);
 
   if ((message->type == Dart_CObject_kArray) &&
       (message->value.as_array.values[0]->type == Dart_CObject_kSendPort)) {
     // Post integer value.
-    Dart_PostInteger(
-        message->value.as_array.values[0]->value.as_send_port.id, 123);
+    Dart_PostInteger(message->value.as_array.values[0]->value.as_send_port.id,
+                     123);
   } else {
     EXPECT_EQ(message->type, Dart_CObject_kNull);
   }
 }
 
 
 TEST_CASE(NativePortReceiveNull) {
   const char* kScriptChars =
       "import 'dart:isolate';\n"
       "void callPort(SendPort port) {\n"
@@ skipping 10 matching lines @@
   Dart_EnterScope();
 
   Dart_Port port_id1 =
       Dart_NewNativePort("PortNull", NewNativePort_nativeReceiveNull, true);
   Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
   EXPECT_VALID(send_port1);
 
   // Test first port.
   Dart_Handle dart_args[1];
   dart_args[0] = send_port1;
-  Dart_Handle result =
-      Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
+  Dart_Handle result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
   EXPECT_VALID(result);
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: 123\n", Dart_GetError(result));
 
   Dart_ExitScope();
 
   // Delete the native ports.
   EXPECT(Dart_CloseNativePort(port_id1));
 }
 
 
 void NewNativePort_nativeReceiveInteger(Dart_Port dest_port_id,
-                                        Dart_CObject *message) {
+                                        Dart_CObject* message) {
   EXPECT_NOTNULL(message);
 
   if ((message->type == Dart_CObject_kArray) &&
       (message->value.as_array.values[0]->type == Dart_CObject_kSendPort)) {
     // Post integer value.
-    Dart_PostInteger(
-        message->value.as_array.values[0]->value.as_send_port.id, 123);
+    Dart_PostInteger(message->value.as_array.values[0]->value.as_send_port.id,
+                     123);
   } else {
     EXPECT_EQ(message->type, Dart_CObject_kInt32);
     EXPECT_EQ(message->value.as_int32, 321);
   }
 }
 
 
 TEST_CASE(NativePortReceiveInteger) {
   const char* kScriptChars =
       "import 'dart:isolate';\n"
@@ skipping 11 matching lines @@
   Dart_EnterScope();
 
   Dart_Port port_id1 =
       Dart_NewNativePort("PortNull", NewNativePort_nativeReceiveInteger, true);
   Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
   EXPECT_VALID(send_port1);
 
   // Test first port.
   Dart_Handle dart_args[1];
   dart_args[0] = send_port1;
-  Dart_Handle result =
-      Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
+  Dart_Handle result = Dart_Invoke(lib, NewString("callPort"), 1, dart_args);
   EXPECT_VALID(result);
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: 123\n", Dart_GetError(result));
 
   Dart_ExitScope();
 
   // Delete the native ports.
   EXPECT(Dart_CloseNativePort(port_id1));
@@ skipping 43 matching lines @@
   bool retval = Dart_IsolateMakeRunnable(isolate);
   EXPECT(retval);
   return isolate;
 }
 
 
 // Common code for RunLoop_Success/RunLoop_Failure.
 static void RunLoopTest(bool throw_exception) {
   Dart_IsolateCreateCallback saved = Isolate::CreateCallback();
   Isolate::SetCreateCallback(RunLoopTestCallback);
-  Dart_Isolate isolate = RunLoopTestCallback(
-      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  Dart_Isolate isolate =
+      RunLoopTestCallback(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 
   Dart_EnterIsolate(isolate);
   Dart_EnterScope();
   Dart_Handle lib = Dart_LookupLibrary(NewString(TestCase::url()));
   EXPECT_VALID(lib);
 
   Dart_Handle result;
   Dart_Handle args[1];
   args[0] = (throw_exception ? Dart_True() : Dart_False());
   result = Dart_Invoke(lib, NewString("main"), 1, args);
@@ skipping 35 matching lines @@
     MonitorLocker ml(sync);
     main_entered = true;
     ml.Notify();
   }
   Dart_SetReturnValue(args, Dart_Null());
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction IsolateInterruptTestNativeLookup(
-    Dart_Handle name, int argument_count, bool* auto_setup_scope) {
+    Dart_Handle name,
+    int argument_count,
+    bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&MarkMainEntered);
 }
 
 
 void BusyLoop_start(uword unused) {
   const char* kScriptChars =
       "class Native {\n"
       "  static void markMainEntered() native 'MarkMainEntered';\n"
       "}\n"
       "\n"
       "void main() {\n"
       "  Native.markMainEntered();\n"
       "  while (true) {\n"  // Infinite empty loop.
       "  }\n"
       "}\n";
 
   // Tell the other thread that shared_isolate is created.
   Dart_Handle lib;
   {
     MonitorLocker ml(sync);
     char* error = NULL;
-    shared_isolate = Dart_CreateIsolate(NULL, NULL,
-                                        bin::isolate_snapshot_buffer,
-                                        NULL,
-                                        NULL, &error);
+    shared_isolate = Dart_CreateIsolate(
+        NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL, &error);
     EXPECT(shared_isolate != NULL);
     Dart_EnterScope();
     Dart_Handle url = NewString(TestCase::url());
     Dart_Handle source = NewString(kScriptChars);
     Dart_Handle result = Dart_SetLibraryTagHandler(TestCase::library_handler);
     EXPECT_VALID(result);
     lib = Dart_LoadScript(url, Dart_Null(), source, 0, 0);
     EXPECT_VALID(lib);
     result = Dart_FinalizeLoading(false);
     EXPECT_VALID(result);
     result =
         Dart_SetNativeResolver(lib, &IsolateInterruptTestNativeLookup, NULL);
     DART_CHECK_VALID(result);
 
     ml.Notify();
   }
 
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
-  EXPECT_SUBSTRING("Unhandled exception:\nfoo\n",
-                   Dart_GetError(result));
+  EXPECT_SUBSTRING("Unhandled exception:\nfoo\n", Dart_GetError(result));
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
   // Tell the other thread that we are done.
   {
     MonitorLocker ml(sync);
     shared_isolate = NULL;
     ml.Notify();
   }
 }
 
 
 static void* saved_callback_data;
 static void IsolateShutdownTestCallback(void* callback_data) {
   saved_callback_data = callback_data;
 }
 
 UNIT_TEST_CASE(IsolateShutdown) {
   Dart_IsolateShutdownCallback saved = Isolate::ShutdownCallback();
   Isolate::SetShutdownCallback(IsolateShutdownTestCallback);
 
   saved_callback_data = NULL;
 
   void* my_data = reinterpret_cast<void*>(12345);
 
   // Create an isolate.
   char* err;
-  Dart_Isolate isolate = Dart_CreateIsolate(NULL, NULL,
-                                            bin::isolate_snapshot_buffer,
-                                            NULL,
-                                            my_data, &err);
+  Dart_Isolate isolate = Dart_CreateIsolate(
+      NULL, NULL, bin::isolate_snapshot_buffer, NULL, my_data, &err);
   if (isolate == NULL) {
     OS::Print("Creation of isolate failed '%s'\n", err);
     free(err);
   }
   EXPECT(isolate != NULL);
 
   // The shutdown callback has not been called.
   EXPECT_EQ(0, reinterpret_cast<intptr_t>(saved_callback_data));
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
   // The shutdown callback has been called.
   EXPECT_EQ(12345, reinterpret_cast<intptr_t>(saved_callback_data));
 
   Isolate::SetShutdownCallback(saved);
 }
 
 static int64_t add_result = 0;
 static void IsolateShutdownRunDartCodeTestCallback(void* callback_data) {
   Dart_EnterScope();
   Dart_Handle lib = Dart_RootLibrary();
   EXPECT_VALID(lib);
   Dart_Handle arg1 = Dart_NewInteger(90);
   EXPECT_VALID(arg1);
   Dart_Handle arg2 = Dart_NewInteger(9);
   EXPECT_VALID(arg2);
-  Dart_Handle dart_args[2] = { arg1, arg2 };
+  Dart_Handle dart_args[2] = {arg1, arg2};
   Dart_Handle result = Dart_Invoke(lib, NewString("add"), 2, dart_args);
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &add_result);
   EXPECT_VALID(result);
   Dart_ExitScope();
 }
 
 UNIT_TEST_CASE(IsolateShutdownRunDartCode) {
   const char* kScriptChars =
       "int add(int a, int b) {\n"
       "  return a + b;\n"
       "}\n"
       "\n"
       "void main() {\n"
       "  add(4, 5);\n"
       "}\n";
 
   // Create an isolate.
   char* err;
-  Dart_Isolate isolate = Dart_CreateIsolate(NULL, NULL,
-                                            bin::isolate_snapshot_buffer,
-                                            NULL,
-                                            NULL, &err);
+  Dart_Isolate isolate = Dart_CreateIsolate(
+      NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL, &err);
   if (isolate == NULL) {
     OS::Print("Creation of isolate failed '%s'\n", err);
     free(err);
   }
   EXPECT(isolate != NULL);
 
   Isolate::SetShutdownCallback(IsolateShutdownRunDartCodeTestCallback);
 
   {
     Dart_EnterScope();
@@ skipping 44 matching lines @@
 
 static void NativeFoo2(Dart_NativeArguments args) {
   Dart_EnterScope();
   intptr_t i = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(2, i);
   Dart_Handle arg1 = Dart_GetNativeArgument(args, 1);
   EXPECT_VALID(arg1);
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(arg1, &value));
   int64_t integer_value = 0;
-  Dart_Handle result = Dart_GetNativeIntegerArgument(args,
-                                                     1,
-                                                     &integer_value);
+  Dart_Handle result = Dart_GetNativeIntegerArgument(args, 1, &integer_value);
   EXPECT_VALID(result);
   EXPECT_EQ(value, integer_value);
   double double_value;
   result = Dart_GetNativeDoubleArgument(args, 1, &double_value);
   EXPECT_VALID(result);
   bool bool_value;
   result = Dart_GetNativeBooleanArgument(args, 1, &bool_value);
   EXPECT(Dart_IsError(result));
   Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg1)));
   Dart_ExitScope();
@@ skipping 11 matching lines @@
 }
 
 
 static void NativeFoo4(Dart_NativeArguments args) {
   Dart_EnterScope();
   intptr_t i = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(4, i);
   Dart_Handle arg1 = Dart_GetNativeArgument(args, 1);
   Dart_Handle arg2 = Dart_GetNativeArgument(args, 2);
   Dart_Handle arg3 = Dart_GetNativeArgument(args, 3);
-  Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg1) +
-                                            GetValue(arg2) +
-                                            GetValue(arg3)));
+  Dart_SetReturnValue(
+      args, Dart_NewInteger(GetValue(arg1) + GetValue(arg2) + GetValue(arg3)));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction MyNativeClosureResolver(Dart_Handle name,
                                                    int arg_count,
                                                    bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   const Object& obj = Object::Handle(Api::UnwrapHandle(name));
@@ skipping 126 matching lines @@
 }
 
 
 static void StaticNativeFoo4(Dart_NativeArguments args) {
   Dart_EnterScope();
   intptr_t i = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(3, i);
   Dart_Handle arg1 = Dart_GetNativeArgument(args, 0);
   Dart_Handle arg2 = Dart_GetNativeArgument(args, 1);
   Dart_Handle arg3 = Dart_GetNativeArgument(args, 2);
-  Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg1) +
-                                            GetValue(arg2) +
-                                            GetValue(arg3)));
+  Dart_SetReturnValue(
+      args, Dart_NewInteger(GetValue(arg1) + GetValue(arg2) + GetValue(arg3)));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction MyStaticNativeClosureResolver(
-    Dart_Handle name, int arg_count, bool* auto_setup_scope) {
+    Dart_Handle name,
+    int arg_count,
+    bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   const Object& obj = Object::Handle(Api::UnwrapHandle(name));
   if (!obj.IsString()) {
     return NULL;
   }
   const char* function_name = obj.ToCString();
   const char* kNativeFoo1 = "StaticNativeFoo1";
   const char* kNativeFoo2 = "StaticNativeFoo2";
   const char* kNativeFoo3 = "StaticNativeFoo3";
@@ skipping 12 matching lines @@
   }
 }
 
 
 TEST_CASE(NativeStaticFunctionClosure) {
   const char* kScriptChars =
       "class Test {"
       "  static int foo1() native \"StaticNativeFoo1\";\n"
       "  static int foo2(int i) native \"StaticNativeFoo2\";\n"
       "  static int foo3([int k = 10000, int l = 1])"
-            " native \"StaticNativeFoo3\";\n"
+      " native \"StaticNativeFoo3\";\n"
       "  static int foo4(int i, [int j = 10, int k = 1])"
-            " native \"StaticNativeFoo4\";\n"
+      " native \"StaticNativeFoo4\";\n"
       "  int bar1() { var func = foo1; return func(); }\n"
       "  int bar2(int i) { var func = foo2; return func(i); }\n"
       "  int bar30() { var func = foo3; return func(); }\n"
       "  int bar31(int i) { var func = foo3; return func(i); }\n"
       "  int bar32(int i, int j) { var func = foo3; return func(i, j); }\n"
       "  int bar41(int i) {\n"
       "    var func = foo4; return func(i); }\n"
       "  int bar42(int i, int j) {\n"
       "    var func = foo4; return func(i, j); }\n"
       "  int bar43(int i, int j, int k) {\n"
@@ skipping 55 matching lines @@
 }
 
 
 TEST_CASE(RangeLimits) {
   uint8_t chars8[1] = {'a'};
   uint16_t chars16[1] = {'a'};
   int32_t chars32[1] = {'a'};
 
   EXPECT_ERROR(Dart_NewList(-1),
                "expects argument 'length' to be in the range");
-  EXPECT_ERROR(Dart_NewList(Array::kMaxElements+1),
+  EXPECT_ERROR(Dart_NewList(Array::kMaxElements + 1),
                "expects argument 'length' to be in the range");
   EXPECT_ERROR(Dart_NewStringFromUTF8(chars8, -1),
                "expects argument 'length' to be in the range");
-  EXPECT_ERROR(Dart_NewStringFromUTF8(chars8, OneByteString::kMaxElements+1),
+  EXPECT_ERROR(Dart_NewStringFromUTF8(chars8, OneByteString::kMaxElements + 1),
                "expects argument 'length' to be in the range");
   EXPECT_ERROR(Dart_NewStringFromUTF16(chars16, -1),
                "expects argument 'length' to be in the range");
-  EXPECT_ERROR(Dart_NewStringFromUTF16(chars16, TwoByteString::kMaxElements+1),
-               "expects argument 'length' to be in the range");
+  EXPECT_ERROR(
+      Dart_NewStringFromUTF16(chars16, TwoByteString::kMaxElements + 1),
+      "expects argument 'length' to be in the range");
   EXPECT_ERROR(Dart_NewStringFromUTF32(chars32, -1),
                "expects argument 'length' to be in the range");
-  EXPECT_ERROR(Dart_NewStringFromUTF32(chars32, TwoByteString::kMaxElements+1),
-               "expects argument 'length' to be in the range");
+  EXPECT_ERROR(
+      Dart_NewStringFromUTF32(chars32, TwoByteString::kMaxElements + 1),
+      "expects argument 'length' to be in the range");
 }
 
 
 TEST_CASE(NewString_Null) {
   Dart_Handle str = Dart_NewStringFromUTF8(NULL, 0);
   EXPECT_VALID(str);
   EXPECT(Dart_IsString(str));
   intptr_t len = -1;
   EXPECT_VALID(Dart_StringLength(str, &len));
   EXPECT_EQ(0, len);
@@ skipping 445 matching lines @@
 
   static int peer8 = 40;
   static int peer16 = 41;
   static int canonical_str_peer = 42;
   intptr_t length = 0;
   intptr_t expected_length = 0;
   {
     Dart_EnterScope();
 
     // First test some negative conditions.
-    uint8_t data8[] = { 'h', 'e', 'l', 'l', 'o' };
+    uint8_t data8[] = {'h', 'e', 'l', 'l', 'o'};
     const char* err = "string";
     Dart_Handle err_str = NewString(err);
-    Dart_Handle ext_err_str = Dart_NewExternalLatin1String(
-        data8, ARRAY_SIZE(data8), NULL, NULL);
-    Dart_Handle result = Dart_MakeExternalString(Dart_Null(),
-                                                 data8,
-                                                 ARRAY_SIZE(data8),
-                                                 NULL,
-                                                 NULL);
+    Dart_Handle ext_err_str =
+        Dart_NewExternalLatin1String(data8, ARRAY_SIZE(data8), NULL, NULL);
+    Dart_Handle result = Dart_MakeExternalString(Dart_Null(), data8,
+                                                 ARRAY_SIZE(data8), NULL, NULL);
     EXPECT(Dart_IsError(result));  // Null string object passed in.
-    result = Dart_MakeExternalString(err_str,
-                                     NULL,
-                                     ARRAY_SIZE(data8),
-                                     NULL,
-                                     NULL);
+    result =
+        Dart_MakeExternalString(err_str, NULL, ARRAY_SIZE(data8), NULL, NULL);
     EXPECT(Dart_IsError(result));  // Null array pointer passed in.
-    result = Dart_MakeExternalString(err_str,
-                                     data8,
-                                     1,
-                                     NULL,
-                                     NULL);
+    result = Dart_MakeExternalString(err_str, data8, 1, NULL, NULL);
     EXPECT(Dart_IsError(result));  // Invalid length passed in.
 
     const intptr_t kLength = 10;
     intptr_t size = 0;
 
     // Test with an external string.
-    result = Dart_MakeExternalString(ext_err_str,
-                                     data8,
-                                     ARRAY_SIZE(data8),
-                                     NULL,
-                                     NULL);
+    result = Dart_MakeExternalString(ext_err_str, data8, ARRAY_SIZE(data8),
+                                     NULL, NULL);
     EXPECT(Dart_IsString(result));
     EXPECT(Dart_IsExternalString(result));
 
     // Test with an empty string.
     Dart_Handle empty_str = NewString("");
     EXPECT(Dart_IsString(empty_str));
     EXPECT(!Dart_IsExternalString(empty_str));
     uint8_t ext_empty_str[kLength];
-    Dart_Handle str = Dart_MakeExternalString(empty_str,
-                                              ext_empty_str,
-                                              kLength,
-                                              NULL,
-                                              NULL);
+    Dart_Handle str =
+        Dart_MakeExternalString(empty_str, ext_empty_str, kLength, NULL, NULL);
     EXPECT(Dart_IsString(str));
     EXPECT(Dart_IsString(empty_str));
     EXPECT(Dart_IsStringLatin1(str));
     EXPECT(Dart_IsStringLatin1(empty_str));
     EXPECT(Dart_IsExternalString(str));
     EXPECT(Dart_IsExternalString(empty_str));
     EXPECT_VALID(Dart_StringLength(str, &length));
     EXPECT_EQ(0, length);
 
     // Test with single character canonical string, it should not become
     // external string but the peer should be setup for it.
-    Dart_Handle canonical_str = Api::NewHandle(thread, Symbols::New(thread,
-                                                                    "*"));
+    Dart_Handle canonical_str =
+        Api::NewHandle(thread, Symbols::New(thread, "*"));
     EXPECT(Dart_IsString(canonical_str));
     EXPECT(!Dart_IsExternalString(canonical_str));
     uint8_t ext_canonical_str[kLength];
-    str = Dart_MakeExternalString(canonical_str,
-                                  ext_canonical_str,
-                                  kLength,
-                                  &canonical_str_peer,
-                                  MakeExternalCback);
+    str = Dart_MakeExternalString(canonical_str, ext_canonical_str, kLength,
+                                  &canonical_str_peer, MakeExternalCback);
     EXPECT(Dart_IsString(str));
     EXPECT(!Dart_IsExternalString(canonical_str));
     EXPECT_EQ(canonical_str, str);
     EXPECT(Dart_IsString(canonical_str));
     EXPECT(!Dart_IsExternalString(canonical_str));
     void* peer;
     EXPECT_VALID(Dart_StringGetProperties(str, &size, &length, &peer));
     EXPECT_EQ(1, size);
     EXPECT_EQ(1, length);
     EXPECT_EQ(reinterpret_cast<void*>(&canonical_str_peer), peer);
 
     // Test with a one byte ascii string.
     const char* ascii = "?unseen";
     expected_length = strlen(ascii);
     Dart_Handle ascii_str = NewString(ascii);
     EXPECT_VALID(ascii_str);
     EXPECT(Dart_IsString(ascii_str));
     EXPECT(Dart_IsStringLatin1(ascii_str));
     EXPECT(!Dart_IsExternalString(ascii_str));
     EXPECT_VALID(Dart_StringLength(ascii_str, &length));
     EXPECT_EQ(expected_length, length);
 
     uint8_t ext_ascii_str[kLength];
     EXPECT_VALID(Dart_StringStorageSize(ascii_str, &size));
-    str = Dart_MakeExternalString(ascii_str,
-                                  ext_ascii_str,
-                                  size,
-                                  &peer8,
+    str = Dart_MakeExternalString(ascii_str, ext_ascii_str, size, &peer8,
                                   MakeExternalCback);
     EXPECT(Dart_IsString(str));
     EXPECT(Dart_IsString(ascii_str));
     EXPECT(Dart_IsStringLatin1(str));
     EXPECT(Dart_IsStringLatin1(ascii_str));
     EXPECT(Dart_IsExternalString(str));
     EXPECT(Dart_IsExternalString(ascii_str));
     EXPECT_VALID(Dart_StringLength(str, &length));
     EXPECT_EQ(expected_length, length);
     EXPECT_VALID(Dart_StringLength(ascii_str, &length));
     EXPECT_EQ(expected_length, length);
     EXPECT(Dart_IdentityEquals(str, ascii_str));
     for (intptr_t i = 0; i < length; i++) {
       EXPECT_EQ(ascii[i], ext_ascii_str[i]);
     }
 
-    uint8_t data[] = { 0xE4, 0xBA, 0x8c };  // U+4E8C.
+    uint8_t data[] = {0xE4, 0xBA, 0x8c};  // U+4E8C.
     expected_length = 1;
     Dart_Handle utf16_str = Dart_NewStringFromUTF8(data, ARRAY_SIZE(data));
     EXPECT_VALID(utf16_str);
     EXPECT(Dart_IsString(utf16_str));
     EXPECT(!Dart_IsStringLatin1(utf16_str));
     EXPECT(!Dart_IsExternalString(utf16_str));
     EXPECT_VALID(Dart_StringLength(utf16_str, &length));
     EXPECT_EQ(expected_length, length);
 
     // Test with a two byte string.
     uint16_t ext_utf16_str[kLength];
     EXPECT_VALID(Dart_StringStorageSize(utf16_str, &size));
-    str = Dart_MakeExternalString(utf16_str,
-                                  ext_utf16_str,
-                                  size,
-                                  &peer16,
+    str = Dart_MakeExternalString(utf16_str, ext_utf16_str, size, &peer16,
                                   MakeExternalCback);
     EXPECT(Dart_IsString(str));
     EXPECT(Dart_IsString(utf16_str));
     EXPECT(!Dart_IsStringLatin1(str));
     EXPECT(!Dart_IsStringLatin1(utf16_str));
     EXPECT(Dart_IsExternalString(str));
     EXPECT(Dart_IsExternalString(utf16_str));
     EXPECT_VALID(Dart_StringLength(str, &length));
     EXPECT_EQ(expected_length, length);
     EXPECT_VALID(Dart_StringLength(utf16_str, &length));
     EXPECT_EQ(expected_length, length);
     EXPECT(Dart_IdentityEquals(str, utf16_str));
     for (intptr_t i = 0; i < length; i++) {
       EXPECT_EQ(0x4e8c, ext_utf16_str[i]);
     }
 
     Zone* zone = thread->zone();
     // Test with a symbol (hash value should be preserved on externalization).
     const char* symbol_ascii = "?unseen";
     expected_length = strlen(symbol_ascii);
-    Dart_Handle symbol_str = Api::NewHandle(thread,
-        Symbols::New(thread, symbol_ascii, expected_length));
+    Dart_Handle symbol_str = Api::NewHandle(
+        thread, Symbols::New(thread, symbol_ascii, expected_length));
     EXPECT_VALID(symbol_str);
     EXPECT(Dart_IsString(symbol_str));
     EXPECT(Dart_IsStringLatin1(symbol_str));
     EXPECT(!Dart_IsExternalString(symbol_str));
     EXPECT_VALID(Dart_StringLength(symbol_str, &length));
     EXPECT_EQ(expected_length, length);
     EXPECT(Api::UnwrapStringHandle(zone, symbol_str).HasHash());
 
     uint8_t ext_symbol_ascii[kLength];
     EXPECT_VALID(Dart_StringStorageSize(symbol_str, &size));
-    str = Dart_MakeExternalString(symbol_str,
-                                  ext_symbol_ascii,
-                                  size,
-                                  &peer8,
+    str = Dart_MakeExternalString(symbol_str, ext_symbol_ascii, size, &peer8,
                                   MakeExternalCback);
     EXPECT(Api::UnwrapStringHandle(zone, str).HasHash());
     EXPECT(Api::UnwrapStringHandle(zone, str).Hash() ==
            Api::UnwrapStringHandle(zone, symbol_str).Hash());
     EXPECT(Dart_IsString(str));
     EXPECT(Dart_IsString(symbol_str));
     EXPECT(Dart_IsStringLatin1(str));
     EXPECT(Dart_IsStringLatin1(symbol_str));
     EXPECT(Dart_IsExternalString(str));
     EXPECT(Dart_IsExternalString(symbol_str));
@@ skipping 27 matching lines @@
 TEST_CASE(ExternalizeConstantStrings) {
   const bool saved_flag = FLAG_support_externalizable_strings;
   FLAG_support_externalizable_strings = true;
 
   const char* kScriptChars =
       "String testMain() {\n"
       "  return 'constant string';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("testMain"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   const char* expected_str = "constant string";
   const intptr_t kExpectedLen = 15;
   uint8_t ext_str[kExpectedLen];
-  Dart_Handle str = Dart_MakeExternalString(result,
-                                            ext_str,
-                                            kExpectedLen,
-                                            NULL,
-                                            NULL);
+  Dart_Handle str =
+      Dart_MakeExternalString(result, ext_str, kExpectedLen, NULL, NULL);
 
   EXPECT(Dart_IsExternalString(str));
   for (intptr_t i = 0; i < kExpectedLen; i++) {
     EXPECT_EQ(expected_str[i], ext_str[i]);
   }
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
 
@@ skipping 53 matching lines @@
   void* peer;
   Dart_Handle str_arg = Dart_GetNativeStringArgument(args, 0, &peer);
   EXPECT(Dart_IsString(str_arg));
   EXPECT(!peer);
   intptr_t size = 0;
   EXPECT_VALID(Dart_StringStorageSize(str, &size));
   intptr_t arg_size = 0;
   EXPECT_VALID(Dart_StringStorageSize(str_arg, &arg_size));
   EXPECT_EQ(size, arg_size);
   char* str_data = new char[size];
-  Dart_Handle result =
-      Dart_MakeExternalString(str,
-                              str_data,
-                              size,
-                              str_data,
-                              &ExternalStringDeoptimize_Finalize);
+  Dart_Handle result = Dart_MakeExternalString(
+      str, str_data, size, str_data, &ExternalStringDeoptimize_Finalize);
   EXPECT_VALID(result);
   EXPECT(Dart_IsExternalString(result));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ExternalStringDeoptimize_native_lookup(
-    Dart_Handle name, int argument_count, bool* auto_setup_scope) {
+    Dart_Handle name,
+    int argument_count,
+    bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&A_change_str_native);
 }
 
 
 // Do not use guarding mechanism on externalizable classes, since their class
 // can change on the fly,
 TEST_CASE(GuardExternalizedString) {
   const bool saved_flag = FLAG_support_externalizable_strings;
@@ skipping 16 matching lines @@
       "    }\n"
       "  }\n"
       "  return sum;\n"
       "}\n"
       "class A {\n"
       "  var f;\n"
       "  A(this.f);\n"
       "}\n"
       "change_str(String s) native 'A_change_str';\n"
       "";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars,
-                               &ExternalStringDeoptimize_native_lookup);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(
+      kScriptChars, &ExternalStringDeoptimize_native_lookup);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(10640000, value);
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringDeoptimize) {
@@ skipping 13 matching lines @@
       "  }\n"
       "  return result;\n"
       "}\n"
       "main() {\n"
       "  str = '$str$str';\n"
       "  for (var i = 0; i < 2000; i++) sum_chars(str, false);\n"
       "  var x = sum_chars(str, false);\n"
       "  var y = sum_chars(str, true);\n"
       "  return x + y;\n"
       "}\n";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars,
-                               &ExternalStringDeoptimize_native_lookup);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(
+      kScriptChars, &ExternalStringDeoptimize_native_lookup);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(260, value);
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringPolymorphicDeoptimize) {
@@ skipping 13 matching lines @@
       "}\n"
       "main() {\n"
       "  var externalA = 'AA' + 'AA';\n"
       "  A.change_str(externalA);\n"
       "  compare('AA' + 'AA', strA);\n"
       "  compare(externalA, strA);\n"
       "  for (var i = 0; i < 10000; i++) compareA(strA);\n"
       "  A.change_str(strA);\n"
       "  return compareA('AA' + 'AA');\n"
       "}\n";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars,
-                               &ExternalStringDeoptimize_native_lookup);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(
+      kScriptChars, &ExternalStringDeoptimize_native_lookup);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringLoadElimination) {
   const bool saved_flag = FLAG_support_externalizable_strings;
   FLAG_support_externalizable_strings = true;
 
   const char* kScriptChars =
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "double_char0(str) {\n"
       "  return str.codeUnitAt(0) + str.codeUnitAt(0);\n"
       "}\n"
       "main() {\n"
       "  var externalA = 'AA' + 'AA';\n"
       "  A.change_str(externalA);\n"
       "  for (var i = 0; i < 10000; i++) double_char0(externalA);\n"
       "  var result = double_char0(externalA);\n"
       "  return result == 130;\n"
       "}\n";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars,
-                               &ExternalStringDeoptimize_native_lookup);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(
+      kScriptChars, &ExternalStringDeoptimize_native_lookup);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
 
@@ skipping 19 matching lines @@
       "  return compare(strA, b, i);\n"
       "}\n"
       "main() {\n"
       "  var externalA = 'AA' + 'AA';\n"
       "  A.change_str(externalA);\n"
       "  compare('AA' + 'AA', strA);\n"
       "  for (var i = 0; i < 10000; i++) compareA(strA);\n"
       "  shouldExternalize = true;\n"
       "  return compareA('AA' + 'AA');\n"
       "}\n";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars,
-                               &ExternalStringDeoptimize_native_lookup);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(
+      kScriptChars, &ExternalStringDeoptimize_native_lookup);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
 
@@ skipping 14 matching lines @@
       "  return compare(G.f, b, i);\n"
       "}\n"
       "main() {\n"
       "  var externalA = 'AA' + 'AA';\n"
       "  A.change_str(externalA);\n"
       "  compare('AA' + 'AA', strA);\n"
       "  for (var i = 0; i < 10000; i++) compareA(strA);\n"
       "  A.change_str(G.f);"
       "  return compareA('AA' + 'AA');\n"
       "}\n";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars,
-                               &ExternalStringDeoptimize_native_lookup);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(
+      kScriptChars, &ExternalStringDeoptimize_native_lookup);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringTrimDoubleParse) {
   const bool saved_flag = FLAG_support_externalizable_strings;
   FLAG_support_externalizable_strings = true;
 
   const char* kScriptChars =
       "String str = 'A';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "main() {\n"
       "  var externalOneByteString = ' 0.2\\xA0 ';\n;"
       "  A.change_str(externalOneByteString);\n"
       "  var externalTwoByteString = ' \\u{2029}0.6\\u{2029} ';\n"
       "  A.change_str(externalTwoByteString);\n"
       "  var x = double.parse(externalOneByteString);\n"
       "  var y = double.parse(externalTwoByteString);\n"
       "  return ((x + y) * 10).toInt();\n"
       "}\n";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars,
-                               &ExternalStringDeoptimize_native_lookup);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(
+      kScriptChars, &ExternalStringDeoptimize_native_lookup);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(8, value);
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringDoubleParse) {
   const bool saved_flag = FLAG_support_externalizable_strings;
   FLAG_support_externalizable_strings = true;
 
   const char* kScriptChars =
       "String str = 'A';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "main() {\n"
       "  var externalOneByteString = '0.2';\n;"
       "  A.change_str(externalOneByteString);\n"
       "  var externalTwoByteString = '0.6';\n"
       "  A.change_str(externalTwoByteString);\n"
       "  var x = double.parse(externalOneByteString);\n"
       "  var y = double.parse(externalTwoByteString);\n"
       "  return ((x + y) * 10).toInt();\n"
       "}\n";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars,
-                               &ExternalStringDeoptimize_native_lookup);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(
+      kScriptChars, &ExternalStringDeoptimize_native_lookup);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(8, value);
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringIndexOf) {
   const char* kScriptChars =
       "main(String pattern) {\n"
       "  var str = 'Hello World';\n"
       "  return str.indexOf(pattern);\n"
       "}\n";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars, NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
-  uint8_t data8[] = { 'W' };
-  Dart_Handle ext8 = Dart_NewExternalLatin1String(data8, ARRAY_SIZE(data8),
-                                                  data8, NULL);
+  uint8_t data8[] = {'W'};
+  Dart_Handle ext8 =
+      Dart_NewExternalLatin1String(data8, ARRAY_SIZE(data8), data8, NULL);
   EXPECT_VALID(ext8);
   EXPECT(Dart_IsString(ext8));
   EXPECT(Dart_IsExternalString(ext8));
 
   Dart_Handle dart_args[1];
   dart_args[0] = ext8;
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   1,
-                                   dart_args);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 1, dart_args);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(6, value);
 }
 
 
 TEST_CASE(StringFromExternalTypedData) {
   const char* kScriptChars =
-    "test(external) {\n"
-    "  var str1 = new String.fromCharCodes(external);\n"
-    "  var str2 = new String.fromCharCodes(new List.from(external));\n"
-    "  if (str2 != str1) throw 'FAIL';\n"
-    "  return str1;\n"
-    "}\n"
-    "testView8(external) {\n"
-    "  return test(external.buffer.asUint8List());\n"
-    "}\n"
-    "testView16(external) {\n"
-    "  return test(external.buffer.asUint16List());\n"
-    "}\n";
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars, NULL);
+      "test(external) {\n"
+      "  var str1 = new String.fromCharCodes(external);\n"
+      "  var str2 = new String.fromCharCodes(new List.from(external));\n"
+      "  if (str2 != str1) throw 'FAIL';\n"
+      "  return str1;\n"
+      "}\n"
+      "testView8(external) {\n"
+      "  return test(external.buffer.asUint8List());\n"
+      "}\n"
+      "testView16(external) {\n"
+      "  return test(external.buffer.asUint16List());\n"
+      "}\n";
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   {
     uint8_t data[64];
     for (int i = 0; i < 64; i++) {
       data[i] = i * 4;
     }
     // LATIN-1 in external Uint8List.
-    Dart_Handle external = Dart_NewExternalTypedData(
-        Dart_TypedData_kUint8, data, 64);
+    Dart_Handle external =
+        Dart_NewExternalTypedData(Dart_TypedData_kUint8, data, 64);
     EXPECT_VALID(external);
     Dart_Handle dart_args[1];
     dart_args[0] = external;
-    Dart_Handle result = Dart_Invoke(lib,
-                                     NewString("test"),
-                                     1,
-                                     dart_args);
+    Dart_Handle result = Dart_Invoke(lib, NewString("test"), 1, dart_args);
     EXPECT_VALID(result);
     EXPECT(Dart_IsString(result));
 
-    result = Dart_Invoke(lib,
-                         NewString("testView8"),
-                         1,
-                         dart_args);
+    result = Dart_Invoke(lib, NewString("testView8"), 1, dart_args);
     EXPECT_VALID(result);
     EXPECT(Dart_IsString(result));
   }
 
   {
     uint16_t data[64];
     for (int i = 0; i < 64; i++) {
       data[i] = i * 4;
     }
     // LATIN-1 in external Uint16List.
-    Dart_Handle external = Dart_NewExternalTypedData(
-        Dart_TypedData_kUint16, data, 64);
+    Dart_Handle external =
+        Dart_NewExternalTypedData(Dart_TypedData_kUint16, data, 64);
     EXPECT_VALID(external);
     Dart_Handle dart_args[1];
     dart_args[0] = external;
-    Dart_Handle result = Dart_Invoke(lib,
-                                     NewString("test"),
-                                     1,
-                                     dart_args);
+    Dart_Handle result = Dart_Invoke(lib, NewString("test"), 1, dart_args);
     EXPECT_VALID(result);
     EXPECT(Dart_IsString(result));
 
-    result = Dart_Invoke(lib,
-                         NewString("testView16"),
-                         1,
-                         dart_args);
+    result = Dart_Invoke(lib, NewString("testView16"), 1, dart_args);
     EXPECT_VALID(result);
     EXPECT(Dart_IsString(result));
   }
 
   {
     uint16_t data[64];
     for (int i = 0; i < 64; i++) {
       data[i] = 0x2000 + i * 4;
     }
     // Non-LATIN-1 in external Uint16List.
-    Dart_Handle external = Dart_NewExternalTypedData(
-        Dart_TypedData_kUint16, data, 64);
+    Dart_Handle external =
+        Dart_NewExternalTypedData(Dart_TypedData_kUint16, data, 64);
     EXPECT_VALID(external);
     Dart_Handle dart_args[1];
     dart_args[0] = external;
-    Dart_Handle result = Dart_Invoke(lib,
-                                     NewString("test"),
-                                     1,
-                                     dart_args);
+    Dart_Handle result = Dart_Invoke(lib, NewString("test"), 1, dart_args);
     EXPECT_VALID(result);
     EXPECT(Dart_IsString(result));
 
-    result = Dart_Invoke(lib,
-                         NewString("testView16"),
-                         1,
-                         dart_args);
+    result = Dart_Invoke(lib, NewString("testView16"), 1, dart_args);
     EXPECT_VALID(result);
     EXPECT(Dart_IsString(result));
   }
 }
 
 
 #ifndef PRODUCT
 
 
 TEST_CASE(Timeline_Dart_TimelineDuration) {
   Isolate* isolate = Isolate::Current();
   // Grab embedder stream.
   TimelineStream* stream = Timeline::GetEmbedderStream();
   // Make sure it is enabled.
   stream->set_enabled(true);
   // Add a duration event.
-  Dart_TimelineEvent("testDurationEvent",
-                     0,
-                     1,
-                     Dart_Timeline_Event_Duration,
-                     0, NULL, NULL);
+  Dart_TimelineEvent("testDurationEvent", 0, 1, Dart_Timeline_Event_Duration, 0,
+                     NULL, NULL);
   // Check that it is in the output.
   TimelineEventRecorder* recorder = Timeline::recorder();
   Timeline::ReclaimCachedBlocksFromThreads();
   JSONStream js;
   IsolateTimelineEventFilter filter(isolate->main_port());
   recorder->PrintJSON(&js, &filter);
   EXPECT_SUBSTRING("testDurationEvent", js.ToCString());
 }
 
 
 TEST_CASE(Timeline_Dart_TimelineInstant) {
   Isolate* isolate = Isolate::Current();
   // Grab embedder stream.
   TimelineStream* stream = Timeline::GetEmbedderStream();
   // Make sure it is enabled.
   stream->set_enabled(true);
-  Dart_TimelineEvent("testInstantEvent",
-                     0,
-                     1,
-                     Dart_Timeline_Event_Instant,
-                     0, NULL, NULL);
+  Dart_TimelineEvent("testInstantEvent", 0, 1, Dart_Timeline_Event_Instant, 0,
+                     NULL, NULL);
   // Check that it is in the output.
   TimelineEventRecorder* recorder = Timeline::recorder();
   Timeline::ReclaimCachedBlocksFromThreads();
   JSONStream js;
   IsolateTimelineEventFilter filter(isolate->main_port());
   recorder->PrintJSON(&js, &filter);
   EXPECT_SUBSTRING("testInstantEvent", js.ToCString());
 }
 
 
 TEST_CASE(Timeline_Dart_TimelineAsyncDisabled) {
   // Grab embedder stream.
   TimelineStream* stream = Timeline::GetEmbedderStream();
   // Make sure it is disabled.
   stream->set_enabled(false);
   int64_t async_id = 99;
-  Dart_TimelineEvent("testAsyncEvent",
-                     0,
-                     async_id,
-                     Dart_Timeline_Event_Async_Begin,
-                     0, NULL, NULL);
+  Dart_TimelineEvent("testAsyncEvent", 0, async_id,
+                     Dart_Timeline_Event_Async_Begin, 0, NULL, NULL);
   // Check that testAsync is not in the output.
   TimelineEventRecorder* recorder = Timeline::recorder();
   Timeline::ReclaimCachedBlocksFromThreads();
   JSONStream js;
   TimelineEventFilter filter;
   recorder->PrintJSON(&js, &filter);
   EXPECT_NOTSUBSTRING("testAsyncEvent", js.ToCString());
 }
 
 
 TEST_CASE(Timeline_Dart_TimelineAsync) {
   Isolate* isolate = Isolate::Current();
   // Grab embedder stream.
   TimelineStream* stream = Timeline::GetEmbedderStream();
   // Make sure it is enabled.
   stream->set_enabled(true);
   int64_t async_id = 99;
-  Dart_TimelineEvent("testAsyncEvent",
-                     0,
-                     async_id,
-                     Dart_Timeline_Event_Async_Begin,
-                     0, NULL, NULL);
+  Dart_TimelineEvent("testAsyncEvent", 0, async_id,
+                     Dart_Timeline_Event_Async_Begin, 0, NULL, NULL);
 
   // Check that it is in the output.
   TimelineEventRecorder* recorder = Timeline::recorder();
   Timeline::ReclaimCachedBlocksFromThreads();
   JSONStream js;
   IsolateTimelineEventFilter filter(isolate->main_port());
   recorder->PrintJSON(&js, &filter);
   EXPECT_SUBSTRING("testAsyncEvent", js.ToCString());
 }
 
@@ skipping 18 matching lines @@
     data->buffer = NULL;
     data->buffer_length = 0;
     return;
   }
   ASSERT(state == Dart_StreamConsumer_kData);
 
   // Grow buffer.
   data->buffer = reinterpret_cast<uint8_t*>(
       realloc(data->buffer, data->buffer_length + buffer_length));
   // Copy new data.
-  memmove(&data->buffer[data->buffer_length],
-          buffer,
-          buffer_length);
+  memmove(&data->buffer[data->buffer_length], buffer, buffer_length);
   // Update length.
   data->buffer_length += buffer_length;
 }
 
 
 TEST_CASE(Timeline_Dart_TimelineGetTrace) {
   const char* kScriptChars =
-    "foo() => 'a';\n"
-    "main() => foo();\n";
+      "foo() => 'a';\n"
+      "main() => foo();\n";
 
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars, NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   const char* buffer = NULL;
   intptr_t buffer_length = 0;
   bool success = false;
 
   // Enable recording of all streams.
   Dart_GlobalTimelineSetRecordedStreams(DART_TIMELINE_STREAM_ALL);
 
   // Invoke main, which will be compiled resulting in a compiler event in
   // the timeline.
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 
   // Grab the trace.
   AppendData data;
   success = Dart_GlobalTimelineGetTrace(AppendStreamConsumer, &data);
   EXPECT(success);
   buffer = reinterpret_cast<char*>(data.buffer);
   buffer_length = data.buffer_length;
   EXPECT(buffer_length > 0);
   EXPECT(buffer != NULL);
 
   // Response starts with a '{' character and not a '['.
   EXPECT(buffer[0] == '{');
   // Response ends with a '}' character and not a ']'.
   EXPECT(buffer[buffer_length - 1] == '\0');
   EXPECT(buffer[buffer_length - 2] == '}');
 
   // Heartbeat test.
   EXPECT_SUBSTRING("\"cat\":\"Compiler\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"CompileFunction\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_main\"", buffer);
 
   // Free buffer allocated by AppendStreamConsumer
   free(data.buffer);
 }
 
 
 TEST_CASE(Timeline_Dart_TimelineGetTraceOnlyDartEvents) {
   const char* kScriptChars =
-    "import 'dart:developer';\n"
-    ""
-    "main() {\n"
-    "  Timeline.startSync('DART_NAME');\n"
-    "  Timeline.finishSync();\n"
-    "}\n";
+      "import 'dart:developer';\n"
+      ""
+      "main() {\n"
+      "  Timeline.startSync('DART_NAME');\n"
+      "  Timeline.finishSync();\n"
+      "}\n";
 
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars, NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   const char* buffer = NULL;
   intptr_t buffer_length = 0;
   bool success = false;
 
   // Enable recording of the Dart stream.
   Dart_GlobalTimelineSetRecordedStreams(DART_TIMELINE_STREAM_DART);
 
   // Invoke main, which will add a new timeline event from Dart.
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 
   // Grab the trace.
   AppendData data;
   data.buffer = NULL;
   data.buffer_length = 0;
   success = Dart_GlobalTimelineGetTrace(AppendStreamConsumer, &data);
   EXPECT(success);
   buffer = reinterpret_cast<char*>(data.buffer);
   buffer_length = data.buffer_length;
@@ skipping 10 matching lines @@
   EXPECT_SUBSTRING("\"cat\":\"Dart\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"DART_NAME\"", buffer);
 
   // Free buffer allocated by AppendStreamConsumer
   free(data.buffer);
 }
 
 
 TEST_CASE(Timeline_Dart_TimelineGetTraceWithDartEvents) {
   const char* kScriptChars =
-    "import 'dart:developer';\n"
-    "\n"
-    "main() {\n"
-    "  Timeline.startSync('DART_NAME');\n"
-    "  Timeline.finishSync();\n"
-    "}\n";
+      "import 'dart:developer';\n"
+      "\n"
+      "main() {\n"
+      "  Timeline.startSync('DART_NAME');\n"
+      "  Timeline.finishSync();\n"
+      "}\n";
 
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars, NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   const char* buffer = NULL;
   intptr_t buffer_length = 0;
   bool success = false;
 
   // Enable recording of all streams.
   Dart_GlobalTimelineSetRecordedStreams(DART_TIMELINE_STREAM_ALL);
 
   // Invoke main, which will be compiled resulting in a compiler event in
   // the timeline.
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 
   // Grab the trace.
   AppendData data;
   success = Dart_GlobalTimelineGetTrace(AppendStreamConsumer, &data);
   EXPECT(success);
   buffer = reinterpret_cast<char*>(data.buffer);
   buffer_length = data.buffer_length;
   EXPECT(buffer_length > 0);
   EXPECT(buffer != NULL);
@@ skipping 10 matching lines @@
   EXPECT_SUBSTRING("\"function\":\"::_main\"", buffer);
   EXPECT_SUBSTRING("\"cat\":\"Dart\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"DART_NAME\"", buffer);
 
   // Free buffer allocated by AppendStreamConsumer
   free(data.buffer);
 }
 
 TEST_CASE(Timeline_Dart_TimelineGetTraceGlobalOverride) {
   const char* kScriptChars =
-    "foo() => 'a';\n"
-    "main() => foo();\n";
+      "foo() => 'a';\n"
+      "main() => foo();\n";
 
-  Dart_Handle lib =
-      TestCase::LoadTestScript(kScriptChars, NULL);
+  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   const char* buffer = NULL;
   intptr_t buffer_length = 0;
   bool success = false;
 
   // Enable recording of all streams across the entire vm.
   Dart_GlobalTimelineSetRecordedStreams(DART_TIMELINE_STREAM_ALL);
 
   // Invoke main, which will be compiled resulting in a compiler event in
   // the timeline.
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 
   // Grab the trace.
   AppendData data;
   success = Dart_GlobalTimelineGetTrace(AppendStreamConsumer, &data);
   EXPECT(success);
   buffer = reinterpret_cast<char*>(data.buffer);
   buffer_length = data.buffer_length;
   EXPECT(buffer_length > 0);
   EXPECT(buffer != NULL);
 
   // Response starts with a '{' character and not a '['.
   EXPECT(buffer[0] == '{');
   // Response ends with a '}' character and not a ']'.
   EXPECT(buffer[buffer_length - 1] == '\0');
   EXPECT(buffer[buffer_length - 2] == '}');
 
   // Heartbeat test.
   EXPECT_SUBSTRING("\"cat\":\"Compiler\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"CompileFunction\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_main\"", buffer);
 
   // Free buffer allocated by AppendStreamConsumer
   free(data.buffer);
 }
 
 
-static const char* arg_names[] = {
-  "arg0"
-};
+static const char* arg_names[] = {"arg0"};
 
 
-static const char* arg_values[] = {
-  "value0"
-};
+static const char* arg_values[] = {"value0"};
 
 
 TEST_CASE(Timeline_Dart_GlobalTimelineGetTrace) {
   const char* kScriptChars =
-    "bar() => 'z';\n"
-    "foo() => 'a';\n"
-    "main() => foo();\n";
+      "bar() => 'z';\n"
+      "foo() => 'a';\n"
+      "main() => foo();\n";
 
   // Enable all streams.
   Dart_GlobalTimelineSetRecordedStreams(DART_TIMELINE_STREAM_ALL |
                                         DART_TIMELINE_STREAM_VM);
   Dart_Handle lib;
   {
     // Add something to the VM stream.
-    TimelineDurationScope tds(Timeline::GetVMStream(),
-                              "TestVMDuration");
+    TimelineDurationScope tds(Timeline::GetVMStream(), "TestVMDuration");
     lib = TestCase::LoadTestScript(kScriptChars, NULL);
   }
 
   {
     // Add something to the embedder stream.
-    Dart_TimelineEvent("TRACE_EVENT",
-                       Dart_TimelineGetMicros(),
-                       0,
-                       Dart_Timeline_Event_Begin,
-                       1,
-                       &arg_names[0],
+    Dart_TimelineEvent("TRACE_EVENT", Dart_TimelineGetMicros(), 0,
+                       Dart_Timeline_Event_Begin, 1, &arg_names[0],
                        &arg_values[0]);
     // Add counter to the embedder stream.
-    Dart_TimelineEvent("COUNTER_EVENT",
-                       Dart_TimelineGetMicros(),
-                       0,
-                       Dart_Timeline_Event_Counter,
-                       0,
-                       NULL,
-                       NULL);
+    Dart_TimelineEvent("COUNTER_EVENT", Dart_TimelineGetMicros(), 0,
+                       Dart_Timeline_Event_Counter, 0, NULL, NULL);
     Dart_SetThreadName("CUSTOM THREAD NAME");
   }
 
   // Invoke main, which will be compiled resulting in a compiler event in
   // the timeline.
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 
   const char* buffer = NULL;
   intptr_t buffer_length = 0;
   bool success = false;
 
   // Grab the global trace.
   AppendData data;
   {
     Thread* T = Thread::Current();
@@ skipping 29 matching lines @@
   // Free buffer allocated by AppendStreamConsumer
   free(data.buffer);
   data.buffer = NULL;
   data.buffer_length = 0;
 
   // Retrieving the global trace resulted in all open blocks being reclaimed.
   // Add some new events and verify that both sets of events are present
   // in the resulting trace.
   {
     // Add something to the VM stream.
-    TimelineDurationScope tds(Timeline::GetVMStream(),
-                              "TestVMDuration2");
+    TimelineDurationScope tds(Timeline::GetVMStream(), "TestVMDuration2");
     // Invoke bar, which will be compiled resulting in a compiler event in
     // the timeline.
-    result = Dart_Invoke(lib,
-                         NewString("bar"),
-                         0,
-                         NULL);
+    result = Dart_Invoke(lib, NewString("bar"), 0, NULL);
   }
 
   // Grab the global trace.
   {
     Thread* T = Thread::Current();
     StackZone zone(T);
     success = Dart_GlobalTimelineGetTrace(AppendStreamConsumer, &data);
     EXPECT(success);
     EXPECT(zone.SizeInBytes() == 0);
   }
@@ skipping 18 matching lines @@
   EXPECT_SUBSTRING("\"function\":\"::_bar\"", buffer);
 
   // Free buffer allocated by AppendStreamConsumer
   free(data.buffer);
 }
 
 
 class GlobalTimelineThreadData {
  public:
   GlobalTimelineThreadData()
-      : monitor_(new Monitor()),
-        data_(new AppendData()),
-        running_(true) {
-  }
+      : monitor_(new Monitor()), data_(new AppendData()), running_(true) {}
 
   ~GlobalTimelineThreadData() {
     delete monitor_;
     monitor_ = NULL;
     free(data_->buffer);
     data_->buffer = NULL;
     data_->buffer_length = 0;
     delete data_;
     data_ = NULL;
   }
@@ skipping 29 matching lines @@
   }
 }
 
 
 // This test is the same as the one above except that the calls to
 // Dart_GlobalTimelineGetTrace are made from a fresh thread. This ensures that
 // we can call the function from a thread for which we have not set up a
 // Thread object.
 TEST_CASE(Timeline_Dart_GlobalTimelineGetTrace_Threaded) {
   const char* kScriptChars =
-    "bar() => 'z';\n"
-    "foo() => 'a';\n"
-    "main() => foo();\n";
+      "bar() => 'z';\n"
+      "foo() => 'a';\n"
+      "main() => foo();\n";
 
   // Enable all streams.
   Dart_GlobalTimelineSetRecordedStreams(DART_TIMELINE_STREAM_ALL |
                                         DART_TIMELINE_STREAM_VM);
   Dart_Handle lib;
   {
     // Add something to the VM stream.
-    TimelineDurationScope tds(Timeline::GetVMStream(),
-                              "TestVMDuration");
+    TimelineDurationScope tds(Timeline::GetVMStream(), "TestVMDuration");
     lib = TestCase::LoadTestScript(kScriptChars, NULL);
   }
 
   // Invoke main, which will be compiled resulting in a compiler event in
   // the timeline.
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 
   const char* buffer = NULL;
   intptr_t buffer_length = 0;
 
   // Run Dart_GlobalTimelineGetTrace on a fresh thread.
   GlobalTimelineThreadData data;
-  int err = OSThread::Start("Timeline test thread",
-      GlobalTimelineThread, reinterpret_cast<uword>(&data));
+  int err = OSThread::Start("Timeline test thread", GlobalTimelineThread,
+                            reinterpret_cast<uword>(&data));
   EXPECT(err == 0);
   {
     MonitorLocker ml(data.monitor());
     while (data.running()) {
       ml.Wait();
     }
     buffer = reinterpret_cast<char*>(data.buffer());
     buffer_length = data.buffer_length();
   }
   EXPECT(buffer_length > 0);
@@ skipping 10 matching lines @@
   EXPECT_SUBSTRING("\"cat\":\"Compiler\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"CompileFunction\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_main\"", buffer);
   EXPECT_NOTSUBSTRING("\"function\":\"::_bar\"", buffer);
 
   // Retrieving the global trace resulted in all open blocks being reclaimed.
   // Add some new events and verify that both sets of events are present
   // in the resulting trace.
   {
     // Add something to the VM stream.
-    TimelineDurationScope tds(Timeline::GetVMStream(),
-                              "TestVMDuration2");
+    TimelineDurationScope tds(Timeline::GetVMStream(), "TestVMDuration2");
     // Invoke bar, which will be compiled resulting in a compiler event in
     // the timeline.
     result = Dart_Invoke(lib, NewString("bar"), 0, NULL);
   }
 
   // Grab the global trace.
   GlobalTimelineThreadData data2;
-  err = OSThread::Start("Timeline test thread",
-      GlobalTimelineThread, reinterpret_cast<uword>(&data2));
+  err = OSThread::Start("Timeline test thread", GlobalTimelineThread,
+                        reinterpret_cast<uword>(&data2));
   EXPECT(err == 0);
   {
     MonitorLocker ml(data2.monitor());
     while (data2.running()) {
       ml.Wait();
     }
     buffer = reinterpret_cast<char*>(data2.buffer());
     buffer_length = data2.buffer_length();
   }
 
@@ skipping 58 matching lines @@
       "foozoo() { new A().zoo(); }\n"
       "foomoo() { A.moo(); }\n";
 
   const char* kScriptChars2 =
       "@patch class A {\n"
       "  @patch int zoo() { return 1; }\n"
       "  @patch static int moo() { return 1; }\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars1, NULL);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   Dart_Handle url = NewString("test-lib-patch");
   Dart_Handle source = NewString(kScriptChars2);
   result = Dart_LibraryLoadPatch(lib, url, source);
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
-  result = Dart_Invoke(lib,
-                       NewString("foozoo"),
-                       0,
-                       NULL);
+  result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT_VALID(result);
-  result = Dart_Invoke(lib,
-                       NewString("foomoo"),
-                       0,
-                       NULL);
+  result = Dart_Invoke(lib, NewString("foomoo"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
 TEST_CASE(Dart_LoadLibraryPatch_Error1) {
   const char* kScriptChars1 =
       "class A {\n"
       "  int foo() { return 10; }\n"
       "  external int zoo();\n"
       "}\n"
       "main() { new A().foo(); }\n"
       "foozoo() { new A().zoo(); }\n";
 
   const char* kScriptChars2 =
       "@patch class A {\n"
       "  @patch int zoo() { return 1; }\n"
       "  @patch int fld1;\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars1, NULL);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   Dart_Handle url = NewString("test-lib-patch");
   Dart_Handle source = NewString(kScriptChars2);
   // We don't expect to be able to patch in this case as new fields
   // are being added.
   result = Dart_LibraryLoadPatch(lib, url, source);
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
-  result = Dart_Invoke(lib,
-                       NewString("foozoo"),
-                       0,
-                       NULL);
+  result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT(Dart_IsError(result));
 }
 
 
 TEST_CASE(Dart_LoadLibraryPatch_Error2) {
   const char* kScriptChars1 =
       "class A {\n"
       "  int foo() { return 10; }\n"
       "  int zoo() { return 20; }\n"
       "}\n"
       "main() { new A().foo(); }\n"
       "foozoo() { new A().zoo(); }\n";
 
   const char* kScriptChars2 =
       "@patch class A {\n"
       "  @patch int zoo() { return 1; }\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars1, NULL);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   Dart_Handle url = NewString("test-lib-patch");
   Dart_Handle source = NewString(kScriptChars2);
   // We don't expect to be able to patch in this case as a non external
   // method is being patched.
   result = Dart_LibraryLoadPatch(lib, url, source);
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
-  result = Dart_Invoke(lib,
-                       NewString("foozoo"),
-                       0,
-                       NULL);
+  result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT(Dart_IsError(result));
   OS::Print("Patched class executed\n");
 }
 
 
 TEST_CASE(Dart_LoadLibraryPatch_Error3) {
   const char* kScriptChars1 =
       "class A {\n"
       "  int foo() { return 10; }\n"
       "  external int zoo();\n"
       "}\n"
       "main() { new A().foo(); }\n"
       "foozoo() { new A().zoo(); }\n";
 
   const char* kScriptChars2 =
       "@patch class A {\n"
       "  @patch int zoo() { return 1; }\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars1, NULL);
-  Dart_Handle result = Dart_Invoke(lib,
-                                   NewString("main"),
-                                   0,
-                                   NULL);
+  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   // We invoke the foozoo method to ensure that code for 'zoo' is generated
   // which throws NoSuchMethod.
-  result = Dart_Invoke(lib,
-                       NewString("foozoo"),
-                       0,
-                       NULL);
+  result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT(Dart_IsError(result));
   Dart_Handle url = NewString("test-lib-patch");
   Dart_Handle source = NewString(kScriptChars2);
   // We don't expect to be able to patch in this case as the function being
   // patched has already executed.
   result = Dart_LibraryLoadPatch(lib, url, source);
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
-  result = Dart_Invoke(lib,
-                       NewString("foozoo"),
-                       0,
-                       NULL);
+  result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT(Dart_IsError(result));
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart