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

runtime/vm/isolate_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/isolate.h"
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/globals.h"
-#include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/thread_barrier.h"
 #include "vm/thread_pool.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 VM_UNIT_TEST_CASE(IsolateCurrent) {
   Dart_Isolate isolate = Dart_CreateIsolate(
       NULL, NULL, bin::core_isolate_snapshot_data,
       bin::core_isolate_snapshot_instructions, NULL, NULL, NULL);
   EXPECT_EQ(isolate, Dart_CurrentIsolate());
   Dart_ShutdownIsolate();
   EXPECT_EQ(reinterpret_cast<Dart_Isolate>(NULL), Dart_CurrentIsolate());
 }
 
-
 // Test to ensure that an exception is thrown if no isolate creation
 // callback has been set by the embedder when an isolate is spawned.
 TEST_CASE(IsolateSpawn) {
   const char* kScriptChars =
       "import 'dart:isolate';\n"
       // Ignores printed lines.
       "var _nullPrintClosure = (String line) {};\n"
       "void entry(message) {}\n"
       "int testMain() {\n"
       "  Isolate.spawn(entry, null);\n"
@@ skipping 28 matching lines @@
       isolate_lib, NewString("_getIsolateScheduleImmediateClosure"), 0, NULL);
   Dart_Handle args[1];
   args[0] = schedule_immediate_closure;
   url = NewString("dart:async");
   DART_CHECK_VALID(url);
   Dart_Handle async_lib = Dart_LookupLibrary(url);
   DART_CHECK_VALID(async_lib);
   DART_CHECK_VALID(Dart_Invoke(
       async_lib, NewString("_setScheduleImmediateClosure"), 1, args));
 
-
   result = Dart_Invoke(test_lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   // Run until all ports to isolate are closed.
   result = Dart_RunLoop();
   EXPECT_ERROR(result, "Unsupported operation: Isolate.spawn");
   EXPECT(Dart_ErrorHasException(result));
   Dart_Handle exception_result = Dart_ErrorGetException(result);
   EXPECT_VALID(exception_result);
 }
 
-
 class InterruptChecker : public ThreadPool::Task {
  public:
   static const intptr_t kTaskCount;
   static const intptr_t kIterations;
 
   InterruptChecker(Thread* thread, ThreadBarrier* barrier)
       : thread_(thread), barrier_(barrier) {}
 
   virtual void Run() {
     Thread::EnterIsolateAsHelper(thread_->isolate(), Thread::kUnknownTask);
@@ skipping 13 matching lines @@
     }
     Thread::ExitIsolateAsHelper();
     barrier_->Exit();
   }
 
  private:
   Thread* thread_;
   ThreadBarrier* barrier_;
 };
 
-
 const intptr_t InterruptChecker::kTaskCount = 5;
 const intptr_t InterruptChecker::kIterations = 10;
 
 // Test and document usage of Isolate::HasInterruptsScheduled.
 //
 // Go through a number of rounds of scheduling interrupts and waiting until all
 // unsynchronized busy-waiting tasks observe it (in the current implementation,
 // the exact latency depends on cache coherence). Synchronization is then used
 // to ensure that the response to the interrupt, i.e., starting a new round,
 // happens *after* the interrupt is observed. Without this synchronization, the
@@ skipping 14 matching lines @@
     thread->ScheduleInterrupts(Thread::kVMInterrupt);
     // Wait for all tasks to observe the interrupt.
     barrier.Sync();
     // Continue with next round.
     uword interrupts = thread->GetAndClearInterrupts();
     EXPECT((interrupts & Thread::kVMInterrupt) != 0);
   }
   barrier.Exit();
 }
 
-
 class IsolateTestHelper {
  public:
   static uword GetStackLimit(Thread* thread) { return thread->stack_limit_; }
   static uword GetSavedStackLimit(Thread* thread) {
     return thread->saved_stack_limit_;
   }
   static uword GetDeferredInterruptsMask(Thread* thread) {
     return thread->deferred_interrupts_mask_;
   }
   static uword GetDeferredInterrupts(Thread* thread) {
     return thread->deferred_interrupts_;
   }
 };
 
-
 TEST_CASE(NoOOBMessageScope) {
   // EXPECT_EQ is picky about type agreement for its arguments.
   const uword kZero = 0;
   const uword kMessageInterrupt = Thread::kMessageInterrupt;
   const uword kVMInterrupt = Thread::kVMInterrupt;
   uword stack_limit;
   uword interrupt_bits;
 
   // Initially no interrupts are scheduled or deferred.
   EXPECT_EQ(IsolateTestHelper::GetStackLimit(thread),
@@ skipping 61 matching lines @@
   // Restore, then clear interrupts.  The world is as it was.
   interrupt_bits = thread->GetAndClearInterrupts();
   EXPECT_EQ(kMessageInterrupt, interrupt_bits);
   EXPECT_EQ(IsolateTestHelper::GetStackLimit(thread),
             IsolateTestHelper::GetSavedStackLimit(thread));
   EXPECT_EQ(kZero, IsolateTestHelper::GetDeferredInterruptsMask(thread));
   EXPECT_EQ(kZero, IsolateTestHelper::GetDeferredInterrupts(thread));
 }
 
 }  // namespace dart