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

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 "vm/dart_api_impl.h"
 #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"
 #include "platform/assert.h"
 #include "platform/text_buffer.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
-#include "vm/dart_api_impl.h"
+#include "vm/compiler.h"
 #include "vm/dart_api_state.h"
 #include "vm/lockers.h"
 #include "vm/timeline.h"
 #include "vm/unit_test.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, verify_acquired_data);
 DECLARE_FLAG(bool, ignore_patch_signature_mismatch);
@@ skipping 31 matching lines @@
 
   EXPECT(Dart_IsError(Dart_ErrorGetException(instance)));
   EXPECT(Dart_IsError(Dart_ErrorGetException(error)));
   EXPECT_VALID(Dart_ErrorGetException(exception));
 
   EXPECT(Dart_IsError(Dart_ErrorGetStackTrace(instance)));
   EXPECT(Dart_IsError(Dart_ErrorGetStackTrace(error)));
   EXPECT_VALID(Dart_ErrorGetStackTrace(exception));
 }
 
-
 TEST_CASE(StackTraceInfo) {
   const char* kScriptChars =
       "bar() => throw new Error();\n"
       "foo() => bar();\n"
       "testMain() => foo();\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle error = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
 
   EXPECT(Dart_IsError(error));
@@ skipping 50 matching lines @@
   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));
 }
 
-
 TEST_CASE(DeepStackTraceInfo) {
   const char* kScriptChars =
       "foo(n) => n == 1 ? throw new Error() : foo(n-1);\n"
       "testMain() => foo(50);\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle error = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
 
   EXPECT(Dart_IsError(error));
 
@@ skipping 58 matching lines @@
   EXPECT_EQ(2, 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));
 }
 
-
 TEST_CASE(StackOverflowStackTraceInfo) {
   const char* kScriptChars =
       "class C {\n"
       "  static foo() => foo();\n"
       "}\n"
       "testMain() => C.foo();\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle error = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
 
@@ skipping 28 matching lines @@
   EXPECT_EQ(2, line_number);
   EXPECT_EQ(13, 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));
 }
 
-
 TEST_CASE(OutOfMemoryStackTraceInfo) {
   const char* kScriptChars =
       "var number_of_ints = 134000000;\n"
       "testMain() {\n"
       "  new List<int>(number_of_ints)\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle error = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
 
   EXPECT(Dart_IsError(error));
 
   Dart_StackTrace stacktrace;
   Dart_Handle result = Dart_GetStackTraceFromError(error, &stacktrace);
   EXPECT(Dart_IsError(result));  // No StackTrace for OutOfMemory.
 }
 
-
 void CurrentStackTraceNative(Dart_NativeArguments args) {
   Dart_EnterScope();
 
   Dart_StackTrace stacktrace;
   Dart_Handle result = Dart_GetStackTrace(&stacktrace);
   EXPECT_VALID(result);
 
   intptr_t frame_count = 0;
   result = Dart_StackTraceLength(stacktrace, &frame_count);
   EXPECT_VALID(result);
@@ skipping 67 matching lines @@
   // 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) {
   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 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
 
-
 TEST_CASE(ErrorHandleTypes) {
   const String& compile_message = String::Handle(String::New("CompileError"));
   const String& fatal_message = String::Handle(String::New("FatalError"));
 
   Dart_Handle not_error = NewString("NotError");
   Dart_Handle api_error = Api::NewError("Api%s", "Error");
   Dart_Handle exception_error =
       Dart_NewUnhandledExceptionError(NewString("ExceptionError"));
   Dart_Handle compile_error =
       Api::NewHandle(thread, LanguageError::New(compile_message));
@@ skipping 31 matching lines @@
   EXPECT(Dart_IsFatalError(fatal_error));
 
   EXPECT_STREQ("", Dart_GetError(not_error));
   EXPECT_STREQ("ApiError", Dart_GetError(api_error));
   EXPECT_SUBSTRING("Unhandled exception:\nExceptionError",
                    Dart_GetError(exception_error));
   EXPECT_STREQ("CompileError", Dart_GetError(compile_error));
   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))));
   Dart_Handle exception_error = Dart_NewUnhandledExceptionError(api_error);
   EXPECT(!Dart_IsApiError(exception_error));
   EXPECT(Dart_IsUnhandledExceptionError(exception_error));
@@ skipping 29 matching lines @@
   Dart_Handle obj = Api::NewHandle(thread, String::New(kRegularString));
   exception_error = Dart_NewUnhandledExceptionError(obj);
   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(kRegularString, exception_cstr);
 }
 
-
 // Should we propagate the error via Dart_SetReturnValue?
 static bool use_set_return = false;
 
 // Should we propagate the error via Dart_ThrowException?
 static bool use_throw_exception = false;
 
