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_pool_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/os.h"
 #include "vm/lockers.h"
 #include "vm/thread_pool.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 DECLARE_FLAG(int, worker_timeout_millis);
 
 
-UNIT_TEST_CASE(ThreadPool_Create) {
+VM_UNIT_TEST_CASE(ThreadPool_Create) {
   ThreadPool thread_pool;
 }
 
 
 class TestTask : public ThreadPool::Task {
  public:
   TestTask(Monitor* sync, bool* done) : sync_(sync), done_(done) {}
 
   // Before running the task, *done_ should be true. This lets the caller
   // ASSERT things knowing that the thread is still around. To unblock the
@@ skipping 10 matching lines @@
     *done_ = true;
     ml.Notify();
   }
 
  private:
   Monitor* sync_;
   bool* done_;
 };
 
 
-UNIT_TEST_CASE(ThreadPool_RunOne) {
+VM_UNIT_TEST_CASE(ThreadPool_RunOne) {
   ThreadPool thread_pool;
   Monitor sync;
   bool done = true;
   thread_pool.Run(new TestTask(&sync, &done));
   {
     MonitorLocker ml(&sync);
     done = false;
     ml.Notify();
     while (!done) {
       ml.Wait();
     }
   }
   EXPECT(done);
 
   // Do a sanity test on the worker stats.
   EXPECT_EQ(1U, thread_pool.workers_started());
   EXPECT_EQ(0U, thread_pool.workers_stopped());
 }
 
 
-UNIT_TEST_CASE(ThreadPool_RunMany) {
+VM_UNIT_TEST_CASE(ThreadPool_RunMany) {
   const int kTaskCount = 100;
   ThreadPool thread_pool;
   Monitor sync[kTaskCount];
   bool done[kTaskCount];
 
   for (int i = 0; i < kTaskCount; i++) {
     done[i] = true;
     thread_pool.Run(new TestTask(&sync[i], &done[i]));
   }
   for (int i = 0; i < kTaskCount; i++) {
@@ skipping 34 matching lines @@
   }
 
  private:
   Monitor* sync_;
   int* started_count_;
   int* slept_count_;
   int millis_;
 };
 
 
-UNIT_TEST_CASE(ThreadPool_WorkerShutdown) {
+VM_UNIT_TEST_CASE(ThreadPool_WorkerShutdown) {
   const int kTaskCount = 10;
   Monitor sync;
   int slept_count = 0;
   int started_count = 0;
 
   // Set up the ThreadPool so that workers notify before they exit.
   ThreadPool* thread_pool = new ThreadPool();
 
   // Run a single task.
   for (int i = 0; i < kTaskCount; i++) {
@@ skipping 17 matching lines @@
     MonitorLocker ml(&sync);
     final_count = slept_count;
   }
 
   // We should have waited for all the workers to finish, so they all should
   // have had a chance to increment slept_count.
   EXPECT_EQ(kTaskCount, final_count);
 }
 
 
-UNIT_TEST_CASE(ThreadPool_WorkerTimeout) {
+VM_UNIT_TEST_CASE(ThreadPool_WorkerTimeout) {
   // Adjust the worker timeout so that we timeout quickly.
   int saved_timeout = FLAG_worker_timeout_millis;
   FLAG_worker_timeout_millis = 1;
 
   ThreadPool thread_pool;
   EXPECT_EQ(0U, thread_pool.workers_started());
   EXPECT_EQ(0U, thread_pool.workers_stopped());
 
   // Run a worker.
   Monitor sync;
@@ skipping 52 matching lines @@
 
  private:
   ThreadPool* pool_;
   Monitor* sync_;
   int todo_;
   int total_;
   int* done_;
 };
 
 
-UNIT_TEST_CASE(ThreadPool_RecursiveSpawn) {
+VM_UNIT_TEST_CASE(ThreadPool_RecursiveSpawn) {
   ThreadPool thread_pool;
   Monitor sync;
   const int kTotalTasks = 500;
   int done = 0;
   thread_pool.Run(
       new SpawnTask(&thread_pool, &sync, kTotalTasks, kTotalTasks, &done));
   {
     MonitorLocker ml(&sync);
     while (done < kTotalTasks) {
       ml.Wait();
     }
   }
   EXPECT_EQ(kTotalTasks, done);
 }
 
 }  // namespace dart