Disable heap growth during weak handle processing unit test in order to avoid triggering of old spa…

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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
@@ skipping 1277 matching lines @@
 
   // Make sure that the value transferred.
   EXPECT(Dart_IsBoolean(obj2));
   bool value = false;
   Dart_Handle result = Dart_BooleanValue(obj2, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
+// Helper class to ensure new gen GC is triggered without any side effects.
+// The normal call to CollectGarbage(Heap::kNew) could potentially trigger
+// an old gen collection if there is a promotion failure and this could
+// perturb the test.
+class GCTestHelper : public AllStatic {
+ public:
+  static void CollectNewSpace(Heap::ApiCallbacks api_callbacks) {
+    bool invoke_api_callbacks = (api_callbacks == Heap::kInvokeApiCallbacks);
+    Isolate::Current()->heap()->new_space_->Scavenge(invoke_api_callbacks);
+  }
+};
+
+
 // Only ia32 and x64 can run execution tests.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 
 TEST_CASE(WeakPersistentHandle) {
   Dart_Handle weak_new_ref = Dart_Null();
   EXPECT(Dart_IsNull(weak_new_ref));
 
   Dart_Handle weak_old_ref = Dart_Null();
   EXPECT(Dart_IsNull(weak_old_ref));
 
   {
     Dart_EnterScope();
 
-    // create an object in new space
+    // Create an object in new space.
     Dart_Handle new_ref = Dart_NewString("new string");
     EXPECT_VALID(new_ref);
 
-    // create an object in old space
+    // Create an object in old space.
     Dart_Handle old_ref;
     {
       Isolate* isolate = Isolate::Current();
       DARTSCOPE(isolate);
       old_ref = Api::NewHandle(isolate, String::New("old string", Heap::kOld));
       EXPECT_VALID(old_ref);
     }
 
-    // create a weak ref to the new space object
+    // Create a weak ref to the new space object.
     weak_new_ref = Dart_NewWeakPersistentHandle(new_ref, NULL, NULL);
     EXPECT_VALID(weak_new_ref);
     EXPECT(!Dart_IsNull(weak_new_ref));
 
-    // create a weak ref to the old space object
+    // Create a weak ref to the old space object.
     weak_old_ref = Dart_NewWeakPersistentHandle(old_ref, NULL, NULL);
     EXPECT_VALID(weak_old_ref);
     EXPECT(!Dart_IsNull(weak_old_ref));
 
-    // garbage collect new space
-    Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+    // Garbage collect new space.
+    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
-    // nothing should be invalidated or cleared
+    // Nothing should be invalidated or cleared.
     EXPECT_VALID(new_ref);
     EXPECT(!Dart_IsNull(new_ref));
     EXPECT_VALID(old_ref);
     EXPECT(!Dart_IsNull(old_ref));
 
     EXPECT_VALID(weak_new_ref);
     EXPECT(!Dart_IsNull(weak_new_ref));
     EXPECT(Dart_IdentityEquals(new_ref, weak_new_ref));
 
     EXPECT_VALID(weak_old_ref);
     EXPECT(!Dart_IsNull(weak_old_ref));
     EXPECT(Dart_IdentityEquals(old_ref, weak_old_ref));
 
-    // garbage collect old space
+    // Garbage collect old space.
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
 
-    // nothing should be invalidated or cleared
+    // Nothing should be invalidated or cleared.
     EXPECT_VALID(new_ref);
     EXPECT(!Dart_IsNull(new_ref));
     EXPECT_VALID(old_ref);
     EXPECT(!Dart_IsNull(old_ref));
 
     EXPECT_VALID(weak_new_ref);
     EXPECT(!Dart_IsNull(weak_new_ref));
     EXPECT(Dart_IdentityEquals(new_ref, weak_new_ref));
 
     EXPECT_VALID(weak_old_ref);
     EXPECT(!Dart_IsNull(weak_old_ref));
     EXPECT(Dart_IdentityEquals(old_ref, weak_old_ref));
 
-    // delete local (strong) references
+    // Delete local (strong) references.
     Dart_ExitScope();
   }
 
-  // garbage collect new space again
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+  // Garbage collect new space again.
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
-  // weak ref to new space object should now be cleared
+  // Weak ref to new space object should now be cleared.
   EXPECT_VALID(weak_new_ref);
   EXPECT(Dart_IsNull(weak_new_ref));
   EXPECT_VALID(weak_old_ref);
   EXPECT(!Dart_IsNull(weak_old_ref));
 
-  // garbage collect old space again
+  // Garbage collect old space again.
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
 
-  // weak ref to old space object should now be cleared
+  // Weak ref to old space object should now be cleared.
   EXPECT_VALID(weak_new_ref);
   EXPECT(Dart_IsNull(weak_new_ref));
   EXPECT_VALID(weak_old_ref);
   EXPECT(Dart_IsNull(weak_old_ref));
 
   Dart_DeletePersistentHandle(weak_new_ref);
   Dart_DeletePersistentHandle(weak_old_ref);
 
-  // garbage collect one last time to revisit deleted handles
+  // Garbage collect one last time to revisit deleted handles.
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
 }
 
 
 static void WeakPersistentHandlePeerFinalizer(Dart_Handle handle, void* peer) {
   *static_cast<int*>(peer) = 42;
 }
 
 
 TEST_CASE(WeakPersistentHandleCallback) {
   Dart_Handle weak_ref = Dart_Null();
   EXPECT(Dart_IsNull(weak_ref));
   int* peer = new int();
   {
     Dart_EnterScope();
     Dart_Handle obj = Dart_NewString("new string");
     EXPECT_VALID(obj);
     weak_ref = Dart_NewWeakPersistentHandle(obj, peer,
                                             WeakPersistentHandlePeerFinalizer);
     Dart_ExitScope();
   }
   EXPECT_VALID(weak_ref);
   EXPECT(*peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(*peer == 0);
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
   EXPECT(*peer == 42);
   delete peer;
   Dart_DeletePersistentHandle(weak_ref);
 }
 
 
 TEST_CASE(ObjectGroups) {
   Dart_Handle strong = Dart_Null();
   EXPECT(Dart_IsNull(strong));
 
@@ skipping 45 matching lines @@
   }
   Dart_ExitScope();
 
   EXPECT_VALID(strong);
 
   EXPECT_VALID(weak1);
   EXPECT_VALID(weak2);
   EXPECT_VALID(weak3);
   EXPECT_VALID(weak4);
 
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
   // New space collection should not affect old space objects
   EXPECT(!Dart_IsNull(weak1));
   EXPECT(!Dart_IsNull(weak2));
   EXPECT(!Dart_IsNull(weak3));
   EXPECT(!Dart_IsNull(weak4));
 
   {
     Dart_Handle array1[] = { weak1, strong };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
@@ skipping 143 matching lines @@
     EXPECT(!Dart_IsNull(old_pwph));
   }
   Dart_ExitScope();
   EXPECT_VALID(new_pwph);
   EXPECT(!Dart_IsNull(new_pwph));
   EXPECT(Dart_IsPrologueWeakPersistentHandle(new_pwph));
   EXPECT_VALID(old_pwph);
   EXPECT(!Dart_IsNull(old_pwph));
   EXPECT(Dart_IsPrologueWeakPersistentHandle(old_pwph));
   // Garbage collect new space without invoking API callbacks.
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew,
-                                             Heap::kIgnoreApiCallbacks);
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+
   // Both prologue weak handles should be preserved.
   EXPECT(!Dart_IsNull(new_pwph));
   EXPECT(!Dart_IsNull(old_pwph));
   // Garbage collect old space without invoking API callbacks.
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
                                              Heap::kIgnoreApiCallbacks);
   // Both prologue weak handles should be preserved.
   EXPECT(!Dart_IsNull(new_pwph));
   EXPECT(!Dart_IsNull(old_pwph));
   // Garbage collect new space invoking API callbacks.
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew,
-                                             Heap::kInvokeApiCallbacks);
+  GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
+
   // The prologue weak handle with a new space referent should now be
   // cleared.  The old space referent should be preserved.
   EXPECT(Dart_IsNull(new_pwph));
   EXPECT(!Dart_IsNull(old_pwph));
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
                                              Heap::kInvokeApiCallbacks);
   // The prologue weak handle with an old space referent should now be
   // cleared.  The new space referent should remain cleared.
   EXPECT(Dart_IsNull(new_pwph));
   EXPECT(Dart_IsNull(old_pwph));
