Convert compiler cctest to unittests: SchedulerTest

test/unittests/compiler/scheduler-unittest.cc

Index: test/unittests/compiler/scheduler-unittest.cc
diff --git a/test/cctest/compiler/test-scheduler.cc b/test/unittests/compiler/scheduler-unittest.cc
similarity index 87%
rename from test/cctest/compiler/test-scheduler.cc
rename to test/unittests/compiler/scheduler-unittest.cc
index 1b79ed5449d546ee11c8a23b5356d16b9e8f6e16..c73b6e849a1f79ad695ef6999bc9be7b0fd7cfaa 100644
--- a/test/cctest/compiler/test-scheduler.cc
+++ b/test/unittests/compiler/scheduler-unittest.cc
@@ -16,11 +16,18 @@
 #include "src/compiler/scheduler.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/verifier.h"
-#include "test/cctest/cctest.h"
+#include "test/unittests/test-utils.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
+namespace {
+
+class SchedulerTest : public TestWithZone {
+ public:
+  SchedulerTest() {}
+};
+
 Operator kIntAdd(IrOpcode::kInt32Add, Operator::kPure, "Int32Add", 2, 0, 0, 1,
                  0, 0);
 
@@ -121,36 +128,30 @@ static Schedule* ComputeAndVerifySchedule(int expected, Graph* graph) {
   return schedule;
 }
 
+}  // namespace
 
-TEST(RPODegenerate1) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
-
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+TEST_F(SchedulerTest, RPODegenerate1) {
+  Schedule schedule(zone());
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 1, false);
   CHECK_EQ(schedule.start(), order->at(0));
 }
 
 
-TEST(RPODegenerate2) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPODegenerate2) {
+  Schedule schedule(zone());
 
   schedule.AddGoto(schedule.start(), schedule.end());
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 2, false);
   CHECK_EQ(schedule.start(), order->at(0));
   CHECK_EQ(schedule.end(), order->at(1));
 }
 
 
-TEST(RPOLine) {
-  HandleAndZoneScope scope;
-
+TEST_F(SchedulerTest, RPOLine) {
   for (int i = 0; i < 10; i++) {
-    Schedule schedule(scope.main_zone());
+    Schedule schedule(zone());
 
     BasicBlock* last = schedule.start();
     for (int j = 0; j < i; j++) {
@@ -159,8 +160,7 @@ TEST(RPOLine) {
       schedule.AddGoto(last, block);
       last = block;
     }
-    BasicBlockVector* order =
-        Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+    BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
     CheckRPONumbers(order, 1 + i, false);
 
     for (size_t i = 0; i < schedule.BasicBlockCount(); i++) {
@@ -173,60 +173,51 @@ TEST(RPOLine) {
 }
 
 
-TEST(RPOSelfLoop) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOSelfLoop) {
+  Schedule schedule(zone());
   schedule.AddSuccessorForTesting(schedule.start(), schedule.start());
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 1, true);
   BasicBlock* loop[] = {schedule.start()};
   CheckLoop(order, loop, 1);
 }
 
 
-TEST(RPOEntryLoop) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOEntryLoop) {
+  Schedule schedule(zone());
   BasicBlock* body = schedule.NewBasicBlock();
   schedule.AddSuccessorForTesting(schedule.start(), body);
   schedule.AddSuccessorForTesting(body, schedule.start());
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 2, true);
   BasicBlock* loop[] = {schedule.start(), body};
   CheckLoop(order, loop, 2);
 }
 
 
-TEST(RPOEndLoop) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOEndLoop) {
+  Schedule schedule(zone());
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2));
   schedule.AddSuccessorForTesting(schedule.start(), loop1->header());
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 3, true);
   loop1->Check(order);
 }
 
 
-TEST(RPOEndLoopNested) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOEndLoopNested) {
+  Schedule schedule(zone());
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2));
   schedule.AddSuccessorForTesting(schedule.start(), loop1->header());
   schedule.AddSuccessorForTesting(loop1->last(), schedule.start());
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 3, true);
   loop1->Check(order);
 }
 
 
