Added new type of unit test, RAW_UNIT_TEST_CASE, which is used for tests that can be flaky if run w…

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"
 
 namespace dart {
 
-UNIT_TEST_CASE(Mutex) {
+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;
 }
 
 
-UNIT_TEST_CASE(Monitor) {
+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();
   EXPECT_EQ(true, monitor->TryEnter());
@@ skipping 117 matching lines @@
   }
 
  private:
   Isolate* isolate_;
   Monitor* monitor_;
   bool* done_;
   intptr_t id_;
 };
 
 
-VM_TEST_CASE(ManyTasksWithZones) {
+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(
         new TaskWithZoneAllocation(isolate, &sync[i], &done[i], i));
@@ skipping 360 matching lines @@
     EXPECT_EQ(SafepointTestTask::kTaskCount, exited);
   }
 }
 
 
 // Test rendezvous of:
 // - helpers in VM code, and
 // - main thread in VM code,
 // organized by
 // - helpers.
-VM_TEST_CASE(SafepointTestVM) {
+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.
-VM_TEST_CASE(RecursiveSafepointTest1) {
+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);
 }
 
 
-VM_TEST_CASE(ThreadIterator_Count) {
+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);
 }
 
 
-VM_TEST_CASE(ThreadIterator_FindSelf) {
+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;
 };
@@ skipping 40 matching lines @@
   delete params.monitor;
 }
 
 
 // Test rendezvous of:
 // - helpers in VM code, and
 // - main thread in VM code,
 // organized by
 // - main thread, and
 // - helpers.
-VM_TEST_CASE(SafepointTestVM2) {
+ISOLATE_UNIT_TEST_CASE(SafepointTestVM2) {
   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));
   }
   bool all_helpers = false;
@@ skipping 11 matching lines @@
   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.
-VM_TEST_CASE(RecursiveSafepointTest2) {
+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(
         isolate, &monitor, &expected_count, &total_done, &exited));
   }
   bool all_helpers = false;
@@ skipping 50 matching lines @@
     }
   }
 
  private:
   Isolate* isolate_;
   Monitor* done_monitor_;
   bool* done_;
 };
 
 
-VM_TEST_CASE(HelperAllocAndGC) {
+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