clang-format runtime/vm

runtime/vm/debugger_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 "include/dart_mirrors_api.h"
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
 #include "vm/dart_api_impl.h"
 #include "vm/lockers.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, trace_shutdown);
 
 #ifndef PRODUCT
 
 static bool breakpoint_hit = false;
-static int  breakpoint_hit_counter = 0;
+static int breakpoint_hit_counter = 0;
 static Dart_Handle script_lib = NULL;
 
 static const bool verbose = true;
 
 static void LoadScript(const char* source) {
   script_lib = TestCase::LoadTestScript(source, NULL);
   EXPECT_VALID(script_lib);
 }
 
 
 static void SetBreakpointAtEntry(const char* cname, const char* fname) {
   ASSERT(script_lib != NULL);
   ASSERT(!Dart_IsError(script_lib));
   ASSERT(Dart_IsLibrary(script_lib));
-  Dart_Handle res = Dart_SetBreakpointAtEntry(script_lib,
-                        NewString(cname),
-                        NewString(fname));
+  Dart_Handle res =
+      Dart_SetBreakpointAtEntry(script_lib, NewString(cname), NewString(fname));
   EXPECT(Dart_IsInteger(res));
 }
 
 
 static void DisableDebuggabilityOfDartColonLibraries() {
   const char* dart_colon = "dart:";
   const intptr_t dart_colon_length = strlen(dart_colon);
   // Disable debuggability of all dart: libraries.
   Dart_Handle library_ids = Dart_GetLibraryIds();
   intptr_t library_ids_length;
@@ skipping 50 matching lines @@
 
 static char const* BreakpointInfo(Dart_StackTrace trace) {
   static char info_str[128];
   Dart_ActivationFrame frame;
   Dart_Handle res = Dart_GetActivationFrame(trace, 0, &frame);
   EXPECT_TRUE(res);
   Dart_Handle func_name;
   Dart_Handle url;
   intptr_t line_number = 0;
   intptr_t library_id = 0;
-  res = Dart_ActivationFrameInfo(
-            frame, &func_name, &url, &line_number, &library_id);
+  res = Dart_ActivationFrameInfo(frame, &func_name, &url, &line_number,
+                                 &library_id);
   EXPECT_TRUE(res);
   OS::SNPrint(info_str, sizeof(info_str), "function %s (%s:%" Pd ")",
               ToCString(func_name), ToCString(url), line_number);
   return info_str;
 }
 
 
 static void PrintValue(Dart_Handle value, bool expand);
 
 
@@ skipping 263 matching lines @@
   Dart_Handle func_name;
 
   char* buffer = stack_buffer;
   int buffer_size = stack_buffer_size;
 
   intptr_t trace_len;
   EXPECT_VALID(Dart_StackTraceLength(trace, &trace_len));
 
   for (intptr_t frame_index = 0; frame_index < trace_len; frame_index++) {
     EXPECT_VALID(Dart_GetActivationFrame(trace, frame_index, &frame));
-    EXPECT_VALID(Dart_ActivationFrameInfo(frame, &func_name,
-                                          NULL, NULL, NULL));
-    int pos = OS::SNPrint(buffer, buffer_size, "[%" Pd "] %s { ",
-                          frame_index, ToCString(func_name));
+    EXPECT_VALID(Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL, NULL));
+    int pos = OS::SNPrint(buffer, buffer_size, "[%" Pd "] %s { ", frame_index,
+                          ToCString(func_name));
     buffer += pos;
     buffer_size -= pos;
 
     Dart_Handle locals = Dart_GetLocalVariables(frame);
     EXPECT_VALID(locals);
     intptr_t list_length = 0;
     EXPECT_VALID(Dart_ListLength(locals, &list_length));
 
     for (intptr_t i = 0; i + 1 < list_length; i += 2) {
       Dart_Handle name = Dart_ListGetAt(locals, i);
       EXPECT_VALID(name);
       EXPECT(Dart_IsString(name));
 
       Dart_Handle value = Dart_ListGetAt(locals, i + 1);
       EXPECT_VALID(value);
       Dart_Handle value_str = Dart_ToString(value);
       EXPECT_VALID(value_str);
 
       const char* name_cstr = NULL;
       const char* value_cstr = NULL;
       EXPECT_VALID(Dart_StringToCString(name, &name_cstr));
       EXPECT_VALID(Dart_StringToCString(value_str, &value_cstr));
-      pos = OS::SNPrint(buffer, buffer_size, "%s = %s ",
-                        name_cstr, value_cstr);
+      pos = OS::SNPrint(buffer, buffer_size, "%s = %s ", name_cstr, value_cstr);
       buffer += pos;
       buffer_size -= pos;
     }
     pos = OS::SNPrint(buffer, buffer_size, "}\n");
     buffer += pos;
     buffer_size -= pos;
   }
 }
 
 