-TEST(RPODiamond) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPODiamond) {
+  Schedule schedule(zone());
 
   BasicBlock* A = schedule.start();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -238,8 +229,7 @@ TEST(RPODiamond) {
   schedule.AddSuccessorForTesting(B, D);
   schedule.AddSuccessorForTesting(C, D);
 
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 4, false);
 
   CHECK_EQ(0, A->rpo_number());
@@ -249,9 +239,8 @@ TEST(RPODiamond) {
 }
 
 
-TEST(RPOLoop1) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOLoop1) {
+  Schedule schedule(zone());
 
   BasicBlock* A = schedule.start();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -263,17 +252,15 @@ TEST(RPOLoop1) {
   schedule.AddSuccessorForTesting(C, B);
   schedule.AddSuccessorForTesting(C, D);
 
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 4, true);
   BasicBlock* loop[] = {B, C};
   CheckLoop(order, loop, 2);
 }
 
 
-TEST(RPOLoop2) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOLoop2) {
+  Schedule schedule(zone());
 
   BasicBlock* A = schedule.start();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -285,19 +272,16 @@ TEST(RPOLoop2) {
   schedule.AddSuccessorForTesting(C, B);
   schedule.AddSuccessorForTesting(B, D);
 
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 4, true);
   BasicBlock* loop[] = {B, C};
   CheckLoop(order, loop, 2);
 }
 
 
-TEST(RPOLoopN) {
-  HandleAndZoneScope scope;
-
+TEST_F(SchedulerTest, RPOLoopN) {
   for (int i = 0; i < 11; i++) {
-    Schedule schedule(scope.main_zone());
+    Schedule schedule(zone());
     BasicBlock* A = schedule.start();
     BasicBlock* B = schedule.NewBasicBlock();
     BasicBlock* C = schedule.NewBasicBlock();
@@ -328,8 +312,7 @@ TEST(RPOLoopN) {
     if (i == 9) schedule.AddSuccessorForTesting(E, G);
     if (i == 10) schedule.AddSuccessorForTesting(F, G);
 
-    BasicBlockVector* order =
-        Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+    BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
     CheckRPONumbers(order, 7, true);
     BasicBlock* loop[] = {B, C, D, E, F};
     CheckLoop(order, loop, 5);
@@ -337,9 +320,8 @@ TEST(RPOLoopN) {
 }
 
 
-TEST(RPOLoopNest1) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOLoopNest1) {
+  Schedule schedule(zone());
 
   BasicBlock* A = schedule.start();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -356,8 +338,7 @@ TEST(RPOLoopNest1) {
   schedule.AddSuccessorForTesting(E, B);
   schedule.AddSuccessorForTesting(E, F);
 
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 6, true);
   BasicBlock* loop1[] = {B, C, D, E};
   CheckLoop(order, loop1, 4);
@@ -367,9 +348,8 @@ TEST(RPOLoopNest1) {
 }
 
 
-TEST(RPOLoopNest2) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOLoopNest2) {
+  Schedule schedule(zone());
 
   BasicBlock* A = schedule.start();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -392,8 +372,7 @@ TEST(RPOLoopNest2) {
   schedule.AddSuccessorForTesting(F, C);
   schedule.AddSuccessorForTesting(G, B);
 
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 8, true);
   BasicBlock* loop1[] = {B, C, D, E, F, G};
   CheckLoop(order, loop1, 6);
@@ -406,9 +385,8 @@ TEST(RPOLoopNest2) {
 }
 
 
-TEST(RPOLoopFollow1) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOLoopFollow1) {
+  Schedule schedule(zone());
 
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1));
   SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1));
@@ -420,8 +398,7 @@ TEST(RPOLoopFollow1) {
   schedule.AddSuccessorForTesting(loop1->header(), loop2->header());
   schedule.AddSuccessorForTesting(loop2->last(), E);
 
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
 
   CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
            static_cast<int>(order->size()));
@@ -431,9 +408,8 @@ TEST(RPOLoopFollow1) {
 }
 
 
