New tests should be JUnit 5

Author: apurtell

hbase-server/src/test/java/org/apache/hadoop/hbase/io/devsim/TestEBSDeviceLayer.java

@@ -17,12 +17,11 @@
  */
 package org.apache.hadoop.hbase.io.devsim;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.IOException;
 import org.apache.hadoop.conf.Configuration;
-import org.apache.hadoop.hbase.HBaseClassTestRule;
 import org.apache.hadoop.hbase.HBaseConfiguration;
 import org.apache.hadoop.hbase.HBaseTestingUtil;
 import org.apache.hadoop.hbase.HConstants;
@@ -41,11 +40,10 @@
 import org.apache.hadoop.hbase.testclassification.MediumTests;
 import org.apache.hadoop.hbase.util.Bytes;
 import org.apache.hadoop.hdfs.MiniDFSCluster;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -58,13 +56,10 @@
  * device latency disabled. Writes data through HBase, flushes, reads it back via scan and get, and
  * asserts that the device layer metrics reflect the IO.
  */
-@Category({ IOTests.class, MediumTests.class })
+@Tag(IOTests.TAG)
+@Tag(MediumTests.TAG)
 public class TestEBSDeviceLayer {
 
-  @ClassRule
-  public static final HBaseClassTestRule CLASS_RULE =
-    HBaseClassTestRule.forClass(TestEBSDeviceLayer.class);
-
   private static final Logger LOG = LoggerFactory.getLogger(TestEBSDeviceLayer.class);
 
   private static final TableName TABLE_NAME = TableName.valueOf("TestEBSDeviceLayer");
@@ -76,7 +71,7 @@ public class TestEBSDeviceLayer {
 
   private static HBaseTestingUtil UTIL;
 
-  @BeforeClass
+  @BeforeAll
   public static void setUp() throws Exception {
     Configuration conf = HBaseConfiguration.create();
     conf.set(HConstants.HBASE_REGION_SPLIT_POLICY_KEY,
@@ -93,7 +88,7 @@ public static void setUp() throws Exception {
     UTIL.startMiniCluster(1);
   }
 
-  @AfterClass
+  @AfterAll
   public static void tearDown() throws Exception {
     EBSDevice.shutdown();
     if (UTIL != null) {
@@ -103,9 +98,9 @@ public static void tearDown() throws Exception {
 
   @Test
   public void testDeviceLayerInterceptsIO() throws Exception {
-    assertEquals("Expected 1 DataNode registered with EBSDevice", 1, EBSDevice.getNumDataNodes());
+    assertEquals(1, EBSDevice.getNumDataNodes(), "Expected 1 DataNode registered with EBSDevice");
     EBSDevice.DataNodeContext dnCtx = EBSDevice.getDataNodeContext(0);
-    assertEquals("Expected " + NUM_VOLUMES + " volumes", NUM_VOLUMES, dnCtx.getNumVolumes());
+    assertEquals(NUM_VOLUMES, dnCtx.getNumVolumes(), "Expected " + NUM_VOLUMES + " volumes");
 
     TableDescriptor desc = TableDescriptorBuilder.newBuilder(TABLE_NAME).setColumnFamily(
       ColumnFamilyDescriptorBuilder.newBuilder(FAMILY).setBlocksize(64 * 1024).build()).build();
@@ -132,23 +127,23 @@ public void testDeviceLayerInterceptsIO() throws Exception {
     LOG.info("After write+flush: bytesWritten={}, writeIntercepts={}, deviceWriteOps={}",
       writeBytesAfterFlush, writeInterceptsAfterFlush, EBSDevice.getDeviceWriteOps());
 
-    assertTrue("Expected write intercepts after flush, got " + writeInterceptsAfterFlush,
-      writeInterceptsAfterFlush > 0);
-    assertTrue("Expected bytes written > 0 after flush, got " + writeBytesAfterFlush,
-      writeBytesAfterFlush > 0);
+    assertTrue(writeInterceptsAfterFlush > 0,
+      "Expected write intercepts after flush, got " + writeInterceptsAfterFlush);
+    assertTrue(writeBytesAfterFlush > 0,
+      "Expected bytes written > 0 after flush, got " + writeBytesAfterFlush);
 
     EBSDevice.resetMetrics();
     int rowCount = 0;
     try (Table table = UTIL.getConnection().getTable(TABLE_NAME)) {
       try (ResultScanner scanner = table.getScanner(new Scan())) {
         Result result;
         while ((result = scanner.next()) != null) {
-          assertTrue("Row should not be empty", !result.isEmpty());
+          assertTrue(!result.isEmpty(), "Row should not be empty");
           rowCount++;
         }
       }
     }
-    assertEquals("Expected to read back all rows", NUM_ROWS, rowCount);
+    assertEquals(NUM_ROWS, rowCount, "Expected to read back all rows");
 
     long readBytes = EBSDevice.getTotalBytesRead();
     long readIntercepts = EBSDevice.getReadInterceptCount();
@@ -157,28 +152,29 @@ public void testDeviceLayerInterceptsIO() throws Exception {
     LOG.info("After scan: bytesRead={}, readIntercepts={}, appReadOps={}, deviceReadOps={}",
       readBytes, readIntercepts, readOps, deviceReadOps);
 
-    assertTrue("Expected read intercepts after scan, got " + readIntercepts, readIntercepts > 0);
-    assertTrue("Expected bytes read > 0 after scan, got " + readBytes, readBytes > 0);
-    assertTrue("Expected device read ops > 0 (IOPS coalescing should still produce ops), got "
-      + deviceReadOps, deviceReadOps > 0);
+    assertTrue(readIntercepts > 0, "Expected read intercepts after scan, got " + readIntercepts);
+    assertTrue(readBytes > 0, "Expected bytes read > 0 after scan, got " + readBytes);
+    assertTrue(deviceReadOps > 0,
+      "Expected device read ops > 0 (IOPS coalescing should still produce ops), got "
+        + deviceReadOps);
 
     EBSDevice.resetMetrics();
     try (Table table = UTIL.getConnection().getTable(TABLE_NAME)) {
       Result result = table.get(new Get(Bytes.toBytes("row-00050")));
-      assertTrue("Get should return data", !result.isEmpty());
+      assertTrue(!result.isEmpty(), "Get should return data");
     }
     long getReadIntercepts = EBSDevice.getReadInterceptCount();
     LOG.info("After get: readIntercepts={}, bytesRead={}", getReadIntercepts,
       EBSDevice.getTotalBytesRead());
-    assertTrue("Expected read intercepts after get, got " + getReadIntercepts,
-      getReadIntercepts > 0);
+    assertTrue(getReadIntercepts > 0,
+      "Expected read intercepts after get, got " + getReadIntercepts);
 
     long totalIntercepts = EBSDevice.getReadInterceptCount() + EBSDevice.getWriteInterceptCount();
     long unresolved = EBSDevice.getUnresolvedVolumeCount();
     if (totalIntercepts > 0) {
       double unresolvedRatio = (double) unresolved / totalIntercepts;
-      assertTrue("Unresolved volume ratio too high: " + unresolvedRatio + " (unresolved="
-        + unresolved + ", total=" + totalIntercepts + ")", unresolvedRatio <= 0.01);
+      assertTrue(unresolvedRatio <= 0.01, "Unresolved volume ratio too high: " + unresolvedRatio
+        + " (unresolved=" + unresolved + ", total=" + totalIntercepts + ")");
     }
 
     LOG.info("Per-volume stats: {}", EBSDevice.getPerVolumeStats());

hbase-server/src/test/java/org/apache/hadoop/hbase/io/devsim/TestIOBudget.java

@@ -17,22 +17,17 @@
  */
 package org.apache.hadoop.hbase.io.devsim;
 
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.apache.hadoop.hbase.HBaseClassTestRule;
 import org.apache.hadoop.hbase.testclassification.IOTests;
 import org.apache.hadoop.hbase.testclassification.SmallTests;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
 
-@Category({ IOTests.class, SmallTests.class })
+@Tag(IOTests.TAG)
+@Tag(SmallTests.TAG)
 public class TestIOBudget {
 
-  @ClassRule
-  public static final HBaseClassTestRule CLASS_RULE =
-    HBaseClassTestRule.forClass(TestIOBudget.class);
-
   @Test
   public void testLowRateModeDoesNotDeadlock() {
     IOBudget budget = new IOBudget(2, 100);
@@ -43,18 +38,18 @@ public void testLowRateModeDoesNotDeadlock() {
     long elapsedSecondTokenMs = System.currentTimeMillis() - t1;
 
     // At 2 tokens/sec, second token should require waiting roughly 500ms.
-    assertTrue("Expected low-rate budget to throttle second token, elapsed=" + elapsedSecondTokenMs,
-      elapsedSecondTokenMs >= 300);
-    assertTrue("Unexpectedly long low-rate throttle delay, elapsed=" + elapsedSecondTokenMs,
-      elapsedSecondTokenMs < 3000);
-    assertTrue("Clock sanity check", t1 >= t0);
+    assertTrue(elapsedSecondTokenMs >= 300,
+      "Expected low-rate budget to throttle second token, elapsed=" + elapsedSecondTokenMs);
+    assertTrue(elapsedSecondTokenMs < 3000,
+      "Unexpectedly long low-rate throttle delay, elapsed=" + elapsedSecondTokenMs);
+    assertTrue(t1 >= t0, "Clock sanity check");
   }
 
   @Test
   public void testRegularWindowModeStillThrottles() {
     // 100 tokens/sec with 100ms windows -> 10 tokens/window
     IOBudget budget = new IOBudget(100, 100);
     long elapsedMs = budget.consume(15);
-    assertTrue("Expected consume to sleep when exceeding window budget", elapsedMs > 0);
+    assertTrue(elapsedMs > 0, "Expected consume to sleep when exceeding window budget");
   }
 }