YARN-11262. Upgrade JUnit from 4 to 5 in hadoop-yarn-server-resourcemanager Part4.

Author: slfan1989

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/ReservationSystemTestUtil.java

@@ -69,7 +69,6 @@
 import org.apache.hadoop.yarn.server.resourcemanager.security.NMTokenSecretManagerInRM;
 import org.apache.hadoop.yarn.server.resourcemanager.security.RMContainerTokenSecretManager;
 import org.apache.hadoop.yarn.util.resource.DefaultResourceCalculator;
-import org.junit.jupiter.api.Assertions;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
@@ -121,8 +120,7 @@ public static void validateReservationQueue(
     assertEquals(8192, plan.getTotalCapacity().getMemorySize());
     assertTrue(
         plan.getReservationAgent() instanceof AlignedPlannerWithGreedy);
-    Assertions
-        .assertTrue(plan.getSharingPolicy() instanceof CapacityOverTimePolicy);
+    assertTrue(plan.getSharingPolicy() instanceof CapacityOverTimePolicy);
   }
 
   public static void setupFSAllocationFile(String allocationFile) {

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/TestAppSchedulingInfo.java

@@ -18,6 +18,10 @@
 
 package org.apache.hadoop.yarn.server.resourcemanager.scheduler;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -36,8 +40,7 @@
 import org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FSLeafQueue;
 import org.apache.hadoop.yarn.server.resourcemanager.scheduler.placement.LocalityAppPlacementAllocator;
 import org.apache.hadoop.yarn.server.scheduler.SchedulerRequestKey;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class TestAppSchedulingInfo {
 
@@ -57,32 +60,32 @@ public void testBacklistChanged() {
 
     appSchedulingInfo.updatePlacesBlacklistedByApp(new ArrayList<String>(),
         new ArrayList<String>());
-    Assert.assertFalse(appSchedulingInfo.getAndResetBlacklistChanged());
+    assertFalse(appSchedulingInfo.getAndResetBlacklistChanged());
 
     ArrayList<String> blacklistAdditions = new ArrayList<String>();
     blacklistAdditions.add("node1");
     blacklistAdditions.add("node2");
     appSchedulingInfo.updatePlacesBlacklistedByApp(blacklistAdditions,
         new ArrayList<String>());
-    Assert.assertTrue(appSchedulingInfo.getAndResetBlacklistChanged());
+    assertTrue(appSchedulingInfo.getAndResetBlacklistChanged());
 
     blacklistAdditions.clear();
     blacklistAdditions.add("node1");
     appSchedulingInfo.updatePlacesBlacklistedByApp(blacklistAdditions,
         new ArrayList<String>());
-    Assert.assertFalse(appSchedulingInfo.getAndResetBlacklistChanged());
+    assertFalse(appSchedulingInfo.getAndResetBlacklistChanged());
 
     ArrayList<String> blacklistRemovals = new ArrayList<String>();
     blacklistRemovals.add("node1");
     appSchedulingInfo.updatePlacesBlacklistedByApp(new ArrayList<String>(),
         blacklistRemovals);
     appSchedulingInfo.updatePlacesBlacklistedByApp(new ArrayList<String>(),
         blacklistRemovals);
-    Assert.assertTrue(appSchedulingInfo.getAndResetBlacklistChanged());
+    assertTrue(appSchedulingInfo.getAndResetBlacklistChanged());
 
     appSchedulingInfo.updatePlacesBlacklistedByApp(new ArrayList<String>(),
         blacklistRemovals);
-    Assert.assertFalse(appSchedulingInfo.getAndResetBlacklistChanged());
+    assertFalse(appSchedulingInfo.getAndResetBlacklistChanged());
   }
 
   @Test
@@ -96,23 +99,23 @@ public void testSchedulerRequestKeyOrdering() {
     ts.add(TestUtils.toSchedulerKey(Priority.newInstance(2), 6));
     Iterator<SchedulerRequestKey> iter = ts.iterator();
     SchedulerRequestKey sk = iter.next();
-    Assert.assertEquals(0, sk.getPriority().getPriority());
-    Assert.assertEquals(3, sk.getAllocationRequestId());
+    assertEquals(0, sk.getPriority().getPriority());
+    assertEquals(3, sk.getAllocationRequestId());
     sk = iter.next();
-    Assert.assertEquals(0, sk.getPriority().getPriority());
-    Assert.assertEquals(4, sk.getAllocationRequestId());
+    assertEquals(0, sk.getPriority().getPriority());
+    assertEquals(4, sk.getAllocationRequestId());
     sk = iter.next();
-    Assert.assertEquals(1, sk.getPriority().getPriority());
-    Assert.assertEquals(1, sk.getAllocationRequestId());
+    assertEquals(1, sk.getPriority().getPriority());
+    assertEquals(1, sk.getAllocationRequestId());
     sk = iter.next();
-    Assert.assertEquals(1, sk.getPriority().getPriority());
-    Assert.assertEquals(2, sk.getAllocationRequestId());
+    assertEquals(1, sk.getPriority().getPriority());
+    assertEquals(2, sk.getAllocationRequestId());
     sk = iter.next();
-    Assert.assertEquals(2, sk.getPriority().getPriority());
-    Assert.assertEquals(5, sk.getAllocationRequestId());
+    assertEquals(2, sk.getPriority().getPriority());
+    assertEquals(5, sk.getAllocationRequestId());
     sk = iter.next();
-    Assert.assertEquals(2, sk.getPriority().getPriority());
-    Assert.assertEquals(6, sk.getAllocationRequestId());
+    assertEquals(2, sk.getPriority().getPriority());
+    assertEquals(6, sk.getAllocationRequestId());
   }
 
   @Test
@@ -128,7 +131,7 @@ public void testSchedulerKeyAccounting() {
     AppSchedulingInfo  info = new AppSchedulingInfo(
         appAttemptId, "test", queue, mock(ActiveUsersManager.class), 0,
         new ResourceUsage(), new HashMap<>(), rmContext, false);
-    Assert.assertEquals(0, info.getSchedulerKeys().size());
+    assertEquals(0, info.getSchedulerKeys().size());
 
     Priority pri1 = Priority.newInstance(1);
     ResourceRequest req1 = ResourceRequest.newInstance(pri1,
@@ -142,16 +145,16 @@ public void testSchedulerKeyAccounting() {
     info.updateResourceRequests(reqs, false);
     ArrayList<SchedulerRequestKey> keys =
         new ArrayList<>(info.getSchedulerKeys());
-    Assert.assertEquals(2, keys.size());
-    Assert.assertEquals(SchedulerRequestKey.create(req1), keys.get(0));
-    Assert.assertEquals(SchedulerRequestKey.create(req2), keys.get(1));
+    assertEquals(2, keys.size());
+    assertEquals(SchedulerRequestKey.create(req1), keys.get(0));
+    assertEquals(SchedulerRequestKey.create(req2), keys.get(1));
 
     // iterate to verify no ConcurrentModificationException
     for (SchedulerRequestKey schedulerKey : info.getSchedulerKeys()) {
       info.allocate(NodeType.OFF_SWITCH, null, schedulerKey, null);
     }
-    Assert.assertEquals(1, info.getSchedulerKeys().size());
-    Assert.assertEquals(SchedulerRequestKey.create(req2),
+    assertEquals(1, info.getSchedulerKeys().size());
+    assertEquals(SchedulerRequestKey.create(req2),
         info.getSchedulerKeys().iterator().next());
 
     req2 = ResourceRequest.newInstance(pri2,
@@ -161,22 +164,22 @@ public void testSchedulerKeyAccounting() {
     info.updateResourceRequests(reqs, false);
     info.allocate(NodeType.OFF_SWITCH, null, SchedulerRequestKey.create(req2),
         null);
-    Assert.assertEquals(0, info.getSchedulerKeys().size());
+    assertEquals(0, info.getSchedulerKeys().size());
 
     req1 = ResourceRequest.newInstance(pri1,
         ResourceRequest.ANY, Resource.newInstance(1024, 1), 5);
     reqs.clear();
     reqs.add(req1);
     info.updateResourceRequests(reqs, false);
-    Assert.assertEquals(1, info.getSchedulerKeys().size());
-    Assert.assertEquals(SchedulerRequestKey.create(req1),
+    assertEquals(1, info.getSchedulerKeys().size());
+    assertEquals(SchedulerRequestKey.create(req1),
         info.getSchedulerKeys().iterator().next());
     req1 = ResourceRequest.newInstance(pri1,
         ResourceRequest.ANY, Resource.newInstance(1024, 1), 0);
     reqs.clear();
     reqs.add(req1);
     info.updateResourceRequests(reqs, false);
-    Assert.assertEquals(0, info.getSchedulerKeys().size());
+    assertEquals(0, info.getSchedulerKeys().size());
   }
 
   @Test
@@ -193,17 +196,17 @@ public void testApplicationPlacementType() {
     AppSchedulingInfo info = new AppSchedulingInfo(appAttemptId, "test", queue,
         mock(ActiveUsersManager.class), 0, new ResourceUsage(), new HashMap<>(),
         rmContext, false);
-    Assert.assertEquals(info.getApplicationSchedulingEnvs(), new HashMap<>());
+    assertEquals(info.getApplicationSchedulingEnvs(), new HashMap<>());
     // This should return null as nothing is set in the conf.
-    Assert.assertNull(info.getDefaultResourceRequestAppPlacementType());
+    assertNull(info.getDefaultResourceRequestAppPlacementType());
     conf = new Configuration();
     conf.set(YarnConfiguration.APPLICATION_PLACEMENT_TYPE_CLASS,
         DEFAULT_APPLICATION_PLACEMENT_TYPE_CLASS);
     when(rmContext.getYarnConfiguration()).thenReturn(conf);
     info = new AppSchedulingInfo(appAttemptId, "test", queue,
         mock(ActiveUsersManager.class), 0, new ResourceUsage(), new HashMap<>(),
         rmContext, false);
-    Assert.assertEquals(info.getDefaultResourceRequestAppPlacementType(),
+    assertEquals(info.getDefaultResourceRequestAppPlacementType(),
         DEFAULT_APPLICATION_PLACEMENT_TYPE_CLASS);
   }
 
@@ -223,7 +226,7 @@ public void testApplicationPlacementTypeNotConfigured() {
         mock(ActiveUsersManager.class), 0, new ResourceUsage(),
         applicationSchedulingEnvs, rmContext, false);
     // This should be set from applicationSchedulingEnvs
-    Assert.assertEquals(info.getDefaultResourceRequestAppPlacementType(),
+    assertEquals(info.getDefaultResourceRequestAppPlacementType(),
         LocalityAppPlacementAllocator.class.getName());
   }
 }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/TestClusterNodeTracker.java

@@ -30,11 +30,11 @@
 import org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FSSchedulerNode;
 import org.apache.hadoop.yarn.util.resource.ResourceUtils;
 
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Test class to verify ClusterNodeTracker. Using FSSchedulerNode without
@@ -44,13 +44,13 @@ public class TestClusterNodeTracker {
   private ClusterNodeTracker<FSSchedulerNode> nodeTracker;
   private ClusterMetrics metrics;
 
-  @Before
+  @BeforeEach
   public void setup() {
     metrics = ClusterMetrics.getMetrics();
     nodeTracker = new ClusterNodeTracker<>();
   }
 
-  @After
+  @AfterEach
   public void teardown() {
     ClusterMetrics.destroy();
   }
@@ -67,33 +67,33 @@ private void addEight4x4Nodes() {
   @Test
   public void testGetNodeCount() {
     addEight4x4Nodes();
-    assertEquals("Incorrect number of nodes in the cluster",
-        8, nodeTracker.nodeCount());
+    assertEquals(8, nodeTracker.nodeCount(),
+        "Incorrect number of nodes in the cluster");
 
-    assertEquals("Incorrect number of nodes in each rack",
-        4, nodeTracker.nodeCount("rack0"));
+    assertEquals(4, nodeTracker.nodeCount("rack0"),
+        "Incorrect number of nodes in each rack");
   }
 
   @Test
   public void testIncrCapability() {
     addEight4x4Nodes();
-    assertEquals("Cluster Capability Memory incorrect",
-        metrics.getCapabilityMB(), (4096 * 8));
-    assertEquals("Cluster Capability Vcores incorrect",
-        metrics.getCapabilityVirtualCores(), 4 * 8);
+    assertEquals(metrics.getCapabilityMB(), (4096 * 8),
+        "Cluster Capability Memory incorrect");
+    assertEquals(metrics.getCapabilityVirtualCores(), 4 * 8,
+        "Cluster Capability Vcores incorrect");
   }
 
   @Test
   public void testGetNodesForResourceName() throws Exception {
     addEight4x4Nodes();
-    assertEquals("Incorrect number of nodes matching ANY",
-        8, nodeTracker.getNodesByResourceName(ResourceRequest.ANY).size());
+    assertEquals(8, nodeTracker.getNodesByResourceName(ResourceRequest.ANY).size(),
+        "Incorrect number of nodes matching ANY");
 
-    assertEquals("Incorrect number of nodes matching rack",
-        4, nodeTracker.getNodesByResourceName("rack0").size());
+    assertEquals(4, nodeTracker.getNodesByResourceName("rack0").size(),
+        "Incorrect number of nodes matching rack");
 
-    assertEquals("Incorrect number of nodes matching node",
-        1, nodeTracker.getNodesByResourceName("host0").size());
+    assertEquals(1, nodeTracker.getNodesByResourceName("host0").size(),
+        "Incorrect number of nodes matching node");
   }
 
   @Test
@@ -113,8 +113,9 @@ public void testMaxAllowedAllocation() {
 
     Resource result = nodeTracker.getMaxAllowedAllocation();
 
-    assertEquals("With no nodes added, the ClusterNodeTracker did not return "
-        + "the configured max allocation", maximum, result);
+    assertEquals(maximum, result,
+        "With no nodes added, the ClusterNodeTracker did not return "
+        + "the configured max allocation");
 
     List<RMNode> smallNodes =
         MockNodes.newNodes(1, 1, Resource.newInstance(1024, 2,
@@ -133,72 +134,70 @@ public void testMaxAllowedAllocation() {
 
     result = nodeTracker.getMaxAllowedAllocation();
 
-    assertEquals("With a single node added, the ClusterNodeTracker did not "
-        + "return that node's resources as the maximum allocation",
-        mediumNodes.get(0).getTotalCapability(), result);
+    assertEquals(mediumNodes.get(0).getTotalCapability(), result,
+        "With a single node added, the ClusterNodeTracker did not "
+        + "return that node's resources as the maximum allocation");
 
     nodeTracker.addNode(smallNode);
 
     result = nodeTracker.getMaxAllowedAllocation();
 
-    assertEquals("With two nodes added, the ClusterNodeTracker did not "
+    assertEquals(Resource.newInstance(4096, 2, Collections.singletonMap("test1", 4L)),
+        result, "With two nodes added, the ClusterNodeTracker did not "
         + "return a the maximum allocation that was the max of their aggregate "
-        + "resources",
-        Resource.newInstance(4096, 2, Collections.singletonMap("test1", 4L)),
-        result);
+        + "resources");
 
     nodeTracker.removeNode(smallNode.getNodeID());
 
     result = nodeTracker.getMaxAllowedAllocation();
 
-    assertEquals("After removing a node, the ClusterNodeTracker did not "
-        + "recalculate the adjusted maximum allocation correctly",
-        mediumNodes.get(0).getTotalCapability(), result);
+    assertEquals(mediumNodes.get(0).getTotalCapability(), result,
+        "After removing a node, the ClusterNodeTracker did not "
+        + "recalculate the adjusted maximum allocation correctly");
 
     nodeTracker.addNode(largeNode);
 
     result = nodeTracker.getMaxAllowedAllocation();
 
-    assertEquals("With two nodes added, the ClusterNodeTracker did not "
+    assertEquals(Resource.newInstance(10240, 4, Collections.singletonMap("test1", 2L)),
+        result, "With two nodes added, the ClusterNodeTracker did not "
         + "return a the maximum allocation that was the max of their aggregate "
-        + "resources",
-        Resource.newInstance(10240, 4, Collections.singletonMap("test1", 2L)),
-        result);
+        + "resources");
 
     nodeTracker.removeNode(largeNode.getNodeID());
 
     result = nodeTracker.getMaxAllowedAllocation();
 
-    assertEquals("After removing a node, the ClusterNodeTracker did not "
-        + "recalculate the adjusted maximum allocation correctly",
-        mediumNodes.get(0).getTotalCapability(), result);
+    assertEquals(mediumNodes.get(0).getTotalCapability(), result,
+        "After removing a node, the ClusterNodeTracker did not "
+        + "recalculate the adjusted maximum allocation correctly");
 
     nodeTracker.removeNode(mediumNode.getNodeID());
 
     result = nodeTracker.getMaxAllowedAllocation();
 
-    assertEquals("After removing all nodes, the ClusterNodeTracker did not "
-        + "return the configured maximum allocation", maximum, result);
+    assertEquals(maximum, result,
+        "After removing all nodes, the ClusterNodeTracker did not "
+        + "return the configured maximum allocation");
 
     nodeTracker.addNode(smallNode);
     nodeTracker.addNode(mediumNode);
     nodeTracker.addNode(largeNode);
 
     result = nodeTracker.getMaxAllowedAllocation();
 
-    assertEquals("With three nodes added, the ClusterNodeTracker did not "
+    assertEquals(Resource.newInstance(10240, 4, Collections.singletonMap("test1", 4L)),
+        result, "With three nodes added, the ClusterNodeTracker did not "
         + "return a the maximum allocation that was the max of their aggregate "
-        + "resources",
-        Resource.newInstance(10240, 4, Collections.singletonMap("test1", 4L)),
-        result);
+        + "resources");
 
     nodeTracker.removeNode(smallNode.getNodeID());
     nodeTracker.removeNode(mediumNode.getNodeID());
     nodeTracker.removeNode(largeNode.getNodeID());
 
     result = nodeTracker.getMaxAllowedAllocation();
 
-    assertEquals("After removing all nodes, the ClusterNodeTracker did not "
-        + "return the configured maximum allocation", maximum, result);
+    assertEquals(maximum, result, "After removing all nodes, the ClusterNodeTracker did not "
+        + "return the configured maximum allocation");
   }
 }