-
 void PropagateErrorNative(Dart_NativeArguments args) {
   Dart_Handle closure = Dart_GetNativeArgument(args, 0);
   EXPECT(Dart_IsClosure(closure));
   Dart_Handle result = Dart_InvokeClosure(closure, 0, NULL);
   EXPECT(Dart_IsError(result));
   if (use_set_return) {
     Dart_SetReturnValue(args, result);
   } else if (use_throw_exception) {
     result = Dart_ThrowException(result);
     EXPECT_VALID(result);  // We do not expect to reach here.
     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) {
   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"
@@ skipping 43 matching lines @@
   result = Dart_Invoke(lib, NewString("Func1"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT_SUBSTRING("semicolon expected", Dart_GetError(result));
 
   result = Dart_Invoke(lib, NewString("Func2"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("myException", Dart_GetError(result));
 }
 
-
 TEST_CASE(Dart_Error) {
   Dart_Handle error = Api::NewError("An %s", "error");
   EXPECT(Dart_IsError(error));
   EXPECT_STREQ("An error", Dart_GetError(error));
 }
 
-
 TEST_CASE(Null) {
   Dart_Handle null = Dart_Null();
   EXPECT_VALID(null);
   EXPECT(Dart_IsNull(null));
 
   Dart_Handle str = NewString("test");
   EXPECT_VALID(str);
   EXPECT(!Dart_IsNull(str));
 }
 
-
 TEST_CASE(EmptyString) {
   Dart_Handle empty = Dart_EmptyString();
   EXPECT_VALID(empty);
   EXPECT(!Dart_IsNull(empty));
 }
 
-
 TEST_CASE(IdentityEquals) {
   Dart_Handle five = Dart_NewInteger(5);
   Dart_Handle five_again = Dart_NewInteger(5);
   Dart_Handle mint = Dart_NewInteger(0xFFFFFFFF);
   Dart_Handle mint_again = Dart_NewInteger(0xFFFFFFFF);
   Dart_Handle abc = NewString("abc");
   Dart_Handle abc_again = NewString("abc");
   Dart_Handle xyz = NewString("xyz");
   Dart_Handle dart_core = NewString("dart:core");
   Dart_Handle dart_mirrors = NewString("dart:mirrors");
@@ skipping 30 matching lines @@
     EXPECT(Dart_IdentityEquals(lib1, lib1));
     EXPECT(Dart_IdentityEquals(lib2, lib2));
     EXPECT(!Dart_IdentityEquals(lib1, lib2));
 
     // Mix instance and non-instance.
     EXPECT(!Dart_IdentityEquals(lib1, nan1));
     EXPECT(!Dart_IdentityEquals(nan1, lib1));
   }
 }
 
-
 TEST_CASE(IdentityHash) {
   Dart_Handle five = Dart_NewInteger(5);
   Dart_Handle five_again = Dart_NewInteger(5);
   Dart_Handle mint = Dart_NewInteger(0xFFFFFFFF);
   Dart_Handle mint_again = Dart_NewInteger(0xFFFFFFFF);
   Dart_Handle abc = NewString("abc");
   // Dart_Handle abc_again = NewString("abc");
   Dart_Handle xyz = NewString("xyz");
   Dart_Handle dart_core = NewString("dart:core");
   Dart_Handle dart_mirrors = NewString("dart:mirrors");
@@ skipping 20 matching lines @@
     CHECK_API_SCOPE(thread);
     HANDLESCOPE(thread);
     Dart_Handle lib1 = Dart_LookupLibrary(dart_core);
     Dart_Handle lib2 = Dart_LookupLibrary(dart_mirrors);
 
     EXPECT_EQ(Dart_IdentityHash(lib1), Dart_IdentityHash(lib1));
     EXPECT_EQ(Dart_IdentityHash(lib2), Dart_IdentityHash(lib2));
   }
 }
 
-
 TEST_CASE(ObjectEquals) {
   bool equal = false;
   Dart_Handle five = NewString("5");
   Dart_Handle five_again = NewString("5");
   Dart_Handle seven = NewString("7");
 
   // Same objects.
   EXPECT_VALID(Dart_ObjectEquals(five, five, &equal));
   EXPECT(equal);
 
   // Equal objects.
   EXPECT_VALID(Dart_ObjectEquals(five, five_again, &equal));
   EXPECT(equal);
 
   // Different objects.
   EXPECT_VALID(Dart_ObjectEquals(five, seven, &equal));
   EXPECT(!equal);
 
   // Case where identity is not equality.
   Dart_Handle nan = Dart_NewDouble(NAN);
   EXPECT_VALID(Dart_ObjectEquals(nan, nan, &equal));
   EXPECT(!equal);
 }
 
-
 TEST_CASE(InstanceValues) {
   EXPECT(Dart_IsInstance(NewString("test")));
   EXPECT(Dart_IsInstance(Dart_True()));
 
   // By convention, our Is*() functions exclude null.
   EXPECT(!Dart_IsInstance(Dart_Null()));
 }
 
-
 TEST_CASE(InstanceGetType) {
   Zone* zone = thread->zone();
   // Get the handle from a valid instance handle.
   Dart_Handle type = Dart_InstanceGetType(Dart_Null());
   EXPECT_VALID(type);
   EXPECT(Dart_IsType(type));
   const Type& null_type_obj = Api::UnwrapTypeHandle(zone, type);
   EXPECT(null_type_obj.raw() == Type::NullType());
 
   Dart_Handle instance = Dart_True();
@@ skipping 22 matching lines @@
 
   // Get the handle from a non-instance handle.
   Dart_Handle dart_core = NewString("dart:core");
   Dart_Handle obj = Dart_LookupLibrary(dart_core);
   Dart_Handle type_type = Dart_InstanceGetType(obj);
   EXPECT_ERROR(type_type,
                "Dart_InstanceGetType expects argument 'instance' to be of "
                "type Instance.");
 }
 
-
 TEST_CASE(BooleanValues) {
   Dart_Handle str = NewString("test");
   EXPECT(!Dart_IsBoolean(str));
 
   bool value = false;
   Dart_Handle result = Dart_BooleanValue(str, &value);
   EXPECT(Dart_IsError(result));
 
   Dart_Handle val1 = Dart_NewBoolean(true);
   EXPECT(Dart_IsBoolean(val1));
 
   result = Dart_BooleanValue(val1, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 
   Dart_Handle val2 = Dart_NewBoolean(false);
   EXPECT(Dart_IsBoolean(val2));
 
   result = Dart_BooleanValue(val2, &value);
   EXPECT_VALID(result);
   EXPECT(!value);
 }
 
-
 TEST_CASE(BooleanConstants) {
   Dart_Handle true_handle = Dart_True();
   EXPECT_VALID(true_handle);
   EXPECT(Dart_IsBoolean(true_handle));
 
   bool value = false;
   Dart_Handle result = Dart_BooleanValue(true_handle, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 
   Dart_Handle false_handle = Dart_False();
   EXPECT_VALID(false_handle);
   EXPECT(Dart_IsBoolean(false_handle));
 
   result = Dart_BooleanValue(false_handle, &value);
   EXPECT_VALID(result);
   EXPECT(!value);
 }
 
-
 TEST_CASE(DoubleValues) {
   const double kDoubleVal1 = 201.29;
   const double kDoubleVal2 = 101.19;
   Dart_Handle val1 = Dart_NewDouble(kDoubleVal1);
   EXPECT(Dart_IsDouble(val1));
   Dart_Handle val2 = Dart_NewDouble(kDoubleVal2);
   EXPECT(Dart_IsDouble(val2));
   double out1, out2;
   Dart_Handle result = Dart_DoubleValue(val1, &out1);
   EXPECT_VALID(result);
   EXPECT_EQ(kDoubleVal1, out1);
   result = Dart_DoubleValue(val2, &out2);
   EXPECT_VALID(result);
   EXPECT_EQ(kDoubleVal2, out2);
 }
 
-
 TEST_CASE(NumberValues) {
   // TODO(antonm): add various kinds of ints (smi, mint, bigint).
   const char* kScriptChars =
       "int getInt() { return 1; }\n"
       "double getDouble() { return 1.0; }\n"
       "bool getBool() { return false; }\n"
       "getNull() { return null; }\n";
   Dart_Handle result;
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
@@ skipping 12 matching lines @@
   result = Dart_Invoke(lib, NewString("getBool"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(!Dart_IsNumber(result));
 
   // Check null case.
   result = Dart_Invoke(lib, NewString("getNull"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(!Dart_IsNumber(result));
 }
 
-
 TEST_CASE(IntegerValues) {
   const int64_t kIntegerVal1 = 100;
   const int64_t kIntegerVal2 = 0xffffffff;
   const char* kIntegerVal3 = "0x123456789123456789123456789";
   const uint64_t kIntegerVal4 = 0xffffffffffffffff;
 
   Dart_Handle val1 = Dart_NewInteger(kIntegerVal1);
   EXPECT(Dart_IsInteger(val1));
   bool fits = false;
   Dart_Handle result = Dart_IntegerFitsIntoInt64(val1, &fits);
@@ skipping 33 matching lines @@
   EXPECT_VALID(result);
   EXPECT_EQ(kIntegerVal4, out4);
 
   Dart_Handle val5 = Dart_NewInteger(-1);
   EXPECT_VALID(val5);
   uint64_t out5 = 0;
   result = Dart_IntegerToUint64(val5, &out5);
   EXPECT(Dart_IsError(result));
 }
 
-
 TEST_CASE(IntegerFitsIntoInt64) {
   Dart_Handle max = Dart_NewInteger(kMaxInt64);
   EXPECT(Dart_IsInteger(max));
   bool fits = false;
   Dart_Handle result = Dart_IntegerFitsIntoInt64(max, &fits);
   EXPECT_VALID(result);
   EXPECT(fits);
 
   Dart_Handle above_max = Dart_NewIntegerFromHexCString("0x8000000000000000");
   EXPECT(Dart_IsInteger(above_max));
@@ skipping 10 matching lines @@
   EXPECT(fits);
 
   Dart_Handle below_min = Dart_NewIntegerFromHexCString("-0x8000000000000001");
   EXPECT(Dart_IsInteger(below_min));
   fits = true;
   result = Dart_IntegerFitsIntoInt64(below_min, &fits);
   EXPECT_VALID(result);
   EXPECT(!fits);
 }
 
-
 TEST_CASE(IntegerFitsIntoUint64) {
   Dart_Handle max = Dart_NewIntegerFromUint64(kMaxUint64);
   EXPECT(Dart_IsInteger(max));
   bool fits = false;
   Dart_Handle result = Dart_IntegerFitsIntoUint64(max, &fits);
   EXPECT_VALID(result);
   EXPECT(fits);
 
   Dart_Handle above_max = Dart_NewIntegerFromHexCString("0x10000000000000000");
   EXPECT(Dart_IsInteger(above_max));
@@ skipping 10 matching lines @@
   EXPECT(fits);
 
   Dart_Handle below_min = Dart_NewIntegerFromHexCString("-1");
   EXPECT(Dart_IsInteger(below_min));
   fits = true;
   result = Dart_IntegerFitsIntoUint64(below_min, &fits);
   EXPECT_VALID(result);
   EXPECT(!fits);
 }
 
-
 TEST_CASE(ArrayValues) {
   EXPECT(!Dart_IsList(Dart_Null()));
   const int kArrayLength = 10;
   Dart_Handle str = NewString("test");
   EXPECT(!Dart_IsList(str));
   Dart_Handle val = Dart_NewList(kArrayLength);
   EXPECT(Dart_IsList(val));
   intptr_t len = 0;
   Dart_Handle result = Dart_ListLength(val, &len);
   EXPECT_VALID(result);
@@ skipping 16 matching lines @@
   for (int i = 0; i < kArrayLength; i++) {
     result = Dart_ListGetAt(val, i);
     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};
 
   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));
@@ skipping 58 matching lines @@
   EXPECT_EQ(data16, peer);
 
   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.
   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));
   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.
   const char* kScriptChars =
       "String lowSurrogate() {"
       "  return '\\u{1D11E}'[1];"
       "}"
@@ skipping 25 matching lines @@
   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.
 // The normal call to CollectGarbage(Heap::kNew) could potentially trigger
 // an old gen collection if there is a promotion failure and this could
 // perturb the test.
 class GCTestHelper : public AllStatic {
  public:
   static void CollectNewSpace(Heap::ApiCallbacks api_callbacks) {
     bool invoke_api_callbacks = (api_callbacks == Heap::kInvokeApiCallbacks);
     Isolate::Current()->heap()->new_space()->Scavenge(invoke_api_callbacks);
   }
 
   static void WaitForGCTasks() {
     Thread* thread = Thread::Current();
     PageSpace* old_space = thread->isolate()->heap()->old_space();
     MonitorLocker ml(old_space->tasks_lock());
     while (old_space->tasks() > 0) {
       ml.WaitWithSafepointCheck(thread);
     }
   }
 };
 
-
 static void ExternalStringCallbackFinalizer(void* peer) {
   *static_cast<int*>(peer) *= 2;
 }
 
-
 TEST_CASE(ExternalStringCallback) {
   int peer8 = 40;
   int peer16 = 41;
 
   {
     Dart_EnterScope();
 
     uint8_t data8[] = {'h', 'e', 'l', 'l', 'o'};
     Dart_Handle obj8 = Dart_NewExternalLatin1String(
         data8, ARRAY_SIZE(data8), &peer8, ExternalStringCallbackFinalizer);
@@ skipping 15 matching lines @@
     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,
     };
     Dart_Handle big8 = Dart_NewExternalLatin1String(
         big_data8, ARRAY_SIZE(big_data8), NULL, NULL);
     EXPECT_VALID(big8);
     static const uint16_t big_data16[16 * MB / 2] = {
@@ skipping 19 matching lines @@
       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;
     int64_t* big_data = new int64_t[kBigLength]();
     Dart_Handle big =
         Dart_NewExternalTypedData(Dart_TypedData_kInt64, big_data, kBigLength);
     EXPECT_VALID(big);
     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);
     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());
     }
     Dart_ExitScope();
     delete[] big_data;
     delete[] small_data;
   }
 }
 
-
 TEST_CASE(ListAccess) {
   const char* kScriptChars =
       "List testMain() {"
       "  List a = new List();"
       "  a.add(10);"
       "  a.add(20);"
       "  a.add(30);"
       "  return a;"
       "}"
       ""
@@ skipping 130 matching lines @@
 
   result = Dart_ListSetAsBytes(list_access_test_obj, 0, native_array, 3);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_IsUnhandledExceptionError(result));
 
   result = Dart_ListSetAt(list_access_test_obj, 0, Dart_NewInteger(42));
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_IsUnhandledExceptionError(result));
 }
 
-
 TEST_CASE(MapAccess) {
   EXPECT(!Dart_IsMap(Dart_Null()));
   const char* kScriptChars =
       "Map testMain() {"
       "  return {"
       "    'a' : 1,"
       "    'b' : null,"
       "  };"
       "}";
   Dart_Handle result;
@@ skipping 72 matching lines @@
 
   result = Dart_ListGetAt(keys, 1);
   EXPECT(Dart_IsString(result));
   equals = false;
   EXPECT_VALID(Dart_ObjectEquals(result, b, &equals));
   EXPECT(equals);
 
   EXPECT(Dart_IsError(Dart_MapKeys(a)));
 }
 
-
 TEST_CASE(IsFuture) {
   const char* kScriptChars =
       "import 'dart:async';"
       "Future testMain() {"
       "  return new Completer().future;"
       "}";
   Dart_Handle result;
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke a function which returns an object of type Future.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsFuture(result));
 
   EXPECT(!Dart_IsFuture(lib));  // Non-instance.
   Dart_Handle anInteger = Dart_NewInteger(0);
   EXPECT(!Dart_IsFuture(anInteger));
   Dart_Handle aString = NewString("I am not a Future");
   EXPECT(!Dart_IsFuture(aString));
   Dart_Handle null = Dart_Null();
   EXPECT(!Dart_IsFuture(null));
 }
 
-
 TEST_CASE(TypedDataViewListGetAsBytes) {
   const int kSize = 1000;
 
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "List main(int size) {\n"
       "  var a = new Int8List(size);\n"
       "  var view = new Int8List.view(a.buffer, 0, size);\n"
       "  return view;\n"
       "}\n";
@@ skipping 12 matching lines @@
   EXPECT_VALID(Dart_ListGetAsBytes(view_obj, 0, data, kSize));
   for (intptr_t i = 0; i < kSize; ++i) {
     EXPECT_EQ(i & 0xff, data[i]);
   }
 
   Dart_Handle result = Dart_ListGetAsBytes(view_obj, 0, data, kSize + 1);
   EXPECT(Dart_IsError(result));
   delete[] data;
 }
 
-
 TEST_CASE(TypedDataViewListIsTypedData) {
   const int kSize = 1000;
 
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "List main(int size) {\n"
       "  var a = new Int8List(size);\n"
       "  var view = new Int8List.view(a.buffer, 0, size);\n"
       "  return view;\n"
       "}\n";
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Create a typed data view object.
   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_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_kInvalid,
             Dart_GetTypeOfExternalTypedData(byte_array1));
   EXPECT(Dart_IsList(byte_array1));
@@ skipping 53 matching lines @@
   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);
   }
 }
 
-
 TEST_CASE(ByteBufferAccess) {
   EXPECT(!Dart_IsByteBuffer(Dart_True()));
   Dart_Handle byte_array = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
   EXPECT_VALID(byte_array);
   // Set through the List API.
   for (intptr_t i = 0; i < 10; ++i) {
     EXPECT_VALID(Dart_ListSetAt(byte_array, i, Dart_NewInteger(i + 1)));
   }
   Dart_Handle byte_buffer = Dart_NewByteBuffer(byte_array);
   EXPECT_VALID(byte_buffer);
@@ skipping 23 matching lines @@
   result = Dart_NewByteBuffer(Dart_True());
   EXPECT(Dart_IsError(result));
   result = Dart_NewByteBuffer(byte_buffer);
   EXPECT(Dart_IsError(result));
   result = Dart_GetDataFromByteBuffer(Dart_False());
   EXPECT(Dart_IsError(result));
   result = Dart_GetDataFromByteBuffer(byte_array);
   EXPECT(Dart_IsError(result));
 }
 
-
 static int kLength = 16;
 
 static void ByteDataNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_Handle byte_data = Dart_NewTypedData(Dart_TypedData_kByteData, kLength);
   EXPECT_VALID(byte_data);
   EXPECT_EQ(Dart_TypedData_kByteData, Dart_GetTypeOfTypedData(byte_data));
   Dart_SetReturnValue(args, byte_data);
   Dart_ExitScope();
 }
 
-
 static Dart_NativeFunction ByteDataNativeResolver(Dart_Handle name,
                                                   int arg_count,
                                                   bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = true;
   return &ByteDataNativeFunction;
 }
 
