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

runtime/vm/thread_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 "platform/assert.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
-#include "vm/unit_test.h"
 #include "vm/profiler.h"
 #include "vm/safepoint.h"
 #include "vm/stack_frame.h"
 #include "vm/thread_pool.h"
+#include "vm/unit_test.h"
 
 namespace dart {
 
 VM_UNIT_TEST_CASE(Mutex) {
   // This unit test case needs a running isolate.
   Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_data,
                      bin::core_isolate_snapshot_instructions, NULL, NULL, NULL);
 
   Mutex* mutex = new Mutex();
   mutex->Lock();
   EXPECT_EQ(false, mutex->TryLock());
   mutex->Unlock();
   EXPECT_EQ(true, mutex->TryLock());
   mutex->Unlock();
   {
     MutexLocker ml(mutex);
     EXPECT_EQ(false, mutex->TryLock());
   }
   // The isolate shutdown and the destruction of the mutex are out-of-order on
   // purpose.
   Dart_ShutdownIsolate();
   delete mutex;
 }
 
-
 VM_UNIT_TEST_CASE(Monitor) {
   // This unit test case needs a running isolate.
   Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_data,
                      bin::core_isolate_snapshot_instructions, NULL, NULL, NULL);
   OSThread* thread = OSThread::Current();
   // Thread interrupter interferes with this test, disable interrupts.
   thread->DisableThreadInterrupts();
   Monitor* monitor = new Monitor();
   monitor->Enter();
   monitor->Exit();
@@ skipping 26 matching lines @@
     attempts++;
   }
   EXPECT_LT(attempts, kNumAttempts);
 
   // The isolate shutdown and the destruction of the mutex are out-of-order on
   // purpose.
   Dart_ShutdownIsolate();
   delete monitor;
 }
 
-
 class ObjectCounter : public ObjectPointerVisitor {
  public:
   explicit ObjectCounter(Isolate* isolate, const Object* obj)
       : ObjectPointerVisitor(isolate), obj_(obj), count_(0) {}
 
   virtual void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; ++current) {
       if (*current == obj_->raw()) {
         ++count_;
       }
     }
   }
 
   intptr_t count() const { return count_; }
 
  private:
   const Object* obj_;
   intptr_t count_;
 };
 
-
 class TaskWithZoneAllocation : public ThreadPool::Task {
  public:
   TaskWithZoneAllocation(Isolate* isolate,
                          Monitor* monitor,
                          bool* done,
                          intptr_t id)
       : isolate_(isolate), monitor_(monitor), done_(done), id_(id) {}
   virtual void Run() {
     Thread::EnterIsolateAsHelper(isolate_, Thread::kUnknownTask);
     {
@@ skipping 49 matching lines @@
     }
   }
 
  private:
   Isolate* isolate_;
   Monitor* monitor_;
   bool* done_;
   intptr_t id_;
 };
 
-
 ISOLATE_UNIT_TEST_CASE(ManyTasksWithZones) {
   const int kTaskCount = 100;
   Monitor sync[kTaskCount];
   bool done[kTaskCount];
   Isolate* isolate = Thread::Current()->isolate();
   EXPECT(isolate->heap()->GrowthControlState());
   isolate->heap()->DisableGrowthControl();
   for (int i = 0; i < kTaskCount; i++) {
     done[i] = false;
     Dart::thread_pool()->Run(
@@ skipping 11 matching lines @@
       ml.Wait();
     }
     EXPECT(done[i]);
     if (i % 10 == 0) {
       Thread::EnterIsolate(isolate);
     }
     EXPECT(bar.Equals("bar"));
   }
 }
 
-
 #ifndef PRODUCT
 class SimpleTaskWithZoneAllocation : public ThreadPool::Task {
  public:
   SimpleTaskWithZoneAllocation(intptr_t id,
                                Isolate* isolate,
                                Thread** thread_ptr,
                                Monitor* sync,
                                Monitor* monitor,
                                intptr_t* done_count,
                                bool* wait)
@@ skipping 61 matching lines @@
 
   intptr_t id_;
   Isolate* isolate_;
   Thread** thread_ptr_;
   Monitor* sync_;
   Monitor* monitor_;
   intptr_t* done_count_;
   bool* wait_;
 };
 
-
 TEST_CASE(ManySimpleTasksWithZones) {
   const int kTaskCount = 10;
   Monitor monitor;
   Monitor sync;
   Thread* threads[kTaskCount];
   Isolate* isolate = Thread::Current()->isolate();
   intptr_t done_count = 0;
   bool wait = true;
 
   EXPECT(isolate->heap()->GrowthControlState());
@@ skipping 52 matching lines @@
   // Now wait for them all to exit before destroying the isolate.
   {
     MonitorLocker ml(&monitor);
     while (done_count < kTaskCount) {
       ml.Wait();
     }
   }
 }
 #endif
 
