Eliminate use of deprecated mockito methods

[controller.git] / opendaylight / md-sal / sal-clustering-commons / src / test / java / org / opendaylight / controller / cluster / messaging / MessageSlicingIntegrationTest.java

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/messaging/MessageSlicingIntegrationTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/messaging/MessageSlicingIntegrationTest.java
index 23d04b5ed2d7b8226a957b8243bc9a88b852390b..61c06177991613d2013f2b1b4d0c96fc9e901664 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/messaging/MessageSlicingIntegrationTest.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/messaging/MessageSlicingIntegrationTest.java
@@ -9,7 +9,8 @@ package org.opendaylight.controller.cluster.messaging;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.mockito.Matchers.any;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.reset;
@@ -18,8 +19,8 @@ import static org.opendaylight.controller.cluster.messaging.MessageSlicerTest.sl
 
 import akka.actor.ActorRef;
 import akka.actor.ActorSystem;
-import akka.testkit.JavaTestKit;
 import akka.testkit.TestProbe;
+import akka.testkit.javadsl.TestKit;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.ObjectOutputStream;
@@ -78,7 +79,7 @@ public class MessageSlicingIntegrationTest {
 
     @AfterClass
     public static void staticTearDown() {
-        JavaTestKit.shutdownActorSystem(ACTOR_SYSTEM, Boolean.TRUE);
+        TestKit.shutdownActorSystem(ACTOR_SYSTEM, true);
     }
 
     @Test
@@ -119,7 +120,9 @@ public class MessageSlicingIntegrationTest {
 
         final BytesMessage message = new BytesMessage(new byte[]{1, 2, 3});
         try (MessageSlicer slicer = newMessageSlicer("testSingleSlice", SerializationUtils.serialize(message).length)) {
-            slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(), mockOnFailureCallback);
+            final boolean wasSliced = slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(),
+                    mockOnFailureCallback);
+            assertFalse(wasSliced);
 
             final BytesMessage sentMessage = sendToProbe.expectMsgClass(BytesMessage.class);
             assertEquals("Sent message", message, sentMessage);
@@ -214,7 +217,9 @@ public class MessageSlicingIntegrationTest {
         final BytesMessage message = new BytesMessage(new byte[]{1, 2, 3});
         final int messageSliceSize = SerializationUtils.serialize(message).length / 2;
         try (MessageSlicer slicer = newMessageSlicer("testSlicingWithFailure", messageSliceSize)) {
-            slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(), mockOnFailureCallback);
+            final boolean wasSliced = slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(),
+                    mockOnFailureCallback);
+            assertTrue(wasSliced);
 
             MessageSlice sliceMessage = sendToProbe.expectMsgClass(MessageSlice.class);
 
@@ -256,13 +261,16 @@ public class MessageSlicingIntegrationTest {
     }
 
     @SuppressWarnings("unchecked")
-    private void testSlicing(String logContext, int messageSliceSize, int expTotalSlices, byte[] messageData) {
+    private void testSlicing(final String logContext, final int messageSliceSize, final int expTotalSlices,
+            final byte[] messageData) {
         reset(mockAssembledMessageCallback);
 
         final BytesMessage message = new BytesMessage(messageData);
 
         try (MessageSlicer slicer = newMessageSlicer(logContext, messageSliceSize)) {
-            slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(), mockOnFailureCallback);
+            final boolean wasSliced = slice(slicer, IDENTIFIER, message, sendToProbe.ref(), replyToProbe.ref(),
+                    mockOnFailureCallback);
+            assertTrue(wasSliced);
 
             Identifier slicingId = null;
             int expLastSliceHashCode = SlicedMessageState.INITIAL_SLICE_HASH_CODE;
@@ -308,21 +316,23 @@ public class MessageSlicingIntegrationTest {
         assertEquals("Sender ActorRef", sender, senderActorRefCaptor.getValue());
     }
 
-    static void assertSuccessfulMessageSliceReply(MessageSliceReply reply, Identifier identifier, int sliceIndex) {
+    static void assertSuccessfulMessageSliceReply(final MessageSliceReply reply, final Identifier identifier,
+            final int sliceIndex) {
         assertEquals("Identifier", identifier, ((MessageSliceIdentifier)reply.getIdentifier())
                 .getClientIdentifier());
         assertEquals("SliceIndex", sliceIndex, reply.getSliceIndex());
     }
 
-    static void assertFailedMessageSliceReply(MessageSliceReply reply, Identifier identifier, boolean isRetriable) {
+    static void assertFailedMessageSliceReply(final MessageSliceReply reply, final Identifier identifier,
+            final boolean isRetriable) {
         assertEquals("Identifier", identifier, ((MessageSliceIdentifier)reply.getIdentifier())
                 .getClientIdentifier());
         assertEquals("Failure present", Boolean.TRUE, reply.getFailure().isPresent());
         assertEquals("isRetriable", isRetriable, reply.getFailure().get().isRetriable());
     }
 
-    static void assertMessageSlice(MessageSlice sliceMessage, Identifier identifier, int sliceIndex, int totalSlices,
-            int lastSliceHashCode, ActorRef replyTo) {
+    static void assertMessageSlice(final MessageSlice sliceMessage, final Identifier identifier, final int sliceIndex,
+            final int totalSlices, final int lastSliceHashCode, final ActorRef replyTo) {
         assertEquals("Identifier", identifier, ((MessageSliceIdentifier)sliceMessage.getIdentifier())
                 .getClientIdentifier());
         assertEquals("SliceIndex", sliceIndex, sliceMessage.getSliceIndex());
@@ -334,7 +344,7 @@ public class MessageSlicingIntegrationTest {
         }
     }
 
-    private MessageSlicer newMessageSlicer(String logContext, final int messageSliceSize) {
+    private static MessageSlicer newMessageSlicer(final String logContext, final int messageSliceSize) {
         return MessageSlicer.builder().messageSliceSize(messageSliceSize).logContext(logContext)
                 .fileBackedStreamFactory(FILE_BACKED_STREAM_FACTORY).build();
     }