-
 TEST_CASE(ByteDataAccess) {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
       "      throw 'not equal. expected: $a, got: $b';\n"
       "    }\n"
       "  }\n"
       "}\n"
@@ skipping 15 matching lines @@
 
   Dart_Handle result =
       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 void ExternalByteDataNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
   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) {
   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 =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
       "      throw 'not equal. expected: $a, got: $b';\n"
       "    }\n"
@@ skipping 26 matching lines @@
   // Invoke 'main' function.
   result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 
   for (intptr_t i = 0; i < kExtLength; i += 2) {
     EXPECT_EQ(0x24, data[i]);
     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 void OptExternalByteDataNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
   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) {
   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"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
       "      throw 'not equal. expected: $a, got: $b';\n"
       "    }\n"
       "  }\n"
       "}\n"
@@ skipping 21 matching lines @@
   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.");
   Dart_TypedData_Type type;
@@ skipping 19 matching lines @@
   result = Dart_TypedDataReleaseData(Dart_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'.");
 }
 
-
 TEST_CASE(TypedDataDirectAccessUnverified) {
   FLAG_verify_acquired_data = false;
   TestTypedDataDirectAccess();
 }
 
-
 TEST_CASE(TypedDataDirectAccessVerified) {
   FLAG_verify_acquired_data = true;
   TestTypedDataDirectAccess();
 }
 
-
 static void TestDirectAccess(Dart_Handle lib,
                              Dart_Handle array,
                              Dart_TypedData_Type expected_type,
                              bool is_external) {
   Dart_Handle result;
 
   // Invoke the dart function that sets initial values.
   Dart_Handle dart_args[1];
   dart_args[0] = array;
   result = Dart_Invoke(lib, NewString("setMain"), 1, dart_args);
@@ skipping 30 matching lines @@
 
   // Release direct access to the typed data object.
   result = Dart_TypedDataReleaseData(array);
   EXPECT_VALID(result);
 
   // Invoke the dart function in order to check the modified values.
   result = Dart_Invoke(lib, NewString("testMain"), 1, dart_args);
   EXPECT_VALID(result);
 }
 
-
 static void TestTypedDataDirectAccess1() {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
       "      throw new Exception('not equal. expected: $a, got: $b');\n"
       "    }\n"
       "  }\n"
       "}\n"
@@ skipping 24 matching lines @@
   // Test with an external typed data object.
   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);
   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();
 }
 
-
 TEST_CASE(TypedDataDirectAccess1Verified) {
   FLAG_verify_acquired_data = true;
   TestTypedDataDirectAccess1();
 }
 
-
 static void TestTypedDataViewDirectAccess() {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
       "      throw 'not equal. expected: $a, got: $b';\n"
       "    }\n"
       "  }\n"
       "}\n"
@@ skipping 18 matching lines @@
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Test with a typed data view 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_CASE(TypedDataViewDirectAccessUnverified) {
   FLAG_verify_acquired_data = false;
   TestTypedDataViewDirectAccess();
 }
 
-
 TEST_CASE(TypedDataViewDirectAccessVerified) {
   FLAG_verify_acquired_data = true;
   TestTypedDataViewDirectAccess();
 }
 
-
 static void TestByteDataDirectAccess() {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
       "      throw 'not equal. expected: $a, got: $b';\n"
       "    }\n"
       "  }\n"
       "}\n"
@@ skipping 18 matching lines @@
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Test with a typed data view 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_kByteData, false);
 }
 
-
 TEST_CASE(ByteDataDirectAccessUnverified) {
   FLAG_verify_acquired_data = false;
   TestByteDataDirectAccess();
 }
 
-
 TEST_CASE(ByteDataDirectAccessVerified) {
   FLAG_verify_acquired_data = true;
   TestByteDataDirectAccess();
 }
 
-
 static void ExternalTypedDataAccessTests(Dart_Handle obj,
                                          Dart_TypedData_Type expected_type,
                                          uint8_t data[],
                                          intptr_t data_length) {
   EXPECT_VALID(obj);
   EXPECT_EQ(expected_type, Dart_GetTypeOfExternalTypedData(obj));
   EXPECT(Dart_IsList(obj));
 
   void* raw_data = NULL;
   intptr_t len;
@@ skipping 36 matching lines @@
     Dart_Handle value = Dart_NewInteger(33 * i);
     EXPECT_VALID(value);
     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};
   intptr_t data_length = ARRAY_SIZE(data);
 
   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};
   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);
 }
 
-
 TEST_CASE(ExternalUint8ClampedArrayAccess) {
   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"
@@ skipping 14 matching lines @@
 
   // 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) {}
 
-
 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);
     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);
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 42);
   }
 }
 
-
 static void SlowFinalizer(void* isolate_callback_data,
                           Dart_WeakPersistentHandle handle,
                           void* peer) {
   OS::Sleep(10);
   intptr_t* count = reinterpret_cast<intptr_t*>(peer);
   (*count)++;
 }
 
-
 TEST_CASE(SlowFinalizer) {
   intptr_t count = 0;
   for (intptr_t i = 0; i < 10; i++) {
     Dart_EnterScope();
     Dart_Handle str1 = Dart_NewStringFromCString("Live fast");
     Dart_NewWeakPersistentHandle(str1, &count, 0, SlowFinalizer);
     Dart_Handle str2 = Dart_NewStringFromCString("Die young");
     Dart_NewWeakPersistentHandle(str2, &count, 0, SlowFinalizer);
     Dart_ExitScope();
 
     {
       TransitionNativeToVM transition(thread);
       Isolate::Current()->heap()->CollectAllGarbage();
     }
   }
 
   {
     TransitionNativeToVM transition(thread);
     GCTestHelper::WaitForGCTasks();
   }
 
   EXPECT_EQ(20, count);
 }
 
-
 static void CheckFloat32x4Data(Dart_Handle obj) {
   void* raw_data = NULL;
   intptr_t len;
   Dart_TypedData_Type type;
   EXPECT_VALID(Dart_TypedDataAcquireData(obj, &type, &raw_data, &len));
   EXPECT_EQ(Dart_TypedData_kFloat32x4, type);
   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 =
       "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);
@@ skipping 21 matching lines @@
   }
   Dart_ExitScope();
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 42);
   }
 }
 
-
 // Unit test for entering a scope, creating a local handle and exiting
 // the scope.
 VM_UNIT_TEST_CASE(EnterExitScope) {
   TestIsolateScope __test_isolate__;
 
   Thread* thread = Thread::Current();
   EXPECT(thread != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   Dart_EnterScope();
   {
     EXPECT(thread->api_top_scope() != NULL);
     HANDLESCOPE(thread);
     const String& str1 = String::Handle(String::New("Test String"));
     Dart_Handle ref = Api::NewHandle(thread, str1.raw());
     String& str2 = String::Handle();
     str2 ^= Api::UnwrapHandle(ref);
     EXPECT(str1.Equals(str2));
   }
   Dart_ExitScope();
   EXPECT(scope == thread->api_top_scope());
 }
 
-
 // Unit test for creating and deleting persistent handles.
 VM_UNIT_TEST_CASE(PersistentHandles) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestCase::CreateTestIsolate();
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
@@ skipping 47 matching lines @@
       String& str = String::Handle();
       str ^= PersistentHandle::Cast(handles[i])->raw();
       EXPECT(str.Equals(kTestString2));
     }
   }
   EXPECT(scope == thread->api_top_scope());
   EXPECT_EQ(2001, state->CountPersistentHandles());
   Dart_ShutdownIsolate();
 }
 
-
 // Test that we are able to create a persistent handle from a
 // persistent handle.
 VM_UNIT_TEST_CASE(NewPersistentHandle_FromPersistentHandle) {
   TestIsolateScope __test_isolate__;
 
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   Thread* thread = Thread::Current();
@@ skipping 11 matching lines @@
 
   // Make sure that the value transferred.
   Dart_Handle obj4 = Dart_HandleFromPersistent(obj3);
   EXPECT(Dart_IsBoolean(obj4));
   bool value = false;
   Dart_Handle result = Dart_BooleanValue(obj4, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
-
 // Test that we can assign to a persistent handle.
 VM_UNIT_TEST_CASE(AssignToPersistentHandle) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestIsolateScope __test_isolate__;
 
   Thread* T = Thread::Current();
   CHECK_API_SCOPE(T);
   HANDLESCOPE(T);
   Isolate* isolate = T->isolate();
@@ skipping 13 matching lines @@
   Dart_Handle ref2 = Api::NewHandle(T, String::New(kTestString2));
   Dart_SetPersistentHandle(obj, ref2);
   str ^= PersistentHandle::Cast(obj)->raw();
   EXPECT(str.Equals(kTestString2));
 
   // Now assign Null to the persistent handle and check.
   Dart_SetPersistentHandle(obj, Dart_Null());
   EXPECT(Dart_IsNull(obj));
 }
 
-
 static Dart_Handle AsHandle(Dart_PersistentHandle weak) {
   return Dart_HandleFromPersistent(weak);
 }
 
-
 static Dart_Handle AsHandle(Dart_WeakPersistentHandle weak) {
   return Dart_HandleFromWeakPersistent(weak);
 }
 
-
 static Dart_WeakPersistentHandle weak_new_ref = NULL;
 static Dart_WeakPersistentHandle weak_old_ref = NULL;
 
-
 static void WeakPersistentHandleCallback(void* isolate_callback_data,
                                          Dart_WeakPersistentHandle handle,
                                          void* peer) {
   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);
 
   Dart_Handle local_old_ref = Dart_Null();
   weak_old_ref = Dart_NewWeakPersistentHandle(local_old_ref, NULL, 0,
                                               WeakPersistentHandleCallback);
 
   {
@@ skipping 100 matching lines @@
   }
 
   {
     TransitionNativeToVM transition(thread);
     // Garbage collect one last time to revisit deleted handles.
     Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   }
 }
 
-
 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);
   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);
   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;
 }
 
-
 TEST_CASE(WeakPersistentHandleCallback) {
   Dart_WeakPersistentHandle weak_ref = NULL;
   int peer = 0;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("new string");
     EXPECT_VALID(obj);
     weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                             WeakPersistentHandlePeerFinalizer);
     EXPECT_VALID(AsHandle(weak_ref));
     EXPECT(peer == 0);
     Dart_ExitScope();
   }
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT(peer == 0);
     GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 42);
   }
 }
 
-
 TEST_CASE(WeakPersistentHandleNoCallback) {
   Dart_WeakPersistentHandle weak_ref = NULL;
   int peer = 0;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("new string");
     EXPECT_VALID(obj);
     weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                             WeakPersistentHandlePeerFinalizer);
     Dart_ExitScope();
   }
   // A finalizer is not invoked on a deleted handle.  Therefore, the
   // peer value should not change after the referent is collected.
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Dart_DeleteWeakPersistentHandle(isolate, weak_ref);
   EXPECT(peer == 0);
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT(peer == 0);
     GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 0);
   }
 }
 
-
 VM_UNIT_TEST_CASE(WeakPersistentHandlesCallbackShutdown) {
   TestCase::CreateTestIsolate();
   Dart_EnterScope();
   Dart_Handle ref = Dart_True();
   int peer = 1234;
   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);
@@ skipping 32 matching lines @@
   Dart_DeleteWeakPersistentHandle(isolate, weak2);
   Dart_DeletePersistentHandle(strong_ref);
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     GCTestHelper::WaitForGCTasks();
     EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
   }
 }
 
-
 TEST_CASE(WeakPersistentHandleExternalAllocationSizeNewspaceGC) {
   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);
@@ skipping 23 matching lines @@
   }
   Dart_DeleteWeakPersistentHandle(isolate, weak1);
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     GCTestHelper::WaitForGCTasks();
     EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
   }
 }
 
-
 TEST_CASE(WeakPersistentHandleExternalAllocationSizeOldspaceGC) {
   // Check that external allocation in old space can trigger GC.
   Isolate* isolate = Isolate::Current();
   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,
                                         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);
   // 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.
@@ skipping 15 matching lines @@
   Dart_DeleteWeakPersistentHandle(isolate, weak1);
   Dart_DeleteWeakPersistentHandle(isolate, weak2);
   EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
   }
 }
 
-
 static Dart_WeakPersistentHandle weak1 = NULL;
 static Dart_WeakPersistentHandle weak2 = NULL;
 static Dart_WeakPersistentHandle weak3 = NULL;
 
-
 static void ImplicitReferencesCallback(void* isolate_callback_data,
                                        Dart_WeakPersistentHandle handle,
                                        void* peer) {
   if (handle == weak1) {
     weak1 = NULL;
   } else if (handle == weak2) {
     weak2 = NULL;
   } else if (handle == weak3) {
     weak3 = NULL;
   }
 }
 
