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

runtime/vm/dart_api_impl_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 "bin/builtin.h"
 #include "vm/compiler.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 2468 matching lines @@
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 42);
   }
 }
 
 
 // Unit test for entering a scope, creating a local handle and exiting
 // the scope.
-UNIT_TEST_CASE(EnterExitScope) {
+VM_UNIT_TEST_CASE(EnterExitScope) {
   TestIsolateScope __test_isolate__;
 
   Thread* thread = Thread::Current();
   EXPECT(thread != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   Dart_EnterScope();
   {
     EXPECT(thread->api_top_scope() != NULL);
     HANDLESCOPE(thread);
     const String& str1 = String::Handle(String::New("Test String"));
     Dart_Handle ref = Api::NewHandle(thread, str1.raw());
     String& str2 = String::Handle();
     str2 ^= Api::UnwrapHandle(ref);
     EXPECT(str1.Equals(str2));
   }
   Dart_ExitScope();
   EXPECT(scope == thread->api_top_scope());
 }
 
 
 // Unit test for creating and deleting persistent handles.
-UNIT_TEST_CASE(PersistentHandles) {
+VM_UNIT_TEST_CASE(PersistentHandles) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestCase::CreateTestIsolate();
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   Dart_PersistentHandle handles[2000];
@@ skipping 48 matching lines @@
     }
   }
   EXPECT(scope == thread->api_top_scope());
   EXPECT_EQ(2001, state->CountPersistentHandles());
   Dart_ShutdownIsolate();
 }
 
 
 // Test that we are able to create a persistent handle from a
 // persistent handle.
-UNIT_TEST_CASE(NewPersistentHandle_FromPersistentHandle) {
+VM_UNIT_TEST_CASE(NewPersistentHandle_FromPersistentHandle) {
   TestIsolateScope __test_isolate__;
 
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   Thread* thread = Thread::Current();
   CHECK_API_SCOPE(thread);
   HANDLESCOPE(thread);
 
@@ skipping 10 matching lines @@
   Dart_Handle obj4 = Dart_HandleFromPersistent(obj3);
   EXPECT(Dart_IsBoolean(obj4));
   bool value = false;
   Dart_Handle result = Dart_BooleanValue(obj4, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
 // Test that we can assign to a persistent handle.
-UNIT_TEST_CASE(AssignToPersistentHandle) {
+VM_UNIT_TEST_CASE(AssignToPersistentHandle) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestIsolateScope __test_isolate__;
 
   Thread* T = Thread::Current();
   CHECK_API_SCOPE(T);
   HANDLESCOPE(T);
   Isolate* isolate = T->isolate();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
@@ skipping 237 matching lines @@
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT(peer == 0);
     GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 0);
   }
 }
 
 
-UNIT_TEST_CASE(WeakPersistentHandlesCallbackShutdown) {
+VM_UNIT_TEST_CASE(WeakPersistentHandlesCallbackShutdown) {
   TestCase::CreateTestIsolate();
   Dart_EnterScope();
   Dart_Handle ref = Dart_True();
   int peer = 1234;
   Dart_NewWeakPersistentHandle(ref, &peer, 0,
                                WeakPersistentHandlePeerFinalizer);
   Dart_ExitScope();
   Dart_ShutdownIsolate();
   EXPECT(peer == 42);
 }
@@ skipping 476 matching lines @@
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT_EQ(3, global_prologue_callback_status);
     EXPECT_EQ(7, global_epilogue_callback_status);
   }
 }
 
 
 // Unit test for creating multiple scopes and local handles within them.
 // Ensure that the local handles get all cleaned out when exiting the
 // scope.
-UNIT_TEST_CASE(LocalHandles) {
+VM_UNIT_TEST_CASE(LocalHandles) {
   TestCase::CreateTestIsolate();
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   EXPECT(isolate != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   Dart_Handle handles[300];
   {
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Smi& val = Smi::Handle();
@@ skipping 43 matching lines @@
   }
   EXPECT_EQ(0, thread->CountLocalHandles());
   EXPECT(scope == thread->api_top_scope());
   Dart_ShutdownIsolate();
 }
 
 
 // Unit test for creating multiple scopes and allocating objects in the
 // zone for the scope. Ensure that the memory is freed when the scope
 // exits.
-UNIT_TEST_CASE(LocalZoneMemory) {
+VM_UNIT_TEST_CASE(LocalZoneMemory) {
   TestCase::CreateTestIsolate();
   Thread* thread = Thread::Current();
   EXPECT(thread != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   {
     // Start a new scope and allocate some memory.
     Dart_EnterScope();
     for (int i = 0; i < 100; i++) {
       Dart_ScopeAllocate(16);
     }
@@ skipping 21 matching lines @@
     }
     EXPECT_EQ(1600, thread->ZoneSizeInBytes());
     Dart_ExitScope();
   }
   EXPECT_EQ(0, thread->ZoneSizeInBytes());
   EXPECT(scope == thread->api_top_scope());
   Dart_ShutdownIsolate();
 }
 
 
-UNIT_TEST_CASE(Isolates) {
+VM_UNIT_TEST_CASE(Isolates) {
   // This test currently assumes that the Dart_Isolate type is an opaque
   // representation of Isolate*.
   Dart_Isolate iso_1 = TestCase::CreateTestIsolate();
   EXPECT_EQ(iso_1, Api::CastIsolate(Isolate::Current()));
   Dart_Isolate isolate = Dart_CurrentIsolate();
   EXPECT_EQ(iso_1, isolate);
   Dart_ExitIsolate();
   EXPECT(NULL == Dart_CurrentIsolate());
   Dart_Isolate iso_2 = TestCase::CreateTestIsolate();
   EXPECT_EQ(iso_2, Dart_CurrentIsolate());
   Dart_ExitIsolate();
   EXPECT(NULL == Dart_CurrentIsolate());
   Dart_EnterIsolate(iso_2);
   EXPECT_EQ(iso_2, Dart_CurrentIsolate());
   Dart_ShutdownIsolate();
   EXPECT(NULL == Dart_CurrentIsolate());
   Dart_EnterIsolate(iso_1);
   EXPECT_EQ(iso_1, Dart_CurrentIsolate());
   Dart_ShutdownIsolate();
   EXPECT(NULL == Dart_CurrentIsolate());
 }
 
 
-UNIT_TEST_CASE(CurrentIsolateData) {
+VM_UNIT_TEST_CASE(CurrentIsolateData) {
   intptr_t mydata = 12345;
   char* err;
   Dart_Isolate isolate =
       Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_data,
                          bin::core_isolate_snapshot_instructions, NULL,
                          reinterpret_cast<void*>(mydata), &err);
   EXPECT(isolate != NULL);
   EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_CurrentIsolateData()));
   EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_IsolateData(isolate)));
   Dart_ShutdownIsolate();
 }
 
 
