Eliminate use of deprecated mockito methods

[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / test / java / org / opendaylight / controller / cluster / datastore / ShardTest.java

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTest.java
index ffa2f995a883356d55ce29c8d6da6b4398293c3e..7d4c054b3e9a4e86728feb9e5936ae9550cee888 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTest.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTest.java
@@ -13,7 +13,7 @@ import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
@@ -33,6 +33,7 @@ import akka.util.Timeout;
 import com.google.common.base.Stopwatch;
 import com.google.common.base.Throwables;
 import com.google.common.util.concurrent.Uninterruptibles;
+import java.time.Duration;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Map;
@@ -139,7 +140,7 @@ public class ShardTest extends AbstractShardTest {
 
         shard.tell(new RegisterDataTreeChangeListener(TestModel.TEST_PATH, dclActor, false), testKit.getRef());
 
-        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("3 seconds"),
+        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(3),
             RegisterDataTreeNotificationListenerReply.class);
         final String replyPath = reply.getListenerRegistrationPath().toString();
         assertTrue("Incorrect reply path: " + replyPath,
@@ -194,16 +195,15 @@ public class ShardTest extends AbstractShardTest {
                 "testDataTreeChangeListenerNotifiedWhenNotTheLeaderOnRegistration");
 
         final ShardTestKit testKit = new ShardTestKit(getSystem());
-        assertEquals("Got first ElectionTimeout", true, onFirstElectionTimeout.await(5, TimeUnit.SECONDS));
+        assertTrue("Got first ElectionTimeout", onFirstElectionTimeout.await(5, TimeUnit.SECONDS));
 
         shard.tell(new RegisterDataTreeChangeListener(path, dclActor, false), testKit.getRef());
-        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
             RegisterDataTreeNotificationListenerReply.class);
         assertNotNull("getListenerRegistratioznPath", reply.getListenerRegistrationPath());
 
         shard.tell(FindLeader.INSTANCE, testKit.getRef());
-        final FindLeaderReply findLeadeReply = testKit.expectMsgClass(testKit.duration("5 seconds"),
-            FindLeaderReply.class);
+        final FindLeaderReply findLeadeReply = testKit.expectMsgClass(Duration.ofSeconds(5), FindLeaderReply.class);
         assertFalse("Expected the shard not to be the leader", findLeadeReply.getLeaderActor().isPresent());
 
         onChangeListenerRegistered.countDown();
@@ -224,7 +224,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CreateTransaction(nextTransactionId(), TransactionType.READ_ONLY.ordinal(),
             DataStoreVersions.CURRENT_VERSION).toSerializable(), testKit.getRef());
 
-        final CreateTransactionReply reply = testKit.expectMsgClass(testKit.duration("3 seconds"),
+        final CreateTransactionReply reply = testKit.expectMsgClass(Duration.ofSeconds(3),
             CreateTransactionReply.class);
 
         final String path = reply.getTransactionPath().toString();
@@ -243,7 +243,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CreateTransaction(nextTransactionId(), TransactionType.READ_ONLY.ordinal(),
             DataStoreVersions.CURRENT_VERSION).toSerializable(), testKit.getRef());
 
