You are viewing a plain text version of this content. The canonical link for it is here.
Posted to common-commits@hadoop.apache.org by ta...@apache.org on 2019/04/16 03:15:13 UTC
[hadoop] branch trunk updated: YARN-8943. Upgrade JUnit from 4 to 5
in hadoop-yarn-api.
This is an automated email from the ASF dual-hosted git repository.
tasanuma pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/hadoop.git
The following commit(s) were added to refs/heads/trunk by this push:
new c65218e YARN-8943. Upgrade JUnit from 4 to 5 in hadoop-yarn-api.
c65218e is described below
commit c65218ee8e3f538b293c98bb78d0e8bb6f7360df
Author: Akira Ajisaka <aa...@apache.org>
AuthorDate: Thu Oct 25 14:19:42 2018 +0900
YARN-8943. Upgrade JUnit from 4 to 5 in hadoop-yarn-api.
Signed-off-by: Takanobu Asanuma <ta...@apache.org>
---
.../hadoop-yarn/hadoop-yarn-api/pom.xml | 21 ++
.../hadoop/yarn/api/records/TestResource.java | 22 +-
.../apache/hadoop/yarn/api/records/TestURL.java | 8 +-
.../timelineservice/TestApplicationEntity.java | 12 +-
.../timelineservice/TestTimelineMetric.java | 10 +-
.../resource/TestPlacementConstraintParser.java | 268 +++++++++++----------
.../api/resource/TestPlacementConstraints.java | 55 ++---
.../hadoop/yarn/conf/TestResourceInformation.java | 47 ++--
.../hadoop/yarn/util/TestUnitsConversionUtil.java | 143 ++++++-----
9 files changed, 313 insertions(+), 273 deletions(-)
diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/pom.xml b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/pom.xml
index fdd25e7..092f85d 100644
--- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/pom.xml
+++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/pom.xml
@@ -73,6 +73,27 @@
<scope>test</scope>
</dependency>
<dependency>
+ <groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter-api</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter-engine</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.junit.vintage</groupId>
+ <artifactId>junit-vintage-engine</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <!-- Only required to run tests in an IDE that bundles an older version -->
+ <dependency>
+ <groupId>org.junit.platform</groupId>
+ <artifactId>junit-platform-launcher</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</dependency>
diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/TestResource.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/TestResource.java
index e0ec370..638ecf9 100644
--- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/TestResource.java
+++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/TestResource.java
@@ -17,27 +17,29 @@
*/
package org.apache.hadoop.yarn.api.records;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* The class to test {@link Resource}.
*/
-public class TestResource {
+class TestResource {
@Test
- public void testCastToIntSafely() {
+ void testCastToIntSafely() {
assertEquals(0, Resource.castToIntSafely(0));
assertEquals(1, Resource.castToIntSafely(1));
assertEquals(Integer.MAX_VALUE,
Resource.castToIntSafely(Integer.MAX_VALUE));
- assertEquals("Cast to Integer.MAX_VALUE if the long is greater than "
- + "Integer.MAX_VALUE", Integer.MAX_VALUE,
- Resource.castToIntSafely(Integer.MAX_VALUE + 1L));
- assertEquals("Cast to Integer.MAX_VALUE if the long is greater than "
- + "Integer.MAX_VALUE", Integer.MAX_VALUE,
- Resource.castToIntSafely(Long.MAX_VALUE));
+ assertEquals(Integer.MAX_VALUE,
+ Resource.castToIntSafely(Integer.MAX_VALUE + 1L),
+ "Cast to Integer.MAX_VALUE if the long is greater than "
+ + "Integer.MAX_VALUE");
+ assertEquals(Integer.MAX_VALUE,
+ Resource.castToIntSafely(Long.MAX_VALUE),
+ "Cast to Integer.MAX_VALUE if the long is greater than "
+ + "Integer.MAX_VALUE");
}
}
diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/TestURL.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/TestURL.java
index b464eca..4251f68 100644
--- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/TestURL.java
+++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/TestURL.java
@@ -17,19 +17,19 @@
*/
package org.apache.hadoop.yarn.api.records;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.yarn.conf.YarnConfiguration;
import org.apache.hadoop.yarn.factories.RecordFactory;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/** Test for the URL class. */
-public class TestURL {
+class TestURL {
@Test
- public void testConversion() throws Exception {
+ void testConversion() throws Exception {
Configuration conf = new Configuration();
conf.set(YarnConfiguration.IPC_RECORD_FACTORY_CLASS,
RecordFactoryForTest.class.getName());
diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/timelineservice/TestApplicationEntity.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/timelineservice/TestApplicationEntity.java
index c3f2777..37b4d22 100644
--- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/timelineservice/TestApplicationEntity.java
+++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/timelineservice/TestApplicationEntity.java
@@ -18,18 +18,18 @@
package org.apache.hadoop.yarn.api.records.timelineservice;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertEquals;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;
/**
* Various tests for the ApplicationEntity class.
*
*/
-public class TestApplicationEntity {
+class TestApplicationEntity {
@Test
- public void testIsApplicationEntity() {
+ void testIsApplicationEntity() {
TimelineEntity te = new TimelineEntity();
te.setType(TimelineEntityType.YARN_APPLICATION.toString());
assertTrue(ApplicationEntity.isApplicationEntity(te));
@@ -43,7 +43,7 @@ public class TestApplicationEntity {
}
@Test
- public void testGetApplicationEvent() {
+ void testGetApplicationEvent() {
TimelineEntity te = null;
TimelineEvent tEvent = ApplicationEntity.getApplicationEvent(te,
"no event");
diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/timelineservice/TestTimelineMetric.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/timelineservice/TestTimelineMetric.java
index 3244bc3..ec4d4dd 100644
--- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/timelineservice/TestTimelineMetric.java
+++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/records/timelineservice/TestTimelineMetric.java
@@ -17,20 +17,20 @@
*/
package org.apache.hadoop.yarn.api.records.timelineservice;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import java.util.HashMap;
import java.util.Map;
import org.apache.hadoop.yarn.api.records.timelineservice.TimelineMetric.Type;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
-public class TestTimelineMetric {
+class TestTimelineMetric {
@Test
- public void testTimelineMetricAggregation() {
+ void testTimelineMetricAggregation() {
long ts = System.currentTimeMillis();
// single_value metric add against null metric
TimelineMetric m1 = getSingleValueMetric("MEGA_BYTES_MILLIS",
diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/resource/TestPlacementConstraintParser.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/resource/TestPlacementConstraintParser.java
index d4b330c..dda30c7 100644
--- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/resource/TestPlacementConstraintParser.java
+++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/resource/TestPlacementConstraintParser.java
@@ -49,17 +49,19 @@ import static org.apache.hadoop.yarn.api.resource.PlacementConstraints.targetIn;
import static org.apache.hadoop.yarn.api.resource.PlacementConstraints.targetNodeAttribute;
import static org.apache.hadoop.yarn.api.resource.PlacementConstraints.targetNotIn;
-import org.junit.Assert;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.junit.jupiter.api.Test;
/**
* Class to test placement constraint parser.
*/
-public class TestPlacementConstraintParser {
+class TestPlacementConstraintParser {
@Test
- public void testTargetExpressionParser()
- throws PlacementConstraintParseException {
+ void testTargetExpressionParser() throws PlacementConstraintParseException {
String expressionStr;
ConstraintParser parser;
AbstractConstraint constraint;
@@ -70,22 +72,22 @@ public class TestPlacementConstraintParser {
expressionStr = "NOTIN, NODE, foo";
parser = new TargetConstraintParser(expressionStr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof SingleConstraint);
+ assertTrue(constraint instanceof SingleConstraint);
single = (SingleConstraint) constraint;
- Assert.assertEquals("node", single.getScope());
- Assert.assertEquals(0, single.getMinCardinality());
- Assert.assertEquals(0, single.getMaxCardinality());
+ assertEquals("node", single.getScope());
+ assertEquals(0, single.getMinCardinality());
+ assertEquals(0, single.getMaxCardinality());
verifyConstraintToString(expressionStr, constraint);
// lower cases is also valid
expressionStr = "notin, node, foo";
parser = new TargetConstraintParser(expressionStr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof SingleConstraint);
+ assertTrue(constraint instanceof SingleConstraint);
single = (SingleConstraint) constraint;
- Assert.assertEquals("node", single.getScope());
- Assert.assertEquals(0, single.getMinCardinality());
- Assert.assertEquals(0, single.getMaxCardinality());
+ assertEquals("node", single.getScope());
+ assertEquals(0, single.getMinCardinality());
+ assertEquals(0, single.getMaxCardinality());
verifyConstraintToString(expressionStr, constraint);
// Affinity with single target tag
@@ -93,11 +95,11 @@ public class TestPlacementConstraintParser {
expressionStr = "IN, NODE, foo";
parser = new TargetConstraintParser(expressionStr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof SingleConstraint);
+ assertTrue(constraint instanceof SingleConstraint);
single = (SingleConstraint) constraint;
- Assert.assertEquals("node", single.getScope());
- Assert.assertEquals(1, single.getMinCardinality());
- Assert.assertEquals(Integer.MAX_VALUE, single.getMaxCardinality());
+ assertEquals("node", single.getScope());
+ assertEquals(1, single.getMinCardinality());
+ assertEquals(Integer.MAX_VALUE, single.getMaxCardinality());
verifyConstraintToString(expressionStr, constraint);
// Anti-affinity with multiple target tags
@@ -105,17 +107,17 @@ public class TestPlacementConstraintParser {
expressionStr = "NOTIN, NODE, foo, bar, exp";
parser = new TargetConstraintParser(expressionStr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof SingleConstraint);
+ assertTrue(constraint instanceof SingleConstraint);
single = (SingleConstraint) constraint;
- Assert.assertEquals("node", single.getScope());
- Assert.assertEquals(0, single.getMinCardinality());
- Assert.assertEquals(0, single.getMaxCardinality());
- Assert.assertEquals(3, single.getTargetExpressions().size());
+ assertEquals("node", single.getScope());
+ assertEquals(0, single.getMinCardinality());
+ assertEquals(0, single.getMaxCardinality());
+ assertEquals(3, single.getTargetExpressions().size());
Set<TargetExpression> expectedTargetExpressions = Sets.newHashSet(
PlacementTargets.allocationTag("foo"),
PlacementTargets.allocationTag("bar"),
PlacementTargets.allocationTag("exp"));
- Assert.assertTrue(Sets.difference(expectedTargetExpressions,
+ assertTrue(Sets.difference(expectedTargetExpressions,
single.getTargetExpressions()).isEmpty());
verifyConstraintToString(expressionStr, constraint);
@@ -124,13 +126,13 @@ public class TestPlacementConstraintParser {
try {
parser.parse();
} catch (Exception e) {
- Assert.assertTrue(e instanceof PlacementConstraintParseException);
- Assert.assertTrue(e.getMessage().contains("expecting in or notin"));
+ assertTrue(e instanceof PlacementConstraintParseException);
+ assertTrue(e.getMessage().contains("expecting in or notin"));
}
}
@Test
- public void testCardinalityConstraintParser()
+ void testCardinalityConstraintParser()
throws PlacementConstraintParseException {
String expressionExpr;
ConstraintParser parser;
@@ -141,34 +143,34 @@ public class TestPlacementConstraintParser {
expressionExpr = "cardinality, NODE, foo, 0, 1";
parser = new CardinalityConstraintParser(expressionExpr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof SingleConstraint);
+ assertTrue(constraint instanceof SingleConstraint);
single = (SingleConstraint) constraint;
- Assert.assertEquals("node", single.getScope());
- Assert.assertEquals(0, single.getMinCardinality());
- Assert.assertEquals(1, single.getMaxCardinality());
- Assert.assertEquals(1, single.getTargetExpressions().size());
+ assertEquals("node", single.getScope());
+ assertEquals(0, single.getMinCardinality());
+ assertEquals(1, single.getMaxCardinality());
+ assertEquals(1, single.getTargetExpressions().size());
TargetExpression exp =
single.getTargetExpressions().iterator().next();
- Assert.assertEquals("ALLOCATION_TAG", exp.getTargetType().toString());
- Assert.assertEquals(1, exp.getTargetValues().size());
- Assert.assertEquals("foo", exp.getTargetValues().iterator().next());
+ assertEquals("ALLOCATION_TAG", exp.getTargetType().toString());
+ assertEquals(1, exp.getTargetValues().size());
+ assertEquals("foo", exp.getTargetValues().iterator().next());
verifyConstraintToString(expressionExpr, constraint);
// cardinality,NODE,foo,bar,moo,0,1
expressionExpr = "cardinality,RACK,foo,bar,moo,0,1";
parser = new CardinalityConstraintParser(expressionExpr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof SingleConstraint);
+ assertTrue(constraint instanceof SingleConstraint);
single = (SingleConstraint) constraint;
- Assert.assertEquals("rack", single.getScope());
- Assert.assertEquals(0, single.getMinCardinality());
- Assert.assertEquals(1, single.getMaxCardinality());
- Assert.assertEquals(3, single.getTargetExpressions().size());
+ assertEquals("rack", single.getScope());
+ assertEquals(0, single.getMinCardinality());
+ assertEquals(1, single.getMaxCardinality());
+ assertEquals(3, single.getTargetExpressions().size());
Set<TargetExpression> expectedTargetExpressions = Sets.newHashSet(
PlacementTargets.allocationTag("foo"),
PlacementTargets.allocationTag("bar"),
PlacementTargets.allocationTag("moo"));
- Assert.assertTrue(Sets.difference(expectedTargetExpressions,
+ assertTrue(Sets.difference(expectedTargetExpressions,
single.getTargetExpressions()).isEmpty());
verifyConstraintToString(expressionExpr, constraint);
@@ -177,9 +179,9 @@ public class TestPlacementConstraintParser {
parser = new CardinalityConstraintParser(
"cardinality,NOWHERE,foo,bar,moo,0,1");
parser.parse();
- Assert.fail("Expecting a parsing failure!");
+ fail("Expecting a parsing failure!");
} catch (PlacementConstraintParseException e) {
- Assert.assertTrue(e.getMessage()
+ assertTrue(e.getMessage()
.contains("expecting scope to node or rack, but met NOWHERE"));
}
@@ -188,15 +190,15 @@ public class TestPlacementConstraintParser {
parser = new CardinalityConstraintParser(
"cardinality,NODE,0,1");
parser.parse();
- Assert.fail("Expecting a parsing failure!");
+ fail("Expecting a parsing failure!");
} catch (PlacementConstraintParseException e) {
- Assert.assertTrue(e.getMessage()
+ assertTrue(e.getMessage()
.contains("at least 5 elements, but only 4 is given"));
}
}
@Test
- public void testAndConstraintParser()
+ void testAndConstraintParser()
throws PlacementConstraintParseException {
String expressionExpr;
ConstraintParser parser;
@@ -206,33 +208,33 @@ public class TestPlacementConstraintParser {
expressionExpr = "AND(NOTIN,NODE,foo:NOTIN,NODE,bar)";
parser = new ConjunctionConstraintParser(expressionExpr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof And);
+ assertTrue(constraint instanceof And);
and = (And) constraint;
- Assert.assertEquals(2, and.getChildren().size());
+ assertEquals(2, and.getChildren().size());
verifyConstraintToString(expressionExpr, constraint);
expressionExpr = "AND(NOTIN,NODE,foo:cardinality,NODE,foo,0,1)";
parser = new ConjunctionConstraintParser(expressionExpr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof And);
- Assert.assertEquals(2, and.getChildren().size());
+ assertTrue(constraint instanceof And);
+ assertEquals(2, and.getChildren().size());
verifyConstraintToString(expressionExpr, constraint);
expressionExpr =
"AND(NOTIN,NODE,foo:AND(NOTIN,NODE,foo:cardinality,NODE,foo,0,1))";
parser = new ConjunctionConstraintParser(expressionExpr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof And);
+ assertTrue(constraint instanceof And);
and = (And) constraint;
- Assert.assertTrue(and.getChildren().get(0) instanceof SingleConstraint);
- Assert.assertTrue(and.getChildren().get(1) instanceof And);
+ assertTrue(and.getChildren().get(0) instanceof SingleConstraint);
+ assertTrue(and.getChildren().get(1) instanceof And);
and = (And) and.getChildren().get(1);
- Assert.assertEquals(2, and.getChildren().size());
+ assertEquals(2, and.getChildren().size());
verifyConstraintToString(expressionExpr, constraint);
}
@Test
- public void testOrConstraintParser()
+ void testOrConstraintParser()
throws PlacementConstraintParseException {
String expressionExpr;
ConstraintParser parser;
@@ -242,33 +244,33 @@ public class TestPlacementConstraintParser {
expressionExpr = "OR(NOTIN,NODE,foo:NOTIN,NODE,bar)";
parser = new ConjunctionConstraintParser(expressionExpr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof Or);
+ assertTrue(constraint instanceof Or);
or = (Or) constraint;
- Assert.assertEquals(2, or.getChildren().size());
+ assertEquals(2, or.getChildren().size());
verifyConstraintToString(expressionExpr, constraint);
expressionExpr = "OR(NOTIN,NODE,foo:cardinality,NODE,foo,0,1)";
parser = new ConjunctionConstraintParser(expressionExpr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof Or);
- Assert.assertEquals(2, or.getChildren().size());
+ assertTrue(constraint instanceof Or);
+ assertEquals(2, or.getChildren().size());
verifyConstraintToString(expressionExpr, constraint);
expressionExpr =
"OR(NOTIN,NODE,foo:OR(NOTIN,NODE,foo:cardinality,NODE,foo,0,1))";
parser = new ConjunctionConstraintParser(expressionExpr);
constraint = parser.parse();
- Assert.assertTrue(constraint instanceof Or);
+ assertTrue(constraint instanceof Or);
or = (Or) constraint;
- Assert.assertTrue(or.getChildren().get(0) instanceof SingleConstraint);
- Assert.assertTrue(or.getChildren().get(1) instanceof Or);
+ assertTrue(or.getChildren().get(0) instanceof SingleConstraint);
+ assertTrue(or.getChildren().get(1) instanceof Or);
or = (Or) or.getChildren().get(1);
- Assert.assertEquals(2, or.getChildren().size());
+ assertEquals(2, or.getChildren().size());
verifyConstraintToString(expressionExpr, constraint);
}
@Test
- public void testMultipleConstraintsTokenizer()
+ void testMultipleConstraintsTokenizer()
throws PlacementConstraintParseException {
MultipleConstraintsTokenizer ct;
SourceTagsTokenizer st;
@@ -310,9 +312,9 @@ public class TestPlacementConstraintParser {
st = new SourceTagsTokenizer("A(B)");
mp = new TokenizerTester(st, "A", "B");
mp.verify();
- Assert.fail("Expecting a parsing failure");
+ fail("Expecting a parsing failure");
} catch (PlacementConstraintParseException e) {
- Assert.assertTrue(e.getMessage()
+ assertTrue(e.getMessage()
.contains("Value of the expression must be an integer"));
}
}
@@ -334,15 +336,15 @@ public class TestPlacementConstraintParser {
int i = 0;
while (tokenizer.hasMoreElements()) {
String current = tokenizer.nextElement();
- Assert.assertTrue(i < expectedExtractions.length);
- Assert.assertEquals(expectedExtractions[i], current);
+ assertTrue(i < expectedExtractions.length);
+ assertEquals(expectedExtractions[i], current);
i++;
}
}
}
@Test
- public void testParsePlacementSpec()
+ void testParsePlacementSpec()
throws PlacementConstraintParseException {
Map<SourceTags, PlacementConstraint> result;
PlacementConstraint expectedPc1, expectedPc2;
@@ -352,92 +354,92 @@ public class TestPlacementConstraintParser {
// Only Source Tag without constraint
result = PlacementConstraintParser
.parsePlacementSpec("foo(3)");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
tag1 = result.keySet().iterator().next();
- Assert.assertEquals("foo", tag1.getTag());
- Assert.assertEquals(3, tag1.getNumOfAllocations());
+ assertEquals("foo", tag1.getTag());
+ assertEquals(3, tag1.getNumOfAllocations());
expectedPc1 = null;
actualPc1 = result.values().iterator().next();
- Assert.assertEquals(expectedPc1, actualPc1);
+ assertEquals(expectedPc1, actualPc1);
// A single anti-affinity constraint
result = PlacementConstraintParser
.parsePlacementSpec("foo(3),notin,node,foo");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
tag1 = result.keySet().iterator().next();
- Assert.assertEquals("foo", tag1.getTag());
- Assert.assertEquals(3, tag1.getNumOfAllocations());
+ assertEquals("foo", tag1.getTag());
+ assertEquals(3, tag1.getNumOfAllocations());
expectedPc1 = targetNotIn("node", allocationTag("foo")).build();
actualPc1 = result.values().iterator().next();
- Assert.assertEquals(expectedPc1, actualPc1);
+ assertEquals(expectedPc1, actualPc1);
// Upper case
result = PlacementConstraintParser
.parsePlacementSpec("foo(3),NOTIN,NODE,foo");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
tag1 = result.keySet().iterator().next();
- Assert.assertEquals("foo", tag1.getTag());
- Assert.assertEquals(3, tag1.getNumOfAllocations());
+ assertEquals("foo", tag1.getTag());
+ assertEquals(3, tag1.getNumOfAllocations());
expectedPc1 = targetNotIn("node", allocationTag("foo")).build();
actualPc1 = result.values().iterator().next();
- Assert.assertEquals(expectedPc1, actualPc1);
+ assertEquals(expectedPc1, actualPc1);
// A single cardinality constraint
result = PlacementConstraintParser
.parsePlacementSpec("foo(10),cardinality,node,foo,bar,0,100");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
tag1 = result.keySet().iterator().next();
- Assert.assertEquals("foo", tag1.getTag());
- Assert.assertEquals(10, tag1.getNumOfAllocations());
+ assertEquals("foo", tag1.getTag());
+ assertEquals(10, tag1.getNumOfAllocations());
TargetExpression[] targetExpressions = new TargetExpression[] {
PlacementTargets.allocationTag("foo"),
PlacementTargets.allocationTag("bar")};
expectedPc1 = PlacementConstraints.targetCardinality("node", 0,
100, targetExpressions).build();
- Assert.assertEquals(expectedPc1, result.values().iterator().next());
+ assertEquals(expectedPc1, result.values().iterator().next());
// Two constraint expressions
result = PlacementConstraintParser
.parsePlacementSpec("foo(3),notin,node,foo:bar(2),in,node,foo");
- Assert.assertEquals(2, result.size());
+ assertEquals(2, result.size());
Iterator<SourceTags> keyIt = result.keySet().iterator();
tag1 = keyIt.next();
- Assert.assertEquals("foo", tag1.getTag());
- Assert.assertEquals(3, tag1.getNumOfAllocations());
+ assertEquals("foo", tag1.getTag());
+ assertEquals(3, tag1.getNumOfAllocations());
tag2 = keyIt.next();
- Assert.assertEquals("bar", tag2.getTag());
- Assert.assertEquals(2, tag2.getNumOfAllocations());
+ assertEquals("bar", tag2.getTag());
+ assertEquals(2, tag2.getNumOfAllocations());
Iterator<PlacementConstraint> valueIt = result.values().iterator();
expectedPc1 = targetNotIn("node", allocationTag("foo")).build();
expectedPc2 = targetIn("node", allocationTag("foo")).build();
- Assert.assertEquals(expectedPc1, valueIt.next());
- Assert.assertEquals(expectedPc2, valueIt.next());
+ assertEquals(expectedPc1, valueIt.next());
+ assertEquals(expectedPc2, valueIt.next());
// And constraint
result = PlacementConstraintParser
.parsePlacementSpec("foo(1000),and(notin,node,bar:in,node,foo)");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
keyIt = result.keySet().iterator();
tag1 = keyIt.next();
- Assert.assertEquals("foo", tag1.getTag());
- Assert.assertEquals(1000, tag1.getNumOfAllocations());
+ assertEquals("foo", tag1.getTag());
+ assertEquals(1000, tag1.getNumOfAllocations());
actualPc1 = result.values().iterator().next();
expectedPc1 = and(targetNotIn("node", allocationTag("bar")),
targetIn("node", allocationTag("foo"))).build();
- Assert.assertEquals(expectedPc1, actualPc1);
+ assertEquals(expectedPc1, actualPc1);
// Multiple constraints with nested forms.
result = PlacementConstraintParser.parsePlacementSpec(
"foo(1000),and(notin,node,bar:or(in,node,foo:in,node,moo))"
+ ":bar(200),notin,node,foo");
- Assert.assertEquals(2, result.size());
+ assertEquals(2, result.size());
keyIt = result.keySet().iterator();
tag1 = keyIt.next();
tag2 = keyIt.next();
- Assert.assertEquals("foo", tag1.getTag());
- Assert.assertEquals(1000, tag1.getNumOfAllocations());
- Assert.assertEquals("bar", tag2.getTag());
- Assert.assertEquals(200, tag2.getNumOfAllocations());
+ assertEquals("foo", tag1.getTag());
+ assertEquals(1000, tag1.getNumOfAllocations());
+ assertEquals("bar", tag2.getTag());
+ assertEquals(200, tag2.getNumOfAllocations());
valueIt = result.values().iterator();
actualPc1 = valueIt.next();
actualPc2 = valueIt.next();
@@ -445,18 +447,18 @@ public class TestPlacementConstraintParser {
expectedPc1 = and(targetNotIn("node", allocationTag("bar")),
or(targetIn("node", allocationTag("foo")),
targetIn("node", allocationTag("moo")))).build();
- Assert.assertEquals(actualPc1, expectedPc1);
+ assertEquals(actualPc1, expectedPc1);
expectedPc2 = targetNotIn("node", allocationTag("foo")).build();
- Assert.assertEquals(expectedPc2, actualPc2);
+ assertEquals(expectedPc2, actualPc2);
// Failure Cases
String[] invalidSpecs = {"foo(3", "foo),bar", "foobar", "),java=1.7,1.8"};
for (String spec : invalidSpecs) {
try {
result = PlacementConstraintParser.parsePlacementSpec(spec);
- Assert.fail("Expected a failure!");
+ fail("Expected a failure!");
} catch (Exception e) {
- Assert.assertTrue(e instanceof PlacementConstraintParseException);
+ assertTrue(e instanceof PlacementConstraintParseException);
}
}
}
@@ -475,13 +477,13 @@ public class TestPlacementConstraintParser {
try {
PlacementConstraintParser.parseExpression(constrainExpr);
} catch (PlacementConstraintParseException e) {
- Assert.fail("The parser is unable to parse the expression: "
+ fail("The parser is unable to parse the expression: "
+ constrainExpr + ", caused by: " + e.getMessage());
}
}
@Test
- public void testParseNodeAttributeSpec()
+ void testParseNodeAttributeSpec()
throws PlacementConstraintParseException {
Map<SourceTags, PlacementConstraint> result;
PlacementConstraint.AbstractConstraint expectedPc1, expectedPc2;
@@ -490,33 +492,33 @@ public class TestPlacementConstraintParser {
// A single node attribute constraint
result = PlacementConstraintParser
.parsePlacementSpec("xyz(4),rm.yarn.io/foo=true");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
TargetExpression target = PlacementTargets
.nodeAttribute("rm.yarn.io/foo", "true");
expectedPc1 = targetNodeAttribute("node", NodeAttributeOpCode.EQ, target);
actualPc1 = result.values().iterator().next();
- Assert.assertEquals(expectedPc1, actualPc1.getConstraintExpr());
+ assertEquals(expectedPc1, actualPc1.getConstraintExpr());
// A single node attribute constraint
result = PlacementConstraintParser
.parsePlacementSpec("xyz(3),rm.yarn.io/foo!=abc");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
target = PlacementTargets
.nodeAttribute("rm.yarn.io/foo", "abc");
expectedPc1 = targetNodeAttribute("node", NodeAttributeOpCode.NE, target);
actualPc1 = result.values().iterator().next();
- Assert.assertEquals(expectedPc1, actualPc1.getConstraintExpr());
+ assertEquals(expectedPc1, actualPc1.getConstraintExpr());
actualPc1 = result.values().iterator().next();
- Assert.assertEquals(expectedPc1, actualPc1.getConstraintExpr());
+ assertEquals(expectedPc1, actualPc1.getConstraintExpr());
// A single node attribute constraint
result = PlacementConstraintParser
.parsePlacementSpec(
"xyz(1),rm.yarn.io/foo!=abc:zxy(1),rm.yarn.io/bar=true");
- Assert.assertEquals(2, result.size());
+ assertEquals(2, result.size());
target = PlacementTargets
.nodeAttribute("rm.yarn.io/foo", "abc");
expectedPc1 = targetNodeAttribute("node", NodeAttributeOpCode.NE, target);
@@ -527,25 +529,25 @@ public class TestPlacementConstraintParser {
Iterator<PlacementConstraint> valueIt = result.values().iterator();
actualPc1 = valueIt.next();
actualPc2 = valueIt.next();
- Assert.assertEquals(expectedPc1, actualPc1.getConstraintExpr());
- Assert.assertEquals(expectedPc2, actualPc2.getConstraintExpr());
+ assertEquals(expectedPc1, actualPc1.getConstraintExpr());
+ assertEquals(expectedPc2, actualPc2.getConstraintExpr());
// A single node attribute constraint w/o source tags
result = PlacementConstraintParser
.parsePlacementSpec("rm.yarn.io/foo=true");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
target = PlacementTargets.nodeAttribute("rm.yarn.io/foo", "true");
expectedPc1 = targetNodeAttribute("node", NodeAttributeOpCode.EQ, target);
SourceTags actualSourceTags = result.keySet().iterator().next();
- Assert.assertTrue(actualSourceTags.isEmpty());
+ assertTrue(actualSourceTags.isEmpty());
actualPc1 = result.values().iterator().next();
- Assert.assertEquals(expectedPc1, actualPc1.getConstraintExpr());
+ assertEquals(expectedPc1, actualPc1.getConstraintExpr());
// Node Attribute Constraint With Multiple Values
result = PlacementConstraintParser
.parsePlacementSpec("java=1.7,1.8");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
Set<String> constraintEntities = new TreeSet<>();
constraintEntities.add("1.7");
@@ -554,52 +556,52 @@ public class TestPlacementConstraintParser {
constraintEntities.toArray(new String[constraintEntities.size()]));
expectedPc1 = targetNodeAttribute("node", NodeAttributeOpCode.EQ, target);
actualSourceTags = result.keySet().iterator().next();
- Assert.assertTrue(actualSourceTags.isEmpty());
+ assertTrue(actualSourceTags.isEmpty());
actualPc1 = result.values().iterator().next();
- Assert.assertEquals(expectedPc1, actualPc1.getConstraintExpr());
+ assertEquals(expectedPc1, actualPc1.getConstraintExpr());
// If source tags is not specified for a node-attribute constraint,
// then this expression must be single constraint expression.
try {
PlacementConstraintParser
.parsePlacementSpec("rm.yarn.io/foo=true:xyz(1),notin,node,xyz");
- Assert.fail("Expected a failure!");
+ fail("Expected a failure!");
} catch (Exception e) {
- Assert.assertTrue(e instanceof PlacementConstraintParseException);
+ assertTrue(e instanceof PlacementConstraintParseException);
}
}
@Test
- public void testParseAllocationTagNameSpace()
+ void testParseAllocationTagNameSpace()
throws PlacementConstraintParseException {
Map<SourceTags, PlacementConstraint> result;
// Constraint with Two Different NameSpaces
result = PlacementConstraintParser
.parsePlacementSpec("foo(2),notin,node,not-self/bar,all/moo");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
Set<TargetExpression> expectedTargetExpressions = Sets.newHashSet(
PlacementTargets.allocationTagWithNamespace("not-self", "bar"),
PlacementTargets.allocationTagWithNamespace("all", "moo"));
AbstractConstraint constraint = result.values().iterator().next().
getConstraintExpr();
- Assert.assertTrue(constraint instanceof SingleConstraint);
+ assertTrue(constraint instanceof SingleConstraint);
SingleConstraint single = (SingleConstraint) constraint;
- Assert.assertEquals(2, single.getTargetExpressions().size());
- Assert.assertTrue(Sets.difference(expectedTargetExpressions,
+ assertEquals(2, single.getTargetExpressions().size());
+ assertTrue(Sets.difference(expectedTargetExpressions,
single.getTargetExpressions()).isEmpty());
// Constraint With Default NameSpace SELF
result = PlacementConstraintParser
.parsePlacementSpec("foo(2),notin,node,moo");
- Assert.assertEquals(1, result.size());
+ assertEquals(1, result.size());
TargetExpression expectedTargetExpression = PlacementTargets.
allocationTagWithNamespace("self", "moo");
constraint = result.values().iterator().next().getConstraintExpr();
- Assert.assertTrue(constraint instanceof SingleConstraint);
+ assertTrue(constraint instanceof SingleConstraint);
single = (SingleConstraint) constraint;
- Assert.assertEquals(1, single.getTargetExpressions().size());
- Assert.assertEquals(expectedTargetExpression,
+ assertEquals(1, single.getTargetExpressions().size());
+ assertEquals(expectedTargetExpression,
single.getTargetExpressions().iterator().next());
// Constraint With Invalid NameSpace
@@ -610,8 +612,8 @@ public class TestPlacementConstraintParser {
} catch(PlacementConstraintParseException e) {
caughtException = true;
}
- Assert.assertTrue("PlacementConstraintParseException is expected",
- caughtException);
+ assertTrue(caughtException,
+ "PlacementConstraintParseException is expected");
}
}
diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/resource/TestPlacementConstraints.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/resource/TestPlacementConstraints.java
index 516ecfc..6b6a2fb 100644
--- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/resource/TestPlacementConstraints.java
+++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/api/resource/TestPlacementConstraints.java
@@ -27,6 +27,8 @@ import static org.apache.hadoop.yarn.api.resource.PlacementConstraints.targetIn;
import static org.apache.hadoop.yarn.api.resource.PlacementConstraints.targetNotIn;
import static org.apache.hadoop.yarn.api.resource.PlacementConstraints.PlacementTargets.allocationTag;
import static org.apache.hadoop.yarn.api.resource.PlacementConstraints.PlacementTargets.nodeAttribute;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import org.apache.hadoop.yarn.api.records.AllocationTagNamespaceType;
import org.apache.hadoop.yarn.api.resource.PlacementConstraint.AbstractConstraint;
@@ -34,36 +36,35 @@ import org.apache.hadoop.yarn.api.resource.PlacementConstraint.And;
import org.apache.hadoop.yarn.api.resource.PlacementConstraint.SingleConstraint;
import org.apache.hadoop.yarn.api.resource.PlacementConstraint.TargetExpression;
import org.apache.hadoop.yarn.api.resource.PlacementConstraint.TargetExpression.TargetType;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Test class for the various static methods in
* {@link org.apache.hadoop.yarn.api.resource.PlacementConstraints}.
*/
-public class TestPlacementConstraints {
+class TestPlacementConstraints {
@Test
- public void testNodeAffinityToTag() {
+ void testNodeAffinityToTag() {
AbstractConstraint constraintExpr =
targetIn(NODE, allocationTag("hbase-m"));
SingleConstraint sConstraint = (SingleConstraint) constraintExpr;
- Assert.assertEquals(NODE, sConstraint.getScope());
- Assert.assertEquals(1, sConstraint.getMinCardinality());
- Assert.assertEquals(Integer.MAX_VALUE, sConstraint.getMaxCardinality());
+ assertEquals(NODE, sConstraint.getScope());
+ assertEquals(1, sConstraint.getMinCardinality());
+ assertEquals(Integer.MAX_VALUE, sConstraint.getMaxCardinality());
- Assert.assertEquals(1, sConstraint.getTargetExpressions().size());
+ assertEquals(1, sConstraint.getTargetExpressions().size());
TargetExpression tExpr =
sConstraint.getTargetExpressions().iterator().next();
- Assert.assertEquals(AllocationTagNamespaceType.SELF.toString(),
+ assertEquals(AllocationTagNamespaceType.SELF.toString(),
tExpr.getTargetKey());
- Assert.assertEquals(TargetType.ALLOCATION_TAG, tExpr.getTargetType());
- Assert.assertEquals(1, tExpr.getTargetValues().size());
- Assert.assertEquals("hbase-m", tExpr.getTargetValues().iterator().next());
+ assertEquals(TargetType.ALLOCATION_TAG, tExpr.getTargetType());
+ assertEquals(1, tExpr.getTargetValues().size());
+ assertEquals("hbase-m", tExpr.getTargetValues().iterator().next());
PlacementConstraint constraint = PlacementConstraints.build(constraintExpr);
- Assert.assertNotNull(constraint.getConstraintExpr());
+ assertNotNull(constraint.getConstraintExpr());
}
@Test
@@ -72,17 +73,17 @@ public class TestPlacementConstraints {
targetNotIn(NODE, nodeAttribute("java", "1.8"));
SingleConstraint sConstraint = (SingleConstraint) constraintExpr;
- Assert.assertEquals(NODE, sConstraint.getScope());
- Assert.assertEquals(0, sConstraint.getMinCardinality());
- Assert.assertEquals(0, sConstraint.getMaxCardinality());
+ assertEquals(NODE, sConstraint.getScope());
+ assertEquals(0, sConstraint.getMinCardinality());
+ assertEquals(0, sConstraint.getMaxCardinality());
- Assert.assertEquals(1, sConstraint.getTargetExpressions().size());
+ assertEquals(1, sConstraint.getTargetExpressions().size());
TargetExpression tExpr =
sConstraint.getTargetExpressions().iterator().next();
- Assert.assertEquals("java", tExpr.getTargetKey());
- Assert.assertEquals(TargetType.NODE_ATTRIBUTE, tExpr.getTargetType());
- Assert.assertEquals(1, tExpr.getTargetValues().size());
- Assert.assertEquals("1.8", tExpr.getTargetValues().iterator().next());
+ assertEquals("java", tExpr.getTargetKey());
+ assertEquals(TargetType.NODE_ATTRIBUTE, tExpr.getTargetType());
+ assertEquals(1, tExpr.getTargetValues().size());
+ assertEquals("1.8", tExpr.getTargetValues().iterator().next());
}
@Test
@@ -93,17 +94,17 @@ public class TestPlacementConstraints {
targetCardinality(RACK, 2, 10, allocationTag("zk")));
And andExpr = (And) constraintExpr;
- Assert.assertEquals(3, andExpr.getChildren().size());
+ assertEquals(3, andExpr.getChildren().size());
SingleConstraint sConstr = (SingleConstraint) andExpr.getChildren().get(0);
TargetExpression tExpr = sConstr.getTargetExpressions().iterator().next();
- Assert.assertEquals("spark", tExpr.getTargetValues().iterator().next());
+ assertEquals("spark", tExpr.getTargetValues().iterator().next());
sConstr = (SingleConstraint) andExpr.getChildren().get(1);
- Assert.assertEquals(0, sConstr.getMinCardinality());
- Assert.assertEquals(3, sConstr.getMaxCardinality());
+ assertEquals(0, sConstr.getMinCardinality());
+ assertEquals(3, sConstr.getMaxCardinality());
sConstr = (SingleConstraint) andExpr.getChildren().get(2);
- Assert.assertEquals(2, sConstr.getMinCardinality());
- Assert.assertEquals(10, sConstr.getMaxCardinality());
+ assertEquals(2, sConstr.getMinCardinality());
+ assertEquals(10, sConstr.getMaxCardinality());
}
}
diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/conf/TestResourceInformation.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/conf/TestResourceInformation.java
index e776a6c..79ff70a 100644
--- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/conf/TestResourceInformation.java
+++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/conf/TestResourceInformation.java
@@ -22,74 +22,77 @@ import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import org.apache.hadoop.yarn.api.protocolrecords.ResourceTypes;
import org.apache.hadoop.yarn.api.records.ResourceInformation;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.fail;
/**
* Test class to verify various resource informations in a given resource.
*/
-public class TestResourceInformation {
+class TestResourceInformation {
@Test
- public void testName() {
+ void testName() {
String name = "yarn.io/test";
ResourceInformation ri = ResourceInformation.newInstance(name);
- Assert.assertEquals("Resource name incorrect", name, ri.getName());
+ assertEquals(name, ri.getName(), "Resource name incorrect");
}
@Test
- public void testUnits() {
+ void testUnits() {
String name = "yarn.io/test";
String units = "m";
ResourceInformation ri = ResourceInformation.newInstance(name, units);
- Assert.assertEquals("Resource name incorrect", name, ri.getName());
- Assert.assertEquals("Resource units incorrect", units, ri.getUnits());
+ assertEquals(name, ri.getName(), "Resource name incorrect");
+ assertEquals(units, ri.getUnits(), "Resource units incorrect");
units = "z";
try {
ResourceInformation.newInstance(name, units).setUnits(units);
- Assert.fail(units + "is not a valid unit");
+ fail(units + "is not a valid unit");
} catch (IllegalArgumentException ie) {
// do nothing
}
}
@Test
- public void testValue() {
+ void testValue() {
String name = "yarn.io/test";
long value = 1L;
ResourceInformation ri = ResourceInformation.newInstance(name, value);
- Assert.assertEquals("Resource name incorrect", name, ri.getName());
- Assert.assertEquals("Resource value incorrect", value, ri.getValue());
+ assertEquals(name, ri.getName(), "Resource name incorrect");
+ assertEquals(value, ri.getValue(), "Resource value incorrect");
}
@Test
- public void testResourceInformation() {
+ void testResourceInformation() {
String name = "yarn.io/test";
long value = 1L;
String units = "m";
ResourceInformation ri =
ResourceInformation.newInstance(name, units, value);
- Assert.assertEquals("Resource name incorrect", name, ri.getName());
- Assert.assertEquals("Resource value incorrect", value, ri.getValue());
- Assert.assertEquals("Resource units incorrect", units, ri.getUnits());
+ assertEquals(name, ri.getName(), "Resource name incorrect");
+ assertEquals(value, ri.getValue(), "Resource value incorrect");
+ assertEquals(units, ri.getUnits(), "Resource units incorrect");
}
@Test
- public void testEqualsWithTagsAndAttributes() {
+ void testEqualsWithTagsAndAttributes() {
// Same tags but different order
ResourceInformation ri01 = ResourceInformation.newInstance("r1", "M", 100,
ResourceTypes.COUNTABLE, 0, 100,
ImmutableSet.of("A", "B"), null);
ResourceInformation ri02 = ResourceInformation.newInstance("r1", "M", 100,
ResourceTypes.COUNTABLE, 0, 100, ImmutableSet.of("B", "A"), null);
- Assert.assertEquals(ri01, ri02);
+ assertEquals(ri01, ri02);
// Different tags
ResourceInformation ri11 = ResourceInformation.newInstance("r1", "M", 100,
ResourceTypes.COUNTABLE, 0, 100, null, null);
ResourceInformation ri12 = ResourceInformation.newInstance("r1", "M", 100,
ResourceTypes.COUNTABLE, 0, 100, ImmutableSet.of("B", "A"), null);
- Assert.assertNotEquals(ri11, ri12);
+ assertNotEquals(ri11, ri12);
// Different attributes
ResourceInformation ri21 = ResourceInformation.newInstance("r1", "M", 100,
@@ -98,20 +101,20 @@ public class TestResourceInformation {
ResourceInformation ri22 = ResourceInformation.newInstance("r1", "M", 100,
ResourceTypes.COUNTABLE, 0, 100, null,
ImmutableMap.of("A", "A1", "B", "B2"));
- Assert.assertNotEquals(ri21, ri22);
+ assertNotEquals(ri21, ri22);
// No tags or attributes
ResourceInformation ri31 = ResourceInformation.newInstance("r1", "M", 100,
ResourceTypes.COUNTABLE, 0, 100, null, null);
ResourceInformation ri32 = ResourceInformation.newInstance("r1", "M", 100,
ResourceTypes.COUNTABLE, 0, 100, null, null);
- Assert.assertEquals(ri31, ri32);
+ assertEquals(ri31, ri32);
// Null tags/attributes same as empty ones
ResourceInformation ri41 = ResourceInformation.newInstance("r1", "M", 100,
ResourceTypes.COUNTABLE, 0, 100, ImmutableSet.of(), null);
ResourceInformation ri42 = ResourceInformation.newInstance("r1", "M", 100,
ResourceTypes.COUNTABLE, 0, 100, null, ImmutableMap.of());
- Assert.assertEquals(ri41, ri42);
+ assertEquals(ri41, ri42);
}
}
diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/util/TestUnitsConversionUtil.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/util/TestUnitsConversionUtil.java
index a412fae..8dff587 100644
--- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/util/TestUnitsConversionUtil.java
+++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/test/java/org/apache/hadoop/yarn/util/TestUnitsConversionUtil.java
@@ -18,121 +18,132 @@
package org.apache.hadoop.yarn.util;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
/**
* Test class to handle all test cases needed to verify basic unit conversion
* scenarios.
*/
-public class TestUnitsConversionUtil {
+class TestUnitsConversionUtil {
@Test
- public void testUnitsConversion() {
+ void testUnitsConversion() {
int value = 5;
String fromUnit = "";
long test = value;
- Assert.assertEquals("pico test failed",
- value * 1000L * 1000L * 1000L * 1000L,
- UnitsConversionUtil.convert(fromUnit, "p", test));
- Assert.assertEquals("nano test failed",
- value * 1000L * 1000L * 1000L,
- UnitsConversionUtil.convert(fromUnit, "n", test));
- Assert
- .assertEquals("micro test failed", value * 1000L * 1000L,
- UnitsConversionUtil.convert(fromUnit, "u", test));
- Assert.assertEquals("milli test failed", value * 1000L,
- UnitsConversionUtil.convert(fromUnit, "m", test));
+ assertEquals(value * 1000L * 1000L * 1000L * 1000L,
+ UnitsConversionUtil.convert(fromUnit, "p", test),
+ "pico test failed");
+ assertEquals(value * 1000L * 1000L * 1000L,
+ UnitsConversionUtil.convert(fromUnit, "n", test),
+ "nano test failed");
+ assertEquals(value * 1000L * 1000L,
+ UnitsConversionUtil.convert(fromUnit, "u", test),
+ "micro test failed");
+ assertEquals(value * 1000L,
+ UnitsConversionUtil.convert(fromUnit, "m", test),
+ "milli test failed");
test = value * 1000L * 1000L * 1000L * 1000L * 1000L;
fromUnit = "";
- Assert.assertEquals("kilo test failed", test / 1000L,
- UnitsConversionUtil.convert(fromUnit, "k", test));
-
- Assert
- .assertEquals("mega test failed", test / (1000L * 1000L),
- UnitsConversionUtil.convert(fromUnit, "M", test));
- Assert.assertEquals("giga test failed",
- test / (1000L * 1000L * 1000L),
- UnitsConversionUtil.convert(fromUnit, "G", test));
- Assert.assertEquals("tera test failed",
- test / (1000L * 1000L * 1000L * 1000L),
- UnitsConversionUtil.convert(fromUnit, "T", test));
- Assert.assertEquals("peta test failed",
- test / (1000L * 1000L * 1000L * 1000L * 1000L),
- UnitsConversionUtil.convert(fromUnit, "P", test));
-
- Assert.assertEquals("nano to pico test failed", value * 1000L,
- UnitsConversionUtil.convert("n", "p", value));
-
- Assert.assertEquals("mega to giga test failed", value,
- UnitsConversionUtil.convert("M", "G", value * 1000L));
-
- Assert.assertEquals("Mi to Gi test failed", value,
- UnitsConversionUtil.convert("Mi", "Gi", value * 1024L));
-
- Assert.assertEquals("Mi to Ki test failed", value * 1024,
- UnitsConversionUtil.convert("Mi", "Ki", value));
-
- Assert.assertEquals("Ki to base units test failed", 5 * 1024,
- UnitsConversionUtil.convert("Ki", "", 5));
-
- Assert.assertEquals("Mi to k test failed", 1073741,
- UnitsConversionUtil.convert("Mi", "k", 1024));
-
- Assert.assertEquals("M to Mi test failed", 953,
- UnitsConversionUtil.convert("M", "Mi", 1000));
+ assertEquals(test / 1000L,
+ UnitsConversionUtil.convert(fromUnit, "k", test),
+ "kilo test failed");
+
+ assertEquals(test / (1000L * 1000L),
+ UnitsConversionUtil.convert(fromUnit, "M", test),
+ "mega test failed");
+ assertEquals(test / (1000L * 1000L * 1000L),
+ UnitsConversionUtil.convert(fromUnit, "G", test),
+ "giga test failed");
+ assertEquals(test / (1000L * 1000L * 1000L * 1000L),
+ UnitsConversionUtil.convert(fromUnit, "T", test),
+ "tera test failed");
+ assertEquals(test / (1000L * 1000L * 1000L * 1000L * 1000L),
+ UnitsConversionUtil.convert(fromUnit, "P", test),
+ "peta test failed");
+
+ assertEquals(value * 1000L,
+ UnitsConversionUtil.convert("n", "p", value),
+ "nano to pico test failed");
+
+ assertEquals(value,
+ UnitsConversionUtil.convert("M", "G", value * 1000L),
+ "mega to giga test failed");
+
+ assertEquals(value,
+ UnitsConversionUtil.convert("Mi", "Gi", value * 1024L),
+ "Mi to Gi test failed");
+
+ assertEquals(value * 1024,
+ UnitsConversionUtil.convert("Mi", "Ki", value),
+ "Mi to Ki test failed");
+
+ assertEquals(5 * 1024,
+ UnitsConversionUtil.convert("Ki", "", 5),
+ "Ki to base units test failed");
+
+ assertEquals(1073741,
+ UnitsConversionUtil.convert("Mi", "k", 1024),
+ "Mi to k test failed");
+
+ assertEquals(953,
+ UnitsConversionUtil.convert("M", "Mi", 1000),
+ "M to Mi test failed");
}
@Test
- public void testOverflow() {
+ void testOverflow() {
long test = 5 * 1000L * 1000L * 1000L * 1000L * 1000L;
try {
UnitsConversionUtil.convert("P", "p", test);
- Assert.fail("this operation should result in an overflow");
+ fail("this operation should result in an overflow");
} catch (IllegalArgumentException ie) {
// do nothing
}
try {
UnitsConversionUtil.convert("m", "p", Long.MAX_VALUE - 1);
- Assert.fail("this operation should result in an overflow");
+ fail("this operation should result in an overflow");
} catch (IllegalArgumentException ie) {
// do nothing
}
}
@Test
- public void testCompare() {
+ void testCompare() {
String unitA = "P";
long valueA = 1;
String unitB = "p";
long valueB = 2;
- Assert.assertEquals(1,
+ assertEquals(1,
UnitsConversionUtil.compare(unitA, valueA, unitB, valueB));
- Assert.assertEquals(-1,
+ assertEquals(-1,
UnitsConversionUtil.compare(unitB, valueB, unitA, valueA));
- Assert.assertEquals(0,
+ assertEquals(0,
UnitsConversionUtil.compare(unitA, valueA, unitA, valueA));
- Assert.assertEquals(-1,
+ assertEquals(-1,
UnitsConversionUtil.compare(unitA, valueA, unitA, valueB));
- Assert.assertEquals(1,
+ assertEquals(1,
UnitsConversionUtil.compare(unitA, valueB, unitA, valueA));
unitB = "T";
- Assert.assertEquals(1,
+ assertEquals(1,
UnitsConversionUtil.compare(unitA, valueA, unitB, valueB));
- Assert.assertEquals(-1,
+ assertEquals(-1,
UnitsConversionUtil.compare(unitB, valueB, unitA, valueA));
- Assert.assertEquals(0,
+ assertEquals(0,
UnitsConversionUtil.compare(unitA, valueA, unitB, 1000L));
unitA = "p";
unitB = "n";
- Assert.assertEquals(-1,
+ assertEquals(-1,
UnitsConversionUtil.compare(unitA, valueA, unitB, valueB));
- Assert.assertEquals(1,
+ assertEquals(1,
UnitsConversionUtil.compare(unitB, valueB, unitA, valueA));
- Assert.assertEquals(0,
+ assertEquals(0,
UnitsConversionUtil.compare(unitA, 1000L, unitB, valueA));
}
---------------------------------------------------------------------
To unsubscribe, e-mail: common-commits-unsubscribe@hadoop.apache.org
For additional commands, e-mail: common-commits-help@hadoop.apache.org