-
 TEST_CASE(ImplicitReferencesOldSpace) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_EnterScope();
   {
     CHECK_API_SCOPE(thread);
     HANDLESCOPE(thread);
 
     Dart_Handle local =
@@ skipping 45 matching lines @@
     Dart_EnterScope();
     // New space collection should not affect old space objects
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     Dart_ExitScope();
   }
 }
 
-
 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));
     strong = Dart_NewPersistentHandle(local);
     strong_weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NopCallback);
 
@@ skipping 40 matching lines @@
   {
     Dart_EnterScope();
     // Old space collection should not affect old space objects.
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     Dart_ExitScope();
   }
 }
 
-
 static int global_prologue_callback_status;
 
-
 static void PrologueCallbackTimes2() {
   global_prologue_callback_status *= 2;
 }
 
-
 static void PrologueCallbackTimes3() {
   global_prologue_callback_status *= 3;
 }
 
-
 static int global_epilogue_callback_status;
 
-
 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));
 
   // Add the same callbacks again.  This is an error.
   EXPECT(Dart_IsError(
       Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackTimes4)));
 
   // Add another callback. This is an error.
   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(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));
 
   {
     TransitionNativeToVM transition(thread);
 
     // Garbage collect new space ignoring callbacks.  This should not
     // invoke the prologue callback.  No status values should change.
@@ skipping 88 matching lines @@
     // Garbage collect old space.  No callbacks should be invoked.  No
     // status values should change.
     global_prologue_callback_status = 3;
     global_epilogue_callback_status = 7;
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT_EQ(3, global_prologue_callback_status);
     EXPECT_EQ(7, global_epilogue_callback_status);
   }
 }
 
-
 // Unit test for creating multiple scopes and local handles within them.
 // Ensure that the local handles get all cleaned out when exiting the
 // scope.
 VM_UNIT_TEST_CASE(LocalHandles) {
   TestCase::CreateTestIsolate();
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   EXPECT(isolate != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   Dart_Handle handles[300];
@@ skipping 43 matching lines @@
       Dart_ExitScope();
     }
     EXPECT_EQ(100, thread->CountLocalHandles());
     Dart_ExitScope();
   }
   EXPECT_EQ(0, thread->CountLocalHandles());
   EXPECT(scope == thread->api_top_scope());
   Dart_ShutdownIsolate();
 }
 
-
 // Unit test for creating multiple scopes and allocating objects in the
 // zone for the scope. Ensure that the memory is freed when the scope
 // exits.
 VM_UNIT_TEST_CASE(LocalZoneMemory) {
   TestCase::CreateTestIsolate();
   Thread* thread = Thread::Current();
   EXPECT(thread != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   {
     // Start a new scope and allocate some memory.
@@ skipping 24 matching lines @@
       Dart_ExitScope();
     }
     EXPECT_EQ(1600, thread->ZoneSizeInBytes());
     Dart_ExitScope();
   }
   EXPECT_EQ(0, thread->ZoneSizeInBytes());
   EXPECT(scope == thread->api_top_scope());
   Dart_ShutdownIsolate();
 }
 
-
 VM_UNIT_TEST_CASE(Isolates) {
   // This test currently assumes that the Dart_Isolate type is an opaque
   // representation of Isolate*.
   Dart_Isolate iso_1 = TestCase::CreateTestIsolate();
   EXPECT_EQ(iso_1, Api::CastIsolate(Isolate::Current()));
   Dart_Isolate isolate = Dart_CurrentIsolate();
   EXPECT_EQ(iso_1, isolate);
   Dart_ExitIsolate();
   EXPECT(NULL == Dart_CurrentIsolate());
   Dart_Isolate iso_2 = TestCase::CreateTestIsolate();
   EXPECT_EQ(iso_2, Dart_CurrentIsolate());
   Dart_ExitIsolate();
   EXPECT(NULL == Dart_CurrentIsolate());
   Dart_EnterIsolate(iso_2);
   EXPECT_EQ(iso_2, Dart_CurrentIsolate());
   Dart_ShutdownIsolate();
   EXPECT(NULL == Dart_CurrentIsolate());
   Dart_EnterIsolate(iso_1);
   EXPECT_EQ(iso_1, Dart_CurrentIsolate());
   Dart_ShutdownIsolate();
   EXPECT(NULL == Dart_CurrentIsolate());
 }
 
-
 VM_UNIT_TEST_CASE(CurrentIsolateData) {
   intptr_t mydata = 12345;
   char* err;
   Dart_Isolate isolate =
       Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_data,
                          bin::core_isolate_snapshot_instructions, NULL,
                          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();
 }
 
-
 VM_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;"
@@ skipping 36 matching lines @@
     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) {}
 
-
 VM_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';";
   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());
   EXPECT(!Dart_HasStickyError());
   EXPECT(Dart_GetStickyError() == Dart_Null());
 }
 
-
 TEST_CASE(TypeGetNonParamtericTypes) {
   const char* kScriptChars =
       "class MyClass0 {\n"
       "}\n"
       "\n"
       "class MyClass1 implements MyInterface1 {\n"
       "}\n"
       "\n"
       "class MyClass2 implements MyInterface0, MyInterface1 {\n"
       "}\n"
@@ skipping 71 matching lines @@
   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"
       "\n"
       "class MyClass1<A, C> {\n"
       "}\n"
       "MyClass0 getMyClass0() {\n"
       "  return new MyClass0<int, double>();\n"
       "}\n"
@@ skipping 83 matching lines @@
   // 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);
   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) {
   Dart_Handle result;
 
   // Make sure we have the right initial value.
   result = Dart_GetField(container, name);
   EXPECT_VALID(result);
   const char* value = "";
@@ skipping 17 matching lines @@
   result = Dart_GetField(container, name);
   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) {
   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"
       "  }\n"
       "  var inherited_fld;\n"
       "  static var non_inherited_fld;\n"
       "}\n"
       "\n"
@@ skipping 231 matching lines @@
   TestFieldNotFound(instance, name);
   TestFieldOk(lib, name, false, "imported getset");
 
   // 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";
 
   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);
@@ skipping 13 matching lines @@
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_SetField expects argument 'value' to be of type Instance.",
                Dart_GetError(result));
 
   // Pass an error handle.  The error is contagious.
   result = Dart_SetField(lib, name, Api::NewError("myerror"));
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("myerror", Dart_GetError(result));
 }
 
-
 void NativeFieldLookup(Dart_NativeArguments args) {
   UNREACHABLE();
 }
 
-
 static Dart_NativeFunction native_field_lookup(Dart_Handle name,
                                                int argument_count,
                                                bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&NativeFieldLookup);
 }
 
-
 TEST_CASE(InjectNativeFields1) {
   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"
@@ skipping 31 matching lines @@
   // (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(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);
 
   // 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"
@@ skipping 21 matching lines @@
   // (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(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"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static const int fld4 = 10;\n"
       "}\n"
@@ skipping 15 matching lines @@
   EXPECT(Dart_IsError(result));
   Dart_Handle expected_error = DartUtils::NewError(
       "'dart:test-lib': Error: line 1 pos 36: "
       "class 'NativeFields' is trying to extend a native fields class, "
       "but library '%s' has no native resolvers",
       TestCase::url());
   EXPECT_SUBSTRING(Dart_GetError(expected_error), Dart_GetError(result));
 #endif
 }
 
-
 static const int kTestNumNativeFields = 2;
 static const intptr_t kNativeField1Value = 30;
 static const intptr_t kNativeField2Value = 40;
 
 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);
   EXPECT_VALID(result);
   EXPECT_EQ(kNativeField1Value, field_values[0]);
   EXPECT_EQ(kNativeField2Value, field_values[1]);
   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) {
   ASSERT(auto_scope != NULL);
   *auto_scope = true;
   const Object& obj = Object::Handle(Api::UnwrapHandle(name));
   if (!obj.IsString()) {
     return NULL;
   }
   const char* function_name = obj.ToCString();
   ASSERT(function_name != NULL);
   if (!strcmp(function_name, "TestNativeFieldsAccess_init")) {
     return reinterpret_cast<Dart_NativeFunction>(&TestNativeFieldsAccess_init);
   } else if (!strcmp(function_name, "TestNativeFieldsAccess_access")) {
     return reinterpret_cast<Dart_NativeFunction>(
         &TestNativeFieldsAccess_access);
   } else {
     return NULL;
   }
 }
 
-
 TEST_CASE(TestNativeFieldsAccess) {
   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"
       "  int initNativeFlds() native 'TestNativeFieldsAccess_init';\n"
       "  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);
 
   // 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';"
       "class NativeFieldsSuper extends NativeFieldWrapperClass1 {\n"
       "  NativeFieldsSuper() : fld1 = 42 {}\n"
       "  int fld1;\n"
       "}\n"
       "class NativeFields extends NativeFieldsSuper {\n"
       "  fld() => fld1;\n"
       "}\n"
       "int testMain() {\n"
       "  NativeFields obj = new NativeFields();\n"
       "  return obj.fld();\n"
       "}\n";
   Dart_Handle result;
   // Load up a test script in the test library.
   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);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(42, value);
 }
 
-
 static void TestNativeFields(Dart_Handle retobj) {
   // Access and set various instance fields of the object.
   Dart_Handle result = Dart_GetField(retobj, NewString("fld3"));
   EXPECT(Dart_IsError(result));
   result = Dart_GetField(retobj, NewString("fld0"));
   EXPECT_VALID(result);
   EXPECT(Dart_IsNull(result));
   result = Dart_GetField(retobj, NewString("fld1"));
   EXPECT_VALID(result);
   int64_t value = 0;
@@ skipping 55 matching lines @@
   result = Dart_GetField(retobj, NewString("fld1"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(40, value);
   result = Dart_GetField(retobj, NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(20, value);
 }
 
-
 TEST_CASE(NativeFieldAccess) {
   const char* kScriptChars =
       "class NativeFields extends NativeFieldsWrapper {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld0;\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static const int fld4 = 10;\n"
       "}\n"
@@ skipping 29 matching lines @@
 
   result = Dart_GetNativeInstanceField(error, 0, &field_value);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("myerror", Dart_GetError(result));
 
   result = Dart_SetNativeInstanceField(error, 0, 1);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("myerror", Dart_GetError(result));
 }
 
-
 TEST_CASE(ImplicitNativeFieldAccess) {
   const char* kScriptChars =
       "import 'dart:nativewrappers';"
       "class NativeFields extends NativeFieldWrapperClass4 {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld0;\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";
   // Load up a test script in the test library.
   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);
 }
 
-
 TEST_CASE(NegativeNativeFieldAccess) {
   const char* kScriptChars =
       "class NativeFields {\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 testMain1() {\n"
@@ skipping 51 matching lines @@
   result = Dart_GetNativeInstanceField(retobj, kNativeFld2, &value);
   EXPECT(Dart_IsError(result));
   result = Dart_SetNativeInstanceField(retobj, kNativeFld4, 40);
   EXPECT(Dart_IsError(result));
   result = Dart_SetNativeInstanceField(retobj, kNativeFld3, 40);
   EXPECT(Dart_IsError(result));
   result = Dart_SetNativeInstanceField(retobj, kNativeFld0, 400);
   EXPECT(Dart_IsError(result));
 }
 
-
 TEST_CASE(NegativeNativeFieldInIsolateMessage) {
   const char* kScriptChars =
       "import 'dart:isolate';\n"
       "import 'dart:nativewrappers';\n"
       "echo(msg) {\n"
       "  var data = msg[0];\n"
       "  var reply = msg[1];\n"
       "  reply.send('echoing ${data(1)}}');\n"
       "}\n"
       "class Test extends NativeFieldWrapperClass2 {\n"
@@ skipping 17 matching lines @@
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke 'main' which should spawn an isolate and try to send an
   // object with native fields over to the spawned isolate. This
   // should result in an unhandled exception which is checked.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(retobj));
 }
 
-
 TEST_CASE(GetStaticField_RunsInitializer) {
   const char* kScriptChars =
       "class TestClass  {\n"
       "  static const int fld1 = 7;\n"
       "  static int fld2 = 11;\n"
       "  static void testMain() {\n"
       "  }\n"
       "}\n";
   Dart_Handle result;
   // Create a test library and Load up a test script in it.
@@ skipping 21 matching lines @@
   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);
 }
 
-
 TEST_CASE(GetField_CheckIsolate) {
   const char* kScriptChars =
       "class TestClass  {\n"
       "  static int fld2 = 11;\n"
       "  static void testMain() {\n"
       "  }\n"
       "}\n";
   Dart_Handle result;
   int64_t value = 0;
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle type = Dart_GetType(lib, NewString("TestClass"), 0, NULL);
   EXPECT_VALID(type);
 
   result = Dart_GetField(type, NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(11, value);
 }
 
-
 TEST_CASE(SetField_CheckIsolate) {
   const char* kScriptChars =
       "class TestClass  {\n"
       "  static int fld2 = 11;\n"
       "  static void testMain() {\n"
       "  }\n"
       "}\n";
   Dart_Handle result;
   int64_t value = 0;
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle type = Dart_GetType(lib, NewString("TestClass"), 0, NULL);
   EXPECT_VALID(type);
 
   result = Dart_SetField(type, NewString("fld2"), Dart_NewInteger(13));
   EXPECT_VALID(result);
 
   result = Dart_GetField(type, NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(13, value);
 }
 
-
 TEST_CASE(New) {
   const char* kScriptChars =
       "class MyClass {\n"
       "  MyClass() : foo = 7 {}\n"
       "  MyClass.named(value) : foo = value {}\n"
       "  MyClass._hidden(value) : foo = -value {}\n"
       "  MyClass.exception(value) : foo = value {\n"
       "    throw 'ConstructorDeath';\n"
       "  }\n"
       "  factory MyClass.multiply(value) {\n"
@@ skipping 211 matching lines @@
   result = Dart_New(intf, Dart_Null(), 0, NULL);
   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);
 }
 
-
 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);
   EXPECT_VALID(list_type);
 
   const int kNumArgs = 1;
   Dart_Handle args[kNumArgs];
   args[0] = Dart_NewInteger(1);
   Dart_Handle list_obj = Dart_New(list_type, Dart_Null(), kNumArgs, args);
   EXPECT_VALID(list_obj);
   EXPECT(Dart_IsList(list_obj));
 }
 