-        final CreateTransactionReply reply = testKit.expectMsgClass(testKit.duration("3 seconds"),
+        final CreateTransactionReply reply = testKit.expectMsgClass(Duration.ofSeconds(3),
             CreateTransactionReply.class);
 
         final String path = reply.getTransactionPath().toString();
@@ -387,8 +387,8 @@ public class ShardTest extends AbstractShardTest {
         final CountDownLatch commitLatch = new CountDownLatch(2);
 
         final long timeoutSec = 5;
-        final FiniteDuration duration = FiniteDuration.create(timeoutSec, TimeUnit.SECONDS);
-        final Timeout timeout = new Timeout(duration);
+        final Duration duration = Duration.ofSeconds(timeoutSec);
+        final Timeout timeout = Timeout.create(duration);
 
         final TestActorRef<Shard> shard = actorFactory.createTestActor(
                 newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()),
@@ -441,9 +441,8 @@ public class ShardTest extends AbstractShardTest {
 
             @Override
             void onSuccess(final Object resp) {
-                final CanCommitTransactionReply canCommitReply =
-                        CanCommitTransactionReply.fromSerializable(resp);
-                assertEquals("Can commit", true, canCommitReply.getCanCommit());
+                final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply.fromSerializable(resp);
+                assertTrue("Can commit", canCommitReply.getCanCommit());
 
                 final Future<Object> commitFuture = Patterns.ask(shard,
                         new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), timeout);
@@ -474,7 +473,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
         final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        assertTrue("Can commit", canCommitReply.getCanCommit());
 
         // Ready 2 more Tx's.
 
@@ -521,7 +520,7 @@ public class ShardTest extends AbstractShardTest {
             throw new RuntimeException(t);
         }
 
-        assertEquals("Commits complete", true, done);
+        assertTrue("Commits complete", done);
 
 //                final InOrder inOrder = inOrder(cohort1.getCanCommit(), cohort1.getPreCommit(), cohort1.getCommit(),
 //                        cohort2.getCanCommit(), cohort2.getPreCommit(), cohort2.getCommit(), cohort3.getCanCommit(),
@@ -553,7 +552,7 @@ public class ShardTest extends AbstractShardTest {
         ShardTestKit.waitUntilLeader(shard);
 
         final TransactionIdentifier transactionID = nextTransactionId();
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         // Send a BatchedModifications to start a transaction.
 
@@ -580,7 +579,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
         final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        assertTrue("Can commit", canCommitReply.getCanCommit());
 
         // Send the CommitTransaction message.
 
@@ -602,7 +601,7 @@ public class ShardTest extends AbstractShardTest {
         ShardTestKit.waitUntilLeader(shard);
 
         final TransactionIdentifier transactionID = nextTransactionId();
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         // Send a BatchedModifications to start a transaction.
 
@@ -646,7 +645,7 @@ public class ShardTest extends AbstractShardTest {
 
         shard.tell(batched, testKit.getRef());
 
-        final Failure failure = testKit.expectMsgClass(testKit.duration("5 seconds"), Failure.class);
+        final Failure failure = testKit.expectMsgClass(Duration.ofSeconds(5), Failure.class);
 
         if (failure != null) {
             Throwables.propagateIfPossible(failure.cause(), Exception.class);
@@ -676,7 +675,7 @@ public class ShardTest extends AbstractShardTest {
         BatchedModifications batched = new BatchedModifications(transactionID, CURRENT_VERSION);
         batched.addModification(new MergeModification(TestModel.TEST_PATH, invalidData));
         shard.tell(batched, testKit.getRef());
-        Failure failure = testKit.expectMsgClass(testKit.duration("5 seconds"), akka.actor.Status.Failure.class);
+        Failure failure = testKit.expectMsgClass(Duration.ofSeconds(5), akka.actor.Status.Failure.class);
 
         final Throwable cause = failure.cause();
 
@@ -686,7 +685,7 @@ public class ShardTest extends AbstractShardTest {
 
         shard.tell(batched, testKit.getRef());
 
-        failure = testKit.expectMsgClass(testKit.duration("5 seconds"), akka.actor.Status.Failure.class);
+        failure = testKit.expectMsgClass(Duration.ofSeconds(5), akka.actor.Status.Failure.class);
         assertEquals("Failure cause", cause, failure.cause());
     }
 
@@ -703,7 +702,7 @@ public class ShardTest extends AbstractShardTest {
         final TransactionIdentifier transactionID1 = new TransactionIdentifier(historyId, 0);
         final TransactionIdentifier transactionID2 = new TransactionIdentifier(historyId, 1);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         // Send a BatchedModifications to start a chained write
         // transaction and ready it.
@@ -718,12 +717,12 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CreateTransaction(transactionID2, TransactionType.READ_ONLY.ordinal(),
             DataStoreVersions.CURRENT_VERSION).toSerializable(), testKit.getRef());
 
-        final CreateTransactionReply createReply = testKit.expectMsgClass(testKit.duration("3 seconds"),
+        final CreateTransactionReply createReply = testKit.expectMsgClass(Duration.ofSeconds(3),
             CreateTransactionReply.class);
 
         getSystem().actorSelection(createReply.getTransactionPath())
         .tell(new ReadData(path, DataStoreVersions.CURRENT_VERSION), testKit.getRef());
-        final ReadDataReply readReply = testKit.expectMsgClass(testKit.duration("3 seconds"), ReadDataReply.class);
+        final ReadDataReply readReply = testKit.expectMsgClass(Duration.ofSeconds(3), ReadDataReply.class);
         assertEquals("Read node", containerNode, readReply.getNormalizedNode());
 
         // Commit the write transaction.
@@ -731,7 +730,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
         final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        assertTrue("Can commit", canCommitReply.getCanCommit());
 
         shard.tell(new CommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
         testKit.expectMsgClass(duration, CommitTransactionReply.class);
@@ -837,7 +836,7 @@ public class ShardTest extends AbstractShardTest {
                 testKit.getRef());
         }
 
-        testKit.expectMsgClass(testKit.duration("5 seconds"), CommitTransactionReply.class);
+        testKit.expectMsgClass(Duration.ofSeconds(5), CommitTransactionReply.class);
 
         final NormalizedNode<?, ?> actualNode = readStore(shard, TestModel.TEST_PATH);
         assertEquals(TestModel.TEST_QNAME.getLocalName(), containerNode, actualNode);
@@ -858,7 +857,9 @@ public class ShardTest extends AbstractShardTest {
 
         final ContainerNode writeData = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
         new WriteModification(TestModel.TEST_PATH, writeData).apply(modification);
-        final MapNode mergeData = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build();
+        final MapNode mergeData = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+                .addChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
+                .build();
         new MergeModification(TestModel.OUTER_LIST_PATH, mergeData).apply(modification);
 
         final TransactionIdentifier txId = nextTransactionId();
@@ -889,7 +890,9 @@ public class ShardTest extends AbstractShardTest {
 
         final ContainerNode writeData = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
         new WriteModification(TestModel.TEST_PATH, writeData).apply(modification);
-        final MapNode mergeData = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build();
+        final MapNode mergeData = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+                .addChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
+                .build();
         new MergeModification(TestModel.OUTER_LIST_PATH, mergeData).apply(modification);
 
         final TransactionIdentifier txId = nextTransactionId();
@@ -906,7 +909,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(txId, CURRENT_VERSION).toSerializable(), testKit.getRef());
         final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(CanCommitTransactionReply.class));
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        assertTrue("Can commit", canCommitReply.getCanCommit());
 
         // Send the CanCommitTransaction message.
 
@@ -929,7 +932,7 @@ public class ShardTest extends AbstractShardTest {
 
         // Setup a simulated transactions with a mock cohort.
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         final TransactionIdentifier transactionID = nextTransactionId();
         final NormalizedNode<?, ?> containerNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
@@ -942,7 +945,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
         final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        assertTrue("Can commit", canCommitReply.getCanCommit());
 
         // Send the CanCommitTransaction message.
 
@@ -972,7 +975,7 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
         final TransactionIdentifier transactionID = nextTransactionId();
 
         if (readWrite) {
@@ -990,7 +993,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
         final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        assertTrue("Can commit", canCommitReply.getCanCommit());
 
         shard.tell(new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
         testKit.expectMsgClass(duration, CommitTransactionReply.class);
@@ -1026,8 +1029,8 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
-        final Timeout timeout = new Timeout(duration);
+        final Duration duration = Duration.ofSeconds(5);
+        final Timeout timeout = Timeout.create(duration);
 
         // Setup 2 simulated transactions with mock cohorts. The first
         // one fails in the
@@ -1051,7 +1054,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
         final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        assertTrue("Can commit", canCommitReply.getCanCommit());
 
         // Send the CanCommitTransaction message for the 2nd Tx. This
         // should get queued and
@@ -1077,7 +1080,7 @@ public class ShardTest extends AbstractShardTest {
             }
         }, getSystem().dispatcher());
 
-        assertEquals("2nd CanCommit complete", true, latch.await(5, TimeUnit.SECONDS));
+        assertTrue("2nd CanCommit complete", latch.await(5, TimeUnit.SECONDS));
 
         final InOrder inOrder = inOrder(dataTree);
         inOrder.verify(dataTree).validate(any(DataTreeModification.class));
@@ -1100,8 +1103,8 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
-        final Timeout timeout = new Timeout(duration);
+        final Duration duration = Duration.ofSeconds(5);
+        final Timeout timeout = Timeout.create(duration);
 
         doThrow(new RuntimeException("mock preCommit failure")).when(dataTree)
         .prepare(any(DataTreeModification.class));
@@ -1121,7 +1124,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
         final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        assertTrue("Can commit", canCommitReply.getCanCommit());
 
         // Send the CanCommitTransaction message for the 2nd Tx. This
         // should get queued and
@@ -1147,7 +1150,7 @@ public class ShardTest extends AbstractShardTest {
             }
         }, getSystem().dispatcher());
 
-        assertEquals("2nd CanCommit complete", true, latch.await(5, TimeUnit.SECONDS));
+        assertTrue("2nd CanCommit complete", latch.await(5, TimeUnit.SECONDS));
 
         final InOrder inOrder = inOrder(dataTree);
         inOrder.verify(dataTree).validate(any(DataTreeModification.class));
@@ -1165,7 +1168,7 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
         final TransactionIdentifier transactionID1 = nextTransactionId();
 
         doThrow(new DataValidationFailedException(YangInstanceIdentifier.EMPTY, "mock canCommit failure"))
@@ -1191,7 +1194,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(transactionID2, CURRENT_VERSION).toSerializable(), testKit.getRef());
         final CanCommitTransactionReply reply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(CanCommitTransactionReply.class));
-        assertEquals("getCanCommit", true, reply.getCanCommit());
+        assertTrue("getCanCommit", reply.getCanCommit());
     }
 
     @Test
@@ -1212,7 +1215,7 @@ public class ShardTest extends AbstractShardTest {
         doThrow(new DataValidationFailedException(YangInstanceIdentifier.EMPTY, "mock canCommit failure"))
         .doNothing().when(dataTree).validate(any(DataTreeModification.class));
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         final TransactionIdentifier transactionID1 = nextTransactionId();
 
@@ -1264,7 +1267,7 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         final TransactionIdentifier transactionID = nextTransactionId();
 
@@ -1298,7 +1301,7 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         writeToStore(shard, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
         writeToStore(shard, TestModel.OUTER_LIST_PATH,
@@ -1427,7 +1430,7 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         final TransactionIdentifier transactionID1 = nextTransactionId();
         shard.tell(newBatchedModifications(transactionID1, TestModel.TEST_PATH,
@@ -1463,7 +1466,7 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         final ShardDataTree dataStore = shard.underlyingActor().getDataStore();
 
@@ -1518,7 +1521,7 @@ public class ShardTest extends AbstractShardTest {
             "testCanCommitBeforeReadyFailure");
 
         shard.tell(new CanCommitTransaction(nextTransactionId(), CURRENT_VERSION).toSerializable(), testKit.getRef());
-        testKit.expectMsgClass(testKit.duration("5 seconds"), akka.actor.Status.Failure.class);
+        testKit.expectMsgClass(Duration.ofSeconds(5), akka.actor.Status.Failure.class);
     }
 
     @Test
@@ -1529,8 +1532,8 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
-        final Timeout timeout = new Timeout(duration);
+        final Duration duration = Duration.ofSeconds(5);
+        final Timeout timeout = Timeout.create(duration);
 
         // Ready 2 transactions - the first one will be aborted.
 
@@ -1549,7 +1552,7 @@ public class ShardTest extends AbstractShardTest {
         shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
         CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
                 .fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        assertTrue("Can commit", canCommitReply.getCanCommit());
 
         // Send the CanCommitTransaction message for the 2nd Tx. This
         // should get queued and
@@ -1567,8 +1570,9 @@ public class ShardTest extends AbstractShardTest {
 
         // Wait for the 2nd Tx to complete the canCommit phase.
 
-        canCommitReply = (CanCommitTransactionReply) Await.result(canCommitFuture, duration);
-        assertEquals("Can commit", true, canCommitReply.getCanCommit());
+        canCommitReply = (CanCommitTransactionReply) Await.result(canCommitFuture,
+            FiniteDuration.create(5, TimeUnit.SECONDS));
+        assertTrue("Can commit", canCommitReply.getCanCommit());
     }
 
     @Test
@@ -1580,7 +1584,7 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         // Ready a tx.
 
@@ -1621,7 +1625,7 @@ public class ShardTest extends AbstractShardTest {
 
         ShardTestKit.waitUntilLeader(shard);
 
-        final FiniteDuration duration = testKit.duration("5 seconds");
+        final Duration duration = Duration.ofSeconds(5);
 
         // Ready 3 tx's.
 
@@ -1713,8 +1717,6 @@ public class ShardTest extends AbstractShardTest {
             }
         }
 
-        final ShardTestKit testKit = new ShardTestKit(getSystem());
-
         final Creator<Shard> creator = () -> new TestShard(newShardBuilder());
 
         final TestActorRef<Shard> shard = actorFactory.createTestActor(Props
@@ -1738,7 +1740,7 @@ public class ShardTest extends AbstractShardTest {
     private static void awaitAndValidateSnapshot(final AtomicReference<CountDownLatch> latch,
             final AtomicReference<Object> savedSnapshot, final NormalizedNode<?, ?> expectedRoot)
                     throws InterruptedException {
-        assertEquals("Snapshot saved", true, latch.get().await(5, TimeUnit.SECONDS));
+        assertTrue("Snapshot saved", latch.get().await(5, TimeUnit.SECONDS));
 
         assertTrue("Invalid saved snapshot " + savedSnapshot.get(), savedSnapshot.get() instanceof Snapshot);
 
@@ -1811,17 +1813,17 @@ public class ShardTest extends AbstractShardTest {
 
         final TestActorRef<Shard> shard = actorFactory.createTestActor(newShardProps(), "testOnDatastoreContext");
 
-        assertEquals("isRecoveryApplicable", true, shard.underlyingActor().persistence().isRecoveryApplicable());
+        assertTrue("isRecoveryApplicable", shard.underlyingActor().persistence().isRecoveryApplicable());
 
         ShardTestKit.waitUntilLeader(shard);
 
         shard.tell(dataStoreContextBuilder.persistent(false).build(), ActorRef.noSender());
 
-        assertEquals("isRecoveryApplicable", false, shard.underlyingActor().persistence().isRecoveryApplicable());
+        assertFalse("isRecoveryApplicable", shard.underlyingActor().persistence().isRecoveryApplicable());
 
         shard.tell(dataStoreContextBuilder.persistent(true).build(), ActorRef.noSender());
 
-        assertEquals("isRecoveryApplicable", true, shard.underlyingActor().persistence().isRecoveryApplicable());
+        assertTrue("isRecoveryApplicable", shard.underlyingActor().persistence().isRecoveryApplicable());
     }
 
     @Test
@@ -1841,8 +1843,7 @@ public class ShardTest extends AbstractShardTest {
 
         ShardLeaderStateChanged leaderStateChanged = MessageCollectorActor.expectFirstMatching(listener,
             ShardLeaderStateChanged.class);
-        assertEquals("getLocalShardDataTree present", true,
-            leaderStateChanged.getLocalShardDataTree().isPresent());
+        assertTrue("getLocalShardDataTree present", leaderStateChanged.getLocalShardDataTree().isPresent());
         assertSame("getLocalShardDataTree", shard.underlyingActor().getDataStore().getDataTree(),
             leaderStateChanged.getLocalShardDataTree().get());
 
@@ -1852,9 +1853,8 @@ public class ShardTest extends AbstractShardTest {
 
         shard.tell(new RequestVote(10000, "member2", 50, 50), testKit.getRef());
 
-        leaderStateChanged = MessageCollectorActor.expectFirstMatching(listener,
-            ShardLeaderStateChanged.class);
-        assertEquals("getLocalShardDataTree present", false, leaderStateChanged.getLocalShardDataTree().isPresent());
+        leaderStateChanged = MessageCollectorActor.expectFirstMatching(listener, ShardLeaderStateChanged.class);
+        assertFalse("getLocalShardDataTree present", leaderStateChanged.getLocalShardDataTree().isPresent());
     }
 
     @Test
@@ -1866,12 +1866,12 @@ public class ShardTest extends AbstractShardTest {
         shard.underlyingActor().handleNonRaftCommand(new FollowerInitialSyncUpStatus(false,
                 "member-1-shard-inventory-operational"));
 
-        assertEquals(false, shard.underlyingActor().getShardMBean().getFollowerInitialSyncStatus());
+        assertFalse(shard.underlyingActor().getShardMBean().getFollowerInitialSyncStatus());
 
         shard.underlyingActor().handleNonRaftCommand(new FollowerInitialSyncUpStatus(true,
                 "member-1-shard-inventory-operational"));
 
-        assertEquals(true, shard.underlyingActor().getShardMBean().getFollowerInitialSyncStatus());
+        assertTrue(shard.underlyingActor().getShardMBean().getFollowerInitialSyncStatus());
     }
 
     @Test
@@ -1894,7 +1894,7 @@ public class ShardTest extends AbstractShardTest {
         testKit.waitUntilNoLeader(shard);
 
         shard.tell(new RegisterDataTreeChangeListener(TestModel.TEST_PATH, dclActor, true), testKit.getRef());
-        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
             RegisterDataTreeNotificationListenerReply.class);
         assertNotNull("getListenerRegistrationPath", reply.getListenerRegistrationPath());
 
@@ -1924,7 +1924,7 @@ public class ShardTest extends AbstractShardTest {
         testKit.waitUntilNoLeader(shard);
 
         shard.tell(new RegisterDataTreeChangeListener(TestModel.TEST_PATH, dclActor, true), testKit.getRef());
-        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
             RegisterDataTreeNotificationListenerReply.class);
         assertNotNull("getListenerRegistrationPath", reply.getListenerRegistrationPath());
 
@@ -1973,7 +1973,7 @@ public class ShardTest extends AbstractShardTest {
             actorFactory.generateActorId(testName + "-DataTreeChangeListener"));
 
         followerShard.tell(new RegisterDataTreeChangeListener(TestModel.TEST_PATH, dclActor, true), testKit.getRef());
-        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
+        final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(Duration.ofSeconds(5),
             RegisterDataTreeNotificationListenerReply.class);
         assertNotNull("getListenerRegistrationPath", reply.getListenerRegistrationPath());