This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-io.git
The following commit(s) were added to refs/heads/master by this push:
new 86fdbb2 Simplify Assertions (#234)
86fdbb2 is described below
commit 86fdbb2a420064c0c6b33bb2466ab8bd4df080a3
Author: Arturo Bernal <arturobern...@gmail.com>
AuthorDate: Sat May 22 14:59:53 2021 +0200
Simplify Assertions (#234)
---
.../apache/commons/io/ByteOrderMarkTestCase.java | 29 +--
.../java/org/apache/commons/io/CopyUtilsTest.java | 19 +-
.../commons/io/FileCleaningTrackerTestCase.java | 37 +--
.../org/apache/commons/io/FileUtilsTestCase.java | 48 ++--
.../apache/commons/io/FilenameUtilsTestCase.java | 265 +++++++++++----------
.../commons/io/IOIndexedExceptionTestCase.java | 3 +-
.../org/apache/commons/io/IOUtilsCopyTestCase.java | 22 +-
.../org/apache/commons/io/IOUtilsTestCase.java | 2 +-
.../apache/commons/io/IOUtilsWriteTestCase.java | 34 +--
.../apache/commons/io/LineIteratorTestCase.java | 2 +-
.../io/comparator/ExtensionFileComparatorTest.java | 7 +-
.../io/comparator/NameFileComparatorTest.java | 7 +-
.../io/comparator/PathFileComparatorTest.java | 7 +-
.../ConditionalFileFilterAbstractTestCase.java | 3 +-
.../commons/io/filefilter/FileFilterTestCase.java | 26 +-
.../io/input/CharSequenceInputStreamTest.java | 4 +-
.../io/input/ObservableInputStreamTest.java | 5 +-
.../io/input/RandomAccessFileInputStreamTest.java | 8 +-
.../io/input/SwappedDataInputStreamTest.java | 8 +-
.../io/output/DeferredFileOutputStreamTest.java | 11 +-
.../commons/io/output/XmlStreamWriterTest.java | 4 +-
.../java/org/apache/commons/io/test/TestUtils.java | 5 +-
22 files changed, 282 insertions(+), 274 deletions(-)
diff --git a/src/test/java/org/apache/commons/io/ByteOrderMarkTestCase.java
b/src/test/java/org/apache/commons/io/ByteOrderMarkTestCase.java
index 0d4ee22..6232c4b 100644
--- a/src/test/java/org/apache/commons/io/ByteOrderMarkTestCase.java
+++ b/src/test/java/org/apache/commons/io/ByteOrderMarkTestCase.java
@@ -17,8 +17,9 @@
package org.apache.commons.io;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -79,26 +80,26 @@ public class ByteOrderMarkTestCase {
/** Test {@link ByteOrderMark#getBytes()} */
@Test
public void getBytes() {
- assertTrue(Arrays.equals(TEST_BOM_1.getBytes(), new byte[] {(byte)1}),
"test1 bytes");
+ assertArrayEquals(TEST_BOM_1.getBytes(), new byte[]{(byte) 1}, "test1
bytes");
TEST_BOM_1.getBytes()[0] = 2;
- assertTrue(Arrays.equals(TEST_BOM_1.getBytes(), new byte[] {(byte)1}),
"test1 bytes");
- assertTrue(Arrays.equals(TEST_BOM_2.getBytes(), new byte[] {(byte)1,
(byte)2}), "test1 bytes");
- assertTrue(Arrays.equals(TEST_BOM_3.getBytes(), new byte[] {(byte)1,
(byte)2, (byte)3}), "test1 bytes");
+ assertArrayEquals(TEST_BOM_1.getBytes(), new byte[]{(byte) 1}, "test1
bytes");
+ assertArrayEquals(TEST_BOM_2.getBytes(), new byte[]{(byte) 1, (byte)
2}, "test1 bytes");
+ assertArrayEquals(TEST_BOM_3.getBytes(), new byte[]{(byte) 1, (byte)
2, (byte) 3}, "test1 bytes");
}
/** Test {@link ByteOrderMark#equals(Object)} */
@SuppressWarnings("EqualsWithItself")
@Test
public void testEquals() {
- assertTrue(TEST_BOM_1.equals(TEST_BOM_1), "test1 equals");
- assertTrue(TEST_BOM_2.equals(TEST_BOM_2), "test2 equals");
- assertTrue(TEST_BOM_3.equals(TEST_BOM_3), "test3 equals");
-
- assertFalse(TEST_BOM_1.equals(new Object()), "Object not equal");
- assertFalse(TEST_BOM_1.equals(new ByteOrderMark("1a", 2)), "test1-1
not equal");
- assertFalse(TEST_BOM_1.equals(new ByteOrderMark("1b", 1, 2)), "test1-2
not test2");
- assertFalse(TEST_BOM_2.equals(new ByteOrderMark("2", 1, 1)), "test2
not equal");
- assertFalse(TEST_BOM_3.equals(new ByteOrderMark("3", 1, 2, 4)), "test3
not equal");
+ assertEquals(TEST_BOM_1, TEST_BOM_1, "test1 equals");
+ assertEquals(TEST_BOM_2, TEST_BOM_2, "test2 equals");
+ assertEquals(TEST_BOM_3, TEST_BOM_3, "test3 equals");
+
+ assertNotEquals(TEST_BOM_1, new Object(), "Object not equal");
+ assertNotEquals(TEST_BOM_1, new ByteOrderMark("1a", 2), "test1-1 not
equal");
+ assertNotEquals(TEST_BOM_1, new ByteOrderMark("1b", 1, 2), "test1-2
not test2");
+ assertNotEquals(TEST_BOM_2, new ByteOrderMark("2", 1, 1), "test2 not
equal");
+ assertNotEquals(TEST_BOM_3, new ByteOrderMark("3", 1, 2, 4), "test3
not equal");
}
/** Test {@link ByteOrderMark#hashCode()} */
diff --git a/src/test/java/org/apache/commons/io/CopyUtilsTest.java
b/src/test/java/org/apache/commons/io/CopyUtilsTest.java
index 708765e..623bc06 100644
--- a/src/test/java/org/apache/commons/io/CopyUtilsTest.java
+++ b/src/test/java/org/apache/commons/io/CopyUtilsTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.io;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
@@ -26,7 +26,6 @@ import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.io.test.TestUtils;
@@ -72,7 +71,7 @@ public class CopyUtilsTest {
CopyUtils.copy(inData, out);
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -85,7 +84,7 @@ public class CopyUtilsTest {
writer.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -110,7 +109,7 @@ public class CopyUtilsTest {
assertEquals(0, in.available(), "Not all bytes were read");
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
assertEquals(inData.length, count);
}
@@ -129,7 +128,7 @@ public class CopyUtilsTest {
assertEquals(0, in.available(), "Not all bytes were read");
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -160,7 +159,7 @@ public class CopyUtilsTest {
// Note: rely on the method to flush
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
@@ -178,7 +177,7 @@ public class CopyUtilsTest {
writer.flush();
assertEquals(inData.length, count, "The number of characters returned
by copy is wrong");
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -197,7 +196,7 @@ public class CopyUtilsTest {
// note: we don't flush here; this IOUtils method does it for us
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -212,7 +211,7 @@ public class CopyUtilsTest {
writer.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
} // CopyUtilsTest
diff --git
a/src/test/java/org/apache/commons/io/FileCleaningTrackerTestCase.java
b/src/test/java/org/apache/commons/io/FileCleaningTrackerTestCase.java
index f6d5a6f..7574623 100644
--- a/src/test/java/org/apache/commons/io/FileCleaningTrackerTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileCleaningTrackerTestCase.java
@@ -18,6 +18,7 @@ package org.apache.commons.io;
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.junit.jupiter.api.Assertions.fail;
@@ -105,7 +106,7 @@ public class FileCleaningTrackerTestCase {
pauseForDeleteToComplete(new File(path));
assertEquals(0, theInstance.getTrackCount());
- assertEquals(false, new File(path).exists(), showFailures());
+ assertFalse(new File(path).exists(), showFailures());
}
@Test
@@ -172,8 +173,8 @@ public class FileCleaningTrackerTestCase {
pauseForDeleteToComplete(testFile.getParentFile());
assertEquals(0, theInstance.getTrackCount());
- assertEquals(false, new File(testFile.getPath()).exists(),
showFailures());
- assertEquals(false, testFile.getParentFile().exists(), showFailures());
+ assertFalse(new File(testFile.getPath()).exists(), showFailures());
+ assertFalse(testFile.getParentFile().exists(), showFailures());
}
@Test
@@ -209,13 +210,13 @@ public class FileCleaningTrackerTestCase {
assertFalse(theInstance.exitWhenFinished);
theInstance.exitWhenFinished();
assertTrue(theInstance.exitWhenFinished);
- assertEquals(null, theInstance.reaper);
+ assertNull(theInstance.reaper);
waitUntilTrackCount();
assertEquals(0, theInstance.getTrackCount());
assertTrue(theInstance.exitWhenFinished);
- assertEquals(null, theInstance.reaper);
+ assertNull(theInstance.reaper);
}
@Test
@@ -223,7 +224,7 @@ public class FileCleaningTrackerTestCase {
assertFalse(theInstance.exitWhenFinished);
theInstance.exitWhenFinished();
assertTrue(theInstance.exitWhenFinished);
- assertEquals(null, theInstance.reaper);
+ assertNull(theInstance.reaper);
final String path = testFile.getPath();
final Object marker = new Object();
@@ -234,27 +235,27 @@ public class FileCleaningTrackerTestCase {
// expected
}
assertTrue(theInstance.exitWhenFinished);
- assertEquals(null, theInstance.reaper);
+ assertNull(theInstance.reaper);
}
@Test
public void testFileCleanerExitWhenFinished1() throws Exception {
final String path = testFile.getPath();
- assertEquals(false, testFile.exists(), "1-testFile exists: " +
testFile);
+ assertFalse(testFile.exists(), "1-testFile exists: " + testFile);
RandomAccessFile r = new RandomAccessFile(testFile, "rw");
- assertEquals(true, testFile.exists(), "2-testFile exists");
+ assertTrue(testFile.exists(), "2-testFile exists");
assertEquals(0, theInstance.getTrackCount(), "3-Track Count");
theInstance.track(path, r);
assertEquals(1, theInstance.getTrackCount(), "4-Track Count");
- assertEquals(false, theInstance.exitWhenFinished,
"5-exitWhenFinished");
- assertEquals(true, theInstance.reaper.isAlive(), "6-reaper.isAlive");
+ assertFalse(theInstance.exitWhenFinished, "5-exitWhenFinished");
+ assertTrue(theInstance.reaper.isAlive(), "6-reaper.isAlive");
- assertEquals(false, theInstance.exitWhenFinished,
"7-exitWhenFinished");
+ assertFalse(theInstance.exitWhenFinished, "7-exitWhenFinished");
theInstance.exitWhenFinished();
- assertEquals(true, theInstance.exitWhenFinished, "8-exitWhenFinished");
- assertEquals(true, theInstance.reaper.isAlive(), "9-reaper.isAlive");
+ assertTrue(theInstance.exitWhenFinished, "8-exitWhenFinished");
+ assertTrue(theInstance.reaper.isAlive(), "9-reaper.isAlive");
r.close();
testFile = null;
@@ -264,9 +265,9 @@ public class FileCleaningTrackerTestCase {
pauseForDeleteToComplete(new File(path));
assertEquals(0, theInstance.getTrackCount(), "10-Track Count");
- assertEquals(false, new File(path).exists(), "11-testFile exists " +
showFailures());
- assertEquals(true, theInstance.exitWhenFinished,
"12-exitWhenFinished");
- assertEquals(false, theInstance.reaper.isAlive(), "13-reaper.isAlive");
+ assertFalse(new File(path).exists(), "11-testFile exists " +
showFailures());
+ assertTrue(theInstance.exitWhenFinished, "12-exitWhenFinished");
+ assertFalse(theInstance.reaper.isAlive(), "13-reaper.isAlive");
}
@Test
@@ -291,7 +292,7 @@ public class FileCleaningTrackerTestCase {
pauseForDeleteToComplete(new File(path));
assertEquals(0, theInstance.getTrackCount());
- assertEquals(false, new File(path).exists(), showFailures());
+ assertFalse(new File(path).exists(), showFailures());
assertFalse(theInstance.exitWhenFinished);
assertTrue(theInstance.reaper.isAlive());
diff --git a/src/test/java/org/apache/commons/io/FileUtilsTestCase.java
b/src/test/java/org/apache/commons/io/FileUtilsTestCase.java
index 59b6462..339241c 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsTestCase.java
@@ -1402,7 +1402,7 @@ public class FileUtilsTestCase {
destination.createNewFile();
assertTrue(destination.exists(), "Copy1.txt doesn't exist to delete");
FileUtils.forceDelete(destination);
- assertTrue(!destination.exists(), "Check No Exist");
+ assertFalse(destination.exists(), "Check No Exist");
}
@Test
@@ -1411,13 +1411,13 @@ public class FileUtilsTestCase {
destination.createNewFile();
assertTrue(destination.exists(), "Copy2.txt doesn't exist to delete");
FileUtils.forceDelete(destination);
- assertTrue(!destination.exists(), "Check No Exist");
+ assertFalse(destination.exists(), "Check No Exist");
}
@Test
public void testForceDeleteAFile3() throws Exception {
final File destination = new File(temporaryFolder, "no_such_file");
- assertTrue(!destination.exists(), "Check No Exist");
+ assertFalse(destination.exists(), "Check No Exist");
try {
FileUtils.forceDelete(destination);
fail("Should generate FileNotFoundException");
@@ -1448,7 +1448,7 @@ public class FileUtilsTestCase {
assertFalse(destination.canWrite());
assertTrue(destination.exists(), "File doesn't exist to delete");
FileUtils.forceDelete(destination);
- assertTrue(!destination.exists(), "Check deletion");
+ assertFalse(destination.exists(), "Check deletion");
}
@Test
@@ -2038,7 +2038,7 @@ public class FileUtilsTestCase {
// Check results
assertTrue(destination.exists(), "Check Exist");
- assertTrue(!src.exists(), "Original deleted");
+ assertFalse(src.exists(), "Original deleted");
final File movedDir = new File(destination, testDir.getName());
final File movedFile = new File(movedDir, testFile.getName());
assertTrue(movedDir.exists(), "Check dir moved");
@@ -2106,7 +2106,7 @@ public class FileUtilsTestCase {
// Check results
assertTrue(destination.exists(), "Check Exist");
- assertTrue(!src.exists(), "Original deleted");
+ assertFalse(src.exists(), "Original deleted");
final File movedDir = new File(destination, testDir.getName());
final File movedFile = new File(movedDir, testFile.getName());
assertTrue(movedDir.exists(), "Check dir moved");
@@ -2140,7 +2140,7 @@ public class FileUtilsTestCase {
// Check results
assertTrue(destDir.exists(), "Check Exist after");
- assertTrue(!src.exists(), "Original deleted");
+ assertFalse(src.exists(), "Original deleted");
final File movedDir = new File(destDir, src.getName());
final File movedChildDir = new File(movedDir, testChildDir.getName());
final File movedFile = new File(movedChildDir, testFile.getName());
@@ -2204,7 +2204,7 @@ public class FileUtilsTestCase {
};
FileUtils.moveFile(src, destination);
assertTrue(destination.exists(), "Check Exist");
- assertTrue(!src.exists(), "Original deleted");
+ assertFalse(src.exists(), "Original deleted");
}
@Test
@@ -2229,7 +2229,7 @@ public class FileUtilsTestCase {
};
assertThrows(IOException.class, () -> FileUtils.moveFile(src,
destination));
// expected
- assertTrue(!destination.exists(), "Check Rollback");
+ assertFalse(destination.exists(), "Check Rollback");
assertTrue(src.exists(), "Original exists");
}
@@ -2253,7 +2253,7 @@ public class FileUtilsTestCase {
FileUtils.moveFile(src, destination,
StandardCopyOption.COPY_ATTRIBUTES);
assertTrue(destination.exists(), "Check Exist");
- assertTrue(!src.exists(), "Original deleted");
+ assertFalse(src.exists(), "Original deleted");
final long destLastMod = getLastModifiedMillis(destination);
final long delta = destLastMod - expected;
@@ -2283,7 +2283,7 @@ public class FileUtilsTestCase {
FileUtils.moveFile(src, destination, PathUtils.EMPTY_COPY_OPTIONS);
assertTrue(destination.exists(), "Check Exist");
- assertTrue(!src.exists(), "Original deleted");
+ assertFalse(src.exists(), "Original deleted");
// On Windows, the last modified time is copied by default.
if (!SystemUtils.IS_OS_WINDOWS) {
@@ -2345,7 +2345,7 @@ public class FileUtilsTestCase {
FileUtils.moveFile(testFile1, destination);
assertTrue(destination.exists(), "Check Exist");
- assertTrue(!testFile1.exists(), "Original deleted");
+ assertFalse(testFile1.exists(), "Original deleted");
}
@Test
@@ -2357,7 +2357,7 @@ public class FileUtilsTestCase {
FileUtils.moveFileToDirectory(testFile1, destDir, true);
assertTrue(movedFile.exists(), "Check Exist after");
- assertTrue(!testFile1.exists(), "Original deleted");
+ assertFalse(testFile1.exists(), "Original deleted");
}
@Test
@@ -2683,8 +2683,8 @@ public class FileUtilsTestCase {
@Test
public void testToFile3() throws Exception {
- assertEquals(null, FileUtils.toFile(null));
- assertEquals(null, FileUtils.toFile(new
URL("http://jakarta.apache.org";)));
+ assertNull(FileUtils.toFile(null));
+ assertNull(FileUtils.toFile(new URL("http://jakarta.apache.org";)));
}
@Test
@@ -2711,8 +2711,8 @@ public class FileUtilsTestCase {
final File[] files = FileUtils.toFiles(urls);
assertEquals(urls.length, files.length);
- assertEquals(true, files[0].toString().contains("file1.txt"), "File: "
+ files[0]);
- assertEquals(true, files[1].toString().contains("file2.txt"), "File: "
+ files[1]);
+ assertTrue(files[0].toString().contains("file1.txt"), "File: " +
files[0]);
+ assertTrue(files[1].toString().contains("file2.txt"), "File: " +
files[1]);
}
@Test
@@ -2724,8 +2724,8 @@ public class FileUtilsTestCase {
final File[] files = FileUtils.toFiles(urls);
assertEquals(urls.length, files.length);
- assertEquals(true, files[0].toString().contains("file1.txt"), "File: "
+ files[0]);
- assertEquals(null, files[1], "File: " + files[1]);
+ assertTrue(files[0].toString().contains("file1.txt"), "File: " +
files[0]);
+ assertNull(files[1], "File: " + files[1]);
}
@Test
@@ -2770,7 +2770,7 @@ public class FileUtilsTestCase {
if (file.exists()) {
file.delete();
}
- assertTrue(!file.exists(), "Bad test: test file still exists");
+ assertFalse(file.exists(), "Bad test: test file still exists");
FileUtils.touch(file);
assertTrue(file.exists(), "FileUtils.touch() created file");
final FileOutputStream out = new FileOutputStream(file);
@@ -2780,15 +2780,15 @@ public class FileUtilsTestCase {
assertEquals(1, file.length(), "Wrote one byte to file");
final long y2k = new GregorianCalendar(2000, 0, 1).getTime().getTime();
final boolean res = setLastModifiedMillis(file, y2k); // 0L fails on
Win98
- assertEquals(true, res, "Bad test: set lastModified failed");
+ assertTrue(res, "Bad test: set lastModified failed");
assertEquals(y2k, getLastModifiedMillis(file), "Bad test: set
lastModified set incorrect value");
final long nowMillis = System.currentTimeMillis();
FileUtils.touch(file);
assertEquals(1, file.length(), "FileUtils.touch() didn't empty the
file.");
- assertEquals(false, y2k == getLastModifiedMillis(file),
"FileUtils.touch() changed lastModified");
+ assertFalse(y2k == getLastModifiedMillis(file), "FileUtils.touch()
changed lastModified");
final int delta = 3000;
- assertEquals(true, getLastModifiedMillis(file) >= nowMillis - delta,
"FileUtils.touch() changed lastModified to more than now-3s");
- assertEquals(true, getLastModifiedMillis(file) <= nowMillis + delta,
"FileUtils.touch() changed lastModified to less than now+3s");
+ assertTrue(getLastModifiedMillis(file) >= nowMillis - delta,
"FileUtils.touch() changed lastModified to more than now-3s");
+ assertTrue(getLastModifiedMillis(file) <= nowMillis + delta,
"FileUtils.touch() changed lastModified to less than now+3s");
}
@Test
diff --git a/src/test/java/org/apache/commons/io/FilenameUtilsTestCase.java
b/src/test/java/org/apache/commons/io/FilenameUtilsTestCase.java
index ab1030b..b87ad58 100644
--- a/src/test/java/org/apache/commons/io/FilenameUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/io/FilenameUtilsTestCase.java
@@ -18,6 +18,7 @@ package org.apache.commons.io;
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.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -99,13 +100,13 @@ public class FilenameUtilsTestCase {
//-----------------------------------------------------------------------
@Test
public void testNormalize() {
- assertEquals(null, FilenameUtils.normalize(null));
- assertEquals(null, FilenameUtils.normalize(":"));
- assertEquals(null, FilenameUtils.normalize("1:\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalize("1:"));
- assertEquals(null, FilenameUtils.normalize("1:a"));
- assertEquals(null, FilenameUtils.normalize("\\\\\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalize("\\\\a"));
+ assertNull(FilenameUtils.normalize(null));
+ assertNull(FilenameUtils.normalize(":"));
+ assertNull(FilenameUtils.normalize("1:\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("1:"));
+ assertNull(FilenameUtils.normalize("1:a"));
+ assertNull(FilenameUtils.normalize("\\\\\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("\\\\a"));
assertEquals("a" + SEP + "b" + SEP + "c.txt",
FilenameUtils.normalize("a\\b/c.txt"));
assertEquals("" + SEP + "a" + SEP + "b" + SEP + "c.txt",
FilenameUtils.normalize("\\a\\b/c.txt"));
@@ -117,12 +118,12 @@ public class FilenameUtilsTestCase {
assertEquals("a" + SEP + "c", FilenameUtils.normalize("a/b/../c"));
assertEquals("c", FilenameUtils.normalize("a/b/../../c"));
assertEquals("c" + SEP, FilenameUtils.normalize("a/b/../../c/"));
- assertEquals(null, FilenameUtils.normalize("a/b/../../../c"));
+ assertNull(FilenameUtils.normalize("a/b/../../../c"));
assertEquals("a" + SEP, FilenameUtils.normalize("a/b/.."));
assertEquals("a" + SEP, FilenameUtils.normalize("a/b/../"));
assertEquals("", FilenameUtils.normalize("a/b/../.."));
assertEquals("", FilenameUtils.normalize("a/b/../../"));
- assertEquals(null, FilenameUtils.normalize("a/b/../../.."));
+ assertNull(FilenameUtils.normalize("a/b/../../.."));
assertEquals("a" + SEP + "d",
FilenameUtils.normalize("a/b/../c/../d"));
assertEquals("a" + SEP + "d" + SEP,
FilenameUtils.normalize("a/b/../c/../d/"));
assertEquals("a" + SEP + "b" + SEP + "d",
FilenameUtils.normalize("a/b//d"));
@@ -132,44 +133,44 @@ public class FilenameUtilsTestCase {
assertEquals("a", FilenameUtils.normalize("./a"));
assertEquals("", FilenameUtils.normalize("./"));
assertEquals("", FilenameUtils.normalize("."));
- assertEquals(null, FilenameUtils.normalize("../a"));
- assertEquals(null, FilenameUtils.normalize(".."));
+ assertNull(FilenameUtils.normalize("../a"));
+ assertNull(FilenameUtils.normalize(".."));
assertEquals("", FilenameUtils.normalize(""));
assertEquals(SEP + "a", FilenameUtils.normalize("/a"));
assertEquals(SEP + "a" + SEP, FilenameUtils.normalize("/a/"));
assertEquals(SEP + "a" + SEP + "c",
FilenameUtils.normalize("/a/b/../c"));
assertEquals(SEP + "c", FilenameUtils.normalize("/a/b/../../c"));
- assertEquals(null, FilenameUtils.normalize("/a/b/../../../c"));
+ assertNull(FilenameUtils.normalize("/a/b/../../../c"));
assertEquals(SEP + "a" + SEP, FilenameUtils.normalize("/a/b/.."));
assertEquals(SEP + "", FilenameUtils.normalize("/a/b/../.."));
- assertEquals(null, FilenameUtils.normalize("/a/b/../../.."));
+ assertNull(FilenameUtils.normalize("/a/b/../../.."));
assertEquals(SEP + "a" + SEP + "d",
FilenameUtils.normalize("/a/b/../c/../d"));
assertEquals(SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalize("/a/b//d"));
assertEquals(SEP + "a" + SEP + "b" + SEP,
FilenameUtils.normalize("/a/b/././."));
assertEquals(SEP + "a", FilenameUtils.normalize("/./a"));
assertEquals(SEP + "", FilenameUtils.normalize("/./"));
assertEquals(SEP + "", FilenameUtils.normalize("/."));
- assertEquals(null, FilenameUtils.normalize("/../a"));
- assertEquals(null, FilenameUtils.normalize("/.."));
+ assertNull(FilenameUtils.normalize("/../a"));
+ assertNull(FilenameUtils.normalize("/.."));
assertEquals(SEP + "", FilenameUtils.normalize("/"));
assertEquals("~" + SEP + "a", FilenameUtils.normalize("~/a"));
assertEquals("~" + SEP + "a" + SEP, FilenameUtils.normalize("~/a/"));
assertEquals("~" + SEP + "a" + SEP + "c",
FilenameUtils.normalize("~/a/b/../c"));
assertEquals("~" + SEP + "c",
FilenameUtils.normalize("~/a/b/../../c"));
- assertEquals(null, FilenameUtils.normalize("~/a/b/../../../c"));
+ assertNull(FilenameUtils.normalize("~/a/b/../../../c"));
assertEquals("~" + SEP + "a" + SEP,
FilenameUtils.normalize("~/a/b/.."));
assertEquals("~" + SEP + "", FilenameUtils.normalize("~/a/b/../.."));
- assertEquals(null, FilenameUtils.normalize("~/a/b/../../.."));
+ assertNull(FilenameUtils.normalize("~/a/b/../../.."));
assertEquals("~" + SEP + "a" + SEP + "d",
FilenameUtils.normalize("~/a/b/../c/../d"));
assertEquals("~" + SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalize("~/a/b//d"));
assertEquals("~" + SEP + "a" + SEP + "b" + SEP,
FilenameUtils.normalize("~/a/b/././."));
assertEquals("~" + SEP + "a", FilenameUtils.normalize("~/./a"));
assertEquals("~" + SEP, FilenameUtils.normalize("~/./"));
assertEquals("~" + SEP, FilenameUtils.normalize("~/."));
- assertEquals(null, FilenameUtils.normalize("~/../a"));
- assertEquals(null, FilenameUtils.normalize("~/.."));
+ assertNull(FilenameUtils.normalize("~/../a"));
+ assertNull(FilenameUtils.normalize("~/.."));
assertEquals("~" + SEP, FilenameUtils.normalize("~/"));
assertEquals("~" + SEP, FilenameUtils.normalize("~"));
@@ -177,18 +178,18 @@ public class FilenameUtilsTestCase {
assertEquals("~user" + SEP + "a" + SEP,
FilenameUtils.normalize("~user/a/"));
assertEquals("~user" + SEP + "a" + SEP + "c",
FilenameUtils.normalize("~user/a/b/../c"));
assertEquals("~user" + SEP + "c",
FilenameUtils.normalize("~user/a/b/../../c"));
- assertEquals(null, FilenameUtils.normalize("~user/a/b/../../../c"));
+ assertNull(FilenameUtils.normalize("~user/a/b/../../../c"));
assertEquals("~user" + SEP + "a" + SEP,
FilenameUtils.normalize("~user/a/b/.."));
assertEquals("~user" + SEP + "",
FilenameUtils.normalize("~user/a/b/../.."));
- assertEquals(null, FilenameUtils.normalize("~user/a/b/../../.."));
+ assertNull(FilenameUtils.normalize("~user/a/b/../../.."));
assertEquals("~user" + SEP + "a" + SEP + "d",
FilenameUtils.normalize("~user/a/b/../c/../d"));
assertEquals("~user" + SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalize("~user/a/b//d"));
assertEquals("~user" + SEP + "a" + SEP + "b" + SEP,
FilenameUtils.normalize("~user/a/b/././."));
assertEquals("~user" + SEP + "a",
FilenameUtils.normalize("~user/./a"));
assertEquals("~user" + SEP + "", FilenameUtils.normalize("~user/./"));
assertEquals("~user" + SEP + "", FilenameUtils.normalize("~user/."));
- assertEquals(null, FilenameUtils.normalize("~user/../a"));
- assertEquals(null, FilenameUtils.normalize("~user/.."));
+ assertNull(FilenameUtils.normalize("~user/../a"));
+ assertNull(FilenameUtils.normalize("~user/.."));
assertEquals("~user" + SEP, FilenameUtils.normalize("~user/"));
assertEquals("~user" + SEP, FilenameUtils.normalize("~user"));
@@ -196,54 +197,54 @@ public class FilenameUtilsTestCase {
assertEquals("C:" + SEP + "a" + SEP, FilenameUtils.normalize("C:/a/"));
assertEquals("C:" + SEP + "a" + SEP + "c",
FilenameUtils.normalize("C:/a/b/../c"));
assertEquals("C:" + SEP + "c",
FilenameUtils.normalize("C:/a/b/../../c"));
- assertEquals(null, FilenameUtils.normalize("C:/a/b/../../../c"));
+ assertNull(FilenameUtils.normalize("C:/a/b/../../../c"));
assertEquals("C:" + SEP + "a" + SEP,
FilenameUtils.normalize("C:/a/b/.."));
assertEquals("C:" + SEP + "", FilenameUtils.normalize("C:/a/b/../.."));
- assertEquals(null, FilenameUtils.normalize("C:/a/b/../../.."));
+ assertNull(FilenameUtils.normalize("C:/a/b/../../.."));
assertEquals("C:" + SEP + "a" + SEP + "d",
FilenameUtils.normalize("C:/a/b/../c/../d"));
assertEquals("C:" + SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalize("C:/a/b//d"));
assertEquals("C:" + SEP + "a" + SEP + "b" + SEP,
FilenameUtils.normalize("C:/a/b/././."));
assertEquals("C:" + SEP + "a", FilenameUtils.normalize("C:/./a"));
assertEquals("C:" + SEP + "", FilenameUtils.normalize("C:/./"));
assertEquals("C:" + SEP + "", FilenameUtils.normalize("C:/."));
- assertEquals(null, FilenameUtils.normalize("C:/../a"));
- assertEquals(null, FilenameUtils.normalize("C:/.."));
+ assertNull(FilenameUtils.normalize("C:/../a"));
+ assertNull(FilenameUtils.normalize("C:/.."));
assertEquals("C:" + SEP + "", FilenameUtils.normalize("C:/"));
assertEquals("C:" + "a", FilenameUtils.normalize("C:a"));
assertEquals("C:" + "a" + SEP, FilenameUtils.normalize("C:a/"));
assertEquals("C:" + "a" + SEP + "c",
FilenameUtils.normalize("C:a/b/../c"));
assertEquals("C:" + "c", FilenameUtils.normalize("C:a/b/../../c"));
- assertEquals(null, FilenameUtils.normalize("C:a/b/../../../c"));
+ assertNull(FilenameUtils.normalize("C:a/b/../../../c"));
assertEquals("C:" + "a" + SEP, FilenameUtils.normalize("C:a/b/.."));
assertEquals("C:" + "", FilenameUtils.normalize("C:a/b/../.."));
- assertEquals(null, FilenameUtils.normalize("C:a/b/../../.."));
+ assertNull(FilenameUtils.normalize("C:a/b/../../.."));
assertEquals("C:" + "a" + SEP + "d",
FilenameUtils.normalize("C:a/b/../c/../d"));
assertEquals("C:" + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalize("C:a/b//d"));
assertEquals("C:" + "a" + SEP + "b" + SEP,
FilenameUtils.normalize("C:a/b/././."));
assertEquals("C:" + "a", FilenameUtils.normalize("C:./a"));
assertEquals("C:" + "", FilenameUtils.normalize("C:./"));
assertEquals("C:" + "", FilenameUtils.normalize("C:."));
- assertEquals(null, FilenameUtils.normalize("C:../a"));
- assertEquals(null, FilenameUtils.normalize("C:.."));
+ assertNull(FilenameUtils.normalize("C:../a"));
+ assertNull(FilenameUtils.normalize("C:.."));
assertEquals("C:" + "", FilenameUtils.normalize("C:"));
assertEquals(SEP + SEP + "server" + SEP + "a",
FilenameUtils.normalize("//server/a"));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP,
FilenameUtils.normalize("//server/a/"));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "c",
FilenameUtils.normalize("//server/a/b/../c"));
assertEquals(SEP + SEP + "server" + SEP + "c",
FilenameUtils.normalize("//server/a/b/../../c"));
- assertEquals(null, FilenameUtils.normalize("//server/a/b/../../../c"));
+ assertNull(FilenameUtils.normalize("//server/a/b/../../../c"));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP,
FilenameUtils.normalize("//server/a/b/.."));
assertEquals(SEP + SEP + "server" + SEP + "",
FilenameUtils.normalize("//server/a/b/../.."));
- assertEquals(null, FilenameUtils.normalize("//server/a/b/../../.."));
+ assertNull(FilenameUtils.normalize("//server/a/b/../../.."));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "d",
FilenameUtils.normalize("//server/a/b/../c/../d"));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalize("//server/a/b//d"));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "b" + SEP,
FilenameUtils.normalize("//server/a/b/././."));
assertEquals(SEP + SEP + "server" + SEP + "a",
FilenameUtils.normalize("//server/./a"));
assertEquals(SEP + SEP + "server" + SEP + "",
FilenameUtils.normalize("//server/./"));
assertEquals(SEP + SEP + "server" + SEP + "",
FilenameUtils.normalize("//server/."));
- assertEquals(null, FilenameUtils.normalize("//server/../a"));
- assertEquals(null, FilenameUtils.normalize("//server/.."));
+ assertNull(FilenameUtils.normalize("//server/../a"));
+ assertNull(FilenameUtils.normalize("//server/.."));
assertEquals(SEP + SEP + "server" + SEP + "",
FilenameUtils.normalize("//server/"));
assertEquals(SEP + SEP + "127.0.0.1" + SEP + "a" + SEP + "b" + SEP +
"c.txt", FilenameUtils.normalize("\\\\127.0.0.1\\a\\b\\c.txt"));
@@ -261,20 +262,20 @@ public class FilenameUtilsTestCase {
assertEquals(SEP + SEP + "127.0.0.01" + SEP + "a" + SEP + "b" + SEP +
"c.txt",
FilenameUtils.normalize("\\\\127.0.0.01\\a\\b\\c.txt"));
- assertEquals(null,
FilenameUtils.normalize("\\\\-server\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalize("\\\\.\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalize("\\\\..\\a\\b\\c.txt"));
- assertEquals(null,
FilenameUtils.normalize("\\\\127.0..1\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalize("\\\\::1::2\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalize("\\\\:1\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalize("\\\\1:\\a\\b\\c.txt"));
- assertEquals(null,
FilenameUtils.normalize("\\\\1:2:3:4:5:6:7:8:9\\a\\b\\c.txt"));
- assertEquals(null,
FilenameUtils.normalize("\\\\g:2:3:4:5:6:7:8\\a\\b\\c.txt"));
- assertEquals(null,
FilenameUtils.normalize("\\\\1ffff:2:3:4:5:6:7:8\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalize("\\\\1:2\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("\\\\-server\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("\\\\.\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("\\\\..\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("\\\\127.0..1\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("\\\\::1::2\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("\\\\:1\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("\\\\1:\\a\\b\\c.txt"));
+
assertNull(FilenameUtils.normalize("\\\\1:2:3:4:5:6:7:8:9\\a\\b\\c.txt"));
+
assertNull(FilenameUtils.normalize("\\\\g:2:3:4:5:6:7:8\\a\\b\\c.txt"));
+
assertNull(FilenameUtils.normalize("\\\\1ffff:2:3:4:5:6:7:8\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalize("\\\\1:2\\a\\b\\c.txt"));
// IO-556
- assertEquals(null, FilenameUtils.normalize("//../foo"));
- assertEquals(null, FilenameUtils.normalize("\\\\..\\foo"));
+ assertNull(FilenameUtils.normalize("//../foo"));
+ assertNull(FilenameUtils.normalize("\\\\..\\foo"));
}
/**
@@ -307,13 +308,13 @@ public class FilenameUtilsTestCase {
//-----------------------------------------------------------------------
@Test
public void testNormalizeNoEndSeparator() {
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator(null));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator(":"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("1:\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("1:"));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("1:a"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("\\\\\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("\\\\a"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator(null));
+ assertNull(FilenameUtils.normalizeNoEndSeparator(":"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("1:\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("1:"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("1:a"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("\\\\\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("\\\\a"));
assertEquals("a" + SEP + "b" + SEP + "c.txt",
FilenameUtils.normalizeNoEndSeparator("a\\b/c.txt"));
assertEquals("" + SEP + "a" + SEP + "b" + SEP + "c.txt",
FilenameUtils.normalizeNoEndSeparator("\\a\\b/c.txt"));
@@ -325,12 +326,12 @@ public class FilenameUtilsTestCase {
assertEquals("a" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("a/b/../c"));
assertEquals("c",
FilenameUtils.normalizeNoEndSeparator("a/b/../../c"));
assertEquals("c",
FilenameUtils.normalizeNoEndSeparator("a/b/../../c/"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("a/b/../../../c"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("a/b/../../../c"));
assertEquals("a", FilenameUtils.normalizeNoEndSeparator("a/b/.."));
assertEquals("a", FilenameUtils.normalizeNoEndSeparator("a/b/../"));
assertEquals("", FilenameUtils.normalizeNoEndSeparator("a/b/../.."));
assertEquals("", FilenameUtils.normalizeNoEndSeparator("a/b/../../"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("a/b/../../.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("a/b/../../.."));
assertEquals("a" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("a/b/../c/../d"));
assertEquals("a" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("a/b/../c/../d/"));
assertEquals("a" + SEP + "b" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("a/b//d"));
@@ -340,44 +341,44 @@ public class FilenameUtilsTestCase {
assertEquals("a", FilenameUtils.normalizeNoEndSeparator("./a"));
assertEquals("", FilenameUtils.normalizeNoEndSeparator("./"));
assertEquals("", FilenameUtils.normalizeNoEndSeparator("."));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("../a"));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator(".."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("../a"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator(".."));
assertEquals("", FilenameUtils.normalizeNoEndSeparator(""));
assertEquals(SEP + "a", FilenameUtils.normalizeNoEndSeparator("/a"));
assertEquals(SEP + "a", FilenameUtils.normalizeNoEndSeparator("/a/"));
assertEquals(SEP + "a" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("/a/b/../c"));
assertEquals(SEP + "c",
FilenameUtils.normalizeNoEndSeparator("/a/b/../../c"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("/a/b/../../../c"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("/a/b/../../../c"));
assertEquals(SEP + "a",
FilenameUtils.normalizeNoEndSeparator("/a/b/.."));
assertEquals(SEP + "",
FilenameUtils.normalizeNoEndSeparator("/a/b/../.."));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("/a/b/../../.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("/a/b/../../.."));
assertEquals(SEP + "a" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("/a/b/../c/../d"));
assertEquals(SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("/a/b//d"));
assertEquals(SEP + "a" + SEP + "b",
FilenameUtils.normalizeNoEndSeparator("/a/b/././."));
assertEquals(SEP + "a", FilenameUtils.normalizeNoEndSeparator("/./a"));
assertEquals(SEP + "", FilenameUtils.normalizeNoEndSeparator("/./"));
assertEquals(SEP + "", FilenameUtils.normalizeNoEndSeparator("/."));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("/../a"));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("/.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("/../a"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("/.."));
assertEquals(SEP + "", FilenameUtils.normalizeNoEndSeparator("/"));
assertEquals("~" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("~/a"));
assertEquals("~" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("~/a/"));
assertEquals("~" + SEP + "a" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("~/a/b/../c"));
assertEquals("~" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("~/a/b/../../c"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("~/a/b/../../../c"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("~/a/b/../../../c"));
assertEquals("~" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("~/a/b/.."));
assertEquals("~" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("~/a/b/../.."));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("~/a/b/../../.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("~/a/b/../../.."));
assertEquals("~" + SEP + "a" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("~/a/b/../c/../d"));
assertEquals("~" + SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("~/a/b//d"));
assertEquals("~" + SEP + "a" + SEP + "b",
FilenameUtils.normalizeNoEndSeparator("~/a/b/././."));
assertEquals("~" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("~/./a"));
assertEquals("~" + SEP, FilenameUtils.normalizeNoEndSeparator("~/./"));
assertEquals("~" + SEP, FilenameUtils.normalizeNoEndSeparator("~/."));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("~/../a"));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("~/.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("~/../a"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("~/.."));
assertEquals("~" + SEP, FilenameUtils.normalizeNoEndSeparator("~/"));
assertEquals("~" + SEP, FilenameUtils.normalizeNoEndSeparator("~"));
@@ -385,18 +386,18 @@ public class FilenameUtilsTestCase {
assertEquals("~user" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("~user/a/"));
assertEquals("~user" + SEP + "a" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("~user/a/b/../c"));
assertEquals("~user" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("~user/a/b/../../c"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("~user/a/b/../../../c"));
+
assertNull(FilenameUtils.normalizeNoEndSeparator("~user/a/b/../../../c"));
assertEquals("~user" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("~user/a/b/.."));
assertEquals("~user" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("~user/a/b/../.."));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("~user/a/b/../../.."));
+
assertNull(FilenameUtils.normalizeNoEndSeparator("~user/a/b/../../.."));
assertEquals("~user" + SEP + "a" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("~user/a/b/../c/../d"));
assertEquals("~user" + SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("~user/a/b//d"));
assertEquals("~user" + SEP + "a" + SEP + "b",
FilenameUtils.normalizeNoEndSeparator("~user/a/b/././."));
assertEquals("~user" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("~user/./a"));
assertEquals("~user" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("~user/./"));
assertEquals("~user" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("~user/."));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("~user/../a"));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("~user/.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("~user/../a"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("~user/.."));
assertEquals("~user" + SEP,
FilenameUtils.normalizeNoEndSeparator("~user/"));
assertEquals("~user" + SEP,
FilenameUtils.normalizeNoEndSeparator("~user"));
@@ -404,54 +405,54 @@ public class FilenameUtilsTestCase {
assertEquals("C:" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("C:/a/"));
assertEquals("C:" + SEP + "a" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("C:/a/b/../c"));
assertEquals("C:" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("C:/a/b/../../c"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("C:/a/b/../../../c"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("C:/a/b/../../../c"));
assertEquals("C:" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("C:/a/b/.."));
assertEquals("C:" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("C:/a/b/../.."));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("C:/a/b/../../.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("C:/a/b/../../.."));
assertEquals("C:" + SEP + "a" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("C:/a/b/../c/../d"));
assertEquals("C:" + SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("C:/a/b//d"));
assertEquals("C:" + SEP + "a" + SEP + "b",
FilenameUtils.normalizeNoEndSeparator("C:/a/b/././."));
assertEquals("C:" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("C:/./a"));
assertEquals("C:" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("C:/./"));
assertEquals("C:" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("C:/."));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("C:/../a"));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("C:/.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("C:/../a"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("C:/.."));
assertEquals("C:" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("C:/"));
assertEquals("C:" + "a", FilenameUtils.normalizeNoEndSeparator("C:a"));
assertEquals("C:" + "a",
FilenameUtils.normalizeNoEndSeparator("C:a/"));
assertEquals("C:" + "a" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("C:a/b/../c"));
assertEquals("C:" + "c",
FilenameUtils.normalizeNoEndSeparator("C:a/b/../../c"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("C:a/b/../../../c"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("C:a/b/../../../c"));
assertEquals("C:" + "a",
FilenameUtils.normalizeNoEndSeparator("C:a/b/.."));
assertEquals("C:" + "",
FilenameUtils.normalizeNoEndSeparator("C:a/b/../.."));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("C:a/b/../../.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("C:a/b/../../.."));
assertEquals("C:" + "a" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("C:a/b/../c/../d"));
assertEquals("C:" + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("C:a/b//d"));
assertEquals("C:" + "a" + SEP + "b",
FilenameUtils.normalizeNoEndSeparator("C:a/b/././."));
assertEquals("C:" + "a",
FilenameUtils.normalizeNoEndSeparator("C:./a"));
assertEquals("C:" + "", FilenameUtils.normalizeNoEndSeparator("C:./"));
assertEquals("C:" + "", FilenameUtils.normalizeNoEndSeparator("C:."));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("C:../a"));
- assertEquals(null, FilenameUtils.normalizeNoEndSeparator("C:.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("C:../a"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("C:.."));
assertEquals("C:" + "", FilenameUtils.normalizeNoEndSeparator("C:"));
assertEquals(SEP + SEP + "server" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("//server/a"));
assertEquals(SEP + SEP + "server" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("//server/a/"));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("//server/a/b/../c"));
assertEquals(SEP + SEP + "server" + SEP + "c",
FilenameUtils.normalizeNoEndSeparator("//server/a/b/../../c"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("//server/a/b/../../../c"));
+
assertNull(FilenameUtils.normalizeNoEndSeparator("//server/a/b/../../../c"));
assertEquals(SEP + SEP + "server" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("//server/a/b/.."));
assertEquals(SEP + SEP + "server" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("//server/a/b/../.."));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("//server/a/b/../../.."));
+
assertNull(FilenameUtils.normalizeNoEndSeparator("//server/a/b/../../.."));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("//server/a/b/../c/../d"));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "b" + SEP + "d",
FilenameUtils.normalizeNoEndSeparator("//server/a/b//d"));
assertEquals(SEP + SEP + "server" + SEP + "a" + SEP + "b",
FilenameUtils.normalizeNoEndSeparator("//server/a/b/././."));
assertEquals(SEP + SEP + "server" + SEP + "a",
FilenameUtils.normalizeNoEndSeparator("//server/./a"));
assertEquals(SEP + SEP + "server" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("//server/./"));
assertEquals(SEP + SEP + "server" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("//server/."));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("//server/../a"));
- assertEquals(null,
FilenameUtils.normalizeNoEndSeparator("//server/.."));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("//server/../a"));
+ assertNull(FilenameUtils.normalizeNoEndSeparator("//server/.."));
assertEquals(SEP + SEP + "server" + SEP + "",
FilenameUtils.normalizeNoEndSeparator("//server/"));
}
@@ -470,14 +471,14 @@ public class FilenameUtilsTestCase {
//-----------------------------------------------------------------------
@Test
public void testConcat() {
- assertEquals(null, FilenameUtils.concat("", null));
- assertEquals(null, FilenameUtils.concat(null, null));
- assertEquals(null, FilenameUtils.concat(null, ""));
- assertEquals(null, FilenameUtils.concat(null, "a"));
+ assertNull(FilenameUtils.concat("", null));
+ assertNull(FilenameUtils.concat(null, null));
+ assertNull(FilenameUtils.concat(null, ""));
+ assertNull(FilenameUtils.concat(null, "a"));
assertEquals(SEP + "a", FilenameUtils.concat(null, "/a"));
- assertEquals(null, FilenameUtils.concat("", ":")); // invalid prefix
- assertEquals(null, FilenameUtils.concat(":", "")); // invalid prefix
+ assertNull(FilenameUtils.concat("", ":")); // invalid prefix
+ assertNull(FilenameUtils.concat(":", "")); // invalid prefix
assertEquals("f" + SEP, FilenameUtils.concat("", "f/"));
assertEquals("f", FilenameUtils.concat("", "f"));
@@ -510,7 +511,7 @@ public class FilenameUtilsTestCase {
//-----------------------------------------------------------------------
@Test
public void testSeparatorsToUnix() {
- assertEquals(null, FilenameUtils.separatorsToUnix(null));
+ assertNull(FilenameUtils.separatorsToUnix(null));
assertEquals("/a/b/c", FilenameUtils.separatorsToUnix("/a/b/c"));
assertEquals("/a/b/c.txt",
FilenameUtils.separatorsToUnix("/a/b/c.txt"));
assertEquals("/a/b/c", FilenameUtils.separatorsToUnix("/a/b\\c"));
@@ -520,7 +521,7 @@ public class FilenameUtilsTestCase {
@Test
public void testSeparatorsToWindows() {
- assertEquals(null, FilenameUtils.separatorsToWindows(null));
+ assertNull(FilenameUtils.separatorsToWindows(null));
assertEquals("\\a\\b\\c",
FilenameUtils.separatorsToWindows("\\a\\b\\c"));
assertEquals("\\a\\b\\c.txt",
FilenameUtils.separatorsToWindows("\\a\\b\\c.txt"));
assertEquals("\\a\\b\\c",
FilenameUtils.separatorsToWindows("\\a\\b/c"));
@@ -531,14 +532,14 @@ public class FilenameUtilsTestCase {
@Test
public void testSeparatorsToSystem() {
if (WINDOWS) {
- assertEquals(null, FilenameUtils.separatorsToSystem(null));
+ assertNull(FilenameUtils.separatorsToSystem(null));
assertEquals("\\a\\b\\c",
FilenameUtils.separatorsToSystem("\\a\\b\\c"));
assertEquals("\\a\\b\\c.txt",
FilenameUtils.separatorsToSystem("\\a\\b\\c.txt"));
assertEquals("\\a\\b\\c",
FilenameUtils.separatorsToSystem("\\a\\b/c"));
assertEquals("\\a\\b\\c",
FilenameUtils.separatorsToSystem("/a/b/c"));
assertEquals("D:\\a\\b\\c",
FilenameUtils.separatorsToSystem("D:/a/b/c"));
} else {
- assertEquals(null, FilenameUtils.separatorsToSystem(null));
+ assertNull(FilenameUtils.separatorsToSystem(null));
assertEquals("/a/b/c", FilenameUtils.separatorsToSystem("/a/b/c"));
assertEquals("/a/b/c.txt",
FilenameUtils.separatorsToSystem("/a/b/c.txt"));
assertEquals("/a/b/c",
FilenameUtils.separatorsToSystem("/a/b\\c"));
@@ -648,13 +649,13 @@ public class FilenameUtilsTestCase {
//-----------------------------------------------------------------------
@Test
public void testGetPrefix() {
- assertEquals(null, FilenameUtils.getPrefix(null));
- assertEquals(null, FilenameUtils.getPrefix(":"));
- assertEquals(null, FilenameUtils.getPrefix("1:\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.getPrefix("1:"));
- assertEquals(null, FilenameUtils.getPrefix("1:a"));
- assertEquals(null, FilenameUtils.getPrefix("\\\\\\a\\b\\c.txt"));
- assertEquals(null, FilenameUtils.getPrefix("\\\\a"));
+ assertNull(FilenameUtils.getPrefix(null));
+ assertNull(FilenameUtils.getPrefix(":"));
+ assertNull(FilenameUtils.getPrefix("1:\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.getPrefix("1:"));
+ assertNull(FilenameUtils.getPrefix("1:a"));
+ assertNull(FilenameUtils.getPrefix("\\\\\\a\\b\\c.txt"));
+ assertNull(FilenameUtils.getPrefix("\\\\a"));
assertEquals("", FilenameUtils.getPrefix(""));
assertEquals("\\", FilenameUtils.getPrefix("\\"));
@@ -702,7 +703,7 @@ public class FilenameUtilsTestCase {
@Test
public void testGetPath() {
- assertEquals(null, FilenameUtils.getPath(null));
+ assertNull(FilenameUtils.getPath(null));
assertEquals("", FilenameUtils.getPath("noseperator.inthispath"));
assertEquals("", FilenameUtils.getPath("/noseperator.inthispath"));
assertEquals("", FilenameUtils.getPath("\\noseperator.inthispath"));
@@ -711,12 +712,12 @@ public class FilenameUtilsTestCase {
assertEquals("a/b/c/", FilenameUtils.getPath("a/b/c/"));
assertEquals("a\\b\\", FilenameUtils.getPath("a\\b\\c"));
- assertEquals(null, FilenameUtils.getPath(":"));
- assertEquals(null, FilenameUtils.getPath("1:/a/b/c.txt"));
- assertEquals(null, FilenameUtils.getPath("1:"));
- assertEquals(null, FilenameUtils.getPath("1:a"));
- assertEquals(null, FilenameUtils.getPath("///a/b/c.txt"));
- assertEquals(null, FilenameUtils.getPath("//a"));
+ assertNull(FilenameUtils.getPath(":"));
+ assertNull(FilenameUtils.getPath("1:/a/b/c.txt"));
+ assertNull(FilenameUtils.getPath("1:"));
+ assertNull(FilenameUtils.getPath("1:a"));
+ assertNull(FilenameUtils.getPath("///a/b/c.txt"));
+ assertNull(FilenameUtils.getPath("//a"));
assertEquals("", FilenameUtils.getPath(""));
assertEquals("", FilenameUtils.getPath("C:"));
@@ -745,7 +746,7 @@ public class FilenameUtilsTestCase {
@Test
public void testGetPathNoEndSeparator() {
- assertEquals(null, FilenameUtils.getPath(null));
+ assertNull(FilenameUtils.getPath(null));
assertEquals("", FilenameUtils.getPath("noseperator.inthispath"));
assertEquals("",
FilenameUtils.getPathNoEndSeparator("/noseperator.inthispath"));
assertEquals("",
FilenameUtils.getPathNoEndSeparator("\\noseperator.inthispath"));
@@ -754,12 +755,12 @@ public class FilenameUtilsTestCase {
assertEquals("a/b/c", FilenameUtils.getPathNoEndSeparator("a/b/c/"));
assertEquals("a\\b", FilenameUtils.getPathNoEndSeparator("a\\b\\c"));
- assertEquals(null, FilenameUtils.getPathNoEndSeparator(":"));
- assertEquals(null,
FilenameUtils.getPathNoEndSeparator("1:/a/b/c.txt"));
- assertEquals(null, FilenameUtils.getPathNoEndSeparator("1:"));
- assertEquals(null, FilenameUtils.getPathNoEndSeparator("1:a"));
- assertEquals(null,
FilenameUtils.getPathNoEndSeparator("///a/b/c.txt"));
- assertEquals(null, FilenameUtils.getPathNoEndSeparator("//a"));
+ assertNull(FilenameUtils.getPathNoEndSeparator(":"));
+ assertNull(FilenameUtils.getPathNoEndSeparator("1:/a/b/c.txt"));
+ assertNull(FilenameUtils.getPathNoEndSeparator("1:"));
+ assertNull(FilenameUtils.getPathNoEndSeparator("1:a"));
+ assertNull(FilenameUtils.getPathNoEndSeparator("///a/b/c.txt"));
+ assertNull(FilenameUtils.getPathNoEndSeparator("//a"));
assertEquals("", FilenameUtils.getPathNoEndSeparator(""));
assertEquals("", FilenameUtils.getPathNoEndSeparator("C:"));
@@ -791,19 +792,19 @@ public class FilenameUtilsTestCase {
@Test
public void testGetFullPath() {
- assertEquals(null, FilenameUtils.getFullPath(null));
+ assertNull(FilenameUtils.getFullPath(null));
assertEquals("", FilenameUtils.getFullPath("noseperator.inthispath"));
assertEquals("a/b/", FilenameUtils.getFullPath("a/b/c.txt"));
assertEquals("a/b/", FilenameUtils.getFullPath("a/b/c"));
assertEquals("a/b/c/", FilenameUtils.getFullPath("a/b/c/"));
assertEquals("a\\b\\", FilenameUtils.getFullPath("a\\b\\c"));
- assertEquals(null, FilenameUtils.getFullPath(":"));
- assertEquals(null, FilenameUtils.getFullPath("1:/a/b/c.txt"));
- assertEquals(null, FilenameUtils.getFullPath("1:"));
- assertEquals(null, FilenameUtils.getFullPath("1:a"));
- assertEquals(null, FilenameUtils.getFullPath("///a/b/c.txt"));
- assertEquals(null, FilenameUtils.getFullPath("//a"));
+ assertNull(FilenameUtils.getFullPath(":"));
+ assertNull(FilenameUtils.getFullPath("1:/a/b/c.txt"));
+ assertNull(FilenameUtils.getFullPath("1:"));
+ assertNull(FilenameUtils.getFullPath("1:a"));
+ assertNull(FilenameUtils.getFullPath("///a/b/c.txt"));
+ assertNull(FilenameUtils.getFullPath("//a"));
assertEquals("", FilenameUtils.getFullPath(""));
@@ -833,19 +834,19 @@ public class FilenameUtilsTestCase {
@Test
public void testGetFullPathNoEndSeparator() {
- assertEquals(null, FilenameUtils.getFullPathNoEndSeparator(null));
+ assertNull(FilenameUtils.getFullPathNoEndSeparator(null));
assertEquals("",
FilenameUtils.getFullPathNoEndSeparator("noseperator.inthispath"));
assertEquals("a/b",
FilenameUtils.getFullPathNoEndSeparator("a/b/c.txt"));
assertEquals("a/b", FilenameUtils.getFullPathNoEndSeparator("a/b/c"));
assertEquals("a/b/c",
FilenameUtils.getFullPathNoEndSeparator("a/b/c/"));
assertEquals("a\\b",
FilenameUtils.getFullPathNoEndSeparator("a\\b\\c"));
- assertEquals(null, FilenameUtils.getFullPathNoEndSeparator(":"));
- assertEquals(null,
FilenameUtils.getFullPathNoEndSeparator("1:/a/b/c.txt"));
- assertEquals(null, FilenameUtils.getFullPathNoEndSeparator("1:"));
- assertEquals(null, FilenameUtils.getFullPathNoEndSeparator("1:a"));
- assertEquals(null,
FilenameUtils.getFullPathNoEndSeparator("///a/b/c.txt"));
- assertEquals(null, FilenameUtils.getFullPathNoEndSeparator("//a"));
+ assertNull(FilenameUtils.getFullPathNoEndSeparator(":"));
+ assertNull(FilenameUtils.getFullPathNoEndSeparator("1:/a/b/c.txt"));
+ assertNull(FilenameUtils.getFullPathNoEndSeparator("1:"));
+ assertNull(FilenameUtils.getFullPathNoEndSeparator("1:a"));
+ assertNull(FilenameUtils.getFullPathNoEndSeparator("///a/b/c.txt"));
+ assertNull(FilenameUtils.getFullPathNoEndSeparator("//a"));
assertEquals("", FilenameUtils.getFullPathNoEndSeparator(""));
@@ -894,7 +895,7 @@ public class FilenameUtilsTestCase {
@Test
public void testGetName() {
- assertEquals(null, FilenameUtils.getName(null));
+ assertNull(FilenameUtils.getName(null));
assertEquals("noseperator.inthispath",
FilenameUtils.getName("noseperator.inthispath"));
assertEquals("c.txt", FilenameUtils.getName("a/b/c.txt"));
assertEquals("c", FilenameUtils.getName("a/b/c"));
@@ -913,7 +914,7 @@ public class FilenameUtilsTestCase {
@Test
public void testGetBaseName() {
- assertEquals(null, FilenameUtils.getBaseName(null));
+ assertNull(FilenameUtils.getBaseName(null));
assertEquals("noseperator",
FilenameUtils.getBaseName("noseperator.inthispath"));
assertEquals("c", FilenameUtils.getBaseName("a/b/c.txt"));
assertEquals("c", FilenameUtils.getBaseName("a/b/c"));
@@ -933,7 +934,7 @@ public class FilenameUtilsTestCase {
@Test
public void testGetExtension() {
- assertEquals(null, FilenameUtils.getExtension(null));
+ assertNull(FilenameUtils.getExtension(null));
assertEquals("ext", FilenameUtils.getExtension("file.ext"));
assertEquals("", FilenameUtils.getExtension("README"));
assertEquals("com", FilenameUtils.getExtension("domain.dot.com"));
@@ -963,7 +964,7 @@ public class FilenameUtilsTestCase {
@Test
public void testRemoveExtension() {
- assertEquals(null, FilenameUtils.removeExtension(null));
+ assertNull(FilenameUtils.removeExtension(null));
assertEquals("file", FilenameUtils.removeExtension("file.ext"));
assertEquals("README", FilenameUtils.removeExtension("README"));
assertEquals("domain.dot",
FilenameUtils.removeExtension("domain.dot.com"));
diff --git
a/src/test/java/org/apache/commons/io/IOIndexedExceptionTestCase.java
b/src/test/java/org/apache/commons/io/IOIndexedExceptionTestCase.java
index fb9c808..feb5790 100644
--- a/src/test/java/org/apache/commons/io/IOIndexedExceptionTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOIndexedExceptionTestCase.java
@@ -19,6 +19,7 @@ package org.apache.commons.io;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
import java.io.EOFException;
@@ -35,7 +36,7 @@ public class IOIndexedExceptionTestCase {
public void testEdge() {
final IOIndexedException exception = new IOIndexedException(-1, null);
assertEquals(-1, exception.getIndex());
- assertEquals(null, exception.getCause());
+ assertNull(exception.getCause());
assertNotNull(exception.getMessage());
}
diff --git a/src/test/java/org/apache/commons/io/IOUtilsCopyTestCase.java
b/src/test/java/org/apache/commons/io/IOUtilsCopyTestCase.java
index a323f78..0452e34 100644
--- a/src/test/java/org/apache/commons/io/IOUtilsCopyTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOUtilsCopyTestCase.java
@@ -20,7 +20,6 @@ import static
org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
@@ -34,7 +33,6 @@ import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
-import java.util.Arrays;
import org.apache.commons.io.input.NullInputStream;
import org.apache.commons.io.input.NullReader;
@@ -78,7 +76,7 @@ public class IOUtilsCopyTestCase {
assertEquals(0, in.available(), "Not all bytes were read");
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
assertEquals(inData.length,count);
}
@@ -144,7 +142,7 @@ public class IOUtilsCopyTestCase {
assertEquals(0, in.available(), "Not all bytes were read");
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
assertEquals(inData.length,count);
}
@@ -164,7 +162,7 @@ public class IOUtilsCopyTestCase {
assertEquals(0, in.available(), "Not all bytes were read");
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
@@ -184,7 +182,7 @@ public class IOUtilsCopyTestCase {
assertEquals(0, in.available(), "Not all bytes were read");
byte[] bytes = baout.toByteArray();
bytes = new String(bytes,
StandardCharsets.UTF_8).getBytes(StandardCharsets.US_ASCII);
- assertTrue(Arrays.equals(inData, bytes), "Content differs");
+ assertArrayEquals(inData, bytes, "Content differs");
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
@@ -203,7 +201,7 @@ public class IOUtilsCopyTestCase {
assertEquals(0, in.available(), "Not all bytes were read");
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -252,7 +250,7 @@ public class IOUtilsCopyTestCase {
writer.flush();
assertEquals(inData.length, count, "The number of characters returned
by copy is wrong");
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -308,7 +306,7 @@ public class IOUtilsCopyTestCase {
// Note: rely on the method to flush
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
@@ -327,7 +325,7 @@ public class IOUtilsCopyTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes,
StandardCharsets.UTF_16).getBytes(StandardCharsets.US_ASCII);
- assertTrue(Arrays.equals(inData, bytes), "Content differs");
+ assertArrayEquals(inData, bytes, "Content differs");
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
@@ -345,7 +343,7 @@ public class IOUtilsCopyTestCase {
// note: we don't flush here; this IOUtils method does it for us
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -397,7 +395,7 @@ public class IOUtilsCopyTestCase {
writer.flush();
assertEquals(inData.length, count, "The number of characters returned
by copy is wrong");
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
/*
diff --git a/src/test/java/org/apache/commons/io/IOUtilsTestCase.java
b/src/test/java/org/apache/commons/io/IOUtilsTestCase.java
index 106729b..ad1050e 100644
--- a/src/test/java/org/apache/commons/io/IOUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOUtilsTestCase.java
@@ -109,7 +109,7 @@ public class IOUtilsTestCase {
/** Assert that the contents of two byte arrays are the same. */
private void assertEqualContent(final byte[] b0, final byte[] b1) {
- assertTrue(Arrays.equals(b0, b1), "Content not equal according to
java.util.Arrays#equals()");
+ assertArrayEquals(b0, b1, "Content not equal according to
java.util.Arrays#equals()");
}
@BeforeEach
diff --git a/src/test/java/org/apache/commons/io/IOUtilsWriteTestCase.java
b/src/test/java/org/apache/commons/io/IOUtilsWriteTestCase.java
index 0dc7d9e..44b6504 100644
--- a/src/test/java/org/apache/commons/io/IOUtilsWriteTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOUtilsWriteTestCase.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.io;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import java.io.OutputStream;
@@ -54,7 +54,7 @@ public class IOUtilsWriteTestCase {
out.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -90,7 +90,7 @@ public class IOUtilsWriteTestCase {
writer.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -129,7 +129,7 @@ public class IOUtilsWriteTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes,
StandardCharsets.UTF_8).getBytes(StandardCharsets.US_ASCII);
- assertTrue(Arrays.equals(inData, bytes), "Content differs");
+ assertArrayEquals(inData, bytes, "Content differs");
}
@Test
@@ -167,7 +167,7 @@ public class IOUtilsWriteTestCase {
writer.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -182,7 +182,7 @@ public class IOUtilsWriteTestCase {
out.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -220,7 +220,7 @@ public class IOUtilsWriteTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes,
StandardCharsets.UTF_16).getBytes(StandardCharsets.US_ASCII);
- assertTrue(Arrays.equals(inData, bytes), "Content differs");
+ assertArrayEquals(inData, bytes, "Content differs");
}
@Test
@@ -257,7 +257,7 @@ public class IOUtilsWriteTestCase {
out.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -274,7 +274,7 @@ public class IOUtilsWriteTestCase {
writer.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -313,7 +313,7 @@ public class IOUtilsWriteTestCase {
out.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -351,7 +351,7 @@ public class IOUtilsWriteTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes,
StandardCharsets.UTF_16).getBytes(StandardCharsets.US_ASCII);
- assertTrue(Arrays.equals(inData, bytes), "Content differs");
+ assertArrayEquals(inData, bytes, "Content differs");
}
@Test
@@ -388,7 +388,7 @@ public class IOUtilsWriteTestCase {
out.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -405,7 +405,7 @@ public class IOUtilsWriteTestCase {
writer.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -444,7 +444,7 @@ public class IOUtilsWriteTestCase {
out.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
@@ -482,7 +482,7 @@ public class IOUtilsWriteTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes,
StandardCharsets.UTF_16).getBytes(StandardCharsets.US_ASCII);
- assertTrue(Arrays.equals(inData, bytes), "Content differs");
+ assertArrayEquals(inData, bytes, "Content differs");
}
@Test
@@ -519,7 +519,7 @@ public class IOUtilsWriteTestCase {
out.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
//-----------------------------------------------------------------------
@@ -537,7 +537,7 @@ public class IOUtilsWriteTestCase {
writer.flush();
assertEquals(inData.length, baout.size(), "Sizes differ");
- assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content
differs");
+ assertArrayEquals(inData, baout.toByteArray(), "Content differs");
}
@Test
diff --git a/src/test/java/org/apache/commons/io/LineIteratorTestCase.java
b/src/test/java/org/apache/commons/io/LineIteratorTestCase.java
index 22eda6c..a362bb4 100644
--- a/src/test/java/org/apache/commons/io/LineIteratorTestCase.java
+++ b/src/test/java/org/apache/commons/io/LineIteratorTestCase.java
@@ -231,7 +231,7 @@ public class LineIteratorTestCase {
final String line = iterator.next();
assertEquals(lines.get(i), line, "next() line " + i);
}
- assertEquals(false, iterator.hasNext(), "No more expected");
+ assertFalse(iterator.hasNext(), "No more expected");
}
}
diff --git
a/src/test/java/org/apache/commons/io/comparator/ExtensionFileComparatorTest.java
b/src/test/java/org/apache/commons/io/comparator/ExtensionFileComparatorTest.java
index af9df74..efd8213 100644
---
a/src/test/java/org/apache/commons/io/comparator/ExtensionFileComparatorTest.java
+++
b/src/test/java/org/apache/commons/io/comparator/ExtensionFileComparatorTest.java
@@ -16,6 +16,7 @@
*/
package org.apache.commons.io.comparator;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
@@ -45,13 +46,13 @@ public class ExtensionFileComparatorTest extends
ComparatorAbstractTestCase {
public void testCaseSensitivity() {
final File file3 = new File("abc.FOO");
final Comparator<File> sensitive = new ExtensionFileComparator(null);
/* test null as well */
- assertTrue(sensitive.compare(equalFile1, equalFile2) == 0, "sensitive
file1 & file2 = 0");
+ assertEquals(0, sensitive.compare(equalFile1, equalFile2), "sensitive
file1 & file2 = 0");
assertTrue(sensitive.compare(equalFile1, file3) > 0, "sensitive file1
& file3 > 0");
assertTrue(sensitive.compare(equalFile1, lessFile) > 0, "sensitive
file1 & less > 0");
final Comparator<File> insensitive =
ExtensionFileComparator.EXTENSION_INSENSITIVE_COMPARATOR;
- assertTrue(insensitive.compare(equalFile1, equalFile2) == 0,
"insensitive file1 & file2 = 0");
- assertTrue(insensitive.compare(equalFile1, file3) == 0, "insensitive
file1 & file3 = 0");
+ assertEquals(0, insensitive.compare(equalFile1, equalFile2),
"insensitive file1 & file2 = 0");
+ assertEquals(0, insensitive.compare(equalFile1, file3), "insensitive
file1 & file3 = 0");
assertTrue(insensitive.compare(equalFile1, lessFile) > 0, "insensitive
file1 & file4 > 0");
assertTrue(insensitive.compare(file3, lessFile) > 0, "insensitive
file3 & less > 0");
}
diff --git
a/src/test/java/org/apache/commons/io/comparator/NameFileComparatorTest.java
b/src/test/java/org/apache/commons/io/comparator/NameFileComparatorTest.java
index fbd2fe8..5374763 100644
--- a/src/test/java/org/apache/commons/io/comparator/NameFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/NameFileComparatorTest.java
@@ -16,6 +16,7 @@
*/
package org.apache.commons.io.comparator;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
@@ -44,13 +45,13 @@ public class NameFileComparatorTest extends
ComparatorAbstractTestCase {
public void testCaseSensitivity() {
final File file3 = new File("a/FOO.txt");
final Comparator<File> sensitive = new NameFileComparator(null); /*
test null as well */
- assertTrue(sensitive.compare(equalFile1, equalFile2) == 0, "sensitive
file1 & file2 = 0");
+ assertEquals(0, sensitive.compare(equalFile1, equalFile2), "sensitive
file1 & file2 = 0");
assertTrue(sensitive.compare(equalFile1, file3) > 0, "sensitive file1
& file3 > 0");
assertTrue(sensitive.compare(equalFile1, lessFile) > 0, "sensitive
file1 & less > 0");
final Comparator<File> insensitive =
NameFileComparator.NAME_INSENSITIVE_COMPARATOR;
- assertTrue(insensitive.compare(equalFile1, equalFile2) == 0,
"insensitive file1 & file2 = 0");
- assertTrue(insensitive.compare(equalFile1, file3) == 0, "insensitive
file1 & file3 = 0");
+ assertEquals(0, insensitive.compare(equalFile1, equalFile2),
"insensitive file1 & file2 = 0");
+ assertEquals(0, insensitive.compare(equalFile1, file3), "insensitive
file1 & file3 = 0");
assertTrue(insensitive.compare(equalFile1, lessFile) > 0, "insensitive
file1 & file4 > 0");
assertTrue(insensitive.compare(file3, lessFile) > 0, "insensitive
file3 & less > 0");
}
diff --git
a/src/test/java/org/apache/commons/io/comparator/PathFileComparatorTest.java
b/src/test/java/org/apache/commons/io/comparator/PathFileComparatorTest.java
index b811689..322cf5e 100644
--- a/src/test/java/org/apache/commons/io/comparator/PathFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/PathFileComparatorTest.java
@@ -16,6 +16,7 @@
*/
package org.apache.commons.io.comparator;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
@@ -45,13 +46,13 @@ public class PathFileComparatorTest extends
ComparatorAbstractTestCase {
public void testCaseSensitivity() {
final File file3 = new File("FOO/file.txt");
final Comparator<File> sensitive = new PathFileComparator(null); /*
test null as well */
- assertTrue(sensitive.compare(equalFile1, equalFile2) == 0, "sensitive
file1 & file2 = 0");
+ assertEquals(0, sensitive.compare(equalFile1, equalFile2), "sensitive
file1 & file2 = 0");
assertTrue(sensitive.compare(equalFile1, file3) > 0, "sensitive file1
& file3 > 0");
assertTrue(sensitive.compare(equalFile1, lessFile) > 0, "sensitive
file1 & less > 0");
final Comparator<File> insensitive =
PathFileComparator.PATH_INSENSITIVE_COMPARATOR;
- assertTrue(insensitive.compare(equalFile1, equalFile2) == 0,
"insensitive file1 & file2 = 0");
- assertTrue(insensitive.compare(equalFile1, file3) == 0, "insensitive
file1 & file3 = 0");
+ assertEquals(0, insensitive.compare(equalFile1, equalFile2),
"insensitive file1 & file2 = 0");
+ assertEquals(0, insensitive.compare(equalFile1, file3), "insensitive
file1 & file3 = 0");
assertTrue(insensitive.compare(equalFile1, lessFile) > 0, "insensitive
file1 & file4 > 0");
assertTrue(insensitive.compare(file3, lessFile) > 0, "insensitive
file3 & less > 0");
}
diff --git
a/src/test/java/org/apache/commons/io/filefilter/ConditionalFileFilterAbstractTestCase.java
b/src/test/java/org/apache/commons/io/filefilter/ConditionalFileFilterAbstractTestCase.java
index 98f929f..3d78f97 100644
---
a/src/test/java/org/apache/commons/io/filefilter/ConditionalFileFilterAbstractTestCase.java
+++
b/src/test/java/org/apache/commons/io/filefilter/ConditionalFileFilterAbstractTestCase.java
@@ -17,6 +17,7 @@
package org.apache.commons.io.filefilter;
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 java.io.File;
@@ -80,7 +81,7 @@ public abstract class ConditionalFileFilterAbstractTestCase
extends IOFileFilter
filters.add(new TesterTrueFileFilter());
for (final TesterTrueFileFilter filter : filters) {
fileFilter.removeFileFilter(filter);
- assertTrue(!fileFilter.getFileFilters().contains(filter), "file
filter removed");
+ assertFalse(fileFilter.getFileFilters().contains(filter), "file
filter removed");
}
assertEquals(0, fileFilter.getFileFilters().size(), "file filters
count");
}
diff --git
a/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
b/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
index 25aef86..e1300ec 100644
--- a/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
@@ -480,16 +480,16 @@ public class FileFilterTestCase {
assertFiltering(listFilter, new File("Test.bmp").toPath(), false);
assertTrue(listFilter.accept(txtFile));
- assertTrue(!listFilter.accept(bmpFile));
- assertTrue(!listFilter.accept(dirFile));
+ assertFalse(listFilter.accept(bmpFile));
+ assertFalse(listFilter.accept(dirFile));
//
assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath,
null));
assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath,
null));
assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirPath,
null));
assertTrue(listFilter.accept(txtFile.getParentFile(),
txtFile.getName()));
- assertTrue(!listFilter.accept(bmpFile.getParentFile(),
bmpFile.getName()));
- assertTrue(!listFilter.accept(dirFile.getParentFile(),
dirFile.getName()));
+ assertFalse(listFilter.accept(bmpFile.getParentFile(),
bmpFile.getName()));
+ assertFalse(listFilter.accept(dirFile.getParentFile(),
dirFile.getName()));
//
assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath,
null));
assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath,
null));
@@ -1353,7 +1353,7 @@ public class FileFilterTestCase {
assertTrue(orFilter.accept(testFile.getParentFile(),
testFile.getName()));
assertEquals(FileVisitResult.CONTINUE, orFilter.accept(testPath,
null));
orFilter.removeFileFilter(trueFilter);
- assertTrue(!orFilter.accept(testFile.getParentFile(),
testFile.getName()));
+ assertFalse(orFilter.accept(testFile.getParentFile(),
testFile.getName()));
assertEquals(FileVisitResult.TERMINATE, orFilter.accept(testPath,
null));
assertThrows(NullPointerException.class, () -> new
OrFileFilter(falseFilter, (IOFileFilter) null));
@@ -1404,7 +1404,7 @@ public class FileFilterTestCase {
assertFiltering(filter, new File("fred").toPath(), false);
assertTrue(filter.accept(testFile.getParentFile(),
testFile.getName()));
- assertTrue(!filter.accept(fredFile.getParentFile(),
fredFile.getName()));
+ assertFalse(filter.accept(fredFile.getParentFile(),
fredFile.getName()));
//
assertEquals(FileVisitResult.CONTINUE, filter.accept(testPath, null));
assertEquals(FileVisitResult.TERMINATE, filter.accept(fredPath, null));
@@ -1412,7 +1412,7 @@ public class FileFilterTestCase {
final List<String> prefixes = Arrays.asList("foo", "fre");
final IOFileFilter listFilter = new PrefixFileFilter(prefixes);
- assertTrue(!listFilter.accept(testFile.getParentFile(),
testFile.getName()));
+ assertFalse(listFilter.accept(testFile.getParentFile(),
testFile.getName()));
assertTrue(listFilter.accept(fredFile.getParentFile(),
fredFile.getName()));
//
assertEquals(FileVisitResult.TERMINATE, listFilter.accept(testPath,
null));
@@ -1630,7 +1630,7 @@ public class FileFilterTestCase {
assertFiltering(filter, new File("fred").toPath(), false);
assertTrue(filter.accept(testFile.getParentFile(),
testFile.getName()));
- assertTrue(!filter.accept(fredFile.getParentFile(),
fredFile.getName()));
+ assertFalse(filter.accept(fredFile.getParentFile(),
fredFile.getName()));
//
assertEquals(FileVisitResult.CONTINUE, filter.accept(testPath, null));
assertEquals(FileVisitResult.TERMINATE, filter.accept(fredPath, null));
@@ -1638,7 +1638,7 @@ public class FileFilterTestCase {
final List<String> prefixes = Arrays.asList("ood", "red");
final IOFileFilter listFilter = new SuffixFileFilter(prefixes);
- assertTrue(!listFilter.accept(testFile.getParentFile(),
testFile.getName()));
+ assertFalse(listFilter.accept(testFile.getParentFile(),
testFile.getName()));
assertTrue(listFilter.accept(fredFile.getParentFile(),
fredFile.getName()));
//
assertEquals(FileVisitResult.TERMINATE, listFilter.accept(testPath,
null));
@@ -1825,16 +1825,16 @@ public class FileFilterTestCase {
final File dirFile = new File("src/java");
final Path dirPath = dirFile.toPath();
assertTrue(listFilter.accept(txtFile));
- assertTrue(!listFilter.accept(bmpFile));
- assertTrue(!listFilter.accept(dirFile));
+ assertFalse(listFilter.accept(bmpFile));
+ assertFalse(listFilter.accept(dirFile));
//
assertEquals(FileVisitResult.CONTINUE,
listFilter.accept(txtFile.toPath(), null));
assertEquals(FileVisitResult.TERMINATE,
listFilter.accept(bmpFile.toPath(), null));
assertEquals(FileVisitResult.TERMINATE,
listFilter.accept(dirFile.toPath(), null));
assertTrue(listFilter.accept(txtFile.getParentFile(),
txtFile.getName()));
- assertTrue(!listFilter.accept(bmpFile.getParentFile(),
bmpFile.getName()));
- assertTrue(!listFilter.accept(dirFile.getParentFile(),
dirFile.getName()));
+ assertFalse(listFilter.accept(bmpFile.getParentFile(),
bmpFile.getName()));
+ assertFalse(listFilter.accept(dirFile.getParentFile(),
dirFile.getName()));
//
assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath,
null));
assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath,
null));
diff --git
a/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java
b/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java
index 0278500..0ebd443 100644
--- a/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java
@@ -18,7 +18,7 @@ package org.apache.commons.io.input;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -132,7 +132,7 @@ public class CharSequenceInputStreamTest {
for (int i = 0; i < readFirst; i++) {
final int ch = is.read();
- assertFalse(ch == -1);
+ assertNotEquals(-1, ch);
}
is.mark(dataSize);
diff --git
a/src/test/java/org/apache/commons/io/input/ObservableInputStreamTest.java
b/src/test/java/org/apache/commons/io/input/ObservableInputStreamTest.java
index 219ab00..e2bf724 100644
--- a/src/test/java/org/apache/commons/io/input/ObservableInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/ObservableInputStreamTest.java
@@ -18,6 +18,7 @@ package org.apache.commons.io.input;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -221,9 +222,9 @@ public class ObservableInputStreamTest {
final ObservableInputStream ois = new ObservableInputStream(bais))
{
final DataViewObserver observer = new DataViewObserver();
final byte[] readBuffer = new byte[23];
- assertEquals(null, observer.buffer);
+ assertNull(observer.buffer);
ois.read(readBuffer);
- assertEquals(null, observer.buffer);
+ assertNull(observer.buffer);
ois.add(observer);
for (;;) {
if (bais.available() >= 2048) {
diff --git
a/src/test/java/org/apache/commons/io/input/RandomAccessFileInputStreamTest.java
b/src/test/java/org/apache/commons/io/input/RandomAccessFileInputStreamTest.java
index 5a74619..34ed2e9 100644
---
a/src/test/java/org/apache/commons/io/input/RandomAccessFileInputStreamTest.java
+++
b/src/test/java/org/apache/commons/io/input/RandomAccessFileInputStreamTest.java
@@ -19,7 +19,9 @@ package org.apache.commons.io.input;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.FileNotFoundException;
import java.io.IOException;
@@ -57,7 +59,7 @@ public class RandomAccessFileInputStreamTest {
public void testCtorCloseOnCloseFalse() throws IOException {
try (RandomAccessFile file = createRandomAccessFile()) {
try (final RandomAccessFileInputStream inputStream = new
RandomAccessFileInputStream(file, false)) {
- assertEquals(false, inputStream.isCloseOnClose());
+ assertFalse(inputStream.isCloseOnClose());
}
file.read();
}
@@ -67,7 +69,7 @@ public class RandomAccessFileInputStreamTest {
public void testCtorCloseOnCloseTrue() throws IOException {
try (RandomAccessFile file = createRandomAccessFile()) {
try (final RandomAccessFileInputStream inputStream = new
RandomAccessFileInputStream(file, true)) {
- assertEquals(true, inputStream.isCloseOnClose());
+ assertTrue(inputStream.isCloseOnClose());
}
assertThrows(IOException.class, () -> file.read());
}
@@ -83,7 +85,7 @@ public class RandomAccessFileInputStreamTest {
try (RandomAccessFile file = createRandomAccessFile()) {
try (final RandomAccessFileInputStream inputStream = new
RandomAccessFileInputStream(file, true)) {
assertEquals(file, inputStream.getRandomAccessFile());
- assertEquals(true, inputStream.isCloseOnClose());
+ assertTrue(inputStream.isCloseOnClose());
}
}
}
diff --git
a/src/test/java/org/apache/commons/io/input/SwappedDataInputStreamTest.java
b/src/test/java/org/apache/commons/io/input/SwappedDataInputStreamTest.java
index c56c535..b943ba8 100644
--- a/src/test/java/org/apache/commons/io/input/SwappedDataInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/SwappedDataInputStreamTest.java
@@ -18,7 +18,9 @@ package org.apache.commons.io.input;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.IOException;
@@ -67,9 +69,9 @@ public class SwappedDataInputStreamTest {
final ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
final SwappedDataInputStream sdis = new
SwappedDataInputStream(bais)
) {
- assertEquals(false, sdis.readBoolean());
- assertEquals(true, sdis.readBoolean());
- assertEquals(true, sdis.readBoolean());
+ assertFalse(sdis.readBoolean());
+ assertTrue(sdis.readBoolean());
+ assertTrue(sdis.readBoolean());
}
}
diff --git
a/src/test/java/org/apache/commons/io/output/DeferredFileOutputStreamTest.java
b/src/test/java/org/apache/commons/io/output/DeferredFileOutputStreamTest.java
index 8f0d509..2098619 100644
---
a/src/test/java/org/apache/commons/io/output/DeferredFileOutputStreamTest.java
+++
b/src/test/java/org/apache/commons/io/output/DeferredFileOutputStreamTest.java
@@ -30,7 +30,6 @@ import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Path;
-import java.util.Arrays;
import java.util.stream.IntStream;
import org.apache.commons.io.IOUtils;
@@ -129,7 +128,7 @@ public class DeferredFileOutputStreamTest {
final byte[] resultBytes = dfos.getData();
assertEquals(testBytes.length, resultBytes.length);
- assertTrue(Arrays.equals(resultBytes, testBytes));
+ assertArrayEquals(resultBytes, testBytes);
}
/**
@@ -150,7 +149,7 @@ public class DeferredFileOutputStreamTest {
final byte[] resultBytes = dfos.getData();
assertEquals(testBytes.length, resultBytes.length);
- assertTrue(Arrays.equals(resultBytes, testBytes));
+ assertArrayEquals(resultBytes, testBytes);
}
/**
@@ -342,7 +341,7 @@ public class DeferredFileOutputStreamTest {
fail("Unexpected IOException");
}
final byte[] copiedBytes = baos.toByteArray();
- assertTrue(Arrays.equals(testBytes, copiedBytes));
+ assertArrayEquals(testBytes, copiedBytes);
verifyResultFile(testFile);
testFile.delete();
}
@@ -379,7 +378,7 @@ public class DeferredFileOutputStreamTest {
fail("Unexpected IOException");
}
final byte[] copiedBytes = baos.toByteArray();
- assertTrue(Arrays.equals(testBytes, copiedBytes));
+ assertArrayEquals(testBytes, copiedBytes);
testFile.delete();
}
@@ -397,7 +396,7 @@ public class DeferredFileOutputStreamTest {
final byte[] resultBytes = new byte[testBytes.length];
assertEquals(testBytes.length, fis.read(resultBytes));
- assertTrue(Arrays.equals(resultBytes, testBytes));
+ assertArrayEquals(resultBytes, testBytes);
assertEquals(-1, fis.read(resultBytes));
try {
diff --git
a/src/test/java/org/apache/commons/io/output/XmlStreamWriterTest.java
b/src/test/java/org/apache/commons/io/output/XmlStreamWriterTest.java
index 067feaf..9f654a2 100644
--- a/src/test/java/org/apache/commons/io/output/XmlStreamWriterTest.java
+++ b/src/test/java/org/apache/commons/io/output/XmlStreamWriterTest.java
@@ -16,11 +16,11 @@
*/
package org.apache.commons.io.output;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
-import java.util.Arrays;
import org.junit.jupiter.api.Test;
import org.junitpioneer.jupiter.DefaultLocale;
@@ -56,7 +56,7 @@ public class XmlStreamWriterTest {
writer.close();
final byte[] xmlContent = out.toByteArray();
assertTrue(encoding.equalsIgnoreCase(writer.getEncoding()));
- assertTrue(Arrays.equals(xml.getBytes(encoding), xmlContent));
+ assertArrayEquals(xml.getBytes(encoding), xmlContent);
}
diff --git a/src/test/java/org/apache/commons/io/test/TestUtils.java
b/src/test/java/org/apache/commons/io/test/TestUtils.java
index 1f0cfff..0e59978 100644
--- a/src/test/java/org/apache/commons/io/test/TestUtils.java
+++ b/src/test/java/org/apache/commons/io/test/TestUtils.java
@@ -16,6 +16,7 @@
*/
package org.apache.commons.io.test;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -34,7 +35,6 @@ import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.output.ByteArrayOutputStream;
@@ -113,8 +113,7 @@ public abstract class TestUtils {
"The files " + f0 + " and " + f1 +
" have differing number of bytes available (" + n0
+ " vs " + n1 + ")");
- assertTrue(Arrays.equals(buf0, buf1),
- "The files " + f0 + " and " + f1 + " have
different content");
+ assertArrayEquals(buf0, buf1, "The files " + f0 + " and "
+ f1 + " have different content");
}
}
}
