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;
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;
@AfterClass
public static void staticTearDown() {
- JavaTestKit.shutdownActorSystem(ACTOR_SYSTEM, Boolean.TRUE);
+ TestKit.shutdownActorSystem(ACTOR_SYSTEM, true);
}
@Test
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);
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);
}
@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;
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());
+ assertEquals("isRetriable", isRetriable, reply.getFailure().orElseThrow().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());
}
}
- 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();
}