@@ skipping 42 matching lines @@
     EXPECT_VALID(weak3);
   }
   Dart_ExitScope();
 
   EXPECT_VALID(strong);
 
   EXPECT_VALID(weak1);
   EXPECT_VALID(weak2);
   EXPECT_VALID(weak3);
 
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
   // New space collection should not affect old space objects
   EXPECT(!Dart_IsNull(weak1));
   EXPECT(!Dart_IsNull(weak2));
   EXPECT(!Dart_IsNull(weak3));
 
   // A strongly referenced key should preserve all the values.
   {
     Dart_Handle keys[] = { strong };
     Dart_Handle values[] = { weak1, weak2, weak3 };
@@ skipping 81 matching lines @@
   EXPECT(!Dart_IsNull(weak2));
   EXPECT(!Dart_IsNull(weak3));
 
   // A strongly referenced key should preserve all the values.
   {
     Dart_Handle keys[] = { strong };
     Dart_Handle values[] = { weak1, weak2, weak3 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(keys, ARRAY_SIZE(keys),
                                           values, ARRAY_SIZE(values)));
 
-    Isolate::Current()->heap()->CollectGarbage(Heap::kNew,
-                                               Heap::kInvokeApiCallbacks);
+    GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
   }
 
   // All weak references should be preserved.
   EXPECT(!Dart_IsNull(weak1));
   EXPECT(!Dart_IsNull(weak2));
   EXPECT(!Dart_IsNull(weak3));
 
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew,
-                                             Heap::kIgnoreApiCallbacks);
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
   // No weak references should be preserved.
   EXPECT(Dart_IsNull(weak1));
   EXPECT(Dart_IsNull(weak2));
   EXPECT(Dart_IsNull(weak3));
 }
 
 
 static int global_prologue_callback_status;
 