-
 static Dart_Handle PrivateLibName(Dart_Handle lib, const char* str) {
   EXPECT(Dart_IsLibrary(lib));
   Thread* thread = Thread::Current();
   const Library& library_obj = Api::UnwrapLibraryHandle(thread->zone(), lib);
   const String& name = String::Handle(String::New(str));
   return Api::NewHandle(thread, library_obj.PrivateName(name));
 }
 
-
 TEST_CASE(Invoke) {
   const char* kScriptChars =
       "class BaseMethods {\n"
       "  inheritedMethod(arg) => 'inherited $arg';\n"
       "  static nonInheritedMethod(arg) => 'noninherited $arg';\n"
       "}\n"
       "\n"
       "class Methods extends BaseMethods {\n"
       "  instanceMethod(arg) => 'instance $arg';\n"
       "  _instanceMethod(arg) => 'hidden instance $arg';\n"
@@ skipping 99 matching lines @@
   // Hidden top-level method.
   name = NewString("_topMethod");
   EXPECT(Dart_IsError(Dart_Invoke(type, name, 1, args)));
   EXPECT(Dart_IsError(Dart_Invoke(instance, name, 1, args)));
   result = Dart_Invoke(lib, name, 1, args);
   EXPECT_VALID(result);
   result = Dart_StringToCString(result, &str);
   EXPECT_STREQ("hidden top !!!", str);
 }
 
-
 TEST_CASE(Invoke_PrivateStatic) {
   const char* kScriptChars =
       "class Methods {\n"
       "  static _staticMethod(arg) => 'hidden static $arg';\n"
       "}\n"
       "\n";
 
   // Shared setup.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle type = Dart_GetType(lib, NewString("Methods"), 0, NULL);
   Dart_Handle result;
   EXPECT_VALID(type);
   Dart_Handle name = NewString("_staticMethod");
   EXPECT_VALID(name);
 
   Dart_Handle args[1];
   args[0] = NewString("!!!");
   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";
 
   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("!!!");
@@ skipping 26 matching lines @@
   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);
   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);
   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"
       "    if (a != b) {\n"
       "      throw 'not equal. expected: $a, got: $b';\n"
       "    }\n"
       "  }\n"
       "}\n"
@@ skipping 44 matching lines @@
   result = Dart_Invoke(instance, NewString("method"), 0, NULL);
   EXPECT_VALID(result);
 
   result = Dart_GetField(type, NewString("fld1"));
   EXPECT_VALID(result);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(3, value);
 }
 
-
 TEST_CASE(Invoke_CrossLibrary) {
   const char* kLibrary1Chars =
       "library library1_name;\n"
       "void local() {}\n"
       "void _local() {}\n";
   const char* kLibrary2Chars =
       "library library2_name;\n"
       "void imported() {}\n"
       "void _imported() {}\n";
 
@@ skipping 18 matching lines @@
   // We can invoke both private and non-private local functions.
   EXPECT_VALID(Dart_Invoke(lib1, NewString("local"), 0, NULL));
   EXPECT_VALID(Dart_Invoke(lib1, NewString("_local"), 0, NULL));
 
   // We can only invoke non-private imported functions.
   EXPECT_VALID(Dart_Invoke(lib1, NewString("imported"), 0, NULL));
   EXPECT_ERROR(Dart_Invoke(lib1, NewString("_imported"), 0, NULL),
                "did not find top-level function '_imported'");
 }
 
-
 TEST_CASE(InvokeClosure) {
   const char* kScriptChars =
       "class InvokeClosure {\n"
       "  InvokeClosure(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  Function method1(int i) {\n"
       "    f(int j) => j + i + fld1 + fld2 + fld4; \n"
       "    return f;\n"
       "  }\n"
       "  static Function method2(int i) {\n"
       "    n(int j) => true + i + fld4; \n"
@@ skipping 46 matching lines @@
   EXPECT(Dart_IsClosure(retobj));
   EXPECT(!Dart_IsClosure(NewString("abcdef")));
 
   // Now invoke the closure and check the result (should be an exception).
   dart_arguments[0] = Dart_NewInteger(1);
   result = Dart_InvokeClosure(retobj, 1, dart_arguments);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
 }
 
-
 void ExceptionNative(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_ThrowException(NewString("Hello from ExceptionNative!"));
   UNREACHABLE();
 }
 
-
 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\";";
   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));
 
   // 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};
   // Allocate and Setup 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},
@@ skipping 79 matching lines @@
     };
     Dart_NativeArgument_Value arg_values[8];
     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) {
   const Object& obj = Object::Handle(Api::UnwrapHandle(name));
   if (!obj.IsString()) {
     return NULL;
   }
   ASSERT(auto_scope_setup != NULL);
   *auto_scope_setup = true;
   const char* function_name = obj.ToCString();
   ASSERT(function_name != NULL);
   if (!strcmp(function_name, "NativeArgument_Create")) {
     return reinterpret_cast<Dart_NativeFunction>(&NativeArgumentCreate);
   } else if (!strcmp(function_name, "NativeArgument_Access")) {
     return reinterpret_cast<Dart_NativeFunction>(&NativeArgumentAccess);
   }
   return NULL;
 }
 
-
 TEST_CASE(GetNativeArguments) {
   const bool saved_flag = FLAG_support_externalizable_strings;
   FLAG_support_externalizable_strings = true;
 
   const char* kScriptChars =
       "import 'dart:nativewrappers';"
       "class MyObject extends NativeFieldWrapperClass2 {"
       "  static MyObject createObject() native 'NativeArgument_Create';"
       "  int accessFields(int arg1,"
       "                   int arg2,"
@@ skipping 31 matching lines @@
 
   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;
 }
 
-
 static void NativeArgumentCounter(Dart_NativeArguments args) {
   Dart_EnterScope();
   int count = Dart_GetNativeArgumentCount(args);
   Dart_SetReturnValue(args, Dart_NewInteger(count));
   Dart_ExitScope();
 }
 
-
 static Dart_NativeFunction gnac_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>(&NativeArgumentCounter);
 }
 
-
 TEST_CASE(GetNativeArgumentCount) {
   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));
 
   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);
 }
 
-
 TEST_CASE(GetType) {
   const char* kScriptChars =
       "library testlib;\n"
       "class Class {\n"
       "  static var name = 'Class';\n"
       "}\n"
       "\n"
       "class _Class {\n"
       "  static var name = '_Class';\n"
       "}\n";
@@ skipping 28 matching lines @@
   type = Dart_GetType(Api::NewError("myerror"), NewString("Class"), 0, NULL);
   EXPECT(Dart_IsError(type));
   EXPECT_STREQ("myerror", Dart_GetError(type));
 
   // Lookup a type using an error class name.  The error propagates.
   type = Dart_GetType(lib, Api::NewError("myerror"), 0, NULL);
   EXPECT(Dart_IsError(type));
   EXPECT_STREQ("myerror", Dart_GetError(type));
 }
 
-
 TEST_CASE(InstanceOf) {
   const char* kScriptChars =
       "class OtherClass {\n"
       "  static returnNull() { return null; }\n"
       "}\n"
       "class InstanceOfTest {\n"
       "  InstanceOfTest() {}\n"
       "  static InstanceOfTest testMain() {\n"
       "    return new InstanceOfTest();\n"
       "  }\n"
@@ skipping 45 matching lines @@
 
   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));
 }
 
-
 static Dart_Handle library_handler(Dart_LibraryTag tag,
                                    Dart_Handle library,
                                    Dart_Handle url) {
   if (tag == Dart_kCanonicalizeUrl) {
     return url;
   }
   return Api::Success();
 }
 
-
 TEST_CASE(LoadScript) {
   const char* kScriptChars =
       "main() {"
       "  return 12345;"
       "}";
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle source = NewString(kScriptChars);
   Dart_Handle error = Dart_NewApiError("incoming error");
   Dart_Handle result;
 
@@ skipping 53 matching lines @@
 
   // 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));
 }
 
-
 TEST_CASE(RootLibrary) {
   const char* kScriptChars =
       "library testlib;"
       "main() {"
       "  return 12345;"
       "}";
 
   Dart_Handle root_lib = Dart_RootLibrary();
   EXPECT_VALID(root_lib);
   EXPECT(Dart_IsNull(root_lib));
@@ skipping 11 matching lines @@
   EXPECT_VALID(Dart_StringToCString(lib_name, &name_cstr));
   EXPECT_STREQ("testlib", name_cstr);
 
   Dart_Handle lib_uri = Dart_LibraryUrl(root_lib);
   EXPECT_VALID(lib_uri);
   EXPECT(!Dart_IsNull(lib_uri));
   const char* uri_cstr = "";
   EXPECT_VALID(Dart_StringToCString(lib_uri, &uri_cstr));
   EXPECT_STREQ(TestCase::url(), uri_cstr);
 
-
   Dart_Handle core_uri = Dart_NewStringFromCString("dart:core");
   Dart_Handle core_lib = Dart_LookupLibrary(core_uri);
   EXPECT_VALID(core_lib);
   EXPECT(Dart_IsLibrary(core_lib));
 
   Dart_Handle result = Dart_SetRootLibrary(core_uri);  // Not a library.
   EXPECT(Dart_IsError(result));
   root_lib = Dart_RootLibrary();
   lib_uri = Dart_LibraryUrl(root_lib);
   EXPECT_VALID(Dart_StringToCString(lib_uri, &uri_cstr));
   EXPECT_STREQ(TestCase::url(), uri_cstr);  // Root library didn't change.
 
   result = Dart_SetRootLibrary(core_lib);
   EXPECT_VALID(result);
   root_lib = Dart_RootLibrary();
   lib_uri = Dart_LibraryUrl(root_lib);
   EXPECT_VALID(Dart_StringToCString(lib_uri, &uri_cstr));
   EXPECT_STREQ("dart:core", uri_cstr);  // Root library did change.
 
   result = Dart_SetRootLibrary(Dart_Null());
   EXPECT_VALID(result);
   root_lib = Dart_RootLibrary();
   EXPECT(Dart_IsNull(root_lib));  // Root library did change.
 }
 
