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 24d44938a3 HDDS-9973. Add static import for assertions and mocks in
hdds-common (#5872)
24d44938a3 is described below
commit 24d44938a3382f8d163629cb204425486a4192c3
Author: Raju Balpande <[email protected]>
AuthorDate: Fri Dec 29 18:21:22 2023 +0530
HDDS-9973. Add static import for assertions and mocks in hdds-common (#5872)
---
.../java/org/apache/hadoop/hdds/TestHddsUtils.java | 8 +-
.../conf/TestGeneratedConfigurationOverwrite.java | 13 +-
.../hadoop/hdds/conf/TestOzoneConfiguration.java | 109 ++++++++---------
.../ratis/TestContainerCommandRequestMessage.java | 5 +-
.../apache/hadoop/hdds/ratis/TestRatisHelper.java | 56 ++++-----
...TestServerNotLeaderExceptionMessageParsing.java | 16 +--
.../scm/container/TestContainerReplicaInfo.java | 36 +++---
.../container/common/helpers/TestExcludeList.java | 13 +-
.../hdds/scm/net/TestNetworkTopologyImpl.java | 5 +-
.../hdds/upgrade/TestHDDSLayoutVersionManager.java | 11 +-
.../hadoop/hdds/utils/TestHddsIdFactory.java | 8 +-
.../hadoop/hdds/utils/TestResourceCache.java | 17 +--
.../apache/hadoop/hdds/utils/db/CodecTestUtil.java | 25 ++--
.../hadoop/hdds/utils/db/TestLeakDetector.java | 9 +-
.../org/apache/hadoop/ozone/TestOzoneConsts.java | 6 +-
.../apache/hadoop/ozone/common/TestChecksum.java | 15 ++-
.../ozone/common/TestChecksumByteBuffer.java | 5 +-
.../hadoop/ozone/common/TestChunkBuffer.java | 61 +++++-----
.../hadoop/ozone/common/TestStateMachine.java | 29 +++--
.../apache/hadoop/ozone/ha/TestOzoneNetUtils.java | 7 +-
.../hadoop/ozone/lease/TestLeaseManager.java | 133 +++++++++++----------
.../apache/hadoop/ozone/lock/TestLockManager.java | 31 ++---
.../ozone/upgrade/TestBasicUpgradeFinalizer.java | 21 ++--
23 files changed, 312 insertions(+), 327 deletions(-)
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/TestHddsUtils.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/TestHddsUtils.java
index 2376af6863..fca23cf8ae 100644
--- a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/TestHddsUtils.java
+++ b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/TestHddsUtils.java
@@ -31,6 +31,7 @@ import org.apache.hadoop.hdds.conf.OzoneConfiguration;
import org.apache.hadoop.hdds.scm.ScmConfigKeys;
import org.apache.hadoop.ozone.ha.ConfUtils;
import org.apache.hadoop.fs.CommonConfigurationKeysPublic;
+import org.junit.jupiter.api.Test;
import static org.apache.hadoop.hdds.HddsUtils.getSCMAddressForDatanodes;
import static org.apache.hadoop.hdds.HddsUtils.processForLogging;
@@ -38,12 +39,9 @@ import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_ADDRESS_KEY;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_DATANODE_PORT_DEFAULT;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_DATANODE_PORT_KEY;
import static
org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_PIPELINE_OWNER_CONTAINER_COUNT;
-
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
@@ -199,7 +197,7 @@ public class TestHddsUtils {
Collection<InetSocketAddress> scmAddressList =
HddsUtils.getSCMAddressForDatanodes(conf);
- Assertions.assertNotNull(scmAddressList);
+ assertNotNull(scmAddressList);
assertEquals(3, scmAddressList.size());
for (InetSocketAddress next : scmAddressList) {
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/conf/TestGeneratedConfigurationOverwrite.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/conf/TestGeneratedConfigurationOverwrite.java
index be40692acd..0894b7ab00 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/conf/TestGeneratedConfigurationOverwrite.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/conf/TestGeneratedConfigurationOverwrite.java
@@ -18,7 +18,6 @@
package org.apache.hadoop.hdds.conf;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -26,6 +25,9 @@ import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
/**
* In HDDS-5035, we met the case that ozone-default-generated.xml got
* overwritten in an assemble jar, here we are trying to simulate this case
@@ -54,13 +56,10 @@ public class TestGeneratedConfigurationOverwrite {
@Test
public void getConfigurationObject() {
// Check Config Type of String
- Assertions.assertNotNull(
- conf.getObject(SimpleConfiguration.class).getBindHost());
+ assertNotNull(conf.getObject(SimpleConfiguration.class).getBindHost());
// Check Config Type of Int
- Assertions.assertNotEquals(
- conf.getObject(SimpleConfiguration.class).getPort(), 0);
+ assertNotEquals(0, conf.getObject(SimpleConfiguration.class).getPort());
// Check Config Type of Time
- Assertions.assertNotEquals(
- conf.getObject(SimpleConfiguration.class).getWaitTime(), 0);
+ assertNotEquals(0,
conf.getObject(SimpleConfiguration.class).getWaitTime());
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/conf/TestOzoneConfiguration.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/conf/TestOzoneConfiguration.java
index 97b62a138f..c9ee219a67 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/conf/TestOzoneConfiguration.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/conf/TestOzoneConfiguration.java
@@ -30,13 +30,19 @@ import java.util.concurrent.TimeUnit;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;
+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.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
/**
* Test class for OzoneConfiguration.
*/
@@ -80,7 +86,7 @@ public class TestOzoneConfiguration {
Path fileResource = new Path(coreDefault.getAbsolutePath());
conf.addResource(fileResource);
- Assertions.assertEquals("XYZ", conf.getAllPropertiesByTag("MYCUSTOMTAG")
+ assertEquals("XYZ", conf.getAllPropertiesByTag("MYCUSTOMTAG")
.getProperty("dfs.random.key"));
}
@@ -98,11 +104,11 @@ public class TestOzoneConfiguration {
}
// Test if values are getting overridden even without tags being present
- Assertions.assertEquals("3", conf.getAllPropertiesByTag("HDFS")
+ assertEquals("3", conf.getAllPropertiesByTag("HDFS")
.getProperty("dfs.replication"));
- Assertions.assertEquals("ABC", conf.getAllPropertiesByTag("MYCUSTOMTAG")
+ assertEquals("ABC", conf.getAllPropertiesByTag("MYCUSTOMTAG")
.getProperty("dfs.random.key"));
- Assertions.assertEquals("true", conf.getAllPropertiesByTag("YARN")
+ assertEquals("true", conf.getAllPropertiesByTag("YARN")
.getProperty("dfs.cblock.trace.io"));
}
@@ -122,14 +128,14 @@ public class TestOzoneConfiguration {
SimpleConfiguration configuration =
ozoneConfig.getObject(SimpleConfiguration.class);
- Assertions.assertEquals("host", configuration.getBindHost());
- Assertions.assertEquals("address", configuration.getClientAddress());
- Assertions.assertTrue(configuration.isEnabled());
- Assertions.assertEquals(5555, configuration.getPort());
- Assertions.assertEquals(600, configuration.getWaitTime());
- Assertions.assertSame(Integer.class, configuration.getMyClass());
- Assertions.assertEquals(10.5, configuration.getThreshold());
- Assertions.assertEquals(Duration.ofSeconds(3),
configuration.getDuration());
+ assertEquals("host", configuration.getBindHost());
+ assertEquals("address", configuration.getClientAddress());
+ assertTrue(configuration.isEnabled());
+ assertEquals(5555, configuration.getPort());
+ assertEquals(600, configuration.getWaitTime());
+ assertSame(Integer.class, configuration.getMyClass());
+ assertEquals(10.5, configuration.getThreshold());
+ assertEquals(Duration.ofSeconds(3), configuration.getDuration());
}
@Test
@@ -139,11 +145,11 @@ public class TestOzoneConfiguration {
SimpleConfiguration configuration =
ozoneConfiguration.getObject(SimpleConfiguration.class);
- Assertions.assertTrue(configuration.isEnabled());
- Assertions.assertEquals(9878, configuration.getPort());
- Assertions.assertSame(Object.class, configuration.getMyClass());
- Assertions.assertEquals(10, configuration.getThreshold());
- Assertions.assertEquals(Duration.ofHours(1), configuration.getDuration());
+ assertTrue(configuration.isEnabled());
+ assertEquals(9878, configuration.getPort());
+ assertSame(Object.class, configuration.getMyClass());
+ assertEquals(10, configuration.getThreshold());
+ assertEquals(Duration.ofHours(1), configuration.getDuration());
}
@Test
@@ -165,21 +171,17 @@ public class TestOzoneConfiguration {
subject.setFromObject(object);
// THEN
- Assertions.assertEquals(object.getBindHost(),
- subject.get("test.scm.client.bind.host"));
- Assertions.assertEquals(object.getClientAddress(),
- subject.get("test.scm.client.address"));
- Assertions.assertEquals(object.isEnabled(),
- subject.getBoolean("test.scm.client.enabled", false));
- Assertions.assertEquals(object.getPort(),
- subject.getInt("test.scm.client.port", 0));
- Assertions.assertEquals(TimeUnit.SECONDS.toMinutes(object.getWaitTime()),
+ assertEquals(object.getBindHost(),
subject.get("test.scm.client.bind.host"));
+ assertEquals(object.getClientAddress(),
subject.get("test.scm.client.address"));
+ assertEquals(object.isEnabled(),
subject.getBoolean("test.scm.client.enabled", false));
+ assertEquals(object.getPort(), subject.getInt("test.scm.client.port", 0));
+ assertEquals(TimeUnit.SECONDS.toMinutes(object.getWaitTime()),
subject.getTimeDuration("test.scm.client.wait", 0, TimeUnit.MINUTES));
- Assertions.assertSame(this.getClass(),
+ assertSame(this.getClass(),
subject.getClass("test.scm.client.class", null));
- Assertions.assertEquals(object.getThreshold(),
+ assertEquals(object.getThreshold(),
subject.getDouble("test.scm.client.threshold", 20.5));
- Assertions.assertEquals(object.getDuration().toMillis(),
+ assertEquals(object.getDuration().toMillis(),
subject.getTimeDuration("test.scm.client.duration", 0,
TimeUnit.MILLISECONDS));
}
@@ -194,18 +196,13 @@ public class TestOzoneConfiguration {
subject.setFromObject(object);
// THEN
- Assertions.assertEquals("0.0.0.0",
- subject.get("test.scm.client.bind.host"));
- Assertions.assertEquals("localhost",
- subject.get("test.scm.client.address"));
- Assertions.assertTrue(
- subject.getBoolean("test.scm.client.enabled", false));
- Assertions.assertEquals(9878,
- subject.getInt("test.scm.client.port", 123));
- Assertions.assertEquals(TimeUnit.MINUTES.toSeconds(30),
+ assertEquals("0.0.0.0", subject.get("test.scm.client.bind.host"));
+ assertEquals("localhost", subject.get("test.scm.client.address"));
+ assertTrue(subject.getBoolean("test.scm.client.enabled", false));
+ assertEquals(9878, subject.getInt("test.scm.client.port", 123));
+ assertEquals(TimeUnit.MINUTES.toSeconds(30),
subject.getTimeDuration("test.scm.client.wait", 555,
TimeUnit.SECONDS));
- Assertions.assertEquals(10,
- subject.getDouble("test.scm.client.threshold", 20.5));
+ assertEquals(10, subject.getDouble("test.scm.client.threshold", 20.5));
}
@Test
@@ -229,10 +226,10 @@ public class TestOzoneConfiguration {
OzoneConfiguration ozoneConfiguration =
new OzoneConfiguration(configuration);
// ozoneConfig value matches input config value for the corresponding key
- Assertions.assertEquals(val, ozoneConfiguration.get(key));
- Assertions.assertEquals(val, configuration.get(key));
+ assertEquals(val, ozoneConfiguration.get(key));
+ assertEquals(val, configuration.get(key));
- Assertions.assertNotEquals(val, new OzoneConfiguration().get(key));
+ assertNotEquals(val, new OzoneConfiguration().get(key));
}
@Test
@@ -245,18 +242,12 @@ public class TestOzoneConfiguration {
subject.setFromObject(object);
// THEN
- Assertions.assertEquals("0.0.0.0",
- subject.get("test.scm.client.bind.host"));
- Assertions.assertEquals("localhost",
- subject.get("test.scm.client.address"));
- Assertions.assertFalse(
- subject.getBoolean("test.scm.client.enabled", false));
- Assertions.assertEquals(0,
- subject.getInt("test.scm.client.port", 123));
- Assertions.assertEquals(0,
- subject.getTimeDuration("test.scm.client.wait", 555,
TimeUnit.SECONDS));
- Assertions.assertEquals(0,
- subject.getDouble("test.scm.client.threshold", 20.5));
+ assertEquals("0.0.0.0", subject.get("test.scm.client.bind.host"));
+ assertEquals("localhost", subject.get("test.scm.client.address"));
+ assertFalse(subject.getBoolean("test.scm.client.enabled", false));
+ assertEquals(0, subject.getInt("test.scm.client.port", 123));
+ assertEquals(0, subject.getTimeDuration("test.scm.client.wait", 555,
TimeUnit.SECONDS));
+ assertEquals(0, subject.getDouble("test.scm.client.threshold", 20.5));
}
@Test
@@ -264,7 +255,7 @@ public class TestOzoneConfiguration {
OzoneConfiguration ozoneConfiguration = new OzoneConfiguration();
ozoneConfiguration.setInt("test.scm.client.port", -3);
- Assertions.assertThrows(NumberFormatException.class,
+ assertThrows(NumberFormatException.class,
() -> ozoneConfiguration.getObject(SimpleConfiguration.class));
}
@@ -272,14 +263,14 @@ public class TestOzoneConfiguration {
@EnumSource
void tagIsRecognized(ConfigTag tag) {
OzoneConfiguration subject = new OzoneConfiguration();
- Assertions.assertTrue(subject.isPropertyTag(tag.name()),
+ assertTrue(subject.isPropertyTag(tag.name()),
() -> tag + " should be recognized as config tag");
}
@Test
void unknownTag() {
OzoneConfiguration subject = new OzoneConfiguration();
- Assertions.assertFalse(subject.isPropertyTag("not-a-tag"));
+ assertFalse(subject.isPropertyTag("not-a-tag"));
}
private void appendProperty(BufferedWriter out, String name, String val)
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestContainerCommandRequestMessage.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestContainerCommandRequestMessage.java
index 75e19f5d45..ef65335a6c 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestContainerCommandRequestMessage.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestContainerCommandRequestMessage.java
@@ -36,9 +36,10 @@ import org.apache.hadoop.ozone.common.ChecksumData;
import org.apache.hadoop.ozone.common.OzoneChecksumException;
import org.apache.ratis.thirdparty.com.google.protobuf.ByteString;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
/** Testing {@link ContainerCommandRequestMessage}. */
public class TestContainerCommandRequestMessage {
static final Random RANDOM = new Random();
@@ -150,6 +151,6 @@ public class TestContainerCommandRequestMessage {
= ContainerCommandRequestMessage.toMessage(original, null);
final ContainerCommandRequestProto computed
= ContainerCommandRequestMessage.toProto(message.getContent(), null);
- Assertions.assertEquals(original, computed);
+ assertEquals(original, computed);
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestRatisHelper.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestRatisHelper.java
index d8f626165e..95953c0bfb 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestRatisHelper.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestRatisHelper.java
@@ -20,9 +20,11 @@ package org.apache.hadoop.hdds.ratis;
import org.apache.hadoop.hdds.conf.OzoneConfiguration;
import org.apache.ratis.conf.RaftProperties;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
/**
* Test RatisHelper class.
*/
@@ -32,22 +34,16 @@ public class TestRatisHelper {
public void testCreateRaftClientProperties() {
OzoneConfiguration ozoneConfiguration = new OzoneConfiguration();
- ozoneConfiguration.set("hdds.ratis.raft.client.rpc.watch" +
- ".request.timeout", "30s");
- ozoneConfiguration.set("hdds.ratis.raft.client.rpc.request" +
- ".timeout", "30s");
- ozoneConfiguration.set(
- "hdds.ratis.raft.server.rpc.watch.request.timeout", "30s");
+ ozoneConfiguration.set("hdds.ratis.raft.client.rpc.watch.request.timeout",
"30s");
+ ozoneConfiguration.set("hdds.ratis.raft.client.rpc.request.timeout",
"30s");
+ ozoneConfiguration.set("hdds.ratis.raft.server.rpc.watch.request.timeout",
"30s");
RaftProperties raftProperties = new RaftProperties();
RatisHelper.createRaftClientProperties(ozoneConfiguration, raftProperties);
- Assertions.assertEquals("30s",
- raftProperties.get("raft.client.rpc.watch.request.timeout"));
- Assertions.assertEquals("30s",
- raftProperties.get("raft.client.rpc.request.timeout"));
- Assertions.assertNull(
- raftProperties.get("raft.server.rpc.watch.request.timeout"));
+ assertEquals("30s",
raftProperties.get("raft.client.rpc.watch.request.timeout"));
+ assertEquals("30s", raftProperties.get("raft.client.rpc.request.timeout"));
+ assertNull(raftProperties.get("raft.server.rpc.watch.request.timeout"));
}
@@ -67,17 +63,17 @@ public class TestRatisHelper {
RaftProperties raftProperties = new RaftProperties();
RatisHelper.createRaftClientProperties(ozoneConfiguration, raftProperties);
- Assertions.assertEquals("30MB",
+ assertEquals("30MB",
raftProperties.get("raft.grpc.message.size.max"));
- Assertions.assertEquals("1MB",
+ assertEquals("1MB",
raftProperties.get("raft.grpc.flow.control.window"));
// As we dont match tls and server raft.grpc properties. So they should
// be null.
- Assertions.assertNull(raftProperties.get("raft.grpc.tls.set"));
- Assertions.assertNull(
+ assertNull(raftProperties.get("raft.grpc.tls.set"));
+ assertNull(
raftProperties.get("raft.grpc.tls.mutual_authn.enabled"));
- Assertions.assertNull(raftProperties.get("raft.grpc.server.port"));
+ assertNull(raftProperties.get("raft.grpc.server.port"));
}
@@ -101,16 +97,11 @@ public class TestRatisHelper {
RatisHelper.createRaftServerProperties(ozoneConfiguration,
raftProperties);
- Assertions.assertEquals("30MB",
- raftProperties.get("raft.grpc.message.size.max"));
- Assertions.assertEquals("1MB",
- raftProperties.get("raft.grpc.flow.control.window"));
- Assertions.assertEquals("true",
- raftProperties.get("raft.grpc.tls.enabled"));
- Assertions.assertEquals("true",
- raftProperties.get("raft.grpc.tls.mutual_authn.enabled"));
- Assertions.assertEquals("100",
- raftProperties.get("raft.grpc.server.port"));
+ assertEquals("30MB", raftProperties.get("raft.grpc.message.size.max"));
+ assertEquals("1MB", raftProperties.get("raft.grpc.flow.control.window"));
+ assertEquals("true", raftProperties.get("raft.grpc.tls.enabled"));
+ assertEquals("true",
raftProperties.get("raft.grpc.tls.mutual_authn.enabled"));
+ assertEquals("100", raftProperties.get("raft.grpc.server.port"));
}
@@ -128,12 +119,9 @@ public class TestRatisHelper {
RaftProperties raftProperties = new RaftProperties();
RatisHelper.createRaftServerProperties(ozoneConfiguration, raftProperties);
- Assertions.assertEquals("30s",
- raftProperties.get("raft.server.rpc.watch.request.timeout"));
- Assertions.assertEquals("30s",
- raftProperties.get("raft.server.rpc.request.timeout"));
- Assertions.assertNull(
- raftProperties.get("raft.client.rpc.request.timeout"));
+ assertEquals("30s",
raftProperties.get("raft.server.rpc.watch.request.timeout"));
+ assertEquals("30s", raftProperties.get("raft.server.rpc.request.timeout"));
+ assertNull(raftProperties.get("raft.client.rpc.request.timeout"));
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestServerNotLeaderExceptionMessageParsing.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestServerNotLeaderExceptionMessageParsing.java
index 00c290bc8d..ac6fa396c1 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestServerNotLeaderExceptionMessageParsing.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/ratis/TestServerNotLeaderExceptionMessageParsing.java
@@ -18,9 +18,11 @@
package org.apache.hadoop.hdds.ratis;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
/** Class to test {@link ServerNotLeaderException} parsing. **/
class TestServerNotLeaderExceptionMessageParsing {
@Test
@@ -31,7 +33,7 @@ class TestServerNotLeaderExceptionMessageParsing {
"Server:cf0bc565-a41b-4784-a24d-3048d5a5b013 is not the leader. "
+ "Suggested leader is Server:scm5-3.scm5.root.hwx.site:9863";
ServerNotLeaderException snle = new ServerNotLeaderException(msg);
- Assertions.assertEquals(snle.getSuggestedLeader(), "scm5-3.scm5.root.hwx" +
+ assertEquals(snle.getSuggestedLeader(), "scm5-3.scm5.root.hwx" +
".site:9863");
String message = "Server:7fdd7170-75cc-4e11-b343-c2657c2f2f39 is not the "
+
@@ -39,7 +41,7 @@ class TestServerNotLeaderExceptionMessageParsing {
"at org.apache.hadoop.hdds.ratis.ServerNotLeaderException" +
".convertToNotLeaderException(ServerNotLeaderException.java:96)";
snle = new ServerNotLeaderException(message);
- Assertions.assertEquals("scm5-3.scm5.root.hwx.site:9863",
+ assertEquals("scm5-3.scm5.root.hwx.site:9863",
snle.getSuggestedLeader());
// Test hostname with out "."
@@ -48,7 +50,7 @@ class TestServerNotLeaderExceptionMessageParsing {
"at org.apache.hadoop.hdds.ratis.ServerNotLeaderException" +
".convertToNotLeaderException(ServerNotLeaderException.java:96)";
snle = new ServerNotLeaderException(message);
- Assertions.assertEquals("localhost:98634",
+ assertEquals("localhost:98634",
snle.getSuggestedLeader());
message = "Server:7fdd7170-75cc-4e11-b343-c2657c2f2f39 is not the " +
@@ -56,14 +58,14 @@ class TestServerNotLeaderExceptionMessageParsing {
"at org.apache.hadoop.hdds.ratis.ServerNotLeaderException" +
".convertToNotLeaderException(ServerNotLeaderException.java:96)";
snle = new ServerNotLeaderException(message);
- Assertions.assertNull(snle.getSuggestedLeader());
+ assertNull(snle.getSuggestedLeader());
message = "Server:7fdd7170-75cc-4e11-b343-c2657c2f2f39 is not the " +
"leader.Suggested leader is Server:localhost:98634:8988 \n" +
"at org.apache.hadoop.hdds.ratis.ServerNotLeaderException" +
".convertToNotLeaderException(ServerNotLeaderException.java:96)";
snle = new ServerNotLeaderException(message);
- Assertions.assertEquals("localhost:98634",
+ assertEquals("localhost:98634",
snle.getSuggestedLeader());
message = "Server:7fdd7170-75cc-4e11-b343-c2657c2f2f39 is not the " +
@@ -71,7 +73,7 @@ class TestServerNotLeaderExceptionMessageParsing {
"at org.apache.hadoop.hdds.ratis.ServerNotLeaderException" +
".convertToNotLeaderException(ServerNotLeaderException.java)";
snle = new ServerNotLeaderException(message);
- Assertions.assertNull(snle.getSuggestedLeader());
+ assertNull(snle.getSuggestedLeader());
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/container/TestContainerReplicaInfo.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/container/TestContainerReplicaInfo.java
index de9042a801..2c2f1a594d 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/container/TestContainerReplicaInfo.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/container/TestContainerReplicaInfo.java
@@ -20,11 +20,11 @@ package org.apache.hadoop.hdds.scm.container;
import org.apache.hadoop.hdds.protocol.DatanodeDetails;
import org.apache.hadoop.hdds.protocol.MockDatanodeDetails;
import org.apache.hadoop.hdds.protocol.proto.HddsProtos;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
-
import java.util.UUID;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
/**
* Test for the ContainerReplicaInfo class.
*/
@@ -46,17 +46,17 @@ public class TestContainerReplicaInfo {
ContainerReplicaInfo info = ContainerReplicaInfo.fromProto(proto);
- Assertions.assertEquals(proto.getContainerID(), info.getContainerID());
- Assertions.assertEquals(proto.getBytesUsed(), info.getBytesUsed());
- Assertions.assertEquals(proto.getKeyCount(), info.getKeyCount());
- Assertions.assertEquals(proto.getPlaceOfBirth(),
+ assertEquals(proto.getContainerID(), info.getContainerID());
+ assertEquals(proto.getBytesUsed(), info.getBytesUsed());
+ assertEquals(proto.getKeyCount(), info.getKeyCount());
+ assertEquals(proto.getPlaceOfBirth(),
info.getPlaceOfBirth().toString());
- Assertions.assertEquals(DatanodeDetails.getFromProtoBuf(
+ assertEquals(DatanodeDetails.getFromProtoBuf(
proto.getDatanodeDetails()), info.getDatanodeDetails());
- Assertions.assertEquals(proto.getSequenceID(), info.getSequenceId());
- Assertions.assertEquals(proto.getState(), info.getState());
+ assertEquals(proto.getSequenceID(), info.getSequenceId());
+ assertEquals(proto.getState(), info.getState());
// If replicaIndex is not in the proto, then -1 should be returned
- Assertions.assertEquals(-1, info.getReplicaIndex());
+ assertEquals(-1, info.getReplicaIndex());
}
@Test
@@ -76,15 +76,15 @@ public class TestContainerReplicaInfo {
ContainerReplicaInfo info = ContainerReplicaInfo.fromProto(proto);
- Assertions.assertEquals(proto.getContainerID(), info.getContainerID());
- Assertions.assertEquals(proto.getBytesUsed(), info.getBytesUsed());
- Assertions.assertEquals(proto.getKeyCount(), info.getKeyCount());
- Assertions.assertEquals(proto.getPlaceOfBirth(),
+ assertEquals(proto.getContainerID(), info.getContainerID());
+ assertEquals(proto.getBytesUsed(), info.getBytesUsed());
+ assertEquals(proto.getKeyCount(), info.getKeyCount());
+ assertEquals(proto.getPlaceOfBirth(),
info.getPlaceOfBirth().toString());
- Assertions.assertEquals(DatanodeDetails.getFromProtoBuf(
+ assertEquals(DatanodeDetails.getFromProtoBuf(
proto.getDatanodeDetails()), info.getDatanodeDetails());
- Assertions.assertEquals(proto.getSequenceID(), info.getSequenceId());
- Assertions.assertEquals(proto.getState(), info.getState());
- Assertions.assertEquals(4, info.getReplicaIndex());
+ assertEquals(proto.getSequenceID(), info.getSequenceId());
+ assertEquals(proto.getState(), info.getState());
+ assertEquals(4, info.getReplicaIndex());
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/container/common/helpers/TestExcludeList.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/container/common/helpers/TestExcludeList.java
index c878124cd1..5571330ee6 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/container/common/helpers/TestExcludeList.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/container/common/helpers/TestExcludeList.java
@@ -19,13 +19,14 @@ package org.apache.hadoop.hdds.scm.container.common.helpers;
import org.apache.hadoop.hdds.protocol.DatanodeDetails;
import org.apache.ozone.test.TestClock;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.time.Instant;
import java.time.ZoneOffset;
import java.util.UUID;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
/**
* Tests the exclude nodes list behavior at client.
*/
@@ -39,9 +40,9 @@ public class TestExcludeList {
.setIpAddress("127.0.0.1").setHostName("localhost").addPort(
DatanodeDetails.newPort(DatanodeDetails.Port.Name.STANDALONE,
2001))
.build());
- Assertions.assertEquals(1, list.getDatanodes().size());
+ assertEquals(1, list.getDatanodes().size());
clock.fastForward(11);
- Assertions.assertEquals(0, list.getDatanodes().size());
+ assertEquals(0, list.getDatanodes().size());
list.addDatanode(DatanodeDetails.newBuilder().setUuid(UUID.randomUUID())
.setIpAddress("127.0.0.2").setHostName("localhost").addPort(
DatanodeDetails.newPort(DatanodeDetails.Port.Name.STANDALONE,
2001))
@@ -50,7 +51,7 @@ public class TestExcludeList {
.setIpAddress("127.0.0.3").setHostName("localhost").addPort(
DatanodeDetails.newPort(DatanodeDetails.Port.Name.STANDALONE,
2001))
.build());
- Assertions.assertEquals(2, list.getDatanodes().size());
+ assertEquals(2, list.getDatanodes().size());
}
@Test
@@ -60,8 +61,8 @@ public class TestExcludeList {
.setIpAddress("127.0.0.1").setHostName("localhost").addPort(
DatanodeDetails.newPort(DatanodeDetails.Port.Name.STANDALONE,
2001))
.build());
- Assertions.assertEquals(1, list.getDatanodes().size());
+ assertEquals(1, list.getDatanodes().size());
clock.fastForward(1);
- Assertions.assertEquals(1, list.getDatanodes().size());
+ assertEquals(1, list.getDatanodes().size());
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/net/TestNetworkTopologyImpl.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/net/TestNetworkTopologyImpl.java
index c7d86ea4fa..f0534ae801 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/net/TestNetworkTopologyImpl.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/scm/net/TestNetworkTopologyImpl.java
@@ -54,6 +54,7 @@ import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import org.junit.jupiter.api.BeforeEach;
@@ -62,7 +63,6 @@ import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -78,8 +78,7 @@ public class TestNetworkTopologyImpl {
@BeforeEach
void beforeAll() {
- mockedShuffleOperation =
- Mockito.mock(Consumer.class);
+ mockedShuffleOperation = mock(Consumer.class);
doAnswer(args -> {
List<? extends Node> collection = args.getArgument(0);
Collections.shuffle(collection);
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/upgrade/TestHDDSLayoutVersionManager.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/upgrade/TestHDDSLayoutVersionManager.java
index 8a81aea168..253cf7dfe4 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/upgrade/TestHDDSLayoutVersionManager.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/upgrade/TestHDDSLayoutVersionManager.java
@@ -38,7 +38,6 @@ import java.util.Optional;
import org.apache.hadoop.hdds.upgrade.test.MockComponent;
import org.apache.hadoop.hdds.upgrade.test.MockComponent.MockDnUpgradeAction;
import org.apache.hadoop.hdds.upgrade.test.MockComponent.MockScmUpgradeAction;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
@@ -58,9 +57,9 @@ public class TestHDDSLayoutVersionManager {
//Cluster is finalized, hence should not register.
Optional<HDDSUpgradeAction> action =
INITIAL_VERSION.scmAction(ON_FINALIZE);
- Assertions.assertFalse(action.isPresent());
+ assertFalse(action.isPresent());
action = DATANODE_SCHEMA_V2.datanodeAction(ON_FIRST_UPGRADE_START);
- Assertions.assertFalse(action.isPresent());
+ assertFalse(action.isPresent());
// Start from an unfinalized version manager.
lvm = mock(HDDSLayoutVersionManager.class);
@@ -72,8 +71,7 @@ public class TestHDDSLayoutVersionManager {
action = INITIAL_VERSION.scmAction(ON_FINALIZE);
assertTrue(action.isPresent());
assertEquals(MockScmUpgradeAction.class, action.get().getClass());
- assertFalse(
- INITIAL_VERSION.datanodeAction(ON_FINALIZE).isPresent());
+ assertFalse(INITIAL_VERSION.datanodeAction(ON_FINALIZE).isPresent());
MockComponent mockObj = mock(MockComponent.class);
action.get().execute(mockObj);
verify(mockObj, times(1)).mockMethodScm();
@@ -82,8 +80,7 @@ public class TestHDDSLayoutVersionManager {
action = DATANODE_SCHEMA_V2.datanodeAction(ON_FIRST_UPGRADE_START);
assertTrue(action.isPresent());
assertEquals(MockDnUpgradeAction.class, action.get().getClass());
- assertFalse(
- DATANODE_SCHEMA_V2.scmAction(ON_FIRST_UPGRADE_START).isPresent());
+
assertFalse(DATANODE_SCHEMA_V2.scmAction(ON_FIRST_UPGRADE_START).isPresent());
mockObj = mock(MockComponent.class);
action.get().execute(mockObj);
verify(mockObj, times(0)).mockMethodScm();
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/TestHddsIdFactory.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/TestHddsIdFactory.java
index 0d9f524762..648010f28f 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/TestHddsIdFactory.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/TestHddsIdFactory.java
@@ -27,11 +27,11 @@ import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.apache.hadoop.hdds.HddsIdFactory;
import org.junit.jupiter.api.AfterEach;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
/**
* Test the JMX interface for the rocksdb metastore implementation.
*/
@@ -65,7 +65,7 @@ public class TestHddsIdFactory {
for (int idNum = 0; idNum < IDS_PER_THREAD; idNum++) {
long var = HddsIdFactory.getLongId();
if (ID_SET.contains(var)) {
- Assertions.fail("Duplicate id found");
+ fail("Duplicate id found");
}
ID_SET.add(var);
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/TestResourceCache.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/TestResourceCache.java
index 3acaee85fa..06112bdf1b 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/TestResourceCache.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/TestResourceCache.java
@@ -18,10 +18,13 @@ package org.apache.hadoop.hdds.utils;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Consumer;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
/**
* Test for ResourceCache.
*/
@@ -48,17 +51,17 @@ public class TestResourceCache {
// put to cache with removing old element "6" as eviction FIFO
resourceCache.put(1, "a");
- Assertions.assertNull(resourceCache.get(6));
- Assertions.assertEquals(1, count.get());
+ assertNull(resourceCache.get(6));
+ assertEquals(1, count.get());
// add 5 should be success with no removal
resourceCache.put(5, "a");
- Assertions.assertNotNull(resourceCache.get(4));
+ assertNotNull(resourceCache.get(4));
// remove and check queue
resourceCache.remove(4);
- Assertions.assertNull(resourceCache.get(4));
- Assertions.assertEquals(1, count.get());
+ assertNull(resourceCache.get(4));
+ assertEquals(1, count.get());
}
@Test
@@ -96,7 +99,7 @@ public class TestResourceCache {
// THEN
for (Integer k : removedKeys) {
- Assertions.assertNull(resourceCache.get(k));
+ assertNull(resourceCache.get(k));
}
// can put new entries
for (int i = 1; i <= removedKeys.length; ++i) {
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/db/CodecTestUtil.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/db/CodecTestUtil.java
index 8c88d049b9..c623298111 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/db/CodecTestUtil.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/db/CodecTestUtil.java
@@ -17,13 +17,16 @@
*/
package org.apache.hadoop.hdds.utils.db;
-import org.junit.jupiter.api.Assertions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.ref.WeakReference;
import java.nio.ByteBuffer;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
/**
* Test {@link Codec} implementations.
*/
@@ -53,35 +56,35 @@ public final class CodecTestUtil {
public static <T> void runTest(Codec<T> codec, T original,
Integer serializedSize, Codec<T> oldCodec) throws Exception {
- Assertions.assertTrue(codec.supportCodecBuffer());
+ assertTrue(codec.supportCodecBuffer());
// serialize to byte[]
final byte[] array = codec.toPersistedFormat(original);
LOG.info("encoded length = " + array.length);
if (serializedSize != null) {
- Assertions.assertEquals(serializedSize, array.length);
+ assertEquals(serializedSize, array.length);
}
if (oldCodec != null) {
final byte[] expected = oldCodec.toPersistedFormat(original);
- Assertions.assertArrayEquals(expected, array);
+ assertArrayEquals(expected, array);
}
// deserialize from byte[]
final T fromArray = codec.fromPersistedFormat(array);
- Assertions.assertEquals(original, fromArray);
+ assertEquals(original, fromArray);
// serialize to CodecBuffer
final CodecBuffer codecBuffer = codec.toCodecBuffer(
original, CodecBuffer.Allocator.getHeap());
- Assertions.assertEquals(array.length, codecBuffer.readableBytes());
+ assertEquals(array.length, codecBuffer.readableBytes());
final ByteBuffer byteBuffer = codecBuffer.asReadOnlyByteBuffer();
- Assertions.assertEquals(array.length, byteBuffer.remaining());
+ assertEquals(array.length, byteBuffer.remaining());
for (int i = 0; i < array.length; i++) {
// assert exact content
- Assertions.assertEquals(array[i], byteBuffer.get(i));
+ assertEquals(array[i], byteBuffer.get(i));
}
if (oldCodec != null && oldCodec.supportCodecBuffer()) {
try (CodecBuffer expected = oldCodec.toHeapCodecBuffer(original)) {
- Assertions.assertEquals(expected.asReadOnlyByteBuffer(),
+ assertEquals(expected.asReadOnlyByteBuffer(),
codecBuffer.asReadOnlyByteBuffer());
}
}
@@ -89,12 +92,12 @@ public final class CodecTestUtil {
// deserialize from CodecBuffer
final T fromBuffer = codec.fromCodecBuffer(codecBuffer);
codecBuffer.release();
- Assertions.assertEquals(original, fromBuffer);
+ assertEquals(original, fromBuffer);
// deserialize from wrapped buffer
final CodecBuffer wrapped = CodecBuffer.wrap(array);
final T fromWrappedArray = codec.fromCodecBuffer(wrapped);
wrapped.release();
- Assertions.assertEquals(original, fromWrappedArray);
+ assertEquals(original, fromWrappedArray);
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/db/TestLeakDetector.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/db/TestLeakDetector.java
index 42422d0dff..0d85e79f26 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/db/TestLeakDetector.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/hdds/utils/db/TestLeakDetector.java
@@ -17,9 +17,11 @@
*/
package org.apache.hadoop.hdds.utils.db;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
/**
* Test {@link CodecBuffer.LeakDetector}.
*/
@@ -35,9 +37,8 @@ public final class TestLeakDetector {
// allocate a buffer but NOT release it.
CodecBuffer.allocateHeap(3);
// It should detect a buffer leak.
- final AssertionError e = Assertions.assertThrows(
- AssertionError.class, CodecTestUtil::gc);
+ final AssertionError e = assertThrows(AssertionError.class,
CodecTestUtil::gc);
e.printStackTrace(System.out);
- Assertions.assertTrue(e.getMessage().startsWith("Found 1 leak"));
+ assertTrue(e.getMessage().startsWith("Found 1 leak"));
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/TestOzoneConsts.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/TestOzoneConsts.java
index 1d36b662f9..c9eba107a1 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/TestOzoneConsts.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/TestOzoneConsts.java
@@ -17,9 +17,10 @@
*/
package org.apache.hadoop.ozone;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
/**
* Test Ozone Constants (e.g. for compatibility).
*/
@@ -28,8 +29,7 @@ public class TestOzoneConsts {
@Test
public void testOzoneTenantPolicyLabelCompatibility() {
// Value of the policy label should not be changed
- Assertions.assertEquals(
- "OzoneTenant", OzoneConsts.OZONE_TENANT_RANGER_POLICY_LABEL);
+ assertEquals("OzoneTenant", OzoneConsts.OZONE_TENANT_RANGER_POLICY_LABEL);
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChecksum.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChecksum.java
index e01b767b10..829f4bb150 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChecksum.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChecksum.java
@@ -19,10 +19,12 @@ package org.apache.hadoop.ozone.common;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.hadoop.hdds.protocol.datanode.proto.ContainerProtos;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests for {@link Checksum} class.
@@ -54,11 +56,10 @@ public class TestChecksum {
// A checksum is calculate for each bytesPerChecksum number of bytes in
// the data. Since that value is 10 here and the data length is 55, we
// should have 6 checksums in checksumData.
- Assertions.assertEquals(6, checksumData.getChecksums().size());
+ assertEquals(6, checksumData.getChecksums().size());
// Checksum verification should pass
- Assertions.assertTrue(Checksum.verifyChecksum(data, checksumData),
- "Checksum mismatch");
+ assertTrue(Checksum.verifyChecksum(data, checksumData), "Checksum
mismatch");
}
/**
@@ -75,8 +76,7 @@ public class TestChecksum {
// mismatch
data[50] = (byte) (data[50] + 1);
ChecksumData newChecksumData = checksum.computeChecksum(data);
- Assertions.assertNotEquals(originalChecksumData, newChecksumData,
- "Checksums should not match for different data");
+ assertNotEquals(originalChecksumData, newChecksumData, "Checksums should
not match for different data");
}
/**
@@ -92,7 +92,6 @@ public class TestChecksum {
Checksum checksum2 = getChecksum(ContainerProtos.ChecksumType.CRC32);
// The two checksums should not match as they have different types
- Assertions.assertNotEquals(checksum1, checksum2,
- "Checksums should not match for different checksum types");
+ assertNotEquals(checksum1, checksum2, "Checksums should not match for
different checksum types");
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChecksumByteBuffer.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChecksumByteBuffer.java
index 6c9236d949..5b88f5cb30 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChecksumByteBuffer.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChecksumByteBuffer.java
@@ -19,13 +19,14 @@ package org.apache.hadoop.ozone.common;
import org.apache.hadoop.util.PureJavaCrc32;
import org.apache.hadoop.util.PureJavaCrc32C;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.nio.charset.StandardCharsets;
import java.util.Random;
import java.util.zip.Checksum;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
/**
* Test {@link ChecksumByteBuffer} implementations.
*/
@@ -96,7 +97,7 @@ public class TestChecksumByteBuffer {
}
private void checkSame() {
- Assertions.assertEquals(expected.getValue(), testee.getValue());
+ assertEquals(expected.getValue(), testee.getValue());
}
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChunkBuffer.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChunkBuffer.java
index c405b83012..414754092f 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChunkBuffer.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestChunkBuffer.java
@@ -30,10 +30,15 @@ import java.util.concurrent.ThreadLocalRandom;
import org.apache.hadoop.hdds.utils.MockGatheringChannel;
import org.apache.ratis.thirdparty.com.google.protobuf.ByteString;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
/**
* Test {@link ChunkBuffer} implementations.
*/
@@ -117,14 +122,14 @@ public class TestChunkBuffer {
System.out.println("n=" + n + ", impl=" + impl);
// check position, remaining
- Assertions.assertEquals(0, impl.position());
- Assertions.assertEquals(n, impl.remaining());
- Assertions.assertEquals(n, impl.limit());
+ assertEquals(0, impl.position());
+ assertEquals(n, impl.remaining());
+ assertEquals(n, impl.limit());
impl.put(expected);
- Assertions.assertEquals(n, impl.position());
- Assertions.assertEquals(0, impl.remaining());
- Assertions.assertEquals(n, impl.limit());
+ assertEquals(n, impl.position());
+ assertEquals(0, impl.remaining());
+ assertEquals(n, impl.limit());
// duplicate
assertDuplicate(expected, impl);
@@ -162,8 +167,8 @@ public class TestChunkBuffer {
byte[] expected, ChunkBuffer impl, int bpc) {
final int n = expected.length;
final ChunkBuffer duplicated = impl.duplicate(0, n);
- Assertions.assertEquals(0, duplicated.position());
- Assertions.assertEquals(n, duplicated.remaining());
+ assertEquals(0, duplicated.position());
+ assertEquals(n, duplicated.remaining());
final int numChecksums = (n + bpc - 1) / bpc;
final Iterator<ByteBuffer> i = duplicated.iterate(bpc).iterator();
@@ -172,58 +177,50 @@ public class TestChunkBuffer {
final ByteBuffer b = i.next();
final int expectedRemaining = j < numChecksums - 1 ?
bpc : n - bpc * (numChecksums - 1);
- Assertions.assertEquals(expectedRemaining, b.remaining());
+ assertEquals(expectedRemaining, b.remaining());
final int offset = j * bpc;
for (int k = 0; k < expectedRemaining; k++) {
- Assertions.assertEquals(expected[offset + k], b.get());
+ assertEquals(expected[offset + k], b.get());
count++;
}
}
- Assertions.assertEquals(n, count);
- Assertions.assertFalse(i.hasNext());
- Assertions.assertThrows(NoSuchElementException.class, i::next);
+ assertEquals(n, count);
+ assertFalse(i.hasNext());
+ assertThrows(NoSuchElementException.class, i::next);
}
private static void assertToByteString(
byte[] expected, int offset, int length, ChunkBuffer impl) {
final ChunkBuffer duplicated = impl.duplicate(offset, offset + length);
- Assertions.assertEquals(offset, duplicated.position());
- Assertions.assertEquals(length, duplicated.remaining());
+ assertEquals(offset, duplicated.position());
+ assertEquals(length, duplicated.remaining());
final ByteString computed = duplicated.toByteString(buffer -> {
buffer.mark();
final ByteString string = ByteString.copyFrom(buffer);
buffer.reset();
return string;
});
- Assertions.assertEquals(offset, duplicated.position());
- Assertions.assertEquals(length, duplicated.remaining());
- assertEquals("offset=" + offset + ", length=" + length,
- ByteString.copyFrom(expected, offset, length), computed);
+ assertEquals(offset, duplicated.position());
+ assertEquals(length, duplicated.remaining());
+ assertEquals(ByteString.copyFrom(expected, offset, length), computed,
+ "offset=" + offset + ", length=" + length);
}
private static void assertWrite(byte[] expected, ChunkBuffer impl) {
impl.rewind();
- Assertions.assertEquals(0, impl.position());
+ assertEquals(0, impl.position());
ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
try {
impl.writeTo(new MockGatheringChannel(Channels.newChannel(output)));
} catch (IOException e) {
- Assertions.fail("Unexpected error: " + e);
+ fail("Unexpected error: " + e);
}
- Assertions.assertArrayEquals(expected, output.toByteArray());
- Assertions.assertFalse(impl.hasRemaining());
- }
-
- private static void assertEquals(String message,
- ByteString expected, ByteString actual) {
- Assertions.assertEquals(
- toString(expected.toByteArray()),
- toString(actual.toByteArray()),
- message);
+ assertArrayEquals(expected, output.toByteArray());
+ assertFalse(impl.hasRemaining());
}
private static String toString(byte[] arr) {
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestStateMachine.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestStateMachine.java
index 274c265de1..0a07646324 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestStateMachine.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/common/TestStateMachine.java
@@ -18,10 +18,8 @@
package org.apache.hadoop.ozone.common;
import org.apache.commons.collections.SetUtils;
-import org.apache.hadoop.ozone.common.statemachine
- .InvalidStateTransitionException;
+import
org.apache.hadoop.ozone.common.statemachine.InvalidStateTransitionException;
import org.apache.hadoop.ozone.common.statemachine.StateMachine;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.HashSet;
@@ -32,8 +30,10 @@ import static
org.apache.hadoop.ozone.common.TestStateMachine.STATES.CLOSED;
import static org.apache.hadoop.ozone.common.TestStateMachine.STATES.CREATING;
import static org.apache.hadoop.ozone.common.TestStateMachine.STATES.FINAL;
import static org.apache.hadoop.ozone.common.TestStateMachine.STATES.INIT;
-import static org.apache.hadoop.ozone.common.TestStateMachine.STATES
- .OPERATIONAL;
+import static
org.apache.hadoop.ozone.common.TestStateMachine.STATES.OPERATIONAL;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* This class is to test ozone common state machine.
@@ -66,28 +66,27 @@ public class TestStateMachine {
stateMachine.addTransition(CREATING, CLEANUP, EVENTS.TIMEOUT);
// Initial and Final states
- Assertions.assertEquals(INIT, stateMachine.getInitialState(),
+ assertEquals(INIT, stateMachine.getInitialState(),
"Initial State");
- Assertions.assertTrue(SetUtils.isEqualSet(finals,
- stateMachine.getFinalStates()), "Final States");
+ assertTrue(SetUtils.isEqualSet(finals, stateMachine.getFinalStates()),
"Final States");
// Valid state transitions
- Assertions.assertEquals(OPERATIONAL, stateMachine.getNextState(CREATING,
+ assertEquals(OPERATIONAL, stateMachine.getNextState(CREATING,
EVENTS.CREATE), "STATE should be OPERATIONAL after being created");
- Assertions.assertEquals(OPERATIONAL, stateMachine.getNextState(OPERATIONAL,
+ assertEquals(OPERATIONAL, stateMachine.getNextState(OPERATIONAL,
EVENTS.UPDATE), "STATE should be OPERATIONAL after being updated");
- Assertions.assertEquals(CLEANUP, stateMachine.getNextState(OPERATIONAL,
+ assertEquals(CLEANUP, stateMachine.getNextState(OPERATIONAL,
EVENTS.DELETE), "STATE should be CLEANUP after being deleted");
- Assertions.assertEquals(CLEANUP, stateMachine.getNextState(CREATING,
+ assertEquals(CLEANUP, stateMachine.getNextState(CREATING,
EVENTS.TIMEOUT), "STATE should be CLEANUP after being timeout");
- Assertions.assertEquals(CLOSED, stateMachine.getNextState(OPERATIONAL,
+ assertEquals(CLOSED, stateMachine.getNextState(OPERATIONAL,
EVENTS.CLOSE), "STATE should be CLOSED after being closed");
// Negative cases: invalid transition
- Assertions.assertThrowsExactly(InvalidStateTransitionException.class, () ->
+ assertThrowsExactly(InvalidStateTransitionException.class, () ->
stateMachine.getNextState(OPERATIONAL, EVENTS.CREATE), "Invalid
event");
- Assertions.assertThrowsExactly(InvalidStateTransitionException.class, () ->
+ assertThrowsExactly(InvalidStateTransitionException.class, () ->
stateMachine.getNextState(CREATING, EVENTS.CLOSE), "Invalid event");
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/ha/TestOzoneNetUtils.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/ha/TestOzoneNetUtils.java
index 5ec42b9117..64ad599a38 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/ha/TestOzoneNetUtils.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/ha/TestOzoneNetUtils.java
@@ -18,11 +18,12 @@ package org.apache.hadoop.ozone.ha;
import org.apache.hadoop.net.NetUtils;
import org.apache.hadoop.ozone.util.OzoneNetUtils;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.net.InetSocketAddress;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
/**
* Tests for {@link OzoneNetUtils} class.
*/
@@ -35,7 +36,7 @@ public class TestOzoneNetUtils {
InetSocketAddress addr0 = NetUtils.createSocketAddr(fqdn, port);
InetSocketAddress addr1 = OzoneNetUtils.getAddressWithHostNameLocal(
addr0);
- Assertions.assertEquals("pod0", addr1.getHostName());
- Assertions.assertEquals(port, addr1.getPort());
+ assertEquals("pod0", addr1.getHostName());
+ assertEquals(port, addr1.getPort());
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/lease/TestLeaseManager.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/lease/TestLeaseManager.java
index 637c54f285..8726d927b8 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/lease/TestLeaseManager.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/lease/TestLeaseManager.java
@@ -18,11 +18,14 @@
package org.apache.hadoop.ozone.lease;
import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.Assertions;
-
import java.util.HashMap;
import java.util.Map;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
/**
* Test class to check functionality and consistency of LeaseManager.
*/
@@ -80,19 +83,19 @@ public class TestLeaseManager {
Lease<DummyResource> leaseOne = manager.acquire(resourceOne);
Lease<DummyResource> leaseTwo = manager.acquire(resourceTwo);
Lease<DummyResource> leaseThree = manager.acquire(resourceThree);
- Assertions.assertEquals(leaseOne, manager.get(resourceOne));
- Assertions.assertEquals(leaseTwo, manager.get(resourceTwo));
- Assertions.assertEquals(leaseThree, manager.get(resourceThree));
- Assertions.assertFalse(leaseOne.hasExpired());
- Assertions.assertFalse(leaseTwo.hasExpired());
- Assertions.assertFalse(leaseThree.hasExpired());
+ assertEquals(leaseOne, manager.get(resourceOne));
+ assertEquals(leaseTwo, manager.get(resourceTwo));
+ assertEquals(leaseThree, manager.get(resourceThree));
+ assertFalse(leaseOne.hasExpired());
+ assertFalse(leaseTwo.hasExpired());
+ assertFalse(leaseThree.hasExpired());
//The below releases should not throw LeaseNotFoundException.
manager.release(resourceOne);
manager.release(resourceTwo);
manager.release(resourceThree);
- Assertions.assertTrue(leaseOne.hasExpired());
- Assertions.assertTrue(leaseTwo.hasExpired());
- Assertions.assertTrue(leaseThree.hasExpired());
+ assertTrue(leaseOne.hasExpired());
+ assertTrue(leaseTwo.hasExpired());
+ assertTrue(leaseThree.hasExpired());
manager.shutdown();
}
@@ -104,10 +107,10 @@ public class TestLeaseManager {
DummyResource resourceTwo = new DummyResource("two");
Lease<DummyResource> leaseOne = manager.acquire(resourceOne);
Lease<DummyResource> leaseTwo = manager.acquire(resourceTwo);
- Assertions.assertEquals(leaseOne, manager.get(resourceOne));
- Assertions.assertEquals(leaseTwo, manager.get(resourceTwo));
+ assertEquals(leaseOne, manager.get(resourceOne));
+ assertEquals(leaseTwo, manager.get(resourceTwo));
- Assertions.assertThrowsExactly(LeaseAlreadyExistException.class,
+ assertThrowsExactly(LeaseAlreadyExistException.class,
() -> manager.acquire(resourceOne), "Resource: " + resourceOne);
manager.release(resourceOne);
@@ -124,22 +127,22 @@ public class TestLeaseManager {
DummyResource resourceThree = new DummyResource("three");
//Case 1: lease was never acquired.
- Assertions.assertThrowsExactly(LeaseNotFoundException.class,
+ assertThrowsExactly(LeaseNotFoundException.class,
() -> manager.get(resourceOne), "Resource: " + resourceOne);
//Case 2: lease is acquired and released.
Lease<DummyResource> leaseTwo = manager.acquire(resourceTwo);
- Assertions.assertEquals(leaseTwo, manager.get(resourceTwo));
- Assertions.assertFalse(leaseTwo.hasExpired());
+ assertEquals(leaseTwo, manager.get(resourceTwo));
+ assertFalse(leaseTwo.hasExpired());
manager.release(resourceTwo);
- Assertions.assertTrue(leaseTwo.hasExpired());
- Assertions.assertThrowsExactly(LeaseNotFoundException.class,
+ assertTrue(leaseTwo.hasExpired());
+ assertThrowsExactly(LeaseNotFoundException.class,
() -> manager.get(resourceTwo), "Resource: " + resourceTwo);
//Case 3: lease acquired and timed out.
Lease<DummyResource> leaseThree = manager.acquire(resourceThree);
- Assertions.assertEquals(leaseThree, manager.get(resourceThree));
- Assertions.assertFalse(leaseThree.hasExpired());
+ assertEquals(leaseThree, manager.get(resourceThree));
+ assertFalse(leaseThree.hasExpired());
long sleepTime = leaseThree.getRemainingTime() + 1000;
try {
Thread.sleep(sleepTime);
@@ -147,8 +150,8 @@ public class TestLeaseManager {
//even in case of interrupt we have to wait till lease times out.
Thread.sleep(sleepTime);
}
- Assertions.assertTrue(leaseThree.hasExpired());
- Assertions.assertThrowsExactly(LeaseNotFoundException.class,
+ assertTrue(leaseThree.hasExpired());
+ assertThrowsExactly(LeaseNotFoundException.class,
() -> manager.get(resourceThree), "Resource: " + resourceThree);
manager.shutdown();
}
@@ -163,15 +166,15 @@ public class TestLeaseManager {
Lease<DummyResource> leaseOne = manager.acquire(resourceOne);
Lease<DummyResource> leaseTwo = manager.acquire(resourceTwo, 10000);
Lease<DummyResource> leaseThree = manager.acquire(resourceThree, 50000);
- Assertions.assertEquals(leaseOne, manager.get(resourceOne));
- Assertions.assertEquals(leaseTwo, manager.get(resourceTwo));
- Assertions.assertEquals(leaseThree, manager.get(resourceThree));
- Assertions.assertFalse(leaseOne.hasExpired());
- Assertions.assertFalse(leaseTwo.hasExpired());
- Assertions.assertFalse(leaseThree.hasExpired());
- Assertions.assertEquals(5000, leaseOne.getLeaseLifeTime());
- Assertions.assertEquals(10000, leaseTwo.getLeaseLifeTime());
- Assertions.assertEquals(50000, leaseThree.getLeaseLifeTime());
+ assertEquals(leaseOne, manager.get(resourceOne));
+ assertEquals(leaseTwo, manager.get(resourceTwo));
+ assertEquals(leaseThree, manager.get(resourceThree));
+ assertFalse(leaseOne.hasExpired());
+ assertFalse(leaseTwo.hasExpired());
+ assertFalse(leaseThree.hasExpired());
+ assertEquals(5000, leaseOne.getLeaseLifeTime());
+ assertEquals(10000, leaseTwo.getLeaseLifeTime());
+ assertEquals(50000, leaseThree.getLeaseLifeTime());
// Releasing of leases is done in shutdown, so don't have to worry about
// lease release
manager.shutdown();
@@ -196,11 +199,11 @@ public class TestLeaseManager {
//even in case of interrupt we have to wait till lease times out.
Thread.sleep(sleepTime);
}
- Assertions.assertTrue(leaseOne.hasExpired());
- Assertions.assertThrowsExactly(LeaseNotFoundException.class,
+ assertTrue(leaseOne.hasExpired());
+ assertThrowsExactly(LeaseNotFoundException.class,
() -> manager.get(resourceOne), "Resource: " + resourceOne);
// check if callback has been executed
- Assertions.assertEquals("lease expired", leaseStatus.get(resourceOne));
+ assertEquals("lease expired", leaseStatus.get(resourceOne));
}
@Test
@@ -218,10 +221,10 @@ public class TestLeaseManager {
leaseStatus.put(resourceOne, "lease in use");
leaseStatus.put(resourceOne, "lease released");
manager.release(resourceOne);
- Assertions.assertTrue(leaseOne.hasExpired());
- Assertions.assertThrowsExactly(LeaseNotFoundException.class,
+ assertTrue(leaseOne.hasExpired());
+ assertThrowsExactly(LeaseNotFoundException.class,
() -> manager.get(resourceOne), "Resource: " + resourceOne);
- Assertions.assertEquals("lease released", leaseStatus.get(resourceOne));
+ assertEquals("lease released", leaseStatus.get(resourceOne));
}
@Test
@@ -278,17 +281,17 @@ public class TestLeaseManager {
//even in case of interrupt we have to wait till lease times out.
Thread.sleep(sleepTime);
}
- Assertions.assertTrue(leaseOne.hasExpired());
- Assertions.assertTrue(leaseTwo.hasExpired());
- Assertions.assertTrue(leaseThree.hasExpired());
- Assertions.assertTrue(leaseFour.hasExpired());
- Assertions.assertTrue(leaseFive.hasExpired());
-
- Assertions.assertEquals("lease released", leaseStatus.get(resourceOne));
- Assertions.assertEquals("lease released", leaseStatus.get(resourceTwo));
- Assertions.assertEquals("lease released", leaseStatus.get(resourceThree));
- Assertions.assertEquals("lease expired", leaseStatus.get(resourceFour));
- Assertions.assertEquals("lease expired", leaseStatus.get(resourceFive));
+ assertTrue(leaseOne.hasExpired());
+ assertTrue(leaseTwo.hasExpired());
+ assertTrue(leaseThree.hasExpired());
+ assertTrue(leaseFour.hasExpired());
+ assertTrue(leaseFive.hasExpired());
+
+ assertEquals("lease released", leaseStatus.get(resourceOne));
+ assertEquals("lease released", leaseStatus.get(resourceTwo));
+ assertEquals("lease released", leaseStatus.get(resourceThree));
+ assertEquals("lease expired", leaseStatus.get(resourceFour));
+ assertEquals("lease expired", leaseStatus.get(resourceFive));
manager.shutdown();
}
@@ -298,18 +301,18 @@ public class TestLeaseManager {
manager.start();
DummyResource resourceOne = new DummyResource("one");
Lease<DummyResource> leaseOne = manager.acquire(resourceOne);
- Assertions.assertEquals(leaseOne, manager.get(resourceOne));
- Assertions.assertFalse(leaseOne.hasExpired());
+ assertEquals(leaseOne, manager.get(resourceOne));
+ assertFalse(leaseOne.hasExpired());
manager.release(resourceOne);
- Assertions.assertTrue(leaseOne.hasExpired());
+ assertTrue(leaseOne.hasExpired());
Lease<DummyResource> sameResourceLease = manager.acquire(resourceOne);
- Assertions.assertEquals(sameResourceLease, manager.get(resourceOne));
- Assertions.assertFalse(sameResourceLease.hasExpired());
+ assertEquals(sameResourceLease, manager.get(resourceOne));
+ assertFalse(sameResourceLease.hasExpired());
manager.release(resourceOne);
- Assertions.assertTrue(sameResourceLease.hasExpired());
+ assertTrue(sameResourceLease.hasExpired());
manager.shutdown();
}
@@ -320,8 +323,8 @@ public class TestLeaseManager {
manager.start();
DummyResource resourceOne = new DummyResource("one");
Lease<DummyResource> leaseOne = manager.acquire(resourceOne);
- Assertions.assertEquals(leaseOne, manager.get(resourceOne));
- Assertions.assertFalse(leaseOne.hasExpired());
+ assertEquals(leaseOne, manager.get(resourceOne));
+ assertFalse(leaseOne.hasExpired());
// wait for lease to expire
long sleepTime = leaseOne.getRemainingTime() + 1000;
try {
@@ -330,14 +333,14 @@ public class TestLeaseManager {
//even in case of interrupt we have to wait till lease times out.
Thread.sleep(sleepTime);
}
- Assertions.assertTrue(leaseOne.hasExpired());
+ assertTrue(leaseOne.hasExpired());
Lease<DummyResource> sameResourceLease = manager.acquire(resourceOne);
- Assertions.assertEquals(sameResourceLease, manager.get(resourceOne));
- Assertions.assertFalse(sameResourceLease.hasExpired());
+ assertEquals(sameResourceLease, manager.get(resourceOne));
+ assertFalse(sameResourceLease.hasExpired());
manager.release(resourceOne);
- Assertions.assertTrue(sameResourceLease.hasExpired());
+ assertTrue(sameResourceLease.hasExpired());
manager.shutdown();
}
@@ -347,8 +350,8 @@ public class TestLeaseManager {
manager.start();
DummyResource resourceOne = new DummyResource("one");
Lease<DummyResource> leaseOne = manager.acquire(resourceOne);
- Assertions.assertEquals(leaseOne, manager.get(resourceOne));
- Assertions.assertFalse(leaseOne.hasExpired());
+ assertEquals(leaseOne, manager.get(resourceOne));
+ assertFalse(leaseOne.hasExpired());
// add 5 more seconds to the lease
leaseOne.renew(5000);
@@ -356,8 +359,8 @@ public class TestLeaseManager {
Thread.sleep(5000);
// lease should still be active
- Assertions.assertEquals(leaseOne, manager.get(resourceOne));
- Assertions.assertFalse(leaseOne.hasExpired());
+ assertEquals(leaseOne, manager.get(resourceOne));
+ assertFalse(leaseOne.hasExpired());
manager.release(resourceOne);
manager.shutdown();
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/lock/TestLockManager.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/lock/TestLockManager.java
index 9addf74471..6dacf9f7f0 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/lock/TestLockManager.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/lock/TestLockManager.java
@@ -20,13 +20,16 @@ package org.apache.hadoop.ozone.lock;
import org.apache.hadoop.hdds.conf.OzoneConfiguration;
import org.apache.ozone.test.GenericTestUtils;
import org.apache.hadoop.util.Daemon;
-import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
/**
* Test-cases to test LockManager.
*/
@@ -42,7 +45,7 @@ public class TestLockManager {
manager.writeLock("/resourceTwo");
manager.writeUnlock("/resourceOne");
manager.writeUnlock("/resourceTwo");
- Assertions.assertTrue(true);
+ assertTrue(true);
}
@Test
@@ -60,13 +63,13 @@ public class TestLockManager {
Thread.sleep(100);
// Since the other thread is trying to get write lock on same object,
// it will wait.
- Assertions.assertFalse(gotLock.get());
+ assertFalse(gotLock.get());
manager.writeUnlock("/resourceOne");
// Since we have released the write lock, the other thread should have
// the lock now
// Let's give some time for the other thread to run
Thread.sleep(100);
- Assertions.assertTrue(gotLock.get());
+ assertTrue(gotLock.get());
}
@Test
@@ -78,7 +81,7 @@ public class TestLockManager {
manager.readLock("/resourceTwo");
manager.readUnlock("/resourceOne");
manager.readUnlock("/resourceTwo");
- Assertions.assertTrue(true);
+ assertTrue(true);
}
@Test
@@ -95,7 +98,7 @@ public class TestLockManager {
// Let's give some time for the other thread to run
Thread.sleep(100);
// Since the new thread is trying to get read lock, it should work.
- Assertions.assertTrue(gotLock.get());
+ assertTrue(gotLock.get());
manager.readUnlock("/resourceOne");
}
@@ -114,13 +117,13 @@ public class TestLockManager {
Thread.sleep(100);
// Since the other thread is trying to get read lock on same object,
// it will wait.
- Assertions.assertFalse(gotLock.get());
+ assertFalse(gotLock.get());
manager.writeUnlock("/resourceOne");
// Since we have released the write lock, the other thread should have
// the lock now
// Let's give some time for the other thread to run
Thread.sleep(100);
- Assertions.assertTrue(gotLock.get());
+ assertTrue(gotLock.get());
}
@Test
@@ -138,13 +141,13 @@ public class TestLockManager {
Thread.sleep(100);
// Since the other thread is trying to get write lock on same object,
// it will wait.
- Assertions.assertFalse(gotLock.get());
+ assertFalse(gotLock.get());
manager.readUnlock("/resourceOne");
// Since we have released the read lock, the other thread should have
// the lock now
// Let's give some time for the other thread to run
Thread.sleep(100);
- Assertions.assertTrue(gotLock.get());
+ assertTrue(gotLock.get());
}
@Test
@@ -163,17 +166,17 @@ public class TestLockManager {
Thread.sleep(100);
// Since the other thread is trying to get write lock on same object,
// it will wait.
- Assertions.assertFalse(gotLock.get());
+ assertFalse(gotLock.get());
manager.readUnlock("/resourceOne");
//We have only released one read lock, we still hold another read lock.
Thread.sleep(100);
- Assertions.assertFalse(gotLock.get());
+ assertFalse(gotLock.get());
manager.readUnlock("/resourceOne");
// Since we have released the read lock, the other thread should have
// the lock now
// Let's give some time for the other thread to run
Thread.sleep(100);
- Assertions.assertTrue(gotLock.get());
+ assertTrue(gotLock.get());
}
@Test
@@ -201,6 +204,6 @@ public class TestLockManager {
}
GenericTestUtils.waitFor(() -> done.get() == count, 100,
10 * count * sleep);
- Assertions.assertEquals(count, done.get());
+ assertEquals(count, done.get());
}
}
diff --git
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/upgrade/TestBasicUpgradeFinalizer.java
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/upgrade/TestBasicUpgradeFinalizer.java
index 96344f3984..d0b9e140f2 100644
---
a/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/upgrade/TestBasicUpgradeFinalizer.java
+++
b/hadoop-hdds/common/src/test/java/org/apache/hadoop/ozone/upgrade/TestBasicUpgradeFinalizer.java
@@ -28,7 +28,8 @@ 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.fail;
-import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
@@ -45,7 +46,6 @@ import org.apache.hadoop.ozone.common.Storage;
import
org.apache.hadoop.ozone.upgrade.TestUpgradeFinalizerActions.MockLayoutVersionManager;
import org.apache.hadoop.ozone.upgrade.UpgradeFinalizer.StatusAndMessages;
import org.junit.jupiter.api.Test;
-import org.mockito.ArgumentMatchers;
import org.mockito.InOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -65,23 +65,23 @@ public class TestBasicUpgradeFinalizer {
Object mockObj = mock(Object.class);
doCallRealMethod().when(finalizer).finalize(anyString(),
- ArgumentMatchers.eq(mockObj));
+ eq(mockObj));
finalizer.finalize("test-client-1", mockObj);
StatusAndMessages res = finalizer.reportStatus("test-client-1", false);
assertEquals(FINALIZATION_DONE, res.status());
- inOrder.verify(finalizer).preFinalizeUpgrade(ArgumentMatchers.eq(mockObj));
+ inOrder.verify(finalizer).preFinalizeUpgrade(eq(mockObj));
inOrder.verify(finalizer).finalizeLayoutFeature(
- ArgumentMatchers.eq(
+ eq(
TestUpgradeFinalizerActions.MockLayoutFeature.VERSION_2),
- ArgumentMatchers.eq(mockObj));
+ eq(mockObj));
inOrder.verify(finalizer).finalizeLayoutFeature(
- ArgumentMatchers.eq(
+ eq(
TestUpgradeFinalizerActions.MockLayoutFeature.VERSION_3),
- ArgumentMatchers.eq(mockObj));
-
inOrder.verify(finalizer).postFinalizeUpgrade(ArgumentMatchers.eq(mockObj));
+ eq(mockObj));
+ inOrder.verify(finalizer).postFinalizeUpgrade(eq(mockObj));
assertTrue(finalizer.isFinalizationDone());
assertTrue(finalizer.preCalled && finalizer.finalizeCalled &&
@@ -227,8 +227,7 @@ public class TestBasicUpgradeFinalizer {
super.finalizeLayoutFeature(lf,
lf.action(LayoutFeature.UpgradeActionType.ON_FINALIZE), mockStorage);
- inOrder.verify(mockStorage)
- .setLayoutVersion(ArgumentMatchers.eq(lf.layoutVersion()));
+ inOrder.verify(mockStorage).setLayoutVersion(eq(lf.layoutVersion()));
try {
inOrder.verify(mockStorage).persistCurrentState();
} catch (IOException ex) {
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
