HADOOP-19415. [JDK17] Upgrade JUnit from 4 to 5 in hadoop-common Part7.

Author: slfan1989

hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/FileContextUtilBase.java

@@ -19,15 +19,15 @@
 
 import static org.apache.hadoop.fs.FileContextTestHelper.readFile;
 import static org.apache.hadoop.fs.FileContextTestHelper.writeFile;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.Assert.assertTrue;
 
 import java.util.Arrays;
 
 import org.apache.hadoop.test.GenericTestUtils;
 import org.apache.hadoop.util.StringUtils;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
 import org.slf4j.event.Level;
 
 /**
@@ -57,12 +57,12 @@ public abstract class FileContextUtilBase {
     }
   }
 
-  @BeforeEach
+  @Before
   public void setUp() throws Exception {
     fc.mkdir(fileContextTestHelper.getTestRootPath(fc), FileContext.DEFAULT_PERM, true);
   }
 
-  @AfterEach
+  @After
   public void tearDown() throws Exception {
     if (fc != null) {
       fc.delete(fileContextTestHelper.getTestRootPath(fc), true);
@@ -80,10 +80,10 @@ public void testFcCopy() throws Exception{
     fc.util().copy(file1, file2);
 
     // verify that newly copied file2 exists
-    assertTrue(fc.util().exists(file2), "Failed to copy file2  ");
+    assertTrue("Failed to copy file2  ", fc.util().exists(file2));
     // verify that file2 contains test string
-    assertTrue(Arrays.equals(ts.getBytes(),
-        readFile(fc,file2,ts.getBytes().length)), "Copied files does not match ");
+    assertTrue("Copied files does not match ",Arrays.equals(ts.getBytes(),
+        readFile(fc,file2,ts.getBytes().length)));
   }
 
   @Test
@@ -103,9 +103,9 @@ public void testRecursiveFcCopy() throws Exception {
     fc.util().copy(dir1, dir2);
 
     // verify that newly copied file2 exists
-    assertTrue(fc.util().exists(file2), "Failed to copy file2  ");
+    assertTrue("Failed to copy file2  ", fc.util().exists(file2));
     // verify that file2 contains test string
-    assertTrue(Arrays.equals(ts.getBytes(),
-        readFile(fc,file2,ts.getBytes().length)), "Copied files does not match ");
+    assertTrue("Copied files does not match ",Arrays.equals(ts.getBytes(),
+        readFile(fc,file2,ts.getBytes().length)));
   }
 }

hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/FileSystemContractBaseTest.java

@@ -31,12 +31,12 @@
 import org.apache.hadoop.security.AccessControlException;
 import org.apache.hadoop.util.StringUtils;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
 import static org.junit.Assume.assumeTrue;
 
-import org.junit.jupiter.api.AfterEach;
+import org.junit.After;
 import org.junit.Rule;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
 import org.junit.rules.Timeout;
 
 /**
@@ -72,7 +72,7 @@ protected int getGlobalTimeout() {
     return 30 * 1000;
   }
 
-  @AfterEach
+  @After
   public void tearDown() throws Exception {
     if (fs != null) {
       // some cases use this absolute path
@@ -195,7 +195,7 @@ public void testMkdirs() throws Exception {
     assertTrue(fs.mkdirs(testDir));
 
     assertTrue(fs.exists(testDir));
-    assertTrue(fs.isDirectory(testDir), "Should be a directory");
+    assertTrue("Should be a directory", fs.isDirectory(testDir));
     assertFalse(fs.isFile(testDir));
 
     Path parentDir = testDir.getParent();
@@ -365,8 +365,8 @@ public void testOverwrite() throws IOException {
 
     createFile(path);
 
-    assertTrue(fs.exists(path), "Exists");
-    assertEquals(data.length, fs.getFileStatus(path).getLen(), "Length");
+    assertTrue("Exists", fs.exists(path));
+    assertEquals("Length", data.length, fs.getFileStatus(path).getLen());
 
     try {
       fs.create(path, false).close();
@@ -379,27 +379,27 @@ public void testOverwrite() throws IOException {
     out.write(data, 0, data.length);
     out.close();
 
-    assertTrue(fs.exists(path), "Exists");
-    assertEquals(data.length, fs.getFileStatus(path).getLen(), "Length");
+    assertTrue("Exists", fs.exists(path));
+    assertEquals("Length", data.length, fs.getFileStatus(path).getLen());
 
   }
 
   @Test
   public void testWriteInNonExistentDirectory() throws IOException {
     Path path = path("testWriteInNonExistentDirectory/file");
-    assertFalse(fs.exists(path.getParent()), "Parent exists");
+    assertFalse("Parent exists", fs.exists(path.getParent()));
     createFile(path);
 
-    assertTrue(fs.exists(path), "Exists");
-    assertEquals(data.length, fs.getFileStatus(path).getLen(), "Length");
-    assertTrue(fs.exists(path.getParent()), "Parent exists");
+    assertTrue("Exists", fs.exists(path));
+    assertEquals("Length", data.length, fs.getFileStatus(path).getLen());
+    assertTrue("Parent exists", fs.exists(path.getParent()));
   }
 
   @Test
   public void testDeleteNonExistentFile() throws IOException {
     Path path = path("testDeleteNonExistentFile/file");
-    assertFalse(fs.exists(path), "Path exists: " + path);
-    assertFalse(fs.delete(path, true), "No deletion");
+    assertFalse("Path exists: " + path, fs.exists(path));
+    assertFalse("No deletion", fs.delete(path, true));
   }
 
   @Test
@@ -409,35 +409,35 @@ public void testDeleteRecursively() throws IOException {
     Path subdir = path("testDeleteRecursively/subdir");
 
     createFile(file);
-    assertTrue(fs.mkdirs(subdir), "Created subdir");
+    assertTrue("Created subdir", fs.mkdirs(subdir));
 
-    assertTrue(fs.exists(file), "File exists");
-    assertTrue(fs.exists(dir), "Dir exists");
-    assertTrue(fs.exists(subdir), "Subdir exists");
+    assertTrue("File exists", fs.exists(file));
+    assertTrue("Dir exists", fs.exists(dir));
+    assertTrue("Subdir exists", fs.exists(subdir));
 
     try {
       fs.delete(dir, false);
       fail("Should throw IOException.");
     } catch (IOException e) {
       // expected
     }
-    assertTrue(fs.exists(file), "File still exists");
-    assertTrue(fs.exists(dir), "Dir still exists");
-    assertTrue(fs.exists(subdir), "Subdir still exists");
+    assertTrue("File still exists", fs.exists(file));
+    assertTrue("Dir still exists", fs.exists(dir));
+    assertTrue("Subdir still exists", fs.exists(subdir));
 
-    assertTrue(fs.delete(dir, true), "Deleted");
-    assertFalse(fs.exists(file), "File doesn't exist");
-    assertFalse(fs.exists(dir), "Dir doesn't exist");
-    assertFalse(fs.exists(subdir), "Subdir doesn't exist");
+    assertTrue("Deleted", fs.delete(dir, true));
+    assertFalse("File doesn't exist", fs.exists(file));
+    assertFalse("Dir doesn't exist", fs.exists(dir));
+    assertFalse("Subdir doesn't exist", fs.exists(subdir));
   }
 
   @Test
   public void testDeleteEmptyDirectory() throws IOException {
     Path dir = path("testDeleteEmptyDirectory");
     assertTrue(fs.mkdirs(dir));
-    assertTrue(fs.exists(dir), "Dir exists");
-    assertTrue(fs.delete(dir, false), "Deleted");
-    assertFalse(fs.exists(dir), "Dir doesn't exist");
+    assertTrue("Dir exists", fs.exists(dir));
+    assertTrue("Deleted", fs.delete(dir, false));
+    assertFalse("Dir doesn't exist", fs.exists(dir));
   }
 
   @Test
@@ -516,14 +516,14 @@ public void testRenameDirectoryMoveToExistingDirectory() throws Exception {
     fs.mkdirs(dst.getParent());
     rename(src, dst, true, false, true);
 
-    assertFalse(
-       fs.exists(path(src + "/file1")), "Nested file1 exists");
-    assertFalse(
-       fs.exists(path(src + "/subdir/file2")), "Nested file2 exists");
-    assertTrue(
-       fs.exists(path(dst + "/file1")), "Renamed nested file1 exists");
-    assertTrue(
-       fs.exists(path(dst + "/subdir/file2")), "Renamed nested exists");
+    assertFalse("Nested file1 exists",
+        fs.exists(path(src + "/file1")));
+    assertFalse("Nested file2 exists",
+        fs.exists(path(src + "/subdir/file2")));
+    assertTrue("Renamed nested file1 exists",
+        fs.exists(path(dst + "/file1")));
+    assertTrue("Renamed nested exists",
+        fs.exists(path(dst + "/subdir/file2")));
   }
 
   @Test
@@ -548,16 +548,16 @@ public void testRenameDirectoryAsExistingDirectory() throws Exception {
     final Path dst = path("testRenameDirectoryAsExistingDirectoryNew/newdir");
     fs.mkdirs(dst);
     rename(src, dst, true, false, true);
-    assertTrue(
-       fs.exists(path(dst + "/dir")), "Destination changed");
-    assertFalse(
-       fs.exists(path(src + "/file1")), "Nested file1 exists");
-    assertFalse(
-       fs.exists(path(src + "/dir/subdir/file2")), "Nested file2 exists");
-    assertTrue(
-       fs.exists(path(dst + "/dir/file1")), "Renamed nested file1 exists");
-    assertTrue(
-       fs.exists(path(dst + "/dir/subdir/file2")), "Renamed nested exists");
+    assertTrue("Destination changed",
+        fs.exists(path(dst + "/dir")));
+    assertFalse("Nested file1 exists",
+        fs.exists(path(src + "/file1")));
+    assertFalse("Nested file2 exists",
+        fs.exists(path(src + "/dir/subdir/file2")));
+    assertTrue("Renamed nested file1 exists",
+        fs.exists(path(dst + "/dir/file1")));
+    assertTrue("Renamed nested exists",
+        fs.exists(path(dst + "/dir/subdir/file2")));
   }
 
   @Test
@@ -590,9 +590,9 @@ protected void createFile(Path path) throws IOException {
 
   protected void rename(Path src, Path dst, boolean renameSucceeded,
       boolean srcExists, boolean dstExists) throws IOException {
-    assertEquals(renameSucceeded, fs.rename(src, dst), "Rename result");
-    assertEquals(srcExists, fs.exists(src), "Source exists");
-    assertEquals(dstExists, fs.exists(dst), "Destination exists" + dst);
+    assertEquals("Rename result", renameSucceeded, fs.rename(src, dst));
+    assertEquals("Source exists", srcExists, fs.exists(src));
+    assertEquals("Destination exists" + dst, dstExists, fs.exists(dst));
   }
 
   /**
@@ -633,27 +633,27 @@ public void testFilesystemIsCaseSensitive() throws Exception {
     String mixedCaseFilename = "testFilesystemIsCaseSensitive";
     Path upper = path(mixedCaseFilename);
     Path lower = path(StringUtils.toLowerCase(mixedCaseFilename));
-    assertFalse(fs.exists(upper), "File exists" + upper);
-    assertFalse(fs.exists(lower), "File exists" + lower);
+    assertFalse("File exists" + upper, fs.exists(upper));
+    assertFalse("File exists" + lower, fs.exists(lower));
     FSDataOutputStream out = fs.create(upper);
     out.writeUTF("UPPER");
     out.close();
     FileStatus upperStatus = fs.getFileStatus(upper);
-    assertTrue(fs.exists(upper), "File does not exist" + upper);
+    assertTrue("File does not exist" + upper, fs.exists(upper));
     //verify the lower-case version of the filename doesn't exist
-    assertFalse(fs.exists(lower), "File exists" + lower);
+    assertFalse("File exists" + lower, fs.exists(lower));
     //now overwrite the lower case version of the filename with a
     //new version.
     out = fs.create(lower);
     out.writeUTF("l");
     out.close();
-    assertTrue(fs.exists(lower), "File does not exist" + lower);
+    assertTrue("File does not exist" + lower, fs.exists(lower));
     //verify the length of the upper file hasn't changed
     FileStatus newStatus = fs.getFileStatus(upper);
-    assertEquals(
-                upperStatus.getLen()
-,                  newStatus.getLen(), "Expected status:" + upperStatus
-                 + " actual status " + newStatus); }
+    assertEquals("Expected status:" + upperStatus
+                 + " actual status " + newStatus,
+                 upperStatus.getLen(),
+                 newStatus.getLen()); }
 
   /**
    * Asserts that a zero byte file has a status of file and not
@@ -693,7 +693,7 @@ public void testRootDirAlwaysExists() throws Exception {
     fs.getFileStatus(path("/"));
     //this catches overrides of the base exists() method that don't
     //use getFileStatus() as an existence probe
-    assertTrue(fs.exists(path("/")), "FileSystem.exists() fails for root");
+    assertTrue("FileSystem.exists() fails for root", fs.exists(path("/")));
   }
 
   /**
@@ -789,8 +789,8 @@ public void testMoveDirUnderParent() throws Throwable {
     Path parent = testdir.getParent();
     //the outcome here is ambiguous, so is not checked
     fs.rename(testdir, parent);
-    assertEquals(true, fs.exists(testdir), "Source exists: " + testdir);
-    assertEquals(true, fs.exists(parent), "Destination exists" + parent);
+    assertEquals("Source exists: " + testdir, true, fs.exists(testdir));
+    assertEquals("Destination exists" + parent, true, fs.exists(parent));
   }
 
   /**
@@ -855,9 +855,9 @@ private void assertListFilesFinds(Path dir, Path subdir) throws IOException {
         found = true;
       }
     }
-    assertTrue(
-              found, "Path " + subdir
-               + " not found in directory " + dir + ":" + builder);
+    assertTrue("Path " + subdir
+               + " not found in directory " + dir + ":" + builder,
+               found);
   }
 
   protected void assertListStatusFinds(Path dir, Path subdir)
@@ -871,9 +871,9 @@ protected void assertListStatusFinds(Path dir, Path subdir)
         found = true;
       }
     }
-    assertTrue(
-              found, "Path " + subdir
-               + " not found in directory " + dir + ":" + builder);
+    assertTrue("Path " + subdir
+               + " not found in directory " + dir + ":" + builder,
+               found);
   }
 
 
@@ -884,14 +884,14 @@ protected void assertListStatusFinds(Path dir, Path subdir)
    * @throws IOException IO problems during file operations
    */
   private void assertIsFile(Path filename) throws IOException {
-    assertTrue(fs.exists(filename), "Does not exist: " + filename);
+    assertTrue("Does not exist: " + filename, fs.exists(filename));
     FileStatus status = fs.getFileStatus(filename);
     String fileInfo = filename + "  " + status;
-    assertTrue(status.isFile(), "Not a file " + fileInfo);
-    assertFalse(
-               status.isSymlink(), "File claims to be a symlink " + fileInfo);
-    assertFalse(
-               status.isDirectory(), "File claims to be a directory " + fileInfo);
+    assertTrue("Not a file " + fileInfo, status.isFile());
+    assertFalse("File claims to be a symlink " + fileInfo,
+                status.isSymlink());
+    assertFalse("File claims to be a directory " + fileInfo,
+                status.isDirectory());
   }
 
   /**
@@ -918,8 +918,8 @@ private void assertIsFile(Path filename) throws IOException {
   protected void writeAndRead(Path path, byte[] src, int len,
                               boolean overwrite,
                               boolean delete) throws IOException {
-    assertTrue(
-              src.length >= len, "Not enough data in source array to write " + len + " bytes");
+    assertTrue("Not enough data in source array to write " + len + " bytes",
+               src.length >= len);
     fs.mkdirs(path.getParent());
 
     FSDataOutputStream out = fs.create(path, overwrite,
@@ -929,8 +929,8 @@ protected void writeAndRead(Path path, byte[] src, int len,
     out.write(src, 0, len);
     out.close();
 
-    assertTrue(fs.exists(path), "Exists");
-    assertEquals(len, fs.getFileStatus(path).getLen(), "Length");
+    assertTrue("Exists", fs.exists(path));
+    assertEquals("Length", len, fs.getFileStatus(path).getLen());
 
     FSDataInputStream in = fs.open(path);
     byte[] buf = new byte[len];
@@ -978,8 +978,8 @@ protected void writeAndRead(Path path, byte[] src, int len,
 
     if (delete) {
       boolean deleted = fs.delete(path, false);
-      assertTrue(deleted, "Deleted");
-      assertFalse(fs.exists(path), "No longer exists");
+      assertTrue("Deleted", deleted);
+      assertFalse("No longer exists", fs.exists(path));
     }
   }