@@ skipping 100 matching lines @@
 
 
 TEST_CASE(SingleGarbageCollectionCallback) {
   // Add a prologue callback.
   EXPECT_VALID(Dart_AddGcPrologueCallback(&PrologueCallbackTimes2));
 
   // Garbage collect new space ignoring callbacks.  This should not
   // invoke the prologue callback.  No status values should change.
   global_prologue_callback_status = 3;
   global_epilogue_callback_status = 7;
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
   EXPECT_EQ(3, global_prologue_callback_status);
   EXPECT_EQ(7, global_epilogue_callback_status);
 
   // Garbage collect new space invoking callbacks.  This should
   // invoke the prologue callback.  No status values should change.
   global_prologue_callback_status = 3;
   global_epilogue_callback_status = 7;
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew,
-                                             Heap::kInvokeApiCallbacks);
+  GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
   EXPECT_EQ(6, global_prologue_callback_status);
   EXPECT_EQ(7, global_epilogue_callback_status);
 
   // Garbage collect old space ignoring callbacks.  This should invoke
   // the prologue callback.  The prologue status value should change.
   global_prologue_callback_status = 3;
   global_epilogue_callback_status = 7;
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
                                              Heap::kIgnoreApiCallbacks);
   EXPECT_EQ(3, global_prologue_callback_status);
@@ skipping 13 matching lines @@
   EXPECT_EQ(12, global_prologue_callback_status);
   EXPECT_EQ(7, global_epilogue_callback_status);
 
   // Add an epilogue callback.
   EXPECT_VALID(Dart_AddGcEpilogueCallback(&EpilogueCallbackTimes4));
 
   // Garbage collect new space.  This should not invoke the prologue
   // or the epilogue callback.  No status values should change.
   global_prologue_callback_status = 3;
   global_epilogue_callback_status = 7;
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
   EXPECT_EQ(3, global_prologue_callback_status);
   EXPECT_EQ(7, global_epilogue_callback_status);
 
   // Garbage collect new space.  This should invoke the prologue and
   // the epilogue callback.  The prologue and epilogue status values
   // should change.
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew,
-                                             Heap::kInvokeApiCallbacks);
+  GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
   EXPECT_EQ(6, global_prologue_callback_status);
   EXPECT_EQ(28, global_epilogue_callback_status);
 
   // Garbage collect old space.  This should invoke the prologue and
   // the epilogue callbacks.  The prologue and epilogue status values
   // should change.
   global_prologue_callback_status = 3;
   global_epilogue_callback_status = 7;
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT_EQ(6, global_prologue_callback_status);
@@ skipping 30 matching lines @@
   EXPECT_VALID(Dart_AddGcPrologueCallback(&PrologueCallbackTimes2));
   EXPECT_VALID(Dart_AddGcPrologueCallback(&PrologueCallbackTimes3));
 
   // Add an epilogue callback.
   EXPECT_VALID(Dart_AddGcEpilogueCallback(&EpilogueCallbackTimes4));
 
   // Garbage collect new space.  This should not invoke the prologue
   // or epilogue callbacks.  No status values should change.
   global_prologue_callback_status = 3;
   global_epilogue_callback_status = 7;
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
   EXPECT_EQ(3, global_prologue_callback_status);
   EXPECT_EQ(7, global_epilogue_callback_status);
 
   // Garbage collect old space.  This should invoke both prologue
   // callbacks and the epilogue callback.  The prologue and epilogue
   // status values should change.
   global_prologue_callback_status = 3;
   global_epilogue_callback_status = 7;
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT_EQ(18, global_prologue_callback_status);
@@ skipping 4078 matching lines @@
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(0, value);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart