You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by ji...@apache.org on 2024/03/15 10:07:20 UTC
(flink) branch master updated: [FLINK-25544][streaming][JUnit5 Migration] The runtime package of module flink-stream-java
This is an automated email from the ASF dual-hosted git repository.
jiabaosun pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/flink.git
The following commit(s) were added to refs/heads/master by this push:
new 62f44e01185 [FLINK-25544][streaming][JUnit5 Migration] The runtime package of module flink-stream-java
62f44e01185 is described below
commit 62f44e0118539c1ed0dedf47099326f97c9d0427
Author: Jiabao Sun <ji...@apache.org>
AuthorDate: Fri Mar 15 18:07:12 2024 +0800
[FLINK-25544][streaming][JUnit5 Migration] The runtime package of module flink-stream-java
---
.../io/MultipleInputSelectionHandlerTest.java | 25 +-
.../runtime/io/RecordAttributesCombinerTest.java | 7 +-
.../runtime/io/StreamTaskNetworkInputTest.java | 26 +-
...taSkewStreamNetworkThroughputBenchmarkTest.java | 3 +-
...eamNetworkBroadcastThroughputBenchmarkTest.java | 3 +-
.../StreamNetworkPointToPointBenchmarkTest.java | 6 +-
.../StreamNetworkThroughputBenchmarkTest.java | 87 +--
.../AlignedCheckpointsMassiveRandomTest.java | 6 +-
.../io/checkpointing/AlignedCheckpointsTest.java | 383 +++++------
.../checkpointing/AlternatingCheckpointsTest.java | 313 ++++-----
.../io/checkpointing/BarrierAlignmentUtilTest.java | 19 +-
.../CheckpointBarrierTrackerTest.java | 199 +++---
.../checkpointing/CheckpointSequenceValidator.java | 53 +-
.../checkpointing/CheckpointedInputGateTest.java | 53 +-
.../io/checkpointing/InputProcessorUtilTest.java | 10 +-
.../UnalignedCheckpointsCancellationTest.java | 28 +-
.../io/checkpointing/UnalignedCheckpointsTest.java | 206 +++---
.../checkpointing/ValidatingCheckpointHandler.java | 7 +-
.../DemultiplexingRecordDeserializerTest.java | 63 +-
.../runtime/metrics/MinWatermarkGaugeTest.java | 17 +-
.../runtime/metrics/WatermarkGaugeTest.java | 13 +-
.../ContinuousFileProcessingRescalingTest.java | 16 +-
.../runtime/operators/MailboxOperatorTest.java | 17 +-
.../SourceOperatorLatencyMetricsTest.java | 30 +-
.../operators/StreamOperatorChainingTest.java | 30 +-
.../StreamSourceOperatorLatencyMetricsTest.java | 64 +-
.../StreamSourceOperatorWatermarksTest.java | 48 +-
.../operators/StreamTaskOperatorTimerTest.java | 14 +-
.../runtime/operators/StreamTaskTimerITCase.java | 47 +-
.../operators/TestProcessingTimeServiceTest.java | 20 +-
.../TimestampsAndWatermarksOperatorTest.java | 99 +--
.../runtime/operators/WriteAheadSinkTestBase.java | 5 +-
.../operators/sink/SinkWriterOperatorTestBase.java | 4 +-
.../streaming/runtime/operators/sink/TestSink.java | 4 +-
.../runtime/operators/sink/TestSinkV2.java | 4 +-
.../CommittableCollectorSerializerTest.java | 2 +-
.../operators/sink/deprecated/TestSinkV2.java | 4 +-
.../windowing/AllWindowTranslationTest.java | 435 ++++++------
.../windowing/ContinuousEventTimeTriggerTest.java | 181 +++--
.../ContinuousProcessingTimeTriggerTest.java | 14 +-
.../operators/windowing/CountTriggerTest.java | 207 +++---
.../DynamicEventTimeSessionWindowsTest.java | 100 ++-
.../DynamicProcessingTimeSessionWindowsTest.java | 99 ++-
.../windowing/EventTimeSessionWindowsTest.java | 108 ++-
.../operators/windowing/EventTimeTriggerTest.java | 218 +++---
.../EvictingWindowOperatorContractTest.java | 2 +-
.../windowing/EvictingWindowOperatorTest.java | 43 +-
.../operators/windowing/GlobalWindowsTest.java | 38 +-
.../operators/windowing/KeyMapPutIfAbsentTest.java | 132 ++--
.../runtime/operators/windowing/KeyMapPutTest.java | 182 +++--
.../runtime/operators/windowing/KeyMapTest.java | 460 ++++++-------
.../operators/windowing/MergingWindowSetTest.java | 412 ++++++-----
.../ProcessingTimeSessionWindowsTest.java | 96 ++-
.../windowing/ProcessingTimeTriggerTest.java | 208 +++---
.../windowing/ProcessingTimeoutTriggerTest.java | 151 ++---
.../operators/windowing/PurgingTriggerTest.java | 74 +-
.../RegularWindowOperatorContractTest.java | 17 +-
.../windowing/SlidingEventTimeWindowsTest.java | 298 ++++----
.../SlidingProcessingTimeWindowsTest.java | 282 ++++----
.../operators/windowing/TimeWindowTest.java | 85 +--
.../windowing/TimeWindowTranslationTest.java | 33 +-
.../windowing/TumblingEventTimeWindowsTest.java | 147 ++--
.../TumblingProcessingTimeWindowsTest.java | 150 ++--
.../windowing/WindowOperatorContractTest.java | 755 ++++++++++-----------
.../windowing/WindowOperatorMigrationTest.java | 55 +-
.../operators/windowing/WindowOperatorTest.java | 111 ++-
.../operators/windowing/WindowStaggerTest.java | 26 +-
.../operators/windowing/WindowTranslationTest.java | 454 +++++++------
.../partitioner/BroadcastPartitionerTest.java | 24 +-
.../partitioner/ForwardPartitionerTest.java | 12 +-
.../runtime/partitioner/GlobalPartitionerTest.java | 12 +-
.../partitioner/KeyGroupStreamPartitionerTest.java | 30 +-
.../partitioner/RebalancePartitionerTest.java | 16 +-
.../partitioner/RescalePartitionerTest.java | 81 ++-
.../partitioner/ShufflePartitionerTest.java | 23 +-
.../runtime/partitioner/StreamPartitionerTest.java | 29 +-
.../streamrecord/StreamElementSerializerTest.java | 52 +-
.../runtime/streamrecord/StreamRecordTest.java | 146 ++--
.../runtime/tasks/AsyncCheckpointRunnableTest.java | 49 +-
...heckpointExceptionHandlerConfigurationTest.java | 31 +-
...ToStreamOperatorRecipientExactlyOnceITCase.java | 2 +-
.../tasks/InterruptSensitiveRestoreTest.java | 27 +-
.../streaming/runtime/tasks/LifeCycleMonitor.java | 9 +-
.../runtime/tasks/LocalStateForwardingTest.java | 45 +-
...tStreamTaskChainedSourcesCheckpointingTest.java | 133 ++--
.../runtime/tasks/MultipleInputStreamTaskTest.java | 334 +++++----
.../runtime/tasks/OneInputStreamTaskTest.java | 159 ++---
.../streaming/runtime/tasks/OperatorChainTest.java | 19 +-
.../tasks/ProcessingTimeServiceImplTest.java | 82 ++-
.../runtime/tasks/RestoreStreamTaskTest.java | 88 +--
.../tasks/SourceExternalCheckpointTriggerTest.java | 51 +-
.../tasks/SourceOperatorStreamTaskTest.java | 2 +-
.../runtime/tasks/SourceTaskTerminationTest.java | 42 +-
.../runtime/tasks/StreamMockEnvironment.java | 2 +-
.../runtime/tasks/StreamOperatorWrapperTest.java | 86 ++-
.../tasks/StreamTaskCancellationBarrierTest.java | 67 +-
.../runtime/tasks/StreamTaskCancellationTest.java | 39 +-
.../tasks/StreamTaskExecutionDecorationTest.java | 41 +-
.../tasks/StreamTaskFinalCheckpointsTest.java | 186 ++---
.../streaming/runtime/tasks/StreamTaskITCase.java | 36 +-
.../tasks/StreamTaskMailboxTestHarness.java | 8 +-
...treamTaskMultipleInputSelectiveReadingTest.java | 60 +-
.../tasks/StreamTaskSelectiveReadingTest.java | 46 +-
.../runtime/tasks/StreamTaskSystemExitTest.java | 50 +-
.../runtime/tasks/StreamTaskTerminationTest.java | 26 +-
.../streaming/runtime/tasks/StreamTaskTest.java | 3 -
.../runtime/tasks/StreamTaskTestHarness.java | 9 +-
.../runtime/tasks/StreamTaskTestHarnessTest.java | 111 ++-
.../tasks/SubtaskCheckpointCoordinatorTest.java | 139 ++--
.../runtime/tasks/SynchronousCheckpointITCase.java | 52 +-
.../runtime/tasks/SynchronousCheckpointTest.java | 40 +-
.../tasks/SystemProcessingTimeServiceTest.java | 212 +++---
.../tasks/TaskCheckpointingBehaviourTest.java | 23 +-
.../runtime/tasks/TwoInputStreamTaskTest.java | 190 +++---
.../tasks/mailbox/MailboxExecutorImplTest.java | 81 +--
.../runtime/tasks/mailbox/TaskMailboxImplTest.java | 192 +++---
.../tasks/mailbox/TaskMailboxProcessorTest.java | 117 ++--
.../watermarkstatus/WatermarkStatusTest.java | 62 +-
118 files changed, 5088 insertions(+), 5796 deletions(-)
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/MultipleInputSelectionHandlerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/MultipleInputSelectionHandlerTest.java
index 6e11e752a84..43258718d83 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/MultipleInputSelectionHandlerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/MultipleInputSelectionHandlerTest.java
@@ -19,39 +19,38 @@ package org.apache.flink.streaming.runtime.io;
import org.apache.flink.streaming.api.operators.InputSelection;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link MultipleInputSelectionHandler}. */
-public class MultipleInputSelectionHandlerTest {
+class MultipleInputSelectionHandlerTest {
@Test
- public void testShouldSetAvailableForAnotherInput() {
+ void testShouldSetAvailableForAnotherInput() {
InputSelection secondAndThird = new InputSelection.Builder().select(2).select(3).build();
MultipleInputSelectionHandler selectionHandler =
new MultipleInputSelectionHandler(() -> secondAndThird, 3);
selectionHandler.nextSelection();
- assertFalse(selectionHandler.shouldSetAvailableForAnotherInput());
+ assertThat(selectionHandler.shouldSetAvailableForAnotherInput()).isFalse();
selectionHandler.setUnavailableInput(0);
- assertFalse(selectionHandler.shouldSetAvailableForAnotherInput());
+ assertThat(selectionHandler.shouldSetAvailableForAnotherInput()).isFalse();
selectionHandler.setUnavailableInput(2);
- assertTrue(selectionHandler.shouldSetAvailableForAnotherInput());
+ assertThat(selectionHandler.shouldSetAvailableForAnotherInput()).isTrue();
selectionHandler.setAvailableInput(0);
- assertTrue(selectionHandler.shouldSetAvailableForAnotherInput());
+ assertThat(selectionHandler.shouldSetAvailableForAnotherInput()).isTrue();
selectionHandler.setAvailableInput(2);
- assertFalse(selectionHandler.shouldSetAvailableForAnotherInput());
+ assertThat(selectionHandler.shouldSetAvailableForAnotherInput()).isFalse();
}
@Test
- public void testLargeInputCount() {
+ void testLargeInputCount() {
int inputCount = MultipleInputSelectionHandler.MAX_SUPPORTED_INPUT_COUNT;
InputSelection.Builder builder = new InputSelection.Builder();
@@ -67,8 +66,8 @@ public class MultipleInputSelectionHandlerTest {
for (int i = 0; i < inputCount - 1; i++) {
selectionHandler.setUnavailableInput(i);
}
- assertTrue(selectionHandler.isAnyInputAvailable());
+ assertThat(selectionHandler.isAnyInputAvailable()).isTrue();
selectionHandler.setUnavailableInput(inputCount - 1);
- assertFalse(selectionHandler.isAnyInputAvailable());
+ assertThat(selectionHandler.isAnyInputAvailable()).isFalse();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/RecordAttributesCombinerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/RecordAttributesCombinerTest.java
index da97a2eb1c5..8ce25034449 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/RecordAttributesCombinerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/RecordAttributesCombinerTest.java
@@ -28,10 +28,10 @@ import java.util.Collections;
import static org.assertj.core.api.Assertions.assertThat;
/** Test for {@link RecordAttributesCombiner}. */
-public class RecordAttributesCombinerTest {
+class RecordAttributesCombinerTest {
@Test
- public void testCombineRecordAttributes() throws Exception {
+ void testCombineRecordAttributes() throws Exception {
final RecordAttributesCombiner combiner = new RecordAttributesCombiner(3);
CollectingDataOutput<Object> collectingDataOutput = new CollectingDataOutput<>();
final RecordAttributes backlogRecordAttribute =
@@ -60,8 +60,7 @@ public class RecordAttributesCombinerTest {
}
@Test
- public void testCombinerOnlyOutputNonBacklogWhenAllInputChannelAreNonBacklog()
- throws Exception {
+ void testCombinerOnlyOutputNonBacklogWhenAllInputChannelAreNonBacklog() throws Exception {
final RecordAttributesCombiner combiner = new RecordAttributesCombiner(2);
CollectingDataOutput<Object> collectingDataOutput = new CollectingDataOutput<>();
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/StreamTaskNetworkInputTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/StreamTaskNetworkInputTest.java
index ecdbf27aa3d..61842c64460 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/StreamTaskNetworkInputTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/StreamTaskNetworkInputTest.java
@@ -60,8 +60,8 @@ import org.apache.flink.streaming.runtime.watermarkstatus.StatusWatermarkValve;
import org.apache.flink.streaming.runtime.watermarkstatus.WatermarkStatus;
import org.apache.flink.util.clock.SystemClock;
-import org.junit.After;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.ByteBuffer;
@@ -79,19 +79,19 @@ import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link StreamTaskNetworkInput}. */
-public class StreamTaskNetworkInputTest {
+class StreamTaskNetworkInputTest {
private static final int PAGE_SIZE = 1000;
private final IOManager ioManager = new IOManagerAsync();
- @After
- public void tearDown() throws Exception {
+ @AfterEach
+ void tearDown() throws Exception {
ioManager.close();
}
@Test
- public void testIsAvailableWithBufferedDataInDeserializer() throws Exception {
+ void testIsAvailableWithBufferedDataInDeserializer() throws Exception {
List<BufferOrEvent> buffers = Collections.singletonList(createDataBuffer());
VerifyRecordsDataOutput<Long> output = new VerifyRecordsDataOutput<>();
@@ -108,7 +108,7 @@ public class StreamTaskNetworkInputTest {
* record.
*/
@Test
- public void testNoDataProcessedAfterCheckpointBarrier() throws Exception {
+ void testNoDataProcessedAfterCheckpointBarrier() throws Exception {
CheckpointBarrier barrier =
new CheckpointBarrier(0, 0, CheckpointOptions.forCheckpointWithDefaultLocation());
@@ -135,7 +135,7 @@ public class StreamTaskNetworkInputTest {
}
@Test
- public void testSnapshotAfterEndOfPartition() throws Exception {
+ void testSnapshotAfterEndOfPartition() throws Exception {
int numInputChannels = 1;
int channelId = 0;
int checkpointId = 0;
@@ -186,7 +186,7 @@ public class StreamTaskNetworkInputTest {
}
@Test
- public void testReleasingDeserializerTimely() throws Exception {
+ void testReleasingDeserializerTimely() throws Exception {
int numInputChannels = 2;
LongSerializer inSerializer = LongSerializer.INSTANCE;
@@ -212,7 +212,7 @@ public class StreamTaskNetworkInputTest {
}
@Test
- public void testInputStatusAfterEndOfRecovery() throws Exception {
+ void testInputStatusAfterEndOfRecovery() throws Exception {
int numInputChannels = 2;
LongSerializer inSerializer = LongSerializer.INSTANCE;
StreamTestSingleInputGate<Long> inputGate =
@@ -235,7 +235,7 @@ public class StreamTaskNetworkInputTest {
}
@Test
- public void testRecordsAreProcessedInBatches() throws Exception {
+ void testRecordsAreProcessedInBatches() throws Exception {
int numInputChannels = 2;
Random random = new Random();
LongSerializer inSerializer = LongSerializer.INSTANCE;
@@ -270,7 +270,7 @@ public class StreamTaskNetworkInputTest {
}
@Test
- public void testBatchProcessingRecordsCanBeInterrupted() throws Exception {
+ void testBatchProcessingRecordsCanBeInterrupted() throws Exception {
int numInputChannels = 2;
Random random = new Random();
LongSerializer inSerializer = LongSerializer.INSTANCE;
@@ -321,7 +321,7 @@ public class StreamTaskNetworkInputTest {
}
@Test
- public void testProcessRecordAttributes() throws Exception {
+ void testProcessRecordAttributes() throws Exception {
int numInputChannels = 2;
LongSerializer inSerializer = LongSerializer.INSTANCE;
StreamTestSingleInputGate<Long> inputGate =
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/DataSkewStreamNetworkThroughputBenchmarkTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/DataSkewStreamNetworkThroughputBenchmarkTest.java
index 7dc604374e9..2bab57e694b 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/DataSkewStreamNetworkThroughputBenchmarkTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/DataSkewStreamNetworkThroughputBenchmarkTest.java
@@ -21,8 +21,7 @@ package org.apache.flink.streaming.runtime.io.benchmark;
/**
* Tests for various network benchmarks based on {@link DataSkewStreamNetworkThroughputBenchmark}.
*/
-public class DataSkewStreamNetworkThroughputBenchmarkTest
- extends StreamNetworkThroughputBenchmarkTest {
+class DataSkewStreamNetworkThroughputBenchmarkTest extends StreamNetworkThroughputBenchmarkTest {
@Override
protected StreamNetworkThroughputBenchmark createBenchmark() {
return new DataSkewStreamNetworkThroughputBenchmark();
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkBroadcastThroughputBenchmarkTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkBroadcastThroughputBenchmarkTest.java
index 27fff51d210..774aa8f023c 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkBroadcastThroughputBenchmarkTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkBroadcastThroughputBenchmarkTest.java
@@ -21,8 +21,7 @@ package org.apache.flink.streaming.runtime.io.benchmark;
/**
* Tests for various network benchmarks based on {@link StreamNetworkBroadcastThroughputBenchmark}.
*/
-public class StreamNetworkBroadcastThroughputBenchmarkTest
- extends StreamNetworkThroughputBenchmarkTest {
+class StreamNetworkBroadcastThroughputBenchmarkTest extends StreamNetworkThroughputBenchmarkTest {
@Override
protected StreamNetworkThroughputBenchmark createBenchmark() {
return new StreamNetworkBroadcastThroughputBenchmark();
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkPointToPointBenchmarkTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkPointToPointBenchmarkTest.java
index 6c4feee4375..8d2a0ad509f 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkPointToPointBenchmarkTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkPointToPointBenchmarkTest.java
@@ -18,12 +18,12 @@
package org.apache.flink.streaming.runtime.io.benchmark;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/** Tests for {@link StreamNetworkPointToPointBenchmark}. */
-public class StreamNetworkPointToPointBenchmarkTest {
+class StreamNetworkPointToPointBenchmarkTest {
@Test
- public void test() throws Exception {
+ void test() throws Exception {
StreamNetworkPointToPointBenchmark benchmark = new StreamNetworkPointToPointBenchmark();
benchmark.setUp(10);
try {
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkThroughputBenchmarkTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkThroughputBenchmarkTest.java
index 19b3e7585ce..e9011fe51dd 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkThroughputBenchmarkTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/benchmark/StreamNetworkThroughputBenchmarkTest.java
@@ -20,22 +20,21 @@ package org.apache.flink.streaming.runtime.io.benchmark;
import org.apache.flink.configuration.NettyShuffleEnvironmentOptions;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
/** Tests for various network benchmarks based on {@link StreamNetworkThroughputBenchmark}. */
-public class StreamNetworkThroughputBenchmarkTest {
- @Rule public ExpectedException expectedException = ExpectedException.none();
+class StreamNetworkThroughputBenchmarkTest {
protected StreamNetworkThroughputBenchmark createBenchmark() {
return new StreamNetworkThroughputBenchmark();
}
@Test
- public void pointToPointBenchmark() throws Exception {
+ void pointToPointBenchmark() throws Exception {
StreamNetworkThroughputBenchmark benchmark = createBenchmark();
benchmark.setUp(1, 1, 100);
try {
@@ -46,7 +45,7 @@ public class StreamNetworkThroughputBenchmarkTest {
}
@Test
- public void largeLocalMode() throws Exception {
+ void largeLocalMode() throws Exception {
StreamNetworkThroughputBenchmark env = new StreamNetworkThroughputBenchmark();
env.setUp(4, 10, 100, true);
env.executeBenchmark(10_000_000);
@@ -54,7 +53,7 @@ public class StreamNetworkThroughputBenchmarkTest {
}
@Test
- public void largeRemoteMode() throws Exception {
+ void largeRemoteMode() throws Exception {
StreamNetworkThroughputBenchmark env = new StreamNetworkThroughputBenchmark();
env.setUp(4, 10, 100, false);
env.executeBenchmark(10_000_000);
@@ -62,7 +61,7 @@ public class StreamNetworkThroughputBenchmarkTest {
}
@Test
- public void largeRemoteAlwaysFlush() throws Exception {
+ void largeRemoteAlwaysFlush() throws Exception {
StreamNetworkThroughputBenchmark env = new StreamNetworkThroughputBenchmark();
env.setUp(1, 1, 0, false);
env.executeBenchmark(1_000_000);
@@ -70,50 +69,54 @@ public class StreamNetworkThroughputBenchmarkTest {
}
@Test
- public void remoteModeInsufficientBuffersSender() throws Exception {
+ void remoteModeInsufficientBuffersSender() {
StreamNetworkThroughputBenchmark env = new StreamNetworkThroughputBenchmark();
int writers = 2;
int channels = 2;
- expectedException.expect(IOException.class);
- expectedException.expectMessage("Insufficient number of network buffers");
-
- env.setUp(
- writers,
- channels,
- 100,
- false,
- writers * channels - 1,
- writers
- * channels
- * NettyShuffleEnvironmentOptions.NETWORK_BUFFERS_PER_CHANNEL
- .defaultValue());
+ assertThatThrownBy(
+ () ->
+ env.setUp(
+ writers,
+ channels,
+ 100,
+ false,
+ writers * channels - 1,
+ writers
+ * channels
+ * NettyShuffleEnvironmentOptions
+ .NETWORK_BUFFERS_PER_CHANNEL
+ .defaultValue()))
+ .isInstanceOf(IOException.class)
+ .hasMessageContaining("Insufficient number of network buffers");
}
@Test
- public void remoteModeInsufficientBuffersReceiver() throws Exception {
+ void remoteModeInsufficientBuffersReceiver() throws Exception {
StreamNetworkThroughputBenchmark env = new StreamNetworkThroughputBenchmark();
int writers = 2;
int channels = 2;
- expectedException.expect(IOException.class);
- expectedException.expectMessage("Insufficient number of network buffers");
-
- env.setUp(
- writers,
- channels,
- 100,
- false,
- writers * channels,
- writers
- * channels
- * NettyShuffleEnvironmentOptions.NETWORK_BUFFERS_PER_CHANNEL
- .defaultValue()
- - 1);
+ assertThatThrownBy(
+ () ->
+ env.setUp(
+ writers,
+ channels,
+ 100,
+ false,
+ writers * channels,
+ writers
+ * channels
+ * NettyShuffleEnvironmentOptions
+ .NETWORK_BUFFERS_PER_CHANNEL
+ .defaultValue()
+ - 1))
+ .isInstanceOf(IOException.class)
+ .hasMessageContaining("Insufficient number of network buffers");
}
@Test
- public void remoteModeMinimumBuffers() throws Exception {
+ void remoteModeMinimumBuffers() throws Exception {
StreamNetworkThroughputBenchmark env = new StreamNetworkThroughputBenchmark();
int writers = 2;
int channels = 2;
@@ -134,7 +137,7 @@ public class StreamNetworkThroughputBenchmarkTest {
}
@Test
- public void pointToMultiPointBenchmark() throws Exception {
+ void pointToMultiPointBenchmark() throws Exception {
StreamNetworkThroughputBenchmark benchmark = createBenchmark();
benchmark.setUp(1, 100, 100);
try {
@@ -145,7 +148,7 @@ public class StreamNetworkThroughputBenchmarkTest {
}
@Test
- public void multiPointToPointBenchmark() throws Exception {
+ void multiPointToPointBenchmark() throws Exception {
StreamNetworkThroughputBenchmark benchmark = createBenchmark();
benchmark.setUp(4, 1, 100);
try {
@@ -156,7 +159,7 @@ public class StreamNetworkThroughputBenchmarkTest {
}
@Test
- public void multiPointToMultiPointBenchmark() throws Exception {
+ void multiPointToMultiPointBenchmark() throws Exception {
StreamNetworkThroughputBenchmark benchmark = createBenchmark();
benchmark.setUp(4, 100, 100);
try {
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlignedCheckpointsMassiveRandomTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlignedCheckpointsMassiveRandomTest.java
index e94423aff6a..6f15a3332bf 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlignedCheckpointsMassiveRandomTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlignedCheckpointsMassiveRandomTest.java
@@ -31,7 +31,7 @@ import org.apache.flink.runtime.mailbox.SyncMailboxExecutor;
import org.apache.flink.runtime.operators.testutils.DummyCheckpointInvokable;
import org.apache.flink.util.clock.SystemClock;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.Arrays;
@@ -47,12 +47,12 @@ import java.util.stream.IntStream;
* The test generates two random streams (input channels) which independently and randomly generate
* checkpoint barriers. The two streams are very unaligned, putting heavy work on the BarrierBuffer.
*/
-public class AlignedCheckpointsMassiveRandomTest {
+class AlignedCheckpointsMassiveRandomTest {
private static final int PAGE_SIZE = 1024;
@Test
- public void testWithTwoChannelsAndRandomBarriers() throws Exception {
+ void testWithTwoChannelsAndRandomBarriers() throws Exception {
NetworkBufferPool networkBufferPool1 = null;
NetworkBufferPool networkBufferPool2 = null;
try {
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlignedCheckpointsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlignedCheckpointsTest.java
index 1b6af2d63b7..01925e5e937 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlignedCheckpointsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlignedCheckpointsTest.java
@@ -19,7 +19,6 @@
package org.apache.flink.streaming.runtime.io.checkpointing;
import org.apache.flink.core.memory.MemorySegment;
-import org.apache.flink.runtime.checkpoint.CheckpointException;
import org.apache.flink.runtime.checkpoint.CheckpointFailureReason;
import org.apache.flink.runtime.checkpoint.CheckpointOptions;
import org.apache.flink.runtime.checkpoint.channel.InputChannelInfo;
@@ -42,12 +41,9 @@ import org.apache.flink.runtime.operators.testutils.DummyCheckpointInvokable;
import org.apache.flink.streaming.runtime.io.MockInputGate;
import org.apache.flink.util.clock.SystemClock;
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.Description;
-import org.hamcrest.Matchers;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.ArrayList;
@@ -57,18 +53,10 @@ import java.util.Random;
import java.util.stream.IntStream;
import static org.apache.flink.streaming.runtime.io.checkpointing.UnalignedCheckpointsTest.addSequence;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for the behavior of aligned checkpoints. */
-public class AlignedCheckpointsTest {
+class AlignedCheckpointsTest {
protected static final int PAGE_SIZE = 512;
@@ -82,8 +70,8 @@ public class AlignedCheckpointsTest {
private MockInputGate mockInputGate;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
testStartTimeNanos = System.nanoTime();
}
@@ -157,10 +145,10 @@ public class AlignedCheckpointsTest {
new SyncMailboxExecutor());
}
- @After
- public void ensureEmpty() throws Exception {
- assertFalse(inputGate.pollNext().isPresent());
- assertTrue(inputGate.isFinished());
+ @AfterEach
+ void ensureEmpty() throws Exception {
+ assertThat(inputGate.pollNext()).isNotPresent();
+ assertThat(inputGate.isFinished()).isTrue();
inputGate.close();
}
@@ -174,7 +162,7 @@ public class AlignedCheckpointsTest {
* input channel.
*/
@Test
- public void testSingleChannelNoBarriers() throws Exception {
+ void testSingleChannelNoBarriers() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(0), createBuffer(0),
createBuffer(0), createEndOfPartition(0)
@@ -182,10 +170,10 @@ public class AlignedCheckpointsTest {
inputGate = createCheckpointedInputGate(1, sequence);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
- assertEquals(0L, inputGate.getAlignmentDurationNanos());
+ assertThat(inputGate.getAlignmentDurationNanos()).isZero();
}
/**
@@ -193,7 +181,7 @@ public class AlignedCheckpointsTest {
* multiple input channels.
*/
@Test
- public void testMultiChannelNoBarriers() throws Exception {
+ void testMultiChannelNoBarriers() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(2),
createBuffer(2),
@@ -212,10 +200,10 @@ public class AlignedCheckpointsTest {
inputGate = createCheckpointedInputGate(4, sequence);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
- assertEquals(0L, inputGate.getAlignmentDurationNanos());
+ assertThat(inputGate.getAlignmentDurationNanos()).isZero();
}
/**
@@ -223,7 +211,7 @@ public class AlignedCheckpointsTest {
* channel, and checkpoint events.
*/
@Test
- public void testSingleChannelWithBarriers() throws Exception {
+ void testSingleChannelWithBarriers() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(0),
createBuffer(0),
@@ -249,7 +237,7 @@ public class AlignedCheckpointsTest {
handler.setNextExpectedCheckpointId(1L);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@@ -258,7 +246,7 @@ public class AlignedCheckpointsTest {
* channels.
*/
@Test
- public void testMultiChannelWithBarriers() throws Exception {
+ void testMultiChannelWithBarriers() throws Exception {
BufferOrEvent[] sequence = {
// checkpoint with data from multi channels
createBuffer(0),
@@ -308,7 +296,7 @@ public class AlignedCheckpointsTest {
check(sequence[0], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[1], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[2], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(1L, handler.getNextExpectedCheckpointId());
+ assertThat(handler.getNextExpectedCheckpointId()).isOne();
long startTs = System.nanoTime();
@@ -317,9 +305,9 @@ public class AlignedCheckpointsTest {
check(sequence[4], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[5], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[6], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(2L, handler.getNextExpectedCheckpointId());
+ assertThat(handler.getNextExpectedCheckpointId()).isEqualTo(2L);
validateAlignmentTime(startTs, inputGate);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
// pre checkpoint 2
check(sequence[7], inputGate.pollNext().get(), PAGE_SIZE);
@@ -327,16 +315,16 @@ public class AlignedCheckpointsTest {
check(sequence[9], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[10], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[11], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(2L, handler.getNextExpectedCheckpointId());
+ assertThat(handler.getNextExpectedCheckpointId()).isEqualTo(2L);
// checkpoint 2 barriers come together
startTs = System.nanoTime();
check(sequence[12], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[13], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[14], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(3L, handler.getNextExpectedCheckpointId());
+ assertThat(handler.getNextExpectedCheckpointId()).isEqualTo(3L);
validateAlignmentTime(startTs, inputGate);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[15], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[16], inputGate.pollNext().get(), PAGE_SIZE);
@@ -347,15 +335,15 @@ public class AlignedCheckpointsTest {
check(sequence[19], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[20], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[21], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(4L, handler.getNextExpectedCheckpointId());
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(handler.getNextExpectedCheckpointId()).isEqualTo(4L);
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
// checkpoint 4
check(sequence[22], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[23], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[24], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(5L, handler.getNextExpectedCheckpointId());
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(handler.getNextExpectedCheckpointId()).isEqualTo(5L);
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
// remaining data
check(sequence[25], inputGate.pollNext().get(), PAGE_SIZE);
@@ -369,7 +357,7 @@ public class AlignedCheckpointsTest {
* later checkpoint on a non-blocked input.
*/
@Test
- public void testMultiChannelJumpingOverCheckpoint() throws Exception {
+ void testMultiChannelJumpingOverCheckpoint() throws Exception {
BufferOrEvent[] sequence = {
// checkpoint 1
/* 0 */ createBuffer(0),
@@ -412,53 +400,53 @@ public class AlignedCheckpointsTest {
// checkpoint 1
check(sequence[3], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(1L, inputGate.getLatestCheckpointId());
+ assertThat(inputGate.getLatestCheckpointId()).isOne();
check(sequence[4], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[5], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[6], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[7], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[8], inputGate.pollNext().get(), PAGE_SIZE);
// alignment of checkpoint 2
check(sequence[9], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(2L, inputGate.getLatestCheckpointId());
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(2L);
check(sequence[10], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[11], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[12], inputGate.pollNext().get(), PAGE_SIZE);
// checkpoint 2 aborted, checkpoint 3 started
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(0, 1));
+ assertThat(mockInputGate.getBlockedChannels()).containsExactlyInAnyOrder(0, 1);
check(sequence[13], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(3L, inputGate.getLatestCheckpointId());
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(2));
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(3L);
+ assertThat(mockInputGate.getBlockedChannels()).containsExactlyInAnyOrder(2);
check(sequence[14], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[15], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[16], inputGate.pollNext().get(), PAGE_SIZE);
// checkpoint 3 aborted, checkpoint 4 started
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(0, 2));
+ assertThat(mockInputGate.getBlockedChannels()).containsExactlyInAnyOrder(0, 2);
check(sequence[17], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(4L, inputGate.getLatestCheckpointId());
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(1));
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(4L);
+ assertThat(mockInputGate.getBlockedChannels()).containsExactlyInAnyOrder(1);
check(sequence[18], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[19], inputGate.pollNext().get(), PAGE_SIZE);
// checkpoint 4 aborted (due to end of partition)
check(sequence[20], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[21], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[22], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[23], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[24], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(1, handler.getTriggeredCheckpointCounter());
- assertEquals(3, handler.getAbortedCheckpointCounter());
+ assertThat(handler.getTriggeredCheckpointCounter()).isOne();
+ assertThat(handler.getAbortedCheckpointCounter()).isEqualTo(3L);
}
@Test
- public void testMetrics() throws Exception {
+ void testMetrics() throws Exception {
List<BufferOrEvent> output = new ArrayList<>();
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler();
int numberOfChannels = 3;
@@ -505,29 +493,21 @@ public class AlignedCheckpointsTest {
long startDelay = System.currentTimeMillis() - checkpointBarrierCreation;
long alignmentDuration = System.nanoTime() - alignmentStartNanos;
- assertEquals(checkpointId, inputGate.getCheckpointBarrierHandler().getLatestCheckpointId());
- assertThat(
- inputGate.getCheckpointStartDelayNanos() / 1_000_000,
- Matchers.greaterThanOrEqualTo(sleepTime));
- assertThat(
- inputGate.getCheckpointStartDelayNanos() / 1_000_000,
- Matchers.lessThanOrEqualTo(startDelay));
-
- assertTrue(handler.lastAlignmentDurationNanos.isDone());
- assertThat(
- handler.lastAlignmentDurationNanos.get() / 1_000_000,
- Matchers.greaterThanOrEqualTo(sleepTime));
- assertThat(
- handler.lastAlignmentDurationNanos.get(),
- Matchers.lessThanOrEqualTo(alignmentDuration));
-
- assertTrue(handler.lastBytesProcessedDuringAlignment.isDone());
- assertThat(
- handler.lastBytesProcessedDuringAlignment.get(), Matchers.equalTo(3L * bufferSize));
+ assertThat(inputGate.getCheckpointBarrierHandler().getLatestCheckpointId())
+ .isEqualTo(checkpointId);
+ assertThat(inputGate.getCheckpointStartDelayNanos() / 1_000_000)
+ .isBetween(sleepTime, startDelay);
+
+ assertThat(handler.lastAlignmentDurationNanos).isDone();
+ assertThat(handler.lastAlignmentDurationNanos.get() / 1_000_000)
+ .isGreaterThanOrEqualTo(sleepTime);
+ assertThat(handler.lastAlignmentDurationNanos.get()).isLessThanOrEqualTo(alignmentDuration);
+
+ assertThat(handler.lastBytesProcessedDuringAlignment).isCompletedWithValue(3L * bufferSize);
}
@Test
- public void testMissingCancellationBarriers() throws Exception {
+ void testMissingCancellationBarriers() throws Exception {
BufferOrEvent[] sequence = {
createBarrier(1L, 0),
createCancellationBarrier(3L, 1),
@@ -539,14 +519,14 @@ public class AlignedCheckpointsTest {
inputGate = createCheckpointedInputGate(2, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
}
@Test
- public void testStartAlignmentWithClosedChannels() throws Exception {
+ void testStartAlignmentWithClosedChannels() throws Exception {
BufferOrEvent[] sequence = {
// close some channels immediately
createEndOfPartition(2),
@@ -587,14 +567,14 @@ public class AlignedCheckpointsTest {
// checkpoint 2 alignment
check(sequence[5], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[6], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(2L, inputGate.getLatestCheckpointId());
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(2L);
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
// checkpoint 3 alignment
check(sequence[7], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[8], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(3L, inputGate.getLatestCheckpointId());
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(3L);
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
// after checkpoint 3
check(sequence[9], inputGate.pollNext().get(), PAGE_SIZE);
@@ -605,15 +585,15 @@ public class AlignedCheckpointsTest {
// checkpoint 4 alignment
check(sequence[14], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(4L, inputGate.getLatestCheckpointId());
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(4L);
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[15], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[16], inputGate.pollNext().get(), PAGE_SIZE);
}
@Test
- public void testEndOfStreamWhileCheckpoint() throws Exception {
+ void testEndOfStreamWhileCheckpoint() throws Exception {
BufferOrEvent[] sequence = {
// one checkpoint
createBarrier(1, 0),
@@ -644,22 +624,22 @@ public class AlignedCheckpointsTest {
check(sequence[0], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[1], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[2], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[3], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[4], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[5], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(1L, inputGate.getLatestCheckpointId());
+ assertThat(inputGate.getLatestCheckpointId()).isOne();
// alignment of second checkpoint
check(sequence[6], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(2L, inputGate.getLatestCheckpointId());
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(2L);
check(sequence[7], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[8], inputGate.pollNext().get(), PAGE_SIZE);
// first end-of-partition encountered: checkpoint will not be completed
check(sequence[9], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[10], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[11], inputGate.pollNext().get(), PAGE_SIZE);
@@ -667,7 +647,7 @@ public class AlignedCheckpointsTest {
}
@Test
- public void testSingleChannelAbortCheckpoint() throws Exception {
+ void testSingleChannelAbortCheckpoint() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(0),
createBarrier(1, 0),
@@ -686,48 +666,45 @@ public class AlignedCheckpointsTest {
toNotify.setNextExpectedCheckpointId(1);
check(sequence[0], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[1], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(0L, inputGate.getAlignmentDurationNanos());
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(inputGate.getAlignmentDurationNanos()).isZero();
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
toNotify.setNextExpectedCheckpointId(2);
check(sequence[2], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[3], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
toNotify.setNextExpectedCheckpointId(5);
check(sequence[4], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[5], inputGate.pollNext().get(), 0);
- assertEquals(4L, inputGate.getLatestCheckpointId());
- assertEquals(4, toNotify.getLastCanceledCheckpointId());
- assertEquals(
- CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER,
- toNotify.getCheckpointFailureReason());
- assertEquals(0L, inputGate.getAlignmentDurationNanos());
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(4L);
+ assertThat(toNotify.getLastCanceledCheckpointId()).isEqualTo(4);
+ assertThat(toNotify.getCheckpointFailureReason())
+ .isEqualTo(CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER);
+ assertThat(inputGate.getAlignmentDurationNanos()).isZero();
check(sequence[6], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(5L, inputGate.getLatestCheckpointId());
- assertEquals(4, toNotify.getLastCanceledCheckpointId());
- assertEquals(
- CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER,
- toNotify.getCheckpointFailureReason());
- assertEquals(0L, inputGate.getAlignmentDurationNanos());
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(5L);
+ assertThat(toNotify.getLastCanceledCheckpointId()).isEqualTo(4);
+ assertThat(toNotify.getCheckpointFailureReason())
+ .isEqualTo(CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER);
+ assertThat(inputGate.getAlignmentDurationNanos()).isZero();
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[7], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[8], inputGate.pollNext().get(), 0);
check(sequence[9], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(6L, inputGate.getLatestCheckpointId());
- assertEquals(6, toNotify.getLastCanceledCheckpointId());
- assertEquals(
- CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER,
- toNotify.getCheckpointFailureReason());
- assertEquals(0L, inputGate.getAlignmentDurationNanos());
-
- assertEquals(3, toNotify.getTriggeredCheckpointCounter());
- assertEquals(2, toNotify.getAbortedCheckpointCounter());
+ assertThat(inputGate.getLatestCheckpointId()).isEqualTo(6L);
+ assertThat(toNotify.getLastCanceledCheckpointId()).isEqualTo(6);
+ assertThat(toNotify.getCheckpointFailureReason())
+ .isEqualTo(CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER);
+ assertThat(inputGate.getAlignmentDurationNanos()).isZero();
+
+ assertThat(toNotify.getTriggeredCheckpointCounter()).isEqualTo(3);
+ assertThat(toNotify.getAbortedCheckpointCounter()).isEqualTo(2);
}
@Test
- public void testMultiChannelAbortCheckpoint() throws Exception {
+ void testMultiChannelAbortCheckpoint() throws Exception {
BufferOrEvent[] sequence = {
// some buffers and a successful checkpoint
/* 0 */ createBuffer(0),
@@ -792,31 +769,30 @@ public class AlignedCheckpointsTest {
startTs = System.nanoTime();
toNotify.setNextExpectedCheckpointId(1);
check(sequence[3], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(1));
+ assertThat(mockInputGate.getBlockedChannels()).containsExactly(1);
check(sequence[4], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(1, 2));
+ assertThat(mockInputGate.getBlockedChannels()).containsExactlyInAnyOrder(1, 2);
check(sequence[5], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[6], inputGate.pollNext().get(), PAGE_SIZE);
validateAlignmentTime(startTs, inputGate);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[7], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[8], inputGate.pollNext().get(), PAGE_SIZE);
// alignment of second checkpoint
check(sequence[9], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(0));
+ assertThat(mockInputGate.getBlockedChannels()).containsExactly(0);
check(sequence[10], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(0, 2));
+ assertThat(mockInputGate.getBlockedChannels()).containsExactlyInAnyOrder(0, 2);
check(sequence[11], inputGate.pollNext().get(), PAGE_SIZE);
// canceled checkpoint on last barrier
check(sequence[12], inputGate.pollNext().get(), 0);
- assertEquals(2, toNotify.getLastCanceledCheckpointId());
- assertThat(mockInputGate.getBlockedChannels(), empty());
- assertEquals(
- CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER,
- toNotify.getCheckpointFailureReason());
+ assertThat(toNotify.getLastCanceledCheckpointId()).isEqualTo(2);
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
+ assertThat(toNotify.getCheckpointFailureReason())
+ .isEqualTo(CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER);
check(sequence[13], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[14], inputGate.pollNext().get(), PAGE_SIZE);
@@ -827,22 +803,21 @@ public class AlignedCheckpointsTest {
check(sequence[16], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[17], inputGate.pollNext().get(), PAGE_SIZE);
validateAlignmentTime(startTs, inputGate);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[18], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[19], inputGate.pollNext().get(), PAGE_SIZE);
// this checkpoint gets immediately canceled
check(sequence[20], inputGate.pollNext().get(), 0);
- assertEquals(4, toNotify.getLastCanceledCheckpointId());
- assertEquals(
- CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER,
- toNotify.getCheckpointFailureReason());
- assertEquals(0L, inputGate.getAlignmentDurationNanos());
+ assertThat(toNotify.getLastCanceledCheckpointId()).isEqualTo(4);
+ assertThat(toNotify.getCheckpointFailureReason())
+ .isEqualTo(CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER);
+ assertThat(inputGate.getAlignmentDurationNanos()).isZero();
check(sequence[21], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[22], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[23], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
// some buffers
check(sequence[24], inputGate.pollNext().get(), PAGE_SIZE);
@@ -856,24 +831,23 @@ public class AlignedCheckpointsTest {
check(sequence[28], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[29], inputGate.pollNext().get(), PAGE_SIZE);
validateAlignmentTime(startTs, inputGate);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[30], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[31], inputGate.pollNext().get(), PAGE_SIZE);
// this checkpoint gets immediately canceled
check(sequence[32], inputGate.pollNext().get(), 0);
check(sequence[33], inputGate.pollNext().get(), 0);
- assertEquals(6, toNotify.getLastCanceledCheckpointId());
- assertEquals(
- CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER,
- toNotify.getCheckpointFailureReason());
- assertEquals(0L, inputGate.getAlignmentDurationNanos());
+ assertThat(toNotify.getLastCanceledCheckpointId()).isEqualTo(6);
+ assertThat(toNotify.getCheckpointFailureReason())
+ .isEqualTo(CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER);
+ assertThat(inputGate.getAlignmentDurationNanos()).isZero();
check(sequence[34], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
check(sequence[35], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(3, toNotify.getTriggeredCheckpointCounter());
- assertEquals(3, toNotify.getAbortedCheckpointCounter());
+ assertThat(toNotify.getTriggeredCheckpointCounter()).isEqualTo(3);
+ assertThat(toNotify.getAbortedCheckpointCounter()).isEqualTo(3);
}
/**
@@ -882,7 +856,7 @@ public class AlignedCheckpointsTest {
* <p>The newer checkpoint barrier must not try to cancel the already canceled checkpoint.
*/
@Test
- public void testAbortOnCanceledBarriers() throws Exception {
+ void testAbortOnCanceledBarriers() throws Exception {
BufferOrEvent[] sequence = {
// starting a checkpoint
/* 0 */ createBuffer(1),
@@ -934,11 +908,10 @@ public class AlignedCheckpointsTest {
// cancelled by cancellation barrier
check(sequence[4], inputGate.pollNext().get(), 0);
check(sequence[5], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(1, toNotify.getLastCanceledCheckpointId());
- assertEquals(
- CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER,
- toNotify.getCheckpointFailureReason());
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(toNotify.getLastCanceledCheckpointId()).isOne();
+ assertThat(toNotify.getCheckpointFailureReason())
+ .isEqualTo(CheckpointFailureReason.CHECKPOINT_DECLINED_ON_CANCELLATION_BARRIER);
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
// the next checkpoint alignment
startTs = System.nanoTime();
@@ -948,7 +921,7 @@ public class AlignedCheckpointsTest {
// ignored barrier and unblock channel directly
check(sequence[9], inputGate.pollNext().get(), PAGE_SIZE);
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(1));
+ assertThat(mockInputGate.getBlockedChannels()).containsExactly(1);
check(sequence[10], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[11], inputGate.pollNext().get(), PAGE_SIZE);
@@ -957,15 +930,15 @@ public class AlignedCheckpointsTest {
check(sequence[12], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[13], inputGate.pollNext().get(), PAGE_SIZE);
validateAlignmentTime(startTs, inputGate);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
// trailing data
check(sequence[14], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[15], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[16], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(1, toNotify.getTriggeredCheckpointCounter());
- assertEquals(1, toNotify.getAbortedCheckpointCounter());
+ assertThat(toNotify.getTriggeredCheckpointCounter()).isOne();
+ assertThat(toNotify.getAbortedCheckpointCounter()).isOne();
}
/**
@@ -973,7 +946,7 @@ public class AlignedCheckpointsTest {
* to receiving a newer checkpoint barrier.
*/
@Test
- public void testIgnoreCancelBarrierIfCheckpointSubsumed() throws Exception {
+ void testIgnoreCancelBarrierIfCheckpointSubsumed() throws Exception {
BufferOrEvent[] sequence = {
// starting a checkpoint
/* 0 */ createBuffer(2),
@@ -1020,13 +993,12 @@ public class AlignedCheckpointsTest {
// future barrier aborts checkpoint
startTs = System.nanoTime();
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(0, 1));
+ assertThat(mockInputGate.getBlockedChannels()).containsExactlyInAnyOrder(0, 1);
check(sequence[4], inputGate.pollNext().get(), PAGE_SIZE);
- assertEquals(3, toNotify.getLastCanceledCheckpointId());
- assertEquals(
- CheckpointFailureReason.CHECKPOINT_DECLINED_SUBSUMED,
- toNotify.getCheckpointFailureReason());
- assertThat(mockInputGate.getBlockedChannels(), containsInAnyOrder(2));
+ assertThat(toNotify.getLastCanceledCheckpointId()).isEqualTo(3);
+ assertThat(toNotify.getCheckpointFailureReason())
+ .isEqualTo(CheckpointFailureReason.CHECKPOINT_DECLINED_SUBSUMED);
+ assertThat(mockInputGate.getBlockedChannels()).containsExactly(2);
check(sequence[5], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[6], inputGate.pollNext().get(), PAGE_SIZE);
@@ -1040,7 +1012,7 @@ public class AlignedCheckpointsTest {
check(sequence[10], inputGate.pollNext().get(), PAGE_SIZE);
check(sequence[11], inputGate.pollNext().get(), PAGE_SIZE);
validateAlignmentTime(startTs, inputGate);
- assertThat(mockInputGate.getBlockedChannels(), empty());
+ assertThat(mockInputGate.getBlockedChannels()).isEmpty();
// remaining data
check(sequence[12], inputGate.pollNext().get(), PAGE_SIZE);
@@ -1048,12 +1020,12 @@ public class AlignedCheckpointsTest {
check(sequence[14], inputGate.pollNext().get(), PAGE_SIZE);
// check overall notifications
- assertEquals(1, toNotify.getTriggeredCheckpointCounter());
- assertEquals(1, toNotify.getAbortedCheckpointCounter());
+ assertThat(toNotify.getTriggeredCheckpointCounter()).isOne();
+ assertThat(toNotify.getAbortedCheckpointCounter()).isOne();
}
@Test
- public void testTriggerCheckpointsWithEndOfPartition() throws Exception {
+ void testTriggerCheckpointsWithEndOfPartition() throws Exception {
BufferOrEvent[] sequence = {
createBarrier(1, 0), createBarrier(1, 1), createEndOfPartition(2)
};
@@ -1065,13 +1037,13 @@ public class AlignedCheckpointsTest {
check(bufferOrEvent, inputGate.pollNext().get(), PAGE_SIZE);
}
- assertThat(validator.triggeredCheckpoints, contains(1L));
- assertEquals(0, validator.getAbortedCheckpointCounter());
- assertThat(inputGate.getCheckpointBarrierHandler().isCheckpointPending(), equalTo(false));
+ assertThat(validator.triggeredCheckpoints).containsExactly(1L);
+ assertThat(validator.getAbortedCheckpointCounter()).isZero();
+ assertThat(inputGate.getCheckpointBarrierHandler().isCheckpointPending()).isFalse();
}
@Test
- public void testDeduplicateChannelsWithBothBarrierAndEndOfPartition() throws Exception {
+ void testDeduplicateChannelsWithBothBarrierAndEndOfPartition() throws Exception {
BufferOrEvent[] sequence = {
/* 0 */ createBarrier(2, 0),
/* 1 */ createBarrier(2, 1),
@@ -1087,17 +1059,17 @@ public class AlignedCheckpointsTest {
}
// Here the checkpoint should not be triggered.
- assertEquals(0, validator.getTriggeredCheckpointCounter());
- assertEquals(0, validator.getAbortedCheckpointCounter());
+ assertThat(validator.getTriggeredCheckpointCounter()).isZero();
+ assertThat(validator.getAbortedCheckpointCounter()).isZero();
// The last barrier aligned the pending checkpoint 2.
- assertEquals(sequence[3], inputGate.pollNext().get());
- assertThat(validator.triggeredCheckpoints, contains(2L));
- assertThat(inputGate.getCheckpointBarrierHandler().isCheckpointPending(), equalTo(false));
+ assertThat(inputGate.pollNext()).hasValue(sequence[3]);
+ assertThat(validator.triggeredCheckpoints).containsExactly(2L);
+ assertThat(inputGate.getCheckpointBarrierHandler().isCheckpointPending()).isFalse();
}
@Test
- public void testTriggerCheckpointsAfterReceivedEndOfPartition() throws Exception {
+ void testTriggerCheckpointsAfterReceivedEndOfPartition() throws Exception {
BufferOrEvent[] sequence = {
/* 0 */ createEndOfPartition(2),
/* 2 */ createBarrier(6, 0),
@@ -1113,9 +1085,9 @@ public class AlignedCheckpointsTest {
check(bufferOrEvent, inputGate.pollNext().get(), PAGE_SIZE);
}
- assertThat(validator.triggeredCheckpoints, contains(6L, 7L));
- assertEquals(0, validator.getAbortedCheckpointCounter());
- assertThat(inputGate.getCheckpointBarrierHandler().isCheckpointPending(), equalTo(false));
+ assertThat(validator.triggeredCheckpoints).containsExactly(6L, 7L);
+ assertThat(validator.getAbortedCheckpointCounter()).isZero();
+ assertThat(inputGate.getCheckpointBarrierHandler().isCheckpointPending()).isFalse();
}
// ------------------------------------------------------------------------
@@ -1156,21 +1128,21 @@ public class AlignedCheckpointsTest {
}
private static void check(BufferOrEvent expected, BufferOrEvent present, int pageSize) {
- assertNotNull(expected);
- assertNotNull(present);
- assertEquals(expected.isBuffer(), present.isBuffer());
+ assertThat(expected).isNotNull();
+ assertThat(present).isNotNull();
+ assertThat(present.isBuffer()).isEqualTo(expected.isBuffer());
if (expected.isBuffer()) {
- assertEquals(
- expected.getBuffer().getMaxCapacity(), present.getBuffer().getMaxCapacity());
- assertEquals(expected.getBuffer().getSize(), present.getBuffer().getSize());
+ assertThat(present.getBuffer().getMaxCapacity())
+ .isEqualTo(expected.getBuffer().getMaxCapacity());
+ assertThat(present.getBuffer().getSize()).isEqualTo(expected.getBuffer().getSize());
MemorySegment expectedMem = expected.getBuffer().getMemorySegment();
MemorySegment presentMem = present.getBuffer().getMemorySegment();
- assertTrue(
- "memory contents differs",
- expectedMem.compare(presentMem, 0, 0, pageSize) == 0);
+ assertThat(expectedMem.compare(presentMem, 0, 0, pageSize))
+ .as("memory contents differs")
+ .isZero();
} else {
- assertEquals(expected.getEvent(), present.getEvent());
+ assertThat(present.getEvent()).isEqualTo(expected.getEvent());
}
}
@@ -1178,41 +1150,12 @@ public class AlignedCheckpointsTest {
long alignmentStartTimestamp, CheckpointedInputGate inputGate) {
long elapsedAlignment = System.nanoTime() - alignmentStartTimestamp;
long elapsedTotalTime = System.nanoTime() - testStartTimeNanos;
- assertThat(
- inputGate.getAlignmentDurationNanos(),
- Matchers.lessThanOrEqualTo(elapsedAlignment));
+ assertThat(inputGate.getAlignmentDurationNanos()).isLessThanOrEqualTo(elapsedAlignment);
// Barrier lag is calculated with System.currentTimeMillis(), so we need a tolerance of 1ms
// when comparing to time elapsed via System.nanoTime()
long tolerance = 1_000_000;
- assertThat(
- inputGate.getCheckpointStartDelayNanos(),
- Matchers.lessThanOrEqualTo(elapsedTotalTime + tolerance));
- }
-
- // ------------------------------------------------------------------------
- // Testing Mocks
- // ------------------------------------------------------------------------
-
- /** A validation matcher for checkpoint exception against failure reason. */
- public static class CheckpointExceptionMatcher extends BaseMatcher<CheckpointException> {
-
- private final CheckpointFailureReason failureReason;
-
- public CheckpointExceptionMatcher(CheckpointFailureReason failureReason) {
- this.failureReason = failureReason;
- }
-
- @Override
- public boolean matches(Object o) {
- return o != null
- && o.getClass() == CheckpointException.class
- && ((CheckpointException) o).getCheckpointFailureReason().equals(failureReason);
- }
-
- @Override
- public void describeTo(Description description) {
- description.appendText("CheckpointException - reason = " + failureReason);
- }
+ assertThat(inputGate.getCheckpointStartDelayNanos())
+ .isLessThanOrEqualTo(elapsedTotalTime + tolerance);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlternatingCheckpointsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlternatingCheckpointsTest.java
index 84215eec7e4..a992987c906 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlternatingCheckpointsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/AlternatingCheckpointsTest.java
@@ -44,7 +44,7 @@ import org.apache.flink.util.clock.Clock;
import org.apache.flink.util.clock.ManualClock;
import org.apache.flink.util.concurrent.FutureUtils;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import javax.annotation.Nonnull;
@@ -58,8 +58,7 @@ import java.util.PriorityQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
-import static java.util.Collections.singletonList;
-import static junit.framework.TestCase.assertTrue;
+import static org.apache.flink.core.testutils.FlinkAssertions.assertThatFuture;
import static org.apache.flink.runtime.checkpoint.CheckpointOptions.AlignmentType;
import static org.apache.flink.runtime.checkpoint.CheckpointOptions.alignedNoTimeout;
import static org.apache.flink.runtime.checkpoint.CheckpointOptions.alignedWithTimeout;
@@ -68,17 +67,10 @@ import static org.apache.flink.runtime.checkpoint.CheckpointType.CHECKPOINT;
import static org.apache.flink.runtime.io.network.api.serialization.EventSerializer.toBuffer;
import static org.apache.flink.runtime.io.network.util.TestBufferFactory.createBuffer;
import static org.apache.flink.runtime.state.CheckpointStorageLocationReference.getDefault;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThanOrEqualTo;
-import static org.hamcrest.Matchers.lessThanOrEqualTo;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.assertj.core.api.Assertions.assertThat;
/** Timing out aligned checkpoints tests. */
-public class AlternatingCheckpointsTest {
+class AlternatingCheckpointsTest {
private final ClockWithDelayedActions clock = new ClockWithDelayedActions();
@@ -95,7 +87,7 @@ public class AlternatingCheckpointsTest {
* buffers.
*/
@Test
- public void testChannelResetOnNewBarrier() throws Exception {
+ void testChannelResetOnNewBarrier() throws Exception {
RecordingChannelStateWriter stateWriter = new RecordingChannelStateWriter();
try (CheckpointedInputGate gate =
new TestCheckpointedInputGateBuilder(
@@ -123,7 +115,7 @@ public class AlternatingCheckpointsTest {
1,
gate);
- assertFalse(stateWriter.getAddedInput().isEmpty());
+ assertThat(stateWriter.getAddedInput().isEmpty()).isFalse();
}
}
@@ -132,7 +124,7 @@ public class AlternatingCheckpointsTest {
* another channel, this UC barrier should be processed by the UC controller.
*/
@Test
- public void testSwitchToUnalignedByUpstream() throws Exception {
+ void testSwitchToUnalignedByUpstream() throws Exception {
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
try (CheckpointedInputGate gate =
new TestCheckpointedInputGateBuilder(2, getTestBarrierHandlerFactory(target))
@@ -149,28 +141,28 @@ public class AlternatingCheckpointsTest {
toBuffer(new EventAnnouncement(aligned, 0), true),
0,
gate); // process announcement but not the barrier
- assertEquals(0, target.triggeredCheckpointCounter);
+ assertThat(target.triggeredCheckpointCounter).isZero();
send(
toBuffer(aligned.asUnaligned(), true),
1,
gate); // pretend it came from upstream before the first (AC) barrier was picked
// up
- assertEquals(1, target.triggeredCheckpointCounter);
+ assertThat(target.triggeredCheckpointCounter).isOne();
}
}
@Test
- public void testCheckpointHandling() throws Exception {
+ void testCheckpointHandling() throws Exception {
testBarrierHandling(CHECKPOINT);
}
@Test
- public void testSavepointHandling() throws Exception {
+ void testSavepointHandling() throws Exception {
testBarrierHandling(SavepointType.savepoint(SavepointFormatType.CANONICAL));
}
@Test
- public void testAlternation() throws Exception {
+ void testAlternation() throws Exception {
int numBarriers = 123;
int numChannels = 123;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
@@ -197,12 +189,12 @@ public class AlternatingCheckpointsTest {
gate);
}
}
- assertEquals(barriers, target.triggeredCheckpoints);
+ assertThat(target.triggeredCheckpoints).isEqualTo(barriers);
}
}
@Test
- public void testAlignedAfterTimedOut() throws Exception {
+ void testAlignedAfterTimedOut() throws Exception {
int numChannels = 1;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
long alignedCheckpointTimeout = 100L;
@@ -226,7 +218,7 @@ public class AlternatingCheckpointsTest {
clock.advanceTime(alignedCheckpointTimeout + 1, TimeUnit.MILLISECONDS);
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
Buffer barrier2 =
barrier(
2,
@@ -239,20 +231,19 @@ public class AlternatingCheckpointsTest {
assertAnnouncement(gate);
assertBarrier(gate);
- assertEquals(2, target.getTriggeredCheckpointCounter());
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(
+ assertThat(target.getTriggeredCheckpointCounter()).isEqualTo(2);
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(
unaligned(CheckpointType.CHECKPOINT, getDefault()),
alignedWithTimeout(
CheckpointType.CHECKPOINT,
getDefault(),
- alignedCheckpointTimeout)));
+ alignedCheckpointTimeout));
}
}
@Test
- public void testAlignedNeverTimeoutableCheckpoint() throws Exception {
+ void testAlignedNeverTimeoutableCheckpoint() throws Exception {
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
try (CheckpointedInputGate gate =
@@ -263,15 +254,15 @@ public class AlternatingCheckpointsTest {
Buffer neverTimeoutableCheckpoint = withTimeout(Integer.MAX_VALUE);
send(neverTimeoutableCheckpoint, 0, gate);
sendData(1000, 1, gate);
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
send(neverTimeoutableCheckpoint, 1, gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
}
}
@Test
- public void testTimeoutAlignment() throws Exception {
+ void testTimeoutAlignment() throws Exception {
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
try (CheckpointedInputGate gate =
new TestCheckpointedInputGateBuilder(2, getTestBarrierHandlerFactory(target))
@@ -283,7 +274,7 @@ public class AlternatingCheckpointsTest {
}
@Test
- public void testTimeoutAlignmentAfterProcessingBarrier() throws Exception {
+ void testTimeoutAlignmentAfterProcessingBarrier() throws Exception {
int numChannels = 3;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
try (CheckpointedInputGate gate =
@@ -302,7 +293,7 @@ public class AlternatingCheckpointsTest {
2,
gate);
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
testTimeoutBarrierOnTwoChannels(target, gate, Integer.MAX_VALUE);
}
@@ -321,16 +312,15 @@ public class AlternatingCheckpointsTest {
getChannel(gate, 1).onBuffer(dataBuffer(), 0, 0, 0);
getChannel(gate, 1).onBuffer(checkpointBarrier.retainBuffer(), 1, 0, 0);
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
assertAnnouncement(gate);
clock.advanceTime(alignedCheckpointTimeout * 2, TimeUnit.MILLISECONDS);
assertAnnouncement(gate);
assertBarrier(gate);
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(unaligned(CheckpointType.CHECKPOINT, getDefault())));
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(unaligned(CheckpointType.CHECKPOINT, getDefault()));
// Followed by overtaken buffers
assertData(gate);
assertData(gate);
@@ -346,7 +336,7 @@ public class AlternatingCheckpointsTest {
* EventAnnouncement} but before/during processing the first {@link CheckpointBarrier}.
*/
@Test
- public void testTimeoutAlignmentOnFirstBarrier() throws Exception {
+ void testTimeoutAlignmentOnFirstBarrier() throws Exception {
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
CheckpointedInputGate gate =
@@ -363,20 +353,20 @@ public class AlternatingCheckpointsTest {
(getChannel(gate, i)).onBuffer(checkpointBarrier.retainBuffer(), 0, 0, 0);
}
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
for (int i = 0; i < numChannels; i++) {
assertAnnouncement(gate);
}
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
clock.advanceTime(alignedCheckpointTimeout * 4, TimeUnit.MILLISECONDS);
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
}
@Test
- public void testTimeoutAlignmentBeforeFirstBarrier() throws Exception {
+ void testTimeoutAlignmentBeforeFirstBarrier() throws Exception {
// given: Local channels.
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
@@ -396,11 +386,11 @@ public class AlternatingCheckpointsTest {
// then: The UC is triggered as soon as the first barrier is received.
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
}
@Test
- public void testTimeoutAlignmentWhenLocalBarrierFirst() throws Exception {
+ void testTimeoutAlignmentWhenLocalBarrierFirst() throws Exception {
// given: Gate with remote and local channels.
int numChannels = 3;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
@@ -426,7 +416,7 @@ public class AlternatingCheckpointsTest {
assertBarrier(gate);
// then: The checkpoint executed successfully.
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
// given: The time in the future.
clock.advanceTime(alignedCheckpointTimeout + 1, TimeUnit.MILLISECONDS);
@@ -439,7 +429,7 @@ public class AlternatingCheckpointsTest {
assertBarrier(gate);
// then: Nothing happens because the alignment timeout should only start after this barrier.
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
// when: Receiving the barrier from second channel(with/without) announcement after time
// more than alignment timeout.
@@ -449,15 +439,14 @@ public class AlternatingCheckpointsTest {
assertBarrier(gate);
// then: The checkpoint should started as unaligned.
- assertEquals(2, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isEqualTo(2);
List<CheckpointOptions> checkpointOptions = target.getTriggeredCheckpointOptions();
- assertEquals(
- AlignmentType.UNALIGNED,
- checkpointOptions.get(checkpointOptions.size() - 1).getAlignment());
+ assertThat(checkpointOptions.get(checkpointOptions.size() - 1).getAlignment())
+ .isEqualTo(AlignmentType.UNALIGNED);
}
@Test
- public void testActiveTimeoutAfterLocalBarrierPassiveTimeout() throws Exception {
+ void testActiveTimeoutAfterLocalBarrierPassiveTimeout() throws Exception {
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
try (CheckpointedInputGate gate =
@@ -476,7 +465,7 @@ public class AlternatingCheckpointsTest {
getChannel(gate, 1).onBuffer(dataBuffer(), 0, 0, 0);
getChannel(gate, 1).onBuffer(checkpointBarrier.retainBuffer(), 1, 0, 0);
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
clock.advanceTimeWithoutRunningCallables(
alignedCheckpointTimeout + 1, TimeUnit.MILLISECONDS);
// the announcement should passively time out causing the barriers to overtake the data
@@ -485,10 +474,9 @@ public class AlternatingCheckpointsTest {
// we simulate active time out firing after the passive one
clock.executeCallables();
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(unaligned(CheckpointType.CHECKPOINT, getDefault())));
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(unaligned(CheckpointType.CHECKPOINT, getDefault()));
// Followed by overtaken buffers
assertData(gate);
assertData(gate);
@@ -501,7 +489,7 @@ public class AlternatingCheckpointsTest {
* least second checkpoint.
*/
@Test
- public void testTimeoutAlignmentOnAnnouncementForSecondCheckpoint() throws Exception {
+ void testTimeoutAlignmentOnAnnouncementForSecondCheckpoint() throws Exception {
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
CheckpointedInputGate gate =
@@ -513,7 +501,7 @@ public class AlternatingCheckpointsTest {
long alignedCheckpointTimeout = 100;
performFirstCheckpoint(numChannels, target, gate, alignedCheckpointTimeout);
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
Buffer checkpointBarrier = withTimeout(2, alignedCheckpointTimeout);
@@ -522,16 +510,16 @@ public class AlternatingCheckpointsTest {
(getChannel(gate, i)).onBuffer(checkpointBarrier.retainBuffer(), 2, 0, 0);
}
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
for (int i = 0; i < numChannels; i++) {
assertAnnouncement(gate);
}
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
clock.advanceTime(alignedCheckpointTimeout * 4, TimeUnit.MILLISECONDS);
// the barrier should overtake the data buffers
assertBarrier(gate);
- assertEquals(2, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isEqualTo(2);
}
private void performFirstCheckpoint(
@@ -544,7 +532,7 @@ public class AlternatingCheckpointsTest {
for (int i = 0; i < numChannels; i++) {
(getChannel(gate, i)).onBuffer(checkpointBarrier.retainBuffer(), 0, 0, 0);
}
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
for (int i = 0; i < numChannels; i++) {
assertAnnouncement(gate);
}
@@ -554,7 +542,7 @@ public class AlternatingCheckpointsTest {
}
@Test
- public void testPassiveTimeoutAlignmentOnAnnouncement() throws Exception {
+ void testPassiveTimeoutAlignmentOnAnnouncement() throws Exception {
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
CheckpointedInputGate gate =
@@ -568,7 +556,7 @@ public class AlternatingCheckpointsTest {
Buffer checkpointBarrier = withTimeout(alignedCheckpointTimeout);
(getChannel(gate, 0)).onBuffer(checkpointBarrier.retainBuffer(), 0, 0, 0);
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
assertAnnouncement(gate);
assertBarrier(gate);
clock.advanceTimeWithoutRunningCallables(
@@ -577,11 +565,11 @@ public class AlternatingCheckpointsTest {
assertAnnouncement(gate);
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
}
@Test
- public void testActiveTimeoutAlignmentOnFirstBarrier() throws Exception {
+ void testActiveTimeoutAlignmentOnFirstBarrier() throws Exception {
int numberOfChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
CheckpointedInputGate gate =
@@ -597,13 +585,12 @@ public class AlternatingCheckpointsTest {
send(checkpointBarrier, 0, gate);
clock.advanceTime(alignedCheckpointTimeout + 1, TimeUnit.MILLISECONDS);
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(unaligned(CheckpointType.CHECKPOINT, getDefault())));
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(unaligned(CheckpointType.CHECKPOINT, getDefault()));
}
@Test
- public void testAllChannelsUnblockedAfteralignedCheckpointTimeout() throws Exception {
+ void testAllChannelsUnblockedAfteralignedCheckpointTimeout() throws Exception {
int numberOfChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
CheckpointedInputGate gate =
@@ -634,16 +621,15 @@ public class AlternatingCheckpointsTest {
((TestInputChannel) gate.getChannel(1)).setBlocked(true);
send(checkpointBarrierBuffer, 1, gate);
- assertThat(target.getTriggeredCheckpointOptions().size(), equalTo(1));
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(unaligned(CheckpointType.CHECKPOINT, getDefault())));
- assertFalse(((TestInputChannel) gate.getChannel(0)).isBlocked());
- assertFalse(((TestInputChannel) gate.getChannel(1)).isBlocked());
+ assertThat(target.getTriggeredCheckpointOptions()).hasSize(1);
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(unaligned(CheckpointType.CHECKPOINT, getDefault()));
+ assertThat(((TestInputChannel) gate.getChannel(0)).isBlocked()).isFalse();
+ assertThat(((TestInputChannel) gate.getChannel(1)).isBlocked()).isFalse();
}
@Test
- public void testNoActiveTimeoutAlignmentAfterLastBarrier() throws Exception {
+ void testNoActiveTimeoutAlignmentAfterLastBarrier() throws Exception {
int numberOfChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
CheckpointedInputGate gate =
@@ -660,13 +646,12 @@ public class AlternatingCheckpointsTest {
send(checkpointBarrier, 1, gate);
clock.advanceTime(alignedCheckpointTimeout + 1, TimeUnit.MILLISECONDS);
- assertThat(
- target.getTriggeredCheckpointOptions(),
- not(contains(unaligned(CheckpointType.CHECKPOINT, getDefault()))));
+ assertThat(target.getTriggeredCheckpointOptions())
+ .doesNotContain(unaligned(CheckpointType.CHECKPOINT, getDefault()));
}
@Test
- public void testNoActiveTimeoutAlignmentAfterAbort() throws Exception {
+ void testNoActiveTimeoutAlignmentAfterAbort() throws Exception {
int numberOfChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
CheckpointedInputGate gate =
@@ -684,11 +669,11 @@ public class AlternatingCheckpointsTest {
send(toBuffer(new CancelCheckpointMarker(1L), true), 1, gate);
clock.advanceTime(alignedCheckpointTimeout + 1, TimeUnit.MILLISECONDS);
- assertThat(target.getTriggeredCheckpointOptions().size(), equalTo(0));
+ assertThat(target.getTriggeredCheckpointOptions()).isEmpty();
}
@Test
- public void testNoActiveTimeoutAlignmentAfterClose() throws Exception {
+ void testNoActiveTimeoutAlignmentAfterClose() throws Exception {
int numberOfChannels = 2;
ClockWithDelayedActions clockWithDelayedActions =
new ClockWithDelayedActions() {
@@ -717,11 +702,11 @@ public class AlternatingCheckpointsTest {
gate.close();
clockWithDelayedActions.advanceTime(alignedCheckpointTimeout + 1, TimeUnit.MILLISECONDS);
- assertThat(target.getTriggeredCheckpointOptions().size(), equalTo(0));
+ assertThat(target.getTriggeredCheckpointOptions()).isEmpty();
}
@Test
- public void testActiveTimeoutAlignmentOnAnnouncement() throws Exception {
+ void testActiveTimeoutAlignmentOnAnnouncement() throws Exception {
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
try (CheckpointedInputGate gate =
@@ -739,17 +724,16 @@ public class AlternatingCheckpointsTest {
getChannel(gate, 1).onBuffer(dataBuffer(), 0, 0, 0);
getChannel(gate, 1).onBuffer(checkpointBarrier.retainBuffer(), 1, 0, 0);
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
assertAnnouncement(gate);
assertAnnouncement(gate);
// the announcement should time out causing the barriers to overtake the data buffers
clock.advanceTime(alignedCheckpointTimeout + 1, TimeUnit.MILLISECONDS);
assertBarrier(gate);
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(unaligned(CheckpointType.CHECKPOINT, getDefault())));
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(unaligned(CheckpointType.CHECKPOINT, getDefault()));
// Followed by overtaken buffers
assertData(gate);
assertData(gate);
@@ -758,7 +742,7 @@ public class AlternatingCheckpointsTest {
}
@Test
- public void testActiveTimeoutAfterAnnouncementPassiveTimeout() throws Exception {
+ void testActiveTimeoutAfterAnnouncementPassiveTimeout() throws Exception {
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
try (CheckpointedInputGate gate =
@@ -776,7 +760,7 @@ public class AlternatingCheckpointsTest {
getChannel(gate, 1).onBuffer(dataBuffer(), 0, 0, 0);
getChannel(gate, 1).onBuffer(checkpointBarrier.retainBuffer(), 1, 0, 0);
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
assertAnnouncement(gate);
clock.advanceTimeWithoutRunningCallables(
alignedCheckpointTimeout + 1, TimeUnit.MILLISECONDS);
@@ -787,10 +771,9 @@ public class AlternatingCheckpointsTest {
clock.executeCallables();
assertBarrier(gate);
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(unaligned(CheckpointType.CHECKPOINT, getDefault())));
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(unaligned(CheckpointType.CHECKPOINT, getDefault()));
// Followed by overtaken buffers
assertData(gate);
assertData(gate);
@@ -799,7 +782,7 @@ public class AlternatingCheckpointsTest {
}
@Test
- public void testActiveTimeoutBeforeFirstAnnouncementPassiveTimeout() throws Exception {
+ void testActiveTimeoutBeforeFirstAnnouncementPassiveTimeout() throws Exception {
// given: Two barriers from two channels.
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
@@ -817,7 +800,7 @@ public class AlternatingCheckpointsTest {
getChannel(gate, 1).onBuffer(dataBuffer(), 0, 0, 0);
getChannel(gate, 1).onBuffer(checkpointBarrier.retainBuffer(), 1, 0, 0);
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
// when: The receiving of the first announcement is delayed on more than alignment
// checkpoint timeout.
@@ -832,10 +815,9 @@ public class AlternatingCheckpointsTest {
assertAnnouncement(gate);
assertBarrier(gate);
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(unaligned(CheckpointType.CHECKPOINT, getDefault())));
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(unaligned(CheckpointType.CHECKPOINT, getDefault()));
// Followed by overtaken buffers
assertData(gate);
assertData(gate);
@@ -843,7 +825,7 @@ public class AlternatingCheckpointsTest {
}
@Test
- public void testActiveTimeoutAfterBarrierPassiveTimeout() throws Exception {
+ void testActiveTimeoutAfterBarrierPassiveTimeout() throws Exception {
int numChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
try (CheckpointedInputGate gate =
@@ -859,7 +841,7 @@ public class AlternatingCheckpointsTest {
getChannel(gate, 0).onBuffer(dataBuffer(), 1, 0, 0);
getChannel(gate, 0).onBuffer(checkpointBarrier.retainBuffer(), 2, 0, 0);
- assertEquals(0, target.getTriggeredCheckpointCounter());
+ assertThat(target.getTriggeredCheckpointCounter()).isZero();
assertAnnouncement(gate);
// we simulate active time out firing after the passive one
assertData(gate);
@@ -876,10 +858,9 @@ public class AlternatingCheckpointsTest {
assertAnnouncement(gate);
assertBarrier(gate);
- assertEquals(1, target.getTriggeredCheckpointCounter());
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(unaligned(CheckpointType.CHECKPOINT, getDefault())));
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(unaligned(CheckpointType.CHECKPOINT, getDefault()));
// Followed by overtaken buffers
assertData(gate);
}
@@ -890,7 +871,7 @@ public class AlternatingCheckpointsTest {
* unaligned {@link CheckpointBarrier}, that has timed out on an upstream task.
*/
@Test
- public void testTimeoutAlignmentOnUnalignedCheckpoint() throws Exception {
+ void testTimeoutAlignmentOnUnalignedCheckpoint() throws Exception {
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
RecordingChannelStateWriter channelStateWriter = new RecordingChannelStateWriter();
CheckpointedInputGate gate =
@@ -922,17 +903,13 @@ public class AlternatingCheckpointsTest {
assertBarrier(gate);
- assertEquals(
- 2,
- channelStateWriter
- .getAddedInput()
- .get(getChannel(gate, 1).getChannelInfo())
- .size());
- assertEquals(1, target.getTriggeredCheckpointCounter());
+ assertThat(channelStateWriter.getAddedInput().get(getChannel(gate, 1).getChannelInfo()))
+ .hasSize(2);
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
}
@Test
- public void testTimeoutAlignmentAfterReceivedEndOfPartition() throws Exception {
+ void testTimeoutAlignmentAfterReceivedEndOfPartition() throws Exception {
int numChannels = 3;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
long alignedCheckpointTimeout = 100L;
@@ -975,10 +952,9 @@ public class AlternatingCheckpointsTest {
assertData(gate);
assertEvent(gate, EndOfPartitionEvent.class);
- assertEquals(1, target.getTriggeredCheckpointCounter());
- assertThat(
- target.getTriggeredCheckpointOptions(),
- contains(unaligned(CheckpointType.CHECKPOINT, getDefault())));
+ assertThat(target.getTriggeredCheckpointCounter()).isOne();
+ assertThat(target.getTriggeredCheckpointOptions())
+ .containsExactly(unaligned(CheckpointType.CHECKPOINT, getDefault()));
}
}
@@ -990,7 +966,7 @@ public class AlternatingCheckpointsTest {
* More information is available in https://issues.apache.org/jira/browse/FLINK-24068.
*/
@Test
- public void testStartNewCheckpointViaAnnouncement() throws Exception {
+ void testStartNewCheckpointViaAnnouncement() throws Exception {
int numChannels = 3;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
long alignedCheckpointTimeout = 10000L;
@@ -1020,7 +996,7 @@ public class AlternatingCheckpointsTest {
// When received the EndOfPartition from channel 1 markAlignmentStart should be called.
assertEvent(gate, EndOfPartitionEvent.class);
- assertTrue(gate.getCheckpointBarrierHandler().isDuringAlignment());
+ assertThat(gate.getCheckpointBarrierHandler().isDuringAlignment()).isTrue();
// Received barrier from channel 0.
assertBarrier(gate);
@@ -1041,7 +1017,7 @@ public class AlternatingCheckpointsTest {
assertAnnouncement(gate);
assertBarrier(gate);
- assertThat(target.triggeredCheckpoints, contains(1L));
+ assertThat(target.triggeredCheckpoints).containsExactly(1L);
}
}
@@ -1050,7 +1026,7 @@ public class AlternatingCheckpointsTest {
}
@Test
- public void testMetricsAlternation() throws Exception {
+ void testMetricsAlternation() throws Exception {
int numChannels = 2;
int bufferSize = 1000;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
@@ -1146,7 +1122,7 @@ public class AlternatingCheckpointsTest {
}
@Test
- public void testMetricsSingleChannel() throws Exception {
+ void testMetricsSingleChannel() throws Exception {
int numChannels = 1;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
CheckpointedInputGate gate =
@@ -1187,22 +1163,20 @@ public class AlternatingCheckpointsTest {
long alignmentDurationNanosMin,
long startDelayNanos,
long bytesProcessedDuringAlignment) {
- assertThat(checkpointBarrierHandler.getLatestCheckpointId(), equalTo(latestCheckpointId));
+ assertThat(checkpointBarrierHandler.getLatestCheckpointId()).isEqualTo(latestCheckpointId);
long alignmentDurationNanos = checkpointBarrierHandler.getAlignmentDurationNanos();
long expectedAlignmentDurationNanosMax =
clock.relativeTimeNanos() - alignmentDurationStartNanos;
- assertThat(alignmentDurationNanos, greaterThanOrEqualTo(alignmentDurationNanosMin));
- assertThat(alignmentDurationNanos, lessThanOrEqualTo(expectedAlignmentDurationNanosMax));
- assertThat(
- checkpointBarrierHandler.getCheckpointStartDelayNanos(),
- greaterThanOrEqualTo(startDelayNanos));
- assertThat(
- FutureUtils.getOrDefault(target.getLastBytesProcessedDuringAlignment(), -1L),
- equalTo(bytesProcessedDuringAlignment));
+ assertThat(alignmentDurationNanos).isGreaterThanOrEqualTo(alignmentDurationNanosMin);
+ assertThat(alignmentDurationNanos).isLessThanOrEqualTo(expectedAlignmentDurationNanosMax);
+ assertThat(checkpointBarrierHandler.getCheckpointStartDelayNanos())
+ .isGreaterThanOrEqualTo(startDelayNanos);
+ assertThat(FutureUtils.getOrDefault(target.getLastBytesProcessedDuringAlignment(), -1L))
+ .isEqualTo(bytesProcessedDuringAlignment);
}
@Test
- public void testPreviousHandlerReset() throws Exception {
+ void testPreviousHandlerReset() throws Exception {
SingleInputGate inputGate = new SingleInputGateBuilder().setNumberOfChannels(2).build();
TestInputChannel[] channels = {
new TestInputChannel(inputGate, 0), new TestInputChannel(inputGate, 1)
@@ -1231,15 +1205,15 @@ public class AlternatingCheckpointsTest {
new InputChannelInfo(0, channel),
false);
if (type.isSavepoint()) {
- assertTrue(channels[channel].isBlocked());
- assertFalse(channels[(channel + 1) % 2].isBlocked());
+ assertThat(channels[channel].isBlocked()).isTrue();
+ assertThat(channels[(channel + 1) % 2].isBlocked()).isFalse();
} else {
- assertFalse(channels[0].isBlocked());
- assertFalse(channels[1].isBlocked());
+ assertThat(channels[0].isBlocked()).isFalse();
+ assertThat(channels[1].isBlocked()).isFalse();
}
- assertTrue(barrierHandler.isCheckpointPending());
- assertFalse(barrierHandler.getAllBarriersReceivedFuture(i).isDone());
+ assertThat(barrierHandler.isCheckpointPending()).isTrue();
+ assertThat(barrierHandler.getAllBarriersReceivedFuture(i)).isNotDone();
channels[0].setBlocked(false);
channels[1].setBlocked(false);
@@ -1247,7 +1221,7 @@ public class AlternatingCheckpointsTest {
}
@Test
- public void testHasInflightDataBeforeProcessBarrier() throws Exception {
+ void testHasInflightDataBeforeProcessBarrier() throws Exception {
SingleInputGate inputGate = new SingleInputGateBuilder().setNumberOfChannels(2).build();
inputGate.setInputChannels(
new TestInputChannel(inputGate, 0), new TestInputChannel(inputGate, 1));
@@ -1264,11 +1238,11 @@ public class AlternatingCheckpointsTest {
new InputChannelInfo(0, 0),
false);
- assertFalse(barrierHandler.getAllBarriersReceivedFuture(id).isDone());
+ assertThat(barrierHandler.getAllBarriersReceivedFuture(id)).isNotDone();
}
@Test
- public void testOutOfOrderBarrier() throws Exception {
+ void testOutOfOrderBarrier() throws Exception {
SingleInputGate inputGate = new SingleInputGateBuilder().setNumberOfChannels(2).build();
TestInputChannel firstChannel = new TestInputChannel(inputGate, 0);
TestInputChannel secondChannel = new TestInputChannel(inputGate, 1);
@@ -1298,12 +1272,12 @@ public class AlternatingCheckpointsTest {
new InputChannelInfo(0, 1),
false);
- assertEquals(checkpointId, barrierHandler.getLatestCheckpointId());
- assertFalse(secondChannel.isBlocked());
+ assertThat(barrierHandler.getLatestCheckpointId()).isEqualTo(checkpointId);
+ assertThat(secondChannel.isBlocked()).isFalse();
}
@Test
- public void testNextFirstCheckpointBarrierOvertakesCancellationBarrier() throws Exception {
+ void testNextFirstCheckpointBarrierOvertakesCancellationBarrier() throws Exception {
int numberOfChannels = 2;
ValidatingCheckpointHandler target = new ValidatingCheckpointHandler();
CheckpointedInputGate gate =
@@ -1325,9 +1299,9 @@ public class AlternatingCheckpointsTest {
send(withTimeout(2, alignedCheckpointTimeout), 1, gate);
clock.advanceTime(Duration.ofSeconds(1));
- assertEquals(
- Duration.ofSeconds(2).toNanos(),
- target.lastAlignmentDurationNanos.get().longValue());
+ assertThatFuture(target.lastAlignmentDurationNanos)
+ .eventuallySucceeds()
+ .isEqualTo(Duration.ofSeconds(2).toNanos());
}
private void testBarrierHandling(SnapshotType checkpointType) throws Exception {
@@ -1353,15 +1327,15 @@ public class AlternatingCheckpointsTest {
: unaligned(CheckpointType.CHECKPOINT, getDefault());
Buffer barrier = barrier(barrierId, 1, options);
send(barrier.retainBuffer(), fast, checkpointedGate);
- assertEquals(checkpointType.isSavepoint(), target.triggeredCheckpoints.isEmpty());
+ assertThat(target.triggeredCheckpoints.isEmpty()).isEqualTo(checkpointType.isSavepoint());
send(barrier.retainBuffer(), slow, checkpointedGate);
- assertEquals(singletonList(barrierId), target.triggeredCheckpoints);
+ assertThat(target.triggeredCheckpoints).containsExactly(barrierId);
if (checkpointType.isSavepoint()) {
for (InputChannel channel : gate.inputChannels()) {
- assertFalse(
- String.format("channel %d should be resumed", channel.getChannelIndex()),
- ((TestInputChannel) channel).isBlocked());
+ assertThat(((TestInputChannel) channel).isBlocked())
+ .as("channel %d should be resumed", channel.getChannelIndex())
+ .isFalse();
}
}
}
@@ -1438,27 +1412,28 @@ public class AlternatingCheckpointsTest {
private static <T extends RuntimeEvent> void assertEvent(
CheckpointedInputGate gate, Class<T> clazz) throws IOException, InterruptedException {
Optional<BufferOrEvent> bufferOrEvent = assertPoll(gate);
- assertTrue(
- "expected event, got data buffer on " + bufferOrEvent.get().getChannelInfo(),
- bufferOrEvent.get().isEvent());
- assertEquals(clazz, bufferOrEvent.get().getEvent().getClass());
+ assertThat(bufferOrEvent.get().isEvent())
+ .as("expected event, got data buffer on " + bufferOrEvent.get().getChannelInfo())
+ .isTrue();
+ assertThat(bufferOrEvent.get().getEvent().getClass()).isEqualTo(clazz);
}
private static <T extends RuntimeEvent> void assertData(CheckpointedInputGate gate)
throws IOException, InterruptedException {
Optional<BufferOrEvent> bufferOrEvent = assertPoll(gate);
- assertTrue(
- "expected data, got "
- + bufferOrEvent.get().getEvent()
- + " on "
- + bufferOrEvent.get().getChannelInfo(),
- bufferOrEvent.get().isBuffer());
+ assertThat(bufferOrEvent.get().isBuffer())
+ .as(
+ "expected data, got "
+ + bufferOrEvent.get().getEvent()
+ + " on "
+ + bufferOrEvent.get().getChannelInfo())
+ .isTrue();
}
private static Optional<BufferOrEvent> assertPoll(CheckpointedInputGate gate)
throws IOException, InterruptedException {
Optional<BufferOrEvent> bufferOrEvent = gate.pollNext();
- assertTrue("empty gate", bufferOrEvent.isPresent());
+ assertThat(bufferOrEvent).as("empty gate").isPresent();
return bufferOrEvent;
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/BarrierAlignmentUtilTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/BarrierAlignmentUtilTest.java
index fa593490094..10327eba3fa 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/BarrierAlignmentUtilTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/BarrierAlignmentUtilTest.java
@@ -26,19 +26,18 @@ import org.apache.flink.streaming.runtime.tasks.mailbox.MailboxExecutorImpl;
import org.apache.flink.streaming.runtime.tasks.mailbox.MailboxProcessor;
import org.apache.flink.streaming.runtime.tasks.mailbox.TaskMailbox;
import org.apache.flink.streaming.runtime.tasks.mailbox.TaskMailboxImpl;
-import org.apache.flink.util.ExceptionUtils;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.time.Duration;
-import static org.junit.Assert.assertThrows;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
/** {@link BarrierAlignmentUtil} test. */
-public class BarrierAlignmentUtilTest {
+class BarrierAlignmentUtilTest {
@Test
- public void testDelayableTimerNotHiddenException() throws Exception {
+ void testDelayableTimerNotHiddenException() throws Exception {
TaskMailbox mailbox = new TaskMailboxImpl();
MailboxProcessor mailboxProcessor =
new MailboxProcessor(controller -> {}, mailbox, StreamTaskActionExecutor.IMMEDIATE);
@@ -63,12 +62,8 @@ public class BarrierAlignmentUtilTest {
timerService.advance(delay.toMillis());
- Throwable t =
- assertThrows(
- "BarrierAlignmentUtil.DelayableTimer should not hidden exception",
- Exception.class,
- () -> mailboxProcessor.runMailboxStep());
-
- ExceptionUtils.assertThrowable(t, ExpectedTestException.class);
+ assertThatThrownBy(mailboxProcessor::runMailboxStep)
+ .as("BarrierAlignmentUtil.DelayableTimer should not hidden exception")
+ .isInstanceOf(ExpectedTestException.class);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointBarrierTrackerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointBarrierTrackerTest.java
index 35bc92f8e55..b7807fe3aea 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointBarrierTrackerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointBarrierTrackerTest.java
@@ -44,8 +44,8 @@ import org.apache.flink.util.clock.Clock;
import org.apache.flink.util.clock.ManualClock;
import org.apache.flink.util.clock.SystemClock;
-import org.junit.After;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
import javax.annotation.Nullable;
@@ -56,43 +56,35 @@ import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
+import static org.apache.flink.core.testutils.FlinkAssertions.assertThatFuture;
import static org.apache.flink.streaming.runtime.io.checkpointing.UnalignedCheckpointsTest.addSequence;
-import static org.hamcrest.Matchers.both;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThanOrEqualTo;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.lessThanOrEqualTo;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for the behavior of the barrier tracker. */
-public class CheckpointBarrierTrackerTest {
+class CheckpointBarrierTrackerTest {
private static final int PAGE_SIZE = 512;
private CheckpointedInputGate inputGate;
- @After
- public void ensureEmpty() throws Exception {
- assertFalse(inputGate.pollNext().isPresent());
- assertTrue(inputGate.isFinished());
+ @AfterEach
+ void ensureEmpty() throws Exception {
+ assertThat(inputGate.pollNext()).isNotPresent();
+ assertThat(inputGate.isFinished()).isTrue();
}
@Test
- public void testSingleChannelNoBarriers() throws Exception {
+ void testSingleChannelNoBarriers() throws Exception {
BufferOrEvent[] sequence = {createBuffer(0), createBuffer(0), createBuffer(0)};
inputGate = createCheckpointedInputGate(1, sequence);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@Test
- public void testMultiChannelNoBarriers() throws Exception {
+ void testMultiChannelNoBarriers() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(2),
createBuffer(2),
@@ -107,12 +99,12 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(4, sequence);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@Test
- public void testSingleChannelWithBarriers() throws Exception {
+ void testSingleChannelWithBarriers() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(0),
createBuffer(0),
@@ -135,12 +127,12 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(1, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@Test
- public void testSingleChannelWithSkippedBarriers() throws Exception {
+ void testSingleChannelWithSkippedBarriers() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(0),
createBarrier(1, 0),
@@ -160,12 +152,12 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(1, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@Test
- public void testMultiChannelWithBarriers() throws Exception {
+ void testMultiChannelWithBarriers() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(0),
createBuffer(2),
@@ -199,12 +191,12 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(3, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@Test
- public void testMultiChannelSkippingCheckpoints() throws Exception {
+ void testMultiChannelSkippingCheckpoints() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(0),
createBuffer(2),
@@ -242,7 +234,7 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(3, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@@ -255,7 +247,7 @@ public class CheckpointBarrierTrackerTest {
* checkpoints, or fail to complete a checkpoint all together.
*/
@Test
- public void testCompleteCheckpointsOnLateBarriers() throws Exception {
+ void testCompleteCheckpointsOnLateBarriers() throws Exception {
BufferOrEvent[] sequence = {
// checkpoint 2
createBuffer(1),
@@ -341,12 +333,12 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(3, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@Test
- public void testNextFirstCheckpointBarrierOvertakesCancellationBarrier() throws Exception {
+ void testNextFirstCheckpointBarrierOvertakesCancellationBarrier() throws Exception {
BufferOrEvent[] sequence = {
// start checkpoint 1
createBarrier(1, 1),
@@ -363,16 +355,16 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(2, sequence, validator, manualClock);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
manualClock.advanceTime(Duration.ofSeconds(1));
}
- assertEquals(
- Duration.ofSeconds(2).toNanos(),
- validator.lastAlignmentDurationNanos.get().longValue());
+ assertThatFuture(validator.lastAlignmentDurationNanos)
+ .eventuallySucceeds()
+ .isEqualTo(Duration.ofSeconds(2).toNanos());
}
@Test
- public void testSingleChannelAbortCheckpoint() throws Exception {
+ void testSingleChannelAbortCheckpoint() throws Exception {
BufferOrEvent[] sequence = {
createBuffer(0),
createBarrier(1, 0),
@@ -389,12 +381,12 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(1, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@Test
- public void testMultiChannelAbortCheckpoint() throws Exception {
+ void testMultiChannelAbortCheckpoint() throws Exception {
BufferOrEvent[] sequence = {
// some buffers and a successful checkpoint
createBuffer(0),
@@ -452,7 +444,7 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(3, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@@ -461,7 +453,7 @@ public class CheckpointBarrierTrackerTest {
* barrier arrival of two consecutive checkpoints.
*/
@Test
- public void testInterleavedCancellationBarriers() throws Exception {
+ void testInterleavedCancellationBarriers() throws Exception {
BufferOrEvent[] sequence = {
createBarrier(1L, 0),
createCancellationBarrier(2L, 0),
@@ -475,12 +467,12 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(3, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
}
@Test
- public void testMetrics() throws Exception {
+ void testMetrics() throws Exception {
List<BufferOrEvent> output = new ArrayList<>();
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler();
int numberOfChannels = 3;
@@ -526,23 +518,25 @@ public class CheckpointBarrierTrackerTest {
long startDelay = System.currentTimeMillis() - checkpointBarrierCreation;
long alignmentDuration = System.nanoTime() - alignmentStartNanos;
- assertThat(
- inputGate.getCheckpointStartDelayNanos() / 1_000_000,
- is(both(greaterThanOrEqualTo(sleepTime)).and(lessThanOrEqualTo(startDelay))));
+ assertThat(inputGate.getCheckpointStartDelayNanos() / 1_000_000)
+ .isBetween(sleepTime, startDelay);
- assertTrue(handler.getLastAlignmentDurationNanos().isDone());
- assertThat(
- handler.getLastAlignmentDurationNanos().get() / 1_000_000,
- is(
- both(greaterThanOrEqualTo(sleepTime))
- .and(lessThanOrEqualTo(alignmentDuration))));
+ assertThatFuture(handler.getLastAlignmentDurationNanos())
+ .eventuallySucceeds()
+ .satisfies(
+ duration ->
+ assertThat(duration / 1_000_000)
+ .isBetween(sleepTime, alignmentDuration));
+ assertThat(handler.getLastAlignmentDurationNanos()).isDone();
+ assertThat(handler.getLastAlignmentDurationNanos().get() / 1_000_000)
+ .isBetween(sleepTime, alignmentDuration);
- assertTrue(handler.getLastBytesProcessedDuringAlignment().isDone());
- assertThat(handler.getLastBytesProcessedDuringAlignment().get(), equalTo(3L * bufferSize));
+ assertThat(handler.getLastBytesProcessedDuringAlignment())
+ .isCompletedWithValue(3L * bufferSize);
}
@Test
- public void testSingleChannelMetrics() throws Exception {
+ void testSingleChannelMetrics() throws Exception {
List<BufferOrEvent> output = new ArrayList<>();
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler();
int numberOfChannels = 1;
@@ -568,22 +562,15 @@ public class CheckpointBarrierTrackerTest {
long startDelay = System.currentTimeMillis() - checkpointBarrierCreation;
- assertThat(
- inputGate.getCheckpointStartDelayNanos() / 1_000_000,
- greaterThanOrEqualTo(sleepTime));
- assertThat(
- inputGate.getCheckpointStartDelayNanos() / 1_000_000,
- lessThanOrEqualTo(startDelay));
+ assertThat(inputGate.getCheckpointStartDelayNanos() / 1_000_000)
+ .isBetween(sleepTime, startDelay);
- assertTrue(handler.getLastAlignmentDurationNanos().isDone());
- assertThat(handler.getLastAlignmentDurationNanos().get(), equalTo(0L));
-
- assertTrue(handler.getLastBytesProcessedDuringAlignment().isDone());
- assertThat(handler.getLastBytesProcessedDuringAlignment().get(), equalTo(0L));
+ assertThat(handler.getLastAlignmentDurationNanos()).isCompletedWithValue(0L);
+ assertThat(handler.getLastBytesProcessedDuringAlignment()).isCompletedWithValue(0L);
}
@Test
- public void testTriggerCheckpointsWithEndOfPartition() throws Exception {
+ void testTriggerCheckpointsWithEndOfPartition() throws Exception {
BufferOrEvent[] sequence = {
createBarrier(1, 0),
createBarrier(2, 0),
@@ -602,18 +589,18 @@ public class CheckpointBarrierTrackerTest {
(CheckpointBarrierTracker) inputGate.getCheckpointBarrierHandler();
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
// Only checkpoints 4 is triggered and the previous checkpoints are ignored.
- assertThat(validator.triggeredCheckpoints, contains(4L));
- assertEquals(0, validator.getAbortedCheckpointCounter());
- assertThat(checkpointBarrierTracker.getPendingCheckpointIds(), contains(5L));
- assertEquals(2, checkpointBarrierTracker.getNumOpenChannels());
+ assertThat(validator.triggeredCheckpoints).containsExactly(4L);
+ assertThat(validator.getAbortedCheckpointCounter()).isZero();
+ assertThat(checkpointBarrierTracker.getPendingCheckpointIds()).containsExactly(5L);
+ assertThat(checkpointBarrierTracker.getNumOpenChannels()).isEqualTo(2);
}
@Test
- public void testDeduplicateChannelsWithBothBarrierAndEndOfPartition() throws Exception {
+ void testDeduplicateChannelsWithBothBarrierAndEndOfPartition() throws Exception {
BufferOrEvent[] sequence = {
/* 0 */ createBarrier(2, 0),
/* 1 */ createBarrier(2, 1),
@@ -625,20 +612,20 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(3, sequence, validator);
for (int i = 0; i <= 2; ++i) {
- assertEquals(sequence[i], inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(sequence[i]);
}
// Here the checkpoint should not be triggered.
- assertEquals(0, validator.getTriggeredCheckpointCounter());
- assertEquals(0, validator.getAbortedCheckpointCounter());
+ assertThat(validator.getTriggeredCheckpointCounter()).isZero();
+ assertThat(validator.getAbortedCheckpointCounter()).isZero();
// The last barrier aligned the pending checkpoint 2.
- assertEquals(sequence[3], inputGate.pollNext().get());
- assertThat(validator.triggeredCheckpoints, contains(2L));
+ assertThat(inputGate.pollNext()).hasValue(sequence[3]);
+ assertThat(validator.triggeredCheckpoints).containsExactly(2L);
}
@Test
- public void testTriggerCheckpointsAfterReceivedEndOfPartition() throws Exception {
+ void testTriggerCheckpointsAfterReceivedEndOfPartition() throws Exception {
BufferOrEvent[] sequence = {
/* 0 */ createEndOfPartition(2),
/* 1 */ createBarrier(5, 0),
@@ -652,15 +639,15 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(3, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
- assertThat(validator.triggeredCheckpoints, contains(6L, 7L));
- assertEquals(0, validator.getAbortedCheckpointCounter());
+ assertThat(validator.triggeredCheckpoints).containsExactly(6L, 7L);
+ assertThat(validator.getAbortedCheckpointCounter()).isZero();
}
@Test
- public void testNoFastPathWithChannelFinishedDuringCheckpoints() throws Exception {
+ void testNoFastPathWithChannelFinishedDuringCheckpoints() throws Exception {
BufferOrEvent[] sequence = {
createBarrier(1, 0), createEndOfPartition(0), createBarrier(1, 1)
};
@@ -669,16 +656,16 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(2, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
// The last barrier should finish the pending checkpoint instead of trigger a "new" one.
- assertEquals(1, validator.getTriggeredCheckpointCounter());
- assertFalse(inputGate.getCheckpointBarrierHandler().isCheckpointPending());
+ assertThat(validator.getTriggeredCheckpointCounter()).isOne();
+ assertThat(inputGate.getCheckpointBarrierHandler().isCheckpointPending()).isFalse();
}
@Test
- public void testCompleteAndRemoveAbortedCheckpointWithEndOfPartition() throws Exception {
+ void testCompleteAndRemoveAbortedCheckpointWithEndOfPartition() throws Exception {
BufferOrEvent[] sequence = {
createCancellationBarrier(4, 0),
createBarrier(4, 1),
@@ -693,18 +680,18 @@ public class CheckpointBarrierTrackerTest {
(CheckpointBarrierTracker) inputGate.getCheckpointBarrierHandler();
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
- assertEquals(1, validator.getAbortedCheckpointCounter());
- assertEquals(4L, validator.getLastCanceledCheckpointId());
- assertEquals(0, validator.getTriggeredCheckpointCounter());
- assertThat(checkpointBarrierTracker.getPendingCheckpointIds(), contains(5L));
- assertEquals(2, checkpointBarrierTracker.getNumOpenChannels());
+ assertThat(validator.getAbortedCheckpointCounter()).isOne();
+ assertThat(validator.getLastCanceledCheckpointId()).isEqualTo(4L);
+ assertThat(validator.getTriggeredCheckpointCounter()).isZero();
+ assertThat(checkpointBarrierTracker.getPendingCheckpointIds()).containsExactly(5L);
+ assertThat(checkpointBarrierTracker.getNumOpenChannels()).isEqualTo(2L);
}
@Test
- public void testAbortCheckpointsAfterEndOfPartitionReceived() throws Exception {
+ void testAbortCheckpointsAfterEndOfPartitionReceived() throws Exception {
BufferOrEvent[] sequence = {
/* 0 */ createEndOfPartition(2),
/* 1 */ createBarrier(5, 0),
@@ -718,15 +705,15 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(3, sequence, validator);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
- assertThat(validator.abortedCheckpoints, contains(5L, 6L, 7L));
- assertEquals(0, validator.getTriggeredCheckpointCounter());
+ assertThat(validator.abortedCheckpoints).containsExactly(5L, 6L, 7L);
+ assertThat(validator.getTriggeredCheckpointCounter()).isZero();
}
@Test
- public void testNoFastPathWithChannelFinishedDuringCheckpointsCancel() throws Exception {
+ void testNoFastPathWithChannelFinishedDuringCheckpointsCancel() throws Exception {
BufferOrEvent[] sequence = {
createBarrier(1, 0, 0), createEndOfPartition(0), createCancellationBarrier(1, 1)
};
@@ -735,16 +722,16 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(2, sequence, checkpointHandler);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
}
- assertEquals(1, checkpointHandler.getLastCanceledCheckpointId());
+ assertThat(checkpointHandler.getLastCanceledCheckpointId()).isOne();
// If go with the fast path, the pending checkpoint would not be removed normally.
- assertFalse(inputGate.getCheckpointBarrierHandler().isCheckpointPending());
+ assertThat(inputGate.getCheckpointBarrierHandler().isCheckpointPending()).isFalse();
}
@Test
- public void testTwoLastBarriersOneByOne() throws Exception {
+ void testTwoLastBarriersOneByOne() throws Exception {
BufferOrEvent[] sequence = {
// start checkpoint 1
createBarrier(1, 1),
@@ -761,12 +748,12 @@ public class CheckpointBarrierTrackerTest {
inputGate = createCheckpointedInputGate(2, sequence, validator, manualClock);
for (BufferOrEvent boe : sequence) {
- assertEquals(boe, inputGate.pollNext().get());
+ assertThat(inputGate.pollNext()).hasValue(boe);
manualClock.advanceTime(Duration.ofSeconds(1));
}
- assertEquals(
- Duration.ofSeconds(2).toNanos(),
- validator.lastAlignmentDurationNanos.get().longValue());
+ assertThatFuture(validator.lastAlignmentDurationNanos)
+ .eventuallySucceeds()
+ .isEqualTo(Duration.ofSeconds(2).toNanos());
}
// ------------------------------------------------------------------------
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointSequenceValidator.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointSequenceValidator.java
index ec9c8aa6be3..a9d3d12b60b 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointSequenceValidator.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointSequenceValidator.java
@@ -28,9 +28,7 @@ import org.apache.flink.runtime.operators.testutils.DummyEnvironment;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
/** {@link AbstractInvokable} that validates expected order of completed and aborted checkpoints. */
class CheckpointSequenceValidator extends AbstractInvokable {
@@ -60,39 +58,38 @@ class CheckpointSequenceValidator extends AbstractInvokable {
CheckpointMetaData checkpointMetaData,
CheckpointOptions checkpointOptions,
CheckpointMetricsBuilder checkpointMetrics) {
- assertTrue(
- "Unexpected triggerCheckpointOnBarrier("
- + checkpointMetaData.getCheckpointId()
- + ")",
- i < checkpointIDs.length);
+ assertThat(checkpointIDs)
+ .as(
+ "Unexpected triggerCheckpointOnBarrier("
+ + checkpointMetaData.getCheckpointId()
+ + ")")
+ .hasSizeGreaterThan(i);
final long expectedId = checkpointIDs[i++];
- if (expectedId >= 0) {
- assertEquals("wrong checkpoint id", expectedId, checkpointMetaData.getCheckpointId());
- assertTrue(checkpointMetaData.getTimestamp() > 0);
- } else {
- fail(
- String.format(
- "got 'triggerCheckpointOnBarrier(%d)' when expecting an 'abortCheckpointOnBarrier(%d)'",
- checkpointMetaData.getCheckpointId(), expectedId));
- }
+ assertThat(expectedId)
+ .as(
+ "got 'triggerCheckpointOnBarrier(%d)' when expecting an 'abortCheckpointOnBarrier(%d)'",
+ checkpointMetaData.getCheckpointId(), expectedId)
+ .isGreaterThanOrEqualTo(0L);
+ assertThat(checkpointMetaData.getCheckpointId()).isEqualTo(expectedId);
+ assertThat(checkpointMetaData.getTimestamp()).isPositive();
}
@Override
public void abortCheckpointOnBarrier(long checkpointId, CheckpointException cause) {
- assertTrue(
- "Unexpected abortCheckpointOnBarrier(" + checkpointId + ")",
- i < checkpointIDs.length);
+ assertThat(checkpointIDs)
+ .as("Unexpected abortCheckpointOnBarrier(" + checkpointId + ")")
+ .hasSizeGreaterThan(i);
final long expectedId = checkpointIDs[i++];
- if (expectedId < 0) {
- assertEquals("wrong checkpoint id for checkpoint abort", -expectedId, checkpointId);
- } else {
- fail(
- String.format(
- "got 'abortCheckpointOnBarrier(%d)' when expecting an 'triggerCheckpointOnBarrier(%d)'",
- checkpointId, expectedId));
- }
+ assertThat(expectedId)
+ .as(
+ "got 'abortCheckpointOnBarrier(%d)' when expecting an 'triggerCheckpointOnBarrier(%d)'",
+ checkpointId, expectedId)
+ .isNegative();
+ assertThat(checkpointId)
+ .as("wrong checkpoint id for checkpoint abort")
+ .isEqualTo(-expectedId);
}
@Override
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointedInputGateTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointedInputGateTest.java
index de5c6b55baa..a7c5d072291 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointedInputGateTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/CheckpointedInputGateTest.java
@@ -52,8 +52,8 @@ import org.apache.flink.util.clock.SystemClock;
import org.apache.flink.shaded.guava31.com.google.common.io.Closer;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.time.Duration;
@@ -62,28 +62,26 @@ import java.util.Optional;
import java.util.concurrent.CountDownLatch;
import static org.apache.flink.runtime.io.network.buffer.BufferBuilderTestUtils.buildSomeBuffer;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** {@link CheckpointedInputGate} test. */
-public class CheckpointedInputGateTest {
+class CheckpointedInputGateTest {
private final HashMap<Integer, Integer> channelIndexToSequenceNumber = new HashMap<>();
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
channelIndexToSequenceNumber.clear();
}
@Test
- public void testUpstreamResumedUponEndOfRecovery() throws Exception {
+ void testUpstreamResumedUponEndOfRecovery() throws Exception {
int numberOfChannels = 11;
NetworkBufferPool bufferPool = new NetworkBufferPool(numberOfChannels * 3, 1024);
try {
ResumeCountingConnectionManager resumeCounter = new ResumeCountingConnectionManager();
CheckpointedInputGate gate =
setupInputGate(numberOfChannels, bufferPool, resumeCounter);
- assertFalse(gate.pollNext().isPresent());
+ assertThat(gate.pollNext()).isNotPresent();
for (int channelIndex = 0; channelIndex < numberOfChannels - 1; channelIndex++) {
enqueueEndOfState(gate, channelIndex);
Optional<BufferOrEvent> bufferOrEvent = gate.pollNext();
@@ -92,30 +90,30 @@ public class CheckpointedInputGateTest {
&& !gate.allChannelsRecovered()) {
bufferOrEvent = gate.pollNext();
}
- assertFalse("should align (block all channels)", bufferOrEvent.isPresent());
+ assertThat(bufferOrEvent).as("should align (block all channels)").isNotPresent();
}
enqueueEndOfState(gate, numberOfChannels - 1);
Optional<BufferOrEvent> polled = gate.pollNext();
- assertTrue(polled.isPresent());
- assertTrue(polled.get().isEvent());
- assertEquals(EndOfChannelStateEvent.INSTANCE, polled.get().getEvent());
- assertEquals(numberOfChannels, resumeCounter.getNumResumed());
- assertFalse(
- "should only be a single event no matter of what is the number of channels",
- gate.pollNext().isPresent());
+ assertThat(polled).isPresent();
+ assertThat(polled.get().isEvent()).isTrue();
+ assertThat(polled.get().getEvent()).isEqualTo(EndOfChannelStateEvent.INSTANCE);
+ assertThat(resumeCounter.getNumResumed()).isEqualTo(numberOfChannels);
+ assertThat(gate.pollNext())
+ .as("should only be a single event no matter of what is the number of channels")
+ .isNotPresent();
} finally {
bufferPool.destroy();
}
}
@Test
- public void testPersisting() throws Exception {
+ void testPersisting() throws Exception {
testPersisting(false);
}
@Test
- public void testPersistingWithDrainingTheGate() throws Exception {
+ void testPersistingWithDrainingTheGate() throws Exception {
testPersisting(true);
}
@@ -127,7 +125,7 @@ public class CheckpointedInputGateTest {
* notifyCheckpointAborted RPCs) and Task should be able to handle this properly. In FLINK-21104
* the problem was that this obsoleted checkpoint barrier was causing a checkState to fail.
*/
- public void testPersisting(boolean drainGate) throws Exception {
+ private void testPersisting(boolean drainGate) throws Exception {
int numberOfChannels = 3;
NetworkBufferPool bufferPool = new NetworkBufferPool(numberOfChannels * 3, 1024);
@@ -151,10 +149,10 @@ public class CheckpointedInputGateTest {
enqueue(gate, 1, buildSomeBuffer());
enqueue(gate, 2, buildSomeBuffer());
- assertEquals(0, validatingHandler.getTriggeredCheckpointCounter());
+ assertThat(validatingHandler.getTriggeredCheckpointCounter()).isZero();
// trigger checkpoint
gate.pollNext();
- assertEquals(1, validatingHandler.getTriggeredCheckpointCounter());
+ assertThat(validatingHandler.getTriggeredCheckpointCounter()).isOne();
assertAddedInputSize(stateWriter, 0, 1);
assertAddedInputSize(stateWriter, 1, 2);
@@ -200,7 +198,7 @@ public class CheckpointedInputGateTest {
* processed while draining mailbox but can't pull any data anymore.
*/
@Test
- public void testPriorityBeforeClose() throws IOException, InterruptedException {
+ void testPriorityBeforeClose() throws IOException, InterruptedException {
NetworkBufferPool bufferPool = new NetworkBufferPool(10, 1024);
try (Closer closer = Closer.create()) {
@@ -259,7 +257,7 @@ public class CheckpointedInputGateTest {
beforeLatch.countDown();
try {
while (mailboxExecutor.tryYield()) {}
- assertEquals(1L, validatingHandler.triggeredCheckpointCounter);
+ assertThat(validatingHandler.triggeredCheckpointCounter).isOne();
} catch (CancelTaskException e) {
}
canceler.join();
@@ -278,9 +276,8 @@ public class CheckpointedInputGateTest {
private void assertAddedInputSize(
RecordingChannelStateWriter stateWriter, int channelIndex, int size) {
- assertEquals(
- size,
- stateWriter.getAddedInput().get(new InputChannelInfo(0, channelIndex)).size());
+ assertThat(stateWriter.getAddedInput().get(new InputChannelInfo(0, channelIndex)))
+ .hasSize(size);
}
private void enqueueEndOfState(CheckpointedInputGate checkpointedInputGate, int channelIndex)
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/InputProcessorUtilTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/InputProcessorUtilTest.java
index b3d417ecc18..b4b9a3f5dc3 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/InputProcessorUtilTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/InputProcessorUtilTest.java
@@ -39,23 +39,23 @@ import org.apache.flink.streaming.runtime.tasks.TestSubtaskCheckpointCoordinator
import org.apache.flink.streaming.util.MockStreamTask;
import org.apache.flink.streaming.util.MockStreamTaskBuilder;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for the behaviors of the {@link
* org.apache.flink.streaming.runtime.io.checkpointing.InputProcessorUtil}.
*/
-public class InputProcessorUtilTest {
+class InputProcessorUtilTest {
@Test
- public void testCreateCheckpointedMultipleInputGate() throws Exception {
+ void testCreateCheckpointedMultipleInputGate() throws Exception {
try (CloseableRegistry registry = new CloseableRegistry()) {
MockEnvironment environment = new MockEnvironmentBuilder().build();
MockStreamTask streamTask = new MockStreamTaskBuilder(environment).build();
@@ -112,7 +112,7 @@ public class InputProcessorUtilTest {
false);
}
}
- assertTrue(barrierHandler.getAllBarriersReceivedFuture(1).isDone());
+ assertThat(barrierHandler.getAllBarriersReceivedFuture(1)).isDone();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/UnalignedCheckpointsCancellationTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/UnalignedCheckpointsCancellationTest.java
index db11e883aba..80071231aca 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/UnalignedCheckpointsCancellationTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/UnalignedCheckpointsCancellationTest.java
@@ -31,27 +31,28 @@ import org.apache.flink.runtime.io.network.partition.consumer.SingleInputGateBui
import org.apache.flink.runtime.jobgraph.tasks.AbstractInvokable;
import org.apache.flink.runtime.operators.testutils.DummyEnvironment;
import org.apache.flink.streaming.runtime.tasks.TestSubtaskCheckpointCoordinator;
+import org.apache.flink.testutils.junit.extensions.parameterized.ParameterizedTestExtension;
+import org.apache.flink.testutils.junit.extensions.parameterized.Parameters;
import org.apache.flink.util.clock.SystemClock;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.TestTemplate;
+import org.junit.jupiter.api.extension.ExtendWith;
import java.util.Arrays;
import java.util.List;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/** Unaligned checkpoints cancellation test. */
-@RunWith(Parameterized.class)
-public class UnalignedCheckpointsCancellationTest {
+@ExtendWith(ParameterizedTestExtension.class)
+class UnalignedCheckpointsCancellationTest {
private final List<RuntimeEvent> events;
private final boolean expectTriggerCheckpoint;
private final boolean expectAbortCheckpoint;
private final int numChannels;
private final int channel;
- public UnalignedCheckpointsCancellationTest(
+ UnalignedCheckpointsCancellationTest(
boolean expectTriggerCheckpoint,
boolean expectAbortCheckpoint,
List<RuntimeEvent> events,
@@ -64,10 +65,10 @@ public class UnalignedCheckpointsCancellationTest {
this.channel = channel;
}
- @Parameterized.Parameters(
+ @Parameters(
name =
"expect trigger: {0}, expect abort {1}, numChannels: {3}, chan: {4}, events: {2}")
- public static Object[][] parameters() {
+ private static Object[][] parameters() {
return new Object[][] {
new Object[] {false, true, Arrays.asList(cancel(10), cancel(20)), 1, 0},
new Object[] {false, true, Arrays.asList(cancel(20), cancel(10)), 1, 0},
@@ -85,8 +86,8 @@ public class UnalignedCheckpointsCancellationTest {
};
}
- @Test
- public void test() throws Exception {
+ @TestTemplate
+ void test() throws Exception {
TestInvokable invokable = new TestInvokable();
final SingleInputGate inputGate =
new SingleInputGateBuilder()
@@ -114,9 +115,8 @@ public class UnalignedCheckpointsCancellationTest {
}
}
- assertEquals("expectAbortCheckpoint", expectAbortCheckpoint, invokable.checkpointAborted);
- assertEquals(
- "expectTriggerCheckpoint", expectTriggerCheckpoint, invokable.checkpointTriggered);
+ assertThat(invokable.checkpointAborted).isEqualTo(expectAbortCheckpoint);
+ assertThat(invokable.checkpointTriggered).isEqualTo(expectTriggerCheckpoint);
}
private static CheckpointBarrier checkpoint(int checkpointId) {
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/UnalignedCheckpointsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/UnalignedCheckpointsTest.java
index fb783a027d1..82c06c851f8 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/UnalignedCheckpointsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/UnalignedCheckpointsTest.java
@@ -46,10 +46,9 @@ import org.apache.flink.streaming.runtime.tasks.TestSubtaskCheckpointCoordinator
import org.apache.flink.streaming.runtime.tasks.mailbox.MailboxDefaultAction;
import org.apache.flink.util.clock.SystemClock;
-import org.hamcrest.Matchers;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import javax.annotation.Nullable;
@@ -64,14 +63,10 @@ import java.util.stream.IntStream;
import static org.apache.flink.runtime.state.CheckpointStorageLocationReference.getDefault;
import static org.apache.flink.util.Preconditions.checkState;
-import static org.hamcrest.Matchers.contains;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for the behaviors of the {@link CheckpointedInputGate}. */
-public class UnalignedCheckpointsTest {
+class UnalignedCheckpointsTest {
private static final long DEFAULT_CHECKPOINT_ID = 0L;
@@ -85,16 +80,16 @@ public class UnalignedCheckpointsTest {
private List<BufferOrEvent> output;
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
channelStateWriter = new RecordingChannelStateWriter();
}
- @After
- public void ensureEmpty() throws Exception {
+ @AfterEach
+ void ensureEmpty() throws Exception {
if (inputGate != null) {
- assertFalse(inputGate.pollNext().isPresent());
- assertTrue(inputGate.isFinished());
+ assertThat(inputGate.pollNext()).isNotPresent();
+ assertThat(inputGate.isFinished()).isTrue();
inputGate.close();
}
@@ -112,7 +107,7 @@ public class UnalignedCheckpointsTest {
* input channel.
*/
@Test
- public void testSingleChannelNoBarriers() throws Exception {
+ void testSingleChannelNoBarriers() throws Exception {
inputGate = createInputGate(1, new ValidatingCheckpointHandler(1));
final BufferOrEvent[] sequence =
addSequence(
@@ -131,7 +126,7 @@ public class UnalignedCheckpointsTest {
* multiple input channels.
*/
@Test
- public void testMultiChannelNoBarriers() throws Exception {
+ void testMultiChannelNoBarriers() throws Exception {
inputGate = createInputGate(4, new ValidatingCheckpointHandler(1));
final BufferOrEvent[] sequence =
addSequence(
@@ -159,7 +154,7 @@ public class UnalignedCheckpointsTest {
* channel, and checkpoint events.
*/
@Test
- public void testSingleChannelWithBarriers() throws Exception {
+ void testSingleChannelWithBarriers() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(1);
inputGate = createInputGate(1, handler);
final BufferOrEvent[] sequence =
@@ -191,7 +186,7 @@ public class UnalignedCheckpointsTest {
* channels, by buffering and blocking certain inputs.
*/
@Test
- public void testMultiChannelWithBarriers() throws Exception {
+ void testMultiChannelWithBarriers() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(1);
inputGate = createInputGate(3, handler);
@@ -211,7 +206,7 @@ public class UnalignedCheckpointsTest {
// checkpoint 1 triggered unaligned
assertOutput(sequence1);
- assertEquals(1L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isOne();
assertInflightData(sequence1[7]);
// checkpoint without in-flight data
@@ -228,7 +223,7 @@ public class UnalignedCheckpointsTest {
createBarrier(2, 2));
assertOutput(sequence2);
- assertEquals(2L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(2L);
assertInflightData();
// checkpoint with data only from one channel
@@ -244,14 +239,14 @@ public class UnalignedCheckpointsTest {
createBarrier(3, 1));
assertOutput(sequence3);
- assertEquals(3L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(3L);
assertInflightData();
// empty checkpoint
addSequence(inputGate, createBarrier(4, 1), createBarrier(4, 2), createBarrier(4, 0));
assertOutput();
- assertEquals(4L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(4L);
assertInflightData();
// checkpoint with in-flight data in mixed order
@@ -274,7 +269,7 @@ public class UnalignedCheckpointsTest {
createBarrier(5, 0));
assertOutput(sequence5);
- assertEquals(5L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(5L);
assertInflightData(sequence5[4], sequence5[5], sequence5[6], sequence5[10]);
// some trailing data
@@ -291,7 +286,7 @@ public class UnalignedCheckpointsTest {
}
@Test
- public void testMetrics() throws Exception {
+ void testMetrics() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(1);
inputGate = createInputGate(3, handler);
int bufferSize = 100;
@@ -333,30 +328,21 @@ public class UnalignedCheckpointsTest {
long alignmentDuration = System.nanoTime() - alignmentStartNanos;
- assertEquals(checkpointId, inputGate.getCheckpointBarrierHandler().getLatestCheckpointId());
- assertThat(
- inputGate.getCheckpointStartDelayNanos() / 1_000_000,
- Matchers.greaterThanOrEqualTo(sleepTime));
- assertThat(
- inputGate.getCheckpointStartDelayNanos() / 1_000_000,
- Matchers.lessThanOrEqualTo(startDelay));
-
- assertTrue(handler.getLastAlignmentDurationNanos().isDone());
- assertThat(
- handler.getLastAlignmentDurationNanos().get() / 1_000_000,
- Matchers.greaterThanOrEqualTo(sleepTime));
- assertThat(
- handler.getLastAlignmentDurationNanos().get(),
- Matchers.lessThanOrEqualTo(alignmentDuration));
-
- assertTrue(handler.getLastBytesProcessedDuringAlignment().isDone());
- assertThat(
- handler.getLastBytesProcessedDuringAlignment().get(),
- Matchers.equalTo(6L * bufferSize));
+ assertThat(inputGate.getCheckpointBarrierHandler().getLatestCheckpointId())
+ .isEqualTo(checkpointId);
+ assertThat(inputGate.getCheckpointStartDelayNanos() / 1_000_000)
+ .isBetween(sleepTime, startDelay);
+
+ assertThat(handler.getLastAlignmentDurationNanos()).isDone();
+ assertThat(handler.getLastAlignmentDurationNanos().get() / 1_000_000)
+ .isBetween(sleepTime, alignmentDuration);
+
+ assertThat(handler.getLastBytesProcessedDuringAlignment())
+ .isCompletedWithValue(6L * bufferSize);
}
@Test
- public void testMultiChannelTrailingInflightData() throws Exception {
+ void testMultiChannelTrailingInflightData() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(1);
inputGate = createInputGate(3, handler, false);
@@ -385,13 +371,13 @@ public class UnalignedCheckpointsTest {
createEndOfPartition(0));
assertOutput(sequence);
- assertEquals(2L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(2L);
// TODO: treat EndOfPartitionEvent as a special CheckpointBarrier?
assertInflightData();
}
@Test
- public void testMissingCancellationBarriers() throws Exception {
+ void testMissingCancellationBarriers() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(1);
inputGate = createInputGate(2, handler);
final BufferOrEvent[] sequence =
@@ -406,13 +392,13 @@ public class UnalignedCheckpointsTest {
createEndOfPartition(1));
assertOutput(sequence);
- assertEquals(1L, channelStateWriter.getLastStartedCheckpointId());
- assertEquals(3L, handler.getLastCanceledCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isOne();
+ assertThat(handler.getLastCanceledCheckpointId()).isEqualTo(3L);
assertInflightData();
}
@Test
- public void testEarlyCleanup() throws Exception {
+ void testEarlyCleanup() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(1);
inputGate = createInputGate(3, handler, false);
@@ -427,7 +413,7 @@ public class UnalignedCheckpointsTest {
createBarrier(1, 2),
createBarrier(1, 0));
assertOutput(sequence1);
- assertEquals(1L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isOne();
assertInflightData();
// checkpoint 2
@@ -449,12 +435,12 @@ public class UnalignedCheckpointsTest {
createBuffer(0),
createEndOfPartition(0));
assertOutput(sequence2);
- assertEquals(2L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(2L);
assertInflightData();
}
@Test
- public void testStartAlignmentWithClosedChannels() throws Exception {
+ void testStartAlignmentWithClosedChannels() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(2);
inputGate = createInputGate(4, handler);
@@ -472,7 +458,7 @@ public class UnalignedCheckpointsTest {
createBarrier(2, 3),
createBarrier(2, 0));
assertOutput(sequence1);
- assertEquals(2L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(2L);
assertInflightData();
// checkpoint with in-flight data
@@ -486,14 +472,14 @@ public class UnalignedCheckpointsTest {
createBuffer(0),
createBarrier(3, 0));
assertOutput(sequence2);
- assertEquals(3L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(3L);
assertInflightData(sequence2[4]);
// empty checkpoint
final BufferOrEvent[] sequence3 =
addSequence(inputGate, createBarrier(4, 0), createBarrier(4, 3));
assertOutput(sequence3);
- assertEquals(4L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(4L);
assertInflightData();
// some data, one channel closes
@@ -505,7 +491,7 @@ public class UnalignedCheckpointsTest {
createBuffer(3),
createEndOfPartition(0));
assertOutput(sequence4);
- assertEquals(-1L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(-1L);
assertInflightData();
// checkpoint on last remaining channel
@@ -517,12 +503,12 @@ public class UnalignedCheckpointsTest {
createBuffer(3),
createEndOfPartition(3));
assertOutput(sequence5);
- assertEquals(5L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(5L);
assertInflightData();
}
@Test
- public void testEndOfStreamWhileCheckpoint() throws Exception {
+ void testEndOfStreamWhileCheckpoint() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(1);
inputGate = createInputGate(3, handler);
@@ -531,7 +517,7 @@ public class UnalignedCheckpointsTest {
addSequence(
inputGate, createBarrier(1, 0), createBarrier(1, 1), createBarrier(1, 2));
assertOutput(sequence1);
- assertEquals(1L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isOne();
assertInflightData();
final BufferOrEvent[] sequence2 =
@@ -557,12 +543,12 @@ public class UnalignedCheckpointsTest {
// final end of stream
createEndOfPartition(0));
assertOutput(sequence2);
- assertEquals(2L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(2L);
assertInflightData(sequence2[7]);
}
@Test
- public void testNotifyAbortCheckpointBeforeCanellingAsyncCheckpoint() throws Exception {
+ void testNotifyAbortCheckpointBeforeCanellingAsyncCheckpoint() throws Exception {
ValidateAsyncFutureNotCompleted handler = new ValidateAsyncFutureNotCompleted(1);
inputGate = createInputGate(2, handler);
handler.setInputGate(inputGate);
@@ -572,7 +558,7 @@ public class UnalignedCheckpointsTest {
}
@Test
- public void testSingleChannelAbortCheckpoint() throws Exception {
+ void testSingleChannelAbortCheckpoint() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(1);
inputGate = createInputGate(1, handler);
final BufferOrEvent[] sequence1 =
@@ -585,8 +571,8 @@ public class UnalignedCheckpointsTest {
createCancellationBarrier(4, 0));
assertOutput(sequence1);
- assertEquals(2L, channelStateWriter.getLastStartedCheckpointId());
- assertEquals(4L, handler.getLastCanceledCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(2L);
+ assertThat(handler.getLastCanceledCheckpointId()).isEqualTo(4L);
assertInflightData();
final BufferOrEvent[] sequence2 =
@@ -599,13 +585,13 @@ public class UnalignedCheckpointsTest {
createEndOfPartition(0));
assertOutput(sequence2);
- assertEquals(5L, channelStateWriter.getLastStartedCheckpointId());
- assertEquals(6L, handler.getLastCanceledCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(5L);
+ assertThat(handler.getLastCanceledCheckpointId()).isEqualTo(6L);
assertInflightData();
}
@Test
- public void testMultiChannelAbortCheckpoint() throws Exception {
+ void testMultiChannelAbortCheckpoint() throws Exception {
ValidatingCheckpointHandler handler = new ValidatingCheckpointHandler(1);
inputGate = createInputGate(3, handler);
// some buffers and a successful checkpoint
@@ -624,7 +610,7 @@ public class UnalignedCheckpointsTest {
createBuffer(2));
assertOutput(sequence1);
- assertEquals(1L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isOne();
assertInflightData();
// canceled checkpoint on last barrier
@@ -638,8 +624,8 @@ public class UnalignedCheckpointsTest {
createCancellationBarrier(2, 1));
assertOutput(sequence2);
- assertEquals(2L, channelStateWriter.getLastStartedCheckpointId());
- assertEquals(2L, handler.getLastCanceledCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(2L);
+ assertThat(handler.getLastCanceledCheckpointId()).isEqualTo(2L);
assertInflightData();
// one more successful checkpoint
@@ -653,7 +639,7 @@ public class UnalignedCheckpointsTest {
createBarrier(3, 0));
assertOutput(sequence3);
- assertEquals(3L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(3L);
assertInflightData();
// this checkpoint gets immediately canceled, don't start a checkpoint at all
@@ -668,8 +654,8 @@ public class UnalignedCheckpointsTest {
createBarrier(4, 0));
assertOutput(sequence4);
- assertEquals(-1, channelStateWriter.getLastStartedCheckpointId());
- assertEquals(4L, handler.getLastCanceledCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(-1L);
+ assertThat(handler.getLastCanceledCheckpointId()).isEqualTo(4L);
assertInflightData();
// a simple successful checkpoint
@@ -687,7 +673,7 @@ public class UnalignedCheckpointsTest {
createBuffer(1));
assertOutput(sequence5);
- assertEquals(5L, channelStateWriter.getLastStartedCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(5L);
assertInflightData();
// abort multiple cancellations and a barrier after the cancellations, don't start a
@@ -704,8 +690,8 @@ public class UnalignedCheckpointsTest {
createEndOfPartition(2));
assertOutput(sequence6);
- assertEquals(-1L, channelStateWriter.getLastStartedCheckpointId());
- assertEquals(6L, handler.getLastCanceledCheckpointId());
+ assertThat(channelStateWriter.getLastStartedCheckpointId()).isEqualTo(-1L);
+ assertThat(handler.getLastCanceledCheckpointId()).isEqualTo(6L);
assertInflightData();
}
@@ -716,7 +702,7 @@ public class UnalignedCheckpointsTest {
* CheckpointBarrierHandler#processBarrier(CheckpointBarrier, InputChannelInfo)}.
*/
@Test
- public void testProcessCancellationBarrierAfterProcessBarrier() throws Exception {
+ void testProcessCancellationBarrierAfterProcessBarrier() throws Exception {
final ValidatingCheckpointInvokable invokable = new ValidatingCheckpointInvokable();
final SingleInputGate inputGate =
new SingleInputGateBuilder()
@@ -736,14 +722,14 @@ public class UnalignedCheckpointsTest {
handler.processBarrier(
buildCheckpointBarrier(DEFAULT_CHECKPOINT_ID), new InputChannelInfo(0, 0), false);
- assertTrue(handler.isCheckpointPending());
- assertEquals(DEFAULT_CHECKPOINT_ID, handler.getLatestCheckpointId());
+ assertThat(handler.isCheckpointPending()).isTrue();
+ assertThat(handler.getLatestCheckpointId()).isEqualTo(DEFAULT_CHECKPOINT_ID);
testProcessCancellationBarrier(handler, invokable);
}
@Test
- public void testProcessCancellationBarrierBeforeProcessAndReceiveBarrier() throws Exception {
+ void testProcessCancellationBarrierBeforeProcessAndReceiveBarrier() throws Exception {
final ValidatingCheckpointInvokable invokable = new ValidatingCheckpointInvokable();
final SingleInputGate inputGate =
new SingleInputGateBuilder()
@@ -795,13 +781,13 @@ public class UnalignedCheckpointsTest {
ValidatingCheckpointInvokable invokable,
long currentCheckpointId) {
- assertFalse(handler.isCheckpointPending());
- assertEquals(currentCheckpointId, handler.getLatestCheckpointId());
- assertEquals(currentCheckpointId, invokable.getAbortedCheckpointId());
+ assertThat(handler.isCheckpointPending()).isFalse();
+ assertThat(handler.getLatestCheckpointId()).isEqualTo(currentCheckpointId);
+ assertThat(invokable.getAbortedCheckpointId()).isEqualTo(currentCheckpointId);
}
@Test
- public void testEndOfStreamWithPendingCheckpoint() throws Exception {
+ void testEndOfStreamWithPendingCheckpoint() throws Exception {
final int numberOfChannels = 2;
final ValidatingCheckpointInvokable invokable = new ValidatingCheckpointInvokable();
final SingleInputGate inputGate =
@@ -822,21 +808,21 @@ public class UnalignedCheckpointsTest {
handler.processBarrier(
buildCheckpointBarrier(DEFAULT_CHECKPOINT_ID), new InputChannelInfo(0, 0), false);
- assertTrue(handler.isCheckpointPending());
- assertEquals(DEFAULT_CHECKPOINT_ID, handler.getLatestCheckpointId());
- assertEquals(numberOfChannels, handler.getNumOpenChannels());
+ assertThat(handler.isCheckpointPending()).isTrue();
+ assertThat(handler.getLatestCheckpointId()).isEqualTo(DEFAULT_CHECKPOINT_ID);
+ assertThat(handler.getNumOpenChannels()).isEqualTo(numberOfChannels);
// should abort current checkpoint while processing eof
handler.processEndOfPartition(new InputChannelInfo(0, 0));
- assertFalse(handler.isCheckpointPending());
- assertEquals(DEFAULT_CHECKPOINT_ID, handler.getLatestCheckpointId());
- assertEquals(numberOfChannels - 1, handler.getNumOpenChannels());
- assertEquals(DEFAULT_CHECKPOINT_ID, invokable.getAbortedCheckpointId());
+ assertThat(handler.isCheckpointPending()).isFalse();
+ assertThat(handler.getLatestCheckpointId()).isEqualTo(DEFAULT_CHECKPOINT_ID);
+ assertThat(handler.getNumOpenChannels()).isEqualTo(numberOfChannels - 1);
+ assertThat(invokable.getAbortedCheckpointId()).isEqualTo(DEFAULT_CHECKPOINT_ID);
}
@Test
- public void testTriggerCheckpointsWithEndOfPartition() throws Exception {
+ void testTriggerCheckpointsWithEndOfPartition() throws Exception {
ValidatingCheckpointHandler validator = new ValidatingCheckpointHandler(-1);
inputGate = createInputGate(3, validator);
@@ -852,13 +838,13 @@ public class UnalignedCheckpointsTest {
/* 6 */ createEndOfPartition(1));
assertOutput(sequence);
- assertThat(validator.triggeredCheckpoints, contains(1L));
- assertEquals(0, validator.getAbortedCheckpointCounter());
+ assertThat(validator.triggeredCheckpoints).containsExactly(1L);
+ assertThat(validator.getAbortedCheckpointCounter()).isZero();
assertInflightData(sequence[1]);
}
@Test
- public void testTriggerCheckpointsAfterReceivedEndOfPartition() throws Exception {
+ void testTriggerCheckpointsAfterReceivedEndOfPartition() throws Exception {
ValidatingCheckpointHandler validator = new ValidatingCheckpointHandler(-1);
inputGate = createInputGate(3, validator);
@@ -873,8 +859,8 @@ public class UnalignedCheckpointsTest {
/* 5 */ createBarrier(3, 2));
assertOutput(sequence1);
assertInflightData(sequence1[3]);
- assertThat(validator.triggeredCheckpoints, contains(3L));
- assertEquals(0, validator.getAbortedCheckpointCounter());
+ assertThat(validator.triggeredCheckpoints).containsExactly(3L);
+ assertThat(validator.getAbortedCheckpointCounter()).isZero();
BufferOrEvent[] sequence2 =
addSequence(
@@ -884,8 +870,8 @@ public class UnalignedCheckpointsTest {
/* 2 */ createEndOfPartition(2));
assertOutput(sequence2);
assertInflightData();
- assertThat(validator.triggeredCheckpoints, contains(3L, 4L));
- assertEquals(0, validator.getAbortedCheckpointCounter());
+ assertThat(validator.triggeredCheckpoints).containsExactly(3L, 4L);
+ assertThat(validator.getAbortedCheckpointCounter()).isZero();
}
// ------------------------------------------------------------------------
@@ -1024,10 +1010,9 @@ public class UnalignedCheckpointsTest {
private void assertInflightData(BufferOrEvent... expected) {
Collection<BufferOrEvent> andResetInflightData = getAndResetInflightData();
- assertEquals(
- "Unexpected in-flight sequence: " + andResetInflightData,
- getIds(Arrays.asList(expected)),
- getIds(andResetInflightData));
+ assertThat(getIds(andResetInflightData))
+ .as("Unexpected in-flight sequence: " + andResetInflightData)
+ .isEqualTo(getIds(Arrays.asList(expected)));
}
private Collection<BufferOrEvent> getAndResetInflightData() {
@@ -1040,10 +1025,9 @@ public class UnalignedCheckpointsTest {
}
private void assertOutput(BufferOrEvent... expectedSequence) {
- assertEquals(
- "Unexpected output sequence",
- getIds(Arrays.asList(expectedSequence)),
- getIds(output));
+ assertThat(getIds(output))
+ .as("Unexpected output sequence")
+ .isEqualTo(getIds(Arrays.asList(expectedSequence)));
}
private List<Object> getIds(Collection<BufferOrEvent> buffers) {
@@ -1094,7 +1078,7 @@ public class UnalignedCheckpointsTest {
public void abortCheckpointOnBarrier(long checkpointId, CheckpointException cause) {
super.abortCheckpointOnBarrier(checkpointId, cause);
checkState(inputGate != null);
- assertFalse(inputGate.getAllBarriersReceivedFuture(checkpointId).isDone());
+ assertThat(inputGate.getAllBarriersReceivedFuture(checkpointId)).isNotDone();
}
public void setInputGate(CheckpointedInputGate inputGate) {
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/ValidatingCheckpointHandler.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/ValidatingCheckpointHandler.java
index 180ba867758..fc924be700d 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/ValidatingCheckpointHandler.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/checkpointing/ValidatingCheckpointHandler.java
@@ -32,8 +32,7 @@ import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** The invokable handler used for triggering checkpoint and validation. */
public class ValidatingCheckpointHandler extends AbstractInvokable {
@@ -112,9 +111,9 @@ public class ValidatingCheckpointHandler extends AbstractInvokable {
CheckpointOptions checkpointOptions,
CheckpointMetricsBuilder checkpointMetrics) {
if (nextExpectedCheckpointId != -1L) {
- assertEquals(nextExpectedCheckpointId, checkpointMetaData.getCheckpointId());
+ assertThat(checkpointMetaData.getCheckpointId()).isEqualTo(nextExpectedCheckpointId);
}
- assertTrue(checkpointMetaData.getTimestamp() > 0);
+ assertThat(checkpointMetaData.getTimestamp()).isPositive();
nextExpectedCheckpointId = checkpointMetaData.getCheckpointId() + 1;
triggeredCheckpointCounter++;
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/recovery/DemultiplexingRecordDeserializerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/recovery/DemultiplexingRecordDeserializerTest.java
index a9383d0456b..1b04b7f6dbe 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/recovery/DemultiplexingRecordDeserializerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/io/recovery/DemultiplexingRecordDeserializerTest.java
@@ -40,17 +40,13 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.shaded.guava31.com.google.common.collect.Iterables;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.mockito.internal.util.collections.Sets;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
@@ -64,24 +60,22 @@ import static org.apache.flink.runtime.checkpoint.InflightDataRescalingDescripto
import static org.apache.flink.runtime.checkpoint.InflightDataRescalingDescriptorUtil.set;
import static org.apache.flink.runtime.checkpoint.InflightDataRescalingDescriptorUtil.to;
import static org.apache.flink.runtime.io.network.buffer.BufferBuilderTestUtils.createBufferBuilder;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests {@link DemultiplexingRecordDeserializer}. */
-public class DemultiplexingRecordDeserializerTest {
- @Rule public TemporaryFolder folder = new TemporaryFolder();
+class DemultiplexingRecordDeserializerTest {
private final ThreadLocalRandom random = ThreadLocalRandom.current();
private IOManager ioManager;
- @Before
- public void setup() {
+ @BeforeEach
+ void setup() {
ioManager = new IOManagerAsync();
}
- @After
- public void cleanup() {
+ @AfterEach
+ void cleanup() {
ioManager = new IOManagerAsync();
}
@@ -90,7 +84,7 @@ public class DemultiplexingRecordDeserializerTest {
* channels.
*/
@Test
- public void testUpscale() throws IOException {
+ void testUpscale() throws IOException {
DemultiplexingRecordDeserializer<Long> deserializer =
DemultiplexingRecordDeserializer.create(
new InputChannelInfo(2, 0),
@@ -103,13 +97,12 @@ public class DemultiplexingRecordDeserializerTest {
ioManager.getSpillingDirectoriesPaths()),
unused -> RecordFilter.all());
- assertEquals(
- Sets.newSet(
+ assertThat(deserializer.getVirtualChannelSelectors())
+ .containsOnly(
new SubtaskConnectionDescriptor(0, 2),
new SubtaskConnectionDescriptor(0, 3),
new SubtaskConnectionDescriptor(1, 2),
- new SubtaskConnectionDescriptor(1, 3)),
- deserializer.getVirtualChannelSelectors());
+ new SubtaskConnectionDescriptor(1, 3));
for (int i = 0; i < 100; i++) {
SubtaskConnectionDescriptor selector =
@@ -125,15 +118,14 @@ public class DemultiplexingRecordDeserializerTest {
deserializer.setNextBuffer(buffer);
}
- assertEquals(
- Arrays.asList(start + 1L, start + 2L, start + 3L), readLongs(deserializer));
- assertTrue(memorySegment.isFreed());
+ assertThat(readLongs(deserializer)).containsExactly(start + 1L, start + 2L, start + 3L);
+ assertThat(memorySegment.isFreed()).isTrue();
}
}
/** Tests that {@link RecordFilter} are used correctly. */
@Test
- public void testAmbiguousChannels() throws IOException {
+ void testAmbiguousChannels() throws IOException {
DemultiplexingRecordDeserializer<Long> deserializer =
DemultiplexingRecordDeserializer.create(
new InputChannelInfo(1, 0),
@@ -146,13 +138,12 @@ public class DemultiplexingRecordDeserializerTest {
ioManager.getSpillingDirectoriesPaths()),
unused -> new RecordFilter(new ModSelector(2), LongSerializer.INSTANCE, 1));
- assertEquals(
- Sets.newSet(
+ assertThat(deserializer.getVirtualChannelSelectors())
+ .containsOnly(
new SubtaskConnectionDescriptor(41, 2),
new SubtaskConnectionDescriptor(41, 3),
new SubtaskConnectionDescriptor(42, 2),
- new SubtaskConnectionDescriptor(42, 3)),
- deserializer.getVirtualChannelSelectors());
+ new SubtaskConnectionDescriptor(42, 3));
for (int i = 0; i < 100; i++) {
MemorySegment memorySegment = allocateUnpooledSegment(128);
@@ -166,20 +157,20 @@ public class DemultiplexingRecordDeserializerTest {
deserializer.setNextBuffer(buffer);
if (selector.getInputSubtaskIndex() == 41) {
- assertEquals(Arrays.asList((long) i, i + 1L), readLongs(deserializer));
+ assertThat(readLongs(deserializer)).containsExactly((long) i, i + 1L);
} else {
// only odd should occur in output
- assertEquals(Arrays.asList(i / 2 * 2 + 1L), readLongs(deserializer));
+ assertThat(readLongs(deserializer)).containsExactly(i / 2 * 2 + 1L);
}
}
- assertTrue(memorySegment.isFreed());
+ assertThat(memorySegment.isFreed()).isTrue();
}
}
/** Tests that Watermarks are only forwarded when all watermarks are received. */
@Test
- public void testWatermarks() throws IOException {
+ void testWatermarks() throws IOException {
DemultiplexingRecordDeserializer<Long> deserializer =
DemultiplexingRecordDeserializer.create(
new InputChannelInfo(0, 0),
@@ -190,7 +181,7 @@ public class DemultiplexingRecordDeserializerTest {
ioManager.getSpillingDirectoriesPaths()),
unused -> RecordFilter.all());
- assertEquals(4, deserializer.getVirtualChannelSelectors().size());
+ assertThat(deserializer.getVirtualChannelSelectors()).hasSize(4);
for (Iterator<SubtaskConnectionDescriptor> iterator =
deserializer.getVirtualChannelSelectors().iterator();
@@ -207,13 +198,13 @@ public class DemultiplexingRecordDeserializerTest {
}
if (iterator.hasNext()) {
- assertEquals(Collections.emptyList(), read(deserializer));
+ assertThat(read(deserializer)).isEmpty();
} else {
// last channel, min should be 42 + 0 + 0
- assertEquals(Arrays.asList(new Watermark(42)), read(deserializer));
+ assertThat(read(deserializer)).containsExactly(new Watermark(42));
}
- assertTrue(memorySegment.isFreed());
+ assertThat(memorySegment.isFreed()).isTrue();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/metrics/MinWatermarkGaugeTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/metrics/MinWatermarkGaugeTest.java
index 95627132f83..8eb3120a161 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/metrics/MinWatermarkGaugeTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/metrics/MinWatermarkGaugeTest.java
@@ -18,27 +18,28 @@
package org.apache.flink.streaming.runtime.metrics;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for the {@link MinWatermarkGauge}. */
-public class MinWatermarkGaugeTest {
+class MinWatermarkGaugeTest {
@Test
- public void testSetCurrentLowWatermark() {
+ void testSetCurrentLowWatermark() {
WatermarkGauge metric1 = new WatermarkGauge();
WatermarkGauge metric2 = new WatermarkGauge();
MinWatermarkGauge metric = new MinWatermarkGauge(metric1, metric2);
- Assert.assertEquals(Long.MIN_VALUE, metric.getValue().longValue());
+ assertThat(metric.getValue()).isEqualTo(Long.MIN_VALUE);
metric1.setCurrentWatermark(1);
- Assert.assertEquals(Long.MIN_VALUE, metric.getValue().longValue());
+ assertThat(metric.getValue()).isEqualTo(Long.MIN_VALUE);
metric2.setCurrentWatermark(2);
- Assert.assertEquals(1L, metric.getValue().longValue());
+ assertThat(metric.getValue()).isOne();
metric1.setCurrentWatermark(3);
- Assert.assertEquals(2L, metric.getValue().longValue());
+ assertThat(metric.getValue()).isEqualTo(2L);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/metrics/WatermarkGaugeTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/metrics/WatermarkGaugeTest.java
index a2d4cbdb104..13b76e5c6d8 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/metrics/WatermarkGaugeTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/metrics/WatermarkGaugeTest.java
@@ -18,19 +18,20 @@
package org.apache.flink.streaming.runtime.metrics;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for the {@link WatermarkGauge}. */
-public class WatermarkGaugeTest {
+class WatermarkGaugeTest {
@Test
- public void testSetCurrentLowWatermark() {
+ void testSetCurrentLowWatermark() {
WatermarkGauge metric = new WatermarkGauge();
- Assert.assertEquals(Long.MIN_VALUE, metric.getValue().longValue());
+ assertThat(metric.getValue()).isEqualTo(Long.MIN_VALUE);
metric.setCurrentWatermark(64);
- Assert.assertEquals(64, metric.getValue().longValue());
+ assertThat(metric.getValue()).isEqualTo(64L);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/ContinuousFileProcessingRescalingTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/ContinuousFileProcessingRescalingTest.java
index 70a8bb72081..cce23535034 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/ContinuousFileProcessingRescalingTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/ContinuousFileProcessingRescalingTest.java
@@ -36,8 +36,7 @@ import org.apache.flink.streaming.runtime.tasks.mailbox.SteppingMailboxProcessor
import org.apache.flink.streaming.util.OneInputStreamOperatorTestHarness;
import org.apache.flink.util.Preconditions;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import javax.annotation.Nullable;
@@ -50,16 +49,17 @@ import java.util.stream.Stream;
import static org.apache.flink.streaming.util.AbstractStreamOperatorTestHarness.repackageState;
import static org.apache.flink.streaming.util.AbstractStreamOperatorTestHarness.repartitionOperatorState;
+import static org.assertj.core.api.Assertions.assertThat;
/** Test processing files during rescaling. */
-public class ContinuousFileProcessingRescalingTest {
+class ContinuousFileProcessingRescalingTest {
private final int maxParallelism = 10;
private final int sizeOfSplit = 20;
/** Simulates the scenario of scaling down from 2 to 1 instances. */
@Test
- public void testReaderScalingDown() throws Exception {
+ void testReaderScalingDown() throws Exception {
HarnessWithFormat[] beforeRescale = {};
try {
beforeRescale = buildAndStart(5, 15);
@@ -76,7 +76,7 @@ public class ContinuousFileProcessingRescalingTest {
i.awaitEverythingProcessed();
}
- Assert.assertEquals(collectOutput(beforeRescale), collectOutput(afterRescale));
+ assertThat(collectOutput(afterRescale)).isEqualTo(collectOutput(beforeRescale));
}
} finally {
for (HarnessWithFormat harness : beforeRescale) {
@@ -87,7 +87,7 @@ public class ContinuousFileProcessingRescalingTest {
/** Simulates the scenario of scaling up from 1 to 2 instances. */
@Test
- public void testReaderScalingUp() throws Exception {
+ void testReaderScalingUp() throws Exception {
try (HarnessWithFormat beforeRescale = buildAndStart(1, 0, 5, null, buildSplits(2))) {
OperatorSubtaskState snapshot = beforeRescale.getHarness().snapshot(0, 0);
try (HarnessWithFormat afterRescale0 =
@@ -110,8 +110,8 @@ public class ContinuousFileProcessingRescalingTest {
harness.awaitEverythingProcessed();
}
- Assert.assertEquals(
- collectOutput(beforeRescale), collectOutput(afterRescale0, afterRescale1));
+ assertThat(collectOutput(afterRescale0, afterRescale1))
+ .isEqualTo(collectOutput(beforeRescale));
}
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/MailboxOperatorTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/MailboxOperatorTest.java
index c00791f4c2b..a4756af3837 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/MailboxOperatorTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/MailboxOperatorTest.java
@@ -25,28 +25,25 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.streaming.runtime.tasks.OneInputStreamTask;
import org.apache.flink.streaming.runtime.tasks.StreamTaskMailboxTestHarness;
import org.apache.flink.streaming.runtime.tasks.StreamTaskMailboxTestHarnessBuilder;
-import org.apache.flink.util.TestLogger;
import org.apache.flink.util.function.RunnableWithException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import javax.annotation.Nonnull;
import java.util.concurrent.RejectedExecutionException;
import java.util.stream.IntStream;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Test to verify that timer triggers are run according to operator precedence (combined with
* yield() at operator level).
*/
-public class MailboxOperatorTest extends TestLogger {
+class MailboxOperatorTest {
@Test
- public void testAvoidTaskStarvation() throws Exception {
+ void testAvoidTaskStarvation() throws Exception {
final int numRecords = 3;
StreamTaskMailboxTestHarnessBuilder<Integer> builder =
@@ -72,9 +69,9 @@ public class MailboxOperatorTest extends TestLogger {
testHarness.getOutput().stream()
.mapToInt(r -> ((StreamRecord<Integer>) r).getValue())
.toArray();
- assertArrayEquals(output, IntStream.range(0, numRecords).toArray());
- assertThat(mail1.getMailCount(), equalTo(numRecords + 1));
- assertThat(mail2.getMailCount(), equalTo(numRecords + 1));
+ assertThat(output).isEqualTo(IntStream.range(0, numRecords).toArray());
+ assertThat(mail1.getMailCount()).isEqualTo(numRecords + 1);
+ assertThat(mail2.getMailCount()).isEqualTo(numRecords + 1);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/SourceOperatorLatencyMetricsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/SourceOperatorLatencyMetricsTest.java
index 78913653983..314ed4de6d8 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/SourceOperatorLatencyMetricsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/SourceOperatorLatencyMetricsTest.java
@@ -30,33 +30,29 @@ import org.apache.flink.streaming.api.operators.SourceOperator;
import org.apache.flink.streaming.api.operators.SourceOperatorFactory;
import org.apache.flink.streaming.runtime.streamrecord.LatencyMarker;
import org.apache.flink.streaming.util.SourceOperatorTestHarness;
-import org.apache.flink.util.TestLogger;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.List;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for the emission of latency markers by {@link SourceOperator} operators. */
-public class SourceOperatorLatencyMetricsTest extends TestLogger {
+class SourceOperatorLatencyMetricsTest {
private static final long MAX_PROCESSING_TIME = 100L;
private static final long LATENCY_MARK_INTERVAL = 10L;
/** Verifies that by default no latency metrics are emitted. */
@Test
- public void testLatencyMarkEmissionDisabled() throws Exception {
+ void testLatencyMarkEmissionDisabled() throws Exception {
testLatencyMarkEmission(false, new Configuration(), new ExecutionConfig());
}
/** Verifies that latency metrics can be enabled via the {@link ExecutionConfig}. */
@Test
- public void testLatencyMarkEmissionEnabledViaExecutionConfig() throws Exception {
+ void testLatencyMarkEmissionEnabledViaExecutionConfig() throws Exception {
Configuration taskConfiguration = new Configuration();
ExecutionConfig executionConfig = new ExecutionConfig();
@@ -67,7 +63,7 @@ public class SourceOperatorLatencyMetricsTest extends TestLogger {
/** Verifies that latency metrics can be enabled via the configuration. */
@Test
- public void testLatencyMarkEmissionEnabledViaFlinkConfig() throws Exception {
+ void testLatencyMarkEmissionEnabledViaFlinkConfig() throws Exception {
Configuration taskConfiguration = new Configuration();
taskConfiguration.set(MetricOptions.LATENCY_INTERVAL, LATENCY_MARK_INTERVAL);
ExecutionConfig executionConfig = new ExecutionConfig();
@@ -80,7 +76,7 @@ public class SourceOperatorLatencyMetricsTest extends TestLogger {
* disabled via the configuration.
*/
@Test
- public void testLatencyMarkEmissionEnabledOverrideViaExecutionConfig() throws Exception {
+ void testLatencyMarkEmissionEnabledOverrideViaExecutionConfig() throws Exception {
Configuration taskConfiguration = new Configuration();
taskConfiguration.set(MetricOptions.LATENCY_INTERVAL, 0L);
ExecutionConfig executionConfig = new ExecutionConfig();
@@ -94,7 +90,7 @@ public class SourceOperatorLatencyMetricsTest extends TestLogger {
* are enabled via the configuration.
*/
@Test
- public void testLatencyMarkEmissionDisabledOverrideViaExecutionConfig() throws Exception {
+ void testLatencyMarkEmissionDisabledOverrideViaExecutionConfig() throws Exception {
Configuration taskConfiguration = new Configuration();
taskConfiguration.set(MetricOptions.LATENCY_INTERVAL, LATENCY_MARK_INTERVAL);
ExecutionConfig executionConfig = new ExecutionConfig();
@@ -103,10 +99,6 @@ public class SourceOperatorLatencyMetricsTest extends TestLogger {
testLatencyMarkEmission(false, taskConfiguration, executionConfig);
}
- private interface OperatorSetupOperation {
- void setupSourceOperator(SourceOperator<Integer, ?> operator) throws Exception;
- }
-
private void testLatencyMarkEmission(
boolean shouldExpectLatencyMarkers,
Configuration taskManagerConfig,
@@ -132,7 +124,7 @@ public class SourceOperatorLatencyMetricsTest extends TestLogger {
List<LatencyMarker> expectedOutput = new ArrayList<>();
if (!shouldExpectLatencyMarkers) {
- assertTrue(testHarness.getOutput().isEmpty());
+ assertThat(testHarness.getOutput()).isEmpty();
} else {
expectedOutput.add(
new LatencyMarker(1, testHarness.getOperator().getOperatorID(), 0));
@@ -143,9 +135,7 @@ public class SourceOperatorLatencyMetricsTest extends TestLogger {
new LatencyMarker(
markedTime, testHarness.getOperator().getOperatorID(), 0));
}
- assertThat(
- (Collection<Object>) testHarness.getOutput(),
- contains(expectedOutput.toArray()));
+ assertThat(testHarness.getOutput()).containsExactlyElementsOf(expectedOutput);
}
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamOperatorChainingTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamOperatorChainingTest.java
index 7b213e19709..5749447142c 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamOperatorChainingTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamOperatorChainingTest.java
@@ -46,18 +46,16 @@ import org.apache.flink.streaming.util.MockStreamTaskBuilder;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for stream operator chaining behaviour. */
@SuppressWarnings("serial")
-public class StreamOperatorChainingTest {
+class StreamOperatorChainingTest {
// We have to use static fields because the sink functions will go through serialization
private static List<String> sink1Results;
@@ -65,7 +63,7 @@ public class StreamOperatorChainingTest {
private static List<String> sink3Results;
@Test
- public void testMultiChainingWithObjectReuse() throws Exception {
+ void testMultiChainingWithObjectReuse() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.getConfig().enableObjectReuse();
@@ -73,7 +71,7 @@ public class StreamOperatorChainingTest {
}
@Test
- public void testMultiChainingWithoutObjectReuse() throws Exception {
+ void testMultiChainingWithoutObjectReuse() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.getConfig().disableObjectReuse();
@@ -118,7 +116,7 @@ public class StreamOperatorChainingTest {
// be build our own StreamTask and OperatorChain
JobGraph jobGraph = env.getStreamGraph().getJobGraph();
- Assert.assertTrue(jobGraph.getVerticesSortedTopologicallyFromSources().size() == 2);
+ assertThat(jobGraph.getVerticesSortedTopologicallyFromSources()).hasSize(2);
JobVertex chainedVertex = jobGraph.getVerticesSortedTopologicallyFromSources().get(1);
@@ -143,8 +141,8 @@ public class StreamOperatorChainingTest {
headOperator.processElement(new StreamRecord<>(2));
headOperator.processElement(new StreamRecord<>(3));
- assertThat(sink1Results, contains("First: 1", "First: 2", "First: 3"));
- assertThat(sink2Results, contains("Second: 1", "Second: 2", "Second: 3"));
+ assertThat(sink1Results).containsExactly("First: 1", "First: 2", "First: 3");
+ assertThat(sink2Results).containsExactly("Second: 1", "Second: 2", "Second: 3");
}
}
@@ -158,7 +156,7 @@ public class StreamOperatorChainingTest {
}
@Test
- public void testMultiChainingWithSplitWithObjectReuse() throws Exception {
+ void testMultiChainingWithSplitWithObjectReuse() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.getConfig().enableObjectReuse();
@@ -166,7 +164,7 @@ public class StreamOperatorChainingTest {
}
@Test
- public void testMultiChainingWithSplitWithoutObjectReuse() throws Exception {
+ void testMultiChainingWithSplitWithoutObjectReuse() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.getConfig().disableObjectReuse();
@@ -244,7 +242,7 @@ public class StreamOperatorChainingTest {
// be build our own StreamTask and OperatorChain
JobGraph jobGraph = env.getStreamGraph().getJobGraph();
- Assert.assertTrue(jobGraph.getVerticesSortedTopologicallyFromSources().size() == 2);
+ assertThat(jobGraph.getVerticesSortedTopologicallyFromSources()).hasSize(2);
JobVertex chainedVertex = jobGraph.getVerticesSortedTopologicallyFromSources().get(1);
@@ -269,9 +267,9 @@ public class StreamOperatorChainingTest {
headOperator.processElement(new StreamRecord<>(2));
headOperator.processElement(new StreamRecord<>(3));
- assertThat(sink1Results, contains("First 1: 1"));
- assertThat(sink2Results, contains("First 2: 1"));
- assertThat(sink3Results, contains("Second: 2", "Second: 3"));
+ assertThat(sink1Results).containsExactly("First 1: 1");
+ assertThat(sink2Results).containsExactly("First 2: 1");
+ assertThat(sink3Results).containsExactly("Second: 2", "Second: 3");
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamSourceOperatorLatencyMetricsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamSourceOperatorLatencyMetricsTest.java
index 9eb2172f7d6..b064ffa13a8 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamSourceOperatorLatencyMetricsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamSourceOperatorLatencyMetricsTest.java
@@ -42,28 +42,25 @@ import org.apache.flink.streaming.runtime.tasks.TimerService;
import org.apache.flink.streaming.util.CollectorOutput;
import org.apache.flink.streaming.util.MockStreamTask;
import org.apache.flink.streaming.util.MockStreamTaskBuilder;
-import org.apache.flink.util.TestLogger;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/** Tests for the emission of latency markers by {@link StreamSource} operators. */
-public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
+class StreamSourceOperatorLatencyMetricsTest {
private static final long maxProcessingTime = 100L;
private static final long latencyMarkInterval = 10L;
/** Verifies that by default no latency metrics are emitted. */
@Test
- public void testLatencyMarkEmissionDisabled() throws Exception {
+ void testLatencyMarkEmissionDisabled() throws Exception {
testLatencyMarkEmission(
0,
(operator, timeProvider) ->
@@ -76,7 +73,7 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
/** Verifies that latency metrics can be enabled via the {@link ExecutionConfig}. */
@Test
- public void testLatencyMarkEmissionEnabledViaExecutionConfig() throws Exception {
+ void testLatencyMarkEmissionEnabledViaExecutionConfig() throws Exception {
testLatencyMarkEmission(
(int) (maxProcessingTime / latencyMarkInterval) + 1,
(operator, timeProvider) -> {
@@ -93,7 +90,7 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
/** Verifies that latency metrics can be enabled via the configuration. */
@Test
- public void testLatencyMarkEmissionEnabledViaFlinkConfig() throws Exception {
+ void testLatencyMarkEmissionEnabledViaFlinkConfig() throws Exception {
testLatencyMarkEmission(
(int) (maxProcessingTime / latencyMarkInterval) + 1,
(operator, timeProvider) -> {
@@ -115,7 +112,7 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
* disabled via the configuration.
*/
@Test
- public void testLatencyMarkEmissionEnabledOverrideViaExecutionConfig() throws Exception {
+ void testLatencyMarkEmissionEnabledOverrideViaExecutionConfig() throws Exception {
testLatencyMarkEmission(
(int) (maxProcessingTime / latencyMarkInterval) + 1,
(operator, timeProvider) -> {
@@ -140,7 +137,7 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
* are enabled via the configuration.
*/
@Test
- public void testLatencyMarkEmissionDisabledOverrideViaExecutionConfig() throws Exception {
+ void testLatencyMarkEmissionDisabledOverrideViaExecutionConfig() throws Exception {
testLatencyMarkEmission(
0,
(operator, timeProvider) -> {
@@ -162,8 +159,8 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
private interface OperatorSetupOperation {
void setupSourceOperator(
- StreamSource<Long, ?> operator,
- TestProcessingTimeService testProcessingTimeService);
+ StreamSource<Long, ?> operator, TestProcessingTimeService testProcessingTimeService)
+ throws Exception;
}
private void testLatencyMarkEmission(
@@ -196,7 +193,7 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
operatorChain.close();
}
- assertEquals(numberLatencyMarkers, output.size());
+ assertThat(output).hasSize(numberLatencyMarkers);
long timestamp = 0L;
int expectedLatencyIndex = 0;
@@ -205,9 +202,9 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
// verify that its only latency markers
for (; i < numberLatencyMarkers; i++) {
StreamElement se = output.get(i);
- Assert.assertTrue(se.isLatencyMarker());
- Assert.assertEquals(operator.getOperatorID(), se.asLatencyMarker().getOperatorId());
- Assert.assertEquals(0, se.asLatencyMarker().getSubtaskIndex());
+ assertThat(se.isLatencyMarker()).isTrue();
+ assertThat(se.asLatencyMarker().getOperatorId()).isEqualTo(operator.getOperatorID());
+ assertThat(se.asLatencyMarker().getSubtaskIndex()).isZero();
// determines the next latency mark that should've been emitted
// latency marks are emitted once per latencyMarkInterval,
@@ -215,9 +212,8 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
while (timestamp > processingTimes.get(expectedLatencyIndex)) {
expectedLatencyIndex++;
}
- Assert.assertEquals(
- processingTimes.get(expectedLatencyIndex).longValue(),
- se.asLatencyMarker().getMarkedTime());
+ assertThat(se.asLatencyMarker().getMarkedTime())
+ .isEqualTo(processingTimes.get(expectedLatencyIndex));
timestamp += latencyMarkInterval;
}
@@ -230,7 +226,8 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
StreamSource<T, ?> operator,
ExecutionConfig executionConfig,
Environment env,
- TimerService timerService) {
+ TimerService timerService)
+ throws Exception {
StreamConfig cfg = new StreamConfig(new Configuration());
cfg.setStateBackend(new MemoryStateBackend());
@@ -239,21 +236,16 @@ public class StreamSourceOperatorLatencyMetricsTest extends TestLogger {
cfg.setOperatorID(new OperatorID());
cfg.serializeAllConfigs();
- try {
- MockStreamTask mockTask =
- new MockStreamTaskBuilder(env)
- .setConfig(cfg)
- .setExecutionConfig(executionConfig)
- .setTimerService(timerService)
- .build();
-
- operator.setProcessingTimeService(
- mockTask.getProcessingTimeServiceFactory().createProcessingTimeService(null));
- operator.setup(mockTask, cfg, (Output<StreamRecord<T>>) mock(Output.class));
- } catch (Exception e) {
- e.printStackTrace();
- fail(e.getMessage());
- }
+ MockStreamTask mockTask =
+ new MockStreamTaskBuilder(env)
+ .setConfig(cfg)
+ .setExecutionConfig(executionConfig)
+ .setTimerService(timerService)
+ .build();
+
+ operator.setProcessingTimeService(
+ mockTask.getProcessingTimeServiceFactory().createProcessingTimeService(null));
+ operator.setup(mockTask, cfg, (Output<StreamRecord<T>>) mock(Output.class));
}
// ------------------------------------------------------------------------
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamSourceOperatorWatermarksTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamSourceOperatorWatermarksTest.java
index 04cf36932a8..dea2cb370d5 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamSourceOperatorWatermarksTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamSourceOperatorWatermarksTest.java
@@ -46,22 +46,21 @@ import org.apache.flink.streaming.util.MockStreamTask;
import org.apache.flink.streaming.util.MockStreamTaskBuilder;
import org.apache.flink.util.ExceptionUtils;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;
/** Tests for {@link StreamSource} operators. */
@SuppressWarnings("serial")
-public class StreamSourceOperatorWatermarksTest {
+class StreamSourceOperatorWatermarksTest {
@Test
- public void testEmitMaxWatermarkForFiniteSource() throws Exception {
+ void testEmitMaxWatermarkForFiniteSource() throws Exception {
StreamSource<String, ?> sourceOperator = new StreamSource<>(new FiniteSource<>());
StreamTaskTestHarness<String> testHarness =
setupSourceStreamTask(sourceOperator, BasicTypeInfo.STRING_TYPE_INFO);
@@ -69,12 +68,12 @@ public class StreamSourceOperatorWatermarksTest {
testHarness.invoke();
testHarness.waitForTaskCompletion();
- assertEquals(1, testHarness.getOutput().size());
- assertEquals(Watermark.MAX_WATERMARK, testHarness.getOutput().peek());
+ assertThat(testHarness.getOutput()).hasSize(1);
+ assertThat(testHarness.getOutput().peek()).isEqualTo(Watermark.MAX_WATERMARK);
}
@Test
- public void testDisabledProgressiveWatermarksForFiniteSource() throws Exception {
+ void testDisabledProgressiveWatermarksForFiniteSource() throws Exception {
StreamSource<String, ?> sourceOperator =
new StreamSource<>(new FiniteSourceWithWatermarks<>(), false);
StreamTaskTestHarness<String> testHarness =
@@ -84,34 +83,29 @@ public class StreamSourceOperatorWatermarksTest {
testHarness.waitForTaskCompletion();
// sent by source function
- assertEquals(Watermark.MAX_WATERMARK, testHarness.getOutput().poll());
+ assertThat(testHarness.getOutput().poll()).isEqualTo(Watermark.MAX_WATERMARK);
// sent by framework
- assertEquals(Watermark.MAX_WATERMARK, testHarness.getOutput().poll());
+ assertThat(testHarness.getOutput().poll()).isEqualTo(Watermark.MAX_WATERMARK);
- assertTrue(testHarness.getOutput().isEmpty());
+ assertThat(testHarness.getOutput()).isEmpty();
}
@Test
- public void testNoMaxWatermarkOnImmediateCancel() throws Exception {
+ void testNoMaxWatermarkOnImmediateCancel() throws Exception {
StreamSource<String, ?> sourceOperator = new StreamSource<>(new InfiniteSource<>());
StreamTaskTestHarness<String> testHarness =
setupSourceStreamTask(sourceOperator, BasicTypeInfo.STRING_TYPE_INFO, true);
testHarness.invoke();
- try {
- testHarness.waitForTaskCompletion();
- fail("should throw an exception");
- } catch (Throwable t) {
- if (!ExceptionUtils.findThrowable(t, CancelTaskException.class).isPresent()) {
- throw t;
- }
- }
- assertTrue(testHarness.getOutput().isEmpty());
+ assertThatThrownBy(testHarness::waitForTaskCompletion)
+ .hasCauseInstanceOf(CancelTaskException.class);
+
+ assertThat(testHarness.getOutput()).isEmpty();
}
@Test
- public void testNoMaxWatermarkOnAsyncCancel() throws Exception {
+ void testNoMaxWatermarkOnAsyncCancel() throws Exception {
StreamSource<String, ?> sourceOperator = new StreamSource<>(new InfiniteSource<>());
StreamTaskTestHarness<String> testHarness =
setupSourceStreamTask(sourceOperator, BasicTypeInfo.STRING_TYPE_INFO);
@@ -127,11 +121,11 @@ public class StreamSourceOperatorWatermarksTest {
throw t;
}
}
- assertTrue(testHarness.getOutput().isEmpty());
+ assertThat(testHarness.getOutput()).isEmpty();
}
@Test
- public void testAutomaticWatermarkContext() throws Exception {
+ void testAutomaticWatermarkContext() throws Exception {
// regular stream source operator
final StreamSource<String, InfiniteSource<String>> operator =
@@ -167,13 +161,13 @@ public class StreamSourceOperatorWatermarksTest {
processingTimeService.setCurrentTime(i);
}
- assertEquals(9, output.size());
+ assertThat(output).hasSize(9);
long nextWatermark = 0;
for (StreamElement el : output) {
nextWatermark += watermarkInterval;
Watermark wm = (Watermark) el;
- assertEquals(wm.getTimestamp(), nextWatermark);
+ assertThat(wm.getTimestamp()).isEqualTo(nextWatermark);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamTaskOperatorTimerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamTaskOperatorTimerTest.java
index ae148583680..d2ca5c7fe08 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamTaskOperatorTimerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamTaskOperatorTimerTest.java
@@ -34,27 +34,24 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.streaming.runtime.tasks.OneInputStreamTask;
import org.apache.flink.streaming.runtime.tasks.OneInputStreamTaskTestHarness;
import org.apache.flink.streaming.runtime.tasks.ProcessingTimeService;
-import org.apache.flink.util.TestLogger;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Test to verify that timer triggers are run according to operator precedence (combined with
* yield() at operator level).
*/
-public class StreamTaskOperatorTimerTest extends TestLogger {
+class StreamTaskOperatorTimerTest {
private static final String TRIGGER_PREFIX = "trigger:";
private static final String RESULT_PREFIX = "timer:";
@Test
- public void testOperatorYieldExecutesSelectedTimers() throws Exception {
+ void testOperatorYieldExecutesSelectedTimers() throws Exception {
final OneInputStreamTaskTestHarness<String, String> testHarness =
new OneInputStreamTaskTestHarness<>(
OneInputStreamTask::new,
@@ -79,8 +76,7 @@ public class StreamTaskOperatorTimerTest extends TestLogger {
testHarness
.getOutput()
.forEach(element -> events.add(((StreamRecord<String>) element).getValue()));
- assertThat(
- events, is(Arrays.asList(trigger, RESULT_PREFIX + "1:0", RESULT_PREFIX + "0:0")));
+ assertThat(events).containsExactly(trigger, RESULT_PREFIX + "1:0", RESULT_PREFIX + "0:0");
}
private static class TestOperatorFactory extends AbstractStreamOperatorFactory<String>
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamTaskTimerITCase.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamTaskTimerITCase.java
index 81c5b60f4a0..f7438ef9fe2 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamTaskTimerITCase.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/StreamTaskTimerITCase.java
@@ -30,13 +30,11 @@ import org.apache.flink.streaming.runtime.tasks.OneInputStreamTaskTestHarness;
import org.apache.flink.streaming.runtime.tasks.ProcessingTimeService;
import org.apache.flink.streaming.runtime.tasks.StreamTask;
import org.apache.flink.streaming.runtime.tasks.StreamTaskTestHarness;
-import org.apache.flink.util.TestLogger;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.Timeout;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
import java.time.Duration;
import java.util.ArrayList;
@@ -47,20 +45,18 @@ import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicReference;
import static org.apache.flink.api.common.operators.ProcessingTimeService.ProcessingTimeCallback;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for the timer service of {@link org.apache.flink.streaming.runtime.tasks.StreamTask}. */
@SuppressWarnings("serial")
-public class StreamTaskTimerITCase extends TestLogger {
+@Timeout(value = 20, unit = TimeUnit.SECONDS)
+class StreamTaskTimerITCase {
private StreamTaskTestHarness<?> testHarness;
private ProcessingTimeService timeService;
- @Rule public final Timeout timeoutPerTest = Timeout.seconds(20);
- @Before
- public void setup() throws Exception {
+ @BeforeEach
+ void setup() throws Exception {
testHarness = startTestHarness();
StreamTask<?, ?> task = testHarness.getTask();
@@ -72,13 +68,13 @@ public class StreamTaskTimerITCase extends TestLogger {
testHarness.getStreamConfig().getChainIndex()));
}
- @After
- public void teardown() throws Exception {
+ @AfterEach
+ void teardown() throws Exception {
stopTestHarness(testHarness, 4000L);
}
@Test
- public void testOpenCloseAndTimestamps() throws InterruptedException {
+ void testOpenCloseAndTimestamps() throws InterruptedException {
// Wait for StreamTask#invoke spawn the timeService threads for the throughput calculation.
while (StreamTask.TRIGGER_THREAD_GROUP.activeCount() != 1) {
Thread.sleep(1);
@@ -87,7 +83,7 @@ public class StreamTaskTimerITCase extends TestLogger {
}
@Test
- public void testErrorReporting() throws Exception {
+ void testErrorReporting() throws Exception {
AtomicReference<Throwable> errorRef = new AtomicReference<>();
OneShotLatch latch = new OneShotLatch();
testHarness
@@ -105,11 +101,11 @@ public class StreamTaskTimerITCase extends TestLogger {
timeService.registerTimer(System.currentTimeMillis(), callback);
latch.await();
- assertThat(errorRef.get(), instanceOf(Exception.class));
+ assertThat(errorRef.get()).isInstanceOf(Exception.class);
}
@Test
- public void checkScheduledTimestamps() throws Exception {
+ void checkScheduledTimestamps() throws Exception {
ValidatingProcessingTimeCallback.numInSequence = 0;
long currentTimeMillis = System.currentTimeMillis();
ArrayList<ValidatingProcessingTimeCallback> timeCallbacks = new ArrayList<>();
@@ -133,7 +129,7 @@ public class StreamTaskTimerITCase extends TestLogger {
for (ValidatingProcessingTimeCallback timeCallback : timeCallbacks) {
timeCallback.assertExpectedValues();
}
- assertEquals(4, ValidatingProcessingTimeCallback.numInSequence);
+ assertThat(ValidatingProcessingTimeCallback.numInSequence).isEqualTo(4);
}
private static class ValidatingProcessingTimeCallback implements ProcessingTimeCallback {
@@ -153,8 +149,8 @@ public class StreamTaskTimerITCase extends TestLogger {
@Override
public void onProcessingTime(long timestamp) {
try {
- assertEquals(expectedTimestamp, timestamp);
- assertEquals(expectedInSequence, numInSequence);
+ assertThat(timestamp).isEqualTo(expectedTimestamp);
+ assertThat(numInSequence).isEqualTo(expectedInSequence);
numInSequence++;
finished.complete(null);
} catch (Throwable t) {
@@ -213,9 +209,8 @@ public class StreamTaskTimerITCase extends TestLogger {
Thread.sleep(10);
}
- assertEquals(
- "Trigger timer thread did not properly shut down",
- 0,
- StreamTask.TRIGGER_THREAD_GROUP.activeCount());
+ assertThat(StreamTask.TRIGGER_THREAD_GROUP.activeCount())
+ .as("Trigger timer thread did not properly shut down")
+ .isZero();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/TestProcessingTimeServiceTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/TestProcessingTimeServiceTest.java
index d9d0a5c8ec7..5564e61a179 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/TestProcessingTimeServiceTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/TestProcessingTimeServiceTest.java
@@ -27,15 +27,15 @@ import org.apache.flink.streaming.runtime.tasks.OneInputStreamTaskTestHarness;
import org.apache.flink.streaming.runtime.tasks.ProcessingTimeService;
import org.apache.flink.streaming.runtime.tasks.TestProcessingTimeService;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link TestProcessingTimeService}. */
-public class TestProcessingTimeServiceTest {
+class TestProcessingTimeServiceTest {
@Test
- public void testCustomTimeServiceProvider() throws Throwable {
+ void testCustomTimeServiceProvider() throws Throwable {
final TestProcessingTimeService tp = new TestProcessingTimeService();
final OneInputStreamTaskTestHarness<String, String> testHarness =
@@ -59,27 +59,27 @@ public class TestProcessingTimeServiceTest {
ProcessingTimeService processingTimeService =
((StreamMap<?, ?>) testHarness.getHeadOperator()).getProcessingTimeService();
- assertEquals(Long.MIN_VALUE, processingTimeService.getCurrentProcessingTime());
+ assertThat(processingTimeService.getCurrentProcessingTime()).isEqualTo(Long.MIN_VALUE);
tp.setCurrentTime(11);
- assertEquals(processingTimeService.getCurrentProcessingTime(), 11);
+ assertThat(processingTimeService.getCurrentProcessingTime()).isEqualTo(11);
tp.setCurrentTime(15);
tp.setCurrentTime(16);
- assertEquals(processingTimeService.getCurrentProcessingTime(), 16);
+ assertThat(processingTimeService.getCurrentProcessingTime()).isEqualTo(16);
// register 2 tasks
processingTimeService.registerTimer(30, timestamp -> {});
processingTimeService.registerTimer(40, timestamp -> {});
- assertEquals(2, tp.getNumActiveTimers());
+ assertThat(tp.getNumActiveTimers()).isEqualTo(2);
tp.setCurrentTime(35);
- assertEquals(1, tp.getNumActiveTimers());
+ assertThat(tp.getNumActiveTimers()).isOne();
tp.setCurrentTime(40);
- assertEquals(0, tp.getNumActiveTimers());
+ assertThat(tp.getNumActiveTimers()).isZero();
tp.shutdownService();
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/TimestampsAndWatermarksOperatorTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/TimestampsAndWatermarksOperatorTest.java
index b7f34619a30..3f718efe3f7 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/TimestampsAndWatermarksOperatorTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/TimestampsAndWatermarksOperatorTest.java
@@ -28,24 +28,22 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.streaming.runtime.watermarkstatus.WatermarkStatus;
import org.apache.flink.streaming.util.OneInputStreamOperatorTestHarness;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.io.Serializable;
import static org.apache.flink.streaming.util.StreamRecordMatchers.streamRecord;
import static org.apache.flink.streaming.util.WatermarkMatchers.legacyWatermark;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.HamcrestCondition.matching;
/** Tests for {@link TimestampsAndWatermarksOperator}. */
-public class TimestampsAndWatermarksOperatorTest {
+class TimestampsAndWatermarksOperatorTest {
private static final long AUTO_WATERMARK_INTERVAL = 50L;
@Test
- public void inputWatermarksAreNotForwarded() throws Exception {
+ void inputWatermarksAreNotForwarded() throws Exception {
OneInputStreamOperatorTestHarness<Long, Long> testHarness =
createTestHarness(
WatermarkStrategy.forGenerator((ctx) -> new PeriodicWatermarkGenerator())
@@ -54,11 +52,11 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processWatermark(createLegacyWatermark(42L));
testHarness.setProcessingTime(AUTO_WATERMARK_INTERVAL);
- assertThat(testHarness.getOutput(), empty());
+ assertThat(testHarness.getOutput()).isEmpty();
}
@Test
- public void inputStatusesAreNotForwarded() throws Exception {
+ void inputStatusesAreNotForwarded() throws Exception {
OneInputStreamOperatorTestHarness<Long, Long> testHarness =
createTestHarness(
WatermarkStrategy.forGenerator((ctx) -> new PeriodicWatermarkGenerator())
@@ -67,11 +65,11 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processWatermarkStatus(WatermarkStatus.IDLE);
testHarness.setProcessingTime(AUTO_WATERMARK_INTERVAL);
- assertThat(testHarness.getOutput(), empty());
+ assertThat(testHarness.getOutput()).isEmpty();
}
@Test
- public void longMaxInputWatermarkIsForwarded() throws Exception {
+ void longMaxInputWatermarkIsForwarded() throws Exception {
OneInputStreamOperatorTestHarness<Long, Long> testHarness =
createTestHarness(
WatermarkStrategy.forGenerator((ctx) -> new PeriodicWatermarkGenerator())
@@ -79,11 +77,12 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processWatermark(createLegacyWatermark(Long.MAX_VALUE));
- assertThat(pollNextLegacyWatermark(testHarness), is(legacyWatermark(Long.MAX_VALUE)));
+ assertThat(pollNextLegacyWatermark(testHarness))
+ .is(matching(legacyWatermark(Long.MAX_VALUE)));
}
@Test
- public void periodicWatermarksEmitOnPeriodicEmitStreamMode() throws Exception {
+ void periodicWatermarksEmitOnPeriodicEmitStreamMode() throws Exception {
OneInputStreamOperatorTestHarness<Long, Long> testHarness =
createTestHarness(
WatermarkStrategy.forGenerator((ctx) -> new PeriodicWatermarkGenerator())
@@ -92,18 +91,18 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processElement(new StreamRecord<>(2L, 1));
testHarness.setProcessingTime(AUTO_WATERMARK_INTERVAL);
- assertThat(pollNextStreamRecord(testHarness), streamRecord(2L, 2L));
- assertThat(pollNextLegacyWatermark(testHarness), is(legacyWatermark(1L)));
+ assertThat(pollNextStreamRecord(testHarness)).is(matching(streamRecord(2L, 2L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).is(matching(legacyWatermark(1L)));
testHarness.processElement(new StreamRecord<>(4L, 1));
testHarness.setProcessingTime(AUTO_WATERMARK_INTERVAL * 2);
- assertThat(pollNextStreamRecord(testHarness), streamRecord(4L, 4L));
- assertThat(pollNextLegacyWatermark(testHarness), is(legacyWatermark(3L)));
+ assertThat(pollNextStreamRecord(testHarness)).is(matching(streamRecord(4L, 4L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).is(matching(legacyWatermark(3L)));
}
@Test
- public void periodicWatermarksBatchMode() throws Exception {
+ void periodicWatermarksBatchMode() throws Exception {
OneInputStreamOperatorTestHarness<Long, Long> testHarness =
createBatchHarness(
WatermarkStrategy.forGenerator((ctx) -> new PeriodicWatermarkGenerator())
@@ -112,18 +111,18 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processElement(new StreamRecord<>(2L, 1));
testHarness.setProcessingTime(AUTO_WATERMARK_INTERVAL);
- assertThat(pollNextStreamRecord(testHarness), streamRecord(2L, 2L));
- assertNull(pollNextLegacyWatermark(testHarness));
+ assertThat(pollNextStreamRecord(testHarness)).is(matching(streamRecord(2L, 2L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).isNull();
testHarness.processElement(new StreamRecord<>(4L, 1));
testHarness.setProcessingTime(AUTO_WATERMARK_INTERVAL * 2);
- assertThat(pollNextStreamRecord(testHarness), streamRecord(4L, 4L));
- assertNull(pollNextLegacyWatermark(testHarness));
+ assertThat(pollNextStreamRecord(testHarness)).is(matching(streamRecord(4L, 4L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).isNull();
}
@Test
- public void periodicWatermarksOnlyEmitOnPeriodicEmitStreamMode() throws Exception {
+ void periodicWatermarksOnlyEmitOnPeriodicEmitStreamMode() throws Exception {
OneInputStreamOperatorTestHarness<Long, Long> testHarness =
createTestHarness(
WatermarkStrategy.forGenerator((ctx) -> new PeriodicWatermarkGenerator())
@@ -131,12 +130,12 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processElement(new StreamRecord<>(2L, 1));
- assertThat(pollNextStreamRecord(testHarness), streamRecord(2L, 2L));
- assertThat(testHarness.getOutput(), empty());
+ assertThat(pollNextStreamRecord(testHarness)).is(matching(streamRecord(2L, 2L)));
+ assertThat(testHarness.getOutput()).isEmpty();
}
@Test
- public void periodicWatermarksDoNotRegressStreamMode() throws Exception {
+ void periodicWatermarksDoNotRegressStreamMode() throws Exception {
OneInputStreamOperatorTestHarness<Long, Long> testHarness =
createTestHarness(
WatermarkStrategy.forGenerator((ctx) -> new PeriodicWatermarkGenerator())
@@ -145,18 +144,18 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processElement(new StreamRecord<>(4L, 1));
testHarness.setProcessingTime(AUTO_WATERMARK_INTERVAL);
- assertThat(pollNextStreamRecord(testHarness), streamRecord(4L, 4L));
- assertThat(pollNextLegacyWatermark(testHarness), is(legacyWatermark(3L)));
+ assertThat(pollNextStreamRecord(testHarness)).is(matching(streamRecord(4L, 4L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).is(matching(legacyWatermark(3L)));
testHarness.processElement(new StreamRecord<>(2L, 1));
testHarness.setProcessingTime(AUTO_WATERMARK_INTERVAL);
- assertThat(pollNextStreamRecord(testHarness), streamRecord(2L, 2L));
- assertThat(testHarness.getOutput(), empty());
+ assertThat(pollNextStreamRecord(testHarness)).is(matching(streamRecord(2L, 2L)));
+ assertThat(testHarness.getOutput()).isEmpty();
}
@Test
- public void punctuatedWatermarksEmitImmediatelyStreamMode() throws Exception {
+ void punctuatedWatermarksEmitImmediatelyStreamMode() throws Exception {
OneInputStreamOperatorTestHarness<Tuple2<Boolean, Long>, Tuple2<Boolean, Long>>
testHarness =
createTestHarness(
@@ -166,17 +165,19 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processElement(new StreamRecord<>(new Tuple2<>(true, 2L), 1));
- assertThat(pollNextStreamRecord(testHarness), streamRecord(new Tuple2<>(true, 2L), 2L));
- assertThat(pollNextLegacyWatermark(testHarness), is(legacyWatermark(2L)));
+ assertThat(pollNextStreamRecord(testHarness))
+ .is(matching(streamRecord(new Tuple2<>(true, 2L), 2L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).is(matching(legacyWatermark(2L)));
testHarness.processElement(new StreamRecord<>(new Tuple2<>(true, 4L), 1));
- assertThat(pollNextStreamRecord(testHarness), streamRecord(new Tuple2<>(true, 4L), 4L));
- assertThat(pollNextLegacyWatermark(testHarness), is(legacyWatermark(4L)));
+ assertThat(pollNextStreamRecord(testHarness))
+ .is(matching(streamRecord(new Tuple2<>(true, 4L), 4L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).is(matching(legacyWatermark(4L)));
}
@Test
- public void punctuatedWatermarksBatchMode() throws Exception {
+ void punctuatedWatermarksBatchMode() throws Exception {
OneInputStreamOperatorTestHarness<Tuple2<Boolean, Long>, Tuple2<Boolean, Long>>
testHarness =
createBatchHarness(
@@ -186,17 +187,19 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processElement(new StreamRecord<>(new Tuple2<>(true, 2L), 1));
- assertThat(pollNextStreamRecord(testHarness), streamRecord(new Tuple2<>(true, 2L), 2L));
- assertNull(pollNextLegacyWatermark(testHarness));
+ assertThat(pollNextStreamRecord(testHarness))
+ .is(matching(streamRecord(new Tuple2<>(true, 2L), 2L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).isNull();
testHarness.processElement(new StreamRecord<>(new Tuple2<>(true, 4L), 1));
- assertThat(pollNextStreamRecord(testHarness), streamRecord(new Tuple2<>(true, 4L), 4L));
- assertNull(pollNextLegacyWatermark(testHarness));
+ assertThat(pollNextStreamRecord(testHarness))
+ .is(matching(streamRecord(new Tuple2<>(true, 4L), 4L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).isNull();
}
@Test
- public void punctuatedWatermarksDoNotRegressStreamMode() throws Exception {
+ void punctuatedWatermarksDoNotRegressStreamMode() throws Exception {
OneInputStreamOperatorTestHarness<Tuple2<Boolean, Long>, Tuple2<Boolean, Long>>
testHarness =
createTestHarness(
@@ -206,18 +209,20 @@ public class TimestampsAndWatermarksOperatorTest {
testHarness.processElement(new StreamRecord<>(new Tuple2<>(true, 4L), 1));
- assertThat(pollNextStreamRecord(testHarness), streamRecord(new Tuple2<>(true, 4L), 4L));
- assertThat(pollNextLegacyWatermark(testHarness), is(legacyWatermark(4L)));
+ assertThat(pollNextStreamRecord(testHarness))
+ .is(matching(streamRecord(new Tuple2<>(true, 4L), 4L)));
+ assertThat(pollNextLegacyWatermark(testHarness)).is(matching(legacyWatermark(4L)));
testHarness.processElement(new StreamRecord<>(new Tuple2<>(true, 2L), 1));
- assertThat(pollNextStreamRecord(testHarness), streamRecord(new Tuple2<>(true, 2L), 2L));
- assertThat(testHarness.getOutput(), empty());
+ assertThat(pollNextStreamRecord(testHarness))
+ .is(matching(streamRecord(new Tuple2<>(true, 2L), 2L)));
+ assertThat(testHarness.getOutput()).isEmpty();
}
/** Negative timestamps also must be correctly forwarded. */
@Test
- public void testNegativeTimestamps() throws Exception {
+ void testNegativeTimestamps() throws Exception {
OneInputStreamOperatorTestHarness<Long, Long> testHarness =
createTestHarness(
@@ -231,7 +236,7 @@ public class TimestampsAndWatermarksOperatorTest {
}
for (long value : values) {
- assertThat(pollNextStreamRecord(testHarness).getTimestamp(), is(value));
+ assertThat(pollNextStreamRecord(testHarness).getTimestamp()).isEqualTo(value);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/WriteAheadSinkTestBase.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/WriteAheadSinkTestBase.java
index 4d652488b52..17b7b53e394 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/WriteAheadSinkTestBase.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/WriteAheadSinkTestBase.java
@@ -23,14 +23,11 @@ import org.apache.flink.runtime.checkpoint.OperatorSubtaskState;
import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.streaming.util.AbstractStreamOperatorTestHarness;
import org.apache.flink.streaming.util.OneInputStreamOperatorTestHarness;
-import org.apache.flink.util.TestLoggerExtension;
import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
/** Test base for {@link GenericWriteAheadSink}. */
-@ExtendWith(TestLoggerExtension.class)
-public abstract class WriteAheadSinkTestBase<IN, S extends GenericWriteAheadSink<IN>> {
+abstract class WriteAheadSinkTestBase<IN, S extends GenericWriteAheadSink<IN>> {
protected abstract S createSink() throws Exception;
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/SinkWriterOperatorTestBase.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/SinkWriterOperatorTestBase.java
index debe699c3a8..ecd7a3e54f3 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/SinkWriterOperatorTestBase.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/SinkWriterOperatorTestBase.java
@@ -119,7 +119,7 @@ abstract class SinkWriterOperatorTestBase {
}
@Test
- public void testTimeBasedBufferingSinkWriter() throws Exception {
+ void testTimeBasedBufferingSinkWriter() throws Exception {
final long initialTime = 0;
final OneInputStreamOperatorTestHarness<Integer, CommittableMessage<Integer>> testHarness =
@@ -421,7 +421,7 @@ abstract class SinkWriterOperatorTestBase {
assertThat(initContext.get().getTaskInfo().getIndexOfThisSubtask()).isEqualTo(subtaskId);
assertThat(initContext.get().getTaskInfo().getNumberOfParallelSubtasks())
.isEqualTo(parallelism);
- assertThat(initContext.get().getTaskInfo().getAttemptNumber()).isEqualTo(0);
+ assertThat(initContext.get().getTaskInfo().getAttemptNumber()).isZero();
assertThat(initContext.get().metricGroup()).isNotNull();
assertThat(initContext.get().getRestoredCheckpointId()).isNotPresent();
assertThat(initContext.get().isObjectReuseEnabled()).isTrue();
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/TestSink.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/TestSink.java
index 742e4438b5d..a062181cc88 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/TestSink.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/TestSink.java
@@ -47,7 +47,7 @@ import java.util.function.Supplier;
import java.util.stream.Collectors;
import static org.apache.flink.util.Preconditions.checkNotNull;
-import static org.junit.Assert.assertNotNull;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* A {@link Sink TestSink} for all the sink related tests. Use only for tests where {@link
@@ -312,7 +312,7 @@ public class TestSink<T> implements Sink<T, String, String, String> {
@Override
public List<String> commit(List<String> committables) {
if (committedData == null) {
- assertNotNull(queueSupplier);
+ assertThat(queueSupplier).isNotNull();
committedData = queueSupplier.get();
}
committedData.addAll(committables);
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/TestSinkV2.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/TestSinkV2.java
index 2dc5cd73890..81c23784fee 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/TestSinkV2.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/TestSinkV2.java
@@ -57,7 +57,7 @@ import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.function.Supplier;
import static org.apache.flink.util.Preconditions.checkNotNull;
-import static org.junit.Assert.assertNotNull;
+import static org.assertj.core.api.Assertions.assertThat;
/** A {@link Sink} for all the sink related tests. */
public class TestSinkV2<InputT> implements Sink<InputT> {
@@ -426,7 +426,7 @@ public class TestSinkV2<InputT> implements Sink<InputT> {
@Override
public void commit(Collection<CommitRequest<String>> committables) {
if (committedData == null) {
- assertNotNull(queueSupplier);
+ assertThat(queueSupplier).isNotNull();
committedData = queueSupplier.get();
}
committedData.addAll(committables);
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/committables/CommittableCollectorSerializerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/committables/CommittableCollectorSerializerTest.java
index cda4f40d7db..33e7fff363c 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/committables/CommittableCollectorSerializerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/committables/CommittableCollectorSerializerTest.java
@@ -126,7 +126,7 @@ class CommittableCollectorSerializerTest {
}
@Test
- public void testCommittablesForSameSubtaskIdV2SerDe() throws IOException {
+ void testCommittablesForSameSubtaskIdV2SerDe() throws IOException {
int subtaskId = 1;
int numberOfSubtasks = 3;
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/deprecated/TestSinkV2.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/deprecated/TestSinkV2.java
index 7e84326cae1..769ee3e6937 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/deprecated/TestSinkV2.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/sink/deprecated/TestSinkV2.java
@@ -49,7 +49,7 @@ import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.function.Supplier;
import static org.apache.flink.util.Preconditions.checkNotNull;
-import static org.junit.Assert.assertNotNull;
+import static org.assertj.core.api.Assertions.assertThat;
/**
* A {@link org.apache.flink.api.connector.sink2.Sink} for all the sink related tests.
@@ -373,7 +373,7 @@ public class TestSinkV2<InputT> implements Sink<InputT> {
@Override
public void commit(Collection<CommitRequest<String>> committables) {
if (committedData == null) {
- assertNotNull(queueSupplier);
+ assertThat(queueSupplier).isNotNull();
committedData = queueSupplier.get();
}
committedData.addAll(committables);
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/AllWindowTranslationTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/AllWindowTranslationTest.java
index 97ee6293ccc..98099356633 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/AllWindowTranslationTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/AllWindowTranslationTest.java
@@ -55,15 +55,12 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.streaming.util.KeyedOneInputStreamOperatorTestHarness;
import org.apache.flink.util.Collector;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.Test;
import java.util.concurrent.TimeUnit;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
/**
* These tests verify that the api calls on {@link AllWindowedStream} instantiate the correct window
@@ -73,9 +70,7 @@ import static org.junit.Assert.fail;
* some output.
*/
@SuppressWarnings("serial")
-public class AllWindowTranslationTest {
-
- @Rule public ExpectedException expectedException = ExpectedException.none();
+class AllWindowTranslationTest {
// ------------------------------------------------------------------------
// rich function tests
@@ -85,48 +80,53 @@ public class AllWindowTranslationTest {
* .reduce() does not support RichReduceFunction, since the reduce function is used internally
* in a {@code ReducingState}.
*/
- @Test(expected = UnsupportedOperationException.class)
- public void testReduceWithRichReducerFails() throws Exception {
+ @Test
+ void testReduceWithRichReducerFails() {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
env.fromData(Tuple2.of("hello", 1), Tuple2.of("hello", 2));
- source.windowAll(
- SlidingEventTimeWindows.of(
- Time.of(1, TimeUnit.SECONDS), Time.of(100, TimeUnit.MILLISECONDS)))
- .reduce(
- new RichReduceFunction<Tuple2<String, Integer>>() {
- private static final long serialVersionUID = -6448847205314995812L;
-
- @Override
- public Tuple2<String, Integer> reduce(
- Tuple2<String, Integer> value1, Tuple2<String, Integer> value2)
- throws Exception {
- return null;
- }
- });
-
- fail("exception was not thrown");
+ assertThatThrownBy(
+ () ->
+ source.windowAll(
+ SlidingEventTimeWindows.of(
+ Time.of(1, TimeUnit.SECONDS),
+ Time.of(100, TimeUnit.MILLISECONDS)))
+ .reduce(
+ new RichReduceFunction<Tuple2<String, Integer>>() {
+ private static final long serialVersionUID =
+ -6448847205314995812L;
+
+ @Override
+ public Tuple2<String, Integer> reduce(
+ Tuple2<String, Integer> value1,
+ Tuple2<String, Integer> value2) {
+ return null;
+ }
+ }))
+ .isInstanceOf(UnsupportedOperationException.class);
}
/**
* .aggregate() does not support RichAggregateFunction, since the AggregateFunction is used
* internally in an {@code AggregatingState}.
*/
- @Test(expected = UnsupportedOperationException.class)
- public void testAggregateWithRichFunctionFails() throws Exception {
+ @Test
+ void testAggregateWithRichFunctionFails() {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
env.fromData(Tuple2.of("hello", 1), Tuple2.of("hello", 2));
- source.windowAll(
- SlidingEventTimeWindows.of(
- Time.of(1, TimeUnit.SECONDS), Time.of(100, TimeUnit.MILLISECONDS)))
- .aggregate(new DummyRichAggregationFunction<Tuple2<String, Integer>>());
-
- fail("exception was not thrown");
+ assertThatThrownBy(
+ () ->
+ source.windowAll(
+ SlidingEventTimeWindows.of(
+ Time.of(1, TimeUnit.SECONDS),
+ Time.of(100, TimeUnit.MILLISECONDS)))
+ .aggregate(new DummyRichAggregationFunction<>()))
+ .isInstanceOf(UnsupportedOperationException.class);
}
// ------------------------------------------------------------------------
@@ -134,58 +134,66 @@ public class AllWindowTranslationTest {
// ------------------------------------------------------------------------
@Test
- public void testMergingAssignerWithNonMergingTriggerFails() throws Exception {
- // verify that we check for trigger compatibility
- expectedException.expect(UnsupportedOperationException.class);
- expectedException.expectMessage(
- "A merging window assigner cannot be used with a trigger"
- + " that does not support merging");
+ void testMergingAssignerWithNonMergingTriggerFails() {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
- env.fromData("Hello", "Ciao")
- .windowAll(EventTimeSessionWindows.withGap(Time.seconds(5)))
- .trigger(
- new Trigger<String, TimeWindow>() {
- private static final long serialVersionUID = 6558046711583024443L;
-
- @Override
- public TriggerResult onElement(
- String element,
- long timestamp,
- TimeWindow window,
- TriggerContext ctx)
- throws Exception {
- return null;
- }
-
- @Override
- public TriggerResult onProcessingTime(
- long time, TimeWindow window, TriggerContext ctx)
- throws Exception {
- return null;
- }
-
- @Override
- public TriggerResult onEventTime(
- long time, TimeWindow window, TriggerContext ctx)
- throws Exception {
- return null;
- }
-
- @Override
- public boolean canMerge() {
- return false;
- }
-
- @Override
- public void clear(TimeWindow window, TriggerContext ctx)
- throws Exception {}
- });
+ // verify that we check for trigger compatibility
+ assertThatThrownBy(
+ () ->
+ env.fromData("Hello", "Ciao")
+ .windowAll(EventTimeSessionWindows.withGap(Time.seconds(5)))
+ .trigger(
+ new Trigger<String, TimeWindow>() {
+ private static final long serialVersionUID =
+ 6558046711583024443L;
+
+ @Override
+ public TriggerResult onElement(
+ String element,
+ long timestamp,
+ TimeWindow window,
+ TriggerContext ctx)
+ throws Exception {
+ return null;
+ }
+
+ @Override
+ public TriggerResult onProcessingTime(
+ long time,
+ TimeWindow window,
+ TriggerContext ctx)
+ throws Exception {
+ return null;
+ }
+
+ @Override
+ public TriggerResult onEventTime(
+ long time,
+ TimeWindow window,
+ TriggerContext ctx)
+ throws Exception {
+ return null;
+ }
+
+ @Override
+ public boolean canMerge() {
+ return false;
+ }
+
+ @Override
+ public void clear(
+ TimeWindow window, TriggerContext ctx)
+ throws Exception {}
+ }))
+ .isInstanceOf(UnsupportedOperationException.class)
+ .hasMessageContaining(
+ "A merging window assigner cannot be used with a trigger"
+ + " that does not support merging");
}
@Test
@SuppressWarnings("rawtypes")
- public void testMergingWindowsWithEvictor() throws Exception {
+ void testMergingWindowsWithEvictor() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -201,12 +209,12 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple3<String, String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof EventTimeSessionWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(EventTimeSessionWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -221,7 +229,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testReduceEventTime() throws Exception {
+ void testReduceEventTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -239,12 +247,12 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof SlidingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ReducingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(SlidingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ReducingStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -255,7 +263,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testReduceProcessingTime() throws Exception {
+ void testReduceProcessingTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -273,12 +281,13 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof ProcessingTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof SlidingProcessingTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ReducingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(ProcessingTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner())
+ .isInstanceOf(SlidingProcessingTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ReducingStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -289,7 +298,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testReduceWithWindowFunctionEventTime() throws Exception {
+ void testReduceWithWindowFunctionEventTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -324,12 +333,12 @@ public class AllWindowTranslationTest {
window.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple3<String, String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ReducingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ReducingStateDescriptor.class);
processElementAndEnsureOutput(
operator,
@@ -340,7 +349,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testReduceWithWindowFunctionProcessingTime() throws Exception {
+ void testReduceWithWindowFunctionProcessingTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -373,12 +382,13 @@ public class AllWindowTranslationTest {
window.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple3<String, String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof ProcessingTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingProcessingTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ReducingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(ProcessingTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner())
+ .isInstanceOf(TumblingProcessingTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ReducingStateDescriptor.class);
processElementAndEnsureOutput(
operator,
@@ -389,7 +399,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testReduceWithProcessWindowFunctionEventTime() throws Exception {
+ void testReduceWithProcessWindowFunctionEventTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -424,12 +434,12 @@ public class AllWindowTranslationTest {
window.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple3<String, String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ReducingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ReducingStateDescriptor.class);
processElementAndEnsureOutput(
operator,
@@ -440,7 +450,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testReduceWithProcessWindowFunctionProcessingTime() throws Exception {
+ void testReduceWithProcessWindowFunctionProcessingTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -473,12 +483,13 @@ public class AllWindowTranslationTest {
window.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple3<String, String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof ProcessingTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingProcessingTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ReducingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(ProcessingTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner())
+ .isInstanceOf(TumblingProcessingTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ReducingStateDescriptor.class);
processElementAndEnsureOutput(
operator,
@@ -489,7 +500,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testReduceWithEvictorAndProcessFunction() throws Exception {
+ void testReduceWithEvictorAndProcessFunction() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -526,13 +537,13 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof EvictingWindowOperator);
+ assertThat(operator).isInstanceOf(EvictingWindowOperator.class);
EvictingWindowOperator<String, Tuple2<String, Integer>, ?, ?> winOperator =
(EvictingWindowOperator<String, Tuple2<String, Integer>, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getEvictor() instanceof CountEvictor);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof SlidingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getEvictor()).isInstanceOf(CountEvictor.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(SlidingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -544,7 +555,7 @@ public class AllWindowTranslationTest {
/** Test for the deprecated .apply(Reducer, WindowFunction). */
@Test
@SuppressWarnings("rawtypes")
- public void testApplyWithPreReducerEventTime() throws Exception {
+ void testApplyWithPreReducerEventTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -579,12 +590,12 @@ public class AllWindowTranslationTest {
window.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple3<String, String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ReducingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ReducingStateDescriptor.class);
processElementAndEnsureOutput(
operator,
@@ -598,7 +609,7 @@ public class AllWindowTranslationTest {
// ------------------------------------------------------------------------
@Test
- public void testAggregateEventTime() throws Exception {
+ void testAggregateEventTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -618,13 +629,13 @@ public class AllWindowTranslationTest {
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof SlidingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof AggregatingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(SlidingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(AggregatingStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -634,7 +645,7 @@ public class AllWindowTranslationTest {
}
@Test
- public void testAggregateProcessingTime() throws Exception {
+ void testAggregateProcessingTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -654,13 +665,14 @@ public class AllWindowTranslationTest {
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof ProcessingTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof SlidingProcessingTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof AggregatingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(ProcessingTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner())
+ .isInstanceOf(SlidingProcessingTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(AggregatingStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -670,7 +682,7 @@ public class AllWindowTranslationTest {
}
@Test
- public void testAggregateWithWindowFunctionEventTime() throws Exception {
+ void testAggregateWithWindowFunctionEventTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -687,13 +699,13 @@ public class AllWindowTranslationTest {
OneInputStreamOperator<Tuple2<String, Integer>, Tuple3<String, String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof AggregatingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(AggregatingStateDescriptor.class);
processElementAndEnsureOutput(
operator,
@@ -703,7 +715,7 @@ public class AllWindowTranslationTest {
}
@Test
- public void testAggregateWithWindowFunctionProcessingTime() throws Exception {
+ void testAggregateWithWindowFunctionProcessingTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -720,13 +732,14 @@ public class AllWindowTranslationTest {
OneInputStreamOperator<Tuple2<String, Integer>, Tuple3<String, String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof ProcessingTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingProcessingTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof AggregatingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(ProcessingTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner())
+ .isInstanceOf(TumblingProcessingTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(AggregatingStateDescriptor.class);
processElementAndEnsureOutput(
operator,
@@ -736,7 +749,7 @@ public class AllWindowTranslationTest {
}
@Test
- public void testAggregateWithEvictor() throws Exception {
+ void testAggregateWithEvictor() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -757,13 +770,13 @@ public class AllWindowTranslationTest {
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof SlidingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(SlidingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -773,7 +786,7 @@ public class AllWindowTranslationTest {
}
@Test
- public void testAggregateWithEvictorAndProcessFunction() throws Exception {
+ void testAggregateWithEvictorAndProcessFunction() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -810,13 +823,13 @@ public class AllWindowTranslationTest {
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof SlidingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(SlidingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -831,7 +844,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testProcessEventTime() throws Exception {
+ void testProcessEventTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -863,12 +876,12 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -879,7 +892,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testProcessProcessingTime() throws Exception {
+ void testProcessProcessingTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -911,12 +924,13 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof ProcessingTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingProcessingTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(ProcessingTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner())
+ .isInstanceOf(TumblingProcessingTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -927,7 +941,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testProcessWithEvictor() throws Exception {
+ void testProcessWithEvictor() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -961,13 +975,13 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof EvictingWindowOperator);
+ assertThat(operator).isInstanceOf(EvictingWindowOperator.class);
EvictingWindowOperator<String, Tuple2<String, Integer>, ?, ?> winOperator =
(EvictingWindowOperator<String, Tuple2<String, Integer>, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof CountTrigger);
- Assert.assertTrue(winOperator.getEvictor() instanceof TimeEvictor);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(CountTrigger.class);
+ assertThat(winOperator.getEvictor()).isInstanceOf(TimeEvictor.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -978,7 +992,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testProcessWithCustomTrigger() throws Exception {
+ void testProcessWithCustomTrigger() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -1011,12 +1025,12 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof CountTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(CountTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -1031,7 +1045,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testApplyEventTime() throws Exception {
+ void testApplyEventTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -1063,12 +1077,12 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -1079,7 +1093,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testApplyProcessingTimeTime() throws Exception {
+ void testApplyProcessingTimeTime() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -1111,12 +1125,13 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof ProcessingTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingProcessingTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(ProcessingTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner())
+ .isInstanceOf(TumblingProcessingTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -1127,7 +1142,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testReduceWithCustomTrigger() throws Exception {
+ void testReduceWithCustomTrigger() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -1148,12 +1163,12 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof CountTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof SlidingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ReducingStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(CountTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(SlidingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ReducingStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -1164,7 +1179,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testApplyWithCustomTrigger() throws Exception {
+ void testApplyWithCustomTrigger() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -1197,12 +1212,12 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof WindowOperator);
+ assertThat(operator).isInstanceOf(WindowOperator.class);
WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?> winOperator =
(WindowOperator<String, Tuple2<String, Integer>, ?, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof CountTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(CountTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -1213,7 +1228,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testReduceWithEvictor() throws Exception {
+ void testReduceWithEvictor() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -1234,13 +1249,13 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof EvictingWindowOperator);
+ assertThat(operator).isInstanceOf(EvictingWindowOperator.class);
EvictingWindowOperator<String, Tuple2<String, Integer>, ?, ?> winOperator =
(EvictingWindowOperator<String, Tuple2<String, Integer>, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof EventTimeTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof SlidingEventTimeWindows);
- Assert.assertTrue(winOperator.getEvictor() instanceof CountEvictor);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(EventTimeTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(SlidingEventTimeWindows.class);
+ assertThat(winOperator.getEvictor()).isInstanceOf(CountEvictor.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -1251,7 +1266,7 @@ public class AllWindowTranslationTest {
@Test
@SuppressWarnings("rawtypes")
- public void testApplyWithEvictor() throws Exception {
+ void testApplyWithEvictor() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<Tuple2<String, Integer>> source =
@@ -1285,13 +1300,13 @@ public class AllWindowTranslationTest {
window1.getTransformation();
OneInputStreamOperator<Tuple2<String, Integer>, Tuple2<String, Integer>> operator =
transform.getOperator();
- Assert.assertTrue(operator instanceof EvictingWindowOperator);
+ assertThat(operator).isInstanceOf(EvictingWindowOperator.class);
EvictingWindowOperator<String, Tuple2<String, Integer>, ?, ?> winOperator =
(EvictingWindowOperator<String, Tuple2<String, Integer>, ?, ?>) operator;
- Assert.assertTrue(winOperator.getTrigger() instanceof CountTrigger);
- Assert.assertTrue(winOperator.getWindowAssigner() instanceof TumblingEventTimeWindows);
- Assert.assertTrue(winOperator.getEvictor() instanceof TimeEvictor);
- Assert.assertTrue(winOperator.getStateDescriptor() instanceof ListStateDescriptor);
+ assertThat(winOperator.getTrigger()).isInstanceOf(CountTrigger.class);
+ assertThat(winOperator.getWindowAssigner()).isInstanceOf(TumblingEventTimeWindows.class);
+ assertThat(winOperator.getEvictor()).isInstanceOf(TimeEvictor.class);
+ assertThat(winOperator.getStateDescriptor()).isInstanceOf(ListStateDescriptor.class);
processElementAndEnsureOutput(
winOperator,
@@ -1326,7 +1341,7 @@ public class AllWindowTranslationTest {
testHarness.processWatermark(Long.MAX_VALUE);
// we at least get the two watermarks and should also see an output element
- assertTrue(testHarness.getOutput().size() >= 3);
+ assertThat(testHarness.getOutput()).hasSizeGreaterThanOrEqualTo(3);
testHarness.close();
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ContinuousEventTimeTriggerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ContinuousEventTimeTriggerTest.java
index e6c7098566a..16dd67471c1 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ContinuousEventTimeTriggerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ContinuousEventTimeTriggerTest.java
@@ -27,39 +27,37 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.shaded.guava31.com.google.common.collect.Lists;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.Collection;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link ContinuousEventTimeTrigger}. */
-public class ContinuousEventTimeTriggerTest {
+class ContinuousEventTimeTriggerTest {
/**
* Verify that the trigger doesn't fail with an NPE if we insert a timer firing when there is no
* trigger state.
*/
@Test
- public void testTriggerHandlesAllOnTimerCalls() throws Exception {
+ void testTriggerHandlesAllOnTimerCalls() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ContinuousEventTimeTrigger.<TimeWindow>of(Time.milliseconds(5)),
new TimeWindow.Serializer());
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
// this will make the elements we now process fall into late windows, i.e. no trigger state
// will be created
testHarness.advanceWatermark(10);
// late fires immediately
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
// simulate a GC timer firing
testHarness.invokeOnEventTime(20, new TimeWindow(0, 2));
@@ -67,34 +65,29 @@ public class ContinuousEventTimeTriggerTest {
/** Verify that state <TimeWindow>of separate windows does not leak into other windows. */
@Test
- public void testWindowSeparationAndFiring() throws Exception {
+ void testWindowSeparationAndFiring() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ContinuousEventTimeTrigger.<TimeWindow>of(Time.hours(1)),
new TimeWindow.Serializer());
// inject several elements
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
-
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(4, testHarness.numEventTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
+
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(4);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isEqualTo(2);
Collection<Tuple2<TimeWindow, TriggerResult>> triggerResults =
testHarness.advanceWatermark(2);
@@ -102,37 +95,37 @@ public class ContinuousEventTimeTriggerTest {
for (Tuple2<TimeWindow, TriggerResult> r : triggerResults) {
if (r.f0.equals(new TimeWindow(0, 2))) {
sawFiring = true;
- assertTrue(r.f1.equals(TriggerResult.FIRE));
+ assertThat(r.f1).isEqualTo(TriggerResult.FIRE);
}
}
- assertTrue(sawFiring);
+ assertThat(sawFiring).isTrue();
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(3, testHarness.numEventTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(3);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isEqualTo(2);
triggerResults = testHarness.advanceWatermark(4);
sawFiring = false;
for (Tuple2<TimeWindow, TriggerResult> r : triggerResults) {
if (r.f0.equals(new TimeWindow(2, 4))) {
sawFiring = true;
- assertTrue(r.f1.equals(TriggerResult.FIRE));
+ assertThat(r.f1).isEqualTo(TriggerResult.FIRE);
}
}
- assertTrue(sawFiring);
+ assertThat(sawFiring).isTrue();
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(2);
}
/**
* Verify that late elements trigger immediately and also that we don't set a timer for those.
*/
@Test
- public void testLateElementTriggersImmediately() throws Exception {
+ void testLateElementTriggersImmediately() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ContinuousEventTimeTrigger.<TimeWindow>of(Time.hours(1)),
@@ -140,83 +133,79 @@ public class ContinuousEventTimeTriggerTest {
testHarness.advanceWatermark(2);
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
}
/** Verify that clear() does not leak across windows. */
@Test
- public void testClear() throws Exception {
+ void testClear() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ContinuousEventTimeTrigger.<TimeWindow>of(Time.hours(1)),
new TimeWindow.Serializer());
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(4, testHarness.numEventTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(4);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isEqualTo(2);
testHarness.clearTriggerState(new TimeWindow(2, 4));
- assertEquals(1, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(3, testHarness.numEventTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isOne();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(3);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isOne();
testHarness.clearTriggerState(new TimeWindow(0, 2));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers()); // doesn't clean up timers
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(2); // doesn't clean up timers
}
@Test
- public void testMergingWindows() throws Exception {
+ void testMergingWindows() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ContinuousEventTimeTrigger.<TimeWindow>of(Time.hours(1)),
new TimeWindow.Serializer());
- assertTrue(ContinuousEventTimeTrigger.<TimeWindow>of(Time.hours(1)).canMerge());
+ assertThat(ContinuousEventTimeTrigger.<TimeWindow>of(Time.hours(1)).canMerge()).isTrue();
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(4, testHarness.numEventTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(4);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isEqualTo(2);
testHarness.mergeWindows(
new TimeWindow(0, 4),
Lists.newArrayList(new TimeWindow(0, 2), new TimeWindow(2, 4)));
- assertEquals(1, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(5, testHarness.numEventTimeTimers()); // on merging, timers are not cleaned up
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(2, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(0, 4)));
+ assertThat(testHarness.numStateEntries()).isOne();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers())
+ .isEqualTo(5); // on merging, timers are not cleaned up
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 4))).isOne();
Collection<Tuple2<TimeWindow, TriggerResult>> triggerResults =
testHarness.advanceWatermark(4);
@@ -224,14 +213,14 @@ public class ContinuousEventTimeTriggerTest {
for (Tuple2<TimeWindow, TriggerResult> r : triggerResults) {
if (r.f0.equals(new TimeWindow(0, 4))) {
sawFiring = true;
- assertTrue(r.f1.equals(TriggerResult.FIRE));
+ assertThat(r.f1).isEqualTo(TriggerResult.FIRE);
}
}
- assertTrue(sawFiring);
+ assertThat(sawFiring).isTrue();
- assertEquals(1, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isOne();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isOne();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ContinuousProcessingTimeTriggerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ContinuousProcessingTimeTriggerTest.java
index 395214d5883..883b7300a8a 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ContinuousProcessingTimeTriggerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ContinuousProcessingTimeTriggerTest.java
@@ -35,16 +35,16 @@ import org.apache.flink.streaming.util.KeyedOneInputStreamOperatorTestHarness;
import org.apache.flink.streaming.util.TestHarnessUtil;
import org.apache.flink.util.Collector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.ArrayDeque;
import java.util.Objects;
import java.util.stream.StreamSupport;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link ContinuousProcessingTimeTrigger}. */
-public class ContinuousProcessingTimeTriggerTest {
+class ContinuousProcessingTimeTriggerTest {
private static final long NO_TIMESTAMP = Watermark.UNINITIALIZED.getTimestamp();
@@ -96,11 +96,11 @@ public class ContinuousProcessingTimeTriggerTest {
/** Verify ContinuousProcessingTimeTrigger fire. */
@Test
- public void testWindowFiring() throws Exception {
+ void testWindowFiring() throws Exception {
ContinuousProcessingTimeTrigger<TimeWindow> trigger =
ContinuousProcessingTimeTrigger.of(Time.milliseconds(5));
- assertTrue(trigger.canMerge());
+ assertThat(trigger.canMerge()).isTrue();
ListStateDescriptor<Integer> stateDesc =
new ListStateDescriptor<>(
@@ -173,11 +173,11 @@ public class ContinuousProcessingTimeTriggerTest {
}
@Test
- public void testMergingWindows() throws Exception {
+ void testMergingWindows() throws Exception {
ContinuousProcessingTimeTrigger<TimeWindow> trigger =
ContinuousProcessingTimeTrigger.of(Time.milliseconds(5));
- assertTrue(trigger.canMerge());
+ assertThat(trigger.canMerge()).isTrue();
ListStateDescriptor<Integer> stateDesc =
new ListStateDescriptor<>(
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/CountTriggerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/CountTriggerTest.java
index 4af59a44609..bd583ad5880 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/CountTriggerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/CountTriggerTest.java
@@ -25,181 +25,160 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.shaded.guava31.com.google.common.collect.Lists;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link CountTrigger}. */
-public class CountTriggerTest {
+class CountTriggerTest {
/** Verify that state of separate windows does not leak into other windows. */
@Test
- public void testWindowSeparationAndFiring() throws Exception {
+ void testWindowSeparationAndFiring() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
- new TriggerTestHarness<>(
- CountTrigger.<TimeWindow>of(3), new TimeWindow.Serializer());
+ new TriggerTestHarness<>(CountTrigger.of(3), new TimeWindow.Serializer());
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
// shouldn't have any timers
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
-
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(2, 4)));
-
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(2, 4))).isOne();
+
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
// right now, CountTrigger will clear it's state in onElement when firing
// ideally, this should be moved to onFire()
- assertEquals(1, testHarness.numStateEntries());
- assertEquals(0, testHarness.numStateEntries(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numStateEntries(new TimeWindow(2, 4))).isOne();
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.FIRE);
// now all state should be gone
- assertEquals(0, testHarness.numStateEntries());
+ assertThat(testHarness.numStateEntries()).isZero();
}
/** Verify that clear() does not leak across windows. */
@Test
- public void testClear() throws Exception {
+ void testClear() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
- new TriggerTestHarness<>(
- CountTrigger.<TimeWindow>of(3), new TimeWindow.Serializer());
+ new TriggerTestHarness<>(CountTrigger.of(3), new TimeWindow.Serializer());
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
// shouldn't have any timers
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(2, 4))).isOne();
testHarness.clearTriggerState(new TimeWindow(2, 4));
- assertEquals(1, testHarness.numStateEntries());
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numStateEntries(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(2, 4))).isZero();
testHarness.clearTriggerState(new TimeWindow(0, 2));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numStateEntries(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numStateEntries(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numStateEntries(new TimeWindow(2, 4))).isZero();
}
@Test
- public void testMergingWindows() throws Exception {
+ void testMergingWindows() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
- new TriggerTestHarness<>(
- CountTrigger.<TimeWindow>of(3), new TimeWindow.Serializer());
-
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(4, 6)));
+ new TriggerTestHarness<>(CountTrigger.of(3), new TimeWindow.Serializer());
+
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(4, 6)))
+ .isEqualTo(TriggerResult.CONTINUE);
// shouldn't have any timers
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
- assertEquals(3, testHarness.numStateEntries());
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(2, 4)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(4, 6)));
+ assertThat(testHarness.numStateEntries()).isEqualTo(3);
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(2, 4))).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(4, 6))).isOne();
testHarness.mergeWindows(
new TimeWindow(0, 4),
Lists.newArrayList(new TimeWindow(0, 2), new TimeWindow(2, 4)));
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(0, testHarness.numStateEntries(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numStateEntries(new TimeWindow(2, 4)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(0, 4)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(4, 6)));
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numStateEntries(new TimeWindow(2, 4))).isZero();
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 4))).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(4, 6))).isOne();
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 4)))
+ .isEqualTo(TriggerResult.FIRE);
- assertEquals(1, testHarness.numStateEntries());
- assertEquals(0, testHarness.numStateEntries(new TimeWindow(0, 4)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(4, 6)));
+ assertThat(testHarness.numStateEntries()).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 4))).isZero();
+ assertThat(testHarness.numStateEntries(new TimeWindow(4, 6))).isOne();
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(4, 6)));
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(4, 6)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(4, 6)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(4, 6)))
+ .isEqualTo(TriggerResult.FIRE);
- assertEquals(0, testHarness.numStateEntries());
+ assertThat(testHarness.numStateEntries()).isZero();
}
@Test
- public void testMergeSubsumingWindow() throws Exception {
+ void testMergeSubsumingWindow() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
- new TriggerTestHarness<>(
- CountTrigger.<TimeWindow>of(3), new TimeWindow.Serializer());
+ new TriggerTestHarness<>(CountTrigger.of(3), new TimeWindow.Serializer());
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(4, 6)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(4, 6)))
+ .isEqualTo(TriggerResult.CONTINUE);
// shouldn't have any timers
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(2, 4)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(4, 6)));
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numStateEntries(new TimeWindow(2, 4))).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(4, 6))).isOne();
testHarness.mergeWindows(
new TimeWindow(0, 8),
Lists.newArrayList(new TimeWindow(2, 4), new TimeWindow(4, 6)));
- assertEquals(1, testHarness.numStateEntries());
- assertEquals(0, testHarness.numStateEntries(new TimeWindow(2, 4)));
- assertEquals(0, testHarness.numStateEntries(new TimeWindow(4, 6)));
- assertEquals(1, testHarness.numStateEntries(new TimeWindow(0, 8)));
+ assertThat(testHarness.numStateEntries()).isOne();
+ assertThat(testHarness.numStateEntries(new TimeWindow(2, 4))).isZero();
+ assertThat(testHarness.numStateEntries(new TimeWindow(4, 6))).isZero();
+ assertThat(testHarness.numStateEntries(new TimeWindow(0, 8))).isOne();
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 8)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 8)))
+ .isEqualTo(TriggerResult.FIRE);
- assertEquals(0, testHarness.numStateEntries());
+ assertThat(testHarness.numStateEntries()).isZero();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/DynamicEventTimeSessionWindowsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/DynamicEventTimeSessionWindowsTest.java
index a5a312e9ef7..0baa5f14cea 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/DynamicEventTimeSessionWindowsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/DynamicEventTimeSessionWindowsTest.java
@@ -25,24 +25,17 @@ import org.apache.flink.streaming.api.windowing.assigners.SessionWindowTimeGapEx
import org.apache.flink.streaming.api.windowing.assigners.WindowAssigner;
import org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
-import org.apache.flink.util.TestLogger;
-import org.apache.flink.shaded.guava31.com.google.common.collect.Lists;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import org.mockito.Matchers;
+import java.util.Arrays;
import java.util.Collection;
+import java.util.Collections;
-import static org.apache.flink.streaming.util.StreamRecordMatchers.timeWindow;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.Matchers.contains;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyCollection;
import static org.mockito.Mockito.eq;
@@ -54,10 +47,10 @@ import static org.mockito.Mockito.when;
import static org.mockito.hamcrest.MockitoHamcrest.argThat;
/** Tests for {@link DynamicEventTimeSessionWindows}. */
-public class DynamicEventTimeSessionWindowsTest extends TestLogger {
+class DynamicEventTimeSessionWindowsTest {
@Test
- public void testWindowAssignment() {
+ void testWindowAssignment() {
WindowAssigner.WindowAssignerContext mockContext =
mock(WindowAssigner.WindowAssignerContext.class);
@@ -69,18 +62,16 @@ public class DynamicEventTimeSessionWindowsTest extends TestLogger {
DynamicEventTimeSessionWindows<String> assigner =
DynamicEventTimeSessionWindows.withDynamicGap(extractor);
- assertThat(
- assigner.assignWindows("gap5000", 0L, mockContext), contains(timeWindow(0, 5000)));
- assertThat(
- assigner.assignWindows("gap4000", 4999L, mockContext),
- contains(timeWindow(4999, 8999)));
- assertThat(
- assigner.assignWindows("gap9000", 5000L, mockContext),
- contains(timeWindow(5000, 14000)));
+ assertThat(assigner.assignWindows("gap5000", 0L, mockContext))
+ .containsExactly(new TimeWindow(0, 5000));
+ assertThat(assigner.assignWindows("gap4000", 4999L, mockContext))
+ .containsExactly(new TimeWindow(4999, 8999));
+ assertThat(assigner.assignWindows("gap9000", 5000L, mockContext))
+ .containsExactly(new TimeWindow(5000, 14000));
}
@Test
- public void testMergeSinglePointWindow() {
+ void testMergeSinglePointWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
@@ -89,13 +80,13 @@ public class DynamicEventTimeSessionWindowsTest extends TestLogger {
DynamicEventTimeSessionWindows assigner =
DynamicEventTimeSessionWindows.withDynamicGap(extractor);
- assigner.mergeWindows(Lists.newArrayList(new TimeWindow(0, 0)), callback);
+ assigner.mergeWindows(Collections.singletonList(new TimeWindow(0, 0)), callback);
verify(callback, never()).merge(anyCollection(), Matchers.anyObject());
}
@Test
- public void testMergeSingleWindow() {
+ void testMergeSingleWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
@@ -104,13 +95,13 @@ public class DynamicEventTimeSessionWindowsTest extends TestLogger {
DynamicEventTimeSessionWindows assigner =
DynamicEventTimeSessionWindows.withDynamicGap(extractor);
- assigner.mergeWindows(Lists.newArrayList(new TimeWindow(0, 1)), callback);
+ assigner.mergeWindows(Collections.singletonList(new TimeWindow(0, 1)), callback);
verify(callback, never()).merge(anyCollection(), Matchers.anyObject());
}
@Test
- public void testMergeConsecutiveWindows() {
+ void testMergeConsecutiveWindows() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
@@ -120,7 +111,7 @@ public class DynamicEventTimeSessionWindowsTest extends TestLogger {
DynamicEventTimeSessionWindows.withDynamicGap(extractor);
assigner.mergeWindows(
- Lists.newArrayList(
+ Arrays.asList(
new TimeWindow(0, 1),
new TimeWindow(1, 2),
new TimeWindow(2, 3),
@@ -150,7 +141,7 @@ public class DynamicEventTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testMergeCoveringWindow() {
+ void testMergeCoveringWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
@@ -160,7 +151,7 @@ public class DynamicEventTimeSessionWindowsTest extends TestLogger {
DynamicEventTimeSessionWindows.withDynamicGap(extractor);
assigner.mergeWindows(
- Lists.newArrayList(
+ Arrays.asList(
new TimeWindow(1, 1),
new TimeWindow(0, 2),
new TimeWindow(4, 7),
@@ -187,47 +178,34 @@ public class DynamicEventTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testInvalidParameters() {
+ void testInvalidParameters() {
WindowAssigner.WindowAssignerContext mockContext =
mock(WindowAssigner.WindowAssignerContext.class);
- try {
- SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
- when(extractor.extract(any())).thenReturn(-1L);
-
- DynamicEventTimeSessionWindows assigner =
- DynamicEventTimeSessionWindows.withDynamicGap(extractor);
- assigner.assignWindows(Lists.newArrayList(new Object()), 1, mockContext);
-
- fail("should fail");
- } catch (IllegalArgumentException e) {
- assertThat(e.toString(), containsString("0 < gap"));
- }
-
- try {
- SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
- when(extractor.extract(any())).thenReturn(0L);
-
- DynamicEventTimeSessionWindows assigner =
- DynamicEventTimeSessionWindows.withDynamicGap(extractor);
- assigner.assignWindows(Lists.newArrayList(new Object()), 1, mockContext);
-
- fail("should fail");
- } catch (IllegalArgumentException e) {
- assertThat(e.toString(), containsString("0 < gap"));
- }
+ SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
+ when(extractor.extract(any())).thenReturn(-1L);
+
+ DynamicEventTimeSessionWindows assigner =
+ DynamicEventTimeSessionWindows.withDynamicGap(extractor);
+
+ assertThatThrownBy(
+ () ->
+ assigner.assignWindows(
+ Collections.singletonList(new Object()), 1, mockContext))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("0 < gap");
}
@Test
- public void testProperties() {
+ void testProperties() {
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
when(extractor.extract(any())).thenReturn(5000L);
DynamicEventTimeSessionWindows assigner =
DynamicEventTimeSessionWindows.withDynamicGap(extractor);
- assertTrue(assigner.isEventTime());
- assertEquals(
- new TimeWindow.Serializer(), assigner.getWindowSerializer(new ExecutionConfig()));
- assertThat(assigner.getDefaultTrigger(), instanceOf(EventTimeTrigger.class));
+ assertThat(assigner.isEventTime()).isTrue();
+ assertThat(assigner.getWindowSerializer(new ExecutionConfig()))
+ .isEqualTo(new TimeWindow.Serializer());
+ assertThat(assigner.getDefaultTrigger()).isInstanceOf(EventTimeTrigger.class);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/DynamicProcessingTimeSessionWindowsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/DynamicProcessingTimeSessionWindowsTest.java
index 705d4f542cf..56c42dd8c81 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/DynamicProcessingTimeSessionWindowsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/DynamicProcessingTimeSessionWindowsTest.java
@@ -25,24 +25,17 @@ import org.apache.flink.streaming.api.windowing.assigners.SessionWindowTimeGapEx
import org.apache.flink.streaming.api.windowing.assigners.WindowAssigner;
import org.apache.flink.streaming.api.windowing.triggers.ProcessingTimeTrigger;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
-import org.apache.flink.util.TestLogger;
-import org.apache.flink.shaded.guava31.com.google.common.collect.Lists;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import org.mockito.Matchers;
+import java.util.Arrays;
import java.util.Collection;
+import java.util.Collections;
-import static org.apache.flink.streaming.util.StreamRecordMatchers.timeWindow;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.Matchers.contains;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyCollection;
import static org.mockito.Mockito.eq;
@@ -54,10 +47,10 @@ import static org.mockito.Mockito.when;
import static org.mockito.hamcrest.MockitoHamcrest.argThat;
/** Tests for {@link DynamicProcessingTimeSessionWindows}. */
-public class DynamicProcessingTimeSessionWindowsTest extends TestLogger {
+class DynamicProcessingTimeSessionWindowsTest {
@Test
- public void testWindowAssignment() {
+ void testWindowAssignment() {
WindowAssigner.WindowAssignerContext mockContext =
mock(WindowAssigner.WindowAssignerContext.class);
@@ -70,23 +63,20 @@ public class DynamicProcessingTimeSessionWindowsTest extends TestLogger {
DynamicProcessingTimeSessionWindows.withDynamicGap(extractor);
when(mockContext.getCurrentProcessingTime()).thenReturn(0L);
- assertThat(
- assigner.assignWindows("gap5000", Long.MIN_VALUE, mockContext),
- contains(timeWindow(0, 5000)));
+ assertThat(assigner.assignWindows("gap5000", Long.MIN_VALUE, mockContext))
+ .containsExactly(new TimeWindow(0, 5000));
when(mockContext.getCurrentProcessingTime()).thenReturn(4999L);
- assertThat(
- assigner.assignWindows("gap4000", Long.MIN_VALUE, mockContext),
- contains(timeWindow(4999, 8999)));
+ assertThat(assigner.assignWindows("gap4000", Long.MIN_VALUE, mockContext))
+ .containsExactly(new TimeWindow(4999, 8999));
when(mockContext.getCurrentProcessingTime()).thenReturn(5000L);
- assertThat(
- assigner.assignWindows("gap9000", Long.MIN_VALUE, mockContext),
- contains(timeWindow(5000, 14000)));
+ assertThat(assigner.assignWindows("gap9000", Long.MIN_VALUE, mockContext))
+ .containsExactly(new TimeWindow(5000, 14000));
}
@Test
- public void testMergeSinglePointWindow() {
+ void testMergeSinglePointWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
@@ -95,13 +85,13 @@ public class DynamicProcessingTimeSessionWindowsTest extends TestLogger {
DynamicProcessingTimeSessionWindows assigner =
DynamicProcessingTimeSessionWindows.withDynamicGap(extractor);
- assigner.mergeWindows(Lists.newArrayList(new TimeWindow(0, 0)), callback);
+ assigner.mergeWindows(Collections.singletonList(new TimeWindow(0, 0)), callback);
verify(callback, never()).merge(anyCollection(), Matchers.anyObject());
}
@Test
- public void testMergeSingleWindow() {
+ void testMergeSingleWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
@@ -110,13 +100,13 @@ public class DynamicProcessingTimeSessionWindowsTest extends TestLogger {
DynamicProcessingTimeSessionWindows assigner =
DynamicProcessingTimeSessionWindows.withDynamicGap(extractor);
- assigner.mergeWindows(Lists.newArrayList(new TimeWindow(0, 1)), callback);
+ assigner.mergeWindows(Collections.singletonList(new TimeWindow(0, 1)), callback);
verify(callback, never()).merge(anyCollection(), Matchers.anyObject());
}
@Test
- public void testMergeConsecutiveWindows() {
+ void testMergeConsecutiveWindows() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
@@ -126,7 +116,7 @@ public class DynamicProcessingTimeSessionWindowsTest extends TestLogger {
DynamicProcessingTimeSessionWindows.withDynamicGap(extractor);
assigner.mergeWindows(
- Lists.newArrayList(
+ Arrays.asList(
new TimeWindow(0, 1),
new TimeWindow(1, 2),
new TimeWindow(2, 3),
@@ -156,7 +146,7 @@ public class DynamicProcessingTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testMergeCoveringWindow() {
+ void testMergeCoveringWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
@@ -166,7 +156,7 @@ public class DynamicProcessingTimeSessionWindowsTest extends TestLogger {
DynamicProcessingTimeSessionWindows.withDynamicGap(extractor);
assigner.mergeWindows(
- Lists.newArrayList(
+ Arrays.asList(
new TimeWindow(1, 1),
new TimeWindow(0, 2),
new TimeWindow(4, 7),
@@ -193,45 +183,34 @@ public class DynamicProcessingTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testInvalidParameters() {
+ void testInvalidParameters() {
WindowAssigner.WindowAssignerContext mockContext =
mock(WindowAssigner.WindowAssignerContext.class);
- try {
- SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
- when(extractor.extract(any())).thenReturn(-1L);
-
- DynamicProcessingTimeSessionWindows assigner =
- DynamicProcessingTimeSessionWindows.withDynamicGap(extractor);
- assigner.assignWindows(Lists.newArrayList(new Object()), 1, mockContext);
- fail("should fail");
- } catch (IllegalArgumentException e) {
- assertThat(e.toString(), containsString("0 < gap"));
- }
-
- try {
- SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
- when(extractor.extract(any())).thenReturn(-1L);
-
- DynamicProcessingTimeSessionWindows assigner =
- DynamicProcessingTimeSessionWindows.withDynamicGap(extractor);
- assigner.assignWindows(Lists.newArrayList(new Object()), 1, mockContext);
- fail("should fail");
- } catch (IllegalArgumentException e) {
- assertThat(e.toString(), containsString("0 < gap"));
- }
+ SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
+ when(extractor.extract(any())).thenReturn(-1L);
+
+ DynamicProcessingTimeSessionWindows assigner =
+ DynamicProcessingTimeSessionWindows.withDynamicGap(extractor);
+
+ assertThatThrownBy(
+ () ->
+ assigner.assignWindows(
+ Collections.singletonList(new Object()), 1, mockContext))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("0 < gap");
}
@Test
- public void testProperties() {
+ void testProperties() {
SessionWindowTimeGapExtractor extractor = mock(SessionWindowTimeGapExtractor.class);
when(extractor.extract(any())).thenReturn(5000L);
DynamicProcessingTimeSessionWindows assigner =
DynamicProcessingTimeSessionWindows.withDynamicGap(extractor);
- assertFalse(assigner.isEventTime());
- assertEquals(
- new TimeWindow.Serializer(), assigner.getWindowSerializer(new ExecutionConfig()));
- assertThat(assigner.getDefaultTrigger(), instanceOf(ProcessingTimeTrigger.class));
+ assertThat(assigner.isEventTime()).isFalse();
+ assertThat(assigner.getWindowSerializer(new ExecutionConfig()))
+ .isEqualTo(new TimeWindow.Serializer());
+ assertThat(assigner.getDefaultTrigger()).isInstanceOf(ProcessingTimeTrigger.class);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EventTimeSessionWindowsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EventTimeSessionWindowsTest.java
index 31e908744e2..122d631316c 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EventTimeSessionWindowsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EventTimeSessionWindowsTest.java
@@ -27,25 +27,17 @@ import org.apache.flink.streaming.api.windowing.assigners.WindowAssigner;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
-import org.apache.flink.util.TestLogger;
-import org.apache.flink.shaded.guava31.com.google.common.collect.Lists;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import org.mockito.Matchers;
+import java.util.Arrays;
import java.util.Collection;
+import java.util.Collections;
-import static org.apache.flink.streaming.util.StreamRecordMatchers.timeWindow;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.Matchers.contains;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
import static org.mockito.Matchers.anyCollection;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
@@ -55,10 +47,10 @@ import static org.mockito.Mockito.verify;
import static org.mockito.hamcrest.MockitoHamcrest.argThat;
/** Tests for {@link EventTimeSessionWindows}. */
-public class EventTimeSessionWindowsTest extends TestLogger {
+class EventTimeSessionWindowsTest {
@Test
- public void testWindowAssignment() {
+ void testWindowAssignment() {
final int sessionGap = 5000;
WindowAssigner.WindowAssignerContext mockContext =
@@ -67,50 +59,47 @@ public class EventTimeSessionWindowsTest extends TestLogger {
EventTimeSessionWindows assigner =
EventTimeSessionWindows.withGap(Time.milliseconds(sessionGap));
- assertThat(
- assigner.assignWindows("String", 0L, mockContext),
- contains(timeWindow(0, 0 + sessionGap)));
- assertThat(
- assigner.assignWindows("String", 4999L, mockContext),
- contains(timeWindow(4999, 4999 + sessionGap)));
- assertThat(
- assigner.assignWindows("String", 5000L, mockContext),
- contains(timeWindow(5000, 5000 + sessionGap)));
+ assertThat(assigner.assignWindows("String", 0L, mockContext))
+ .containsExactly(new TimeWindow(0, 0 + sessionGap));
+ assertThat(assigner.assignWindows("String", 4999L, mockContext))
+ .containsExactly(new TimeWindow(4999, 4999 + sessionGap));
+ assertThat(assigner.assignWindows("String", 5000L, mockContext))
+ .containsExactly(new TimeWindow(5000, 5000 + sessionGap));
}
@Test
- public void testMergeSinglePointWindow() {
+ void testMergeSinglePointWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
EventTimeSessionWindows assigner = EventTimeSessionWindows.withGap(Time.milliseconds(5000));
- assigner.mergeWindows(Lists.newArrayList(new TimeWindow(0, 0)), callback);
+ assigner.mergeWindows(Collections.singletonList(new TimeWindow(0, 0)), callback);
verify(callback, never()).merge(anyCollection(), Matchers.anyObject());
}
@Test
- public void testMergeSingleWindow() {
+ void testMergeSingleWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
EventTimeSessionWindows assigner = EventTimeSessionWindows.withGap(Time.milliseconds(5000));
- assigner.mergeWindows(Lists.newArrayList(new TimeWindow(0, 1)), callback);
+ assigner.mergeWindows(Collections.singletonList(new TimeWindow(0, 1)), callback);
verify(callback, never()).merge(anyCollection(), Matchers.anyObject());
}
@Test
- public void testMergeConsecutiveWindows() {
+ void testMergeConsecutiveWindows() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
EventTimeSessionWindows assigner = EventTimeSessionWindows.withGap(Time.milliseconds(5000));
assigner.mergeWindows(
- Lists.newArrayList(
+ Arrays.asList(
new TimeWindow(0, 1),
new TimeWindow(1, 2),
new TimeWindow(2, 3),
@@ -140,14 +129,14 @@ public class EventTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testMergeCoveringWindow() {
+ void testMergeCoveringWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
EventTimeSessionWindows assigner = EventTimeSessionWindows.withGap(Time.milliseconds(5000));
assigner.mergeWindows(
- Lists.newArrayList(
+ Arrays.asList(
new TimeWindow(1, 1),
new TimeWindow(0, 2),
new TimeWindow(4, 7),
@@ -174,7 +163,7 @@ public class EventTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testTimeUnits() {
+ void testTimeUnits() {
// sanity check with one other time unit
final int sessionGap = 5000;
@@ -185,51 +174,42 @@ public class EventTimeSessionWindowsTest extends TestLogger {
EventTimeSessionWindows assigner =
EventTimeSessionWindows.withGap(Time.seconds(sessionGap / 1000));
- assertThat(
- assigner.assignWindows("String", 0L, mockContext),
- contains(timeWindow(0, 0 + sessionGap)));
- assertThat(
- assigner.assignWindows("String", 4999L, mockContext),
- contains(timeWindow(4999, 4999 + sessionGap)));
- assertThat(
- assigner.assignWindows("String", 5000L, mockContext),
- contains(timeWindow(5000, 5000 + sessionGap)));
+ assertThat(assigner.assignWindows("String", 0L, mockContext))
+ .containsExactly(new TimeWindow(0, 0 + sessionGap));
+ assertThat(assigner.assignWindows("String", 4999L, mockContext))
+ .containsExactly(new TimeWindow(4999, 4999 + sessionGap));
+ assertThat(assigner.assignWindows("String", 5000L, mockContext))
+ .containsExactly(new TimeWindow(5000, 5000 + sessionGap));
}
@Test
- public void testInvalidParameters() {
- try {
- EventTimeSessionWindows.withGap(Time.seconds(-1));
- fail("should fail");
- } catch (IllegalArgumentException e) {
- assertThat(e.toString(), containsString("0 < size"));
- }
-
- try {
- EventTimeSessionWindows.withGap(Time.seconds(0));
- fail("should fail");
- } catch (IllegalArgumentException e) {
- assertThat(e.toString(), containsString("0 < size"));
- }
+ void testInvalidParameters() {
+ assertThatThrownBy(() -> EventTimeSessionWindows.withGap(Time.seconds(-1)))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("0 < size");
+
+ assertThatThrownBy(() -> EventTimeSessionWindows.withGap(Time.seconds(0)))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("0 < size");
}
@Test
- public void testProperties() {
+ void testProperties() {
EventTimeSessionWindows assigner = EventTimeSessionWindows.withGap(Time.seconds(5));
- assertTrue(assigner.isEventTime());
- assertEquals(
- new TimeWindow.Serializer(), assigner.getWindowSerializer(new ExecutionConfig()));
- assertThat(assigner.getDefaultTrigger(), instanceOf(EventTimeTrigger.class));
+ assertThat(assigner.isEventTime()).isTrue();
+ assertThat(assigner.getWindowSerializer(new ExecutionConfig()))
+ .isEqualTo(new TimeWindow.Serializer());
+ assertThat(assigner.getDefaultTrigger()).isInstanceOf(EventTimeTrigger.class);
}
@Test
- public void testDynamicGapProperties() {
+ void testDynamicGapProperties() {
SessionWindowTimeGapExtractor<String> extractor = mock(SessionWindowTimeGapExtractor.class);
DynamicEventTimeSessionWindows<String> assigner =
EventTimeSessionWindows.withDynamicGap(extractor);
- assertNotNull(assigner);
- assertTrue(assigner.isEventTime());
+ assertThat(assigner).isNotNull();
+ assertThat(assigner.isEventTime()).isTrue();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EventTimeTriggerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EventTimeTriggerTest.java
index f05db7c0c3c..5ea3a408327 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EventTimeTriggerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EventTimeTriggerTest.java
@@ -25,147 +25,139 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.shaded.guava31.com.google.common.collect.Lists;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link EventTimeTrigger}. */
-public class EventTimeTriggerTest {
+class EventTimeTriggerTest {
/** Verify that state of separate windows does not leak into other windows. */
@Test
- public void testWindowSeparationAndFiring() throws Exception {
+ void testWindowSeparationAndFiring() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(EventTimeTrigger.create(), new TimeWindow.Serializer());
// inject several elements
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
-
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
-
- assertEquals(TriggerResult.FIRE, testHarness.advanceWatermark(2, new TimeWindow(0, 2)));
-
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
-
- assertEquals(TriggerResult.FIRE, testHarness.advanceWatermark(4, new TimeWindow(2, 4)));
-
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
+
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isOne();
+
+ assertThat(testHarness.advanceWatermark(2, new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
+
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isOne();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isOne();
+
+ assertThat(testHarness.advanceWatermark(4, new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.FIRE);
+
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
}
/**
* Verify that late elements trigger immediately and also that we don't set a timer for those.
*/
@Test
- public void testLateElementTriggersImmediately() throws Exception {
+ void testLateElementTriggersImmediately() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(EventTimeTrigger.create(), new TimeWindow.Serializer());
testHarness.advanceWatermark(2);
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
}
/** Verify that clear() does not leak across windows. */
@Test
- public void testClear() throws Exception {
+ void testClear() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(EventTimeTrigger.create(), new TimeWindow.Serializer());
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isOne();
testHarness.clearTriggerState(new TimeWindow(2, 4));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isOne();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isZero();
testHarness.clearTriggerState(new TimeWindow(0, 2));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
}
@Test
- public void testMergingWindows() throws Exception {
+ void testMergingWindows() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(EventTimeTrigger.create(), new TimeWindow.Serializer());
- assertTrue(EventTimeTrigger.create().canMerge());
+ assertThat(EventTimeTrigger.create().canMerge()).isTrue();
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isOne();
testHarness.mergeWindows(
new TimeWindow(0, 4),
Lists.newArrayList(new TimeWindow(0, 2), new TimeWindow(2, 4)));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(0, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isOne();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isZero();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 4))).isOne();
- assertEquals(TriggerResult.FIRE, testHarness.advanceWatermark(4, new TimeWindow(0, 4)));
+ assertThat(testHarness.advanceWatermark(4, new TimeWindow(0, 4)))
+ .isEqualTo(TriggerResult.FIRE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
}
/**
@@ -173,43 +165,41 @@ public class EventTimeTriggerTest {
* from onElement() on the merged window and one from the timer.
*/
@Test
- public void testMergingLateWindows() throws Exception {
+ void testMergingLateWindows() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(EventTimeTrigger.create(), new TimeWindow.Serializer());
- assertTrue(EventTimeTrigger.create().canMerge());
+ assertThat(EventTimeTrigger.create().canMerge()).isTrue();
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(2, testHarness.numEventTimeTimers());
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isEqualTo(2);
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isOne();
testHarness.advanceWatermark(10);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isZero();
testHarness.mergeWindows(
new TimeWindow(0, 4),
Lists.newArrayList(new TimeWindow(0, 2), new TimeWindow(2, 4)));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numEventTimeTimers(new TimeWindow(2, 4)));
- assertEquals(0, testHarness.numEventTimeTimers(new TimeWindow(0, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(2, 4))).isZero();
+ assertThat(testHarness.numEventTimeTimers(new TimeWindow(0, 4))).isZero();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EvictingWindowOperatorContractTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EvictingWindowOperatorContractTest.java
index bbfcb388093..3e2f7dd376d 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EvictingWindowOperatorContractTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EvictingWindowOperatorContractTest.java
@@ -41,7 +41,7 @@ import org.apache.flink.util.OutputTag;
*
* <p>These tests document the implicit contract that exists between the windowing components.
*/
-public class EvictingWindowOperatorContractTest extends WindowOperatorContractTest {
+class EvictingWindowOperatorContractTest extends WindowOperatorContractTest {
protected <W extends Window, OUT>
KeyedOneInputStreamOperatorTestHarness<Integer, Integer, OUT> createWindowOperator(
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EvictingWindowOperatorTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EvictingWindowOperatorTest.java
index 63b8e23d11c..5cbf0efc158 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EvictingWindowOperatorTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/EvictingWindowOperatorTest.java
@@ -52,23 +52,24 @@ import org.apache.flink.streaming.util.OneInputStreamOperatorTestHarness;
import org.apache.flink.streaming.util.TestHarnessUtil;
import org.apache.flink.util.Collector;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.Comparator;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
+import static org.assertj.core.api.Assertions.assertThat;
+
/** Tests for {@link EvictingWindowOperator}. */
-public class EvictingWindowOperatorTest {
+class EvictingWindowOperatorTest {
private static final TypeInformation<Tuple2<String, Integer>> STRING_INT_TUPLE =
TypeInformation.of(new TypeHint<Tuple2<String, Integer>>() {});
/** Tests CountEvictor evictAfter behavior. */
@Test
- public void testCountEvictorEvictAfter() throws Exception {
+ void testCountEvictorEvictAfter() throws Exception {
AtomicInteger closeCalled = new AtomicInteger(0);
final int windowSize = 4;
final int triggerCount = 2;
@@ -156,12 +157,12 @@ public class EvictingWindowOperatorTest {
testHarness.close();
- Assert.assertEquals("Close was not called.", 1, closeCalled.get());
+ assertThat(closeCalled).as("Close was not called.").hasValue(1);
}
/** Tests TimeEvictor evictAfter behavior. */
@Test
- public void testTimeEvictorEvictAfter() throws Exception {
+ void testTimeEvictorEvictAfter() throws Exception {
AtomicInteger closeCalled = new AtomicInteger(0);
final int triggerCount = 2;
final boolean evictAfter = true;
@@ -238,12 +239,12 @@ public class EvictingWindowOperatorTest {
testHarness.close();
- Assert.assertEquals("Close was not called.", 1, closeCalled.get());
+ assertThat(closeCalled).as("Close was not called.").hasValue(1);
}
/** Tests TimeEvictor evictBefore behavior. */
@Test
- public void testTimeEvictorEvictBefore() throws Exception {
+ void testTimeEvictorEvictBefore() throws Exception {
AtomicInteger closeCalled = new AtomicInteger(0);
final int triggerCount = 2;
final int windowSize = 4;
@@ -319,7 +320,7 @@ public class EvictingWindowOperatorTest {
testHarness.close();
- Assert.assertEquals("Close was not called.", 1, closeCalled.get());
+ assertThat(closeCalled).as("Close was not called.").hasValue(1);
}
/**
@@ -327,7 +328,7 @@ public class EvictingWindowOperatorTest {
* evicted from the window.
*/
@Test
- public void testTimeEvictorNoTimestamp() throws Exception {
+ void testTimeEvictorNoTimestamp() throws Exception {
AtomicInteger closeCalled = new AtomicInteger(0);
final int triggerCount = 2;
final boolean evictAfter = true;
@@ -402,12 +403,12 @@ public class EvictingWindowOperatorTest {
testHarness.close();
- Assert.assertEquals("Close was not called.", 1, closeCalled.get());
+ assertThat(closeCalled).as("Close was not called.").hasValue(1);
}
/** Tests DeltaEvictor, evictBefore behavior. */
@Test
- public void testDeltaEvictorEvictBefore() throws Exception {
+ void testDeltaEvictorEvictBefore() throws Exception {
AtomicInteger closeCalled = new AtomicInteger(0);
final int triggerCount = 2;
final boolean evictAfter = false;
@@ -496,12 +497,12 @@ public class EvictingWindowOperatorTest {
testHarness.close();
- Assert.assertEquals("Close was not called.", 1, closeCalled.get());
+ assertThat(closeCalled).as("Close was not called.").hasValue(1);
}
/** Tests DeltaEvictor, evictAfter behavior. */
@Test
- public void testDeltaEvictorEvictAfter() throws Exception {
+ void testDeltaEvictorEvictAfter() throws Exception {
AtomicInteger closeCalled = new AtomicInteger(0);
final int triggerCount = 2;
final boolean evictAfter = true;
@@ -590,12 +591,12 @@ public class EvictingWindowOperatorTest {
testHarness.close();
- Assert.assertEquals("Close was not called.", 1, closeCalled.get());
+ assertThat(closeCalled).as("Close was not called.").hasValue(1);
}
@Test
@SuppressWarnings("unchecked")
- public void testCountTrigger() throws Exception {
+ void testCountTrigger() throws Exception {
final int windowSize = 4;
final int windowSlide = 2;
@@ -685,7 +686,7 @@ public class EvictingWindowOperatorTest {
@Test
@SuppressWarnings("unchecked")
- public void testCountTriggerWithApply() throws Exception {
+ void testCountTriggerWithApply() throws Exception {
AtomicInteger closeCalled = new AtomicInteger(0);
final int windowSize = 4;
@@ -766,12 +767,12 @@ public class EvictingWindowOperatorTest {
testHarness.close();
- Assert.assertEquals("Close was not called.", 1, closeCalled.get());
+ assertThat(closeCalled).as("Close was not called.").hasValue(1);
}
@Test
@SuppressWarnings("unchecked")
- public void testTumblingWindowWithApply() throws Exception {
+ void testTumblingWindowWithApply() throws Exception {
AtomicInteger closeCalled = new AtomicInteger(0);
final int windowSize = 4;
@@ -889,9 +890,7 @@ public class EvictingWindowOperatorTest {
Collector<Tuple2<String, Integer>> out)
throws Exception {
- if (!openCalled) {
- Assert.fail("Open was not called");
- }
+ assertThat(openCalled).as("Open was not called").isTrue();
int sum = 0;
for (Tuple2<String, Integer> t : input) {
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/GlobalWindowsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/GlobalWindowsTest.java
index ca00ab9bdbc..3c6008fe38c 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/GlobalWindowsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/GlobalWindowsTest.java
@@ -22,44 +22,40 @@ import org.apache.flink.api.common.ExecutionConfig;
import org.apache.flink.streaming.api.windowing.assigners.GlobalWindows;
import org.apache.flink.streaming.api.windowing.assigners.WindowAssigner;
import org.apache.flink.streaming.api.windowing.windows.GlobalWindow;
-import org.apache.flink.util.TestLogger;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/** Tests for {@link GlobalWindows}. */
-public class GlobalWindowsTest extends TestLogger {
+class GlobalWindowsTest {
@Test
- public void testWindowAssignment() {
+ void testWindowAssignment() {
WindowAssigner.WindowAssignerContext mockContext =
mock(WindowAssigner.WindowAssignerContext.class);
GlobalWindows assigner = GlobalWindows.create();
- assertThat(assigner.assignWindows("String", 0L, mockContext), contains(GlobalWindow.get()));
- assertThat(
- assigner.assignWindows("String", 4999L, mockContext), contains(GlobalWindow.get()));
- assertThat(
- assigner.assignWindows("String", 5000L, mockContext), contains(GlobalWindow.get()));
+ assertThat(assigner.assignWindows("String", 0L, mockContext))
+ .containsExactly(GlobalWindow.get());
+ assertThat(assigner.assignWindows("String", 4999L, mockContext))
+ .containsExactly(GlobalWindow.get());
+ assertThat(assigner.assignWindows("String", 5000L, mockContext))
+ .containsExactly(GlobalWindow.get());
}
@Test
- public void testProperties() {
+ void testProperties() {
GlobalWindows assigner = GlobalWindows.create();
- assertFalse(assigner.isEventTime());
- assertEquals(
- new GlobalWindow.Serializer(), assigner.getWindowSerializer(new ExecutionConfig()));
- assertThat(assigner.getDefaultTrigger(), instanceOf(GlobalWindows.NeverTrigger.class));
+ assertThat(assigner.isEventTime()).isFalse();
+ assertThat(assigner.getWindowSerializer(new ExecutionConfig()))
+ .isEqualTo(new GlobalWindow.Serializer());
+ assertThat(assigner.getDefaultTrigger()).isInstanceOf(GlobalWindows.NeverTrigger.class);
assigner = GlobalWindows.createWithEndOfStreamTrigger();
- assertThat(
- assigner.getDefaultTrigger(), instanceOf(GlobalWindows.EndOfStreamTrigger.class));
+ assertThat(assigner.getDefaultTrigger())
+ .isInstanceOf(GlobalWindows.EndOfStreamTrigger.class);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapPutIfAbsentTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapPutIfAbsentTest.java
index 7c5b1d9a736..1bc39173b8f 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapPutIfAbsentTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapPutIfAbsentTest.java
@@ -18,88 +18,76 @@
package org.apache.flink.streaming.runtime.operators.windowing;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link KeyMap}. */
-public class KeyMapPutIfAbsentTest {
+class KeyMapPutIfAbsentTest {
@Test
- public void testPutIfAbsentUniqueKeysAndGrowth() {
- try {
- KeyMap<Integer, Integer> map = new KeyMap<>();
- IntegerFactory factory = new IntegerFactory();
-
- final int numElements = 1000000;
-
- for (int i = 0; i < numElements; i++) {
- factory.set(2 * i + 1);
- map.putIfAbsent(i, factory);
-
- assertEquals(i + 1, map.size());
- assertTrue(map.getCurrentTableCapacity() > map.size());
- assertTrue(map.getCurrentTableCapacity() > map.getRehashThreshold());
- assertTrue(map.size() <= map.getRehashThreshold());
- }
-
- assertEquals(numElements, map.size());
- assertEquals(numElements, map.traverseAndCountElements());
- assertEquals(1 << 21, map.getCurrentTableCapacity());
-
- for (int i = 0; i < numElements; i++) {
- assertEquals(2 * i + 1, map.get(i).intValue());
- }
-
- for (int i = numElements - 1; i >= 0; i--) {
- assertEquals(2 * i + 1, map.get(i).intValue());
- }
-
- assertEquals(numElements, map.size());
- assertEquals(numElements, map.traverseAndCountElements());
- assertEquals(1 << 21, map.getCurrentTableCapacity());
- assertTrue(map.getLongestChainLength() <= 7);
- } catch (Exception e) {
- e.printStackTrace();
- fail(e.getMessage());
+ void testPutIfAbsentUniqueKeysAndGrowth() {
+ KeyMap<Integer, Integer> map = new KeyMap<>();
+ IntegerFactory factory = new IntegerFactory();
+
+ final int numElements = 1000000;
+
+ for (int i = 0; i < numElements; i++) {
+ factory.set(2 * i + 1);
+ map.putIfAbsent(i, factory);
+
+ assertThat(map.size()).isEqualTo(i + 1).isLessThanOrEqualTo(map.getRehashThreshold());
+ assertThat(map.getCurrentTableCapacity())
+ .isGreaterThan(map.size())
+ .isGreaterThan(map.getRehashThreshold());
+ }
+
+ assertThat(map).hasSize(numElements);
+ assertThat(map.traverseAndCountElements()).isEqualTo(numElements);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(1 << 21);
+
+ for (int i = 0; i < numElements; i++) {
+ assertThat(map.get(i)).isEqualTo(2 * i + 1);
+ }
+
+ for (int i = numElements - 1; i >= 0; i--) {
+ assertThat(map.get(i)).isEqualTo(2 * i + 1);
}
+
+ assertThat(map).hasSize(numElements);
+ assertThat(map.traverseAndCountElements()).isEqualTo(numElements);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(1 << 21);
+ assertThat(map.getLongestChainLength()).isLessThanOrEqualTo(7);
}
@Test
- public void testPutIfAbsentDuplicateKeysAndGrowth() {
- try {
- KeyMap<Integer, Integer> map = new KeyMap<>();
- IntegerFactory factory = new IntegerFactory();
-
- final int numElements = 1000000;
-
- for (int i = 0; i < numElements; i++) {
- int val = 2 * i + 1;
- factory.set(val);
- Integer put = map.putIfAbsent(i, factory);
- assertEquals(val, put.intValue());
- }
-
- for (int i = 0; i < numElements; i += 3) {
- factory.set(2 * i);
- Integer put = map.putIfAbsent(i, factory);
- assertEquals(2 * i + 1, put.intValue());
- }
-
- for (int i = 0; i < numElements; i++) {
- assertEquals(2 * i + 1, map.get(i).intValue());
- }
-
- assertEquals(numElements, map.size());
- assertEquals(numElements, map.traverseAndCountElements());
- assertEquals(1 << 21, map.getCurrentTableCapacity());
- assertTrue(map.getLongestChainLength() <= 7);
- } catch (Exception e) {
- e.printStackTrace();
- fail(e.getMessage());
+ void testPutIfAbsentDuplicateKeysAndGrowth() {
+ KeyMap<Integer, Integer> map = new KeyMap<>();
+ IntegerFactory factory = new IntegerFactory();
+
+ final int numElements = 1000000;
+
+ for (int i = 0; i < numElements; i++) {
+ int val = 2 * i + 1;
+ factory.set(val);
+ Integer put = map.putIfAbsent(i, factory);
+ assertThat(put).isEqualTo(val);
+ }
+
+ for (int i = 0; i < numElements; i += 3) {
+ factory.set(2 * i);
+ Integer put = map.putIfAbsent(i, factory);
+ assertThat(put).isEqualTo(2 * i + 1);
+ }
+
+ for (int i = 0; i < numElements; i++) {
+ assertThat(map.get(i)).isEqualTo(2 * i + 1);
}
+
+ assertThat(map).hasSize(numElements);
+ assertThat(map.traverseAndCountElements()).isEqualTo(numElements);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(1 << 21);
+ assertThat(map.getLongestChainLength()).isLessThanOrEqualTo(7);
}
// ------------------------------------------------------------------------
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapPutTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapPutTest.java
index eb36b2e6acf..ac108df604b 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapPutTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapPutTest.java
@@ -18,116 +18,100 @@
package org.apache.flink.streaming.runtime.operators.windowing;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.BitSet;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link KeyMap}. */
-public class KeyMapPutTest {
+class KeyMapPutTest {
@Test
- public void testPutUniqueKeysAndGrowth() {
- try {
- KeyMap<Integer, Integer> map = new KeyMap<>();
-
- final int numElements = 1000000;
-
- for (int i = 0; i < numElements; i++) {
- map.put(i, 2 * i + 1);
-
- assertEquals(i + 1, map.size());
- assertTrue(map.getCurrentTableCapacity() > map.size());
- assertTrue(map.getCurrentTableCapacity() > map.getRehashThreshold());
- assertTrue(map.size() <= map.getRehashThreshold());
- }
-
- assertEquals(numElements, map.size());
- assertEquals(numElements, map.traverseAndCountElements());
- assertEquals(1 << 21, map.getCurrentTableCapacity());
-
- for (int i = 0; i < numElements; i++) {
- assertEquals(2 * i + 1, map.get(i).intValue());
- }
-
- for (int i = numElements - 1; i >= 0; i--) {
- assertEquals(2 * i + 1, map.get(i).intValue());
- }
-
- BitSet bitset = new BitSet();
- int numContained = 0;
- for (KeyMap.Entry<Integer, Integer> entry : map) {
- numContained++;
-
- assertEquals(entry.getKey() * 2 + 1, entry.getValue().intValue());
- assertFalse(bitset.get(entry.getKey()));
- bitset.set(entry.getKey());
- }
-
- assertEquals(numElements, numContained);
- assertEquals(numElements, bitset.cardinality());
-
- assertEquals(numElements, map.size());
- assertEquals(numElements, map.traverseAndCountElements());
- assertEquals(1 << 21, map.getCurrentTableCapacity());
- assertTrue(map.getLongestChainLength() <= 7);
- } catch (Exception e) {
- e.printStackTrace();
- fail(e.getMessage());
+ void testPutUniqueKeysAndGrowth() {
+ KeyMap<Integer, Integer> map = new KeyMap<>();
+
+ final int numElements = 1000000;
+
+ for (int i = 0; i < numElements; i++) {
+ map.put(i, 2 * i + 1);
+
+ assertThat(map.size()).isEqualTo(i + 1).isLessThanOrEqualTo(map.getRehashThreshold());
+ assertThat(map.getCurrentTableCapacity())
+ .isGreaterThan(map.size())
+ .isGreaterThan(map.getRehashThreshold());
+ }
+
+ assertThat(map).hasSize(numElements);
+ assertThat(map.traverseAndCountElements()).isEqualTo(numElements);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(1 << 21);
+
+ for (int i = 0; i < numElements; i++) {
+ assertThat(map.get(i)).isEqualTo(2 * i + 1);
}
+
+ for (int i = numElements - 1; i >= 0; i--) {
+ assertThat(map.get(i)).isEqualTo(2 * i + 1);
+ }
+
+ BitSet bitset = new BitSet();
+ int numContained = 0;
+ for (KeyMap.Entry<Integer, Integer> entry : map) {
+ numContained++;
+
+ assertThat(entry.getValue()).isEqualTo(entry.getKey() * 2 + 1);
+ assertThat(bitset.get(entry.getKey())).isFalse();
+ bitset.set(entry.getKey());
+ }
+
+ assertThat(numContained).isEqualTo(numElements);
+ assertThat(bitset.cardinality()).isEqualTo(numElements);
+
+ assertThat(map).hasSize(numElements);
+ assertThat(map.traverseAndCountElements()).isEqualTo(numElements);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(1 << 21);
+ assertThat(map.getLongestChainLength()).isLessThanOrEqualTo(7);
}
@Test
- public void testPutDuplicateKeysAndGrowth() {
- try {
- final KeyMap<Integer, Integer> map = new KeyMap<>();
- final int numElements = 1000000;
-
- for (int i = 0; i < numElements; i++) {
- Integer put = map.put(i, 2 * i + 1);
- assertNull(put);
- }
-
- for (int i = 0; i < numElements; i += 3) {
- Integer put = map.put(i, 2 * i);
- assertNotNull(put);
- assertEquals(2 * i + 1, put.intValue());
- }
-
- for (int i = 0; i < numElements; i++) {
- int expected = (i % 3 == 0) ? (2 * i) : (2 * i + 1);
- assertEquals(expected, map.get(i).intValue());
- }
-
- assertEquals(numElements, map.size());
- assertEquals(numElements, map.traverseAndCountElements());
- assertEquals(1 << 21, map.getCurrentTableCapacity());
- assertTrue(map.getLongestChainLength() <= 7);
-
- BitSet bitset = new BitSet();
- int numContained = 0;
- for (KeyMap.Entry<Integer, Integer> entry : map) {
- numContained++;
-
- int key = entry.getKey();
- int expected = key % 3 == 0 ? (2 * key) : (2 * key + 1);
-
- assertEquals(expected, entry.getValue().intValue());
- assertFalse(bitset.get(key));
- bitset.set(key);
- }
-
- assertEquals(numElements, numContained);
- assertEquals(numElements, bitset.cardinality());
- } catch (Exception e) {
- e.printStackTrace();
- fail(e.getMessage());
+ void testPutDuplicateKeysAndGrowth() {
+ final KeyMap<Integer, Integer> map = new KeyMap<>();
+ final int numElements = 1000000;
+
+ for (int i = 0; i < numElements; i++) {
+ Integer put = map.put(i, 2 * i + 1);
+ assertThat(put).isNull();
+ }
+
+ for (int i = 0; i < numElements; i += 3) {
+ Integer put = map.put(i, 2 * i);
+ assertThat(put).isNotNull().isEqualTo(2 * i + 1);
+ }
+
+ for (int i = 0; i < numElements; i++) {
+ int expected = (i % 3 == 0) ? (2 * i) : (2 * i + 1);
+ assertThat(map.get(i)).isEqualTo(expected);
}
+
+ assertThat(map).hasSize(numElements);
+ assertThat(map.traverseAndCountElements()).isEqualTo(numElements);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(1 << 21);
+ assertThat(map.getLongestChainLength()).isLessThanOrEqualTo(7);
+
+ BitSet bitset = new BitSet();
+ int numContained = 0;
+ for (KeyMap.Entry<Integer, Integer> entry : map) {
+ numContained++;
+
+ int key = entry.getKey();
+ int expected = key % 3 == 0 ? (2 * key) : (2 * key + 1);
+
+ assertThat(entry.getValue()).isEqualTo(expected);
+ assertThat(bitset.get(key)).isFalse();
+ bitset.set(key);
+ }
+
+ assertThat(numContained).isEqualTo(numElements);
+ assertThat(bitset.cardinality()).isEqualTo(numElements);
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapTest.java
index 500c3f7743b..52bf6e7bf11 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/KeyMapTest.java
@@ -18,304 +18,274 @@
package org.apache.flink.streaming.runtime.operators.windowing;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Random;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
/** Tests for {@link KeyMap}. */
-public class KeyMapTest {
+class KeyMapTest {
@Test
- public void testInitialSizeComputation() {
+ void testInitialSizeComputation() {
+ KeyMap<String, String> map;
+
+ map = new KeyMap<>();
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(64);
+ assertThat(map.getLog2TableCapacity()).isEqualTo(6);
+ assertThat(map.getShift()).isEqualTo(24);
+ assertThat(map.getRehashThreshold()).isEqualTo(48);
+
+ map = new KeyMap<>(0);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(64);
+ assertThat(map.getLog2TableCapacity()).isEqualTo(6);
+ assertThat(map.getShift()).isEqualTo(24);
+ assertThat(map.getRehashThreshold()).isEqualTo(48);
+
+ map = new KeyMap<>(1);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(64);
+ assertThat(map.getLog2TableCapacity()).isEqualTo(6);
+ assertThat(map.getShift()).isEqualTo(24);
+ assertThat(map.getRehashThreshold()).isEqualTo(48);
+
+ map = new KeyMap<>(9);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(64);
+ assertThat(map.getLog2TableCapacity()).isEqualTo(6);
+ assertThat(map.getShift()).isEqualTo(24);
+ assertThat(map.getRehashThreshold()).isEqualTo(48);
+
+ map = new KeyMap<>(63);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(64);
+ assertThat(map.getLog2TableCapacity()).isEqualTo(6);
+ assertThat(map.getShift()).isEqualTo(24);
+ assertThat(map.getRehashThreshold()).isEqualTo(48);
+
+ map = new KeyMap<>(64);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(128);
+ assertThat(map.getLog2TableCapacity()).isEqualTo(7);
+ assertThat(map.getShift()).isEqualTo(23);
+ assertThat(map.getRehashThreshold()).isEqualTo(96);
+
+ map = new KeyMap<>(500);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(512);
+ assertThat(map.getLog2TableCapacity()).isEqualTo(9);
+ assertThat(map.getShift()).isEqualTo(21);
+ assertThat(map.getRehashThreshold()).isEqualTo(384);
+
+ map = new KeyMap<>(127);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(128);
+ assertThat(map.getLog2TableCapacity()).isEqualTo(7);
+ assertThat(map.getShift()).isEqualTo(23);
+ assertThat(map.getRehashThreshold()).isEqualTo(96);
+
+ // no negative number of elements
+ assertThatThrownBy(() -> new KeyMap<>(-1)).isInstanceOf(IllegalArgumentException.class);
+
+ // check integer overflow
try {
- KeyMap<String, String> map;
-
- map = new KeyMap<>();
- assertEquals(64, map.getCurrentTableCapacity());
- assertEquals(6, map.getLog2TableCapacity());
- assertEquals(24, map.getShift());
- assertEquals(48, map.getRehashThreshold());
-
- map = new KeyMap<>(0);
- assertEquals(64, map.getCurrentTableCapacity());
- assertEquals(6, map.getLog2TableCapacity());
- assertEquals(24, map.getShift());
- assertEquals(48, map.getRehashThreshold());
-
- map = new KeyMap<>(1);
- assertEquals(64, map.getCurrentTableCapacity());
- assertEquals(6, map.getLog2TableCapacity());
- assertEquals(24, map.getShift());
- assertEquals(48, map.getRehashThreshold());
-
- map = new KeyMap<>(9);
- assertEquals(64, map.getCurrentTableCapacity());
- assertEquals(6, map.getLog2TableCapacity());
- assertEquals(24, map.getShift());
- assertEquals(48, map.getRehashThreshold());
-
- map = new KeyMap<>(63);
- assertEquals(64, map.getCurrentTableCapacity());
- assertEquals(6, map.getLog2TableCapacity());
- assertEquals(24, map.getShift());
- assertEquals(48, map.getRehashThreshold());
-
- map = new KeyMap<>(64);
- assertEquals(128, map.getCurrentTableCapacity());
- assertEquals(7, map.getLog2TableCapacity());
- assertEquals(23, map.getShift());
- assertEquals(96, map.getRehashThreshold());
-
- map = new KeyMap<>(500);
- assertEquals(512, map.getCurrentTableCapacity());
- assertEquals(9, map.getLog2TableCapacity());
- assertEquals(21, map.getShift());
- assertEquals(384, map.getRehashThreshold());
-
- map = new KeyMap<>(127);
- assertEquals(128, map.getCurrentTableCapacity());
- assertEquals(7, map.getLog2TableCapacity());
- assertEquals(23, map.getShift());
- assertEquals(96, map.getRehashThreshold());
-
- // no negative number of elements
- try {
- new KeyMap<>(-1);
- fail("should fail with an exception");
- } catch (IllegalArgumentException e) {
- // expected
- }
-
- // check integer overflow
- try {
- map = new KeyMap<>(0x65715522);
-
- final int maxCap = Integer.highestOneBit(Integer.MAX_VALUE);
- assertEquals(
- Integer.highestOneBit(Integer.MAX_VALUE), map.getCurrentTableCapacity());
- assertEquals(30, map.getLog2TableCapacity());
- assertEquals(0, map.getShift());
- assertEquals(maxCap / 4 * 3, map.getRehashThreshold());
- } catch (OutOfMemoryError e) {
- // this may indeed happen in small test setups. we tolerate this in this test
- }
- } catch (Exception e) {
- e.printStackTrace();
- fail(e.getMessage());
+ map = new KeyMap<>(0x65715522);
+
+ final int maxCap = Integer.highestOneBit(Integer.MAX_VALUE);
+ assertThat(map.getCurrentTableCapacity()).isEqualTo(maxCap);
+ assertThat(map.getLog2TableCapacity()).isEqualTo(30);
+ assertThat(map.getShift()).isZero();
+ assertThat(map.getRehashThreshold()).isEqualTo(maxCap / 4 * 3);
+ } catch (OutOfMemoryError e) {
+ // this may indeed happen in small test setups. we tolerate this in this test
}
}
@Test
- public void testPutAndGetRandom() {
- try {
- final KeyMap<Integer, Integer> map = new KeyMap<>();
- final Random rnd = new Random();
+ void testPutAndGetRandom() {
+ final KeyMap<Integer, Integer> map = new KeyMap<>();
+ final Random rnd = new Random();
- final long seed = rnd.nextLong();
- final int numElements = 10000;
+ final long seed = rnd.nextLong();
+ final int numElements = 10000;
- final HashMap<Integer, Integer> groundTruth = new HashMap<>();
+ final HashMap<Integer, Integer> groundTruth = new HashMap<>();
- rnd.setSeed(seed);
- for (int i = 0; i < numElements; i++) {
- Integer key = rnd.nextInt();
- Integer value = rnd.nextInt();
+ rnd.setSeed(seed);
+ for (int i = 0; i < numElements; i++) {
+ Integer key = rnd.nextInt();
+ Integer value = rnd.nextInt();
- if (rnd.nextBoolean()) {
- groundTruth.put(key, value);
- map.put(key, value);
- }
+ if (rnd.nextBoolean()) {
+ groundTruth.put(key, value);
+ map.put(key, value);
}
+ }
- rnd.setSeed(seed);
- for (int i = 0; i < numElements; i++) {
- Integer key = rnd.nextInt();
-
- // skip these, evaluating it is tricky due to duplicates
- rnd.nextInt();
- rnd.nextBoolean();
-
- Integer expected = groundTruth.get(key);
- if (expected == null) {
- assertNull(map.get(key));
- } else {
- Integer contained = map.get(key);
- assertNotNull(contained);
- assertEquals(expected, contained);
- }
+ rnd.setSeed(seed);
+ for (int i = 0; i < numElements; i++) {
+ Integer key = rnd.nextInt();
+
+ // skip these, evaluating it is tricky due to duplicates
+ rnd.nextInt();
+ rnd.nextBoolean();
+
+ Integer expected = groundTruth.get(key);
+ if (expected == null) {
+ assertThat(map.get(key)).isNull();
+ } else {
+ Integer contained = map.get(key);
+ assertThat(contained).isNotNull().isEqualTo(expected);
}
- } catch (Exception e) {
- e.printStackTrace();
- fail(e.getMessage());
}
}
@Test
- public void testConjunctTraversal() {
- try {
- final Random rootRnd = new Random(654685486325439L);
-
- final int numMaps = 7;
- final int numKeys = 1000000;
+ void testConjunctTraversal() throws Exception {
+ final Random rootRnd = new Random(654685486325439L);
+
+ final int numMaps = 7;
+ final int numKeys = 1000000;
+
+ // ------ create a set of maps ------
+ @SuppressWarnings("unchecked")
+ final KeyMap<Integer, Integer>[] maps =
+ (KeyMap<Integer, Integer>[]) new KeyMap<?, ?>[numMaps];
+ for (int i = 0; i < numMaps; i++) {
+ maps[i] = new KeyMap<>();
+ }
- // ------ create a set of maps ------
- @SuppressWarnings("unchecked")
- final KeyMap<Integer, Integer>[] maps =
- (KeyMap<Integer, Integer>[]) new KeyMap<?, ?>[numMaps];
- for (int i = 0; i < numMaps; i++) {
- maps[i] = new KeyMap<>();
+ // ------ prepare probabilities for maps ------
+ final double[] probabilities = new double[numMaps];
+ final double[] probabilitiesTemp = new double[numMaps];
+ {
+ probabilities[0] = 0.5;
+ double remainingProb = 1.0 - probabilities[0];
+ for (int i = 1; i < numMaps - 1; i++) {
+ remainingProb /= 2;
+ probabilities[i] = remainingProb;
}
- // ------ prepare probabilities for maps ------
- final double[] probabilities = new double[numMaps];
- final double[] probabilitiesTemp = new double[numMaps];
- {
- probabilities[0] = 0.5;
- double remainingProb = 1.0 - probabilities[0];
- for (int i = 1; i < numMaps - 1; i++) {
- remainingProb /= 2;
- probabilities[i] = remainingProb;
- }
+ // compensate for rounding errors
+ probabilities[numMaps - 1] = remainingProb;
+ }
- // compensate for rounding errors
- probabilities[numMaps - 1] = remainingProb;
- }
+ // ------ generate random elements ------
+ final long probSeed = rootRnd.nextLong();
+ final long keySeed = rootRnd.nextLong();
- // ------ generate random elements ------
- final long probSeed = rootRnd.nextLong();
- final long keySeed = rootRnd.nextLong();
+ final Random probRnd = new Random(probSeed);
+ final Random keyRnd = new Random(keySeed);
- final Random probRnd = new Random(probSeed);
- final Random keyRnd = new Random(keySeed);
+ final int maxStride = Integer.MAX_VALUE / numKeys;
- final int maxStride = Integer.MAX_VALUE / numKeys;
+ int totalNumElements = 0;
+ int nextKeyValue = 1;
- int totalNumElements = 0;
- int nextKeyValue = 1;
+ for (int i = 0; i < numKeys; i++) {
+ int numCopies = (nextKeyValue % 3) + 1;
+ System.arraycopy(probabilities, 0, probabilitiesTemp, 0, numMaps);
- for (int i = 0; i < numKeys; i++) {
- int numCopies = (nextKeyValue % 3) + 1;
- System.arraycopy(probabilities, 0, probabilitiesTemp, 0, numMaps);
+ double totalProb = 1.0;
+ for (int copy = 0; copy < numCopies; copy++) {
+ int pos = drawPosProportionally(probabilitiesTemp, totalProb, probRnd);
+ totalProb -= probabilitiesTemp[pos];
+ probabilitiesTemp[pos] = 0.0;
- double totalProb = 1.0;
- for (int copy = 0; copy < numCopies; copy++) {
- int pos = drawPosProportionally(probabilitiesTemp, totalProb, probRnd);
- totalProb -= probabilitiesTemp[pos];
- probabilitiesTemp[pos] = 0.0;
+ Integer boxed = nextKeyValue;
+ Integer previous = maps[pos].put(boxed, boxed);
+ assertThat(previous).as("Test problem - test does not assign unique maps").isNull();
+ }
- Integer boxed = nextKeyValue;
- Integer previous = maps[pos].put(boxed, boxed);
- assertNull("Test problem - test does not assign unique maps", previous);
- }
+ totalNumElements += numCopies;
+ nextKeyValue += keyRnd.nextInt(maxStride) + 1;
+ }
- totalNumElements += numCopies;
- nextKeyValue += keyRnd.nextInt(maxStride) + 1;
+ // check that all maps contain the total number of elements
+ int numContained = 0;
+ for (KeyMap<?, ?> map : maps) {
+ numContained += map.size();
+ }
+ assertThat(numContained).isEqualTo(totalNumElements);
+
+ // ------ check that all elements can be found in the maps ------
+ keyRnd.setSeed(keySeed);
+
+ numContained = 0;
+ nextKeyValue = 1;
+ for (int i = 0; i < numKeys; i++) {
+ int numCopiesExpected = (nextKeyValue % 3) + 1;
+ int numCopiesContained = 0;
+
+ for (KeyMap<Integer, Integer> map : maps) {
+ Integer val = map.get(nextKeyValue);
+ if (val != null) {
+ assertThat(val).isEqualTo(nextKeyValue);
+ numCopiesContained++;
+ }
}
- // check that all maps contain the total number of elements
- int numContained = 0;
- for (KeyMap<?, ?> map : maps) {
- numContained += map.size();
- }
- assertEquals(totalNumElements, numContained);
-
- // ------ check that all elements can be found in the maps ------
- keyRnd.setSeed(keySeed);
-
- numContained = 0;
- nextKeyValue = 1;
- for (int i = 0; i < numKeys; i++) {
- int numCopiesExpected = (nextKeyValue % 3) + 1;
- int numCopiesContained = 0;
-
- for (KeyMap<Integer, Integer> map : maps) {
- Integer val = map.get(nextKeyValue);
- if (val != null) {
- assertEquals(nextKeyValue, val.intValue());
- numCopiesContained++;
+ assertThat(numCopiesContained).isEqualTo(numCopiesExpected);
+ numContained += numCopiesContained;
+
+ nextKeyValue += keyRnd.nextInt(maxStride) + 1;
+ }
+ assertThat(numContained).isEqualTo(totalNumElements);
+
+ // ------ make a traversal over all keys and validate the keys in the traversal ------
+ final int[] keysStartedAndFinished = {0, 0};
+ KeyMap.TraversalEvaluator<Integer, Integer> traversal =
+ new KeyMap.TraversalEvaluator<Integer, Integer>() {
+
+ private int key;
+ private int valueCount;
+
+ @Override
+ public void startNewKey(Integer key) {
+ this.key = key;
+ this.valueCount = 0;
+
+ keysStartedAndFinished[0]++;
}
- }
- assertEquals(numCopiesExpected, numCopiesContained);
- numContained += numCopiesContained;
+ @Override
+ public void nextValue(Integer value) {
+ assertThat(value).isEqualTo(this.key);
+ this.valueCount++;
+ }
- nextKeyValue += keyRnd.nextInt(maxStride) + 1;
- }
- assertEquals(totalNumElements, numContained);
-
- // ------ make a traversal over all keys and validate the keys in the traversal ------
- final int[] keysStartedAndFinished = {0, 0};
- KeyMap.TraversalEvaluator<Integer, Integer> traversal =
- new KeyMap.TraversalEvaluator<Integer, Integer>() {
-
- private int key;
- private int valueCount;
-
- @Override
- public void startNewKey(Integer key) {
- this.key = key;
- this.valueCount = 0;
-
- keysStartedAndFinished[0]++;
- }
-
- @Override
- public void nextValue(Integer value) {
- assertEquals(this.key, value.intValue());
- this.valueCount++;
- }
-
- @Override
- public void keyDone() {
- int expected = (key % 3) + 1;
- if (expected != valueCount) {
- fail(
+ @Override
+ public void keyDone() {
+ int expected = (key % 3) + 1;
+ assertThat(valueCount)
+ .as(
"Wrong count for key "
+ key
+ " ; expected="
+ expected
+ " , count="
- + valueCount);
- }
+ + valueCount)
+ .isEqualTo(expected);
- keysStartedAndFinished[1]++;
- }
- };
+ keysStartedAndFinished[1]++;
+ }
+ };
- KeyMap.traverseMaps(shuffleArray(maps, rootRnd), traversal, 17);
+ KeyMap.traverseMaps(shuffleArray(maps, rootRnd), traversal, 17);
- assertEquals(numKeys, keysStartedAndFinished[0]);
- assertEquals(numKeys, keysStartedAndFinished[1]);
- } catch (Exception e) {
- e.printStackTrace();
- fail(e.getMessage());
- }
+ assertThat(keysStartedAndFinished[0]).isEqualTo(numKeys);
+ assertThat(keysStartedAndFinished[1]).isEqualTo(numKeys);
}
@Test
- public void testSizeComparator() {
- try {
- KeyMap<String, String> map1 = new KeyMap<>(5);
- KeyMap<String, String> map2 = new KeyMap<>(80);
-
- assertTrue(map1.getCurrentTableCapacity() < map2.getCurrentTableCapacity());
-
- assertTrue(KeyMap.CapacityDescendingComparator.INSTANCE.compare(map1, map1) == 0);
- assertTrue(KeyMap.CapacityDescendingComparator.INSTANCE.compare(map2, map2) == 0);
- assertTrue(KeyMap.CapacityDescendingComparator.INSTANCE.compare(map1, map2) > 0);
- assertTrue(KeyMap.CapacityDescendingComparator.INSTANCE.compare(map2, map1) < 0);
- } catch (Exception e) {
- e.printStackTrace();
- fail(e.getMessage());
- }
+ void testSizeComparator() {
+ KeyMap<String, String> map1 = new KeyMap<>(5);
+ KeyMap<String, String> map2 = new KeyMap<>(80);
+
+ assertThat(map1.getCurrentTableCapacity()).isLessThan(map2.getCurrentTableCapacity());
+
+ assertThat(KeyMap.CapacityDescendingComparator.INSTANCE.compare(map1, map1)).isZero();
+ assertThat(KeyMap.CapacityDescendingComparator.INSTANCE.compare(map2, map2)).isZero();
+ assertThat(KeyMap.CapacityDescendingComparator.INSTANCE.compare(map1, map2)).isPositive();
+ assertThat(KeyMap.CapacityDescendingComparator.INSTANCE.compare(map2, map1)).isNegative();
}
// ------------------------------------------------------------------------
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/MergingWindowSetTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/MergingWindowSetTest.java
index 542eef60eb9..1db617abdbc 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/MergingWindowSetTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/MergingWindowSetTest.java
@@ -32,7 +32,7 @@ import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.shaded.guava31.com.google.common.collect.Lists;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import org.mockito.Matchers;
import java.util.ArrayList;
@@ -41,17 +41,7 @@ import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import static org.hamcrest.CoreMatchers.anyOf;
-import static org.hamcrest.CoreMatchers.hasItem;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsNot.not;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -62,7 +52,7 @@ import static org.mockito.Mockito.when;
* Tests for verifying that {@link MergingWindowSet} correctly merges windows in various situations
* and that the merge callback is called with the correct sets of windows.
*/
-public class MergingWindowSetTest {
+class MergingWindowSetTest {
/**
* This test uses a special (misbehaving) {@code MergingWindowAssigner} that produces cases
@@ -70,7 +60,7 @@ public class MergingWindowSetTest {
* the merging window set is nevertheless correct and contains all added windows.
*/
@Test
- public void testNonEagerMerging() throws Exception {
+ void testNonEagerMerging() throws Exception {
@SuppressWarnings("unchecked")
ListState<Tuple2<TimeWindow, TimeWindow>> mockState = mock(ListState.class);
@@ -83,23 +73,23 @@ public class MergingWindowSetTest {
mergeFunction.reset();
result = windowSet.addWindow(new TimeWindow(0, 2), mergeFunction);
- assertNotNull(windowSet.getStateWindow(result));
+ assertThat(windowSet.getStateWindow(result)).isNotNull();
mergeFunction.reset();
result = windowSet.addWindow(new TimeWindow(2, 5), mergeFunction);
- assertNotNull(windowSet.getStateWindow(result));
+ assertThat(windowSet.getStateWindow(result)).isNotNull();
mergeFunction.reset();
result = windowSet.addWindow(new TimeWindow(1, 2), mergeFunction);
- assertNotNull(windowSet.getStateWindow(result));
+ assertThat(windowSet.getStateWindow(result)).isNotNull();
mergeFunction.reset();
result = windowSet.addWindow(new TimeWindow(10, 12), mergeFunction);
- assertNotNull(windowSet.getStateWindow(result));
+ assertThat(windowSet.getStateWindow(result)).isNotNull();
}
@Test
- public void testIncrementalMerging() throws Exception {
+ void testIncrementalMerging() throws Exception {
@SuppressWarnings("unchecked")
ListState<Tuple2<TimeWindow, TimeWindow>> mockState = mock(ListState.class);
@@ -111,110 +101,113 @@ public class MergingWindowSetTest {
// add initial window
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 4), windowSet.addWindow(new TimeWindow(0, 4), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(0, 4), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 4));
+ assertThat(mergeFunction.hasMerged()).isFalse();
- assertTrue(windowSet.getStateWindow(new TimeWindow(0, 4)).equals(new TimeWindow(0, 4)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 4))).isEqualTo(new TimeWindow(0, 4));
// add some more windows
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 4), windowSet.addWindow(new TimeWindow(0, 4), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(0, 4), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 4));
+ assertThat(mergeFunction.hasMerged()).isFalse();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 5), windowSet.addWindow(new TimeWindow(3, 5), mergeFunction));
- assertTrue(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(0, 5), mergeFunction.mergeTarget());
- assertEquals(new TimeWindow(0, 4), mergeFunction.stateWindow());
- assertThat(mergeFunction.mergeSources(), containsInAnyOrder(new TimeWindow(0, 4)));
- assertTrue(mergeFunction.mergedStateWindows().isEmpty());
+ assertThat(windowSet.addWindow(new TimeWindow(3, 5), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 5));
+ assertThat(mergeFunction.hasMerged()).isTrue();
+ assertThat(mergeFunction.mergeTarget()).isEqualTo(new TimeWindow(0, 5));
+ assertThat(mergeFunction.stateWindow()).isEqualTo(new TimeWindow(0, 4));
+ assertThat(mergeFunction.mergeSources()).containsExactly(new TimeWindow(0, 4));
+ assertThat(mergeFunction.mergedStateWindows()).isEmpty();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 6), windowSet.addWindow(new TimeWindow(4, 6), mergeFunction));
- assertTrue(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(0, 6), mergeFunction.mergeTarget());
- assertEquals(new TimeWindow(0, 4), mergeFunction.stateWindow());
- assertThat(mergeFunction.mergeSources(), containsInAnyOrder(new TimeWindow(0, 5)));
- assertTrue(mergeFunction.mergedStateWindows().isEmpty());
+ assertThat(windowSet.addWindow(new TimeWindow(4, 6), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 6));
+ assertThat(mergeFunction.hasMerged()).isTrue();
+ assertThat(mergeFunction.mergeTarget()).isEqualTo(new TimeWindow(0, 6));
+ assertThat(mergeFunction.stateWindow()).isEqualTo(new TimeWindow(0, 4));
+ assertThat(mergeFunction.mergeSources()).containsExactly(new TimeWindow(0, 5));
+ assertThat(mergeFunction.mergedStateWindows()).isEmpty();
- assertEquals(new TimeWindow(0, 4), windowSet.getStateWindow(new TimeWindow(0, 6)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 6))).isEqualTo(new TimeWindow(0, 4));
// add some windows that falls into the already merged region
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 6), windowSet.addWindow(new TimeWindow(1, 4), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(1, 4), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 6));
+ assertThat(mergeFunction.hasMerged()).isFalse();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 6), windowSet.addWindow(new TimeWindow(0, 4), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(0, 4), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 6));
+ assertThat(mergeFunction.hasMerged()).isFalse();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 6), windowSet.addWindow(new TimeWindow(3, 5), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(3, 5), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 6));
+ assertThat(mergeFunction.hasMerged()).isFalse();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 6), windowSet.addWindow(new TimeWindow(4, 6), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(4, 6), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 6));
+ assertThat(mergeFunction.hasMerged()).isFalse();
- assertEquals(new TimeWindow(0, 4), windowSet.getStateWindow(new TimeWindow(0, 6)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 6))).isEqualTo(new TimeWindow(0, 4));
// add some more windows that don't merge with the first bunch
mergeFunction.reset();
- assertEquals(
- new TimeWindow(11, 14), windowSet.addWindow(new TimeWindow(11, 14), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(11, 14), mergeFunction))
+ .isEqualTo(new TimeWindow(11, 14));
+ assertThat(mergeFunction.hasMerged()).isFalse();
- assertEquals(new TimeWindow(0, 4), windowSet.getStateWindow(new TimeWindow(0, 6)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 6))).isEqualTo(new TimeWindow(0, 4));
- assertEquals(new TimeWindow(11, 14), windowSet.getStateWindow(new TimeWindow(11, 14)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(11, 14)))
+ .isEqualTo(new TimeWindow(11, 14));
// add some more windows that merge with the second bunch
mergeFunction.reset();
- assertEquals(
- new TimeWindow(10, 14), windowSet.addWindow(new TimeWindow(10, 13), mergeFunction));
- assertTrue(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(10, 14), mergeFunction.mergeTarget());
- assertEquals(new TimeWindow(11, 14), mergeFunction.stateWindow());
- assertThat(mergeFunction.mergeSources(), containsInAnyOrder(new TimeWindow(11, 14)));
- assertTrue(mergeFunction.mergedStateWindows().isEmpty());
+ assertThat(windowSet.addWindow(new TimeWindow(10, 13), mergeFunction))
+ .isEqualTo(new TimeWindow(10, 14));
+ assertThat(mergeFunction.hasMerged()).isTrue();
+ assertThat(mergeFunction.mergeTarget()).isEqualTo(new TimeWindow(10, 14));
+ assertThat(mergeFunction.stateWindow()).isEqualTo(new TimeWindow(11, 14));
+ assertThat(mergeFunction.mergeSources()).containsExactly(new TimeWindow(11, 14));
+ assertThat(mergeFunction.mergedStateWindows()).isEmpty();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(10, 15), windowSet.addWindow(new TimeWindow(12, 15), mergeFunction));
- assertTrue(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(10, 15), mergeFunction.mergeTarget());
- assertEquals(new TimeWindow(11, 14), mergeFunction.stateWindow());
- assertThat(mergeFunction.mergeSources(), containsInAnyOrder(new TimeWindow(10, 14)));
- assertTrue(mergeFunction.mergedStateWindows().isEmpty());
+ assertThat(windowSet.addWindow(new TimeWindow(12, 15), mergeFunction))
+ .isEqualTo(new TimeWindow(10, 15));
+ assertThat(mergeFunction.hasMerged()).isTrue();
+ assertThat(mergeFunction.mergeTarget()).isEqualTo(new TimeWindow(10, 15));
+ assertThat(mergeFunction.stateWindow()).isEqualTo(new TimeWindow(11, 14));
+ assertThat(mergeFunction.mergeSources()).containsExactly(new TimeWindow(10, 14));
+ assertThat(mergeFunction.mergedStateWindows()).isEmpty();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(10, 15), windowSet.addWindow(new TimeWindow(11, 14), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(11, 14), mergeFunction))
+ .isEqualTo(new TimeWindow(10, 15));
+ assertThat(mergeFunction.hasMerged()).isFalse();
- assertEquals(new TimeWindow(0, 4), windowSet.getStateWindow(new TimeWindow(0, 6)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 6))).isEqualTo(new TimeWindow(0, 4));
- assertEquals(new TimeWindow(11, 14), windowSet.getStateWindow(new TimeWindow(10, 15)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(10, 15)))
+ .isEqualTo(new TimeWindow(11, 14));
// retire the first batch of windows
windowSet.retireWindow(new TimeWindow(0, 6));
- assertTrue(windowSet.getStateWindow(new TimeWindow(0, 6)) == null);
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 6))).isNull();
- assertTrue(windowSet.getStateWindow(new TimeWindow(10, 15)).equals(new TimeWindow(11, 14)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(10, 15)))
+ .isEqualTo(new TimeWindow(11, 14));
}
@Test
- public void testLateMerging() throws Exception {
+ void testLateMerging() throws Exception {
@SuppressWarnings("unchecked")
ListState<Tuple2<TimeWindow, TimeWindow>> mockState = mock(ListState.class);
@@ -227,97 +220,92 @@ public class MergingWindowSetTest {
// add several non-overlapping initial windows
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 3), windowSet.addWindow(new TimeWindow(0, 3), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(0, 3), windowSet.getStateWindow(new TimeWindow(0, 3)));
+ assertThat(windowSet.addWindow(new TimeWindow(0, 3), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 3));
+ assertThat(mergeFunction.hasMerged()).isFalse();
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 3))).isEqualTo(new TimeWindow(0, 3));
mergeFunction.reset();
- assertEquals(
- new TimeWindow(5, 8), windowSet.addWindow(new TimeWindow(5, 8), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(5, 8), windowSet.getStateWindow(new TimeWindow(5, 8)));
+ assertThat(windowSet.addWindow(new TimeWindow(5, 8), mergeFunction))
+ .isEqualTo(new TimeWindow(5, 8));
+ assertThat(mergeFunction.hasMerged()).isFalse();
+ assertThat(windowSet.getStateWindow(new TimeWindow(5, 8))).isEqualTo(new TimeWindow(5, 8));
mergeFunction.reset();
- assertEquals(
- new TimeWindow(10, 13), windowSet.addWindow(new TimeWindow(10, 13), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(10, 13), windowSet.getStateWindow(new TimeWindow(10, 13)));
+ assertThat(windowSet.addWindow(new TimeWindow(10, 13), mergeFunction))
+ .isEqualTo(new TimeWindow(10, 13));
+ assertThat(mergeFunction.hasMerged()).isFalse();
+ assertThat(windowSet.getStateWindow(new TimeWindow(10, 13)))
+ .isEqualTo(new TimeWindow(10, 13));
// add a window that merges the later two windows
mergeFunction.reset();
- assertEquals(
- new TimeWindow(5, 13), windowSet.addWindow(new TimeWindow(8, 10), mergeFunction));
- assertTrue(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(5, 13), mergeFunction.mergeTarget());
- assertThat(
- mergeFunction.stateWindow(),
- anyOf(is(new TimeWindow(5, 8)), is(new TimeWindow(10, 13))));
- assertThat(
- mergeFunction.mergeSources(),
- containsInAnyOrder(new TimeWindow(5, 8), new TimeWindow(10, 13)));
- assertThat(
- mergeFunction.mergedStateWindows(),
- anyOf(
- containsInAnyOrder(new TimeWindow(10, 13)),
- containsInAnyOrder(new TimeWindow(5, 8))));
- assertThat(mergeFunction.mergedStateWindows(), not(hasItem(mergeFunction.mergeTarget())));
+ assertThat(windowSet.addWindow(new TimeWindow(8, 10), mergeFunction))
+ .isEqualTo(new TimeWindow(5, 13));
+ assertThat(mergeFunction.hasMerged()).isTrue();
+ assertThat(mergeFunction.mergeTarget()).isEqualTo(new TimeWindow(5, 13));
+ assertThat(mergeFunction.stateWindow())
+ .satisfiesAnyOf(
+ w -> assertThat(w).isEqualTo(new TimeWindow(5, 8)),
+ w -> assertThat(w).isEqualTo(new TimeWindow(10, 13)));
+ assertThat(mergeFunction.mergeSources())
+ .containsExactlyInAnyOrder(new TimeWindow(5, 8), new TimeWindow(10, 13));
+ assertThat(mergeFunction.mergedStateWindows())
+ .containsAnyOf(new TimeWindow(5, 8), new TimeWindow(10, 13));
- assertEquals(new TimeWindow(0, 3), windowSet.getStateWindow(new TimeWindow(0, 3)));
+ assertThat(mergeFunction.mergedStateWindows().toArray())
+ .satisfiesAnyOf(
+ o -> assertThat(o).containsExactly(new TimeWindow(10, 13)),
+ o -> assertThat(o).containsExactly(new TimeWindow(5, 8)));
+
+ assertThat(mergeFunction.mergedStateWindows()).doesNotContain(mergeFunction.mergeTarget());
+
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 3))).isEqualTo(new TimeWindow(0, 3));
mergeFunction.reset();
- assertEquals(
- new TimeWindow(5, 13), windowSet.addWindow(new TimeWindow(5, 8), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(5, 8), mergeFunction))
+ .isEqualTo(new TimeWindow(5, 13));
+ assertThat(mergeFunction.hasMerged()).isFalse();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(5, 13), windowSet.addWindow(new TimeWindow(8, 10), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(8, 10), mergeFunction))
+ .isEqualTo(new TimeWindow(5, 13));
+ assertThat(mergeFunction.hasMerged()).isFalse();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(5, 13), windowSet.addWindow(new TimeWindow(10, 13), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
+ assertThat(windowSet.addWindow(new TimeWindow(10, 13), mergeFunction))
+ .isEqualTo(new TimeWindow(5, 13));
+ assertThat(mergeFunction.hasMerged()).isFalse();
- assertThat(
- windowSet.getStateWindow(new TimeWindow(5, 13)),
- anyOf(is(new TimeWindow(5, 8)), is(new TimeWindow(10, 13))));
+ assertThat(windowSet.getStateWindow(new TimeWindow(5, 13)))
+ .isIn(new TimeWindow(5, 8), new TimeWindow(10, 13));
// add a window that merges all of them together
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 13), windowSet.addWindow(new TimeWindow(3, 5), mergeFunction));
- assertTrue(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(0, 13), mergeFunction.mergeTarget());
- assertThat(
- mergeFunction.stateWindow(),
- anyOf(
- is(new TimeWindow(0, 3)),
- is(new TimeWindow(5, 8)),
- is(new TimeWindow(10, 13))));
- assertThat(
- mergeFunction.mergeSources(),
- containsInAnyOrder(new TimeWindow(0, 3), new TimeWindow(5, 13)));
- assertThat(
- mergeFunction.mergedStateWindows(),
- anyOf(
- containsInAnyOrder(new TimeWindow(0, 3)),
- containsInAnyOrder(new TimeWindow(5, 8)),
- containsInAnyOrder(new TimeWindow(10, 13))));
- assertThat(mergeFunction.mergedStateWindows(), not(hasItem(mergeFunction.mergeTarget())));
-
- assertThat(
- windowSet.getStateWindow(new TimeWindow(0, 13)),
- anyOf(
- is(new TimeWindow(0, 3)),
- is(new TimeWindow(5, 8)),
- is(new TimeWindow(10, 13))));
+ assertThat(windowSet.addWindow(new TimeWindow(3, 5), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 13));
+ assertThat(mergeFunction.hasMerged()).isTrue();
+ assertThat(mergeFunction.mergeTarget()).isEqualTo(new TimeWindow(0, 13));
+ assertThat(mergeFunction.stateWindow())
+ .isIn(new TimeWindow(0, 3), new TimeWindow(5, 8), new TimeWindow(10, 13));
+
+ assertThat(mergeFunction.mergeSources())
+ .containsExactlyInAnyOrder(new TimeWindow(0, 3), new TimeWindow(5, 13));
+
+ assertThat(mergeFunction.mergedStateWindows().toArray())
+ .satisfiesAnyOf(
+ o -> assertThat(o).containsExactly(new TimeWindow(0, 3)),
+ o -> assertThat(o).containsExactly(new TimeWindow(5, 8)),
+ o -> assertThat(o).containsExactly(new TimeWindow(10, 13)));
+
+ assertThat(mergeFunction.mergedStateWindows()).doesNotContain(mergeFunction.mergeTarget());
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 13)))
+ .isIn(new TimeWindow(0, 3), new TimeWindow(5, 8), new TimeWindow(10, 13));
}
/** Test merging of a large new window that covers one existing windows. */
@Test
- public void testMergeLargeWindowCoveringSingleWindow() throws Exception {
+ void testMergeLargeWindowCoveringSingleWindow() throws Exception {
@SuppressWarnings("unchecked")
ListState<Tuple2<TimeWindow, TimeWindow>> mockState = mock(ListState.class);
@@ -330,18 +318,18 @@ public class MergingWindowSetTest {
// add an initial small window
mergeFunction.reset();
- assertEquals(
- new TimeWindow(1, 2), windowSet.addWindow(new TimeWindow(1, 2), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(1, 2), windowSet.getStateWindow(new TimeWindow(1, 2)));
+ assertThat(windowSet.addWindow(new TimeWindow(1, 2), mergeFunction))
+ .isEqualTo(new TimeWindow(1, 2));
+ assertThat(mergeFunction.hasMerged()).isFalse();
+ assertThat(windowSet.getStateWindow(new TimeWindow(1, 2))).isEqualTo(new TimeWindow(1, 2));
// add a new window that completely covers the existing window
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 3), windowSet.addWindow(new TimeWindow(0, 3), mergeFunction));
- assertTrue(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(1, 2), windowSet.getStateWindow(new TimeWindow(0, 3)));
+ assertThat(windowSet.addWindow(new TimeWindow(0, 3), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 3));
+ assertThat(mergeFunction.hasMerged()).isTrue();
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 3))).isEqualTo(new TimeWindow(1, 2));
}
/**
@@ -349,7 +337,7 @@ public class MergingWindowSetTest {
* merge.
*/
@Test
- public void testAddingIdenticalWindows() throws Exception {
+ void testAddingIdenticalWindows() throws Exception {
@SuppressWarnings("unchecked")
ListState<Tuple2<TimeWindow, TimeWindow>> mockState = mock(ListState.class);
@@ -360,21 +348,21 @@ public class MergingWindowSetTest {
TestingMergeFunction mergeFunction = new TestingMergeFunction();
mergeFunction.reset();
- assertEquals(
- new TimeWindow(1, 2), windowSet.addWindow(new TimeWindow(1, 2), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(1, 2), windowSet.getStateWindow(new TimeWindow(1, 2)));
+ assertThat(windowSet.addWindow(new TimeWindow(1, 2), mergeFunction))
+ .isEqualTo(new TimeWindow(1, 2));
+ assertThat(mergeFunction.hasMerged()).isFalse();
+ assertThat(windowSet.getStateWindow(new TimeWindow(1, 2))).isEqualTo(new TimeWindow(1, 2));
mergeFunction.reset();
- assertEquals(
- new TimeWindow(1, 2), windowSet.addWindow(new TimeWindow(1, 2), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(1, 2), windowSet.getStateWindow(new TimeWindow(1, 2)));
+ assertThat(windowSet.addWindow(new TimeWindow(1, 2), mergeFunction))
+ .isEqualTo(new TimeWindow(1, 2));
+ assertThat(mergeFunction.hasMerged()).isFalse();
+ assertThat(windowSet.getStateWindow(new TimeWindow(1, 2))).isEqualTo(new TimeWindow(1, 2));
}
/** Test merging of a large new window that covers multiple existing windows. */
@Test
- public void testMergeLargeWindowCoveringMultipleWindows() throws Exception {
+ void testMergeLargeWindowCoveringMultipleWindows() throws Exception {
@SuppressWarnings("unchecked")
ListState<Tuple2<TimeWindow, TimeWindow>> mockState = mock(ListState.class);
@@ -387,45 +375,52 @@ public class MergingWindowSetTest {
// add several non-overlapping initial windows
mergeFunction.reset();
- assertEquals(
- new TimeWindow(1, 3), windowSet.addWindow(new TimeWindow(1, 3), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(1, 3), windowSet.getStateWindow(new TimeWindow(1, 3)));
+ assertThat(windowSet.addWindow(new TimeWindow(1, 3), mergeFunction))
+ .isEqualTo(new TimeWindow(1, 3));
+ assertThat(mergeFunction.hasMerged()).isFalse();
+ assertThat(windowSet.getStateWindow(new TimeWindow(1, 3))).isEqualTo(new TimeWindow(1, 3));
mergeFunction.reset();
- assertEquals(
- new TimeWindow(5, 8), windowSet.addWindow(new TimeWindow(5, 8), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(5, 8), windowSet.getStateWindow(new TimeWindow(5, 8)));
+ assertThat(windowSet.addWindow(new TimeWindow(5, 8), mergeFunction))
+ .isEqualTo(new TimeWindow(5, 8));
+ assertThat(mergeFunction.hasMerged()).isFalse();
+ assertThat(windowSet.getStateWindow(new TimeWindow(5, 8))).isEqualTo(new TimeWindow(5, 8));
mergeFunction.reset();
- assertEquals(
- new TimeWindow(10, 13), windowSet.addWindow(new TimeWindow(10, 13), mergeFunction));
- assertFalse(mergeFunction.hasMerged());
- assertEquals(new TimeWindow(10, 13), windowSet.getStateWindow(new TimeWindow(10, 13)));
+ assertThat(windowSet.addWindow(new TimeWindow(10, 13), mergeFunction))
+ .isEqualTo(new TimeWindow(10, 13));
+ assertThat(mergeFunction.hasMerged()).isFalse();
+ assertThat(windowSet.getStateWindow(new TimeWindow(10, 13)))
+ .isEqualTo(new TimeWindow(10, 13));
// add a new window that completely covers the existing windows
mergeFunction.reset();
- assertEquals(
- new TimeWindow(0, 13), windowSet.addWindow(new TimeWindow(0, 13), mergeFunction));
- assertTrue(mergeFunction.hasMerged());
- assertThat(
- mergeFunction.mergedStateWindows(),
- anyOf(
- containsInAnyOrder(new TimeWindow(0, 3), new TimeWindow(5, 8)),
- containsInAnyOrder(new TimeWindow(0, 3), new TimeWindow(10, 13)),
- containsInAnyOrder(new TimeWindow(5, 8), new TimeWindow(10, 13))));
- assertThat(
- windowSet.getStateWindow(new TimeWindow(0, 13)),
- anyOf(
- is(new TimeWindow(1, 3)),
- is(new TimeWindow(5, 8)),
- is(new TimeWindow(10, 13))));
+ assertThat(windowSet.addWindow(new TimeWindow(0, 13), mergeFunction))
+ .isEqualTo(new TimeWindow(0, 13));
+ assertThat(mergeFunction.hasMerged()).isTrue();
+
+ assertThat(mergeFunction.mergedStateWindows().toArray())
+ .satisfiesAnyOf(
+ o ->
+ assertThat(o)
+ .containsExactlyInAnyOrder(
+ new TimeWindow(0, 3), new TimeWindow(5, 8)),
+ o ->
+ assertThat(o)
+ .containsExactlyInAnyOrder(
+ new TimeWindow(0, 3), new TimeWindow(10, 13)),
+ o ->
+ assertThat(o)
+ .containsExactlyInAnyOrder(
+ new TimeWindow(5, 8), new TimeWindow(10, 13)));
+
+ assertThat(windowSet.getStateWindow(new TimeWindow(0, 13)))
+ .isIn(new TimeWindow(1, 3), new TimeWindow(5, 8), new TimeWindow(10, 13));
}
@Test
- public void testRestoreFromState() throws Exception {
+ void testRestoreFromState() throws Exception {
@SuppressWarnings("unchecked")
ListState<Tuple2<TimeWindow, TimeWindow>> mockState = mock(ListState.class);
when(mockState.get())
@@ -438,12 +433,13 @@ public class MergingWindowSetTest {
new MergingWindowSet<>(
EventTimeSessionWindows.withGap(Time.milliseconds(3)), mockState);
- assertEquals(new TimeWindow(42, 17), windowSet.getStateWindow(new TimeWindow(17, 42)));
- assertEquals(new TimeWindow(3, 4), windowSet.getStateWindow(new TimeWindow(1, 2)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(17, 42)))
+ .isEqualTo(new TimeWindow(42, 17));
+ assertThat(windowSet.getStateWindow(new TimeWindow(1, 2))).isEqualTo(new TimeWindow(3, 4));
}
@Test
- public void testPersist() throws Exception {
+ void testPersist() throws Exception {
@SuppressWarnings("unchecked")
ListState<Tuple2<TimeWindow, TimeWindow>> mockState = mock(ListState.class);
@@ -456,8 +452,9 @@ public class MergingWindowSetTest {
windowSet.addWindow(new TimeWindow(1, 2), mergeFunction);
windowSet.addWindow(new TimeWindow(17, 42), mergeFunction);
- assertEquals(new TimeWindow(1, 2), windowSet.getStateWindow(new TimeWindow(1, 2)));
- assertEquals(new TimeWindow(17, 42), windowSet.getStateWindow(new TimeWindow(17, 42)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(1, 2))).isEqualTo(new TimeWindow(1, 2));
+ assertThat(windowSet.getStateWindow(new TimeWindow(17, 42)))
+ .isEqualTo(new TimeWindow(17, 42));
windowSet.persist();
@@ -476,7 +473,7 @@ public class MergingWindowSetTest {
}
@Test
- public void testPersistOnlyIfHaveUpdates() throws Exception {
+ void testPersistOnlyIfHaveUpdates() throws Exception {
@SuppressWarnings("unchecked")
ListState<Tuple2<TimeWindow, TimeWindow>> mockState = mock(ListState.class);
when(mockState.get())
@@ -489,8 +486,9 @@ public class MergingWindowSetTest {
new MergingWindowSet<>(
EventTimeSessionWindows.withGap(Time.milliseconds(3)), mockState);
- assertEquals(new TimeWindow(42, 17), windowSet.getStateWindow(new TimeWindow(17, 42)));
- assertEquals(new TimeWindow(3, 4), windowSet.getStateWindow(new TimeWindow(1, 2)));
+ assertThat(windowSet.getStateWindow(new TimeWindow(17, 42)))
+ .isEqualTo(new TimeWindow(42, 17));
+ assertThat(windowSet.getStateWindow(new TimeWindow(1, 2))).isEqualTo(new TimeWindow(3, 4));
windowSet.persist();
@@ -539,9 +537,9 @@ public class MergingWindowSetTest {
TimeWindow stateWindowResult,
Collection<TimeWindow> mergedStateWindows)
throws Exception {
- if (target != null) {
- fail("More than one merge for adding a Window should not occur.");
- }
+ assertThat(target)
+ .as("More than one merge for adding a Window should not occur.")
+ .isNull();
this.stateWindow = stateWindowResult;
this.target = mergeResult;
this.mergedStateWindows = mergedStateWindows;
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeSessionWindowsTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeSessionWindowsTest.java
index 4702be4384f..4c32ebed60e 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeSessionWindowsTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeSessionWindowsTest.java
@@ -27,25 +27,17 @@ import org.apache.flink.streaming.api.windowing.assigners.WindowAssigner;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.triggers.ProcessingTimeTrigger;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
-import org.apache.flink.util.TestLogger;
import org.apache.flink.shaded.guava31.com.google.common.collect.Lists;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import org.mockito.Matchers;
import java.util.Collection;
-import static org.apache.flink.streaming.util.StreamRecordMatchers.timeWindow;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.Matchers.contains;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
import static org.mockito.Matchers.anyCollection;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
@@ -56,10 +48,10 @@ import static org.mockito.Mockito.when;
import static org.mockito.hamcrest.MockitoHamcrest.argThat;
/** Tests for {@link ProcessingTimeSessionWindows}. */
-public class ProcessingTimeSessionWindowsTest extends TestLogger {
+class ProcessingTimeSessionWindowsTest {
@Test
- public void testWindowAssignment() {
+ void testWindowAssignment() {
WindowAssigner.WindowAssignerContext mockContext =
mock(WindowAssigner.WindowAssignerContext.class);
@@ -67,23 +59,20 @@ public class ProcessingTimeSessionWindowsTest extends TestLogger {
ProcessingTimeSessionWindows.withGap(Time.milliseconds(5000));
when(mockContext.getCurrentProcessingTime()).thenReturn(0L);
- assertThat(
- assigner.assignWindows("String", Long.MIN_VALUE, mockContext),
- contains(timeWindow(0, 5000)));
+ assertThat(assigner.assignWindows("String", Long.MIN_VALUE, mockContext))
+ .containsExactly(new TimeWindow(0, 5000));
when(mockContext.getCurrentProcessingTime()).thenReturn(4999L);
- assertThat(
- assigner.assignWindows("String", Long.MIN_VALUE, mockContext),
- contains(timeWindow(4999, 9999)));
+ assertThat(assigner.assignWindows("String", Long.MIN_VALUE, mockContext))
+ .containsExactly(new TimeWindow(4999, 9999));
when(mockContext.getCurrentProcessingTime()).thenReturn(5000L);
- assertThat(
- assigner.assignWindows("String", Long.MIN_VALUE, mockContext),
- contains(timeWindow(5000, 10000)));
+ assertThat(assigner.assignWindows("String", Long.MIN_VALUE, mockContext))
+ .containsExactly(new TimeWindow(5000, 10000));
}
@Test
- public void testMergeSinglePointWindow() {
+ void testMergeSinglePointWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
@@ -96,7 +85,7 @@ public class ProcessingTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testMergeSingleWindow() {
+ void testMergeSingleWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
@@ -109,7 +98,7 @@ public class ProcessingTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testMergeConsecutiveWindows() {
+ void testMergeConsecutiveWindows() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
@@ -147,7 +136,7 @@ public class ProcessingTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testMergeCoveringWindow() {
+ void testMergeCoveringWindow() {
MergingWindowAssigner.MergeCallback callback =
mock(MergingWindowAssigner.MergeCallback.class);
@@ -182,7 +171,7 @@ public class ProcessingTimeSessionWindowsTest extends TestLogger {
}
@Test
- public void testTimeUnits() {
+ void testTimeUnits() {
// sanity check with one other time unit
WindowAssigner.WindowAssignerContext mockContext =
@@ -192,56 +181,47 @@ public class ProcessingTimeSessionWindowsTest extends TestLogger {
ProcessingTimeSessionWindows.withGap(Time.seconds(5));
when(mockContext.getCurrentProcessingTime()).thenReturn(0L);
- assertThat(
- assigner.assignWindows("String", Long.MIN_VALUE, mockContext),
- contains(timeWindow(0, 5000)));
+ assertThat(assigner.assignWindows("String", Long.MIN_VALUE, mockContext))
+ .containsExactly(new TimeWindow(0, 5000));
when(mockContext.getCurrentProcessingTime()).thenReturn(4999L);
- assertThat(
- assigner.assignWindows("String", Long.MIN_VALUE, mockContext),
- contains(timeWindow(4999, 9999)));
+ assertThat(assigner.assignWindows("String", Long.MIN_VALUE, mockContext))
+ .containsExactly(new TimeWindow(4999, 9999));
when(mockContext.getCurrentProcessingTime()).thenReturn(5000L);
- assertThat(
- assigner.assignWindows("String", Long.MIN_VALUE, mockContext),
- contains(timeWindow(5000, 10000)));
+ assertThat(assigner.assignWindows("String", Long.MIN_VALUE, mockContext))
+ .containsExactly(new TimeWindow(5000, 10000));
}
@Test
- public void testInvalidParameters() {
- try {
- ProcessingTimeSessionWindows.withGap(Time.seconds(-1));
- fail("should fail");
- } catch (IllegalArgumentException e) {
- assertThat(e.toString(), containsString("0 < size"));
- }
-
- try {
- ProcessingTimeSessionWindows.withGap(Time.seconds(0));
- fail("should fail");
- } catch (IllegalArgumentException e) {
- assertThat(e.toString(), containsString("0 < size"));
- }
+ void testInvalidParameters() {
+ assertThatThrownBy(() -> ProcessingTimeSessionWindows.withGap(Time.seconds(-1)))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("0 < size");
+
+ assertThatThrownBy(() -> ProcessingTimeSessionWindows.withGap(Time.seconds(0)))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("0 < size");
}
@Test
- public void testProperties() {
+ void testProperties() {
ProcessingTimeSessionWindows assigner =
ProcessingTimeSessionWindows.withGap(Time.seconds(5));
- assertFalse(assigner.isEventTime());
- assertEquals(
- new TimeWindow.Serializer(), assigner.getWindowSerializer(new ExecutionConfig()));
- assertThat(assigner.getDefaultTrigger(), instanceOf(ProcessingTimeTrigger.class));
+ assertThat(assigner.isEventTime()).isFalse();
+ assertThat(assigner.getWindowSerializer(new ExecutionConfig()))
+ .isEqualTo(new TimeWindow.Serializer());
+ assertThat(assigner.getDefaultTrigger()).isInstanceOf(ProcessingTimeTrigger.class);
}
@Test
- public void testDynamicGapProperties() {
+ void testDynamicGapProperties() {
SessionWindowTimeGapExtractor<String> extractor = mock(SessionWindowTimeGapExtractor.class);
DynamicProcessingTimeSessionWindows<String> assigner =
ProcessingTimeSessionWindows.withDynamicGap(extractor);
- assertNotNull(assigner);
- assertFalse(assigner.isEventTime());
+ assertThat(assigner).isNotNull();
+ assertThat(assigner.isEventTime()).isFalse();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeTriggerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeTriggerTest.java
index 84b41455f7b..5858c215908 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeTriggerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeTriggerTest.java
@@ -25,134 +25,124 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
import org.apache.flink.shaded.guava31.com.google.common.collect.Lists;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link ProcessingTimeTrigger}. */
-public class ProcessingTimeTriggerTest {
+class ProcessingTimeTriggerTest {
/** Verify that state of separate windows does not leak into other windows. */
@Test
- public void testWindowSeparationAndFiring() throws Exception {
+ void testWindowSeparationAndFiring() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ProcessingTimeTrigger.create(), new TimeWindow.Serializer());
// inject several elements
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
-
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(2, testHarness.numProcessingTimeTimers());
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(2, 4)));
-
- assertEquals(
- TriggerResult.FIRE, testHarness.advanceProcessingTime(2, new TimeWindow(0, 2)));
-
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(1, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numProcessingTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(2, 4)));
-
- assertEquals(
- TriggerResult.FIRE, testHarness.advanceProcessingTime(4, new TimeWindow(2, 4)));
-
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
+
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(2, 4))).isOne();
+
+ assertThat(testHarness.advanceProcessingTime(2, new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
+
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isOne();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(2, 4))).isOne();
+
+ assertThat(testHarness.advanceProcessingTime(4, new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.FIRE);
+
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
}
/** Verify that clear() does not leak across windows. */
@Test
- public void testClear() throws Exception {
+ void testClear() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ProcessingTimeTrigger.create(), new TimeWindow.Serializer());
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(2, testHarness.numProcessingTimeTimers());
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(2, 4))).isOne();
testHarness.clearTriggerState(new TimeWindow(2, 4));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(1, testHarness.numProcessingTimeTimers());
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numProcessingTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isOne();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(2, 4))).isZero();
testHarness.clearTriggerState(new TimeWindow(0, 2));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numProcessingTimeTimers());
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
}
@Test
- public void testMergingWindows() throws Exception {
+ void testMergingWindows() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ProcessingTimeTrigger.create(), new TimeWindow.Serializer());
- assertTrue(ProcessingTimeTrigger.create().canMerge());
+ assertThat(ProcessingTimeTrigger.create().canMerge()).isTrue();
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(2, testHarness.numProcessingTimeTimers());
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(2, 4))).isOne();
testHarness.mergeWindows(
new TimeWindow(0, 4),
Lists.newArrayList(new TimeWindow(0, 2), new TimeWindow(2, 4)));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(1, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numProcessingTimeTimers(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numProcessingTimeTimers(new TimeWindow(2, 4)));
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(0, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isOne();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(2, 4))).isZero();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 4))).isOne();
- assertEquals(
- TriggerResult.FIRE, testHarness.advanceProcessingTime(4, new TimeWindow(0, 4)));
+ assertThat(testHarness.advanceProcessingTime(4, new TimeWindow(0, 4)))
+ .isEqualTo(TriggerResult.FIRE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
}
/**
@@ -160,43 +150,41 @@ public class ProcessingTimeTriggerTest {
* from onElement() on the merged window and one from the timer.
*/
@Test
- public void testMergingLateWindows() throws Exception {
+ void testMergingLateWindows() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ProcessingTimeTrigger.create(), new TimeWindow.Serializer());
- assertTrue(ProcessingTimeTrigger.create().canMerge());
+ assertThat(ProcessingTimeTrigger.create().canMerge()).isTrue();
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<Object>(1), new TimeWindow(2, 4)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(2, 4)))
+ .isEqualTo(TriggerResult.CONTINUE);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(2, testHarness.numProcessingTimeTimers());
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(0, 2)));
- assertEquals(1, testHarness.numProcessingTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 2))).isOne();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(2, 4))).isOne();
testHarness.advanceProcessingTime(10);
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numProcessingTimeTimers(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numProcessingTimeTimers(new TimeWindow(2, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(2, 4))).isZero();
testHarness.mergeWindows(
new TimeWindow(0, 4),
Lists.newArrayList(new TimeWindow(0, 2), new TimeWindow(2, 4)));
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numEventTimeTimers());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numProcessingTimeTimers(new TimeWindow(0, 2)));
- assertEquals(0, testHarness.numProcessingTimeTimers(new TimeWindow(2, 4)));
- assertEquals(0, testHarness.numProcessingTimeTimers(new TimeWindow(0, 4)));
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 2))).isZero();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(2, 4))).isZero();
+ assertThat(testHarness.numProcessingTimeTimers(new TimeWindow(0, 4))).isZero();
}
}
diff --git a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeoutTriggerTest.java b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeoutTriggerTest.java
index 83cf21ebd82..99a2593ab78 100644
--- a/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeoutTriggerTest.java
+++ b/flink-streaming-java/src/test/java/org/apache/flink/streaming/runtime/operators/windowing/ProcessingTimeoutTriggerTest.java
@@ -26,35 +26,33 @@ import org.apache.flink.streaming.api.windowing.triggers.TriggerResult;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.time.Duration;
import static org.apache.flink.core.testutils.CommonTestUtils.assertThrows;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
/** Tests for {@link ProcessingTimeoutTrigger}. */
-public class ProcessingTimeoutTriggerTest {
+class ProcessingTimeoutTriggerTest {
@Test
- public void testWindowFireWithoutResetTimer() throws Exception {
+ void testWindowFireWithoutResetTimer() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ProcessingTimeoutTrigger.of(
CountTrigger.of(3), Duration.ofMillis(50), false, true),
new TimeWindow.Serializer());
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
// Should be two states, one for ProcessingTimeoutTrigger and one for CountTrigger.
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(1, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers()).isOne();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
// Should not fire before interval time.
assertThrows(
@@ -62,28 +60,24 @@ public class ProcessingTimeoutTriggerTest {
IllegalStateException.class,
() -> testHarness.advanceProcessingTime(Long.MIN_VALUE + 40, new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.FIRE,
- testHarness.advanceProcessingTime(Long.MIN_VALUE + 50, new TimeWindow(0, 2)));
+ assertThat(testHarness.advanceProcessingTime(Long.MIN_VALUE + 50, new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
// After firing states should be clear.
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
// Check inner trigger is working as well
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
}
@Test
- public void testWindowFireWithResetTimer() throws Exception {
+ void testWindowFireWithResetTimer() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ProcessingTimeoutTrigger.of(
@@ -94,21 +88,19 @@ public class ProcessingTimeoutTriggerTest {
"Must have exactly one timer firing. Fired timers: []",
IllegalStateException.class,
() -> testHarness.advanceProcessingTime(0, new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
assertThrows(
"Must have exactly one timer firing. Fired timers: []",
IllegalStateException.class,
() -> testHarness.advanceProcessingTime(10, new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
// Should be two states, one for ProcessingTimeoutTrigger and one for CountTrigger.
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(1, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers()).isOne();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
// Should not fire at timestampA+interval (at 50 millis), because resetTimer is on, it
// should fire at 60 millis.
@@ -117,58 +109,52 @@ public class ProcessingTimeoutTriggerTest {
IllegalStateException.class,
() -> testHarness.advanceProcessingTime(50, new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.FIRE, testHarness.advanceProcessingTime(60, new TimeWindow(0, 2)));
+ assertThat(testHarness.advanceProcessingTime(60, new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
// After firing states should be clear.
- assertEquals(0, testHarness.numStateEntries());
- assertEquals(0, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isZero();
+ assertThat(testHarness.numProcessingTimeTimers()).isZero();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
// Check inner trigger is working as well
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1, 0), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1, 10), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.FIRE,
- testHarness.processElement(new StreamRecord<>(1, 20), new TimeWindow(0, 2)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1, 0), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1, 10), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1, 20), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.FIRE);
}
@Test
- public void testWindowFireWithoutClearOnTimeout() throws Exception {
+ void testWindowFireWithoutClearOnTimeout() throws Exception {
TriggerTestHarness<Object, TimeWindow> testHarness =
new TriggerTestHarness<>(
ProcessingTimeoutTrigger.of(
CountTrigger.of(3), Duration.ofMillis(50), false, false),
new TimeWindow.Serializer());
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)));
- assertEquals(
- TriggerResult.CONTINUE,
- testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)));
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
+ assertThat(testHarness.processElement(new StreamRecord<>(1), new TimeWindow(0, 2)))
+ .isEqualTo(TriggerResult.CONTINUE);
// Should be two states, one for ProcessingTimeoutTrigger and one for CountTrigger.
- assertEquals(2, testHarness.numStateEntries());
- assertEquals(1, testHarness.numProcessingTimeTimers());
- assertEquals(0, testHarness.numEventTimeTimers());
+ assertThat(testHarness.numStateEntries()).isEqualTo(2);
+ assertThat(testHarness.numProcessingTimeTimers()).isOne();
+ assertThat(testHarness.numEventTimeTimers()).isZero();
- assertEquals(
- TriggerResult.FIRE,
- testHarness.advanceProcessingTime(Long.MIN_VALUE + 50, new TimeWindow(0, 2)));
+ assertThat(testHarness.advanceProcessingTime(Long.MIN_VALUE + 50, new TimeWindow(0, 2)))
... 12736 lines suppressed ...