-
 static int index = 0;
 
-
 static Dart_Handle import_library_handler(Dart_LibraryTag tag,
                                           Dart_Handle library,
                                           Dart_Handle url) {
   if (tag == Dart_kCanonicalizeUrl) {
     return url;
   }
   EXPECT(Dart_IsString(url));
   const char* cstr = NULL;
   EXPECT_VALID(Dart_StringToCString(url, &cstr));
   switch (index) {
@@ skipping 13 matching lines @@
       EXPECT_STREQ("winnerwinner", cstr);
       break;
     default:
       EXPECT(false);
       return Api::NewError("invalid callback");
   }
   index += 1;
   return Api::Success();
 }
 
-
 TEST_CASE(LoadScript_CompileError) {
   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 ')'"));
 }
 
-
 TEST_CASE(LookupLibrary) {
   const char* kScriptChars =
       "import 'library1_dart';"
       "main() {}";
   const char* kLibrary1Chars =
       "library library1_dart;"
       "import 'library2_dart';";
 
   // Create a test library and Load up a test script in it.
   Dart_Handle url = NewString(TestCase::url());
@@ skipping 26 matching lines @@
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("incoming error", Dart_GetError(result));
 
   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;";
   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));
@@ skipping 11 matching lines @@
   EXPECT_STREQ("incoming error", Dart_GetError(result));
 
   result = Dart_LibraryName(lib);
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
   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;";
   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);
@@ skipping 15 matching lines @@
   EXPECT_VALID(result);
   Dart_Handle libFromId = Dart_GetLibraryFromId(libraryId);
   EXPECT(Dart_IsLibrary(libFromId));
   result = Dart_LibraryName(libFromId);
   EXPECT(Dart_IsString(result));
   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;";
   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));
@@ skipping 11 matching lines @@
   EXPECT_STREQ("incoming error", Dart_GetError(result));
 
   result = Dart_LibraryUrl(lib);
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
   const char* cstr = NULL;
   EXPECT_VALID(Dart_StringToCString(result, &cstr));
   EXPECT_STREQ("library1_url", cstr);
 }
 
-
 TEST_CASE(LibraryGetClassNames) {
   const char* kLibraryChars =
       "library library_name;\n"
       "\n"
       "class A {}\n"
       "class B {}\n"
       "abstract class C {}\n"
       "class _A {}\n"
       "class _B {}\n"
       "abstract class _C {}\n"
@@ skipping 18 matching lines @@
   args[0] = list;
   EXPECT_VALID(Dart_Invoke(lib, NewString("sort"), kNumArgs, args));
 
   Dart_Handle list_string = Dart_ToString(list);
   EXPECT_VALID(list_string);
   const char* list_cstr = "";
   EXPECT_VALID(Dart_StringToCString(list_string, &list_cstr));
   EXPECT_STREQ("[A, B, C, _A, _B, _C]", list_cstr);
 }
 
-
 TEST_CASE(GetFunctionNames) {
   const char* kLibraryChars =
       "library library_name;\n"
       "\n"
       "void A() {}\n"
       "get B => 11;\n"
       "set C(x) { }\n"
       "var D;\n"
       "void _A() {}\n"
       "get _B => 11;\n"
@@ skipping 51 matching lines @@
   EXPECT_VALID(Dart_Invoke(lib, NewString("sort"), kNumArgs, args));
 
   // 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;";
   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);
@@ skipping 34 matching lines @@
       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);
 }
 
-
 TEST_CASE(ImportLibraryWithPrefix) {
   const char* kLibrary1Chars =
       "library library1_name;"
       "int bar() => 42;";
   Dart_Handle url1 = NewString("library1_url");
   Dart_Handle source1 = NewString(kLibrary1Chars);
   Dart_Handle lib1 = Dart_LoadLibrary(url1, Dart_Null(), source1, 0, 0);
   EXPECT_VALID(lib1);
   EXPECT(Dart_IsLibrary(lib1));
 
@@ skipping 21 matching lines @@
   // Check that lib1 is available under the prefix in lib2.
   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;";
   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));
@@ skipping 40 matching lines @@
   EXPECT(Dart_IsLibrary(result));
 
   // Duplicate library load fails.
   result = Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ(
       "Dart_LoadLibrary: library 'library1_url' has already been loaded.",
       Dart_GetError(result));
 }
 
-
 TEST_CASE(LoadLibrary_CompileError) {
   const char* kLibrary1Chars =
       "library library1_name;"
       ")";
   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 = ")";
   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);
@@ skipping 69 matching lines @@
   EXPECT_VALID(result);
   EXPECT(Dart_IsLibrary(result));
   EXPECT(Dart_IdentityEquals(lib, result));
 
   // Language errors are detected.
   source = NewString(kBadSourceChars);
   result = Dart_LoadSource(lib, url, Dart_Null(), source, 0, 0);
   EXPECT(Dart_IsError(result));
 }
 
-
 TEST_CASE(LoadSource_LateLoad) {
   const char* kLibrary1Chars =
       "library library1_name;\n"
       "class OldClass {\n"
       "  foo() => 'foo';\n"
       "}\n";
   const char* kSourceChars =
       "part of library1_name;\n"
       "class NewClass extends OldClass{\n"
       "  bar() => 'bar';\n"
@@ skipping 29 matching lines @@
   EXPECT_VALID(type);
   recv = Dart_New(type, Dart_Null(), 0, NULL);
   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* kSourceChars =
       "part of library1_name;\n"
       "external int foo();";
   const char* kPatchChars = "@patch int foo() => 42;";
 
   // Load up a library.
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
@@ skipping 130 matching lines @@
     EXPECT_VALID(result);
     EXPECT(Dart_IsInteger(result));
     int64_t value = 0;
     EXPECT_VALID(Dart_IntegerToInt64(result, &value));
     EXPECT_EQ(200, value);
   }
 
   FLAG_ignore_patch_signature_mismatch = old_flag_value;
 }
 
-
 static void PatchNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_SetReturnValue(args, Dart_Null());
   Dart_ExitScope();
 }
 
-
 static Dart_NativeFunction PatchNativeResolver(Dart_Handle name,
                                                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"
@@ skipping 150 matching lines @@
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(8, value);
 
   // Make sure all source files show up in the patched library.
   const Array& lib_scripts = Array::Handle(lib.LoadedScripts());
   EXPECT_EQ(4, lib_scripts.Length());
 }
 
-
 static void MyNativeFunction1(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_SetReturnValue(args, Dart_NewInteger(654321));
   Dart_ExitScope();
 }
 
-
 static void MyNativeFunction2(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_SetReturnValue(args, Dart_NewInteger(123456));
   Dart_ExitScope();
 }
 
-
 static Dart_NativeFunction MyNativeResolver1(Dart_Handle name,
                                              int arg_count,
                                              bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   return &MyNativeFunction1;
 }
 
-
 static Dart_NativeFunction MyNativeResolver2(Dart_Handle name,
                                              int arg_count,
                                              bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   return &MyNativeFunction2;
 }
 
-
 TEST_CASE(SetNativeResolver) {
   const char* kScriptChars =
       "class Test {"
       "  static foo() native \"SomeNativeFunction\";\n"
       "  static bar() native \"SomeNativeFunction2\";\n"
       "  static baz() native \"SomeNativeFunction3\";\n"
       "}";
   Dart_Handle error = Dart_NewApiError("incoming error");
   Dart_Handle result;
 
@@ skipping 60 matching lines @@
 
   // A NULL resolver is okay, but resolution will fail.
   result = Dart_SetNativeResolver(lib, NULL, NULL);
   EXPECT_VALID(result);
 
   EXPECT_ERROR(Dart_Invoke(type, NewString("baz"), 0, NULL),
                "native function 'SomeNativeFunction3' (0 arguments) "
                "cannot be found");
 }
 
-
 // Test that an imported name does not clash with the same name defined
 // in the importing library.
 TEST_CASE(ImportLibrary2) {
   const char* kScriptChars =
       "import 'library1_dart';\n"
       "var foo;\n"
       "main() { foo = 0; }\n";
   const char* kLibrary1Chars =
       "library library1_dart;\n"
       "import 'library2_dart';\n"
@@ skipping 17 matching lines @@
   url = NewString("library2_dart");
   source = NewString(kLibrary2Chars);
   Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
 
   Dart_FinalizeLoading(false);
 
   result = Dart_Invoke(result, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
-
 // Test that if the same name is imported from two libraries, it is
 // an error if that name is referenced.
 TEST_CASE(ImportLibrary3) {
   const char* kScriptChars =
       "import 'library2_dart';\n"
       "import 'library1_dart';\n"
       "var foo_top = 10;  // foo has dup def. So should be an error.\n"
       "main() { foo = 0; }\n";
   const char* kLibrary1Chars =
       "library library1_dart;\n"
@@ skipping 19 matching lines @@
   source = NewString(kLibrary1Chars);
   Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
 
   result = Dart_Invoke(result, NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT_SUBSTRING("NoSuchMethodError", Dart_GetError(result));
 }
 
-
 // Test that if the same name is imported from two libraries, it is
 // not an error if that name is not used.
 TEST_CASE(ImportLibrary4) {
   const char* kScriptChars =
       "import 'library2_dart';\n"
       "import 'library1_dart';\n"
       "main() {  }\n";
   const char* kLibrary1Chars =
       "library library1_dart;\n"
       "var foo;";
@@ skipping 16 matching lines @@
 
   url = NewString("library1_dart");
   source = NewString(kLibrary1Chars);
   Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   Dart_FinalizeLoading(false);
 
   result = Dart_Invoke(result, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
-
 TEST_CASE(ImportLibrary5) {
   const char* kScriptChars =
       "import 'lib.dart';\n"
       "abstract class Y {\n"
       "  void set handler(void callback(List<int> x));\n"
       "}\n"
       "void main() {}\n";
   const char* kLibraryChars =
       "library lib.dart;\n"
       "abstract class X {\n"
@@ skipping 10 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) {
   // 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);
 }
 
-
 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);
 }
 
-
 TEST_CASE(IllegalNewSendPort) {
   Dart_Handle error = Dart_NewSendPort(ILLEGAL_PORT);
   EXPECT(Dart_IsError(error));
   EXPECT(Dart_IsApiError(error));
 }
 
-
 TEST_CASE(IllegalPost) {
   Dart_Handle message = Dart_True();
   bool success = Dart_Post(ILLEGAL_PORT, message);
   EXPECT(!success);
 }
 
-
 VM_UNIT_TEST_CASE(NewNativePort) {
   // Create a port with a bogus handler.
   Dart_Port error_port = Dart_NewNativePort("Foo", NULL, true);
   EXPECT_EQ(ILLEGAL_PORT, error_port);
 
   // Create the port w/o a current isolate, just to make sure that works.
   Dart_Port port_id1 =
       Dart_NewNativePort("Port123", NewNativePort_send123, true);
 
   TestIsolateScope __test_isolate__;
@@ skipping 39 matching lines @@
   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) {
   // 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);
 }
 
-
 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);
 }
 
-
 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"
       "  receivePort.handler = (message) {\n"
       "    receivePort.close();\n"
       "    throw new Exception(message);\n"
@@ skipping 31 matching lines @@
   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) {
   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);
   } else {
     EXPECT_EQ(message->type, Dart_CObject_kNull);
   }
 }
 
-
 TEST_CASE(NativePortReceiveNull) {
   const char* kScriptChars =
       "import 'dart:isolate';\n"
       "void callPort(SendPort port) {\n"
       "  var receivePort = new RawReceivePort();\n"
       "  var replyPort = receivePort.sendPort;\n"
       "  port.send(null);\n"
       "  port.send([replyPort]);\n"
       "  receivePort.handler = (message) {\n"
       "    receivePort.close();\n"
@@ skipping 17 matching lines @@
   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) {
   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);
   } 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"
       "void callPort(SendPort port) {\n"
       "  var receivePort = new RawReceivePort();\n"
       "  var replyPort = receivePort.sendPort;\n"
       "  port.send(321);\n"
       "  port.send([replyPort]);\n"
       "  receivePort.handler = (message) {\n"
       "    receivePort.close();\n"
