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

runtime/vm/unit_test.h

 // Copyright (c) 2011, 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.
 
 #ifndef RUNTIME_VM_UNIT_TEST_H_
 #define RUNTIME_VM_UNIT_TEST_H_
 
 #include "include/dart_native_api.h"
 
 #include "platform/globals.h"
@@ skipping 10 matching lines @@
 #include "vm/simulator.h"
 #include "vm/zone.h"
 
 // The UNIT_TEST_CASE macro is used for tests that do not need any
 // default isolate or zone functionality.
 #define UNIT_TEST_CASE(name)                                                   \
   void Dart_Test##name();                                                      \
   static const dart::TestCase kRegister##name(Dart_Test##name, #name);         \
   void Dart_Test##name()
 
+// The RAW_UNIT_TEST_CASE macro is used for tests that do not require any of the
+// functionality provided by the VM. Tests declared using this macro will be run
+// before the VM is initialized.
+#define RAW_UNIT_TEST_CASE(name)                                               \
+  void Dart_Test##name();                                                      \
+  static const dart::RawTestCase kRegister##name(Dart_Test##name, #name);      \
+  void Dart_Test##name()
+
 // The VM_TEST_CASE macro is used for tests that need an isolate and zone
 // in order to test its functionality. This macro is used for tests that
 // are implemented using the VM code directly and do not use the Dart API
 // for calling into the VM. The safepoint execution state of threads using
 // this macro is transitioned from kThreadInNative to kThreadInVM.
 #define VM_TEST_CASE(name)                                                     \
   static void Dart_TestHelper##name(Thread* thread);                           \
   UNIT_TEST_CASE(name) {                                                       \
     TestIsolateScope __test_isolate__;                                         \
     Thread* __thread__ = Thread::Current();                                    \
@@ skipping 213 matching lines @@
  public:
   explicit TestCaseBase(const char* name);
   virtual ~TestCaseBase() {}
 
   const char* name() const { return name_; }
 
   virtual void Run() = 0;
   void RunTest();
 
   static void RunAll();
+  static void RunAllRaw();
+
+ protected:
+  bool raw_test_;
 
  private:
   static TestCaseBase* first_;
   static TestCaseBase* tail_;
 
   TestCaseBase* next_;
   const char* name_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCaseBase);
 };
@@ skipping 42 matching lines @@
   static void AddTestLib(const char* url, const char* source);
   static const char* GetTestLib(const char* url);
 
  private:
   static Dart_Isolate CreateIsolate(const uint8_t* buffer, const char* name);
 
   RunEntry* const run_;
 };
 
 
+class RawTestCase : TestCaseBase {
+ public:
+  typedef void(RunEntry)();
+
+  RawTestCase(RunEntry* run, const char* name) : TestCaseBase(name), run_(run) {
+    raw_test_ = true;
+  }
+  virtual void Run();
+
+ private:
+  RunEntry* const run_;
+};
+
+
 class TestIsolateScope {
  public:
   TestIsolateScope() {
     isolate_ = reinterpret_cast<Isolate*>(TestCase::CreateTestIsolate());
     Dart_EnterScope();  // Create a Dart API scope for unit tests.
   }
   ~TestIsolateScope() {
     Dart_ExitScope();  // Exit the Dart API scope created for unit tests.
     ASSERT(isolate_ == Isolate::Current());
     Dart_ShutdownIsolate();
@@ skipping 278 matching lines @@
   ~SetFlagScope() { *flag_ = original_value_; }
 
  private:
   T* flag_;
   T original_value_;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_UNIT_TEST_H_