@@ skipping 56 matching lines @@
   // Set up the breakpoint.
   Dart_SetPausedEventHandler(InspectOptimizedStack_Breakpoint);
   SetBreakpointAtEntry("", "breakpointNow");
 
   // Run the code and inspect the stack.
   stack_buffer[0] = '\0';
   dart_args[0] = Dart_True();
   dart_args[1] = Dart_NewInteger(kLowThreshold);
   EXPECT_VALID(Dart_Invoke(script_lib, NewString("test"), 2, dart_args));
   if (optimize) {
-    EXPECT_STREQ("[0] breakpointNow { }\n"
-                 "[1] helper { a = 5 b = 99 stop = <optimized out> }\n"
-                 "[2] anotherMiddleMan { one = <optimized out> "
-                 "two = <optimized out> stop = <optimized out> }\n"
-                 "[3] middleMan { x = 5 limit = 100 stop = true value = 24255"
-                 " i = 99 }\n"
-                 "[4] test { stop = true limit = 100 }\n",
-                 stack_buffer);
+    EXPECT_STREQ(
+        "[0] breakpointNow { }\n"
+        "[1] helper { a = 5 b = 99 stop = <optimized out> }\n"
+        "[2] anotherMiddleMan { one = <optimized out> "
+        "two = <optimized out> stop = <optimized out> }\n"
+        "[3] middleMan { x = 5 limit = 100 stop = true value = 24255"
+        " i = 99 }\n"
+        "[4] test { stop = true limit = 100 }\n",
+        stack_buffer);
   } else {
-    EXPECT_STREQ("[0] breakpointNow { }\n"
-                 "[1] helper { a = 5 b = 99 stop = true }\n"
-                 "[2] anotherMiddleMan { one = 5 two = 99 stop = true }\n"
-                 "[3] middleMan { x = 5 limit = 100 stop = true value = 24255"
-                 " i = 99 }\n"
-                 "[4] test { stop = true limit = 100 }\n",
-                 stack_buffer);
+    EXPECT_STREQ(
+        "[0] breakpointNow { }\n"
+        "[1] helper { a = 5 b = 99 stop = true }\n"
+        "[2] anotherMiddleMan { one = 5 two = 99 stop = true }\n"
+        "[3] middleMan { x = 5 limit = 100 stop = true value = 24255"
+        " i = 99 }\n"
+        "[4] test { stop = true limit = 100 }\n",
+        stack_buffer);
   }
 
   FLAG_optimization_counter_threshold = saved_threshold;
   FLAG_use_osr = saved_osr;
 }
 
 
 TEST_CASE(Debug_InspectStack_NotOptimized) {
   InspectStackTest(false);
 }
