This is an automated email from the ASF dual-hosted git repository.
adoroszlai pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ozone.git
The following commit(s) were added to refs/heads/master by this push:
new 0cb538198c HDDS-10092. improve assertTrue assertions in client
integration tests (#5969)
0cb538198c is described below
commit 0cb538198ceb5c8d1ff8e8bd430a6c5a7fc47c11
Author: Zhaohui Wang <[email protected]>
AuthorDate: Thu Jan 11 05:47:25 2024 +0800
HDDS-10092. improve assertTrue assertions in client integration tests
(#5969)
---
.../client/rpc/AbstractTestECKeyOutputStream.java | 16 ++--
.../ozone/client/rpc/Test2WayCommitInRatis.java | 6 +-
.../apache/hadoop/ozone/client/rpc/TestBCSID.java | 4 +-
.../client/rpc/TestBlockDataStreamOutput.java | 10 +--
.../ozone/client/rpc/TestBlockOutputStream.java | 36 +++++----
.../rpc/TestBlockOutputStreamWithFailures.java | 50 +++++++-----
.../rpc/TestCloseContainerHandlingByClient.java | 16 ++--
.../rpc/TestContainerReplicationEndToEnd.java | 7 +-
.../client/rpc/TestContainerStateMachine.java | 10 +--
.../rpc/TestContainerStateMachineFailures.java | 28 +++----
.../client/rpc/TestDeleteWithInAdequateDN.java | 12 +--
.../client/rpc/TestDiscardPreallocatedBlocks.java | 5 +-
.../client/rpc/TestFailureHandlingByClient.java | 49 +++++-------
.../rpc/TestFailureHandlingByClientFlushDelay.java | 12 +--
.../client/rpc/TestHybridPipelineOnDatanode.java | 4 +-
.../rpc/TestMultiBlockWritesWithDnFailures.java | 8 +-
.../client/rpc/TestOzoneAtRestEncryption.java | 11 +--
.../rpc/TestOzoneClientMultipartUploadWithFSO.java | 8 +-
...estOzoneClientRetriesOnExceptionFlushDelay.java | 18 ++---
.../rpc/TestOzoneClientRetriesOnExceptions.java | 36 ++++-----
.../client/rpc/TestOzoneRpcClientAbstract.java | 93 +++++++++-------------
.../rpc/TestOzoneRpcClientForAclAuditLog.java | 5 +-
.../client/rpc/TestValidateBCSIDOnRestart.java | 16 ++--
.../ozone/client/rpc/TestWatchForCommit.java | 35 ++++----
24 files changed, 243 insertions(+), 252 deletions(-)
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/AbstractTestECKeyOutputStream.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/AbstractTestECKeyOutputStream.java
index 2bbee25f97..3478489edd 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/AbstractTestECKeyOutputStream.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/AbstractTestECKeyOutputStream.java
@@ -61,10 +61,10 @@ import java.util.concurrent.TimeoutException;
import static java.nio.charset.StandardCharsets.UTF_8;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_DEADNODE_INTERVAL;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.fail;
/**
@@ -158,7 +158,7 @@ abstract class AbstractTestECKeyOutputStream {
.createKey(keyString, new ECReplicationConfig(3, 2,
ECReplicationConfig.EcCodec.RS, chunkSize), inputSize,
objectStore, volumeName, bucketName)) {
- assertTrue(key.getOutputStream() instanceof ECKeyOutputStream);
+ assertInstanceOf(ECKeyOutputStream.class, key.getOutputStream());
}
}
@@ -167,7 +167,7 @@ abstract class AbstractTestECKeyOutputStream {
OzoneVolume volume = objectStore.getVolume(volumeName);
OzoneBucket bucket = volume.getBucket(bucketName);
try (OzoneOutputStream out = bucket.createKey("myKey", inputSize)) {
- assertTrue(out.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, out.getOutputStream());
for (byte[] inputChunk : inputChunks) {
out.write(inputChunk);
}
@@ -188,7 +188,7 @@ abstract class AbstractTestECKeyOutputStream {
OzoneBucket bucket = volume.getBucket(myBucket);
try (OzoneOutputStream out = bucket.createKey(keyString, inputSize)) {
- assertTrue(out.getOutputStream() instanceof ECKeyOutputStream);
+ assertInstanceOf(ECKeyOutputStream.class, out.getOutputStream());
for (byte[] inputChunk : inputChunks) {
out.write(inputChunk);
}
@@ -259,7 +259,7 @@ abstract class AbstractTestECKeyOutputStream {
"testCreateRatisKeyAndWithECBucketDefaults", 2000,
RatisReplicationConfig.getInstance(HddsProtos.ReplicationFactor.THREE),
new HashMap<>())) {
- assertTrue(out.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, out.getOutputStream());
for (byte[] inputChunk : inputChunks) {
out.write(inputChunk);
}
@@ -427,8 +427,8 @@ abstract class AbstractTestECKeyOutputStream {
// Check the second blockGroup pipeline to make sure that the failed
// node is not selected.
- assertFalse(ecOut.getStreamEntries()
- .get(1).getPipeline().getNodes().contains(nodeToKill));
+ assertThat(ecOut.getStreamEntries().get(1).getPipeline().getNodes())
+ .doesNotContain(nodeToKill);
}
try (OzoneInputStream is = bucket.readKey(keyName)) {
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/Test2WayCommitInRatis.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/Test2WayCommitInRatis.java
index f2a5d75848..ce89e679df 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/Test2WayCommitInRatis.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/Test2WayCommitInRatis.java
@@ -50,8 +50,8 @@ import java.util.concurrent.TimeUnit;
import static org.apache.hadoop.hdds.scm.ScmConfigKeys.
OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* This class tests the 2 way commit in Ratis.
@@ -175,8 +175,8 @@ public class Test2WayCommitInRatis {
// commitInfo Map will be reduced to 2 here
assertEquals(2, ratisClient.getCommitInfoMap().size());
clientManager.releaseClient(xceiverClient, false);
- assertTrue(logCapturer.getOutput().contains("3 way commit failed"));
- assertTrue(logCapturer.getOutput().contains("Committed by majority"));
+ assertThat(logCapturer.getOutput()).contains("3 way commit failed");
+ assertThat(logCapturer.getOutput()).contains("Committed by majority");
logCapturer.stopCapturing();
shutdown();
}
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBCSID.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBCSID.java
index 4245f460be..c0ae49f3bf 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBCSID.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBCSID.java
@@ -52,8 +52,8 @@ import static org.apache.hadoop.hdds.HddsConfigKeys.
import static org.apache.hadoop.hdds.HddsConfigKeys
.HDDS_SCM_SAFEMODE_PIPELINE_CREATION;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests the validity BCSID of a container.
@@ -139,7 +139,7 @@ public class TestBCSID {
.getContainer().getContainerSet()
.getContainer(omKeyLocationInfo.getContainerID())
.getContainerReport().getBlockCommitSequenceId();
- assertTrue(blockCommitSequenceId > 0);
+ assertThat(blockCommitSequenceId).isGreaterThan(0);
// make sure the persisted block Id in OM is same as that seen in the
// container report to be reported to SCM.
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockDataStreamOutput.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockDataStreamOutput.java
index 017b0fb583..d3caf62387 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockDataStreamOutput.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockDataStreamOutput.java
@@ -49,8 +49,9 @@ import java.util.concurrent.TimeUnit;
import static java.nio.charset.StandardCharsets.UTF_8;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
/**
* Tests BlockDataStreamOutput class.
@@ -177,7 +178,7 @@ public class TestBlockDataStreamOutput {
(KeyDataStreamOutput) key.getByteBufStreamOutput();
ByteBufferStreamOutput stream =
keyDataStreamOutput.getStreamEntries().get(0).getByteBufStreamOutput();
- assertTrue(stream instanceof BlockDataStreamOutput);
+ assertInstanceOf(BlockDataStreamOutput.class, stream);
TestHelper.waitForContainerClose(key, cluster);
key.write(b);
key.close();
@@ -201,9 +202,8 @@ public class TestBlockDataStreamOutput {
ContainerTestHelper.getFixedLengthString(keyString, dataLength)
.getBytes(UTF_8);
key.write(ByteBuffer.wrap(data));
- assertTrue(
-
metrics.getPendingContainerOpCountMetrics(ContainerProtos.Type.PutBlock)
- <= pendingPutBlockCount + 1);
+
assertThat(metrics.getPendingContainerOpCountMetrics(ContainerProtos.Type.PutBlock))
+ .isLessThanOrEqualTo(pendingPutBlockCount + 1);
key.close();
// Since data length is 500 , first putBlock will be at 400(flush boundary)
// and the other at 500
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockOutputStream.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockOutputStream.java
index 37355b0a45..74686d363c 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockOutputStream.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockOutputStream.java
@@ -60,9 +60,9 @@ import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_DEADNODE_INTERV
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_SCM_BLOCK_SIZE;
import static org.apache.hadoop.ozone.container.TestHelper.validateData;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
-import static org.junit.jupiter.api.Assertions.assertTrue;
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@Timeout(300)
@@ -528,10 +528,10 @@ class TestBlockOutputStream {
// since its hitting the full bufferCondition, it will call
watchForCommit
// and completes atleast putBlock for first flushSize worth of data
- assertTrue(metrics.getPendingContainerOpCountMetrics(WriteChunk)
- <= pendingWriteChunkCount + 2);
- assertTrue(metrics.getPendingContainerOpCountMetrics(PutBlock)
- <= pendingPutBlockCount + 1);
+ assertThat(metrics.getPendingContainerOpCountMetrics(WriteChunk))
+ .isLessThanOrEqualTo(pendingWriteChunkCount + 2);
+ assertThat(metrics.getPendingContainerOpCountMetrics(PutBlock))
+ .isLessThanOrEqualTo(pendingPutBlockCount + 1);
KeyOutputStream keyOutputStream =
assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
@@ -551,12 +551,14 @@ class TestBlockOutputStream {
// since data equals to maxBufferSize is written, this will be a blocking
// call and hence will wait for atleast flushSize worth of data to get
// ack'd by all servers right here
- assertTrue(blockOutputStream.getTotalAckDataLength() >= FLUSH_SIZE);
+ assertThat(blockOutputStream.getTotalAckDataLength())
+ .isGreaterThanOrEqualTo(FLUSH_SIZE);
// watchForCommit will clean up atleast one entry from the map where each
// entry corresponds to flushSize worth of data
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <=
1);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(1);
// This will flush the data and update the flush length and the map.
key.flush();
@@ -570,7 +572,8 @@ class TestBlockOutputStream {
assertEquals(dataLength, blockOutputStream.getWrittenDataLength());
assertEquals(dataLength, blockOutputStream.getTotalDataFlushedLength());
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <=
1);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(1);
// now close the stream, it will update ack length after watchForCommit
key.close();
@@ -618,10 +621,10 @@ class TestBlockOutputStream {
// since it's hitting full-buffer, it will call watchForCommit
// and completes putBlock at least for first flushSize worth of data
- assertTrue(metrics.getPendingContainerOpCountMetrics(WriteChunk)
- <= pendingWriteChunkCount + 2);
- assertTrue(metrics.getPendingContainerOpCountMetrics(PutBlock)
- <= pendingPutBlockCount + 1);
+ assertThat(metrics.getPendingContainerOpCountMetrics(WriteChunk))
+ .isLessThanOrEqualTo(pendingWriteChunkCount + 2);
+ assertThat(metrics.getPendingContainerOpCountMetrics(PutBlock))
+ .isLessThanOrEqualTo(pendingPutBlockCount + 1);
assertEquals(writeChunkCount + 4,
metrics.getContainerOpCountMetrics(WriteChunk));
assertEquals(putBlockCount + 2,
@@ -642,11 +645,13 @@ class TestBlockOutputStream {
// since data equals to maxBufferSize is written, this will be a blocking
// call and hence will wait for atleast flushSize worth of data to get
// ack'd by all servers right here
- assertTrue(blockOutputStream.getTotalAckDataLength() >= FLUSH_SIZE);
+ assertThat(blockOutputStream.getTotalAckDataLength())
+ .isGreaterThanOrEqualTo(FLUSH_SIZE);
// watchForCommit will clean up atleast one entry from the map where each
// entry corresponds to flushSize worth of data
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <=
1);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(1);
// Now do a flush.
key.flush();
@@ -664,7 +669,8 @@ class TestBlockOutputStream {
// dataLength > MAX_FLUSH_SIZE
assertEquals(flushDelay ? MAX_FLUSH_SIZE : dataLength,
blockOutputStream.getTotalDataFlushedLength());
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <=
2);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(2);
// now close the stream, it will update ack length after watchForCommit
key.close();
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockOutputStreamWithFailures.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockOutputStreamWithFailures.java
index 22f2b831f4..708f4cec04 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockOutputStreamWithFailures.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestBlockOutputStreamWithFailures.java
@@ -44,6 +44,7 @@ import static
org.apache.hadoop.ozone.client.rpc.TestBlockOutputStream.getKeyNam
import static
org.apache.hadoop.ozone.client.rpc.TestBlockOutputStream.newClient;
import static
org.apache.hadoop.ozone.client.rpc.TestBlockOutputStream.newClientConfig;
import static org.apache.hadoop.ozone.container.TestHelper.validateData;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -118,11 +119,13 @@ class TestBlockOutputStreamWithFailures {
// since data equals to maxBufferSize is written, this will be a blocking
// call and hence will wait for atleast flushSize worth of data to get
// ack'd by all servers right here
- assertTrue(blockOutputStream.getTotalAckDataLength() >= FLUSH_SIZE);
+ assertThat(blockOutputStream.getTotalAckDataLength())
+ .isGreaterThanOrEqualTo(FLUSH_SIZE);
// watchForCommit will clean up atleast one entry from the map where each
// entry corresponds to flushSize worth of data
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <= 1);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(1);
// This will flush the data and update the flush length and the map.
key.flush();
@@ -136,7 +139,8 @@ class TestBlockOutputStreamWithFailures {
assertEquals(dataLength, blockOutputStream.getTotalDataFlushedLength());
// flush will make sure one more entry gets updated in the map
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <= 2);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(2);
XceiverClientRatis raftClient =
(XceiverClientRatis) blockOutputStream.getXceiverClient();
@@ -205,11 +209,13 @@ class TestBlockOutputStreamWithFailures {
// since data equals to maxBufferSize is written, this will be a blocking
// call and hence will wait for atleast flushSize worth of data to get
// ack'd by all servers right here
- assertTrue(blockOutputStream.getTotalAckDataLength() >= FLUSH_SIZE);
+ assertThat(blockOutputStream.getTotalAckDataLength())
+ .isGreaterThanOrEqualTo(FLUSH_SIZE);
// watchForCommit will clean up atleast flushSize worth of data buffer
// where each entry corresponds to flushSize worth of data
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <=
2);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(2);
// This will flush the data and update the flush length and the map.
key.flush();
@@ -284,11 +290,13 @@ class TestBlockOutputStreamWithFailures {
// since data equals to maxBufferSize is written, this will be a blocking
// call and hence will wait for atleast flushSize worth of data to get
// acked by all servers right here
- assertTrue(blockOutputStream.getTotalAckDataLength() >= FLUSH_SIZE);
+ assertThat(blockOutputStream.getTotalAckDataLength())
+ .isGreaterThanOrEqualTo(FLUSH_SIZE);
// watchForCommit will clean up atleast one entry from the map where each
// entry corresponds to flushSize worth of data
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <=
1);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(1);
// This will flush the data and update the flush length and the map.
key.flush();
@@ -301,7 +309,8 @@ class TestBlockOutputStreamWithFailures {
assertEquals(dataLength, blockOutputStream.getTotalDataFlushedLength());
// flush will make sure one more entry gets updated in the map
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <=
2);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(2);
XceiverClientRatis raftClient =
(XceiverClientRatis) blockOutputStream.getXceiverClient();
@@ -454,8 +463,6 @@ class TestBlockOutputStreamWithFailures {
assertInstanceOf(ContainerNotOpenException.class,
checkForException(blockOutputStream.getIoException()));
- assertTrue(checkForException(blockOutputStream
- .getIoException()) instanceof ContainerNotOpenException);
// Make sure the retryCount is reset after the exception is handled
assertEquals(0, keyOutputStream.getRetryCount());
// make sure the bufferPool is empty
@@ -497,11 +504,13 @@ class TestBlockOutputStreamWithFailures {
// since data equals to maxBufferSize is written, this will be a blocking
// call and hence will wait for atleast flushSize worth of data to get
// ack'd by all servers right here
- assertTrue(blockOutputStream.getTotalAckDataLength() >= FLUSH_SIZE);
+ assertThat(blockOutputStream.getTotalAckDataLength())
+ .isGreaterThanOrEqualTo(FLUSH_SIZE);
// watchForCommit will clean up atleast one entry from the map where each
// entry corresponds to flushSize worth of data
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <= 1);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(1);
// This will flush the data and update the flush length and the map.
key.flush();
@@ -514,7 +523,8 @@ class TestBlockOutputStreamWithFailures {
assertEquals(dataLength, blockOutputStream.getTotalDataFlushedLength());
// flush will make sure one more entry gets updated in the map
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <= 2);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(2);
XceiverClientRatis raftClient =
(XceiverClientRatis) blockOutputStream.getXceiverClient();
@@ -532,8 +542,6 @@ class TestBlockOutputStreamWithFailures {
assertInstanceOf(ContainerNotOpenException.class,
checkForException(blockOutputStream.getIoException()));
- assertTrue(checkForException(blockOutputStream
- .getIoException()) instanceof ContainerNotOpenException);
// Make sure the retryCount is reset after the exception is handled
assertEquals(0, keyOutputStream.getRetryCount());
// commitInfoMap will remain intact as there is no server failure
@@ -586,11 +594,13 @@ class TestBlockOutputStreamWithFailures {
// since data equals to maxBufferSize is written, this will be a blocking
// call and hence will wait for atleast flushSize worth of data to get
// ack'd by all servers right here
- assertTrue(blockOutputStream.getTotalAckDataLength() >= FLUSH_SIZE);
+ assertThat(blockOutputStream.getTotalAckDataLength())
+ .isGreaterThanOrEqualTo(FLUSH_SIZE);
// watchForCommit will clean up atleast flushSize worth of data buffer
// where each entry corresponds to flushSize worth of data
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <=
2);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(2);
// This will flush the data and update the flush length and the map.
key.flush();
@@ -675,11 +685,13 @@ class TestBlockOutputStreamWithFailures {
// since data equals to maxBufferSize is written, this will be a blocking
// call and hence will wait for atleast flushSize worth of data to get
// ack'd by all servers right here
- assertTrue(blockOutputStream.getTotalAckDataLength() >= FLUSH_SIZE);
+ assertThat(blockOutputStream.getTotalAckDataLength())
+ .isGreaterThanOrEqualTo(FLUSH_SIZE);
// watchForCommit will clean up atleast flushSize worth of data buffer
// where each entry corresponds to flushSize worth of data
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().size() <=
2);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(2);
// This will flush the data and update the flush length and
// the map.
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestCloseContainerHandlingByClient.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestCloseContainerHandlingByClient.java
index e3353b9bf0..f2a5748bff 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestCloseContainerHandlingByClient.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestCloseContainerHandlingByClient.java
@@ -55,7 +55,7 @@ import static
org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
@@ -135,7 +135,7 @@ public class TestCloseContainerHandlingByClient {
.getBytes(UTF_8);
key.write(data);
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
//get the name of a valid container
OmKeyArgs keyArgs = new OmKeyArgs.Builder().setVolumeName(volumeName)
.setBucketName(bucketName)
@@ -168,7 +168,7 @@ public class TestCloseContainerHandlingByClient {
.getBytes(UTF_8);
key.write(data);
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
//get the name of a valid container
OmKeyArgs keyArgs = new OmKeyArgs.Builder().setVolumeName(volumeName)
.setBucketName(bucketName)
@@ -202,7 +202,7 @@ public class TestCloseContainerHandlingByClient {
assertEquals(data.length, 3 * blockSize);
key.write(data);
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
//get the name of a valid container
OmKeyArgs keyArgs = new OmKeyArgs.Builder().setVolumeName(volumeName)
.setBucketName(bucketName)
@@ -241,7 +241,7 @@ public class TestCloseContainerHandlingByClient {
KeyOutputStream keyOutputStream =
(KeyOutputStream) key.getOutputStream();
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
// With the initial size provided, it should have pre allocated 2 blocks
assertEquals(2, keyOutputStream.getStreamEntries().size());
String dataString =
@@ -306,7 +306,7 @@ public class TestCloseContainerHandlingByClient {
assertEquals(data.length, 3 * blockSize + chunkSize);
key.write(data);
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
//get the name of a valid container
OmKeyArgs keyArgs = new OmKeyArgs.Builder().setVolumeName(volumeName)
.setBucketName(bucketName)
@@ -377,7 +377,7 @@ public class TestCloseContainerHandlingByClient {
.setKeyName(keyName)
.build();
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
waitForContainerClose(key);
// Again Write the Data. This will throw an exception which will be handled
// and new blocks will be allocated
@@ -403,7 +403,7 @@ public class TestCloseContainerHandlingByClient {
.getBytes(UTF_8);
key.write(data1);
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
//get the name of a valid container
OmKeyArgs keyArgs = new OmKeyArgs.Builder().setVolumeName(volumeName)
.setBucketName(bucketName)
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerReplicationEndToEnd.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerReplicationEndToEnd.java
index d012bfd524..fe08b9e0f4 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerReplicationEndToEnd.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerReplicationEndToEnd.java
@@ -62,10 +62,10 @@ import static
org.apache.hadoop.hdds.HddsConfigKeys.HDDS_CONTAINER_REPORT_INTERV
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_PIPELINE_DESTROY_TIMEOUT;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_DATANODE_PIPELINE_LIMIT;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests delete key operation with a slow follower in the datanode
@@ -231,9 +231,10 @@ public class TestContainerReplicationEndToEnd {
return newReplicaNode.getDatanodeStateMachine().getContainer()
.getContainerSet().getContainer(containerID) != null;
}, 500, 100000);
- assertTrue(newReplicaNode.getDatanodeStateMachine().getContainer()
+ assertThat(newReplicaNode.getDatanodeStateMachine().getContainer()
.getContainerSet().getContainer(containerID).getContainerData()
- .getBlockCommitSequenceId() > 0);
+ .getBlockCommitSequenceId())
+ .isGreaterThan(0);
// wait for SCM to update the replica Map
Thread.sleep(5 * containerReportInterval);
// now shutdown the other two dns of the original pipeline and try reading
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachine.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachine.java
index f1aae8e4d0..84b7579cd0 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachine.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachine.java
@@ -54,9 +54,9 @@ import static
org.apache.hadoop.hdds.HddsConfigKeys.HDDS_BLOCK_TOKEN_ENABLED;
import static
org.apache.hadoop.hdds.HddsConfigKeys.HDDS_COMMAND_STATUS_REPORT_INTERVAL;
import static
org.apache.hadoop.hdds.HddsConfigKeys.HDDS_CONTAINER_REPORT_INTERVAL;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.ratis.statemachine.impl.SimpleStateMachineStorage;
import org.apache.ratis.statemachine.impl.StatemachineImplTestUtil;
@@ -209,8 +209,8 @@ public class TestContainerStateMachine {
storage = (SimpleStateMachineStorage)
stateMachine.getStateMachineStorage();
Path parentPath = getSnapshotPath(storage);
int numSnapshots = parentPath.getParent().toFile().listFiles().length;
- assertTrue(Math.abs(ratisServerConfiguration
- .getNumSnapshotsRetained() - numSnapshots) <= 1);
+ assertThat(Math.abs(ratisServerConfiguration.getNumSnapshotsRetained() -
numSnapshots))
+ .isLessThanOrEqualTo(1);
// Write 10 more keys. Num Snapshots should remain the same.
for (int i = 11; i <= 20; i++) {
@@ -230,8 +230,8 @@ public class TestContainerStateMachine {
storage = (SimpleStateMachineStorage)
stateMachine.getStateMachineStorage();
parentPath = getSnapshotPath(storage);
numSnapshots = parentPath.getParent().toFile().listFiles().length;
- assertTrue(Math.abs(ratisServerConfiguration
- .getNumSnapshotsRetained() - numSnapshots) <= 1);
+ assertThat(Math.abs(ratisServerConfiguration.getNumSnapshotsRetained() -
numSnapshots))
+ .isLessThanOrEqualTo(1);
}
static Path getSnapshotPath(SimpleStateMachineStorage storage)
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFailures.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFailures.java
index eb84e67398..5a2d67960f 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFailures.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestContainerStateMachineFailures.java
@@ -87,7 +87,9 @@ import static
org.apache.hadoop.hdds.HddsConfigKeys.HDDS_PIPELINE_REPORT_INTERVA
import static
org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos.ContainerDataProto.State.QUASI_CLOSED;
import static
org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos.ContainerDataProto.State.UNHEALTHY;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -340,9 +342,8 @@ public class TestContainerStateMachineFailures {
.getContainer().getContainerSet()
.getContainer(omKeyLocationInfo.getContainerID())
.getContainerData();
- assertTrue(containerData instanceof KeyValueContainerData);
KeyValueContainerData keyValueContainerData =
- (KeyValueContainerData) containerData;
+ assertInstanceOf(KeyValueContainerData.class, containerData);
// delete the container db file
FileUtil.fullyDelete(new File(keyValueContainerData.getChunksPath()));
try {
@@ -425,9 +426,8 @@ public class TestContainerStateMachineFailures {
.getContainer().getContainerSet()
.getContainer(omKeyLocationInfo.getContainerID())
.getContainerData();
- assertTrue(containerData instanceof KeyValueContainerData);
KeyValueContainerData keyValueContainerData =
- (KeyValueContainerData) containerData;
+ assertInstanceOf(KeyValueContainerData.class, containerData);
key.close();
ContainerStateMachine stateMachine =
(ContainerStateMachine) TestHelper.getStateMachine(cluster.
@@ -439,7 +439,7 @@ public class TestContainerStateMachineFailures {
final Path parentPath = snapshot.getPath();
// Since the snapshot threshold is set to 1, since there are
// applyTransactions, we should see snapshots
- assertTrue(parentPath.getParent().toFile().listFiles().length > 0);
+
assertThat(parentPath.getParent().toFile().listFiles().length).isGreaterThan(0);
assertNotNull(snapshot);
long containerID = omKeyLocationInfo.getContainerID();
// delete the container db file
@@ -474,7 +474,7 @@ public class TestContainerStateMachineFailures {
// try to take a new snapshot, ideally it should just fail
stateMachine.takeSnapshot();
} catch (IOException ioe) {
- assertTrue(ioe instanceof StateMachineException);
+ assertInstanceOf(StateMachineException.class, ioe);
}
if (snapshot.getPath().toFile().exists()) {
@@ -517,7 +517,7 @@ public class TestContainerStateMachineFailures {
.getContainer().getContainerSet()
.getContainer(omKeyLocationInfo.getContainerID())
.getContainerData();
- assertTrue(containerData instanceof KeyValueContainerData);
+ assertInstanceOf(KeyValueContainerData.class, containerData);
key.close();
ContainerStateMachine stateMachine =
(ContainerStateMachine) TestHelper.getStateMachine(dn,
@@ -527,7 +527,7 @@ public class TestContainerStateMachineFailures {
final FileInfo snapshot = getSnapshotFileInfo(storage);
final Path parentPath = snapshot.getPath();
stateMachine.takeSnapshot();
- assertTrue(parentPath.getParent().toFile().listFiles().length > 0);
+
assertThat(parentPath.getParent().toFile().listFiles().length).isGreaterThan(0);
assertNotNull(snapshot);
long markIndex1 = StatemachineImplTestUtil.findLatestSnapshot(storage)
.getIndex();
@@ -610,7 +610,7 @@ public class TestContainerStateMachineFailures {
.getContainer().getContainerSet()
.getContainer(omKeyLocationInfo.getContainerID())
.getContainerData();
- assertTrue(containerData instanceof KeyValueContainerData);
+ assertInstanceOf(KeyValueContainerData.class, containerData);
key.close();
ContainerStateMachine stateMachine =
(ContainerStateMachine) TestHelper.getStateMachine(dn,
@@ -622,7 +622,7 @@ public class TestContainerStateMachineFailures {
stateMachine.takeSnapshot();
// Since the snapshot threshold is set to 1, since there are
// applyTransactions, we should see snapshots
- assertTrue(parentPath.getParent().toFile().listFiles().length > 0);
+
assertThat(parentPath.getParent().toFile().listFiles().length).isGreaterThan(0);
assertNotNull(snapshot);
long containerID = omKeyLocationInfo.getContainerID();
Pipeline pipeline = cluster.getStorageContainerLocationClient()
@@ -664,9 +664,8 @@ public class TestContainerStateMachineFailures {
failCount.incrementAndGet();
}
String message = e.getMessage();
- assertFalse(message.contains("hello"), message);
- assertTrue(message.contains(HddsUtils.REDACTED.toStringUtf8()),
- message);
+ assertThat(message).doesNotContain("hello");
+ assertThat(message).contains(HddsUtils.REDACTED.toStringUtf8());
}
};
@@ -808,9 +807,8 @@ public class TestContainerStateMachineFailures {
ContainerData containerData =
container
.getContainerData();
- assertTrue(containerData instanceof KeyValueContainerData);
KeyValueContainerData keyValueContainerData =
- (KeyValueContainerData) containerData;
+ assertInstanceOf(KeyValueContainerData.class, containerData);
FileUtil.fullyDelete(new
File(keyValueContainerData.getChunksPath()));
}
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestDeleteWithInAdequateDN.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestDeleteWithInAdequateDN.java
index cd4f1c4ae9..0363d7aef1 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestDeleteWithInAdequateDN.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestDeleteWithInAdequateDN.java
@@ -69,10 +69,11 @@ import static
org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_PIPELINE_CREATION_INTERVAL;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_PIPELINE_DESTROY_TIMEOUT;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assumptions;
@@ -307,8 +308,8 @@ public class TestDeleteWithInAdequateDN {
// Make sure the readStateMachine call got triggered after the follower
// caught up
- assertTrue(stateMachine.getMetrics().getNumReadStateMachineOps()
- > numReadStateMachineOps);
+ assertThat(stateMachine.getMetrics().getNumReadStateMachineOps())
+ .isGreaterThan(numReadStateMachineOps);
assertEquals(0, stateMachine.getMetrics().getNumReadStateMachineFails());
// wait for the chunk to get deleted now
Thread.sleep(10000);
@@ -325,9 +326,8 @@ public class TestDeleteWithInAdequateDN {
}
fail("Expected exception is not thrown");
} catch (IOException ioe) {
- assertTrue(ioe instanceof StorageContainerException);
- assertSame(((StorageContainerException) ioe).getResult(),
- ContainerProtos.Result.UNABLE_TO_FIND_CHUNK);
+ StorageContainerException e =
assertInstanceOf(StorageContainerException.class, ioe);
+ assertSame(ContainerProtos.Result.UNABLE_TO_FIND_CHUNK, e.getResult());
}
}
}
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestDiscardPreallocatedBlocks.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestDiscardPreallocatedBlocks.java
index 505dab409f..c689a692ae 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestDiscardPreallocatedBlocks.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestDiscardPreallocatedBlocks.java
@@ -50,8 +50,8 @@ import org.apache.hadoop.ozone.om.helpers.OmKeyLocationInfo;
import static java.nio.charset.StandardCharsets.UTF_8;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
@@ -129,8 +129,7 @@ public class TestDiscardPreallocatedBlocks {
OzoneOutputStream key =
createKey(keyName, ReplicationType.RATIS, 2 * blockSize);
KeyOutputStream keyOutputStream =
- (KeyOutputStream) key.getOutputStream();
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
// With the initial size provided, it should have pre allocated 2 blocks
assertEquals(2, keyOutputStream.getStreamEntries().size());
long containerID1 = keyOutputStream.getStreamEntries().get(0)
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClient.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClient.java
index deeb421401..d1b20de88a 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClient.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClient.java
@@ -66,9 +66,10 @@ import static java.nio.charset.StandardCharsets.UTF_8;
import static
org.apache.hadoop.fs.CommonConfigurationKeysPublic.NET_TOPOLOGY_NODE_SWITCH_MAPPING_IMPL_KEY;
import static
org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor.THREE;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
@@ -175,13 +176,11 @@ public class TestFailureHandlingByClient {
key.write(data);
// get the name of a valid container
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
+ KeyOutputStream groupOutputStream =
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
// assert that the exclude list's expire time equals to
// default value 600000 ms in OzoneClientConfig.java
- assertEquals(((KeyOutputStream) key.getOutputStream())
- .getExcludeList().getExpiryTime(), 600000);
- KeyOutputStream groupOutputStream =
- (KeyOutputStream) key.getOutputStream();
+ assertEquals(groupOutputStream.getExcludeList().getExpiryTime(), 600000);
List<OmKeyLocationInfo> locationInfoList =
groupOutputStream.getLocationInfoList();
assertEquals(1, locationInfoList.size());
@@ -279,7 +278,7 @@ public class TestFailureHandlingByClient {
.getLocalID()));
// The first Block could have 1 or 2 chunkSize of data
int block1NumChunks = blockData1.getChunks().size();
- assertTrue(block1NumChunks >= 1);
+ assertThat(block1NumChunks).isGreaterThanOrEqualTo(1);
assertEquals(chunkSize * block1NumChunks, blockData1.getSize());
assertEquals(1, containerData1.getBlockCount());
@@ -320,9 +319,8 @@ public class TestFailureHandlingByClient {
.getFixedLengthString(keyString, chunkSize / 2);
key.write(data.getBytes(UTF_8));
// get the name of a valid container
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
KeyOutputStream keyOutputStream =
- (KeyOutputStream) key.getOutputStream();
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
List<OmKeyLocationInfo> locationInfoList =
keyOutputStream.getLocationInfoList();
long containerId = locationInfoList.get(0).getContainerID();
@@ -367,9 +365,8 @@ public class TestFailureHandlingByClient {
.getFixedLengthString(keyString, chunkSize);
// get the name of a valid container
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
KeyOutputStream keyOutputStream =
- (KeyOutputStream) key.getOutputStream();
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
List<BlockOutputStreamEntry> streamEntryList =
keyOutputStream.getStreamEntries();
@@ -391,10 +388,10 @@ public class TestFailureHandlingByClient {
key.write(data.getBytes(UTF_8));
key.flush();
- assertTrue(keyOutputStream.getExcludeList().getContainerIds()
- .contains(ContainerID.valueOf(containerId)));
- assertTrue(keyOutputStream.getExcludeList().getDatanodes().isEmpty());
- assertTrue(keyOutputStream.getExcludeList().getPipelineIds().isEmpty());
+ assertThat(keyOutputStream.getExcludeList().getContainerIds())
+ .contains(ContainerID.valueOf(containerId));
+ assertThat(keyOutputStream.getExcludeList().getDatanodes()).isEmpty();
+ assertThat(keyOutputStream.getExcludeList().getPipelineIds()).isEmpty();
// The close will just write to the buffer
key.close();
@@ -423,9 +420,8 @@ public class TestFailureHandlingByClient {
.getFixedLengthString(keyString, chunkSize);
// get the name of a valid container
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
KeyOutputStream keyOutputStream =
- (KeyOutputStream) key.getOutputStream();
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
List<BlockOutputStreamEntry> streamEntryList =
keyOutputStream.getStreamEntries();
@@ -451,10 +447,10 @@ public class TestFailureHandlingByClient {
key.write(data.getBytes(UTF_8));
key.flush();
- assertTrue(keyOutputStream.getExcludeList().getDatanodes()
- .contains(datanodes.get(0)));
- assertTrue(keyOutputStream.getExcludeList().getContainerIds().isEmpty());
- assertTrue(keyOutputStream.getExcludeList().getPipelineIds().isEmpty());
+ assertThat(keyOutputStream.getExcludeList().getDatanodes())
+ .contains(datanodes.get(0));
+ assertThat(keyOutputStream.getExcludeList().getContainerIds()).isEmpty();
+ assertThat(keyOutputStream.getExcludeList().getPipelineIds()).isEmpty();
// The close will just write to the buffer
key.close();
@@ -484,9 +480,8 @@ public class TestFailureHandlingByClient {
.getFixedLengthString(keyString, chunkSize);
// get the name of a valid container
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
KeyOutputStream keyOutputStream =
- (KeyOutputStream) key.getOutputStream();
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
List<BlockOutputStreamEntry> streamEntryList =
keyOutputStream.getStreamEntries();
@@ -512,10 +507,10 @@ public class TestFailureHandlingByClient {
key.write(data.getBytes(UTF_8));
key.write(data.getBytes(UTF_8));
key.flush();
- assertTrue(keyOutputStream.getExcludeList().getPipelineIds()
- .contains(pipeline.getId()));
- assertTrue(keyOutputStream.getExcludeList().getContainerIds().isEmpty());
- assertTrue(keyOutputStream.getExcludeList().getDatanodes().isEmpty());
+ assertThat(keyOutputStream.getExcludeList().getPipelineIds())
+ .contains(pipeline.getId());
+ assertThat(keyOutputStream.getExcludeList().getContainerIds()).isEmpty();
+ assertThat(keyOutputStream.getExcludeList().getDatanodes()).isEmpty();
// The close will just write to the buffer
key.close();
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClientFlushDelay.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClientFlushDelay.java
index 8af60c4e80..41438996c2 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClientFlushDelay.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestFailureHandlingByClientFlushDelay.java
@@ -61,9 +61,10 @@ import java.util.concurrent.TimeUnit;
import static java.nio.charset.StandardCharsets.UTF_8;
import static
org.apache.hadoop.fs.CommonConfigurationKeysPublic.NET_TOPOLOGY_NODE_SWITCH_MAPPING_IMPL_KEY;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests Exception handling by Ozone Client by set flush delay.
@@ -172,9 +173,8 @@ public class TestFailureHandlingByClientFlushDelay {
.getFixedLengthString(keyString, chunkSize);
// get the name of a valid container
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
KeyOutputStream keyOutputStream =
- (KeyOutputStream) key.getOutputStream();
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
List<BlockOutputStreamEntry> streamEntryList =
keyOutputStream.getStreamEntries();
@@ -199,9 +199,9 @@ public class TestFailureHandlingByClientFlushDelay {
key.write(data.getBytes(UTF_8));
key.flush();
- assertTrue(keyOutputStream.getExcludeList().getContainerIds().isEmpty());
- assertTrue(keyOutputStream.getExcludeList().getDatanodes().isEmpty());
- assertTrue(keyOutputStream.getExcludeList().getDatanodes().isEmpty());
+ assertThat(keyOutputStream.getExcludeList().getContainerIds()).isEmpty();
+ assertThat(keyOutputStream.getExcludeList().getDatanodes()).isEmpty();
+ assertThat(keyOutputStream.getExcludeList().getDatanodes()).isEmpty();
key.write(data.getBytes(UTF_8));
// The close will just write to the buffer
key.close();
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestHybridPipelineOnDatanode.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestHybridPipelineOnDatanode.java
index 0b829814b0..4ccdd0e2d4 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestHybridPipelineOnDatanode.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestHybridPipelineOnDatanode.java
@@ -44,11 +44,11 @@ import org.junit.jupiter.api.Timeout;
import java.io.IOException;
import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import java.util.HashMap;
@@ -158,7 +158,7 @@ public class TestHybridPipelineOnDatanode {
assertSame(pipeline1.getType(), pipeline2.getType());
// assert that the pipeline Id1 and pipelineId2 are on the same node
// but different replication factor
- assertTrue(pipeline2.getNodes().contains(dns.get(0)));
+ assertThat(pipeline2.getNodes()).contains(dns.get(0));
byte[] b1 = new byte[data.length];
byte[] b2 = new byte[data.length];
// now try to read both the keys
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestMultiBlockWritesWithDnFailures.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestMultiBlockWritesWithDnFailures.java
index 403ece9a0c..b7b52d389b 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestMultiBlockWritesWithDnFailures.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestMultiBlockWritesWithDnFailures.java
@@ -56,7 +56,7 @@ import static java.nio.charset.StandardCharsets.UTF_8;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_DATANODE_PIPELINE_LIMIT;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
/**
* Tests MultiBlock Writes with Dn failures by Ozone Client.
@@ -147,9 +147,8 @@ public class TestMultiBlockWritesWithDnFailures {
key.write(data.getBytes(UTF_8));
// get the name of a valid container
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
KeyOutputStream groupOutputStream =
- (KeyOutputStream) key.getOutputStream();
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
List<OmKeyLocationInfo> locationInfoList =
groupOutputStream.getLocationInfoList();
assertEquals(2, locationInfoList.size());
@@ -192,9 +191,8 @@ public class TestMultiBlockWritesWithDnFailures {
key.write(data.getBytes(UTF_8));
// get the name of a valid container
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
KeyOutputStream keyOutputStream =
- (KeyOutputStream) key.getOutputStream();
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
List<BlockOutputStreamEntry> streamEntryList =
keyOutputStream.getStreamEntries();
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneAtRestEncryption.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneAtRestEncryption.java
index 8bb723b7dd..ab09bc2433 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneAtRestEncryption.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneAtRestEncryption.java
@@ -78,9 +78,11 @@ import org.apache.ozone.test.GenericTestUtils;
import static org.apache.hadoop.hdds.HddsConfigKeys.OZONE_METADATA_DIRS;
import static org.apache.hadoop.hdds.client.ReplicationFactor.ONE;
import static org.apache.hadoop.hdds.client.ReplicationType.RATIS;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -381,9 +383,9 @@ class TestOzoneAtRestEncryption {
assertNotNull(deletedKeys);
Map<String, String> deletedKeyMetadata =
deletedKeys.getOmKeyInfoList().get(0).getMetadata();
- assertFalse(deletedKeyMetadata.containsKey(OzoneConsts.GDPR_FLAG));
- assertFalse(deletedKeyMetadata.containsKey(OzoneConsts.GDPR_SECRET));
- assertFalse(deletedKeyMetadata.containsKey(OzoneConsts.GDPR_ALGORITHM));
+ assertThat(deletedKeyMetadata).doesNotContainKey(OzoneConsts.GDPR_FLAG);
+ assertThat(deletedKeyMetadata).doesNotContainKey(OzoneConsts.GDPR_SECRET);
+
assertThat(deletedKeyMetadata).doesNotContainKey(OzoneConsts.GDPR_ALGORITHM);
assertNull(deletedKeys.getOmKeyInfoList().get(0).getFileEncryptionInfo());
}
@@ -560,8 +562,7 @@ class TestOzoneAtRestEncryption {
// Create an input stream to read the data
try (OzoneInputStream inputStream = bucket.readKey(keyName)) {
- assertTrue(inputStream.getInputStream()
- instanceof MultipartInputStream);
+ assertInstanceOf(MultipartInputStream.class,
inputStream.getInputStream());
// Test complete read
byte[] completeRead = new byte[keySize];
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientMultipartUploadWithFSO.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientMultipartUploadWithFSO.java
index 4aee60b60b..4867be4906 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientMultipartUploadWithFSO.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientMultipartUploadWithFSO.java
@@ -83,6 +83,7 @@ import static
org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes.NO_S
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -494,7 +495,7 @@ public class TestOzoneClientMultipartUploadWithFSO {
ozoneOutputStream.close();
fail("testCommitPartAfterCompleteUpload failed");
} catch (IOException ex) {
- assertTrue(ex instanceof OMException);
+ assertInstanceOf(OMException.class, ex);
assertEquals(NO_SUCH_MULTIPART_UPLOAD_ERROR,
((OMException) ex).getResult());
}
@@ -527,7 +528,7 @@ public class TestOzoneClientMultipartUploadWithFSO {
ozoneOutputStream.close();
fail("testAbortUploadFailWithInProgressPartUpload failed");
} catch (IOException ex) {
- assertTrue(ex instanceof OMException);
+ assertInstanceOf(OMException.class, ex);
assertEquals(NO_SUCH_MULTIPART_UPLOAD_ERROR,
((OMException) ex).getResult());
}
@@ -658,8 +659,7 @@ public class TestOzoneClientMultipartUploadWithFSO {
listPartNames.remove(partKeyName);
}
- assertTrue(listPartNames.isEmpty(),
- "Wrong partKeyName format in DB!");
+ assertThat(listPartNames).withFailMessage("Wrong partKeyName format in
DB!").isEmpty();
}
private String verifyPartNames(Map<Integer, String> partsMap, int index,
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientRetriesOnExceptionFlushDelay.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientRetriesOnExceptionFlushDelay.java
index 49a3db9187..925cfd9d95 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientRetriesOnExceptionFlushDelay.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientRetriesOnExceptionFlushDelay.java
@@ -46,8 +46,9 @@ import org.apache.hadoop.ozone.container.ContainerTestHelper;
import org.apache.hadoop.ozone.container.TestHelper;
import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import org.apache.ratis.protocol.exceptions.GroupMismatchException;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
@@ -144,8 +145,8 @@ public class TestOzoneClientRetriesOnExceptionFlushDelay {
byte[] data1 =
ContainerTestHelper.getFixedLengthString(keyString, dataLength)
.getBytes(UTF_8);
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
- KeyOutputStream keyOutputStream = (KeyOutputStream) key.getOutputStream();
+ KeyOutputStream keyOutputStream =
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
long containerID =
keyOutputStream.getStreamEntries().get(0).
getBlockID().getContainerID();
@@ -164,14 +165,13 @@ public class TestOzoneClientRetriesOnExceptionFlushDelay {
key.write(data1);
OutputStream stream = keyOutputStream.getStreamEntries().get(0)
.getOutputStream();
- assertTrue(stream instanceof BlockOutputStream);
- BlockOutputStream blockOutputStream = (BlockOutputStream) stream;
+ BlockOutputStream blockOutputStream =
assertInstanceOf(BlockOutputStream.class, stream);
TestHelper.waitForPipelineClose(key, cluster, false);
key.flush();
- assertTrue(HddsClientUtils.checkForException(blockOutputStream
- .getIoException()) instanceof GroupMismatchException);
- assertTrue(keyOutputStream.getExcludeList().getPipelineIds()
- .contains(pipeline.getId()));
+ assertInstanceOf(GroupMismatchException.class,
+ HddsClientUtils.checkForException(blockOutputStream.getIoException()));
+ assertThat(keyOutputStream.getExcludeList().getPipelineIds())
+ .contains(pipeline.getId());
assertEquals(2, keyOutputStream.getStreamEntries().size());
key.close();
assertEquals(0, keyOutputStream.getStreamEntries().size());
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientRetriesOnExceptions.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientRetriesOnExceptions.java
index 037965f580..5d6b601ad9 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientRetriesOnExceptions.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneClientRetriesOnExceptions.java
@@ -50,8 +50,9 @@ import org.apache.hadoop.ozone.container.ContainerTestHelper;
import org.apache.hadoop.ozone.container.TestHelper;
import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.fail;
import org.apache.ratis.protocol.exceptions.GroupMismatchException;
import org.junit.jupiter.api.AfterEach;
@@ -153,8 +154,8 @@ public class TestOzoneClientRetriesOnExceptions {
byte[] data1 =
ContainerTestHelper.getFixedLengthString(keyString, dataLength)
.getBytes(UTF_8);
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
- KeyOutputStream keyOutputStream = (KeyOutputStream) key.getOutputStream();
+ KeyOutputStream keyOutputStream =
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
long containerID =
keyOutputStream.getStreamEntries().get(0).
getBlockID().getContainerID();
@@ -173,14 +174,13 @@ public class TestOzoneClientRetriesOnExceptions {
key.write(data1);
OutputStream stream = keyOutputStream.getStreamEntries().get(0)
.getOutputStream();
- assertTrue(stream instanceof BlockOutputStream);
- BlockOutputStream blockOutputStream = (BlockOutputStream) stream;
+ BlockOutputStream blockOutputStream =
assertInstanceOf(BlockOutputStream.class, stream);
TestHelper.waitForPipelineClose(key, cluster, false);
key.flush();
- assertTrue(HddsClientUtils.checkForException(blockOutputStream
- .getIoException()) instanceof GroupMismatchException);
- assertTrue(keyOutputStream.getExcludeList().getPipelineIds()
- .contains(pipeline.getId()));
+ assertInstanceOf(GroupMismatchException.class,
+ HddsClientUtils.checkForException(blockOutputStream.getIoException()));
+ assertThat(keyOutputStream.getExcludeList().getPipelineIds())
+ .contains(pipeline.getId());
assertEquals(2, keyOutputStream.getStreamEntries().size());
key.close();
assertEquals(0, keyOutputStream.getStreamEntries().size());
@@ -192,8 +192,8 @@ public class TestOzoneClientRetriesOnExceptions {
String keyName = getKeyName();
OzoneOutputStream key = createKey(
keyName, ReplicationType.RATIS, (MAX_RETRIES + 1) * blockSize);
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
- KeyOutputStream keyOutputStream = (KeyOutputStream) key.getOutputStream();
+ KeyOutputStream keyOutputStream =
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
List<BlockOutputStreamEntry> entries = keyOutputStream.getStreamEntries();
assertEquals((MAX_RETRIES + 1),
keyOutputStream.getStreamEntries().size());
@@ -222,8 +222,7 @@ public class TestOzoneClientRetriesOnExceptions {
}
key.write(data1);
OutputStream stream = entries.get(0).getOutputStream();
- assertTrue(stream instanceof BlockOutputStream);
- BlockOutputStream blockOutputStream = (BlockOutputStream) stream;
+ BlockOutputStream blockOutputStream =
assertInstanceOf(BlockOutputStream.class, stream);
TestHelper.waitForContainerClose(key, cluster);
// Ensure that blocks for the key have been allocated to at least N+1
// containers so that write request will be tried on N+1 different blocks
@@ -237,19 +236,18 @@ public class TestOzoneClientRetriesOnExceptions {
key.flush();
fail("Expected exception not thrown");
} catch (IOException ioe) {
- assertTrue(HddsClientUtils.checkForException(blockOutputStream
- .getIoException()) instanceof ContainerNotOpenException);
- assertTrue(ioe.
- getMessage().contains(
+ assertInstanceOf(ContainerNotOpenException.class,
+
HddsClientUtils.checkForException(blockOutputStream.getIoException()));
+ assertThat(ioe.getMessage()).contains(
"Retry request failed. " +
"retries get failed due to exceeded maximum " +
- "allowed retries number: " + MAX_RETRIES));
+ "allowed retries number: " + MAX_RETRIES);
}
try {
key.flush();
fail("Expected exception not thrown");
} catch (IOException ioe) {
- assertTrue(ioe.getMessage().contains("Stream is closed"));
+ assertThat(ioe.getMessage()).contains("Stream is closed");
}
try {
key.close();
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientAbstract.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientAbstract.java
index 244dc08141..4e0c9bbf5b 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientAbstract.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientAbstract.java
@@ -125,7 +125,6 @@ import static java.nio.charset.StandardCharsets.UTF_8;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.RandomUtils;
-import org.apache.commons.lang3.StringUtils;
import static org.apache.hadoop.hdds.StringUtils.string2Bytes;
import static org.apache.hadoop.hdds.client.ReplicationFactor.ONE;
import static org.apache.hadoop.hdds.client.ReplicationFactor.THREE;
@@ -149,6 +148,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -675,7 +675,7 @@ public abstract class TestOzoneRpcClientAbstract {
volume.createBucket(bucketName, builder.build());
OzoneBucket bucket = volume.getBucket(bucketName);
assertEquals(bucketName, bucket.getName());
- assertTrue(bucket.getAcls().contains(userAcl));
+ assertThat(bucket.getAcls()).contains(userAcl);
}
@Test
@@ -717,7 +717,7 @@ public abstract class TestOzoneRpcClientAbstract {
assertEquals(bucketName, bucket.getName());
assertTrue(bucket.getVersioning());
assertEquals(StorageType.SSD, bucket.getStorageType());
- assertTrue(bucket.getAcls().contains(userAcl));
+ assertThat(bucket.getAcls()).contains(userAcl);
assertEquals(repConfig, bucket.getReplicationConfig());
}
@@ -749,7 +749,7 @@ public abstract class TestOzoneRpcClientAbstract {
}
OzoneBucket newBucket = volume.getBucket(bucketName);
assertEquals(bucketName, newBucket.getName());
- assertTrue(bucket.getAcls().contains(acls.get(0)));
+ assertThat(bucket.getAcls()).contains(acls.get(0));
}
@Test
@@ -772,7 +772,7 @@ public abstract class TestOzoneRpcClientAbstract {
}
OzoneBucket newBucket = volume.getBucket(bucketName);
assertEquals(bucketName, newBucket.getName());
- assertFalse(bucket.getAcls().contains(acls.get(0)));
+ assertThat(bucket.getAcls()).doesNotContain(acls.get(0));
}
@Test
@@ -800,11 +800,11 @@ public abstract class TestOzoneRpcClientAbstract {
// Remove the 2nd acl added to the list.
boolean remove = store.removeAcl(ozoneObj, acls.get(1));
assertTrue(remove);
- assertFalse(store.getAcl(ozoneObj).contains(acls.get(1)));
+ assertThat(store.getAcl(ozoneObj)).doesNotContain(acls.get(1));
remove = store.removeAcl(ozoneObj, acls.get(0));
assertTrue(remove);
- assertFalse(store.getAcl(ozoneObj).contains(acls.get(0)));
+ assertThat(store.getAcl(ozoneObj)).doesNotContain(acls.get(0));
}
@Test
@@ -1432,7 +1432,7 @@ public abstract class TestOzoneRpcClientAbstract {
IOException ioException = assertThrows(IOException.class,
() -> writeKey(bucket, key3, ONE, value, value.length()));
- assertTrue(ioException.toString().contains("QUOTA_EXCEEDED"));
+ assertThat(ioException.toString()).contains("QUOTA_EXCEEDED");
// Write failed, bucket usedNamespace should remain as 2
assertEquals(2L,
@@ -1665,8 +1665,9 @@ public abstract class TestOzoneRpcClientAbstract {
latch.await(600, TimeUnit.SECONDS);
- assertTrue(failCount.get() <= 0,
- "testPutKeyRatisThreeNodesParallel failed");
+ assertThat(failCount.get())
+ .withFailMessage("testPutKeyRatisThreeNodesParallel failed")
+ .isLessThanOrEqualTo(0);
}
@@ -2035,7 +2036,7 @@ public abstract class TestOzoneRpcClientAbstract {
OzoneKey key = bucket.getKey(keyName);
List<OzoneKeyLocation> keyLocation =
((OzoneKeyDetails) key).getOzoneKeyLocations();
- assertFalse(keyLocation.isEmpty(), "Key location not found in OM");
+ assertThat(keyLocation).withFailMessage("Key location not found in
OM").isNotEmpty();
long containerID = ((OzoneKeyDetails) key).getOzoneKeyLocations().get(0)
.getContainerID();
@@ -2052,7 +2053,7 @@ public abstract class TestOzoneRpcClientAbstract {
}
}
}
- assertFalse(containerList.isEmpty(), "Container not found");
+ assertThat(containerList).withFailMessage("Container not
found").isNotEmpty();
corruptData(containerList.get(0), key);
// Try reading the key. Read will fail on the first node and will
eventually
// failover to next replica
@@ -2811,9 +2812,8 @@ public abstract class TestOzoneRpcClientAbstract {
initiateMultipartUpload(bucket2, keyName2, anyReplication());
fail("User without permission should fail");
} catch (Exception e) {
- assertTrue(e instanceof OMException);
- assertEquals(ResultCodes.PERMISSION_DENIED,
- ((OMException) e).getResult());
+ OMException ome = assertInstanceOf(OMException.class, e);
+ assertEquals(ResultCodes.PERMISSION_DENIED, ome.getResult());
}
// Add create permission for user, and try multi-upload init again
@@ -2846,9 +2846,8 @@ public abstract class TestOzoneRpcClientAbstract {
try (OzoneInputStream ignored = bucket2.readKey(keyName)) {
fail("User without permission should fail");
} catch (Exception e) {
- assertTrue(e instanceof OMException);
- assertEquals(ResultCodes.PERMISSION_DENIED,
- ((OMException) e).getResult());
+ OMException ome = assertInstanceOf(OMException.class, e);
+ assertEquals(ResultCodes.PERMISSION_DENIED, ome.getResult());
}
}
}
@@ -3058,9 +3057,8 @@ public abstract class TestOzoneRpcClientAbstract {
ozoneOutputStream.close();
fail("testAbortUploadFailWithInProgressPartUpload failed");
} catch (IOException ex) {
- assertTrue(ex instanceof OMException);
- assertEquals(NO_SUCH_MULTIPART_UPLOAD_ERROR,
- ((OMException) ex).getResult());
+ OMException ome = assertInstanceOf(OMException.class, ex);
+ assertEquals(NO_SUCH_MULTIPART_UPLOAD_ERROR, ome.getResult());
}
}
@@ -3121,9 +3119,8 @@ public abstract class TestOzoneRpcClientAbstract {
ozoneOutputStream.close();
fail("testCommitPartAfterCompleteUpload failed");
} catch (IOException ex) {
- assertTrue(ex instanceof OMException);
- assertEquals(NO_SUCH_MULTIPART_UPLOAD_ERROR,
- ((OMException) ex).getResult());
+ OMException ome = assertInstanceOf(OMException.class, ex);
+ assertEquals(NO_SUCH_MULTIPART_UPLOAD_ERROR, ome.getResult());
}
}
@@ -3401,20 +3398,12 @@ public abstract class TestOzoneRpcClientAbstract {
}
}
List<OzoneAcl> acls = store.getAcl(parentObj);
- assertTrue(acls.contains(defaultUserAcl),
- "Current acls: " + StringUtils.join(",", acls) +
- " inheritedUserAcl: " + inheritedUserAcl);
- assertTrue(acls.contains(defaultGroupAcl),
- "Current acls: " + StringUtils.join(",", acls) +
- " inheritedGroupAcl: " + inheritedGroupAcl);
+ assertThat(acls).contains(defaultUserAcl);
+ assertThat(acls).contains(defaultGroupAcl);
acls = store.getAcl(childObj);
- assertTrue(acls.contains(inheritedUserAcl),
- "Current acls:" + StringUtils.join(",", acls) +
- " inheritedUserAcl:" + inheritedUserAcl);
- assertTrue(acls.contains(inheritedGroupAcl),
- "Current acls:" + StringUtils.join(",", acls) +
- " inheritedGroupAcl:" + inheritedGroupAcl);
+ assertThat(acls).contains(inheritedUserAcl);
+ assertThat(acls).contains(inheritedGroupAcl);
}
@Test
@@ -3468,10 +3457,8 @@ public abstract class TestOzoneRpcClientAbstract {
// Prefix should inherit DEFAULT acl from bucket.
List<OzoneAcl> acls = store.getAcl(prefixObj);
- assertTrue(acls.contains(inheritedUserAcl),
- "Current acls:" + StringUtils.join(",", acls));
- assertTrue(acls.contains(inheritedGroupAcl),
- "Current acls:" + StringUtils.join(",", acls));
+ assertThat(acls).contains(inheritedUserAcl);
+ assertThat(acls).contains(inheritedGroupAcl);
// Remove inherited acls from prefix.
assertTrue(store.removeAcl(prefixObj, inheritedUserAcl));
assertTrue(store.removeAcl(prefixObj, inheritedGroupAcl));
@@ -3607,8 +3594,7 @@ public abstract class TestOzoneRpcClientAbstract {
&& acl.getType().equals(newAcl.getType()))
.findFirst();
assertTrue(readAcl.isPresent(), "New acl expected but not found.");
- assertTrue(readAcl.get().getAclList().contains(ACLType.READ_ACL),
- "READ_ACL should exist in current acls:" + readAcl.get());
+ assertThat(readAcl.get().getAclList()).contains(ACLType.READ_ACL);
// Case:2 Remove newly added acl permission.
@@ -3620,14 +3606,13 @@ public abstract class TestOzoneRpcClientAbstract {
&& acl.getType().equals(newAcl.getType()))
.findFirst();
assertTrue(nonReadAcl.isPresent(), "New acl expected but not found.");
- assertFalse(nonReadAcl.get().getAclList().contains(ACLType.READ_ACL),
- "READ_ACL should not exist in current acls:" + nonReadAcl.get());
+
assertThat(nonReadAcl.get().getAclList()).doesNotContain(ACLType.READ_ACL);
} else {
fail("Default acl should not be empty.");
}
List<OzoneAcl> keyAcls = store.getAcl(ozObj);
- expectedAcls.forEach(a -> assertTrue(keyAcls.contains(a)));
+ assertThat(keyAcls).containsAll(expectedAcls);
// Remove all acl's.
for (OzoneAcl a : expectedAcls) {
@@ -3646,7 +3631,7 @@ public abstract class TestOzoneRpcClientAbstract {
newAcls = store.getAcl(ozObj);
assertEquals(expectedAcls.size(), newAcls.size());
List<OzoneAcl> finalNewAcls = newAcls;
- expectedAcls.forEach(a -> assertTrue(finalNewAcls.contains(a)));
+ assertThat(finalNewAcls).containsAll(expectedAcls);
// Reset acl's.
OzoneAcl ua = new OzoneAcl(USER, "userx",
@@ -3656,8 +3641,8 @@ public abstract class TestOzoneRpcClientAbstract {
store.setAcl(ozObj, Arrays.asList(ua, ug));
newAcls = store.getAcl(ozObj);
assertEquals(2, newAcls.size());
- assertTrue(newAcls.contains(ua));
- assertTrue(newAcls.contains(ug));
+ assertThat(newAcls).contains(ua);
+ assertThat(newAcls).contains(ug);
}
private void writeKey(String key1, OzoneBucket bucket) throws IOException {
@@ -3958,11 +3943,9 @@ public abstract class TestOzoneRpcClientAbstract {
if (deletedKeys != null) {
Map<String, String> deletedKeyMetadata =
deletedKeys.getOmKeyInfoList().get(0).getMetadata();
- assertFalse(deletedKeyMetadata.containsKey(OzoneConsts.GDPR_FLAG));
- assertFalse(
- deletedKeyMetadata.containsKey(OzoneConsts.GDPR_SECRET));
- assertFalse(
- deletedKeyMetadata.containsKey(OzoneConsts.GDPR_ALGORITHM));
+ assertThat(deletedKeyMetadata).doesNotContainKey(OzoneConsts.GDPR_FLAG);
+
assertThat(deletedKeyMetadata).doesNotContainKey(OzoneConsts.GDPR_SECRET);
+
assertThat(deletedKeyMetadata).doesNotContainKey(OzoneConsts.GDPR_ALGORITHM);
}
}
@@ -3983,7 +3966,7 @@ public abstract class TestOzoneRpcClientAbstract {
List<OzoneAcl> ozoneAclList = store.getAcl(s3vVolume);
- assertTrue(ozoneAclList.contains(ozoneAcl));
+ assertThat(ozoneAclList).contains(ozoneAcl);
}
@Test
@@ -4082,7 +4065,7 @@ public abstract class TestOzoneRpcClientAbstract {
cluster.getOzoneManager().getMetadataManager()
.getOzoneKey(volumeName, bucketName, keyName));
- assertTrue(rangeKVs.size() > 0);
+ assertThat(rangeKVs.size()).isGreaterThan(0);
assertEquals(expectedCount,
rangeKVs.get(0).getValue().getOmKeyInfoList().size());
} else {
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientForAclAuditLog.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientForAclAuditLog.java
index 8b75d05c9c..a830c8c739 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientForAclAuditLog.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestOzoneRpcClientForAclAuditLog.java
@@ -61,6 +61,7 @@ import static
org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_ADMINISTRATORS;
import static
org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_ADMINISTRATORS_WILDCARD;
import static
org.apache.hadoop.ozone.security.acl.OzoneObj.ResourceType.VOLUME;
import static org.apache.hadoop.ozone.security.acl.OzoneObj.StoreType.OZONE;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -204,7 +205,7 @@ public class TestOzoneRpcClientForAclAuditLog {
List<OzoneAcl> acls = store.getAcl(volObj);
verifyLog(OMAction.GET_ACL.name(), volumeName,
AuditEventStatus.SUCCESS.name());
- assertTrue(acls.size() > 0);
+ assertThat(acls.size()).isGreaterThan(0);
//Testing addAcl
store.addAcl(volObj, USER_ACL);
@@ -286,7 +287,7 @@ public class TestOzoneRpcClientForAclAuditLog {
// that must be equal to the expected string
assertNotEquals(0, lines.size());
for (String exp: expected) {
- assertTrue(lines.get(0).contains(exp));
+ assertThat(lines.get(0)).contains(exp);
}
} catch (AssertionError ex) {
LOG.error("Error occurred in log verification", ex);
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestValidateBCSIDOnRestart.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestValidateBCSIDOnRestart.java
index 1aea5b3708..a8029987fe 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestValidateBCSIDOnRestart.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestValidateBCSIDOnRestart.java
@@ -60,10 +60,10 @@ import static
org.apache.hadoop.hdds.HddsConfigKeys.HDDS_CONTAINER_REPORT_INTERV
import static
org.apache.hadoop.hdds.HddsConfigKeys.HDDS_PIPELINE_REPORT_INTERVAL;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_PIPELINE_DESTROY_TIMEOUT;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.ratis.statemachine.impl.SimpleStateMachineStorage;
import org.apache.ratis.statemachine.impl.StatemachineImplTestUtil;
import org.junit.jupiter.api.AfterAll;
@@ -176,9 +176,8 @@ public class TestValidateBCSIDOnRestart {
.getContainer().getContainerSet()
.getContainer(omKeyLocationInfo.getContainerID())
.getContainerData();
- assertTrue(containerData instanceof KeyValueContainerData);
KeyValueContainerData keyValueContainerData =
- (KeyValueContainerData) containerData;
+ assertInstanceOf(KeyValueContainerData.class, containerData);
key.close();
long containerID = omKeyLocationInfo.getContainerID();
@@ -203,12 +202,12 @@ public class TestValidateBCSIDOnRestart {
stateMachine.buildMissingContainerSet(parentPath.toFile());
// Since the snapshot threshold is set to 1, since there are
// applyTransactions, we should see snapshots
- assertTrue(parentPath.getParent().toFile().listFiles().length > 0);
+
assertThat(parentPath.getParent().toFile().listFiles().length).isGreaterThan(0);
// make sure the missing containerSet is not empty
HddsDispatcher dispatcher = (HddsDispatcher)
ozoneContainer.getDispatcher();
- assertFalse(dispatcher.getMissingContainerSet().isEmpty());
- assertTrue(dispatcher.getMissingContainerSet().contains(containerID));
+ assertThat(dispatcher.getMissingContainerSet()).isNotEmpty();
+ assertThat(dispatcher.getMissingContainerSet()).contains(containerID);
// write a new key
key = objectStore.getVolume(volumeName).getBucket(bucketName)
.createKey("ratis", 1024,
@@ -229,8 +228,7 @@ public class TestValidateBCSIDOnRestart {
.getContainer().getContainerSet()
.getContainer(omKeyLocationInfo.getContainerID())
.getContainerData();
- assertTrue(containerData instanceof KeyValueContainerData);
- keyValueContainerData = (KeyValueContainerData) containerData;
+ keyValueContainerData = assertInstanceOf(KeyValueContainerData.class,
containerData);
try (DBHandle db = BlockUtils.getDB(keyValueContainerData, conf)) {
// modify the bcsid for the container in the ROCKS DB thereby inducing
diff --git
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestWatchForCommit.java
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestWatchForCommit.java
index 9289d4fb6d..d03c57bf4e 100644
---
a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestWatchForCommit.java
+++
b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/client/rpc/TestWatchForCommit.java
@@ -65,9 +65,10 @@ import org.apache.ozone.test.tag.Flaky;
import static java.nio.charset.StandardCharsets.UTF_8;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_STALENODE_INTERVAL;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.fail;
import org.apache.ratis.protocol.exceptions.GroupMismatchException;
@@ -187,12 +188,12 @@ public class TestWatchForCommit {
ContainerTestHelper.getFixedLengthString(keyString, dataLength)
.getBytes(UTF_8);
key.write(data1);
- assertTrue(key.getOutputStream() instanceof KeyOutputStream);
- KeyOutputStream keyOutputStream = (KeyOutputStream)key.getOutputStream();
+ KeyOutputStream keyOutputStream =
+ assertInstanceOf(KeyOutputStream.class, key.getOutputStream());
OutputStream stream = keyOutputStream.getStreamEntries().get(0)
.getOutputStream();
- assertTrue(stream instanceof BlockOutputStream);
+ assertInstanceOf(BlockOutputStream.class, stream);
RatisBlockOutputStream blockOutputStream = (RatisBlockOutputStream) stream;
// we have just written data more than flush Size(2 chunks), at this time
// buffer pool will have 3 buffers allocated worth of chunk size
@@ -204,11 +205,12 @@ public class TestWatchForCommit {
// since data equals to maxBufferSize is written, this will be a blocking
// call and hence will wait for atleast flushSize worth of data to get
// acked by all servers right here
- assertTrue(blockOutputStream.getTotalAckDataLength() >= flushSize);
+ assertThat(blockOutputStream.getTotalAckDataLength())
+ .isGreaterThanOrEqualTo(flushSize);
// watchForCommit will clean up atleast one entry from the map where each
// entry corresponds to flushSize worth of data
- assertTrue(
- blockOutputStream.getCommitIndex2flushedDataMap().size() <= 1);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(1);
// Now do a flush. This will flush the data and update the flush length and
// the map.
key.flush();
@@ -218,8 +220,8 @@ public class TestWatchForCommit {
assertEquals(dataLength, blockOutputStream.getWrittenDataLength());
assertEquals(dataLength, blockOutputStream.getTotalDataFlushedLength());
// flush will make sure one more entry gets updated in the map
- assertTrue(
- blockOutputStream.getCommitIndex2flushedDataMap().size() <= 2);
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap().size())
+ .isLessThanOrEqualTo(2);
XceiverClientRatis raftClient =
(XceiverClientRatis) blockOutputStream.getXceiverClient();
assertEquals(3, raftClient.getCommitInfoMap().size());
@@ -243,7 +245,7 @@ public class TestWatchForCommit {
assertEquals(dataLength, blockOutputStream.getTotalAckDataLength());
// make sure the bufferPool is empty
assertEquals(0, blockOutputStream.getBufferPool().computeBufferData());
- assertTrue(blockOutputStream.getCommitIndex2flushedDataMap().isEmpty());
+ assertThat(blockOutputStream.getCommitIndex2flushedDataMap()).isEmpty();
validateData(keyName, data1);
}
@@ -281,7 +283,7 @@ public class TestWatchForCommit {
.watchForCommit(index + new Random().nextInt(100) + 10);
fail("expected exception not thrown");
} catch (Exception e) {
- assertTrue(e instanceof ExecutionException);
+ assertInstanceOf(ExecutionException.class, e);
// since the timeout value is quite long, the watch request will either
// fail with NotReplicated exceptio, RetryFailureException or
// RuntimeException
@@ -290,7 +292,7 @@ public class TestWatchForCommit {
// client should not attempt to watch with
// MAJORITY_COMMITTED replication level, except the grpc IO issue
if (!logCapturer.getOutput().contains("Connection refused")) {
- assertFalse(e.getMessage().contains("Watch-MAJORITY_COMMITTED"));
+
assertThat(e.getMessage()).doesNotContain("Watch-MAJORITY_COMMITTED");
}
}
clientManager.releaseClient(xceiverClient, false);
@@ -338,9 +340,9 @@ public class TestWatchForCommit {
assertEquals(2, ratisClient.getCommitInfoMap().size());
clientManager.releaseClient(xceiverClient, false);
String output = logCapturer.getOutput();
- assertTrue(output.contains("3 way commit failed"));
- assertTrue(output.contains("TimeoutException"));
- assertTrue(output.contains("Committed by majority"));
+ assertThat(output).contains("3 way commit failed");
+ assertThat(output).contains("TimeoutException");
+ assertThat(output).contains("Committed by majority");
}
logCapturer.stopCapturing();
}
@@ -375,8 +377,7 @@ public class TestWatchForCommit {
new Random().nextInt(100) + 10);
fail("Expected exception not thrown");
} catch (Exception e) {
- assertTrue(HddsClientUtils
- .checkForException(e) instanceof GroupMismatchException);
+ assertInstanceOf(GroupMismatchException.class,
HddsClientUtils.checkForException(e));
}
clientManager.releaseClient(xceiverClient, false);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