-TEST(RPOLoopFollow2) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOLoopFollow2) {
+  Schedule schedule(zone());
 
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1));
   SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1));
@@ -447,8 +423,7 @@ TEST(RPOLoopFollow2) {
   schedule.AddSuccessorForTesting(S, loop2->header());
   schedule.AddSuccessorForTesting(loop2->last(), E);
 
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
 
   CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
            static_cast<int>(order->size()));
@@ -457,12 +432,10 @@ TEST(RPOLoopFollow2) {
 }
 
 
-TEST(RPOLoopFollowN) {
-  HandleAndZoneScope scope;
-
+TEST_F(SchedulerTest, RPOLoopFollowN) {
   for (int size = 1; size < 5; size++) {
     for (int exit = 0; exit < size; exit++) {
-      Schedule schedule(scope.main_zone());
+      Schedule schedule(zone());
       SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size));
       SmartPointer<TestLoop> loop2(CreateLoop(&schedule, size));
       BasicBlock* A = schedule.start();
@@ -471,8 +444,7 @@ TEST(RPOLoopFollowN) {
       schedule.AddSuccessorForTesting(A, loop1->header());
       schedule.AddSuccessorForTesting(loop1->nodes[exit], loop2->header());
       schedule.AddSuccessorForTesting(loop2->nodes[exit], E);
-      BasicBlockVector* order =
-          Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+      BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
 
       CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
                static_cast<int>(order->size()));
@@ -483,9 +455,8 @@ TEST(RPOLoopFollowN) {
 }
 
 
-TEST(RPONestedLoopFollow1) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPONestedLoopFollow1) {
+  Schedule schedule(zone());
 
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1));
   SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1));
@@ -502,8 +473,7 @@ TEST(RPONestedLoopFollow1) {
   schedule.AddSuccessorForTesting(C, E);
   schedule.AddSuccessorForTesting(C, B);
 
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
 
   CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
            static_cast<int>(order->size()));
@@ -515,13 +485,11 @@ TEST(RPONestedLoopFollow1) {
 }
 
 
-TEST(RPOLoopBackedges1) {
-  HandleAndZoneScope scope;
-
+TEST_F(SchedulerTest, RPOLoopBackedges1) {
   int size = 8;
   for (int i = 0; i < size; i++) {
     for (int j = 0; j < size; j++) {
-      Schedule schedule(scope.main_zone());
+      Schedule schedule(zone());
       BasicBlock* A = schedule.start();
       BasicBlock* E = schedule.end();
 
@@ -532,8 +500,7 @@ TEST(RPOLoopBackedges1) {
       schedule.AddSuccessorForTesting(loop1->nodes[i], loop1->header());
       schedule.AddSuccessorForTesting(loop1->nodes[j], E);
 
-      BasicBlockVector* order =
-          Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+      BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
       CheckRPONumbers(order, schedule.BasicBlockCount(), true);
       loop1->Check(order);
     }
@@ -541,13 +508,11 @@ TEST(RPOLoopBackedges1) {
 }
 
 
-TEST(RPOLoopOutedges1) {
-  HandleAndZoneScope scope;
-
+TEST_F(SchedulerTest, RPOLoopOutedges1) {
   int size = 8;
   for (int i = 0; i < size; i++) {
     for (int j = 0; j < size; j++) {
-      Schedule schedule(scope.main_zone());
+      Schedule schedule(zone());
       BasicBlock* A = schedule.start();
       BasicBlock* D = schedule.NewBasicBlock();
       BasicBlock* E = schedule.end();
@@ -560,8 +525,7 @@ TEST(RPOLoopOutedges1) {
       schedule.AddSuccessorForTesting(loop1->nodes[j], D);
       schedule.AddSuccessorForTesting(D, E);
 
-      BasicBlockVector* order =
-          Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+      BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
       CheckRPONumbers(order, schedule.BasicBlockCount(), true);
       loop1->Check(order);
     }
@@ -569,12 +533,10 @@ TEST(RPOLoopOutedges1) {
 }
 
 
-TEST(RPOLoopOutedges2) {
-  HandleAndZoneScope scope;
-
+TEST_F(SchedulerTest, RPOLoopOutedges2) {
   int size = 8;
   for (int i = 0; i < size; i++) {
-    Schedule schedule(scope.main_zone());
+    Schedule schedule(zone());
     BasicBlock* A = schedule.start();
     BasicBlock* E = schedule.end();
 
@@ -588,20 +550,17 @@ TEST(RPOLoopOutedges2) {
       schedule.AddSuccessorForTesting(O, E);
     }
 
-    BasicBlockVector* order =
-        Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+    BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
     CheckRPONumbers(order, schedule.BasicBlockCount(), true);
     loop1->Check(order);
   }
 }
 
 
-TEST(RPOLoopOutloops1) {
-  HandleAndZoneScope scope;
-
+TEST_F(SchedulerTest, RPOLoopOutloops1) {
   int size = 8;
   for (int i = 0; i < size; i++) {
-    Schedule schedule(scope.main_zone());
+    Schedule schedule(zone());
     BasicBlock* A = schedule.start();
     BasicBlock* E = schedule.end();
     SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size));
@@ -615,8 +574,7 @@ TEST(RPOLoopOutloops1) {
       schedule.AddSuccessorForTesting(loopN[j]->last(), E);
     }
 
-    BasicBlockVector* order =
-        Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+    BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
     CheckRPONumbers(order, schedule.BasicBlockCount(), true);
     loop1->Check(order);
 
@@ -629,9 +587,8 @@ TEST(RPOLoopOutloops1) {
 }
 
 
-TEST(RPOLoopMultibackedge) {
-  HandleAndZoneScope scope;
-  Schedule schedule(scope.main_zone());
+TEST_F(SchedulerTest, RPOLoopMultibackedge) {
+  Schedule schedule(zone());
 
   BasicBlock* A = schedule.start();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -647,8 +604,7 @@ TEST(RPOLoopMultibackedge) {
   schedule.AddSuccessorForTesting(D, B);
   schedule.AddSuccessorForTesting(E, B);
 
-  BasicBlockVector* order =
-      Scheduler::ComputeSpecialRPO(scope.main_zone(), &schedule);
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule);
   CheckRPONumbers(order, 5, true);
 
   BasicBlock* loop1[] = {B, C, D, E};
@@ -656,21 +612,19 @@ TEST(RPOLoopMultibackedge) {
 }
 
 
-TEST(BuildScheduleEmpty) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder builder(scope.main_zone());
+TEST_F(SchedulerTest, BuildScheduleEmpty) {
+  Graph graph(zone());
+  CommonOperatorBuilder builder(zone());
   graph.SetStart(graph.NewNode(builder.Start(0)));
   graph.SetEnd(graph.NewNode(builder.End(), graph.start()));
 
-  USE(Scheduler::ComputeSchedule(scope.main_zone(), &graph));
+  USE(Scheduler::ComputeSchedule(zone(), &graph));
 }
 
 
-TEST(BuildScheduleOneParameter) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder builder(scope.main_zone());
+TEST_F(SchedulerTest, BuildScheduleOneParameter) {
+  Graph graph(zone());
+  CommonOperatorBuilder builder(zone());
   graph.SetStart(graph.NewNode(builder.Start(0)));
 
   Node* p1 = graph.NewNode(builder.Parameter(0), graph.start());
@@ -678,15 +632,14 @@ TEST(BuildScheduleOneParameter) {
 
   graph.SetEnd(graph.NewNode(builder.End(), ret));
 
-  USE(Scheduler::ComputeSchedule(scope.main_zone(), &graph));
+  USE(Scheduler::ComputeSchedule(zone(), &graph));
 }
 
 
-TEST(BuildScheduleIfSplit) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder builder(scope.main_zone());
-  JSOperatorBuilder js_builder(scope.main_zone());
+TEST_F(SchedulerTest, BuildScheduleIfSplit) {
+  Graph graph(zone());
+  CommonOperatorBuilder builder(zone());
+  JSOperatorBuilder js_builder(zone());
   graph.SetStart(graph.NewNode(builder.Start(3)));
 
   Node* p1 = graph.NewNode(builder.Parameter(0), graph.start());
@@ -709,16 +662,14 @@ TEST(BuildScheduleIfSplit) {
 }
 
 
-TEST(BuildScheduleIfSplitWithEffects) {
-  HandleAndZoneScope scope;
-  Isolate* isolate = scope.main_isolate();
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common_builder(scope.main_zone());
-  JSOperatorBuilder js_builder(scope.main_zone());
+TEST_F(SchedulerTest, BuildScheduleIfSplitWithEffects) {
+  Graph graph(zone());
+  CommonOperatorBuilder common_builder(zone());
+  JSOperatorBuilder js_builder(zone());
   const Operator* op;
 
   Handle<HeapObject> object =

[Michael Starzinger, 2015/01/22 16:10:36]

I am not an expert on how the unit-tests should be structured, but should be
have helper methods providing these objects? Maybe Benedikt has an opinion.

[danno, 2015/01/23 16:51:36]

Done.

-      Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+      Handle<HeapObject>(isolate()->heap()->undefined_value(), isolate());
   Unique<HeapObject> unique_constant =
       Unique<HeapObject>::CreateUninitialized(object);
 
@@ -855,16 +806,14 @@ TEST(BuildScheduleIfSplitWithEffects) {
 }
 
 
-TEST(BuildScheduleSimpleLoop) {
-  HandleAndZoneScope scope;
-  Isolate* isolate = scope.main_isolate();
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common_builder(scope.main_zone());
-  JSOperatorBuilder js_builder(scope.main_zone());
+TEST_F(SchedulerTest, BuildScheduleSimpleLoop) {
+  Graph graph(zone());
+  CommonOperatorBuilder common_builder(zone());
+  JSOperatorBuilder js_builder(zone());
   const Operator* op;
 
   Handle<HeapObject> object =
-      Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+      Handle<HeapObject>(isolate()->heap()->undefined_value(), isolate());
   Unique<HeapObject> unique_constant =
       Unique<HeapObject>::CreateUninitialized(object);
 
@@ -968,16 +917,14 @@ TEST(BuildScheduleSimpleLoop) {
 }
 
 
-TEST(BuildScheduleComplexLoops) {
-  HandleAndZoneScope scope;
-  Isolate* isolate = scope.main_isolate();
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common_builder(scope.main_zone());
-  JSOperatorBuilder js_builder(scope.main_zone());
+TEST_F(SchedulerTest, BuildScheduleComplexLoops) {
+  Graph graph(zone());
+  CommonOperatorBuilder common_builder(zone());
+  JSOperatorBuilder js_builder(zone());
   const Operator* op;
 
   Handle<HeapObject> object =
-      Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+      Handle<HeapObject>(isolate()->heap()->undefined_value(), isolate());
   Unique<HeapObject> unique_constant =
       Unique<HeapObject>::CreateUninitialized(object);
 
@@ -1216,16 +1163,14 @@ TEST(BuildScheduleComplexLoops) {
 }
 
 
-TEST(BuildScheduleBreakAndContinue) {
-  HandleAndZoneScope scope;
-  Isolate* isolate = scope.main_isolate();
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common_builder(scope.main_zone());
-  JSOperatorBuilder js_builder(scope.main_zone());
+TEST_F(SchedulerTest, BuildScheduleBreakAndContinue) {
+  Graph graph(zone());
+  CommonOperatorBuilder common_builder(zone());
+  JSOperatorBuilder js_builder(zone());
   const Operator* op;
 
   Handle<HeapObject> object =
-      Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+      Handle<HeapObject>(isolate()->heap()->undefined_value(), isolate());
   Unique<HeapObject> unique_constant =
       Unique<HeapObject>::CreateUninitialized(object);
 
@@ -1546,16 +1491,14 @@ TEST(BuildScheduleBreakAndContinue) {
 }
 
 
-TEST(BuildScheduleSimpleLoopWithCodeMotion) {
-  HandleAndZoneScope scope;
-  Isolate* isolate = scope.main_isolate();
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common_builder(scope.main_zone());
-  JSOperatorBuilder js_builder(scope.main_zone());
+TEST_F(SchedulerTest, BuildScheduleSimpleLoopWithCodeMotion) {
+  Graph graph(zone());
+  CommonOperatorBuilder common_builder(zone());
+  JSOperatorBuilder js_builder(zone());
   const Operator* op;
 
   Handle<HeapObject> object =
-      Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+      Handle<HeapObject>(isolate()->heap()->undefined_value(), isolate());
   Unique<HeapObject> unique_constant =
       Unique<HeapObject>::CreateUninitialized(object);
 
@@ -1688,10 +1631,9 @@ static Node* CreateDiamond(Graph* graph, CommonOperatorBuilder* common,
 }
 
 
-TEST(FloatingDiamond1) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, FloatingDiamond1) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(1));
   graph.SetStart(start);
@@ -1707,10 +1649,9 @@ TEST(FloatingDiamond1) {
 }
 
 
-TEST(FloatingDiamond2) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, FloatingDiamond2) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
@@ -1729,10 +1670,9 @@ TEST(FloatingDiamond2) {
 }
 
 
-TEST(FloatingDiamond3) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, FloatingDiamond3) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
@@ -1752,11 +1692,10 @@ TEST(FloatingDiamond3) {
 }
 
 
-TEST(NestedFloatingDiamonds) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
-  SimplifiedOperatorBuilder simplified(scope.main_zone());
+TEST_F(SchedulerTest, NestedFloatingDiamonds) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
+  SimplifiedOperatorBuilder simplified(zone());
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
@@ -1793,10 +1732,9 @@ TEST(NestedFloatingDiamonds) {
 }
 
 
-TEST(NestedFloatingDiamondWithChain) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, NestedFloatingDiamondWithChain) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
@@ -1839,10 +1777,9 @@ TEST(NestedFloatingDiamondWithChain) {
 }
 
 
-TEST(NestedFloatingDiamondWithLoop) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, NestedFloatingDiamondWithLoop) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
@@ -1877,10 +1814,9 @@ TEST(NestedFloatingDiamondWithLoop) {
 }
 
 
-TEST(LoopedFloatingDiamond1) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, LoopedFloatingDiamond1) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
@@ -1914,10 +1850,9 @@ TEST(LoopedFloatingDiamond1) {
 }
 
 
-TEST(LoopedFloatingDiamond2) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, LoopedFloatingDiamond2) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
@@ -1952,10 +1887,9 @@ TEST(LoopedFloatingDiamond2) {
 }
 
 
-TEST(LoopedFloatingDiamond3) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, LoopedFloatingDiamond3) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
@@ -2002,10 +1936,9 @@ TEST(LoopedFloatingDiamond3) {
 }
 
 
-TEST(PhisPushedDownToDifferentBranches) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, PhisPushedDownToDifferentBranches) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
@@ -2039,10 +1972,9 @@ TEST(PhisPushedDownToDifferentBranches) {
 }
 
 
-TEST(BranchHintTrue) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, BranchHintTrue) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(1));
   graph.SetStart(start);
@@ -2067,10 +1999,9 @@ TEST(BranchHintTrue) {
 }
 
 
-TEST(BranchHintFalse) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, BranchHintFalse) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(1));
   graph.SetStart(start);
@@ -2095,10 +2026,9 @@ TEST(BranchHintFalse) {
 }
 
 
-TEST(ScheduleTerminate) {
-  HandleAndZoneScope scope;
-  Graph graph(scope.main_zone());
-  CommonOperatorBuilder common(scope.main_zone());
+TEST_F(SchedulerTest, ScheduleTerminate) {
+  Graph graph(zone());
+  CommonOperatorBuilder common(zone());
 
   Node* start = graph.NewNode(common.Start(1));
   graph.SetStart(start);