@@ skipping 58 matching lines @@
   // Set up the breakpoint.
   Dart_SetPausedEventHandler(InspectOptimizedStack_Breakpoint);
   SetBreakpointAtEntry("", "breakpointNow");
 
   // Run the code and inspect the stack.
   stack_buffer[0] = '\0';
   dart_args[0] = Dart_True();
   dart_args[1] = Dart_NewInteger(kLowThreshold);
   EXPECT_VALID(Dart_Invoke(script_lib, NewString("test"), 2, dart_args));
   if (optimize) {
-    EXPECT_STREQ("[0] breakpointNow { }\n"
-                 "[1] helper { a = 50 b = 99 stop = <optimized out> }\n"
-                 "[2] <anonymous closure> { x = 5 i = 99 stop = true"
-                 " value = <optimized out> }\n"
-                 "[3] anotherMiddleMan { func = <optimized out> }\n"
-                 "[4] middleMan { x = 5 limit = 100 stop = true"
-                 " value = 242550 i = 99 }\n"
-                 "[5] test { stop = true limit = 100 }\n",
-                 stack_buffer);
+    EXPECT_STREQ(
+        "[0] breakpointNow { }\n"
+        "[1] helper { a = 50 b = 99 stop = <optimized out> }\n"
+        "[2] <anonymous closure> { x = 5 i = 99 stop = true"
+        " value = <optimized out> }\n"
+        "[3] anotherMiddleMan { func = <optimized out> }\n"
+        "[4] middleMan { x = 5 limit = 100 stop = true"
+        " value = 242550 i = 99 }\n"
+        "[5] test { stop = true limit = 100 }\n",
+        stack_buffer);
   } else {
-    EXPECT_STREQ("[0] breakpointNow { }\n"
-                 "[1] helper { a = 50 b = 99 stop = true }\n"
-                 "[2] <anonymous closure> { x = 5 i = 99 stop = true"
-                 " value = 10 }\n"
-                 "[3] anotherMiddleMan {"
-                 " func = Closure: (dynamic) => dynamic }\n"
-                 "[4] middleMan { x = 5 limit = 100 stop = true"
-                 " value = 242550 i = 99 }\n"
-                 "[5] test { stop = true limit = 100 }\n",
-                 stack_buffer);
+    EXPECT_STREQ(
+        "[0] breakpointNow { }\n"
+        "[1] helper { a = 50 b = 99 stop = true }\n"
+        "[2] <anonymous closure> { x = 5 i = 99 stop = true"
+        " value = 10 }\n"
+        "[3] anotherMiddleMan {"
+        " func = Closure: (dynamic) => dynamic }\n"
+        "[4] middleMan { x = 5 limit = 100 stop = true"
+        " value = 242550 i = 99 }\n"
+        "[5] test { stop = true limit = 100 }\n",
+        stack_buffer);
   }
 
   FLAG_optimization_counter_threshold = saved_threshold;
   FLAG_use_osr = saved_osr;
 }
 
 
 TEST_CASE(Debug_InspectStackWithClosure_NotOptimized) {
   InspectStackWithClosureTest(false);
 }