-UNIT_TEST_CASE(IsolateSetCheckedMode) {
+VM_UNIT_TEST_CASE(IsolateSetCheckedMode) {
   const char* kScriptChars =
       "int bad1() {\n"
       "  int foo = 'string';\n"
       "  return foo;\n"
       "}\n"
       "\n"
       "int good1() {\n"
       "  int five = 5;\n"
       "  return five;"
       "}\n";
@@ skipping 46 matching lines @@
 TEST_CASE(DebugName) {
   Dart_Handle debug_name = Dart_DebugName();
   EXPECT_VALID(debug_name);
   EXPECT(Dart_IsString(debug_name));
 }
 
 
 static void MyMessageNotifyCallback(Dart_Isolate dest_isolate) {}
 
 
-UNIT_TEST_CASE(SetMessageCallbacks) {
+VM_UNIT_TEST_CASE(SetMessageCallbacks) {
   Dart_Isolate dart_isolate = TestCase::CreateTestIsolate();
   Dart_SetMessageNotifyCallback(&MyMessageNotifyCallback);
   Isolate* isolate = reinterpret_cast<Isolate*>(dart_isolate);
   EXPECT_EQ(&MyMessageNotifyCallback, isolate->message_notify_callback());
   Dart_ShutdownIsolate();
 }
 
 
 TEST_CASE(SetStickyError) {
   const char* kScriptChars = "main() => throw 'HI';";
@@ skipping 3601 matching lines @@
 }
 
 
 TEST_CASE(IllegalPost) {
   Dart_Handle message = Dart_True();
   bool success = Dart_Post(ILLEGAL_PORT, message);
   EXPECT(!success);
 }
 
 
-UNIT_TEST_CASE(NewNativePort) {
+VM_UNIT_TEST_CASE(NewNativePort) {
   // Create a port with a bogus handler.
   Dart_Port error_port = Dart_NewNativePort("Foo", NULL, true);
   EXPECT_EQ(ILLEGAL_PORT, error_port);
 
   // Create the port w/o a current isolate, just to make sure that works.
   Dart_Port port_id1 =
       Dart_NewNativePort("Port123", NewNativePort_send123, true);
 
   TestIsolateScope __test_isolate__;
   const char* kScriptChars =
@@ skipping 301 matching lines @@
     EXPECT_VALID(result);
   }
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
   Isolate::SetCreateCallback(saved);
 }
 
 
-UNIT_TEST_CASE(RunLoop_Success) {
+VM_UNIT_TEST_CASE(RunLoop_Success) {
   RunLoopTest(false);
 }
 
 
-UNIT_TEST_CASE(RunLoop_Exception) {
+VM_UNIT_TEST_CASE(RunLoop_Exception) {
   RunLoopTest(true);
 }
 
 
 // Utility functions and variables for test case IsolateInterrupt starts here.
 static Monitor* sync = NULL;
 static Dart_Isolate shared_isolate = NULL;
 static bool main_entered = false;
 
 
@@ skipping 72 matching lines @@
     ml.Notify();
   }
 }
 
 
 static void* saved_callback_data;
 static void IsolateShutdownTestCallback(void* callback_data) {
   saved_callback_data = callback_data;
 }
 
-UNIT_TEST_CASE(IsolateShutdown) {
+VM_UNIT_TEST_CASE(IsolateShutdown) {
   Dart_IsolateShutdownCallback saved = Isolate::ShutdownCallback();
   Isolate::SetShutdownCallback(IsolateShutdownTestCallback);
 
   saved_callback_data = NULL;
 
   void* my_data = reinterpret_cast<void*>(12345);
 
   // Create an isolate.
   char* err;
   Dart_Isolate isolate = Dart_CreateIsolate(
@@ skipping 27 matching lines @@
   Dart_Handle arg2 = Dart_NewInteger(9);
   EXPECT_VALID(arg2);
   Dart_Handle dart_args[2] = {arg1, arg2};
   Dart_Handle result = Dart_Invoke(lib, NewString("add"), 2, dart_args);
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &add_result);
   EXPECT_VALID(result);
   Dart_ExitScope();
 }
 
-UNIT_TEST_CASE(IsolateShutdownRunDartCode) {
+VM_UNIT_TEST_CASE(IsolateShutdownRunDartCode) {
   const char* kScriptChars =
       "int add(int a, int b) {\n"
       "  return a + b;\n"
       "}\n"
       "\n"
       "void main() {\n"
       "  add(4, 5);\n"
       "}\n";
 
   // Create an isolate.
@@ skipping 2236 matching lines @@
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
   result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT(Dart_IsError(result));
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart