Revert of Create our own blink_heap run_all_tests target to avoid piggy-backing on wtf's.

Source/heap/HeapTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 542 matching lines @@
         , m_weakBar(weakBar)
     {
     }
 
     Member<Bar> m_strongBar;
     WeakMember<Bar> m_weakBar;
 };
 
 TEST(HeapTest, Threading)
 {
+    Heap::init();
     ThreadedHeapTester::test();
+    Heap::shutdown();
+}
+
+TEST(HeapTest, Init)
+{
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner. This test can be removed
+    // when that is done.
+    Heap::init();
+    Heap::shutdown();
 }
 
 TEST(HeapTest, SimpleAllocation)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     // Get initial heap stats.
     HeapStats initialHeapStats;
     getHeapStats(&initialHeapStats);
     EXPECT_EQ(0ul, initialHeapStats.totalObjectSpace());
 
     // Allocate an object in the heap.
     HeapAllocatedArray* array = new HeapAllocatedArray();
     HeapStats statsAfterAllocation;
     getHeapStats(&statsAfterAllocation);
     EXPECT_TRUE(statsAfterAllocation.totalObjectSpace() >= sizeof(HeapAllocatedArray));
 
     // Sanity check of the contents in the heap.
     EXPECT_EQ(0, array->at(0));
     EXPECT_EQ(42, array->at(42));
     EXPECT_EQ(0, array->at(128));
     EXPECT_EQ(999 % 128, array->at(999));
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, SimplePersistent)
 {
-    Persistent<TraceCounter> traceCounter = TraceCounter::create();
-    EXPECT_EQ(0, traceCounter->traceCount());
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
-    EXPECT_EQ(1, traceCounter->traceCount());
+    {
+        Persistent<TraceCounter> traceCounter = TraceCounter::create();
+        EXPECT_EQ(0, traceCounter->traceCount());
 
-    Persistent<ClassWithMember> classWithMember = ClassWithMember::create();
-    EXPECT_EQ(0, classWithMember->traceCount());
+        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+        EXPECT_EQ(1, traceCounter->traceCount());
 
-    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
-    EXPECT_EQ(1, classWithMember->traceCount());
-    EXPECT_EQ(2, traceCounter->traceCount());
+        Persistent<ClassWithMember> classWithMember = ClassWithMember::create();
+        EXPECT_EQ(0, classWithMember->traceCount());
+
+        Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+        EXPECT_EQ(1, classWithMember->traceCount());
+        EXPECT_EQ(2, traceCounter->traceCount());
+    }
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, SimpleFinalization)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     {
         Persistent<SimpleFinalizedObject> finalized = SimpleFinalizedObject::create();
         EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
     }
 
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(1, SimpleFinalizedObject::s_destructorCalls);
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, TypedHeapSanity)
 {
-    // We use TraceCounter for allocating an object on the general heap.
-    Persistent<TraceCounter> generalHeapObject = TraceCounter::create();
-    Persistent<TestTypedHeapClass> typedHeapObject = TestTypedHeapClass::create();
-    EXPECT_NE(pageHeaderAddress(reinterpret_cast<Address>(generalHeapObject.get())),
-        pageHeaderAddress(reinterpret_cast<Address>(typedHeapObject.get())));
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
+    {
+        // We use TraceCounter for allocating an object on the general heap.
+        Persistent<TraceCounter> generalHeapObject = TraceCounter::create();
+        Persistent<TestTypedHeapClass> typedHeapObject = TestTypedHeapClass::create();
+        EXPECT_NE(pageHeaderAddress(reinterpret_cast<Address>(generalHeapObject.get())),
+            pageHeaderAddress(reinterpret_cast<Address>(typedHeapObject.get())));
+    }
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, NoAllocation)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     EXPECT_TRUE(ThreadState::current()->isAllocationAllowed());
     {
         // Disallow allocation
         NoAllocationScope<AnyThread> noAllocationScope;
         EXPECT_FALSE(ThreadState::current()->isAllocationAllowed());
     }
     EXPECT_TRUE(ThreadState::current()->isAllocationAllowed());
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, Members)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     Bar::s_live = 0;
     {
         Persistent<Baz> h1;
         Persistent<Baz> h2;
         {
             h1 = Baz::create(Bar::create());
             Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
             EXPECT_EQ(1u, Bar::s_live);
             h2 = Baz::create(Bar::create());
             Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
             EXPECT_EQ(2u, Bar::s_live);
         }
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(2u, Bar::s_live);
         h1->clear();
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(1u, Bar::s_live);
     }
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, Bar::s_live);
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, DeepTest)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     const unsigned depth = 100000;
     Bar::s_live = 0;
     {
         Bar* bar = Bar::create();
         EXPECT_TRUE(ThreadState::current()->contains(bar));
         Foo* foo = Foo::create(bar);
         EXPECT_TRUE(ThreadState::current()->contains(foo));
         EXPECT_EQ(2u, Bar::s_live);
         for (unsigned i = 0; i < depth; i++) {
             Foo* foo2 = Foo::create(foo);
             foo = foo2;
             EXPECT_TRUE(ThreadState::current()->contains(foo));
         }
         EXPECT_EQ(depth + 2, Bar::s_live);
         Heap::collectGarbage(ThreadState::HeapPointersOnStack);
         EXPECT_EQ(depth + 2, Bar::s_live);
     }
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, Bar::s_live);
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, WideTest)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     Bar::s_live = 0;
     {
         Bars* bars = Bars::create();
         unsigned width = Bars::width;
         EXPECT_EQ(width + 1, Bar::s_live);
         Heap::collectGarbage(ThreadState::HeapPointersOnStack);
         EXPECT_EQ(width + 1, Bar::s_live);
         // Use bars here to make sure that it will be on the stack
         // for the conservative stack scan to find.
         EXPECT_EQ(width, bars->getWidth());
     }
     EXPECT_EQ(Bars::width + 1, Bar::s_live);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, Bar::s_live);
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, HashMapOfMembers)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     HeapStats initialHeapSize;
     IntWrapper::s_destructorCalls = 0;
 
     clearOutOldGarbage(&initialHeapSize);
     {
         typedef HashMap<
             Member<IntWrapper>,
             Member<IntWrapper>,
             DefaultHash<Member<IntWrapper> >::Hash,
             HashTraits<Member<IntWrapper> >,
@@ skipping 62 matching lines @@
         getHeapStats(&afterGC3);
         EXPECT_TRUE(afterGC3.totalObjectSpace() < afterAdding1000.totalObjectSpace());
     }
 
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     // The objects 'one', anotherOne, and the 999 other pairs.
     EXPECT_EQ(IntWrapper::s_destructorCalls, 2000);
     HeapStats afterGC4;
     getHeapStats(&afterGC4);
     EXPECT_EQ(afterGC4.totalObjectSpace(), initialHeapSize.totalObjectSpace());
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, NestedAllocation)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     HeapStats initialHeapSize;
     clearOutOldGarbage(&initialHeapSize);
     {
         Persistent<ConstructorAllocation> constructorAllocation = ConstructorAllocation::create();
     }
     HeapStats afterFree;
     clearOutOldGarbage(&afterFree);
     EXPECT_TRUE(initialHeapSize == afterFree);
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, LargeObjects)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     HeapStats initialHeapSize;
     clearOutOldGarbage(&initialHeapSize);
     IntWrapper::s_destructorCalls = 0;
     LargeObject::s_destructorCalls = 0;
     {
         int slack = 8; // LargeObject points to an IntWrapper that is also allocated.
         Persistent<LargeObject> object = LargeObject::create();
         HeapStats afterAllocation;
         clearOutOldGarbage(&afterAllocation);
         {
@@ skipping 25 matching lines @@
         EXPECT_TRUE(oneLargeObject == afterAllocation);
         EXPECT_EQ(10, IntWrapper::s_destructorCalls);
         EXPECT_EQ(10, LargeObject::s_destructorCalls);
     }
     HeapStats backToInitial;
     clearOutOldGarbage(&backToInitial);
     EXPECT_TRUE(initialHeapSize == backToInitial);
     EXPECT_EQ(11, IntWrapper::s_destructorCalls);
     EXPECT_EQ(11, LargeObject::s_destructorCalls);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, RefCountedGarbageCollected)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     RefCountedAndGarbageCollected::s_destructorCalls = 0;
     {
         RefPtr<RefCountedAndGarbageCollected> refPtr3;
         {
             Persistent<RefCountedAndGarbageCollected> persistent;
             {
                 RefPtr<RefCountedAndGarbageCollected> refPtr1 = RefCountedAndGarbageCollected::create();
                 RefPtr<RefCountedAndGarbageCollected> refPtr2 = RefCountedAndGarbageCollected::create();
                 Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
                 EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
                 persistent = refPtr1.get();
             }
             // Reference count is zero for both objects but one of
             // them is kept alive by a persistent handle.
             Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
             EXPECT_EQ(1, RefCountedAndGarbageCollected::s_destructorCalls);
             refPtr3 = persistent;
         }
         // The persistent handle is gone but the ref count has been
         // increased to 1.
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(1, RefCountedAndGarbageCollected::s_destructorCalls);
     }
     // Both persistent handle is gone and ref count is zero so the
     // object can be collected.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(2, RefCountedAndGarbageCollected::s_destructorCalls);
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, WeakMembers)
 {
+    // FIXME: init and shutdown should be called via Blink
+    // initialization in the test runner.
+    Heap::init();
+
     Bar::s_live = 0;
     {
         Persistent<Bar> h1 = Bar::create();
         Persistent<Weak> h4;
         Persistent<WithWeakMember> h5;
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         ASSERT_EQ(1u, Bar::s_live); // h1 is live.
         {
             Bar* h2 = Bar::create();
             Bar* h3 = Bar::create();
@@ skipping 15 matching lines @@
         EXPECT_FALSE(h5->weakIsThere()); // h3 is gone from weak pointer.
         h1.release(); // Zero out h1.
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(3u, Bar::s_live); // Only h4, h5 and h2 are left.
         EXPECT_TRUE(h4->strongIsThere()); // h2 is still pointed to from h4.
         EXPECT_TRUE(h5->strongIsThere()); // h2 is still pointed to from h5.
     }
     // h4 and h5 have gone out of scope now and they were keeping h2 alive.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, Bar::s_live); // All gone.
+
+    Heap::shutdown();
 }
 
 TEST(HeapTest, Comparisons)
 {
-    Persistent<Bar> barPersistent = Bar::create();
-    Persistent<Foo> fooPersistent = Foo::create(barPersistent);
-    EXPECT_TRUE(barPersistent != fooPersistent);
-    barPersistent = fooPersistent;
-    EXPECT_TRUE(barPersistent == fooPersistent);
+    Heap::init();
+
+    {
+        Persistent<Bar> barPersistent = Bar::create();
+        Persistent<Foo> fooPersistent = Foo::create(barPersistent);
+        EXPECT_TRUE(barPersistent != fooPersistent);
+        barPersistent = fooPersistent;
+        EXPECT_TRUE(barPersistent == fooPersistent);
+    }
+
+    Heap::shutdown();
 }
 
 DEFINE_GC_INFO(Bar);
 DEFINE_GC_INFO(Baz);
 DEFINE_GC_INFO(ClassWithMember);
 DEFINE_GC_INFO(ConstructorAllocation);
 DEFINE_GC_INFO(HeapAllocatedArray);
 DEFINE_GC_INFO(IntWrapper);
 DEFINE_GC_INFO(LargeObject);
 DEFINE_GC_INFO(RefCountedAndGarbageCollected);
 DEFINE_GC_INFO(SimpleFinalizedObject);
 DEFINE_GC_INFO(TestTypedHeapClass);
 DEFINE_GC_INFO(TraceCounter);
 
 } // namespace