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

runtime/vm/stack_frame_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/stack_frame.h"
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/resolver.h"
-#include "vm/stack_frame.h"
 #include "vm/unit_test.h"
 #include "vm/verifier.h"
 #include "vm/zone.h"
 
 namespace dart {
 
 // Unit test for empty stack frame iteration.
 ISOLATE_UNIT_TEST_CASE(EmptyStackFrameIteration) {
   StackFrameIterator iterator(StackFrameIterator::kValidateFrames,
                               Thread::Current(),
                               StackFrameIterator::kNoCrossThreadIteration);
   EXPECT(!iterator.HasNextFrame());
   EXPECT(iterator.NextFrame() == NULL);
   VerifyPointersVisitor::VerifyPointers();
 }
 
-
 // Unit test for empty dart stack frame iteration.
 ISOLATE_UNIT_TEST_CASE(EmptyDartStackFrameIteration) {
   DartFrameIterator iterator(Thread::Current(),
                              StackFrameIterator::kNoCrossThreadIteration);
   EXPECT(iterator.NextFrame() == NULL);
   VerifyPointersVisitor::VerifyPointers();
 }
 
-
 #define FUNCTION_NAME(name) StackFrame_##name
 #define REGISTER_FUNCTION(name, count) {"" #name, FUNCTION_NAME(name), count},
 
-
 void FUNCTION_NAME(StackFrame_equals)(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   const Instance& expected = Instance::CheckedHandle(arguments->NativeArgAt(0));
   const Instance& actual = Instance::CheckedHandle(arguments->NativeArgAt(1));
   if (!expected.OperatorEquals(actual)) {
     OS::Print("expected: '%s' actual: '%s'\n", expected.ToCString(),
               actual.ToCString());
     FATAL("Expect_equals fails.\n");
   }
 }
 
-
 void FUNCTION_NAME(StackFrame_frameCount)(Dart_NativeArguments args) {
   int count = 0;
   StackFrameIterator frames(StackFrameIterator::kValidateFrames,
                             Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
   while (frames.NextFrame() != NULL) {
     count += 1;  // Count the frame.
   }
   VerifyPointersVisitor::VerifyPointers();
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   arguments->SetReturn(Object::Handle(Smi::New(count)));
 }
 
-
 void FUNCTION_NAME(StackFrame_dartFrameCount)(Dart_NativeArguments args) {
   int count = 0;
   DartFrameIterator frames(Thread::Current(),
                            StackFrameIterator::kNoCrossThreadIteration);
   while (frames.NextFrame() != NULL) {
     count += 1;  // Count the dart frame.
   }
   VerifyPointersVisitor::VerifyPointers();
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   arguments->SetReturn(Object::Handle(Smi::New(count)));
 }
 
-
 void FUNCTION_NAME(StackFrame_validateFrame)(Dart_NativeArguments args) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
   Dart_Handle index = Dart_GetNativeArgument(args, 0);
   Dart_Handle name = Dart_GetNativeArgument(args, 1);
   const Smi& frame_index_smi = Smi::CheckedHandle(Api::UnwrapHandle(index));
   const char* expected_name =
       String::CheckedHandle(Api::UnwrapHandle(name)).ToCString();
   int frame_index = frame_index_smi.Value();
@@ skipping 22 matching lines @@
         FATAL("StackFrame_validateFrame fails, incorrect frame.\n");
       }
       return;
     }
     count += 1;  // Count the dart frames.
     frame = frames.NextFrame();
   }
   FATAL("StackFrame_validateFrame fails, frame count < index passed in.\n");
 }
 
-
 // List all native functions implemented in the vm or core boot strap dart
 // libraries so that we can resolve the native function to it's entry
 // point.
 #define STACKFRAME_NATIVE_LIST(V)                                              \
   V(StackFrame_equals, 2)                                                      \
   V(StackFrame_frameCount, 0)                                                  \
   V(StackFrame_dartFrameCount, 0)                                              \
   V(StackFrame_validateFrame, 2)
 
-
 static struct NativeEntries {
   const char* name_;
   Dart_NativeFunction function_;
   int argument_count_;
 } BuiltinEntries[] = {STACKFRAME_NATIVE_LIST(REGISTER_FUNCTION)};
 
-
 static Dart_NativeFunction native_lookup(Dart_Handle name,
                                          int argument_count,
                                          bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   const Object& obj = Object::Handle(Api::UnwrapHandle(name));
   ASSERT(obj.IsString());
   const char* function_name = obj.ToCString();
   ASSERT(function_name != NULL);
   int num_entries = sizeof(BuiltinEntries) / sizeof(struct NativeEntries);
   for (int i = 0; i < num_entries; i++) {
     struct NativeEntries* entry = &(BuiltinEntries[i]);
     if (!strcmp(function_name, entry->name_) &&
         (entry->argument_count_ == argument_count)) {
       return reinterpret_cast<Dart_NativeFunction>(entry->function_);
     }
   }
   return NULL;
 }
 
-
 // Unit test case to verify stack frame iteration.
 TEST_CASE(ValidateStackFrameIteration) {
   const char* kScriptChars =
       "class StackFrame {"
       "  static equals(var obj1, var obj2) native \"StackFrame_equals\";"
       "  static int frameCount() native \"StackFrame_frameCount\";"
       "  static int dartFrameCount() native \"StackFrame_dartFrameCount\";"
       "  static validateFrame(int index,"
       "                       String name) native \"StackFrame_validateFrame\";"
       "} "
@@ skipping 66 matching lines @@
       "    obj.method1(1);"
       "    obj.method1(2);"
       "  }"
       "}";
   Dart_Handle lib = TestCase::LoadTestScript(
       kScriptChars, reinterpret_cast<Dart_NativeEntryResolver>(native_lookup));
   Dart_Handle cls = Dart_GetClass(lib, NewString("StackFrameTest"));
   EXPECT_VALID(Dart_Invoke(cls, NewString("testMain"), 0, NULL));
 }
 
-
 // Unit test case to verify stack frame iteration.
 TEST_CASE(ValidateNoSuchMethodStackFrameIteration) {
   const char* kScriptChars;
   // The true stack depends on which strategy we are using for noSuchMethod. The
   // stacktrace as seen by Dart is the same either way because dispatcher
   // methods are marked invisible.
   if (FLAG_lazy_dispatchers) {
     kScriptChars =
         "class StackFrame {"
         "  static equals(var obj1, var obj2) native \"StackFrame_equals\";"
@@ skipping 64 matching lines @@
         "  }"
         "}";
   }
   Dart_Handle lib = TestCase::LoadTestScript(
       kScriptChars, reinterpret_cast<Dart_NativeEntryResolver>(native_lookup));
   Dart_Handle cls = Dart_GetClass(lib, NewString("StackFrame2Test"));
   EXPECT_VALID(Dart_Invoke(cls, NewString("testMain"), 0, NULL));
 }
 
 }  // namespace dart