-
 TEST_CASE(ThreadRegistry) {
   Isolate* orig = Thread::Current()->isolate();
   Zone* orig_zone = Thread::Current()->zone();
   char* orig_str = orig_zone->PrintToString("foo");
   Dart_ExitIsolate();
   // Create and enter a new isolate.
   Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_data,
                      bin::core_isolate_snapshot_instructions, NULL, NULL, NULL);
   Zone* zone0 = Thread::Current()->zone();
   EXPECT(zone0 != orig_zone);
   Dart_ShutdownIsolate();
   // Create and enter yet another isolate.
   Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_data,
                      bin::core_isolate_snapshot_instructions, NULL, NULL, NULL);
   {
     // Create a stack resource this time, and exercise it.
     StackZone stack_zone(Thread::Current());
     Zone* zone1 = Thread::Current()->zone();
     EXPECT(zone1 != zone0);
     EXPECT(zone1 != orig_zone);
   }
   Dart_ShutdownIsolate();
   Dart_EnterIsolate(reinterpret_cast<Dart_Isolate>(orig));
   // Original zone should be preserved.
   EXPECT_EQ(orig_zone, Thread::Current()->zone());
   EXPECT_STREQ("foo", orig_str);
 }
 
-
 // A helper thread that alternatingly cooperates and organizes
 // safepoint rendezvous. At rendezvous, it explicitly visits the
 // stacks looking for a specific marker (Smi) to verify that the expected
 // number threads are actually visited. The task is "done" when it has
 // successfully made all other tasks and the main thread rendezvous (may
 // not happen in the first rendezvous, since tasks are still starting up).
 class SafepointTestTask : public ThreadPool::Task {
  public:
   static const intptr_t kTaskCount;
 
@@ skipping 69 matching lines @@
 
  private:
   Isolate* isolate_;
   Monitor* monitor_;
   intptr_t* expected_count_;  // # copies of kUniqueSmi we expect to visit.
   intptr_t* total_done_;      // # tasks that successfully safepointed once.
   intptr_t* exited_;          // # tasks that are no longer running.
   bool local_done_;           // this task has successfully safepointed >= once.
 };
 
-
 const intptr_t SafepointTestTask::kTaskCount = 5;
 
-
 // Test rendezvous of:
 // - helpers in VM code,
 // - main thread in pure Dart,
 // organized by
 // - helpers.
 TEST_CASE(SafepointTestDart) {
   Isolate* isolate = Thread::Current()->isolate();
   Monitor monitor;
   intptr_t expected_count = 0;
   intptr_t total_done = 0;
@@ skipping 31 matching lines @@
   {
     MonitorLocker ml(&monitor);
     while (exited != SafepointTestTask::kTaskCount) {
       ml.Wait();
     }
     EXPECT_EQ(SafepointTestTask::kTaskCount, total_done);
     EXPECT_EQ(SafepointTestTask::kTaskCount, exited);
   }
 }
 
-
 // Test rendezvous of:
 // - helpers in VM code, and
 // - main thread in VM code,
 // organized by
 // - helpers.
 ISOLATE_UNIT_TEST_CASE(SafepointTestVM) {
   Isolate* isolate = thread->isolate();
   Monitor monitor;
   intptr_t expected_count = 0;
   intptr_t total_done = 0;
   intptr_t exited = 0;
   for (int i = 0; i < SafepointTestTask::kTaskCount; i++) {
     Dart::thread_pool()->Run(new SafepointTestTask(
         isolate, &monitor, &expected_count, &total_done, &exited));
   }
   String& label = String::Handle(String::New("foo"));
   UserTag& tag = UserTag::Handle(UserTag::New(label));
   isolate->set_current_tag(tag);
   MonitorLocker ml(&monitor);
   while (exited != SafepointTestTask::kTaskCount) {
     ml.WaitWithSafepointCheck(thread);
   }
 }
 
-
 // Test case for recursive safepoint operations.
 ISOLATE_UNIT_TEST_CASE(RecursiveSafepointTest1) {
   intptr_t count = 0;
   {
     SafepointOperationScope safepoint_scope(thread);
     count += 1;
     {
       SafepointOperationScope safepoint_scope(thread);
       count += 1;
       {
         SafepointOperationScope safepoint_scope(thread);
         count += 1;
       }
     }
   }
   EXPECT(count == 3);
 }
 
-
 ISOLATE_UNIT_TEST_CASE(ThreadIterator_Count) {
   intptr_t thread_count_0 = 0;
   intptr_t thread_count_1 = 0;
 
   {
     OSThreadIterator ti;
     while (ti.HasNext()) {
       OSThread* thread = ti.Next();
       EXPECT(thread != NULL);
       thread_count_0++;
     }
   }
 
   {
     OSThreadIterator ti;
     while (ti.HasNext()) {
       OSThread* thread = ti.Next();
       EXPECT(thread != NULL);
       thread_count_1++;
     }
   }
 
   EXPECT(thread_count_0 > 0);
   EXPECT(thread_count_1 > 0);
   EXPECT(thread_count_0 >= thread_count_1);
 }
 
-
 ISOLATE_UNIT_TEST_CASE(ThreadIterator_FindSelf) {
   OSThread* current = OSThread::Current();
   EXPECT(OSThread::IsThreadInList(current->id()));
 }
 
-
 struct ThreadIteratorTestParams {
   ThreadId spawned_thread_id;
   ThreadJoinId spawned_thread_join_id;
   Monitor* monitor;
 };
 
-
 void ThreadIteratorTestMain(uword parameter) {
   ThreadIteratorTestParams* params =
       reinterpret_cast<ThreadIteratorTestParams*>(parameter);
   OSThread* thread = OSThread::Current();
   EXPECT(thread != NULL);
 
   MonitorLocker ml(params->monitor);
   params->spawned_thread_id = thread->id();
   params->spawned_thread_join_id = OSThread::GetCurrentThreadJoinId(thread);
   EXPECT(params->spawned_thread_id != OSThread::kInvalidThreadId);
   EXPECT(OSThread::IsThreadInList(thread->id()));
   ml.Notify();
 }
 
-
 // NOTE: This test case also verifies that known TLS destructors are called
 // on Windows. See |OnDartThreadExit| in os_thread_win.cc for more details.
 TEST_CASE(ThreadIterator_AddFindRemove) {
   ThreadIteratorTestParams params;
   params.spawned_thread_id = OSThread::kInvalidThreadId;
   params.monitor = new Monitor();
 
   {
     MonitorLocker ml(params.monitor);
     EXPECT(params.spawned_thread_id == OSThread::kInvalidThreadId);
     // Spawn thread and wait to receive the thread id.
     OSThread::Start("ThreadIteratorTest", ThreadIteratorTestMain,
                     reinterpret_cast<uword>(&params));
     while (params.spawned_thread_id == OSThread::kInvalidThreadId) {
       ml.Wait();
     }
     EXPECT(params.spawned_thread_id != OSThread::kInvalidThreadId);
     EXPECT(params.spawned_thread_join_id != OSThread::kInvalidThreadJoinId);
     OSThread::Join(params.spawned_thread_join_id);
   }
 
   EXPECT(!OSThread::IsThreadInList(params.spawned_thread_id))
 
   delete params.monitor;
 }
 
-
 // Test rendezvous of:
 // - helpers in VM code, and
 // - main thread in VM code,
 // organized by
 // - main thread, and
 // - helpers.
 ISOLATE_UNIT_TEST_CASE(SafepointTestVM2) {
   Isolate* isolate = thread->isolate();
   Monitor monitor;
   intptr_t expected_count = 0;
@@ skipping 15 matching lines @@
   } while (!all_helpers);
   String& label = String::Handle(String::New("foo"));
   UserTag& tag = UserTag::Handle(UserTag::New(label));
   isolate->set_current_tag(tag);
   MonitorLocker ml(&monitor);
   while (exited != SafepointTestTask::kTaskCount) {
     ml.WaitWithSafepointCheck(thread);
   }
 }
 
-
 // Test recursive safepoint operation scopes with other threads trying
 // to also start a safepoint operation scope.
 ISOLATE_UNIT_TEST_CASE(RecursiveSafepointTest2) {
   Isolate* isolate = thread->isolate();
   Monitor monitor;
   intptr_t expected_count = 0;
   intptr_t total_done = 0;
   intptr_t exited = 0;
   for (int i = 0; i < SafepointTestTask::kTaskCount; i++) {
     Dart::thread_pool()->Run(new SafepointTestTask(
@@ skipping 19 matching lines @@
     {
       SafepointOperationScope safepoint_scope(thread);
       MonitorLocker ml(&monitor);
       if (exited == SafepointTestTask::kTaskCount) {
         all_exited = true;
       }
     }
   } while (!all_exited);
 }
 
-
 class AllocAndGCTask : public ThreadPool::Task {
  public:
   AllocAndGCTask(Isolate* isolate, Monitor* done_monitor, bool* done)
       : isolate_(isolate), done_monitor_(done_monitor), done_(done) {}
 
   virtual void Run() {
     Thread::EnterIsolateAsHelper(isolate_, Thread::kUnknownTask);
     {
       Thread* thread = Thread::Current();
       StackZone stack_zone(thread);
@@ skipping 12 matching lines @@
       ml.Notify();
     }
   }
 
  private:
   Isolate* isolate_;
   Monitor* done_monitor_;
   bool* done_;
 };
 
-
 ISOLATE_UNIT_TEST_CASE(HelperAllocAndGC) {
   Monitor done_monitor;
   bool done = false;
   Isolate* isolate = thread->isolate();
   Dart::thread_pool()->Run(new AllocAndGCTask(isolate, &done_monitor, &done));
   {
     while (true) {
       TransitionVMToBlocked transition(thread);
       MonitorLocker ml(&done_monitor);
       if (done) {
         break;
       }
     }
   }
 }
 
 }  // namespace dart