@@ skipping 17 matching lines @@
   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));
 }
 
-
 static Dart_Isolate RunLoopTestCallback(const char* script_name,
                                         const char* main,
                                         const char* package_root,
                                         const char* package_config,
                                         Dart_IsolateFlags* flags,
                                         void* data,
                                         char** error) {
   const char* kScriptChars =
       "import 'builtin';\n"
       "import 'dart:isolate';\n"
@@ skipping 25 matching lines @@
   EXPECT_VALID(lib);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
   Dart_ExitScope();
   Dart_ExitIsolate();
   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_EnterIsolate(isolate);
   Dart_EnterScope();
   Dart_Handle lib = Dart_LookupLibrary(NewString(TestCase::url()));
@@ skipping 10 matching lines @@
   } else {
     EXPECT_VALID(result);
   }
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
   Isolate::SetCreateCallback(saved);
 }
 
-
 VM_UNIT_TEST_CASE(RunLoop_Success) {
   RunLoopTest(false);
 }
 
-
 VM_UNIT_TEST_CASE(RunLoop_Exception) {
   RunLoopTest(true);
 }
 
-
 // Utility functions and variables for test case IsolateInterrupt starts here.
 static Monitor* sync = NULL;
 static Dart_Isolate shared_isolate = NULL;
 static bool main_entered = false;
 
-
 void MarkMainEntered(Dart_NativeArguments args) {
   Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
   // Indicate that main has been entered.
   {
     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) {
   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"
@@ skipping 33 matching lines @@
   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;
 }
 
 VM_UNIT_TEST_CASE(IsolateShutdown) {
   Dart_IsolateShutdownCallback saved = Isolate::ShutdownCallback();
   Isolate::SetShutdownCallback(IsolateShutdownTestCallback);
 
   saved_callback_data = NULL;
@@ skipping 71 matching lines @@
     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("main"), 0, NULL);
     EXPECT_VALID(result);
     Dart_ExitScope();
   }
 
-
   // The shutdown callback has not been called.
   EXPECT_EQ(0, add_result);
 
   EXPECT(isolate != NULL);
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
   // The shutdown callback has been called and ran Dart code.
   EXPECT_EQ(99, add_result);
@@ skipping 10 matching lines @@
 static void NativeFoo1(Dart_NativeArguments args) {
   Dart_EnterScope();
   intptr_t i = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(1, i);
   Dart_Handle arg = Dart_GetNativeArgument(args, 0);
   EXPECT_VALID(arg);
   Dart_SetReturnValue(args, Dart_NewInteger(1));
   Dart_ExitScope();
 }
 
-
 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);
   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();
 }
 
-
 static void NativeFoo3(Dart_NativeArguments args) {
   Dart_EnterScope();
   intptr_t i = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(3, i);
   Dart_Handle arg1 = Dart_GetNativeArgument(args, 1);
   Dart_Handle arg2 = Dart_GetNativeArgument(args, 2);
   Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg1) + GetValue(arg2)));
   Dart_ExitScope();
 }
 
-
 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_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));
   if (!obj.IsString()) {
     return NULL;
   }
   const char* function_name = obj.ToCString();
   const char* kNativeFoo1 = "NativeFoo1";
   const char* kNativeFoo2 = "NativeFoo2";
   const char* kNativeFoo3 = "NativeFoo3";
   const char* kNativeFoo4 = "NativeFoo4";
   if (!strncmp(function_name, kNativeFoo1, strlen(kNativeFoo1))) {
     return &NativeFoo1;
   } else if (!strncmp(function_name, kNativeFoo2, strlen(kNativeFoo2))) {
     return &NativeFoo2;
   } else if (!strncmp(function_name, kNativeFoo3, strlen(kNativeFoo3))) {
     return &NativeFoo3;
   } else if (!strncmp(function_name, kNativeFoo4, strlen(kNativeFoo4))) {
     return &NativeFoo4;
   } else {
     UNREACHABLE();
     return NULL;
   }
 }
 
-
 TEST_CASE(NativeFunctionClosure) {
   const char* kScriptChars =
       "class Test {"
       "  int foo1() native \"NativeFoo1\";\n"
       "  int foo2(int i) native \"NativeFoo2\";\n"
       "  int foo3([int k = 10000, int l = 1]) native \"NativeFoo3\";\n"
       "  int foo4(int i,"
       "           [int j = 10, int k = 1]) native \"NativeFoo4\";\n"
       "  int bar1() { var func = foo1; return func(); }\n"
       "  int bar2(int i) { var func = foo2; return func(i); }\n"
@@ skipping 55 matching lines @@
   EXPECT_VALID(result);
 
   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(0, value);
 }
 
-
 static void StaticNativeFoo1(Dart_NativeArguments args) {
   Dart_EnterScope();
   intptr_t i = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(0, i);
   Dart_SetReturnValue(args, Dart_NewInteger(0));
   Dart_ExitScope();
 }
 
-
 static void StaticNativeFoo2(Dart_NativeArguments args) {
   Dart_EnterScope();
   intptr_t i = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(1, i);
   Dart_Handle arg = Dart_GetNativeArgument(args, 0);
   Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg)));
   Dart_ExitScope();
 }
 
-
 static void StaticNativeFoo3(Dart_NativeArguments args) {
   Dart_EnterScope();
   intptr_t i = Dart_GetNativeArgumentCount(args);
   EXPECT_EQ(2, i);
   Dart_Handle arg1 = Dart_GetNativeArgument(args, 0);
   Dart_Handle arg2 = Dart_GetNativeArgument(args, 1);
   Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg1) + GetValue(arg2)));
   Dart_ExitScope();
 }
 
-
 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_ExitScope();
 }
 
-
 static Dart_NativeFunction MyStaticNativeClosureResolver(
     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";
   const char* kNativeFoo4 = "StaticNativeFoo4";
   if (!strncmp(function_name, kNativeFoo1, strlen(kNativeFoo1))) {
     return &StaticNativeFoo1;
   } else if (!strncmp(function_name, kNativeFoo2, strlen(kNativeFoo2))) {
     return &StaticNativeFoo2;
   } else if (!strncmp(function_name, kNativeFoo3, strlen(kNativeFoo3))) {
     return &StaticNativeFoo3;
   } else if (!strncmp(function_name, kNativeFoo4, strlen(kNativeFoo4))) {
     return &StaticNativeFoo4;
   } else {
     UNREACHABLE();
     return NULL;
   }
 }
 
-
 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"
       "  static int foo4(int i, [int j = 10, int k = 1])"
       " native \"StaticNativeFoo4\";\n"
       "  int bar1() { var func = foo1; return func(); }\n"
@@ skipping 56 matching lines @@
   EXPECT_VALID(result);
 
   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(0, value);
 }
 
-
 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),
                "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),
                "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_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");
 }
 
-
 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);
 
   str = Dart_NewStringFromUTF16(NULL, 0);
   EXPECT_VALID(str);
   EXPECT(Dart_IsString(str));
   len = -1;
   EXPECT_VALID(Dart_StringLength(str, &len));
   EXPECT_EQ(0, len);
 
   str = Dart_NewStringFromUTF32(NULL, 0);
   EXPECT_VALID(str);
   EXPECT(Dart_IsString(str));
   len = -1;
   EXPECT_VALID(Dart_StringLength(str, &len));
   EXPECT_EQ(0, len);
 }
 
-
 // Try to allocate a peer with a handles to objects of prohibited
 // subtypes.
 TEST_CASE(InvalidGetSetPeer) {
   void* out = &out;
   EXPECT(Dart_IsError(Dart_GetPeer(Dart_Null(), &out)));
   EXPECT(out == &out);
   EXPECT(Dart_IsError(Dart_SetPeer(Dart_Null(), &out)));
   out = &out;
   EXPECT(Dart_IsError(Dart_GetPeer(Dart_True(), &out)));
   EXPECT(out == &out);
@@ skipping 11 matching lines @@
   Dart_Handle big = Dart_NewIntegerFromHexCString("0x10000000000000000");
   EXPECT(Dart_IsError(Dart_GetPeer(big, &out)));
   EXPECT(out == &out);
   EXPECT(Dart_IsError(Dart_SetPeer(big, &out)));
   Dart_Handle dbl = Dart_NewDouble(0.0);
   EXPECT(Dart_IsError(Dart_GetPeer(dbl, &out)));
   EXPECT(out == &out);
   EXPECT(Dart_IsError(Dart_SetPeer(dbl, &out)));
 }
 
-
 // Allocates an object in new space and assigns it a peer.  Removes
 // the peer and checks that the count of peer objects is decremented
 // by one.
 TEST_CASE(OneNewSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_Handle str = NewString("a string");
   EXPECT_VALID(str);
   EXPECT(Dart_IsString(str));
   EXPECT_EQ(0, isolate->heap()->PeerCount());
   void* out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == NULL);
   int peer = 1234;
   EXPECT_VALID(Dart_SetPeer(str, &peer));
   EXPECT_EQ(1, isolate->heap()->PeerCount());
   out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_VALID(Dart_SetPeer(str, NULL));
   out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == NULL);
   EXPECT_EQ(0, isolate->heap()->PeerCount());
 }
 
-
 // Allocates an object in new space and assigns it a peer.  Allows the
 // peer referent to be garbage collected and checks that the count of
 // peer objects is decremented by one.
 TEST_CASE(CollectOneNewSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
     CHECK_API_SCOPE(thread);
     HANDLESCOPE(thread);
     Dart_Handle str = NewString("a string");
@@ skipping 19 matching lines @@
     EXPECT(out == reinterpret_cast<void*>(&peer));
   }
   Dart_ExitScope();
   {
     TransitionNativeToVM transition(thread);
     isolate->heap()->CollectGarbage(Heap::kNew);
     EXPECT_EQ(0, isolate->heap()->PeerCount());
   }
 }
 
-
 // Allocates two objects in new space and assigns them peers.  Removes
 // the peers and checks that the count of peer objects is decremented
 // by two.
 TEST_CASE(TwoNewSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_Handle s1 = NewString("s1");
   EXPECT_VALID(s1);
   EXPECT(Dart_IsString(s1));
   void* o1 = &o1;
   EXPECT_VALID(Dart_GetPeer(s1, &o1));
@@ skipping 19 matching lines @@
   EXPECT_VALID(Dart_SetPeer(s1, NULL));
   EXPECT_EQ(1, isolate->heap()->PeerCount());
   EXPECT(Dart_GetPeer(s1, &o1));
   EXPECT(o1 == NULL);
   EXPECT_VALID(Dart_SetPeer(s2, NULL));
   EXPECT_EQ(0, isolate->heap()->PeerCount());
   EXPECT(Dart_GetPeer(s2, &o2));
   EXPECT(o2 == NULL);
 }
 
-
 // Allocates two objects in new space and assigns them a peer.  Allow
 // the peer referents to be garbage collected and check that the count
 // of peer objects is decremented by two.
 TEST_CASE(CollectTwoNewSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
     CHECK_API_SCOPE(thread);
     HANDLESCOPE(thread);
     Dart_Handle s1 = NewString("s1");
@@ skipping 22 matching lines @@
     EXPECT(o2 == reinterpret_cast<void*>(&p2));
   }
   Dart_ExitScope();
   {
     TransitionNativeToVM transition(thread);
     isolate->heap()->CollectGarbage(Heap::kNew);
     EXPECT_EQ(0, isolate->heap()->PeerCount());
   }
 }
 
