clang-format runtime/vm

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 "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"
@@ skipping 31 matching lines @@
   Dart_Handle test_lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Setup the internal library's 'internalPrint' function.
   // Necessary because asynchronous errors use "print" to print their
   // stack trace.
   Dart_Handle url = NewString("dart:_internal");
   DART_CHECK_VALID(url);
   Dart_Handle internal_lib = Dart_LookupLibrary(url);
   DART_CHECK_VALID(internal_lib);
   Dart_Handle print = Dart_GetField(test_lib, NewString("_nullPrintClosure"));
-  Dart_Handle result = Dart_SetField(internal_lib,
-                                     NewString("_printClosure"),
-                                     print);
+  Dart_Handle result =
+      Dart_SetField(internal_lib, NewString("_printClosure"), print);
 
   DART_CHECK_VALID(result);
 
   // Setup the 'scheduleImmediate' closure.
   url = NewString("dart:isolate");
   DART_CHECK_VALID(url);
   Dart_Handle isolate_lib = Dart_LookupLibrary(url);
   DART_CHECK_VALID(isolate_lib);
-  Dart_Handle schedule_immediate_closure =
-      Dart_Invoke(isolate_lib, NewString("_getIsolateScheduleImmediateClosure"),
-                  0, NULL);
+  Dart_Handle schedule_immediate_closure = Dart_Invoke(
+      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) {
-  }
+      : thread_(thread), barrier_(barrier) {}
 
   virtual void Run() {
     Thread::EnterIsolateAsHelper(thread_->isolate(), Thread::kUnknownTask);
     // Tell main thread that we are ready.
     barrier_->Sync();
     for (intptr_t i = 0; i < kIterations; ++i) {
       // Busy wait for interrupts.
       uword limit = 0;
       do {
         limit = AtomicOperations::LoadRelaxed(
             reinterpret_cast<uword*>(thread_->stack_limit_address()));
-      } while ((limit == thread_->saved_stack_limit_) ||
-               (((limit & Thread::kInterruptsMask) &
-                 Thread::kVMInterrupt) == 0));
+      } while (
+          (limit == thread_->saved_stack_limit_) ||
+          (((limit & Thread::kInterruptsMask) & Thread::kVMInterrupt) == 0));
       // Tell main thread that we observed the interrupt.
       barrier_->Sync();
     }
     Thread::ExitIsolateAsHelper();
     barrier_->Exit();
   }
 
  private:
   Thread* thread_;
   ThreadBarrier* barrier_;
@@ skipping 30 matching lines @@
     // 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 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_;
   }
 };
@@ skipping 73 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