8165602: Convert TestChunkedList_test to GTest

Reviewed-by: iignatyev, dfazunen

hotspot/src/share/vm/utilities/internalVMTests.cpp

@@ -60,7 +60,6 @@ void InternalVMTests::run() {
   run_unit_test(TestBitMap_test);
   run_unit_test(TestResourcehash_test);
   run_unit_test(ObjectMonitor_test);
-  run_unit_test(TestChunkedList_test);
   run_unit_test(JSON_test);
   run_unit_test(Test_log_tag_combinations_limit);
   run_unit_test(Test_logtarget);

hotspot/test/native/utilities/test_chunkedList.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -19,42 +19,40 @@
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
- *
  */
 
 #include "precompiled.hpp"
+#include "unittest.hpp"
 #include "utilities/chunkedList.hpp"
-#include "utilities/debug.hpp"
 
-/////////////// Unit tests ///////////////
-
-#ifndef PRODUCT
+class Metadata;
 
 template <typename T>
 class TestChunkedList {
   typedef ChunkedList<T, mtOther> ChunkedListT;
 
  public:
+
   static void testEmpty() {
     ChunkedListT buffer;
-    assert(buffer.size() == 0, "assert");
+    ASSERT_EQ((size_t) 0, buffer.size());
   }
 
   static void testFull() {
     ChunkedListT buffer;
     for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
-      buffer.push((T)i);
+      buffer.push((T) i);
     }
-    assert(buffer.size() == ChunkedListT::BufferSize, "assert");
-    assert(buffer.is_full(), "assert");
+    ASSERT_EQ((size_t) ChunkedListT::BufferSize, buffer.size());
+    ASSERT_TRUE(buffer.is_full());
   }
 
   static void testSize() {
     ChunkedListT buffer;
     for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
-      assert(buffer.size() == i, "assert");
-      buffer.push((T)i);
-      assert(buffer.size() == i + 1, "assert");
+      ASSERT_EQ((size_t) i, buffer.size());
+      buffer.push((T) i);
+      ASSERT_EQ((size_t) (i + 1), buffer.size());
     }
   }
 
@@ -62,48 +60,71 @@ class TestChunkedList {
     ChunkedListT buffer;
 
     buffer.clear();
-    assert(buffer.size() == 0, "assert");
+    ASSERT_EQ((size_t) 0, buffer.size());
 
     for (uintptr_t i = 0; i < ChunkedListT::BufferSize / 2; i++) {
-      buffer.push((T)i);
+      buffer.push((T) i);
     }
     buffer.clear();
-    assert(buffer.size() == 0, "assert");
+    ASSERT_EQ((size_t) 0, buffer.size());
 
     for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
-      buffer.push((T)i);
+      buffer.push((T) i);
     }
     buffer.clear();
-    assert(buffer.size() == 0, "assert");
+    ASSERT_EQ((size_t) 0, buffer.size());
   }
 
   static void testAt() {
     ChunkedListT buffer;
 
     for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
-      buffer.push((T)i);
-      assert(buffer.at(i) == (T)i, "assert");
+      buffer.push((T) i);
+      ASSERT_EQ((T) i, buffer.at(i));
     }
 
     for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) {
-      assert(buffer.at(i) == (T)i, "assert");
+      ASSERT_EQ((T) i, buffer.at(i));
     }
   }
-
-  static void test() {
-    testEmpty();
-    testFull();
-    testSize();
-    testClear();
-    testAt();
-  }
 };
 
-class Metadata;
-
-void TestChunkedList_test() {
-  TestChunkedList<Metadata*>::test();
-  TestChunkedList<size_t>::test();
+TEST(ChunkedList, metadata_empty) {
+  TestChunkedList<Metadata*>::testEmpty();
 }
 
-#endif
+TEST(ChunkedList, metadata_full) {
+  TestChunkedList<Metadata*>::testFull();
+}
+
+TEST(ChunkedList, metadata_size) {
+  TestChunkedList<Metadata*>::testSize();
+}
+
+TEST(ChunkedList, metadata_clear) {
+  TestChunkedList<Metadata*>::testSize();
+}
+
+TEST(ChunkedList, metadata_at) {
+  TestChunkedList<Metadata*>::testAt();
+}
+
+TEST(ChunkedList, size_t_empty) {
+  TestChunkedList<size_t>::testEmpty();
+}
+
+TEST(ChunkedList, size_t_full) {
+  TestChunkedList<size_t>::testFull();
+}
+
+TEST(ChunkedList, size_t_size) {
+  TestChunkedList<size_t>::testSize();
+}
+
+TEST(ChunkedList, size_t_clear) {
+  TestChunkedList<size_t>::testSize();
+}
+
+TEST(ChunkedList, size_t_at) {
+  TestChunkedList<size_t>::testAt();
+}