-
 // Allocates several objects in new space.  Performs successive
 // garbage collections and checks that the peer count is stable.
 TEST_CASE(CopyNewSpacePeers) {
   const int kPeerCount = 10;
   Isolate* isolate = Isolate::Current();
   Dart_Handle s[kPeerCount];
   for (int i = 0; i < kPeerCount; ++i) {
     s[i] = NewString("a string");
     EXPECT_VALID(s[i]);
     EXPECT(Dart_IsString(s[i]));
@@ skipping 13 matching lines @@
   EXPECT_EQ(kPeerCount, isolate->heap()->PeerCount());
   {
     TransitionNativeToVM transition(thread);
     isolate->heap()->CollectGarbage(Heap::kNew);
     EXPECT_EQ(kPeerCount, isolate->heap()->PeerCount());
     isolate->heap()->CollectGarbage(Heap::kNew);
     EXPECT_EQ(kPeerCount, isolate->heap()->PeerCount());
   }
 }
 
-
 // Allocates an object in new space and assigns it a peer.  Promotes
 // the peer to old space.  Removes the peer and check that the count
 // of peer objects is decremented by one.
 TEST_CASE(OnePromotedPeer) {
   Isolate* isolate = Isolate::Current();
   Dart_Handle str = NewString("a string");
   EXPECT_VALID(str);
   EXPECT(Dart_IsString(str));
   EXPECT_EQ(0, isolate->heap()->PeerCount());
   void* out = &out;
@@ skipping 20 matching lines @@
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_EQ(1, isolate->heap()->PeerCount());
   EXPECT_VALID(Dart_SetPeer(str, NULL));
   out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == NULL);
   EXPECT_EQ(0, isolate->heap()->PeerCount());
 }
 
-
 // Allocates an object in old space and assigns it a peer.  Removes
 // the peer and checks that the count of peer objects is decremented
 // by one.
 TEST_CASE(OneOldSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_Handle str = Api::NewHandle(thread, String::New("str", Heap::kOld));
   EXPECT_VALID(str);
   EXPECT(Dart_IsString(str));
   EXPECT_EQ(0, isolate->heap()->PeerCount());
   void* out = &out;
@@ skipping 12 matching lines @@
   }
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_VALID(Dart_SetPeer(str, NULL));
   out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == NULL);
   EXPECT_EQ(0, isolate->heap()->PeerCount());
 }
 
-
 // Allocates an object in old space and assigns it a peer.  Allow the
 // peer referent to be garbage collected and check that the count of
 // peer objects is decremented by one.
 TEST_CASE(CollectOneOldSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
     Thread* T = Thread::Current();
     CHECK_API_SCOPE(T);
     HANDLESCOPE(T);
@@ skipping 19 matching lines @@
     EXPECT(out == reinterpret_cast<void*>(&peer));
   }
   Dart_ExitScope();
   {
     TransitionNativeToVM transition(thread);
     isolate->heap()->CollectGarbage(Heap::kOld);
     EXPECT_EQ(0, isolate->heap()->PeerCount());
   }
 }
 
-
 // Allocates two objects in old space and assigns them peers.  Removes
 // the peers and checks that the count of peer objects is decremented
 // by two.
 TEST_CASE(TwoOldSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_Handle s1 = Api::NewHandle(thread, String::New("s1", Heap::kOld));
   EXPECT_VALID(s1);
   EXPECT(Dart_IsString(s1));
   EXPECT_EQ(0, isolate->heap()->PeerCount());
   void* o1 = &o1;
@@ skipping 23 matching lines @@
   o1 = &o1;
   EXPECT(Dart_GetPeer(s1, &o1));
   EXPECT(o1 == NULL);
   EXPECT_VALID(Dart_SetPeer(s2, NULL));
   EXPECT_EQ(0, isolate->heap()->PeerCount());
   o2 = &o2;
   EXPECT_VALID(Dart_GetPeer(s2, &o2));
   EXPECT(o2 == NULL);
 }
 
-
 // Allocates two objects in old space and assigns them a peer.  Allows
 // the peer referents to be garbage collected and checks that the
 // count of peer objects is decremented by two.
 TEST_CASE(CollectTwoOldSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
     Thread* T = Thread::Current();
     CHECK_API_SCOPE(T);
     HANDLESCOPE(T);
@@ skipping 25 matching lines @@
     EXPECT(o2 == reinterpret_cast<void*>(&p2));
   }
   Dart_ExitScope();
   {
     TransitionNativeToVM transition(thread);
     isolate->heap()->CollectGarbage(Heap::kOld);
     EXPECT_EQ(0, isolate->heap()->PeerCount());
   }
 }
 
-
 // Test API call to make strings external.
 static void MakeExternalCback(void* peer) {
   *static_cast<int*>(peer) *= 2;
 }
 
-
 TEST_CASE(MakeExternalString) {
   const bool saved_flag = FLAG_support_externalizable_strings;
   FLAG_support_externalizable_strings = true;
 
   static int peer8 = 40;
   static int peer16 = 41;
   static int canonical_str_peer = 42;
   intptr_t length = 0;
   intptr_t expected_length = 0;
   {
@@ skipping 165 matching lines @@
     Isolate::Current()->heap()->CollectAllGarbage();
     GCTestHelper::WaitForGCTasks();
   }
   EXPECT_EQ(80, peer8);
   EXPECT_EQ(82, peer16);
   EXPECT_EQ(42, canonical_str_peer);  // "*" Symbol is not removed on GC.
 
   FLAG_support_externalizable_strings = saved_flag;
 }
 
-
 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);
   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);
 
   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;
 }
 
-
 TEST_CASE(LazyLoadDeoptimizes) {
   const char* kLoadFirst =
       "library L;\n"
       "start(a) {\n"
       "  var obj = (a == 1) ? createB() : new A();\n"
       "  for (int i = 0; i < 4000; i++) {\n"
       "    var res = obj.foo();\n"
       "    if (a == 1) { if (res != 1) throw 'Error'; }\n"
       "    else if (res != 2) throw 'Error'; \n"
       "  }\n"
@@ skipping 22 matching lines @@
   Dart_Handle url = NewString(TestCase::url());
   Dart_LoadSource(TestCase::lib(), url, Dart_Null(), source, 0, 0);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
 
   dart_args[0] = Dart_NewInteger(1);
   result = Dart_Invoke(lib1, NewString("start"), 1, dart_args);
   EXPECT_VALID(result);
 }
 
-
 // Test external strings and optimized code.
 static void ExternalStringDeoptimize_Finalize(void* peer) {
   delete[] reinterpret_cast<char*>(peer);
 }
 
-
 static void A_change_str_native(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_Handle str = Dart_GetNativeArgument(args, 0);
   EXPECT(Dart_IsString(str));
   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);
   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) {
   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;
   FLAG_support_externalizable_strings = true;
 
   const char* kScriptChars =
       "main() {\n"
       "  var a = new A('hello');\n"
       "  var res = runOne(a);\n"
@@ skipping 21 matching lines @@
       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) {
   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"
       "sum_chars(String s, bool b) {\n"
@@ skipping 15 matching lines @@
       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) {
   const bool saved_flag = FLAG_support_externalizable_strings;
   FLAG_support_externalizable_strings = true;
 
   const char* kScriptChars =
       "const strA = 'AAAA';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "compare(a, b, [i = 0]) {\n"
@@ skipping 16 matching lines @@
   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"
@@ skipping 10 matching lines @@
   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(ExternalStringGuardFieldDeoptimize) {
   const bool saved_flag = FLAG_support_externalizable_strings;
   FLAG_support_externalizable_strings = true;
 
   const char* kScriptChars =
       "const strA = 'AAAA';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "class G { var f = 'A'; }\n"
@@ skipping 21 matching lines @@
   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(ExternalStringStaticFieldDeoptimize) {
   const bool saved_flag = FLAG_support_externalizable_strings;
   FLAG_support_externalizable_strings = true;
 
   const char* kScriptChars =
       "const strA = 'AAAA';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "class G { static final f = strA; }\n"
@@ skipping 16 matching lines @@
   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);
   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);
   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);
 
   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);
   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"
@@ skipping 57 matching lines @@
     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);
     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);
   // 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);
   // 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);
   // 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);
 
   // 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());
 }
 
-
 struct AppendData {
   uint8_t* buffer;
   intptr_t buffer_length;
 };
 
-
 static void AppendStreamConsumer(Dart_StreamConsumer_State state,
                                  const char* stream_name,
                                  const uint8_t* buffer,
                                  intptr_t buffer_length,
                                  void* user_data) {
   if (state == Dart_StreamConsumer_kFinish) {
     return;
   }
   AppendData* data = reinterpret_cast<AppendData*>(user_data);
   if (state == Dart_StreamConsumer_kStart) {
     // Initialize append data.
     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);
   // Update length.
   data->buffer_length += buffer_length;
 }
 
-
 TEST_CASE(Timeline_Dart_TimelineGetTrace) {
   const char* kScriptChars =
       "foo() => 'a';\n"
       "main() => foo();\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   const char* buffer = NULL;
   intptr_t buffer_length = 0;
   bool success = false;
@@ skipping 23 matching lines @@
 
   // 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";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
@@ skipping 27 matching lines @@
   EXPECT(buffer[buffer_length - 2] == '}');
 
   // Heartbeat test.
   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";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
@@ skipping 72 matching lines @@
 
   // 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_values[] = {"value0"};
 
-
 TEST_CASE(Timeline_Dart_GlobalTimelineGetTrace) {
   const char* kScriptChars =
       "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;
@@ skipping 97 matching lines @@
   EXPECT_SUBSTRING("\"function\":\"::_main\"", buffer);
 
   // Heartbeat test for new events.
   EXPECT_SUBSTRING("\"name\":\"TestVMDuration2\"", buffer);
   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) {}
 
   ~GlobalTimelineThreadData() {
     delete monitor_;
     monitor_ = NULL;
     free(data_->buffer);
     data_->buffer = NULL;
     data_->buffer_length = 0;
     delete data_;
     data_ = NULL;
   }
 
   Monitor* monitor() const { return monitor_; }
   bool running() const { return running_; }
   AppendData* data() const { return data_; }
   uint8_t* buffer() const { return data_->buffer; }
   intptr_t buffer_length() const { return data_->buffer_length; }
 
   void set_running(bool running) { running_ = running; }
 
  private:
   Monitor* monitor_;
   AppendData* data_;
   bool running_;
 };
 
-
 static void GlobalTimelineThread(uword parameter) {
   GlobalTimelineThreadData* data =
       reinterpret_cast<GlobalTimelineThreadData*>(parameter);
   Thread* T = Thread::Current();
   // When there is no current Thread, then Zone allocation will fail.
   EXPECT(T == NULL);
   {
     MonitorLocker ml(data->monitor());
     bool success =
         Dart_GlobalTimelineGetTrace(AppendStreamConsumer, data->data());
     EXPECT(success);
     data->set_running(false);
     ml.Notify();
   }
 }
 
-
 // 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";
 
@@ skipping 92 matching lines @@
 static bool stop_called = false;
 
 static void StartRecording() {
   start_called = true;
 }
 
 static void StopRecording() {
   stop_called = true;
 }
 
-
 TEST_CASE(Timeline_Dart_EmbedderTimelineStartStopRecording) {
   Dart_SetEmbedderTimelineCallbacks(StartRecording, StopRecording);
 
   EXPECT(!start_called);
   EXPECT(!stop_called);
   Timeline::SetStreamEmbedderEnabled(true);
   EXPECT(start_called);
   EXPECT(!stop_called);
 
   start_called = false;
   stop_called = false;
   EXPECT(!start_called);
   EXPECT(!stop_called);
   Timeline::SetStreamEmbedderEnabled(false);
   EXPECT(!start_called);
   EXPECT(stop_called);
 }
 
-
 TEST_CASE(Dart_LoadLibraryPatch_1) {
   const char* kScriptChars1 =
       "class A {\n"
       "  int foo() { return 10; }\n"
       "  external int zoo();\n"
       "  external static int moo();\n"
       "}\n"
       "main() { new A().foo(); }\n"
       "foozoo() { new A().zoo(); }\n"
       "foomoo() { A.moo(); }\n";
@@ skipping 12 matching lines @@
   result = Dart_LibraryLoadPatch(lib, url, source);
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
   result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT_VALID(result);
   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 =
@@ skipping 10 matching lines @@
   // 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);
   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 =
@@ skipping 10 matching lines @@
   // 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);
   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 =
@@ skipping 15 matching lines @@
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
   result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT(Dart_IsError(result));
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart