[test] Turn compiler/test-node-cache into a unit test.

R=jarin@chromium.org
TEST=unittests/NodeCacheTest

Review URL: https://codereview.chromium.org/1114903002

Cr-Commit-Position: refs/heads/master@{#28136}

test/cctest/cctest.gyp

@@ -69,7 +69,6 @@
         'compiler/test-loop-assignment-analysis.cc',
         'compiler/test-loop-analysis.cc',
         'compiler/test-machine-operator-reducer.cc',
-        'compiler/test-node-cache.cc',
         'compiler/test-node.cc',
         'compiler/test-operator.cc',
         'compiler/test-osr.cc',

test/cctest/compiler/test-node-cache.cc → test/unittests/compiler/node-cache-unittest.cc

@@ -2,174 +2,158 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "src/v8.h"
-
-#include "graph-tester.h"
-#include "src/compiler/common-operator.h"
 #include "src/compiler/node-cache.h"
+#include "test/unittests/compiler/graph-unittest.h"
+#include "test/unittests/test-utils.h"
+#include "testing/gmock-support.h"
+
+using testing::Contains;
+
+namespace v8 {
+namespace internal {
+namespace compiler {
 
-using namespace v8::internal;
-using namespace v8::internal::compiler;
+typedef GraphTest NodeCacheTest;
 
-TEST(Int32Constant_back_to_back) {
-  GraphTester graph;
+TEST_F(NodeCacheTest, Int32Constant_back_to_back) {
   Int32NodeCache cache;
 
   for (int i = -2000000000; i < 2000000000; i += 3315177) {
-    Node** pos = cache.Find(graph.zone(), i);
-    CHECK(pos);
+    Node** pos = cache.Find(zone(), i);
+    ASSERT_TRUE(pos != nullptr);
     for (int j = 0; j < 3; j++) {
-      Node** npos = cache.Find(graph.zone(), i);
-      CHECK_EQ(pos, npos);
+      Node** npos = cache.Find(zone(), i);
+      EXPECT_EQ(pos, npos);
     }
   }
 }
 
 
-TEST(Int32Constant_five) {
-  GraphTester graph;
+TEST_F(NodeCacheTest, Int32Constant_five) {
   Int32NodeCache cache;
-  CommonOperatorBuilder common(graph.zone());
-
   int32_t constants[] = {static_cast<int32_t>(0x80000000), -77, 0, 1, -1};
-
   Node* nodes[arraysize(constants)];
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     int32_t k = constants[i];
-    Node* node = graph.NewNode(common.Int32Constant(k));
-    *cache.Find(graph.zone(), k) = nodes[i] = node;
+    Node* node = graph()->NewNode(common()->Int32Constant(k));
+    *cache.Find(zone(), k) = nodes[i] = node;
   }
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     int32_t k = constants[i];
-    CHECK_EQ(nodes[i], *cache.Find(graph.zone(), k));
+    EXPECT_EQ(nodes[i], *cache.Find(zone(), k));
   }
 }
 
 
-TEST(Int32Constant_hits) {
-  GraphTester graph;
+TEST_F(NodeCacheTest, Int32Constant_hits) {
   Int32NodeCache cache;
   const int32_t kSize = 1500;
-  Node** nodes = graph.zone()->NewArray<Node*>(kSize);
-  CommonOperatorBuilder common(graph.zone());
+  Node** nodes = zone()->NewArray<Node*>(kSize);
 
   for (int i = 0; i < kSize; i++) {
     int32_t v = i * -55;
-    nodes[i] = graph.NewNode(common.Int32Constant(v));
-    *cache.Find(graph.zone(), v) = nodes[i];
+    nodes[i] = graph()->NewNode(common()->Int32Constant(v));
+    *cache.Find(zone(), v) = nodes[i];
   }
 
   int hits = 0;
   for (int i = 0; i < kSize; i++) {
     int32_t v = i * -55;
-    Node** pos = cache.Find(graph.zone(), v);
+    Node** pos = cache.Find(zone(), v);
     if (*pos != NULL) {
-      CHECK_EQ(nodes[i], *pos);
+      EXPECT_EQ(nodes[i], *pos);
       hits++;
     }
   }
-  CHECK_LT(4, hits);
+  EXPECT_LT(4, hits);
 }
 
 
-TEST(Int64Constant_back_to_back) {
-  GraphTester graph;
+TEST_F(NodeCacheTest, Int64Constant_back_to_back) {
   Int64NodeCache cache;
 
   for (int64_t i = -2000000000; i < 2000000000; i += 3315177) {
-    Node** pos = cache.Find(graph.zone(), i);
-    CHECK(pos);
+    Node** pos = cache.Find(zone(), i);
+    ASSERT_TRUE(pos != nullptr);
     for (int j = 0; j < 3; j++) {
-      Node** npos = cache.Find(graph.zone(), i);
-      CHECK_EQ(pos, npos);
+      Node** npos = cache.Find(zone(), i);
+      EXPECT_EQ(pos, npos);
     }
   }
 }
 
 
-TEST(Int64Constant_hits) {
-  GraphTester graph;
+TEST_F(NodeCacheTest, Int64Constant_hits) {
   Int64NodeCache cache;
   const int32_t kSize = 1500;
-  Node** nodes = graph.zone()->NewArray<Node*>(kSize);
-  CommonOperatorBuilder common(graph.zone());
+  Node** nodes = zone()->NewArray<Node*>(kSize);
 
   for (int i = 0; i < kSize; i++) {
     int64_t v = static_cast<int64_t>(i) * static_cast<int64_t>(5003001);
-    nodes[i] = graph.NewNode(common.Int32Constant(i));
-    *cache.Find(graph.zone(), v) = nodes[i];
+    nodes[i] = graph()->NewNode(common()->Int32Constant(i));
+    *cache.Find(zone(), v) = nodes[i];
   }
 
   int hits = 0;
   for (int i = 0; i < kSize; i++) {
     int64_t v = static_cast<int64_t>(i) * static_cast<int64_t>(5003001);
-    Node** pos = cache.Find(graph.zone(), v);
+    Node** pos = cache.Find(zone(), v);
     if (*pos != NULL) {
-      CHECK_EQ(nodes[i], *pos);
+      EXPECT_EQ(nodes[i], *pos);
       hits++;
     }
   }
-  CHECK_LT(4, hits);
-}
-
-
-static bool Contains(ZoneVector<Node*>* nodes, Node* n) {
-  for (size_t i = 0; i < nodes->size(); i++) {
-    if (nodes->at(i) == n) return true;
-  }
-  return false;
+  EXPECT_LT(4, hits);
 }
 
 
-TEST(NodeCache_GetCachedNodes_int32) {
-  GraphTester graph;
+TEST_F(NodeCacheTest, GetCachedNodes_int32) {
   Int32NodeCache cache;
-  CommonOperatorBuilder common(graph.zone());
-
   int32_t constants[] = {0, 311, 12,  13,  14,  555, -555, -44, -33, -22, -11,
                          0, 311, 311, 412, 412, 11,  11,   -33, -33, -22, -11};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     int32_t k = constants[i];
-    Node** pos = cache.Find(graph.zone(), k);
+    Node** pos = cache.Find(zone(), k);
     if (*pos != NULL) {
-      ZoneVector<Node*> nodes(graph.zone());
+      ZoneVector<Node*> nodes(zone());
       cache.GetCachedNodes(&nodes);
-      CHECK(Contains(&nodes, *pos));
+      EXPECT_THAT(nodes, Contains(*pos));
     } else {
-      ZoneVector<Node*> nodes(graph.zone());
-      Node* n = graph.NewNode(common.Int32Constant(k));
+      ZoneVector<Node*> nodes(zone());
+      Node* n = graph()->NewNode(common()->Int32Constant(k));
       *pos = n;
       cache.GetCachedNodes(&nodes);
-      CHECK(Contains(&nodes, n));
+      EXPECT_THAT(nodes, Contains(n));
     }
   }
 }
 
 
-TEST(NodeCache_GetCachedNodes_int64) {
-  GraphTester graph;
+TEST_F(NodeCacheTest, GetCachedNodes_int64) {
   Int64NodeCache cache;
-  CommonOperatorBuilder common(graph.zone());
-
   int64_t constants[] = {0, 311, 12,  13,  14,  555, -555, -44, -33, -22, -11,
                          0, 311, 311, 412, 412, 11,  11,   -33, -33, -22, -11};
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     int64_t k = constants[i];
-    Node** pos = cache.Find(graph.zone(), k);
+    Node** pos = cache.Find(zone(), k);
     if (*pos != NULL) {
-      ZoneVector<Node*> nodes(graph.zone());
+      ZoneVector<Node*> nodes(zone());
       cache.GetCachedNodes(&nodes);
-      CHECK(Contains(&nodes, *pos));
+      EXPECT_THAT(nodes, Contains(*pos));
     } else {
-      ZoneVector<Node*> nodes(graph.zone());
-      Node* n = graph.NewNode(common.Int64Constant(k));
+      ZoneVector<Node*> nodes(zone());
+      Node* n = graph()->NewNode(common()->Int64Constant(k));
       *pos = n;
       cache.GetCachedNodes(&nodes);
-      CHECK(Contains(&nodes, n));
+      EXPECT_THAT(nodes, Contains(n));
     }
   }
 }
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8

test/unittests/unittests.gyp

@@ -64,6 +64,7 @@
         'compiler/machine-operator-reducer-unittest.cc',
         'compiler/machine-operator-unittest.cc',
         'compiler/move-optimizer-unittest.cc',
+        'compiler/node-cache-unittest.cc',
         'compiler/node-matchers-unittest.cc',
         'compiler/node-properties-unittest.cc',
         'compiler/node-test-utils.cc',