@@ skipping 64 matching lines @@
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(Dart_IsInteger(retval));
   int64_t int_value = ToInt64(retval);
   EXPECT_EQ(2, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 static const char* step_into_expected_bpts[] = {
-    "main",        // entry
-    "main",        // call foo
-      "foo",       // entry
-      "foo",       // call f1
-        "f1",      // entry
-        "f1",      // return
-      "foo",       // call initializer
-      "foo",       // call kvmk
-        "X.kvmk",  // entry
-        "X.kvmk",  // call
-          "f2",    // entry
-          "f2",    // return
-        "X.kvmk",  // call +
-        "X.kvmk",  // return
-      "foo",       // return
-    "main"         // return
+    "main",    // entry
+    "main",    // call foo
+    "foo",     // entry
+    "foo",     // call f1
+    "f1",      // entry
+    "f1",      // return
+    "foo",     // call initializer
+    "foo",     // call kvmk
+    "X.kvmk",  // entry
+    "X.kvmk",  // call
+    "f2",      // entry
+    "f2",      // return
+    "X.kvmk",  // call +
+    "X.kvmk",  // return
+    "foo",     // return
+    "main"     // return
 };
 
 void TestStepIntoHandler(Dart_IsolateId isolate_id,
                          intptr_t bp_id,
                          const Dart_CodeLocation& location) {
   Dart_StackTrace trace;
   Dart_GetStackTrace(&trace);
   const intptr_t expected_bpts_length = ARRAY_SIZE(step_into_expected_bpts);
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
@@ skipping 58 matching lines @@
   EXPECT(breakpoint_hit_counter == ARRAY_SIZE(step_into_expected_bpts));
 }
 
 
 static void StepIntoHandler(Dart_IsolateId isolate_id,
                             intptr_t bp_id,
                             const Dart_CodeLocation& location) {
   Dart_StackTrace trace;
   Dart_GetStackTrace(&trace);
   if (verbose) {
-    OS::Print(">>> Breakpoint nr. %d in %s <<<\n",
-              breakpoint_hit_counter, BreakpointInfo(trace));
+    OS::Print(">>> Breakpoint nr. %d in %s <<<\n", breakpoint_hit_counter,
+              BreakpointInfo(trace));
     PrintStackTrace(trace);
   }
   breakpoint_hit = true;
   breakpoint_hit_counter++;
   Dart_SetStepInto();
 }
 
 
 TEST_CASE(Debug_IgnoreBP) {
   const char* kScriptChars =
@@ skipping 60 matching lines @@
   EXPECT_EQ(2 * 99, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
 void TestSingleStepHandler(Dart_IsolateId isolate_id,
                            intptr_t bp_id,
                            const Dart_CodeLocation& location) {
   Dart_StackTrace trace;
   Dart_GetStackTrace(&trace);
-  const char* expected_bpts[] = {
-      "moo", "moo", "foo", "moo", "moo", "foo", "moo", "moo", "foo", "main"};
+  const char* expected_bpts[] = {"moo", "moo", "foo", "moo", "moo",
+                                 "foo", "moo", "moo", "foo", "main"};
   const intptr_t expected_bpts_length = ARRAY_SIZE(expected_bpts);
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_VALID(res);
   EXPECT(breakpoint_hit_counter < expected_bpts_length);
   Dart_ActivationFrame frame;
   res = Dart_GetActivationFrame(trace, 0, &frame);
   EXPECT_VALID(res);
   Dart_Handle func_name;
   res = Dart_ActivationFrameInfo(frame, &func_name, NULL, NULL, NULL);
@@ skipping 197 matching lines @@
       "    return y;                   \n"  // Return.
       "  }                             \n"
       "}                               \n"
       "                                \n"
       "main() {                        \n"
       "  var i = 3;                    \n"
       "  foo(i);                       \n"
       "}                               \n";
 
   LoadScript(kScriptChars);
-  Dart_Handle result = Dart_SetNativeResolver(script_lib,
-                                              &NoopNativeResolver,
-                                              NULL);
+  Dart_Handle result =
+      Dart_SetNativeResolver(script_lib, &NoopNativeResolver, NULL);
   EXPECT_VALID(result);
   Dart_SetPausedEventHandler(&TestBreakpointHandlerWithVerify);
 
   Dart_Handle script_url = NewString(TestCase::url());
 
   const intptr_t num_breakpoints = 9;
-  intptr_t breakpoint_lines[num_breakpoints] =
-      {5, 6, 7, 8, 9, 10, 11, 12, 13};
+  intptr_t breakpoint_lines[num_breakpoints] = {5, 6, 7, 8, 9, 10, 11, 12, 13};
 
   for (intptr_t i = 0; i < num_breakpoints; i++) {
     result = Dart_SetBreakpoint(script_url, breakpoint_lines[i]);
     EXPECT_VALID(result);
     EXPECT(Dart_IsInteger(result));
   }
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
@@ skipping 85 matching lines @@
   ASSERT(script_lib != NULL);
   ASSERT(!Dart_IsError(script_lib));
   ASSERT(Dart_IsLibrary(script_lib));
   Dart_Handle class_A = Dart_GetClass(script_lib, NewString("A"));
   EXPECT_VALID(class_A);
 
   const int expected_num_fields = 2;
   struct {
     const char* field_name;
     const char* field_value;
-  } expected[] = {
-    // Expected values at first breakpoint.
-    { "bla", "yada yada yada"},
-    { "u", "null" },
-    // Expected values at second breakpoint.
-    { "bla", "silence is golden" },
-    { "u", "442" }
-  };
+  } expected[] = {// Expected values at first breakpoint.
+                  {"bla", "yada yada yada"},
+                  {"u", "null"},
+                  // Expected values at second breakpoint.
+                  {"bla", "silence is golden"},
+                  {"u", "442"}};
   ASSERT(breakpoint_hit_counter < 2);
   int expected_idx = breakpoint_hit_counter * expected_num_fields;
   breakpoint_hit_counter++;
 
   Dart_Handle fields = Dart_GetStaticFields(class_A);
   ASSERT(!Dart_IsError(fields));
   ASSERT(Dart_IsList(fields));
 
   intptr_t list_length = 0;
   Dart_Handle retval = Dart_ListLength(fields, &list_length);
@@ skipping 18 matching lines @@
     Dart_StringToCString(value_handle, &value);
     EXPECT_STREQ(expected[expected_idx].field_value, value);
     OS::Print("  %s: %s\n", name, value);
     expected_idx++;
   }
 }
 
 
 TEST_CASE(Debug_InspectStaticField) {
   const char* kScriptChars =
-    " class A {                                 \n"
-    "   static var bla = 'yada yada yada';      \n"
-    "   static var u;                           \n"
-    " }                                         \n"
-    "                                           \n"
-    " debugBreak() { }                          \n"
-    " main() {                                  \n"
-    "   var a = new A();                        \n"
-    "   debugBreak();                           \n"
-    "   A.u = 442;                              \n"
-    "   A.bla = 'silence is golden';            \n"
-    "   debugBreak();                           \n"
-    " }                                         \n";
+      " class A {                                 \n"
+      "   static var bla = 'yada yada yada';      \n"
+      "   static var u;                           \n"
+      " }                                         \n"
+      "                                           \n"
+      " debugBreak() { }                          \n"
+      " main() {                                  \n"
+      "   var a = new A();                        \n"
+      "   debugBreak();                           \n"
+      "   A.u = 442;                              \n"
+      "   A.bla = 'silence is golden';            \n"
+      "   debugBreak();                           \n"
+      " }                                         \n";
 
   LoadScript(kScriptChars);
   Dart_SetPausedEventHandler(&InspectStaticFieldHandler);
   SetBreakpointAtEntry("", "debugBreak");
 
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
 }
 
 
 TEST_CASE(Debug_InspectObject) {
   const char* kScriptChars =
-    " class A {                                 \n"
-    "   var a_field = 'a';                      \n"
-    "   static var bla = 'yada yada yada';      \n"
-    "   static var error = unresolvedName();    \n"
-    "   var d = 42.1;                           \n"
-    " }                                         \n"
-    " class B extends A {                       \n"
-    "   var oneDay = const Duration(hours: 24); \n"
-    "   static var bla = 'blah blah';           \n"
-    " }                                         \n"
-    " get_b() { return new B(); }               \n"
-    " get_int() { return 666; }                 \n";
+      " class A {                                 \n"
+      "   var a_field = 'a';                      \n"
+      "   static var bla = 'yada yada yada';      \n"
+      "   static var error = unresolvedName();    \n"
+      "   var d = 42.1;                           \n"
+      " }                                         \n"
+      " class B extends A {                       \n"
+      "   var oneDay = const Duration(hours: 24); \n"
+      "   static var bla = 'blah blah';           \n"
+      " }                                         \n"
+      " get_b() { return new B(); }               \n"
+      " get_int() { return 666; }                 \n";
 
   // Number of instance fields in an object of class B.
   const intptr_t kNumObjectFields = 3;
 
   LoadScript(kScriptChars);
 
   Dart_Handle object_b = Invoke("get_b");
 
   EXPECT_VALID(object_b);
 
@@ skipping 222 matching lines @@
       "}                            \n"
       "void main() {                \n"
       "  A.foo();                   \n"
       "}                            \n";
 
   Dart_Isolate isolate = TestCase::CreateTestIsolate();
   ASSERT(isolate != NULL);
   Dart_EnterScope();
   LoadScript(kScriptChars);
 
-  Dart_Handle result = Dart_SetNativeResolver(script_lib,
-                                              &InterruptNativeResolver,
-                                              NULL);
+  Dart_Handle result =
+      Dart_SetNativeResolver(script_lib, &InterruptNativeResolver, NULL);
   EXPECT_VALID(result);
 
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 }
 
 
 TEST_CASE(Debug_InterruptIsolate) {
@@ skipping 39 matching lines @@
       ml.Wait();
     }
   }
   EXPECT(interrupt_isolate_id == ILLEGAL_ISOLATE_ID);
   OS::PrintErr("Complete\n");
   FLAG_trace_shutdown = saved_flag;
 }
 
 
 static void StackTraceDump1BreakpointHandler(
-                Dart_IsolateId isolate_id,
-                intptr_t bp_id,
-                const Dart_CodeLocation& location) {
+    Dart_IsolateId isolate_id,
+    intptr_t bp_id,
+    const Dart_CodeLocation& location) {
   Dart_StackTrace trace;
   Dart_GetStackTrace(&trace);
   const int kStackTraceLen = 4;
   static const char* expected_trace[kStackTraceLen] = {
-    "local_to_main",
-    "Test.local1_to_func1",
-    "Test.func1",
-    "main"
-  };
+      "local_to_main", "Test.local1_to_func1", "Test.func1", "main"};
 
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_VALID(res);
   EXPECT_EQ(kStackTraceLen, trace_len);
 
   // Frame 0 corresponding to "local_to_main".
   Dart_Handle frame0_locals = Dart_NewList(8);
   Dart_ListSetAt(frame0_locals, 0, NewString("i"));
   Dart_ListSetAt(frame0_locals, 1, Dart_NewInteger(76));
@@ skipping 50 matching lines @@
   Dart_ListSetAt(frame3_locals, 5, Dart_Null());
   Dart_ListSetAt(frame3_locals, 6, NewString("sum"));
   Dart_ListSetAt(frame3_locals, 7, Dart_NewInteger(0));
   Dart_ListSetAt(frame3_locals, 8, NewString("value"));
   Dart_ListSetAt(frame3_locals, 9, Dart_Null());
   Dart_ListSetAt(frame3_locals, 10, NewString("func1"));
   Dart_ListSetAt(frame3_locals, 11, Dart_Null());
   Dart_ListSetAt(frame3_locals, 12, NewString("main_local"));
   Dart_ListSetAt(frame3_locals, 13, Dart_Null());
 
-  Dart_Handle expected_locals[] = {
-    frame0_locals,
-    frame1_locals,
-    frame2_locals,
-    frame3_locals
-  };
+  Dart_Handle expected_locals[] = {frame0_locals, frame1_locals, frame2_locals,
+                                   frame3_locals};
   breakpoint_hit_counter++;
-  VerifyStackTrace(trace, expected_trace, expected_locals,
-                   kStackTraceLen, true);
+  VerifyStackTrace(trace, expected_trace, expected_locals, kStackTraceLen,
+                   true);
 }
 
 
 TEST_CASE(Debug_StackTraceDump1) {
   const char* kScriptChars =
       "class Test {\n"
       "  Test(int local);\n"
       "\n"
       "  int func1(int func(int i, int j)) {\n"
       "    var i = 0;\n"
@@ skipping 50 matching lines @@
   EXPECT_EQ(195, int_value);
   EXPECT_EQ(1, breakpoint_hit_counter);
 }
 
 
 static void StackTraceDump2ExceptionHandler(Dart_IsolateId isolate_id,
                                             Dart_Handle exception_object,
                                             Dart_StackTrace trace) {
   const int kStackTraceLen = 5;
   static const char* expected_trace[kStackTraceLen] = {
-    "Object._noSuchMethod",
-    "Object.noSuchMethod",
-    "Test.local1_to_func1",
-    "Test.func1",
-    "main"
-  };
+      "Object._noSuchMethod", "Object.noSuchMethod", "Test.local1_to_func1",
+      "Test.func1", "main"};
 
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_VALID(res);
   EXPECT_EQ(kStackTraceLen, trace_len);
 
   // Frame 0 corresponding to "Object._noSuchMethod".
   Dart_Handle frame0_locals = Dart_NewList(12);
   Dart_ListSetAt(frame0_locals, 0, NewString("this"));
   Dart_ListSetAt(frame0_locals, 1, Dart_Null());
