This is an automated email from the ASF dual-hosted git repository. zhangduo pushed a commit to branch branch--3 in repository https://gitbox.apache.org/repos/asf/hbase.git
commit 87d57be47735c000f3e052f358427d7eaad02a8f Author: Liu Xiao <[email protected]> AuthorDate: Thu Feb 12 23:55:30 2026 +0800 HBASE-29879 Upgrade hbase-procedure to use junit5 (#7727) Signed-off-by: Duo Zhang <[email protected]> (cherry picked from commit 4ee0f4520ac7fe18365d665cc4868f049d62b837) --- hbase-procedure/pom.xml | 5 -- .../hbase/procedure2/ProcedureTestingUtility.java | 37 ++++++----- .../hbase/procedure2/TestChildProcedures.java | 35 +++++------ .../hbase/procedure2/TestForceUpdateProcedure.java | 52 +++++++--------- .../hadoop/hbase/procedure2/TestLockAndQueue.java | 17 ++--- .../hbase/procedure2/TestProcedureBypass.java | 38 +++++------- .../hbase/procedure2/TestProcedureCleanup.java | 33 +++++----- .../hbase/procedure2/TestProcedureEvents.java | 25 +++----- .../hbase/procedure2/TestProcedureExecution.java | 59 +++++++++--------- .../hbase/procedure2/TestProcedureExecutor.java | 33 +++++----- .../procedure2/TestProcedureInMemoryChore.java | 31 ++++------ .../hbase/procedure2/TestProcedureMetrics.java | 72 ++++++++++------------ .../hbase/procedure2/TestProcedureNonce.java | 39 ++++++------ .../hbase/procedure2/TestProcedureRecovery.java | 29 ++++----- .../hbase/procedure2/TestProcedureReplayOrder.java | 33 +++++----- .../procedure2/TestProcedureRollbackAIOOB.java | 36 +++++------ .../TestProcedureSchedulerConcurrency.java | 20 +++--- .../procedure2/TestProcedureSkipPersistence.java | 24 +++----- .../hbase/procedure2/TestProcedureSuspended.java | 48 +++++++-------- .../hbase/procedure2/TestProcedureToString.java | 15 ++--- .../hadoop/hbase/procedure2/TestProcedureUtil.java | 27 ++++---- ...rocedureDispatcherUncaughtExceptionHandler.java | 39 +++++------- .../hadoop/hbase/procedure2/TestStackIdHoles.java | 21 +++---- .../procedure2/TestStateMachineProcedure.java | 28 ++++----- .../hbase/procedure2/TestYieldProcedures.java | 36 +++++------ .../hbase/procedure2/store/TestProcedureTree.java | 16 ++--- .../hbase/procedure2/store/wal/TestBitSetNode.java | 19 +++--- .../store/wal/TestProcedureStoreTracker.java | 31 +++++----- .../store/wal/TestStressWALProcedureStore.java | 31 ++++------ .../store/wal/TestWALProcedureStore.java | 55 ++++++++--------- .../hbase/procedure2/util/TestDelayedUtil.java | 19 +++--- 31 files changed, 434 insertions(+), 569 deletions(-) diff --git a/hbase-procedure/pom.xml b/hbase-procedure/pom.xml index 58759881c8e..835b3430fc3 100644 --- a/hbase-procedure/pom.xml +++ b/hbase-procedure/pom.xml @@ -91,11 +91,6 @@ <artifactId>junit-jupiter-params</artifactId> <scope>test</scope> </dependency> - <dependency> - <groupId>org.junit.vintage</groupId> - <artifactId>junit-vintage-engine</artifactId> - <scope>test</scope> - </dependency> <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-metrics-api</artifactId> diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/ProcedureTestingUtility.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/ProcedureTestingUtility.java index 32be56e44db..1efab6f5d3a 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/ProcedureTestingUtility.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/ProcedureTestingUtility.java @@ -17,9 +17,12 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.ArrayList; @@ -264,8 +267,8 @@ public final class ProcedureTestingUtility { if ( procExecutor.testing.killBeforeStoreUpdate || procExecutor.testing.toggleKillBeforeStoreUpdate ) { - assertEquals("expected only one executor running during test with kill/restart", 1, - procExecutor.getCorePoolSize()); + assertEquals(1, procExecutor.getCorePoolSize(), + "expected only one executor running during test with kill/restart"); } } @@ -342,48 +345,48 @@ public final class ProcedureTestingUtility { public static <TEnv> void assertProcNotYetCompleted(ProcedureExecutor<TEnv> procExecutor, long procId) { - assertFalse("expected a running proc", procExecutor.isFinished(procId)); - assertEquals(null, procExecutor.getResult(procId)); + assertFalse(procExecutor.isFinished(procId), "expected a running proc"); + assertNull(procExecutor.getResult(procId)); } public static <TEnv> void assertProcNotFailed(ProcedureExecutor<TEnv> procExecutor, long procId) { Procedure<?> result = procExecutor.getResult(procId); - assertTrue("expected procedure result", result != null); + assertNotNull(result, "expected procedure result"); assertProcNotFailed(result); } public static void assertProcNotFailed(final Procedure<?> result) { - assertFalse("found exception: " + result.getException(), result.isFailed()); + assertFalse(result.isFailed(), "found exception: " + result.getException()); } public static <TEnv> Throwable assertProcFailed(final ProcedureExecutor<TEnv> procExecutor, final long procId) { Procedure<?> result = procExecutor.getResult(procId); - assertTrue("expected procedure result", result != null); + assertNotNull(result, "expected procedure result"); return assertProcFailed(result); } public static Throwable assertProcFailed(final Procedure<?> result) { - assertEquals(true, result.isFailed()); + assertTrue(result.isFailed()); LOG.info("procId=" + result.getProcId() + " exception: " + result.getException().getMessage()); return getExceptionCause(result); } public static void assertIsAbortException(final Procedure<?> result) { Throwable cause = assertProcFailed(result); - assertTrue("expected abort exception, got " + cause, - cause instanceof ProcedureAbortedException); + assertInstanceOf(ProcedureAbortedException.class, cause, + "expected abort exception, got " + cause); } public static void assertIsTimeoutException(final Procedure<?> result) { Throwable cause = assertProcFailed(result); - assertTrue("expected TimeoutIOException, got " + cause, cause instanceof TimeoutIOException); + assertInstanceOf(TimeoutIOException.class, cause, "expected TimeoutIOException, got " + cause); } public static void assertIsIllegalArgumentException(final Procedure<?> result) { Throwable cause = assertProcFailed(result); - assertTrue("expected IllegalArgumentIOException, got " + cause, - cause instanceof IllegalArgumentIOException); + assertInstanceOf(IllegalArgumentIOException.class, cause, + "expected IllegalArgumentIOException, got " + cause); } public static Throwable getExceptionCause(final Procedure<?> procInfo) { @@ -669,7 +672,7 @@ public final class ProcedureTestingUtility { runnable.add(proc); } if (procIds != null) { - assertTrue("procId=" + procId + " unexpected", procIds.contains(procId)); + assertTrue(procIds.contains(procId), "procId=" + procId + " unexpected"); } } } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestChildProcedures.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestChildProcedures.java index 7aaa8b04bb1..1d804588d94 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestChildProcedures.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestChildProcedures.java @@ -17,32 +17,27 @@ */ package org.apache.hadoop.hbase.procedure2; -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.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestChildProcedures { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestChildProcedures.class); - private static final Logger LOG = LoggerFactory.getLogger(TestChildProcedures.class); private static final int PROCEDURE_EXECUTOR_SLOTS = 1; @@ -56,7 +51,7 @@ public class TestChildProcedures { private Path testDir; private Path logDir; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); testDir = htu.getDataTestDir(); @@ -72,7 +67,7 @@ public class TestChildProcedures { ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -88,7 +83,7 @@ public class TestChildProcedures { ProcedureTestingUtility.restart(procExecutor); ProcedureTestingUtility.waitProcedure(procExecutor, proc); - assertTrue("expected completed proc", procExecutor.isFinished(procId)); + assertTrue(procExecutor.isFinished(procId), "expected completed proc"); ProcedureTestingUtility.assertProcNotFailed(procExecutor, procId); } @@ -105,7 +100,7 @@ public class TestChildProcedures { restartCount++; } assertEquals(3, restartCount); - assertTrue("expected completed proc", procExecutor.isFinished(procId)); + assertTrue(procExecutor.isFinished(procId), "expected completed proc"); ProcedureTestingUtility.assertProcNotFailed(procExecutor, procId); } @@ -126,7 +121,7 @@ public class TestChildProcedures { restartCount++; } assertEquals(4, restartCount); - assertTrue("expected completed proc", procExecutor.isFinished(procId)); + assertTrue(procExecutor.isFinished(procId), "expected completed proc"); ProcedureTestingUtility.assertProcNotFailed(procExecutor, procId); } @@ -161,9 +156,9 @@ public class TestChildProcedures { } private void assertProcFailed(long procId) { - assertTrue("expected completed proc", procExecutor.isFinished(procId)); + assertTrue(procExecutor.isFinished(procId), "expected completed proc"); Procedure<?> result = procExecutor.getResult(procId); - assertEquals(true, result.isFailed()); + assertTrue(result.isFailed()); LOG.info(result.getException().getMessage()); } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestForceUpdateProcedure.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestForceUpdateProcedure.java index 50f2b1ba033..d5791aff63f 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestForceUpdateProcedure.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestForceUpdateProcedure.java @@ -17,62 +17,55 @@ */ package org.apache.hadoop.hbase.procedure2; -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 java.util.HashMap; import java.util.Map; import java.util.concurrent.Exchanger; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.NoopProcedure; import org.apache.hadoop.hbase.procedure2.store.wal.WALProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestForceUpdateProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestForceUpdateProcedure.class); - - private static HBaseCommonTestingUtil UTIL = new HBaseCommonTestingUtil(); + private static final HBaseCommonTestingUtil UTIL = new HBaseCommonTestingUtil(); private static WALProcedureStore STORE; private static ProcedureExecutor<Void> EXEC; - private static Exchanger<Boolean> EXCHANGER = new Exchanger<>(); + private static final Exchanger<Boolean> EXCHANGER = new Exchanger<>(); - private static int WAL_COUNT = 5; + private static final int WAL_COUNT = 5; - @Rule - public final TestName name = new TestName(); + private String methodName; private void createStoreAndExecutor() throws IOException { UTIL.getConfiguration().setInt(CompletedProcedureCleaner.CLEANER_INTERVAL_CONF_KEY, 1000); - Path logDir = UTIL.getDataTestDir(name.getMethodName()); + Path logDir = UTIL.getDataTestDir(methodName); STORE = ProcedureTestingUtility.createWalStore(UTIL.getConfiguration(), logDir); STORE.start(1); - EXEC = new ProcedureExecutor<Void>(UTIL.getConfiguration(), null, STORE); + EXEC = new ProcedureExecutor<>(UTIL.getConfiguration(), null, STORE); ProcedureTestingUtility.initAndStartWorkers(EXEC, 1, true); } - @BeforeClass + @BeforeAll public static void setUpBeforeClass() throws IOException { UTIL.getConfiguration().setInt(WALProcedureStore.WAL_COUNT_WARN_THRESHOLD_CONF_KEY, WAL_COUNT); } @@ -84,17 +77,18 @@ public class TestForceUpdateProcedure { STORE = null; } - @AfterClass + @AfterAll public static void tearDownAfterClass() throws IOException { UTIL.cleanupTestDir(); } - @Before - public void setUp() throws IOException { + @BeforeEach + public void setUp(TestInfo testInfo) throws IOException { + methodName = testInfo.getTestMethod().get().getName(); createStoreAndExecutor(); } - @After + @AfterEach public void tearDown() { stopStoreAndExecutor(); } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestLockAndQueue.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestLockAndQueue.java index 58c3bb3277a..e0374f461ab 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestLockAndQueue.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestLockAndQueue.java @@ -17,26 +17,21 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.HashMap; import java.util.Map; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.NoopProcedure; import org.apache.hadoop.hbase.testclassification.MasterTests; 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({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestLockAndQueue { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestLockAndQueue.class); - @Test public void testHasLockAccess() { Map<Long, NoopProcedure<Void>> procMap = new HashMap<>(); diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureBypass.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureBypass.java index 6bc3b4a84f6..620f2da40d1 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureBypass.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureBypass.java @@ -17,35 +17,30 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.concurrent.atomic.AtomicBoolean; import java.util.stream.Collectors; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -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; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureBypass { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureBypass.class); - private static final Logger LOG = LoggerFactory.getLogger(TestProcedureBypass.class); private static final int PROCEDURE_EXECUTOR_SLOTS = 1; @@ -64,7 +59,7 @@ public class TestProcedureBypass { private static class TestProcEnv { } - @BeforeClass + @BeforeAll public static void setUp() throws Exception { htu = new HBaseCommonTestingUtil(); @@ -81,6 +76,13 @@ public class TestProcedureBypass { ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true); } + @AfterAll + public static void tearDown() throws Exception { + procExecutor.stop(); + procStore.stop(false); + procExecutor.join(); + } + @Test public void testBypassSuspendProcedure() throws Exception { final SuspendProcedure proc = new SuspendProcedure(); @@ -157,13 +159,6 @@ public class TestProcedureBypass { LOG.info("{} finished", proc); } - @AfterClass - public static void tearDown() throws Exception { - procExecutor.stop(); - procStore.stop(false); - procExecutor.join(); - } - public static class SuspendProcedure extends ProcedureTestingUtility.NoopProcedure<TestProcEnv> { public SuspendProcedure() { @@ -284,5 +279,4 @@ public class TestProcedureBypass { return tState.ordinal(); } } - } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureCleanup.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureCleanup.java index 0c1c979927a..5de8c002d27 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureCleanup.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureCleanup.java @@ -17,7 +17,7 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.Arrays; @@ -28,29 +28,24 @@ import org.apache.hadoop.fs.FSDataOutputStream; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.wal.WALProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hbase.thirdparty.com.google.common.io.ByteStreams; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureCleanup { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureCleanup.class); - private static final Logger LOG = LoggerFactory.getLogger(TestProcedureCleanup.class); private static final int PROCEDURE_EXECUTOR_SLOTS = 2; @@ -65,18 +60,17 @@ public class TestProcedureCleanup { private static Path testDir; private static Path logDir; - @Rule - public final TestName name = new TestName(); + private String methodName; private void createProcExecutor() throws Exception { - logDir = new Path(testDir, name.getMethodName()); + logDir = new Path(testDir, methodName); procStore = ProcedureTestingUtility.createWalStore(htu.getConfiguration(), logDir); procExecutor = new ProcedureExecutor<>(htu.getConfiguration(), null, procStore); procStore.start(PROCEDURE_EXECUTOR_SLOTS); ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true, true); } - @BeforeClass + @BeforeAll public static void setUp() throws Exception { htu = new HBaseCommonTestingUtil(); htu.getConfiguration().setBoolean(WALProcedureStore.EXEC_WAL_CLEANUP_ON_LOAD_CONF_KEY, true); @@ -86,6 +80,11 @@ public class TestProcedureCleanup { assertTrue(testDir.depth() > 1); } + @BeforeEach + public void setUpEach(TestInfo testInfo) throws Exception { + methodName = testInfo.getTestMethod().get().getName(); + } + @Test public void testProcedureShouldNotCleanOnLoad() throws Exception { createProcExecutor(); diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureEvents.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureEvents.java index b48d7f6877e..06b2d5b18bc 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureEvents.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureEvents.java @@ -17,23 +17,21 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.io.IOException; import java.util.concurrent.atomic.AtomicInteger; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.NoopProcedure; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -41,13 +39,10 @@ import org.apache.hbase.thirdparty.com.google.protobuf.Int32Value; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestProcedureEvents { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureEvents.class); - private static final Logger LOG = LoggerFactory.getLogger(TestProcedureEvents.class); private TestProcEnv procEnv; @@ -58,7 +53,7 @@ public class TestProcedureEvents { private FileSystem fs; private Path logDir; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); Path testDir = htu.getDataTestDir(); @@ -72,7 +67,7 @@ public class TestProcedureEvents { ProcedureTestingUtility.initAndStartWorkers(procExecutor, 1, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -174,7 +169,7 @@ public class TestProcedureEvents { @Override protected synchronized boolean setTimeoutFailure(final TestProcEnv env) { int n = ntimeouts.incrementAndGet(); - LOG.info("HANDLE TIMEOUT " + this + " ntimeouts=" + n); + LOG.info("HANDLE TIMEOUT {} ntimeouts={}", this, n); setState(ProcedureState.RUNNABLE); event.wake((AbstractProcedureScheduler) env.getProcedureScheduler()); return false; diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecution.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecution.java index c9a1d49b2ba..29905f199b1 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecution.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecution.java @@ -17,8 +17,9 @@ */ package org.apache.hadoop.hbase.procedure2; -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.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.ArrayList; @@ -26,27 +27,23 @@ import java.util.List; import java.util.Objects; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureExecution { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureExecution.class); private static final Logger LOG = LoggerFactory.getLogger(TestProcedureExecution.class); @@ -61,7 +58,7 @@ public class TestProcedureExecution { private Path testDir; private Path logDir; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); testDir = htu.getDataTestDir(); @@ -75,7 +72,7 @@ public class TestProcedureExecution { ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -149,10 +146,10 @@ public class TestProcedureExecution { // failed state with 2 execute and 2 rollback LOG.info(Objects.toString(state)); Procedure<?> result = procExecutor.getResult(rootId); - assertTrue(state.toString(), result.isFailed()); + assertTrue(result.isFailed(), state.toString()); ProcedureTestingUtility.assertIsIllegalArgumentException(result); - assertEquals(state.toString(), 4, state.size()); + assertEquals(4, state.size(), state.toString()); assertEquals("rootProc-execute", state.get(0)); assertEquals("subProc1-execute", state.get(1)); assertEquals("subProc1-rollback", state.get(2)); @@ -171,7 +168,7 @@ public class TestProcedureExecution { LOG.info(Objects.toString(state)); Procedure<?> result = procExecutor.getResult(rootId); ProcedureTestingUtility.assertProcNotFailed(result); - assertEquals(state.toString(), 3, state.size()); + assertEquals(3, state.size(), state.toString()); } @Test @@ -186,13 +183,13 @@ public class TestProcedureExecution { // the 3rd proc fail, rollback after 2 successful execution LOG.info(Objects.toString(state)); Procedure<?> result = procExecutor.getResult(rootId); - assertTrue(state.toString(), result.isFailed()); + assertTrue(result.isFailed(), state.toString()); LOG.info(result.getException().getMessage()); Throwable cause = ProcedureTestingUtility.getExceptionCause(result); - assertTrue("expected TestProcedureException, got " + cause, - cause instanceof TestProcedureException); + assertTrue(cause instanceof TestProcedureException, + "expected TestProcedureException, got " + cause); - assertEquals(state.toString(), 6, state.size()); + assertEquals(6, state.size(), state.toString()); assertEquals("rootProc-execute", state.get(0)); assertEquals("subProc1-execute", state.get(1)); assertEquals("subProc2-execute", state.get(2)); @@ -216,10 +213,10 @@ public class TestProcedureExecution { @Override protected void rollback(Void env) throws IOException { if (++retries < 3) { - LOG.info("inject rollback failure " + retries); + LOG.info("inject rollback failure {}", retries); throw new IOException("injected failure number " + retries); } - LOG.info("execute non faulty rollback step retries=" + retries); + LOG.info("execute non faulty rollback step retries={}", retries); } @Override @@ -233,11 +230,11 @@ public class TestProcedureExecution { long procId = ProcedureTestingUtility.submitAndWait(procExecutor, new TestFaultyRollback()); Procedure<?> result = procExecutor.getResult(procId); - assertTrue("expected a failure", result.isFailed()); + assertTrue(result.isFailed(), "expected a failure"); LOG.info(result.getException().getMessage()); Throwable cause = ProcedureTestingUtility.getExceptionCause(result); - assertTrue("expected TestProcedureException, got " + cause, - cause instanceof TestProcedureException); + assertInstanceOf(TestProcedureException.class, cause, + "expected TestProcedureException, got " + cause); } public static class TestWaitingProcedure extends SequentialProcedure<Void> { @@ -315,11 +312,11 @@ public class TestProcedureExecution { long rootId = ProcedureTestingUtility.submitAndWait(procExecutor, proc); long execTime = EnvironmentEdgeManager.currentTime() - startTime; LOG.info(Objects.toString(state)); - assertTrue("we didn't wait enough execTime=" + execTime, execTime >= PROC_TIMEOUT_MSEC); + assertTrue(execTime >= PROC_TIMEOUT_MSEC, "we didn't wait enough execTime=" + execTime); Procedure<?> result = procExecutor.getResult(rootId); - assertTrue(state.toString(), result.isFailed()); + assertTrue(result.isFailed(), state.toString()); ProcedureTestingUtility.assertIsTimeoutException(result); - assertEquals(state.toString(), 2, state.size()); + assertEquals(2, state.size(), state.toString()); assertEquals("wproc-execute", state.get(0)); assertEquals("wproc-rollback", state.get(1)); } @@ -332,9 +329,9 @@ public class TestProcedureExecution { long rootId = ProcedureTestingUtility.submitAndWait(procExecutor, proc); LOG.info(Objects.toString(state)); Procedure<?> result = procExecutor.getResult(rootId); - assertTrue(state.toString(), result.isFailed()); + assertTrue(result.isFailed(), state.toString()); ProcedureTestingUtility.assertIsTimeoutException(result); - assertEquals(state.toString(), 3, state.size()); + assertEquals(3, state.size(), state.toString()); assertEquals("wproc-execute", state.get(0)); assertEquals("wproc-child-execute", state.get(1)); assertEquals("wproc-rollback", state.get(2)); diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecutor.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecutor.java index 923039f794c..6d58a4800db 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecutor.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecutor.java @@ -17,33 +17,30 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.NoopProcedure; import org.apache.hadoop.hbase.procedure2.store.NoopProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.Threads; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureExecutor { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureExecutor.class); - private static final Logger LOG = LoggerFactory.getLogger(TestProcedureExecutor.class); private TestProcEnv procEnv; @@ -52,7 +49,7 @@ public class TestProcedureExecutor { private HBaseCommonTestingUtil htu; - @Before + @BeforeEach public void setUp() throws Exception { htu = new HBaseCommonTestingUtil(); @@ -62,7 +59,7 @@ public class TestProcedureExecutor { procStore.start(1); } - @After + @AfterEach public void tearDown() throws Exception { procExecutor.stop(); procStore.stop(false); @@ -106,9 +103,9 @@ public class TestProcedureExecutor { assertEquals(true, procExecutor.isFinished(otherProcId)); ProcedureTestingUtility.assertProcNotFailed(procExecutor, otherProcId); - assertEquals(true, procExecutor.isRunning()); - assertEquals(false, procExecutor.isFinished(busyProcId1)); - assertEquals(false, procExecutor.isFinished(busyProcId2)); + assertTrue(procExecutor.isRunning()); + assertFalse(procExecutor.isFinished(busyProcId1)); + assertFalse(procExecutor.isFinished(busyProcId2)); // terminate the busy procedures latch1.release(); @@ -117,7 +114,7 @@ public class TestProcedureExecutor { LOG.info("set keep alive and wait threads being removed"); procExecutor.setKeepAliveTime(500L, TimeUnit.MILLISECONDS); int threads2 = waitThreadCount(NUM_THREADS); - LOG.info("threads got removed: " + (threads1 - threads2)); + LOG.info("threads got removed: {}", threads1 - threads2); assertEquals(NUM_THREADS, threads2); // terminate the busy procedures diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureInMemoryChore.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureInMemoryChore.java index 7ff4b3d5d41..81c121ff36c 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureInMemoryChore.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureInMemoryChore.java @@ -17,32 +17,27 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.NoopProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureInMemoryChore { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureInMemoryChore.class); - private static final Logger LOG = LoggerFactory.getLogger(TestProcedureInMemoryChore.class); private static final int PROCEDURE_EXECUTOR_SLOTS = 1; @@ -53,7 +48,7 @@ public class TestProcedureInMemoryChore { private HBaseCommonTestingUtil htu; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); @@ -65,7 +60,7 @@ public class TestProcedureInMemoryChore { ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -89,9 +84,9 @@ public class TestProcedureInMemoryChore { latch = new CountDownLatch(nCountDown); chore.setLatch(latch); latch.await(timeoutMSec * nCountDown, TimeUnit.MILLISECONDS); - LOG.info("chore latch count=" + latch.getCount()); + LOG.info("chore latch count={}", latch.getCount()); assertFalse(chore.isWaiting()); - assertTrue("latchCount=" + latch.getCount(), latch.getCount() > 0); + assertTrue(latch.getCount() > 0, "latchCount=" + latch.getCount()); } public static class TestLatchChore extends ProcedureInMemoryChore<TestProcEnv> { @@ -108,7 +103,7 @@ public class TestProcedureInMemoryChore { @Override protected void periodicExecute(final TestProcEnv env) { - LOG.info("periodic execute " + this); + LOG.info("periodic execute {}", this); latch.countDown(); } } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureMetrics.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureMetrics.java index 287c5d5431b..05208ab35bd 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureMetrics.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureMetrics.java @@ -17,33 +17,25 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -@Category({ MasterTests.class, SmallTests.class }) -public class TestProcedureMetrics { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureMetrics.class); +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; - private static final Logger LOG = LoggerFactory.getLogger(TestProcedureMetrics.class); +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) +public class TestProcedureMetrics { private static final int PROCEDURE_EXECUTOR_SLOTS = 1; @@ -60,7 +52,7 @@ public class TestProcedureMetrics { private static int successCount = 0; private static int failedCount = 0; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); testDir = htu.getDataTestDir(); @@ -76,7 +68,7 @@ public class TestProcedureMetrics { ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -88,13 +80,13 @@ public class TestProcedureMetrics { // procedure that executes successfully ProcedureMetrics proc = new ProcedureMetrics(true); long id = ProcedureTestingUtility.submitAndWait(procExecutor, proc); - assertNotEquals("ProcId zero!", 0, id); + assertNotEquals(0, id, "ProcId zero!"); beginCount++; successCount++; ProcedureTestingUtility.waitProcedure(procExecutor, proc); - assertEquals("beginCount doesn't match!", beginCount, proc.beginCount); - assertEquals("successCount doesn't match!", successCount, proc.successCount); - assertEquals("failedCont doesn't match!", failedCount, proc.failedCount); + assertEquals(beginCount, proc.beginCount, "beginCount doesn't match!"); + assertEquals(successCount, proc.successCount, "successCount doesn't match!"); + assertEquals(failedCount, proc.failedCount, "failedCont doesn't match!"); } @Test @@ -102,13 +94,13 @@ public class TestProcedureMetrics { // procedure that fails ProcedureMetrics proc = new ProcedureMetrics(false); long id = ProcedureTestingUtility.submitAndWait(procExecutor, proc); - assertNotEquals("ProcId zero!", 0, id); + assertNotEquals(0, id, "ProcId zero!"); beginCount++; failedCount++; ProcedureTestingUtility.waitProcedure(procExecutor, proc); - assertEquals("beginCount doesn't match!", beginCount, proc.beginCount); - assertEquals("successCount doesn't match!", successCount, proc.successCount); - assertEquals("failedCont doesn't match!", failedCount, proc.failedCount); + assertEquals(beginCount, proc.beginCount, "beginCount doesn't match!"); + assertEquals(successCount, proc.successCount, "successCount doesn't match!"); + assertEquals(failedCount, proc.failedCount, "failedCont doesn't match!"); } @Test @@ -116,13 +108,13 @@ public class TestProcedureMetrics { // procedure that yields ProcedureMetrics proc = new ProcedureMetrics(true, true); long id = ProcedureTestingUtility.submitAndWait(procExecutor, proc); - assertNotEquals("ProcId zero!", 0, id); + assertNotEquals(0, id, "ProcId zero!"); beginCount++; successCount++; ProcedureTestingUtility.waitProcedure(procExecutor, proc); - assertEquals("beginCount doesn't match!", beginCount, proc.beginCount); - assertEquals("successCount doesn't match!", successCount, proc.successCount); - assertEquals("failedCont doesn't match!", failedCount, proc.failedCount); + assertEquals(beginCount, proc.beginCount, "beginCount doesn't match!"); + assertEquals(successCount, proc.successCount, "successCount doesn't match!"); + assertEquals(failedCount, proc.failedCount, "failedCont doesn't match!"); } @Test @@ -130,13 +122,13 @@ public class TestProcedureMetrics { // procedure that yields and fails ProcedureMetrics proc = new ProcedureMetrics(false, true); long id = ProcedureTestingUtility.submitAndWait(procExecutor, proc); - assertNotEquals("ProcId zero!", 0, id); + assertNotEquals(0, id, "ProcId zero!"); beginCount++; failedCount++; ProcedureTestingUtility.waitProcedure(procExecutor, proc); - assertEquals("beginCount doesn't match!", beginCount, proc.beginCount); - assertEquals("successCount doesn't match!", successCount, proc.successCount); - assertEquals("failedCont doesn't match!", failedCount, proc.failedCount); + assertEquals(beginCount, proc.beginCount, "beginCount doesn't match!"); + assertEquals(successCount, proc.successCount, "successCount doesn't match!"); + assertEquals(failedCount, proc.failedCount, "failedCont doesn't match!"); } @Test @@ -152,7 +144,7 @@ public class TestProcedureMetrics { ProcedureMetrics proc = new ProcedureMetrics(true, true, 3, subprocs); long id = ProcedureTestingUtility.submitAndWait(procExecutor, proc); - assertNotEquals("ProcId zero!", 0, id); + assertNotEquals(0, id, "ProcId zero!"); beginCount += subProcCount + 1; successCount += subProcCount - (failChildIndex + 1); if (failChildIndex >= 0) { @@ -161,9 +153,9 @@ public class TestProcedureMetrics { successCount++; } ProcedureTestingUtility.waitProcedure(procExecutor, proc); - assertEquals("beginCount doesn't match!", beginCount, proc.beginCount); - assertEquals("successCount doesn't match!", successCount, proc.successCount); - assertEquals("failedCont doesn't match!", failedCount, proc.failedCount); + assertEquals(beginCount, proc.beginCount, "beginCount doesn't match!"); + assertEquals(successCount, proc.successCount, "successCount doesn't match!"); + assertEquals(failedCount, proc.failedCount, "failedCont doesn't match!"); } private static class TestProcEnv { diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureNonce.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureNonce.java index 911d7ac5367..8a7944b0f48 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureNonce.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureNonce.java @@ -17,16 +17,16 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicReference; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.security.User; @@ -35,19 +35,16 @@ import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.NonceKey; import org.apache.hadoop.hbase.util.Threads; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureNonce { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureNonce.class); private static final Logger LOG = LoggerFactory.getLogger(TestProcedureNonce.class); @@ -61,7 +58,7 @@ public class TestProcedureNonce { private FileSystem fs; private Path logDir; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); Path testDir = htu.getDataTestDir(); @@ -77,7 +74,7 @@ public class TestProcedureNonce { ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -190,8 +187,8 @@ public class TestProcedureNonce { public void run() { try { // release the nonce and wake t2 - assertFalse("unexpected already registered nonce", - procExecutor.registerNonce(nonceKey) >= 0); + assertFalse(procExecutor.registerNonce(nonceKey) >= 0, + "unexpected already registered nonce"); t1NonceRegisteredLatch.countDown(); // hold the submission until t2 is registering the nonce @@ -229,7 +226,7 @@ public class TestProcedureNonce { // register the nonce t2BeforeNonceRegisteredLatch.countDown(); - assertFalse("unexpected non registered nonce", procExecutor.registerNonce(nonceKey) < 0); + assertFalse(procExecutor.registerNonce(nonceKey) < 0, "unexpected non registered nonce"); } catch (Throwable e) { t2Exception.set(e); } finally { @@ -248,8 +245,8 @@ public class TestProcedureNonce { } ProcedureTestingUtility.waitNoProcedureRunning(procExecutor); - assertEquals(null, t1Exception.get()); - assertEquals(null, t2Exception.get()); + assertNull(t1Exception.get()); + assertNull(t2Exception.get()); } public static class TestSingleStepProcedure extends SequentialProcedure<TestProcEnv> { @@ -262,7 +259,7 @@ public class TestProcedureNonce { protected Procedure[] execute(TestProcEnv env) throws InterruptedException { step++; env.waitOnLatch(); - LOG.debug("execute procedure " + this + " step=" + step); + LOG.debug("execute procedure {} step={}", this, step); step++; setResult(Bytes.toBytes(step)); return null; diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRecovery.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRecovery.java index 4bc2178422a..4459f62af3f 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRecovery.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRecovery.java @@ -17,9 +17,9 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.concurrent.CountDownLatch; @@ -27,30 +27,25 @@ import java.util.concurrent.atomic.AtomicBoolean; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; -import org.apache.hadoop.hbase.procedure2.TestProcedureRecovery.TestStateMachineProcedure.State; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.hbase.util.Threads; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hbase.thirdparty.com.google.protobuf.Int32Value; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestProcedureRecovery { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureRecovery.class); private static final Logger LOG = LoggerFactory.getLogger(TestProcedureRecovery.class); @@ -66,7 +61,7 @@ public class TestProcedureRecovery { private Path testDir; private Path logDir; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); testDir = htu.getDataTestDir(); @@ -83,7 +78,7 @@ public class TestProcedureRecovery { procSleepInterval = 0; } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -532,7 +527,7 @@ public class TestProcedureRecovery { FileStatus[] files = fs.listStatus(logDir); if (files != null && files.length > 0) { for (FileStatus file : files) { - assertTrue(file.toString(), file.isFile()); + assertTrue(file.isFile(), file.toString()); LOG.debug("log file " + file.getPath() + " size=" + file.getLen()); } } else { diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureReplayOrder.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureReplayOrder.java index 2735cf2b319..3b5dabb46a3 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureReplayOrder.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureReplayOrder.java @@ -17,27 +17,25 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import java.util.ArrayList; import java.util.concurrent.atomic.AtomicLong; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.procedure2.store.wal.WALProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -47,13 +45,10 @@ import org.apache.hbase.thirdparty.com.google.protobuf.Int64Value; * For now we do not guarantee this, we will restore the locks when restarting ProcedureExecutor so * we should use lock to obtain the correct order. Ignored. */ -@Ignore -@Category({ MasterTests.class, SmallTests.class }) +@Disabled +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureReplayOrder { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureReplayOrder.class); - private static final Logger LOG = LoggerFactory.getLogger(TestProcedureReplayOrder.class); private static final int NUM_THREADS = 16; @@ -67,7 +62,7 @@ public class TestProcedureReplayOrder { private Path testDir; private Path logDir; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); htu.getConfiguration().setInt(WALProcedureStore.SYNC_WAIT_MSEC_CONF_KEY, 25); @@ -84,7 +79,7 @@ public class TestProcedureReplayOrder { ProcedureTestingUtility.initAndStartWorkers(procExecutor, 1, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -184,7 +179,7 @@ public class TestProcedureReplayOrder { for (int i = 0; i < execList.size() - 1; ++i) { TestProcedure a = execList.get(i); TestProcedure b = execList.get(i + 1); - assertTrue("exec list not sorted: " + a + " < " + b, a.getExecId() > b.getExecId()); + assertTrue(a.getExecId() > b.getExecId(), "exec list not sorted: " + a + " < " + b); } } } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRollbackAIOOB.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRollbackAIOOB.java index c5554da0f1a..0ca2f6785f7 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRollbackAIOOB.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRollbackAIOOB.java @@ -19,29 +19,24 @@ package org.apache.hadoop.hbase.procedure2; import java.io.IOException; import java.util.concurrent.CountDownLatch; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.NoopProcedure; import org.apache.hadoop.hbase.procedure2.store.wal.WALProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; /** * Testcase for HBASE-20973 */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestProcedureRollbackAIOOB { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureRollbackAIOOB.class); private static final HBaseCommonTestingUtil UTIL = new HBaseCommonTestingUtil(); @@ -77,25 +72,22 @@ public class TestProcedureRollbackAIOOB { private ProcedureExecutor<Void> procExec; - @Rule - public final TestName name = new TestName(); - - @Before - public void setUp() throws IOException { + @BeforeEach + public void setUp(TestInfo testInfo) throws IOException { procStore = ProcedureTestingUtility.createWalStore(UTIL.getConfiguration(), - UTIL.getDataTestDir(name.getMethodName())); + UTIL.getDataTestDir(testInfo.getTestMethod().get().getName())); procStore.start(2); - procExec = new ProcedureExecutor<Void>(UTIL.getConfiguration(), null, procStore); + procExec = new ProcedureExecutor<>(UTIL.getConfiguration(), null, procStore); ProcedureTestingUtility.initAndStartWorkers(procExec, 2, true); } - @After + @AfterEach public void tearDown() { procExec.stop(); procStore.stop(false); } - @AfterClass + @AfterAll public static void tearDownAfterClass() throws IOException { UTIL.cleanupTestDir(); } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSchedulerConcurrency.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSchedulerConcurrency.java index 186d3859534..662a871e7e1 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSchedulerConcurrency.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSchedulerConcurrency.java @@ -20,37 +20,33 @@ package org.apache.hadoop.hbase.procedure2; import java.io.IOException; import java.util.concurrent.ConcurrentSkipListSet; import java.util.concurrent.atomic.AtomicInteger; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.NoopProcedure; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.hbase.util.Threads; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureSchedulerConcurrency { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureSchedulerConcurrency.class); private static final Logger LOG = LoggerFactory.getLogger(TestProcedureEvents.class); private SimpleProcedureScheduler procSched; - @Before + @BeforeEach public void setUp() throws IOException { procSched = new SimpleProcedureScheduler(); procSched.start(); } - @After + @AfterEach public void tearDown() throws IOException { procSched.stop(); } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSkipPersistence.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSkipPersistence.java index 452b6f7e807..bbb5b959936 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSkipPersistence.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSkipPersistence.java @@ -17,31 +17,27 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureSkipPersistence { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureSkipPersistence.class); private ProcedureExecutor<ProcEnv> procExecutor; private ProcedureStore procStore; @@ -123,7 +119,7 @@ public class TestProcedureSkipPersistence { } } - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); testDir = htu.getDataTestDir(); @@ -137,7 +133,7 @@ public class TestProcedureSkipPersistence { ProcedureTestingUtility.initAndStartWorkers(procExecutor, 1, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSuspended.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSuspended.java index d34a08d6dd5..f1e43839d22 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSuspended.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSuspended.java @@ -17,32 +17,30 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.ArrayList; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicLong; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.store.NoopProcedureStore; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.Threads; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureSuspended { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureSuspended.class); private static final Logger LOG = LoggerFactory.getLogger(TestProcedureSuspended.class); @@ -54,7 +52,7 @@ public class TestProcedureSuspended { private HBaseCommonTestingUtil htu; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); @@ -64,7 +62,7 @@ public class TestProcedureSuspended { ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -87,8 +85,8 @@ public class TestProcedureSuspended { waitAndAssertTimestamp(p1keyA, 1, 1); waitAndAssertTimestamp(p2keyA, 0, -1); waitAndAssertTimestamp(p3keyB, 1, 2); - assertEquals(true, lockA.get()); - assertEquals(true, lockB.get()); + assertTrue(lockA.get()); + assertTrue(lockB.get()); // release p3 p3keyB.setThrowSuspend(false); @@ -96,11 +94,11 @@ public class TestProcedureSuspended { waitAndAssertTimestamp(p1keyA, 1, 1); waitAndAssertTimestamp(p2keyA, 0, -1); waitAndAssertTimestamp(p3keyB, 2, 3); - assertEquals(true, lockA.get()); + assertTrue(lockA.get()); // wait until p3 is fully completed ProcedureTestingUtility.waitProcedure(procExecutor, p3keyB); - assertEquals(false, lockB.get()); + assertFalse(lockB.get()); // rollback p2 and wait until is fully completed p1keyA.setTriggerRollback(true); @@ -111,7 +109,7 @@ public class TestProcedureSuspended { waitAndAssertTimestamp(p1keyA, 4, 60000); waitAndAssertTimestamp(p2keyA, 1, 7); waitAndAssertTimestamp(p3keyB, 2, 3); - assertEquals(true, lockA.get()); + assertTrue(lockA.get()); // wait until p2 is fully completed p2keyA.setThrowSuspend(false); @@ -120,8 +118,8 @@ public class TestProcedureSuspended { waitAndAssertTimestamp(p1keyA, 4, 60000); waitAndAssertTimestamp(p2keyA, 2, 8); waitAndAssertTimestamp(p3keyB, 2, 3); - assertEquals(false, lockA.get()); - assertEquals(false, lockB.get()); + assertFalse(lockA.get()); + assertFalse(lockB.get()); } @Test @@ -164,7 +162,7 @@ public class TestProcedureSuspended { Threads.sleep(10); } - LOG.info(proc + " -> " + timestamps); + LOG.info("{} -> {}", proc, timestamps); assertEquals(size, timestamps.size()); if (size > 0) { assertEquals(lastTs, timestamps.get(timestamps.size() - 1).longValue()); @@ -204,7 +202,7 @@ public class TestProcedureSuspended { @Override protected Procedure[] execute(final TestProcEnv env) throws ProcedureYieldException, ProcedureSuspendedException { - LOG.info("EXECUTE " + this + " suspend " + (lock != null)); + LOG.info("EXECUTE {} suspend {}", this, lock != null); timestamps.add(env.nextTimestamp()); if (triggerRollback) { setFailure(getClass().getSimpleName(), new Exception("injected failure")); @@ -218,7 +216,7 @@ public class TestProcedureSuspended { @Override protected void rollback(final TestProcEnv env) { - LOG.info("ROLLBACK " + this); + LOG.info("ROLLBACK {}", this); timestamps.add(env.nextTimestamp() * 10000); } @@ -226,7 +224,7 @@ public class TestProcedureSuspended { protected LockState acquireLock(final TestProcEnv env) { hasLock = lock.compareAndSet(false, true); if (hasLock) { - LOG.info("ACQUIRE LOCK " + this + " " + (hasLock)); + LOG.info("ACQUIRE LOCK {} {}", this, hasLock); return LockState.LOCK_ACQUIRED; } return LockState.LOCK_YIELD_WAIT; @@ -234,7 +232,7 @@ public class TestProcedureSuspended { @Override protected void releaseLock(final TestProcEnv env) { - LOG.info("RELEASE LOCK " + this + " " + hasLock); + LOG.info("RELEASE LOCK {} {}", this, hasLock); lock.set(false); } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureToString.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureToString.java index ff4de723b11..e2d605e5eb9 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureToString.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureToString.java @@ -17,26 +17,21 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.MasterTests; 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; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ServerCrashState; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureToString { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureToString.class); - /** * A do-nothing environment for BasicProcedure. */ diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureUtil.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureUtil.java index 885ba88a832..5d35882d4cf 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureUtil.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureUtil.java @@ -17,33 +17,32 @@ */ package org.apache.hadoop.hbase.procedure2; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.TestProcedure; import org.apache.hadoop.hbase.testclassification.MasterTests; 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; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureUtil { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureUtil.class); - @Test public void testValidation() throws Exception { ProcedureUtil.validateClass(new TestProcedure(10)); } - @Test(expected = BadProcedureException.class) + @Test public void testNoDefaultConstructorValidation() throws Exception { - ProcedureUtil.validateClass(new TestProcedureNoDefaultConstructor(1)); + assertThrows(BadProcedureException.class, () -> { + ProcedureUtil.validateClass(new TestProcedureNoDefaultConstructor(1)); + }); } @Test @@ -53,8 +52,8 @@ public class TestProcedureUtil { final ProcedureProtos.Procedure proto1 = ProcedureUtil.convertToProtoProcedure(proc1); final TestProcedure proc2 = (TestProcedure) ProcedureUtil.convertToProcedure(proto1); final ProcedureProtos.Procedure proto2 = ProcedureUtil.convertToProtoProcedure(proc2); - assertEquals(false, proto2.hasResult()); - assertEquals("Procedure protobuf does not match", proto1, proto2); + assertFalse(proto2.hasResult()); + assertEquals(proto1, proto2, "Procedure protobuf does not match"); } public static class TestProcedureNoDefaultConstructor extends TestProcedure { diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestRemoteProcedureDispatcherUncaughtExceptionHandler.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestRemoteProcedureDispatcherUncaughtExceptionHandler.java index 07ca0221b77..d278b62fe3c 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestRemoteProcedureDispatcherUncaughtExceptionHandler.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestRemoteProcedureDispatcherUncaughtExceptionHandler.java @@ -17,20 +17,19 @@ */ package org.apache.hadoop.hbase.procedure2; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.lang.Thread.UncaughtExceptionHandler; import java.util.Set; import java.util.concurrent.TimeUnit; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.ExpectedException; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; /** * Make sure the {@link UncaughtExceptionHandler} will be called when there are unchecked exceptions @@ -38,15 +37,12 @@ import org.junit.rules.ExpectedException; * <p/> * See HBASE-21875 and HBASE-21890 for more details. */ -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestRemoteProcedureDispatcherUncaughtExceptionHandler { private static HBaseCommonTestingUtil UTIL = new HBaseCommonTestingUtil(); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRemoteProcedureDispatcherUncaughtExceptionHandler.class); - private static final class ExceptionHandler implements UncaughtExceptionHandler { private Throwable error; @@ -88,21 +84,18 @@ public class TestRemoteProcedureDispatcherUncaughtExceptionHandler { } } - @Rule - public ExpectedException thrown = ExpectedException.none(); - private ExceptionHandler handler; private Dispatcher dispatcher; - @Before + @BeforeEach public void setUp() { handler = new ExceptionHandler(); dispatcher = new Dispatcher(handler); dispatcher.start(); } - @After + @AfterEach public void tearDown() { dispatcher.stop(); dispatcher = null; @@ -112,8 +105,6 @@ public class TestRemoteProcedureDispatcherUncaughtExceptionHandler { @Test public void testSubmit() throws Throwable { String message = "inject error"; - thrown.expect(RuntimeException.class); - thrown.expectMessage(message); dispatcher.submitTask(new Runnable() { @Override @@ -121,14 +112,13 @@ public class TestRemoteProcedureDispatcherUncaughtExceptionHandler { throw new RuntimeException(message); } }); - handler.get(); + RuntimeException exception = assertThrows(RuntimeException.class, () -> handler.get()); + assertEquals(message, exception.getMessage()); } @Test public void testDelayedSubmit() throws Throwable { String message = "inject error"; - thrown.expect(RuntimeException.class); - thrown.expectMessage(message); dispatcher.submitTask(new Runnable() { @Override @@ -136,6 +126,7 @@ public class TestRemoteProcedureDispatcherUncaughtExceptionHandler { throw new RuntimeException(message); } }, 100, TimeUnit.MILLISECONDS); - handler.get(); + RuntimeException exception = assertThrows(RuntimeException.class, () -> handler.get()); + assertEquals(message, exception.getMessage()); } } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStackIdHoles.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStackIdHoles.java index 4708df44745..fecbf5120cf 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStackIdHoles.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStackIdHoles.java @@ -22,7 +22,6 @@ import java.io.UncheckedIOException; import java.util.LinkedHashMap; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicLong; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.NoopProcedure; import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreBase; @@ -30,11 +29,10 @@ import org.apache.hadoop.hbase.procedure2.store.ProcedureTree; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.AtomicUtils; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; @@ -43,13 +41,10 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; * {@link RootProcedureState} first and then crash, and then cause holes in stack ids when loading, * and finally fail the start up of master. */ -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestStackIdHoles { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestStackIdHoles.class); - private final class DummyProcedureStore extends ProcedureStoreBase { private int numThreads; @@ -193,7 +188,7 @@ public class TestStackIdHoles { private ProcedureExecutor<Void> procExec; - @Before + @BeforeEach public void setUp() throws IOException { procStore = new DummyProcedureStore(); procStore.start(4); @@ -202,7 +197,7 @@ public class TestStackIdHoles { procExec.startWorkers(); } - @After + @AfterEach public void tearDown() { procExec.stop(); } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStateMachineProcedure.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStateMachineProcedure.java index e1770f5ac57..da4640b19de 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStateMachineProcedure.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStateMachineProcedure.java @@ -17,32 +17,28 @@ */ package org.apache.hadoop.hbase.procedure2; -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 java.util.concurrent.atomic.AtomicInteger; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.NoopProcedure; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestStateMachineProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestStateMachineProcedure.class); private static final Logger LOG = LoggerFactory.getLogger(TestStateMachineProcedure.class); @@ -81,7 +77,7 @@ public class TestStateMachineProcedure { private Path testDir; private Path logDir; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); testDir = htu.getDataTestDir(); @@ -94,10 +90,10 @@ public class TestStateMachineProcedure { ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true); } - @After + @AfterEach public void tearDown() throws IOException { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExecutor, false); - assertTrue("expected executor to be running", procExecutor.isRunning()); + assertTrue(procExecutor.isRunning(), "expected executor to be running"); procExecutor.stop(); procStore.stop(false); @@ -113,7 +109,7 @@ public class TestStateMachineProcedure { Thread.sleep(1000 + (int) (Math.random() * 4001)); proc.abort(procExecutor.getEnvironment()); ProcedureTestingUtility.waitProcedure(procExecutor, procId); - assertEquals(true, proc.isFailed()); + assertTrue(proc.isFailed()); } finally { procExecutor.getEnvironment().loop = false; } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestYieldProcedures.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestYieldProcedures.java index 47a5e5616e7..0c34af93824 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestYieldProcedures.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestYieldProcedures.java @@ -17,8 +17,9 @@ */ package org.apache.hadoop.hbase.procedure2; -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.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.ArrayList; @@ -27,25 +28,20 @@ import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicLong; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; -import org.apache.hadoop.hbase.procedure2.TestYieldProcedures.TestStateMachineProcedure.State; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestYieldProcedures { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestYieldProcedures.class); private static final Logger LOG = LoggerFactory.getLogger(TestYieldProcedures.class); @@ -61,7 +57,7 @@ public class TestYieldProcedures { private Path testDir; private Path logDir; - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); testDir = htu.getDataTestDir(); @@ -77,7 +73,7 @@ public class TestYieldProcedures { ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true); } - @After + @AfterEach public void tearDown() throws IOException { procExecutor.stop(); procStore.stop(false); @@ -102,14 +98,14 @@ public class TestYieldProcedures { int index = 0; for (int execStep = 0; execStep < NUM_STATES; ++execStep) { TestStateMachineProcedure.ExecutionInfo info = procs[i].getExecutionInfo().get(index++); - assertEquals(false, info.isRollback()); + assertFalse(info.isRollback()); assertEquals(execStep, info.getStep().ordinal()); } // verify rollback for (int execStep = NUM_STATES - 1; execStep >= 0; --execStep) { TestStateMachineProcedure.ExecutionInfo info = procs[i].getExecutionInfo().get(index++); - assertEquals(true, info.isRollback()); + assertTrue(info.isRollback()); assertEquals(execStep, info.getStep().ordinal()); } } @@ -135,18 +131,18 @@ public class TestYieldProcedures { assertEquals(NUM_STATES * 4, proc.getExecutionInfo().size()); for (int i = 0; i < NUM_STATES; ++i) { TestStateMachineProcedure.ExecutionInfo info = proc.getExecutionInfo().get(count++); - assertEquals(false, info.isRollback()); + assertFalse(info.isRollback()); assertEquals(i, info.getStep().ordinal()); info = proc.getExecutionInfo().get(count++); - assertEquals(false, info.isRollback()); + assertFalse(info.isRollback()); assertEquals(i, info.getStep().ordinal()); } // test rollback (we execute steps twice, rollback counts both IE and completed) for (int i = NUM_STATES - 1; i >= 0; --i) { TestStateMachineProcedure.ExecutionInfo info = proc.getExecutionInfo().get(count++); - assertEquals(true, info.isRollback()); + assertTrue(info.isRollback()); assertEquals(i, info.getStep().ordinal()); } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestProcedureTree.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestProcedureTree.java index 73acdf633ce..6799bcc98ad 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestProcedureTree.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestProcedureTree.java @@ -17,7 +17,7 @@ */ package org.apache.hadoop.hbase.procedure2.store; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.io.IOException; import java.io.UncheckedIOException; @@ -25,7 +25,6 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.ProcedureStateSerializer; import org.apache.hadoop.hbase.procedure2.ProcedureSuspendedException; @@ -34,19 +33,15 @@ import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureIterator; import org.apache.hadoop.hbase.testclassification.MasterTests; 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; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestProcedureTree { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureTree.class); - public static final class TestProcedure extends Procedure<Void> { @Override @@ -169,5 +164,4 @@ public class TestProcedureTree { assertEquals(5, corruptedProcs.get(0).getProcId()); assertEquals(4, corruptedProcs.get(0).getParentProcId()); } - } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestBitSetNode.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestBitSetNode.java index 251cb39842b..762a958aa10 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestBitSetNode.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestBitSetNode.java @@ -17,26 +17,21 @@ */ package org.apache.hadoop.hbase.procedure2.store.wal; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.store.wal.ProcedureStoreTracker.DeleteState; import org.apache.hadoop.hbase.testclassification.MasterTests; 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({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestBitSetNode { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBitSetNode.class); - @Test public void testGetActiveMaxMinProcId() { BitSetNode node = new BitSetNode(5L, false); diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestProcedureStoreTracker.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestProcedureStoreTracker.java index 46164be6469..593f605967e 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestProcedureStoreTracker.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestProcedureStoreTracker.java @@ -17,26 +17,23 @@ */ package org.apache.hadoop.hbase.procedure2.store.wal; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.concurrent.ThreadLocalRandom; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -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; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestProcedureStoreTracker { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureStoreTracker.class); private static final Logger LOG = LoggerFactory.getLogger(TestProcedureStoreTracker.class); @@ -58,7 +55,7 @@ public class TestProcedureStoreTracker { } // All the proc that are not yet inserted should be result as deleted for (int j = i + 1; j < MAX_PROC; ++j) { - assertTrue(tracker.isDeleted(j) != ProcedureStoreTracker.DeleteState.NO); + assertNotSame(ProcedureStoreTracker.DeleteState.NO, tracker.isDeleted(j)); } } @@ -213,7 +210,7 @@ public class TestProcedureStoreTracker { if (hasProc) { assertEquals(ProcedureStoreTracker.DeleteState.NO, tracker.isDeleted(i)); } else { - assertEquals("procId=" + i, ProcedureStoreTracker.DeleteState.YES, tracker.isDeleted(i)); + assertEquals(ProcedureStoreTracker.DeleteState.YES, tracker.isDeleted(i), "procId=" + i); } } } @@ -227,24 +224,24 @@ public class TestProcedureStoreTracker { for (int i = 0; i < procIds.length; ++i) { tracker.insert(procIds[i]); } - assertEquals(false, tracker.isEmpty()); + assertFalse(tracker.isEmpty()); for (int i = 0; i < procIds.length; ++i) { tracker.setDeletedIfModified(procIds[i] - 1); tracker.setDeletedIfModified(procIds[i]); tracker.setDeletedIfModified(procIds[i] + 1); } - assertEquals(true, tracker.isEmpty()); + assertTrue(tracker.isEmpty()); // test batch tracker.reset(); for (int i = 0; i < procIds.length; ++i) { tracker.insert(procIds[i]); } - assertEquals(false, tracker.isEmpty()); + assertFalse(tracker.isEmpty()); tracker.setDeletedIfModified(procIds); - assertEquals(true, tracker.isEmpty()); + assertTrue(tracker.isEmpty()); } @Test diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestStressWALProcedureStore.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestStressWALProcedureStore.java index 31fb550c7cb..3cbc824293d 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestStressWALProcedureStore.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestStressWALProcedureStore.java @@ -17,8 +17,8 @@ */ package org.apache.hadoop.hbase.procedure2.store.wal; -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 java.util.Random; @@ -27,7 +27,6 @@ import java.util.concurrent.atomic.AtomicLong; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.LoadCounter; @@ -35,22 +34,18 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.TestProcedure; import org.apache.hadoop.hbase.procedure2.util.StringUtils; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestStressWALProcedureStore { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestStressWALProcedureStore.class); - private static final Logger LOG = LoggerFactory.getLogger(TestWALProcedureStore.class); private static final int PROCEDURE_STORE_SLOTS = 8; @@ -68,7 +63,7 @@ public class TestStressWALProcedureStore { conf.setInt(WALProcedureStore.ROLL_THRESHOLD_CONF_KEY, 128 * 1024); } - @Before + @BeforeEach public void setUp() throws IOException { htu = new HBaseCommonTestingUtil(); setupConfiguration(htu.getConfiguration()); @@ -89,7 +84,7 @@ public class TestStressWALProcedureStore { assertEquals(0, loader.getCorruptedCount()); } - @After + @AfterEach public void tearDown() throws IOException { procStore.stop(false); fs.delete(logDir, true); @@ -138,14 +133,14 @@ public class TestStressWALProcedureStore { assertEquals(1, procStore.getActiveLogs().size()); } - @Ignore + @Disabled @Test // REENABLE after merge of // https://github.com/google/protobuf/issues/2228#issuecomment-252058282 public void testEntrySizeLimit() throws Exception { final int NITEMS = 20; for (int i = 1; i <= NITEMS; ++i) { final byte[] data = new byte[256 << i]; - LOG.info(String.format("Writing %s", StringUtils.humanSize(data.length))); + LOG.info("Writing {}", StringUtils.humanSize(data.length)); TestProcedure proc = new TestProcedure(i, 0, data); procStore.insert(proc, null); } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureStore.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureStore.java index e01c573b1df..0c89a166ba0 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureStore.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureStore.java @@ -17,9 +17,10 @@ */ package org.apache.hadoop.hbase.procedure2.store.wal; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.FileNotFoundException; import java.io.IOException; @@ -35,7 +36,6 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.procedure2.Procedure; @@ -49,11 +49,10 @@ import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.io.IOUtils; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; @@ -62,11 +61,9 @@ import org.slf4j.LoggerFactory; import org.apache.hbase.thirdparty.com.google.protobuf.Int64Value; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestWALProcedureStore { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestWALProcedureStore.class); private static final Logger LOG = LoggerFactory.getLogger(TestWALProcedureStore.class); @@ -83,7 +80,7 @@ public class TestWALProcedureStore { conf.setBoolean(WALProcedureStore.EXEC_WAL_CLEANUP_ON_LOAD_CONF_KEY, true); } - @Before + @BeforeEach public void setUp() throws IOException { testDir = htu.getDataTestDir(); htu.getConfiguration().set(HConstants.HBASE_DIR, testDir.toString()); @@ -100,7 +97,7 @@ public class TestWALProcedureStore { procStore.load(new LoadCounter()); } - @After + @AfterEach public void tearDown() throws IOException { procStore.stop(false); fs.delete(logDir, true); @@ -171,8 +168,8 @@ public class TestWALProcedureStore { for (int i = 0; i < deleteOrder.length; i++) { procStore.delete(procs[deleteOrder[i]].getProcId()); procStore.removeInactiveLogsForTesting(); - assertFalse(logs.get(deleteOrder[i]).toString(), - procStore.getActiveLogs().contains(logs.get(deleteOrder[i]))); + assertFalse(procStore.getActiveLogs().contains(logs.get(deleteOrder[i])), + logs.get(deleteOrder[i]).toString()); assertEquals(procStore.getActiveLogs().size(), procs.length - i); } } @@ -422,11 +419,11 @@ public class TestWALProcedureStore { final int[] updatedProcs, final int[] nonUpdatedProcs) { for (int index : updatedProcs) { long procId = procs[index].getProcId(); - assertTrue("Procedure id : " + procId, tracker.isModified(procId)); + assertTrue(tracker.isModified(procId), "Procedure id : " + procId); } for (int index : nonUpdatedProcs) { long procId = procs[index].getProcId(); - assertFalse("Procedure id : " + procId, tracker.isModified(procId)); + assertFalse(tracker.isModified(procId), "Procedure id : " + procId); } } @@ -434,13 +431,13 @@ public class TestWALProcedureStore { final int[] deletedProcs, final int[] nonDeletedProcs) { for (int index : deletedProcs) { long procId = procs[index].getProcId(); - assertEquals("Procedure id : " + procId, ProcedureStoreTracker.DeleteState.YES, - tracker.isDeleted(procId)); + assertEquals(ProcedureStoreTracker.DeleteState.YES, tracker.isDeleted(procId), + "Procedure id : " + procId); } for (int index : nonDeletedProcs) { long procId = procs[index].getProcId(); - assertEquals("Procedure id : " + procId, ProcedureStoreTracker.DeleteState.NO, - tracker.isDeleted(procId)); + assertEquals(ProcedureStoreTracker.DeleteState.NO, tracker.isDeleted(procId), + "Procedure id : " + procId); } } @@ -523,7 +520,7 @@ public class TestWALProcedureStore { LoadCounter loader = new LoadCounter(); storeRestart(loader); - assertTrue(procStore.getCorruptedLogs() != null); + assertNotNull(procStore.getCorruptedLogs()); assertEquals(1, procStore.getCorruptedLogs().size()); assertEquals(87, loader.getLoadedCount()); assertEquals(0, loader.getCorruptedCount()); @@ -558,7 +555,7 @@ public class TestWALProcedureStore { // the first log was removed, // we have insert-txn and updates in the others so everything is fine FileStatus[] logs = fs.listStatus(logDir); - assertEquals(Arrays.toString(logs), 2, logs.length); + assertEquals(2, logs.length, Arrays.toString(logs)); Arrays.sort(logs, new Comparator<FileStatus>() { @Override public int compare(FileStatus o1, FileStatus o2) { @@ -578,9 +575,9 @@ public class TestWALProcedureStore { assertEquals(0, loader.getLoadedCount()); assertEquals(rootProcs.length, loader.getCorruptedCount()); for (Procedure<?> proc : loader.getCorrupted()) { - assertTrue(proc.toString(), proc.getParentProcId() <= rootProcs.length); - assertTrue(proc.toString(), - proc.getProcId() > rootProcs.length && proc.getProcId() <= (rootProcs.length * 2)); + assertTrue(proc.getParentProcId() <= rootProcs.length, proc.toString()); + assertTrue(proc.getProcId() > rootProcs.length && proc.getProcId() <= (rootProcs.length * 2), + proc.toString()); } } @@ -789,7 +786,7 @@ public class TestWALProcedureStore { restartAndAssert(procId != count ? count : 0, count - (i + 1), 0, 0); } procStore.removeInactiveLogsForTesting(); - assertEquals("WALs=" + procStore.getActiveLogs(), 1, procStore.getActiveLogs().size()); + assertEquals(1, procStore.getActiveLogs().size(), "WALs=" + procStore.getActiveLogs()); } @Test diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/util/TestDelayedUtil.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/util/TestDelayedUtil.java index 27f280ad13a..f07674d428a 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/util/TestDelayedUtil.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/util/TestDelayedUtil.java @@ -17,24 +17,19 @@ */ package org.apache.hadoop.hbase.procedure2.util; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.MasterTests; 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; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestDelayedUtil { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestDelayedUtil.class); - private static final Logger LOG = LoggerFactory.getLogger(TestDelayedUtil.class); @Test @@ -74,8 +69,8 @@ public class TestDelayedUtil { } } boolean isMatching = src.equals(items[i]); - assertEquals(src.getObject() + " unexpectedly match " + items[i].getObject(), shouldMatch, - isMatching); + assertEquals(shouldMatch, isMatching, + src.getObject() + " unexpectedly match " + items[i].getObject()); } }