@@ skipping 61 matching lines @@
   Dart_ListSetAt(frame4_locals, 3, Dart_NewInteger(20));
   Dart_ListSetAt(frame4_locals, 4, NewString("local_to_main"));
   Dart_ListSetAt(frame4_locals, 5, Dart_Null());
   Dart_ListSetAt(frame4_locals, 6, NewString("sum"));
   Dart_ListSetAt(frame4_locals, 7, Dart_NewInteger(0));
   Dart_ListSetAt(frame4_locals, 8, NewString("value"));
   Dart_ListSetAt(frame4_locals, 9, Dart_Null());
   Dart_ListSetAt(frame4_locals, 10, NewString("func1"));
   Dart_ListSetAt(frame4_locals, 11, Dart_Null());
 
-  Dart_Handle expected_locals[] = {
-    frame0_locals,
-    frame1_locals,
-    frame2_locals,
-    frame3_locals,
-    frame4_locals
-  };
+  Dart_Handle expected_locals[] = {frame0_locals, frame1_locals, frame2_locals,
+                                   frame3_locals, frame4_locals};
   breakpoint_hit_counter++;
-  VerifyStackTrace(trace, expected_trace, expected_locals,
-                   kStackTraceLen, true);
+  VerifyStackTrace(trace, expected_trace, expected_locals, kStackTraceLen,
+                   true);
 }
 
 
 TEST_CASE(Debug_StackTraceDump2) {
   const char* kScriptChars =
       "class Test {\n"
       "  Test(int local);\n"
       "\n"
       "  int func1(int func(int i, int j)) {\n"
       "    var i = 0;\n"
@@ skipping 160 matching lines @@
   // List l now has 5 elements.
 
   len = Dart_EvaluateExpr(script_lib, NewString("l.length + 1"));
   EXPECT_VALID(len);
   EXPECT(Dart_IsNumber(len));
   EXPECT_EQ(6, ToInt64(len));
 
   closure = Dart_EvaluateExpr(script_lib, NewString("(x) => l.length + x"));
   EXPECT_VALID(closure);
   EXPECT(Dart_IsClosure(closure));
-  Dart_Handle args[1] = { Dart_NewInteger(1) };
+  Dart_Handle args[1] = {Dart_NewInteger(1)};
   len = Dart_InvokeClosure(closure, 1, args);
   EXPECT_VALID(len);
   EXPECT(Dart_IsNumber(len));
   EXPECT_EQ(6, ToInt64(len));
 
   len = Dart_EvaluateExpr(script_lib, NewString("((x) => l.length + x)(1)"));
   EXPECT_VALID(len);
   EXPECT(Dart_IsNumber(len));
   EXPECT_EQ(6, ToInt64(len));
 
@@ skipping 28 matching lines @@
       "  Point(this.x, this.y);          \n"
       "  get r => sqrt(x*x + y*y);       \n"
       "}                                 \n";
   LoadScript(kScriptChars);
   Dart_FinalizeLoading(false);
 
   Dart_SetExceptionThrownHandler(&EvaluateInActivationOfEvaluateHandler);
   Dart_SetExceptionPauseInfo(kPauseOnAllExceptions);
   breakpoint_hit_counter = 0;
 
-  Dart_Handle result = Dart_EvaluateExpr(script_lib, NewString(
-      "() { var p = new Point(3, 4); throw p; } ())"));
+  Dart_Handle result = Dart_EvaluateExpr(
+      script_lib, NewString("() { var p = new Point(3, 4); throw p; } ())"));
   EXPECT(Dart_IsError(result));
   EXPECT_EQ(1, breakpoint_hit_counter);
 }
 
 
 static void UnhandledExceptionHandler(Dart_IsolateId isolate_id,
                                       Dart_Handle exception_object,
                                       Dart_StackTrace trace) {
   breakpoint_hit_counter++;
 }
@@ skipping 107 matching lines @@
   Dart_Handle iterable_name = Dart_NewStringFromCString("Iterable");
   Dart_Handle list_name = Dart_NewStringFromCString("List");
 
   Dart_Handle object_type = Dart_GetType(core_lib, object_name, 0, NULL);
   Dart_Handle int_type = Dart_GetType(core_lib, int_name, 0, NULL);
   EXPECT_VALID(int_type);
   Dart_Handle Test_type = Dart_GetType(script_lib, Test_name, 0, NULL);
   Dart_Handle Test1_type = Dart_GetType(script_lib, Test1_name, 0, NULL);
   Dart_Handle type_args = Dart_NewList(1);
   Dart_ListSetAt(type_args, 0, int_type);
-  Dart_Handle Test2_int_type = Dart_GetType(script_lib,
-                                            Test2_name,
-                                            1,
-                                            &type_args);
+  Dart_Handle Test2_int_type =
+      Dart_GetType(script_lib, Test2_name, 1, &type_args);
   Dart_Handle Test3_type = Dart_GetType(script_lib, Test3_name, 0, NULL);
   type_args = Dart_NewList(2);
   Dart_ListSetAt(type_args, 0, int_type);
   Dart_ListSetAt(type_args, 1, Test_type);
-  Dart_Handle Test4_int_type = Dart_GetType(script_lib,
-                                            Test4_name,
-                                            2,
-                                            &type_args);
+  Dart_Handle Test4_int_type =
+      Dart_GetType(script_lib, Test4_name, 2, &type_args);
   type_args = Dart_NewList(3);
   Dart_ListSetAt(type_args, 0, int_type);
   Dart_ListSetAt(type_args, 1, Test_type);
   Dart_ListSetAt(type_args, 2, int_type);
-  Dart_Handle Test5_int_type = Dart_GetType(script_lib,
-                                            Test5_name,
-                                            3,
-                                            &type_args);
+  Dart_Handle Test5_int_type =
+      Dart_GetType(script_lib, Test5_name, 3, &type_args);
   {
     Dart_Handle super_type = Dart_GetSupertype(object_type);
     EXPECT(super_type == Dart_Null());
   }
   {
     Dart_Handle super_type = Dart_GetSupertype(Test1_type);
     const Type& expected_type = Api::UnwrapTypeHandle(zone, Test_type);
     const Type& actual_type = Api::UnwrapTypeHandle(zone, super_type);
     EXPECT(expected_type.raw() == actual_type.raw());
   }
@@ skipping 121 matching lines @@
       " null, 5, 17, 5, 18, 9, 19, 12,"
       " null, 6, 21, 1,"
       " null, 8, 24, 1, 25, 5, 26, 6, 27, 8,"
       " null, 9, 29, 1]",
       tokens_cstr);
 }
 
 #endif
 
 }  // namespace dart