You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2019/10/06 15:01:44 UTC
[commons-io] branch master updated: IO-628: Migration to JUnit
Jupiter (#97)
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 eae791d IO-628: Migration to JUnit Jupiter (#97)
eae791d is described below
commit eae791d517e79254474e2a5332ed83bd84657237
Author: Allon Murienik <mu...@gmail.com>
AuthorDate: Sun Oct 6 18:01:39 2019 +0300
IO-628: Migration to JUnit Jupiter (#97)
* Use fail instead of throwing an AssertionFailedError
Use JUnit's Assert#fail in order to fail tests with the proper JUnit
API, instead of explicitly throwing the underlying exception.
This change makes the tests easier to read and maintain, and will help
facilitate the migration to JUnit Jupiter.
* Remove outdate javadoc references to TestCase#setUp()
In JUnit 3, in order to run some code before each test, you would
extend junit.framework.TestCase and override its setUp() method.
In JUnit 4 this is no longer the case, and you simply need to annotate
the method with org.junit.Before, as is done in the classes in
question.
This patch removes old javadoc comments that reference the TestCase
method which are no longer relevant, and are probably outdated remains
from the days the project used JUnit 3.
* Standardize org.junit.Assert imports
The de-facto standard for using org.junit.Assert methods in the
project is to statically import its method.
However, some places use the class directly and call methods on it.
This patch standardizes the approach, and makes sure all the usages of
org.junit.Assert statically import methods in order to have a
consistent coding standard throughout the project's tests.
* Statically import org.junit.Assume methods
Statically import methods from org.junit.Assume in order to make its
usages consistent with org.junit.Assert's usage pattern.
* Migrate test suite to JUnit Jupiter
This patch upgrades the project's testing framework from JUnit 4.12
to the modern JUnit Jupiter 5.5.4.
Since JUnit 5 Jupiter is not backwards compatible to JUnit 4.x (or
even JUnit Vintage), this patch is a bit large, even though a lot of
the changes are merely cosmetic (such as changing the argument order,
see details below). In order to make the reviewer's task as easy as
possible, this patch does not presume to use JUnit Jupiter's best
practices and all its new functionality, but only to migrate the
existing test with as little change as possible. Following patches
may want to improve the tests by using some of JUnit Jupiter's new
features.
This patch includes the following changes:
1. Maven dependency changes:
a. junit:junit was replaced with org.junit.jupiter:junit-jupiter.
b. org.junit-pioneer:junit-pioneer was introduced (see details
below in section 2.g.).
2. Annotations:
a. org.junit.jupiter.api.Test was used as a drop in replacement for
org.juit.Test without arguments. See 3.b. and 3.c. for handling
of @Test annotations with "expected" and "timeout" arguments
respectively.
b. org.junit.jupiter.params.ParameterizedTest in conjunction with
org.junit.jupiter.params.provider.MethodSource was used to
replace org.juit.Test in test classes run with
org.junit.runners.Parameterized.
c. org.junit.runners.Parameterized.Parameters annotations were
removed, and the methods annotated with them were written to
match the signature expected of a @MethodSource
d. org.junit.jupiter.api.BeforeEach was used as an drop in
replacement for org.junit.Before.
e. org.junit.jupiter.api.AfterEach was used as a drop in replacement
for org.junit.After.
f. org.junit.jupiter.api.Disabled was used as a drop in replacement
for org.junit.Ignore.
g. org.junitpioneer.jupiter.DefaultLocale was used as a drop in
replacement for org.apache.commons.io.testtools.SystemDefaults.
This annotation comes from the JUnit Pioneer project, and while
it isn't part of the actual JUnit project, it's widely accepted
as an extension library for JUnit, and is used in other Apache
Commons projects, such as Apache Commons Lang.
3. Assertions:
a. org.junit.jupiter.api.Assertions' methods were used as drop in
replacements for org.junit.Assert's methods with the same name in
the simple case of an assertion without a message.
In the case of an assertion with a message,
org.junit.jupiter.api.Assertions' methods were used, but the
argument order was changed - Assert's methods take the message as
the first argument, while Assertions' methods take the message as
the last argument.
b. org.junit.jupiter.api.Assertions#assertThrows was used to assert
that a specific exception was throws instead of an org.junit.Test
annotation with an "expected" argument. This technique has a side
bonus of making the tests slightly stricter, as now they can
assert the exception was thrown from a specific line and prevent
false positives where the test's "set-up" code accidentally threw
that exception.
The throws clauses of these methods were cleaned up from
exceptions that can no longer be thrown in order to avoid
compilation warnings.
c. org.junit.jupiter.api.Assertions#assertTimeout was used to assert
a specific block of code completes before a timeout is reach
instead of an org.junit.Test annotation with a "timeout"
argument.
4. Assumptions
a. org.junit.jupiter.api.Assumptions' methods were used as drop in
replacements for org.junit.Assume's methods with the same name,
but the argument order was changed - Assume's methods take the
message as the first argument, while Assumptions' methods take
the message as the last argument.
5. Rules
a. org.junit.jupiter.api.io.TempDir was used instead of the
org.junit.rules.TemporaryFolder Rule, and the code that used them
was adapted accordingly.
b. org.apache.commons.io.testtools.SystemDefaultsSwitch was removed
from the project, and its functionality replaced by
org.junitpioneer.jupiter.DefaultLocale.
6. Specific changes:
a. Parameters in JUnit Jupiter (such as those produced by
MethodSource) can only be applied to @Test methods, not to other
lifecycle methods, such as @BeforeEach. Thus, the design of
ReversedLinesFileReaderTestParamFile had to be changed - instead
of receiving constructor arguments and storing a state in data
members, it was rewritten to be stateless, and manage all its
resources in the single test method it has,
testDataIntegrityWithBufferedReader. As a side bonus, this change
allows to narrow the scope of open resources, and close them
immediately after they are no longer needed, instead of
preserving them in data members until the @After method is
called.
b. JUnit Jupiter's @TempDir is stricter than JUnit 4's
@TemporaryFolder, and if it cannot delete any file at the end of
the test, it will fail the test. FileUtilsCleanDirectoryTestCase's
methods testThrowsOnNullList and testThrowsOnCannotDeleteFile
chmod the temporary directory and thus prevent files in it from
being deleted at the end of the test. A finally block was added to
these tests in order to chmod the temporary directory back to 755
and allow it to be deleted. In addition, the restriction of not
running the test on Windows was changed to use JUnit Jupiter's
@DisabledOnOs annotation, in order to make the test a tad easier
to follow.
c. TailerTest has a similar issue to 6.b., where threads opened
during the test are only closed in the @AfterEach method (by
calling Tailer#stop), which is too late, since the @TempDir's
tear down is called (and fails) before hand. Using a shared temp
dir (by declaring the member static) causes the directory to be
deleted only when the entire class is finished.
* Attempt to disable JaCoCo for JDK EA
This is done by passing an environment variable in the .travis.yml
file, and then using it to set the jacoco.skip property in the
pom.xml.
---
.travis.yml | 8 +
pom.xml | 13 +-
.../apache/commons/io/ByteOrderMarkTestCase.java | 73 +--
.../org/apache/commons/io/ByteOrderParserTest.java | 16 +-
.../org/apache/commons/io/CharsetsTestCase.java | 37 +-
.../java/org/apache/commons/io/CopyUtilsTest.java | 47 +-
.../java/org/apache/commons/io/DemuxTestCase.java | 26 +-
.../apache/commons/io/DirectoryWalkerTestCase.java | 93 ++-
.../commons/io/DirectoryWalkerTestCaseJava4.java | 84 +--
.../org/apache/commons/io/EndianUtilsTest.java | 10 +-
.../commons/io/FileCleaningTrackerTestCase.java | 77 ++-
.../commons/io/FileDeleteStrategyTestCase.java | 28 +-
.../org/apache/commons/io/FileSystemTestCase.java | 33 +-
.../apache/commons/io/FileSystemUtilsTestCase.java | 29 +-
.../io/FileUtilsCleanDirectoryTestCase.java | 46 +-
.../commons/io/FileUtilsCleanSymlinksTestCase.java | 27 +-
.../FileUtilsCopyDirectoryToDirectoryTestCase.java | 30 +-
.../commons/io/FileUtilsCopyToFileTestCase.java | 27 +-
.../io/FileUtilsDirectoryContainsTestCase.java | 30 +-
.../commons/io/FileUtilsFileNewerTestCase.java | 53 +-
.../commons/io/FileUtilsListFilesTestCase.java | 76 ++-
.../org/apache/commons/io/FileUtilsTestCase.java | 656 ++++++++++-----------
.../commons/io/FileUtilsWaitForTestCase.java | 4 +-
.../apache/commons/io/FilenameUtilsTestCase.java | 30 +-
.../commons/io/FilenameUtilsWildcardTestCase.java | 16 +-
.../java/org/apache/commons/io/HexDumpTest.java | 30 +-
.../java/org/apache/commons/io/IOCaseTestCase.java | 12 +-
.../apache/commons/io/IOExceptionListTestCase.java | 23 +-
.../commons/io/IOExceptionWithCauseTestCase.java | 6 +-
.../commons/io/IOIndexedExceptionTestCase.java | 18 +-
.../org/apache/commons/io/IOUtilsCopyTestCase.java | 119 ++--
.../org/apache/commons/io/IOUtilsTestCase.java | 140 ++---
.../apache/commons/io/IOUtilsWriteTestCase.java | 94 +--
.../apache/commons/io/LineIteratorTestCase.java | 83 ++-
.../apache/commons/io/TaggedIOExceptionTest.java | 8 +-
.../apache/commons/io/ThreadMonitorTestCase.java | 10 +-
.../io/comparator/ComparatorAbstractTestCase.java | 51 +-
.../io/comparator/CompositeFileComparatorTest.java | 29 +-
.../io/comparator/DefaultFileComparatorTest.java | 4 +-
.../io/comparator/DirectoryFileComparatorTest.java | 6 +-
.../io/comparator/ExtensionFileComparatorTest.java | 22 +-
.../comparator/LastModifiedFileComparatorTest.java | 6 +-
.../io/comparator/NameFileComparatorTest.java | 23 +-
.../io/comparator/PathFileComparatorTest.java | 22 +-
.../io/comparator/SizeFileComparatorTest.java | 22 +-
.../io/filefilter/AndFileFilterTestCase.java | 4 +-
.../ConditionalFileFilterAbstractTestCase.java | 22 +-
.../commons/io/filefilter/FileFilterTestCase.java | 172 +++---
.../filefilter/IOFileFilterAbstractTestCase.java | 31 +-
.../io/filefilter/OrFileFilterTestCase.java | 4 +-
.../io/filefilter/RegexFileFilterTestCase.java | 26 +-
.../commons/io/input/AutoCloseInputStreamTest.java | 44 +-
.../commons/io/input/BOMInputStreamTest.java | 118 ++--
.../commons/io/input/BoundedInputStreamTest.java | 20 +-
.../apache/commons/io/input/BoundedReaderTest.java | 41 +-
.../commons/io/input/BrokenInputStreamTest.java | 10 +-
.../apache/commons/io/input/BrokenReaderTest.java | 10 +-
.../io/input/CharSequenceInputStreamTest.java | 57 +-
.../commons/io/input/CharSequenceReaderTest.java | 11 +-
.../io/input/CharacterFilterReaderTest.java | 19 +-
.../io/input/CharacterSetFilterReaderTest.java | 35 +-
.../io/input/ClassLoaderObjectInputStreamTest.java | 30 +-
.../io/input/CloseShieldInputStreamTest.java | 16 +-
.../commons/io/input/CloseShieldReaderTest.java | 12 +-
.../commons/io/input/ClosedInputStreamTest.java | 6 +-
.../apache/commons/io/input/ClosedReaderTest.java | 6 +-
.../commons/io/input/CountingInputStreamTest.java | 10 +-
.../io/input/InfiniteCircularInputStreamTest.java | 10 +-
.../MessageDigestCalculatingInputStreamTest.java | 4 +-
.../commons/io/input/NullInputStreamTest.java | 80 ++-
.../apache/commons/io/input/NullReaderTest.java | 75 ++-
.../io/input/ObservableInputStreamTest.java | 8 +-
.../apache/commons/io/input/ProxyReaderTest.java | 2 +-
.../commons/io/input/ReaderInputStreamTest.java | 6 +-
.../ReversedLinesFileReaderTestParamBlockSize.java | 129 ++--
.../ReversedLinesFileReaderTestParamFile.java | 138 ++---
.../input/ReversedLinesFileReaderTestSimple.java | 21 +-
.../io/input/SwappedDataInputStreamTest.java | 28 +-
.../commons/io/input/TaggedInputStreamTest.java | 10 +-
.../apache/commons/io/input/TaggedReaderTest.java | 10 +-
.../org/apache/commons/io/input/TailerTest.java | 143 +++--
.../commons/io/input/TeeInputStreamTest.java | 16 +-
.../org/apache/commons/io/input/TeeReaderTest.java | 16 +-
.../io/input/UnixLineEndingInputStreamTest.java | 4 +-
.../io/input/WindowsLineEndingInputStreamTest.java | 4 +-
.../commons/io/input/XmlStreamReaderTest.java | 29 +-
.../io/input/XmlStreamReaderUtilitiesTest.java | 54 +-
.../buffer/CircularBufferInputStreamTest.java | 2 +-
.../io/monitor/AbstractMonitorTestCase.java | 29 +-
.../io/monitor/FileAlterationMonitorTestCase.java | 34 +-
.../io/monitor/FileAlterationObserverTestCase.java | 178 +++---
.../io/output/AppendableOutputStreamTest.java | 8 +-
.../commons/io/output/AppendableWriterTest.java | 8 +-
.../commons/io/output/BrokenOutputStreamTest.java | 10 +-
.../apache/commons/io/output/BrokenWriterTest.java | 10 +-
.../io/output/ByteArrayOutputStreamTestCase.java | 12 +-
.../commons/io/output/ChunkedOutputStreamTest.java | 13 +-
.../commons/io/output/ChunkedWriterTest.java | 12 +-
.../io/output/CloseShieldOutputStreamTest.java | 14 +-
.../commons/io/output/CloseShieldWriterTest.java | 10 +-
.../commons/io/output/ClosedOutputStreamTest.java | 4 +-
.../apache/commons/io/output/ClosedWriterTest.java | 4 +-
.../io/output/CountingOutputStreamTest.java | 22 +-
.../io/output/DeferredFileOutputStreamTest.java | 108 ++--
.../io/output/FileWriterWithEncodingTest.java | 31 +-
.../commons/io/output/LockableFileWriterTest.java | 41 +-
.../commons/io/output/NullOutputStreamTest.java | 2 +-
.../commons/io/output/NullPrintStreamTest.java | 2 +-
.../apache/commons/io/output/NullWriterTest.java | 2 +-
.../io/output/ProxyCollectionWriterTest.java | 115 ++--
.../commons/io/output/ProxyOutputStreamTest.java | 8 +-
.../apache/commons/io/output/ProxyWriterTest.java | 63 +-
.../commons/io/output/StringBuilderWriterTest.java | 8 +-
.../commons/io/output/TaggedOutputStreamTest.java | 10 +-
.../apache/commons/io/output/TaggedWriterTest.java | 10 +-
.../commons/io/output/TeeOutputStreamTest.java | 10 +-
.../apache/commons/io/output/TeeWriterTest.java | 115 ++--
.../io/output/ThresholdingOutputStreamTest.java | 6 +-
.../commons/io/output/WriterOutputStreamTest.java | 6 +-
.../commons/io/output/XmlStreamWriterTest.java | 13 +-
.../commons/io/serialization/ClosingBase.java | 8 +-
.../io/serialization/FullClassNameMatcherTest.java | 6 +-
.../io/serialization/MoreComplexObjectTest.java | 10 +-
.../serialization/RegexpClassNameMatcherTest.java | 15 +-
.../ValidatingObjectInputStreamTest.java | 91 +--
.../WildcardClassNameMatcherTest.java | 6 +-
.../commons/io/testtools/SystemDefaults.java | 36 --
.../commons/io/testtools/SystemDefaultsSwitch.java | 79 ---
.../org/apache/commons/io/testtools/TestUtils.java | 39 +-
.../testtools/YellOnFlushAndCloseOutputStream.java | 8 +-
130 files changed, 2375 insertions(+), 2631 deletions(-)
diff --git a/.travis.yml b/.travis.yml
index 3759820..b71b2cf 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -23,6 +23,14 @@ jdk:
- openjdk-ea
- oraclejdk11
+matrix:
+ exclude:
+ - jdk: openjdk-ea
+ include:
+ - jdk: openjdk-ea
+ env: JACOCO_SKIP=true
+
+
script:
- mvn
diff --git a/pom.xml b/pom.xml
index 18a623f..8bd1a35 100644
--- a/pom.xml
+++ b/pom.xml
@@ -227,9 +227,15 @@ file comparators, endian transformation classes, and much more.
<dependencies>
<dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <version>4.12</version>
+ <groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter</artifactId>
+ <version>5.5.2</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.junit-pioneer</groupId>
+ <artifactId>junit-pioneer</artifactId>
+ <version>0.3.0</version>
<scope>test</scope>
</dependency>
<dependency>
@@ -285,6 +291,7 @@ file comparators, endian transformation classes, and much more.
<commons.surefire.version>2.22.2</commons.surefire.version>
<commons.japicmp.version>0.14.1</commons.japicmp.version>
<japicmp.skip>false</japicmp.skip>
+ <jacoco.skip>${env.JACOCO_SKIP}</jacoco.skip>
</properties>
<build>
diff --git a/src/test/java/org/apache/commons/io/ByteOrderMarkTestCase.java b/src/test/java/org/apache/commons/io/ByteOrderMarkTestCase.java
index b5c455d..6c9a540 100644
--- a/src/test/java/org/apache/commons/io/ByteOrderMarkTestCase.java
+++ b/src/test/java/org/apache/commons/io/ByteOrderMarkTestCase.java
@@ -17,16 +17,16 @@
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.nio.charset.Charset;
import java.util.Arrays;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
@@ -42,9 +42,9 @@ public class ByteOrderMarkTestCase {
/** Test {@link ByteOrderMark#getCharsetName()} */
@Test
public void charsetName() {
- assertEquals("test1 name", "test1", TEST_BOM_1.getCharsetName());
- assertEquals("test2 name", "test2", TEST_BOM_2.getCharsetName());
- assertEquals("test3 name", "test3", TEST_BOM_3.getCharsetName());
+ assertEquals("test1", TEST_BOM_1.getCharsetName(), "test1 name");
+ assertEquals("test2", TEST_BOM_2.getCharsetName(), "test2 name");
+ assertEquals("test3", TEST_BOM_3.getCharsetName(), "test3 name");
}
/** Tests that {@link ByteOrderMark#getCharsetName()} can be loaded as a {@link java.nio.charset.Charset} as advertised. */
@@ -59,52 +59,53 @@ public class ByteOrderMarkTestCase {
/** Test {@link ByteOrderMark#length()} */
@Test
- public void testLength() { assertEquals("test1 length", 1, TEST_BOM_1.length());
- assertEquals("test2 length", 2, TEST_BOM_2.length());
- assertEquals("test3 length", 3, TEST_BOM_3.length());
+ public void testLength() {
+ assertEquals(1, TEST_BOM_1.length(), "test1 length");
+ assertEquals(2, TEST_BOM_2.length(), "test2 length");
+ assertEquals(3, TEST_BOM_3.length(), "test3 length");
}
/** Test {@link ByteOrderMark#get(int)} */
@Test
public void get() {
- assertEquals("test1 get(0)", 1, TEST_BOM_1.get(0));
- assertEquals("test2 get(0)", 1, TEST_BOM_2.get(0));
- assertEquals("test2 get(1)", 2, TEST_BOM_2.get(1));
- assertEquals("test3 get(0)", 1, TEST_BOM_3.get(0));
- assertEquals("test3 get(1)", 2, TEST_BOM_3.get(1));
- assertEquals("test3 get(2)", 3, TEST_BOM_3.get(2));
+ assertEquals(1, TEST_BOM_1.get(0), "test1 get(0)");
+ assertEquals(1, TEST_BOM_2.get(0), "test2 get(0)");
+ assertEquals(2, TEST_BOM_2.get(1), "test2 get(1)");
+ assertEquals(1, TEST_BOM_3.get(0), "test3 get(0)");
+ assertEquals(2, TEST_BOM_3.get(1), "test3 get(1)");
+ assertEquals(3, TEST_BOM_3.get(2), "test3 get(2)");
}
/** Test {@link ByteOrderMark#getBytes()} */
@Test
public void getBytes() {
- assertTrue("test1 bytes", Arrays.equals(TEST_BOM_1.getBytes(), new byte[] {(byte)1}));
- assertTrue("test1 bytes", Arrays.equals(TEST_BOM_2.getBytes(), new byte[] {(byte)1, (byte)2}));
- assertTrue("test1 bytes", Arrays.equals(TEST_BOM_3.getBytes(), new byte[] {(byte)1, (byte)2, (byte)3}));
+ 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");
}
/** Test {@link ByteOrderMark#equals(Object)} */
@SuppressWarnings("EqualsWithItself")
@Test
public void testEquals() {
- assertTrue("test1 equals", TEST_BOM_1.equals(TEST_BOM_1));
- assertTrue("test2 equals", TEST_BOM_2.equals(TEST_BOM_2));
- assertTrue("test3 equals", TEST_BOM_3.equals(TEST_BOM_3));
-
- assertFalse("Object not equal", TEST_BOM_1.equals(new Object()));
- assertFalse("test1-1 not equal", TEST_BOM_1.equals(new ByteOrderMark("1a", 2)));
- assertFalse("test1-2 not test2", TEST_BOM_1.equals(new ByteOrderMark("1b", 1, 2)));
- assertFalse("test2 not equal", TEST_BOM_2.equals(new ByteOrderMark("2", 1, 1)));
- assertFalse("test3 not equal", TEST_BOM_3.equals(new ByteOrderMark("3", 1, 2, 4)));
+ 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");
}
/** Test {@link ByteOrderMark#hashCode()} */
@Test
public void testHashCode() {
final int bomClassHash = ByteOrderMark.class.hashCode();
- assertEquals("hash test1 ", bomClassHash + 1, TEST_BOM_1.hashCode());
- assertEquals("hash test2 ", bomClassHash + 3, TEST_BOM_2.hashCode());
- assertEquals("hash test3 ", bomClassHash + 6, TEST_BOM_3.hashCode());
+ assertEquals(bomClassHash + 1, TEST_BOM_1.hashCode(), "hash test1 ");
+ assertEquals(bomClassHash + 3, TEST_BOM_2.hashCode(), "hash test2 ");
+ assertEquals(bomClassHash + 6, TEST_BOM_3.hashCode(), "hash test3 ");
}
/** Test Errors */
@@ -139,8 +140,8 @@ public class ByteOrderMarkTestCase {
/** Test {@link ByteOrderMark#toString()} */
@Test
public void testToString() {
- assertEquals("test1 ", "ByteOrderMark[test1: 0x1]", TEST_BOM_1.toString());
- assertEquals("test2 ", "ByteOrderMark[test2: 0x1,0x2]", TEST_BOM_2.toString());
- assertEquals("test3 ", "ByteOrderMark[test3: 0x1,0x2,0x3]", TEST_BOM_3.toString());
+ assertEquals("ByteOrderMark[test1: 0x1]", TEST_BOM_1.toString(), "test1 ");
+ assertEquals("ByteOrderMark[test2: 0x1,0x2]", TEST_BOM_2.toString(), "test2 ");
+ assertEquals("ByteOrderMark[test3: 0x1,0x2,0x3]", TEST_BOM_3.toString(), "test3 ");
}
}
diff --git a/src/test/java/org/apache/commons/io/ByteOrderParserTest.java b/src/test/java/org/apache/commons/io/ByteOrderParserTest.java
index a3310d4..268c9c3 100644
--- a/src/test/java/org/apache/commons/io/ByteOrderParserTest.java
+++ b/src/test/java/org/apache/commons/io/ByteOrderParserTest.java
@@ -16,10 +16,12 @@
*/
package org.apache.commons.io;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
import java.nio.ByteOrder;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class ByteOrderParserTest {
@@ -29,16 +31,16 @@ public class ByteOrderParserTest {
@Test
public void testParseBig() {
- Assert.assertEquals(ByteOrder.BIG_ENDIAN, parseByteOrder("BIG_ENDIAN"));
+ assertEquals(ByteOrder.BIG_ENDIAN, parseByteOrder("BIG_ENDIAN"));
}
@Test
public void testParseLittle() {
- Assert.assertEquals(ByteOrder.LITTLE_ENDIAN, parseByteOrder("LITTLE_ENDIAN"));
+ assertEquals(ByteOrder.LITTLE_ENDIAN, parseByteOrder("LITTLE_ENDIAN"));
}
- @Test(expected = IllegalArgumentException.class)
- public void testThrowsException() throws Exception {
- parseByteOrder("some value");
+ @Test
+ public void testThrowsException() {
+ assertThrows(IllegalArgumentException.class, () -> parseByteOrder("some value"));
}
}
diff --git a/src/test/java/org/apache/commons/io/CharsetsTestCase.java b/src/test/java/org/apache/commons/io/CharsetsTestCase.java
index ae6639c..c9687bd 100644
--- a/src/test/java/org/apache/commons/io/CharsetsTestCase.java
+++ b/src/test/java/org/apache/commons/io/CharsetsTestCase.java
@@ -17,11 +17,12 @@
package org.apache.commons.io;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import java.nio.charset.Charset;
import java.util.SortedMap;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Tests {@link Charsets}.
@@ -35,50 +36,50 @@ public class CharsetsTestCase {
final SortedMap<String, Charset> requiredCharsets = Charsets.requiredCharsets();
// test for what we expect to be there as of Java 6
// Make sure the object at the given key is the right one
- Assert.assertEquals(requiredCharsets.get("US-ASCII").name(), "US-ASCII");
- Assert.assertEquals(requiredCharsets.get("ISO-8859-1").name(), "ISO-8859-1");
- Assert.assertEquals(requiredCharsets.get("UTF-8").name(), "UTF-8");
- Assert.assertEquals(requiredCharsets.get("UTF-16").name(), "UTF-16");
- Assert.assertEquals(requiredCharsets.get("UTF-16BE").name(), "UTF-16BE");
- Assert.assertEquals(requiredCharsets.get("UTF-16LE").name(), "UTF-16LE");
+ assertEquals(requiredCharsets.get("US-ASCII").name(), "US-ASCII");
+ assertEquals(requiredCharsets.get("ISO-8859-1").name(), "ISO-8859-1");
+ assertEquals(requiredCharsets.get("UTF-8").name(), "UTF-8");
+ assertEquals(requiredCharsets.get("UTF-16").name(), "UTF-16");
+ assertEquals(requiredCharsets.get("UTF-16BE").name(), "UTF-16BE");
+ assertEquals(requiredCharsets.get("UTF-16LE").name(), "UTF-16LE");
}
@Test
public void testIso8859_1() {
- Assert.assertEquals("ISO-8859-1", Charsets.ISO_8859_1.name());
+ assertEquals("ISO-8859-1", Charsets.ISO_8859_1.name());
}
@Test
public void testToCharset() {
- Assert.assertEquals(Charset.defaultCharset(), Charsets.toCharset((String) null));
- Assert.assertEquals(Charset.defaultCharset(), Charsets.toCharset((Charset) null));
- Assert.assertEquals(Charset.defaultCharset(), Charsets.toCharset(Charset.defaultCharset()));
- Assert.assertEquals(Charset.forName("UTF-8"), Charsets.toCharset(Charset.forName("UTF-8")));
+ assertEquals(Charset.defaultCharset(), Charsets.toCharset((String) null));
+ assertEquals(Charset.defaultCharset(), Charsets.toCharset((Charset) null));
+ assertEquals(Charset.defaultCharset(), Charsets.toCharset(Charset.defaultCharset()));
+ assertEquals(Charset.forName("UTF-8"), Charsets.toCharset(Charset.forName("UTF-8")));
}
@Test
public void testUsAscii() {
- Assert.assertEquals("US-ASCII", Charsets.US_ASCII.name());
+ assertEquals("US-ASCII", Charsets.US_ASCII.name());
}
@Test
public void testUtf16() {
- Assert.assertEquals("UTF-16", Charsets.UTF_16.name());
+ assertEquals("UTF-16", Charsets.UTF_16.name());
}
@Test
public void testUtf16Be() {
- Assert.assertEquals("UTF-16BE", Charsets.UTF_16BE.name());
+ assertEquals("UTF-16BE", Charsets.UTF_16BE.name());
}
@Test
public void testUtf16Le() {
- Assert.assertEquals("UTF-16LE", Charsets.UTF_16LE.name());
+ assertEquals("UTF-16LE", Charsets.UTF_16LE.name());
}
@Test
public void testUtf8() {
- Assert.assertEquals("UTF-8", Charsets.UTF_8.name());
+ assertEquals("UTF-8", Charsets.UTF_8.name());
}
}
diff --git a/src/test/java/org/apache/commons/io/CopyUtilsTest.java b/src/test/java/org/apache/commons/io/CopyUtilsTest.java
index 7b85ae6..59a42ec 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.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
@@ -31,7 +31,7 @@ import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.io.testtools.TestUtils;
import org.apache.commons.io.testtools.YellOnCloseInputStream;
import org.apache.commons.io.testtools.YellOnFlushAndCloseOutputStream;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
@SuppressWarnings("deprecation") // these are test cases for the deprecated CopyUtils
@@ -70,8 +70,8 @@ public class CopyUtilsTest {
CopyUtils.copy(inData, out);
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -83,8 +83,8 @@ public class CopyUtilsTest {
CopyUtils.copy(inData, writer);
writer.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -107,9 +107,9 @@ public class CopyUtilsTest {
final int count = CopyUtils.copy(in, out);
- assertEquals("Not all bytes were read", 0, in.available());
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(0, in.available(), "Not all bytes were read");
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
assertEquals(inData.length, count);
}
@@ -126,9 +126,9 @@ public class CopyUtilsTest {
CopyUtils.copy(in, writer);
writer.flush();
- assertEquals("Not all bytes were read", 0, in.available());
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(0, in.available(), "Not all bytes were read");
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -158,8 +158,8 @@ public class CopyUtilsTest {
// out = fout;
// Note: rely on the method to flush
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
@@ -175,12 +175,9 @@ public class CopyUtilsTest {
final int count = CopyUtils.copy(reader, writer);
writer.flush();
- assertEquals(
- "The number of characters returned by copy is wrong",
- inData.length,
- count);
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ 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");
}
@Test
@@ -198,8 +195,8 @@ public class CopyUtilsTest {
// out = fout;
// note: we don't flush here; this IOUtils method does it for us
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -213,8 +210,8 @@ public class CopyUtilsTest {
CopyUtils.copy(str, writer);
writer.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
} // CopyUtilsTest
diff --git a/src/test/java/org/apache/commons/io/DemuxTestCase.java b/src/test/java/org/apache/commons/io/DemuxTestCase.java
index f0214dd..0dcd857 100644
--- a/src/test/java/org/apache/commons/io/DemuxTestCase.java
+++ b/src/test/java/org/apache/commons/io/DemuxTestCase.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
@@ -30,7 +30,7 @@ import org.apache.commons.io.input.DemuxInputStream;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.io.output.DemuxOutputStream;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Basic unit tests for the multiplexing streams.
@@ -53,14 +53,14 @@ public class DemuxTestCase {
private String getOutput(final String threadName) {
final ByteArrayOutputStream output =
m_outputMap.get(threadName);
- assertNotNull("getOutput()", output);
+ assertNotNull(output, "getOutput()");
return output.toString(StandardCharsets.UTF_8);
}
private String getInput(final String threadName) {
final ReaderThread thread = (ReaderThread) m_threadMap.get(threadName);
- assertNotNull("getInput()", thread);
+ assertNotNull(thread, "getInput()");
return thread.getData();
}
@@ -113,10 +113,10 @@ public class DemuxTestCase {
doStart();
doJoin();
- assertEquals("Data1", DATA1, getOutput(T1));
- assertEquals("Data2", DATA2, getOutput(T2));
- assertEquals("Data3", DATA3, getOutput(T3));
- assertEquals("Data4", DATA4, getOutput(T4));
+ assertEquals(DATA1, getOutput(T1), "Data1");
+ assertEquals(DATA2, getOutput(T2), "Data2");
+ assertEquals(DATA3, getOutput(T3), "Data3");
+ assertEquals(DATA4, getOutput(T4), "Data4");
}
@Test
@@ -131,10 +131,10 @@ public class DemuxTestCase {
doStart();
doJoin();
- assertEquals("Data1", DATA1, getInput(T1));
- assertEquals("Data2", DATA2, getInput(T2));
- assertEquals("Data3", DATA3, getInput(T3));
- assertEquals("Data4", DATA4, getInput(T4));
+ assertEquals(DATA1, getInput(T1), "Data1");
+ assertEquals(DATA2, getInput(T2), "Data2");
+ assertEquals(DATA3, getInput(T3), "Data3");
+ assertEquals(DATA4, getInput(T4), "Data4");
}
private static class ReaderThread
diff --git a/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java b/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java
index 92065db..299d9e7 100644
--- a/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java
+++ b/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java
@@ -16,10 +16,10 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.File;
import java.io.FileFilter;
@@ -32,8 +32,7 @@ import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.NameFileFilter;
import org.apache.commons.io.filefilter.OrFileFilter;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* This is used to test DirectoryWalker for correctness.
@@ -79,8 +78,8 @@ public class DirectoryWalkerTestCase {
@Test
public void testFilter() {
final List<File> results = new TestFileFinder(dirsAndFilesFilter, -1).find(javaDir);
- assertEquals("Result Size", 1 + dirs.length + ioFiles.length + outputFiles.length, results.size());
- assertTrue("Start Dir", results.contains(javaDir));
+ assertEquals(1 + dirs.length + ioFiles.length + outputFiles.length, results.size(), "Result Size");
+ assertTrue(results.contains(javaDir), "Start Dir");
checkContainsFiles("Dir", dirs, results);
checkContainsFiles("IO File", ioFiles, results);
checkContainsFiles("Output File", outputFiles, results);
@@ -92,8 +91,8 @@ public class DirectoryWalkerTestCase {
@Test
public void testFilterAndLimitA() {
final List<File> results = new TestFileFinder(NOT_SVN, 0).find(javaDir);
- assertEquals("[A] Result Size", 1, results.size());
- assertTrue("[A] Start Dir", results.contains(javaDir));
+ assertEquals(1, results.size(), "[A] Result Size");
+ assertTrue(results.contains(javaDir), "[A] Start Dir");
}
/**
@@ -102,9 +101,9 @@ public class DirectoryWalkerTestCase {
@Test
public void testFilterAndLimitB() {
final List<File> results = new TestFileFinder(NOT_SVN, 1).find(javaDir);
- assertEquals("[B] Result Size", 2, results.size());
- assertTrue("[B] Start Dir", results.contains(javaDir));
- assertTrue("[B] Org Dir", results.contains(orgDir));
+ assertEquals(2, results.size(), "[B] Result Size");
+ assertTrue(results.contains(javaDir), "[B] Start Dir");
+ assertTrue(results.contains(orgDir), "[B] Org Dir");
}
/**
@@ -113,11 +112,11 @@ public class DirectoryWalkerTestCase {
@Test
public void testFilterAndLimitC() {
final List<File> results = new TestFileFinder(NOT_SVN, 3).find(javaDir);
- assertEquals("[C] Result Size", 4, results.size());
- assertTrue("[C] Start Dir", results.contains(javaDir));
- assertTrue("[C] Org Dir", results.contains(orgDir));
- assertTrue("[C] Apache Dir", results.contains(apacheDir));
- assertTrue("[C] Commons Dir", results.contains(commonsDir));
+ assertEquals(4, results.size(), "[C] Result Size");
+ assertTrue(results.contains(javaDir), "[C] Start Dir");
+ assertTrue(results.contains(orgDir), "[C] Org Dir");
+ assertTrue(results.contains(apacheDir), "[C] Apache Dir");
+ assertTrue(results.contains(commonsDir), "[C] Commons Dir");
}
/**
@@ -126,8 +125,8 @@ public class DirectoryWalkerTestCase {
@Test
public void testFilterAndLimitD() {
final List<File> results = new TestFileFinder(dirsAndFilesFilter, 5).find(javaDir);
- assertEquals("[D] Result Size", 1 + dirs.length + ioFiles.length, results.size());
- assertTrue("[D] Start Dir", results.contains(javaDir));
+ assertEquals(1 + dirs.length + ioFiles.length, results.size(), "[D] Result Size");
+ assertTrue(results.contains(javaDir), "[D] Start Dir");
checkContainsFiles("[D] Dir", dirs, results);
checkContainsFiles("[D] File", ioFiles, results);
}
@@ -138,8 +137,8 @@ public class DirectoryWalkerTestCase {
@Test
public void testFilterDirAndFile1() {
final List<File> results = new TestFileFinder(dirsFilter, iofilesFilter, -1).find(javaDir);
- assertEquals("[DirAndFile1] Result Size", 1 + dirs.length + ioFiles.length, results.size());
- assertTrue("[DirAndFile1] Start Dir", results.contains(javaDir));
+ assertEquals(1 + dirs.length + ioFiles.length, results.size(), "[DirAndFile1] Result Size");
+ assertTrue(results.contains(javaDir), "[DirAndFile1] Start Dir");
checkContainsFiles("[DirAndFile1] Dir", dirs, results);
checkContainsFiles("[DirAndFile1] File", ioFiles, results);
}
@@ -150,8 +149,8 @@ public class DirectoryWalkerTestCase {
@Test
public void testFilterDirAndFile2() {
final List<File> results = new TestFileFinder(null, null, -1).find(javaDir);
- assertTrue("[DirAndFile2] Result Size", results.size() > 1 + dirs.length + ioFiles.length);
- assertTrue("[DirAndFile2] Start Dir", results.contains(javaDir));
+ assertTrue(results.size() > 1 + dirs.length + ioFiles.length, "[DirAndFile2] Result Size");
+ assertTrue(results.contains(javaDir), "[DirAndFile2] Start Dir");
checkContainsFiles("[DirAndFile2] Dir", dirs, results);
checkContainsFiles("[DirAndFile2] File", ioFiles, results);
}
@@ -163,8 +162,8 @@ public class DirectoryWalkerTestCase {
public void testFilterDirAndFile3() {
final List<File> results = new TestFileFinder(dirsFilter, null, -1).find(javaDir);
final List<File> resultDirs = directoriesOnly(results);
- assertEquals("[DirAndFile3] Result Size", 1 + dirs.length, resultDirs.size());
- assertTrue("[DirAndFile3] Start Dir", results.contains(javaDir));
+ assertEquals(1 + dirs.length, resultDirs.size(), "[DirAndFile3] Result Size");
+ assertTrue(results.contains(javaDir), "[DirAndFile3] Start Dir");
checkContainsFiles("[DirAndFile3] Dir", dirs, resultDirs);
}
@@ -175,8 +174,8 @@ public class DirectoryWalkerTestCase {
public void testFilterDirAndFile4() {
final List<File> results = new TestFileFinder(null, iofilesFilter, -1).find(javaDir);
final List<File> resultFiles = filesOnly(results);
- assertEquals("[DirAndFile4] Result Size", ioFiles.length, resultFiles.size());
- assertTrue("[DirAndFile4] Start Dir", results.contains(javaDir));
+ assertEquals(ioFiles.length, resultFiles.size(), "[DirAndFile4] Result Size");
+ assertTrue(results.contains(javaDir), "[DirAndFile4] Start Dir");
checkContainsFiles("[DirAndFile4] File", ioFiles, resultFiles);
}
@@ -186,8 +185,8 @@ public class DirectoryWalkerTestCase {
@Test
public void testLimitToCurrent() {
final List<File> results = new TestFileFinder(null, 0).find(current);
- assertEquals("Result Size", 1, results.size());
- assertTrue("Current Dir", results.contains(new File(".")));
+ assertEquals(1, results.size(), "Result Size");
+ assertTrue(results.contains(new File(".")), "Current Dir");
}
/**
@@ -199,8 +198,8 @@ public class DirectoryWalkerTestCase {
// TODO is this what we want with invalid directory?
final File invalidDir = new File("invalid-dir");
final List<File> results = new TestFileFinder(null, -1).find(invalidDir);
- assertEquals("Result Size", 1, results.size());
- assertTrue("Current Dir", results.contains(invalidDir));
+ assertEquals(1, results.size(), "Result Size");
+ assertTrue(results.contains(invalidDir), "Current Dir");
try {
new TestFileFinder(null, -1).find(null);
@@ -217,7 +216,7 @@ public class DirectoryWalkerTestCase {
public void testHandleStartDirectoryFalse() {
final List<File> results = new TestFalseFileFinder(null, -1).find(current);
- assertEquals("Result Size", 0, results.size());
+ assertEquals(0, results.size(), "Result Size");
}
@@ -228,13 +227,13 @@ public class DirectoryWalkerTestCase {
*/
private void checkContainsFiles(final String prefix, final File[] files, final Collection<File> results) {
for (int i = 0; i < files.length; i++) {
- assertTrue(prefix + "["+i+"] " + files[i], results.contains(files[i]));
+ assertTrue(results.contains(files[i]), prefix + "["+i+"] " + files[i]);
}
}
private void checkContainsString(final String prefix, final File[] files, final Collection<String> results) {
for (int i = 0; i < files.length; i++) {
- assertTrue(prefix + "["+i+"] " + files[i], results.contains(files[i].toString()));
+ assertTrue(results.contains(files[i].toString()), prefix + "["+i+"] " + files[i]);
}
}
@@ -289,8 +288,8 @@ public class DirectoryWalkerTestCase {
new TestCancelWalker(cancelName, false).find(javaDir);
fail("CancelException not thrown for '" + cancelName + "'");
} catch (final DirectoryWalker.CancelException cancel) {
- assertEquals("File: " + cancelName, cancelName, cancel.getFile().getName());
- assertEquals("Depth: " + cancelName, 5, cancel.getDepth());
+ assertEquals(cancelName, cancel.getFile().getName(), "File: " + cancelName);
+ assertEquals(5, cancel.getDepth(), "Depth: " + cancelName);
} catch(final IOException ex) {
fail("IOException: " + cancelName + " " + ex);
}
@@ -301,8 +300,8 @@ public class DirectoryWalkerTestCase {
new TestCancelWalker(cancelName, false).find(javaDir);
fail("CancelException not thrown for '" + cancelName + "'");
} catch (final DirectoryWalker.CancelException cancel) {
- assertEquals("File: " + cancelName, cancelName, cancel.getFile().getName());
- assertEquals("Depth: " + cancelName, 3, cancel.getDepth());
+ assertEquals(cancelName, cancel.getFile().getName(), "File: " + cancelName);
+ assertEquals(3, cancel.getDepth(), "Depth: " + cancelName);
} catch(final IOException ex) {
fail("IOException: " + cancelName + " " + ex);
}
@@ -311,7 +310,7 @@ public class DirectoryWalkerTestCase {
try {
final List<File> results = new TestCancelWalker(cancelName, true).find(javaDir);
final File lastFile = results.get(results.size() - 1);
- assertEquals("Suppress: " + cancelName, cancelName, lastFile.getName());
+ assertEquals(cancelName, lastFile.getName(), "Suppress: " + cancelName);
} catch(final IOException ex) {
fail("Suppress threw " + ex);
}
@@ -332,7 +331,7 @@ public class DirectoryWalkerTestCase {
} catch (final DirectoryWalker.CancelException cancel) {
final File last = walker.results.get(walker.results.size() - 1);
assertEquals(cancelName, last.getName());
- assertEquals("Depth: " + cancelName, 5, cancel.getDepth());
+ assertEquals(5, cancel.getDepth(), "Depth: " + cancelName);
} catch(final IOException ex) {
fail("IOException: " + cancelName + " " + ex);
}
@@ -344,8 +343,8 @@ public class DirectoryWalkerTestCase {
walker.find(javaDir);
fail("CancelException not thrown for '" + cancelName + "'");
} catch (final DirectoryWalker.CancelException cancel) {
- assertEquals("File: " + cancelName, cancelName, cancel.getFile().getName());
- assertEquals("Depth: " + cancelName, 3, cancel.getDepth());
+ assertEquals(cancelName, cancel.getFile().getName(), "File: " + cancelName);
+ assertEquals(3, cancel.getDepth(), "Depth: " + cancelName);
} catch(final IOException ex) {
fail("IOException: " + cancelName + " " + ex);
}
@@ -355,7 +354,7 @@ public class DirectoryWalkerTestCase {
walker = new TestMultiThreadCancelWalker(cancelName, true);
final List<File> results = walker.find(javaDir);
final File lastFile = results.get(results.size() - 1);
- assertEquals("Suppress: " + cancelName, cancelName, lastFile.getName());
+ assertEquals(cancelName, lastFile.getName(), "Suppress: " + cancelName);
} catch(final IOException ex) {
fail("Suppress threw " + ex);
}
@@ -368,7 +367,7 @@ public class DirectoryWalkerTestCase {
@Test
public void testFilterString() {
final List<String> results = new TestFileFinderString(dirsAndFilesFilter, -1).find(javaDir);
- assertEquals("Result Size", outputFiles.length + ioFiles.length, results.size());
+ assertEquals(results.size(), outputFiles.length + ioFiles.length, "Result Size");
checkContainsString("IO File", ioFiles, results);
checkContainsString("Output File", outputFiles, results);
}
@@ -395,7 +394,7 @@ public class DirectoryWalkerTestCase {
try {
walk(startDirectory, results);
} catch(final IOException ex) {
- Assert.fail(ex.toString());
+ fail(ex.toString());
}
return results;
}
@@ -558,7 +557,7 @@ public class DirectoryWalkerTestCase {
try {
walk(startDirectory, results);
} catch(final IOException ex) {
- Assert.fail(ex.toString());
+ fail(ex.toString());
}
return results;
}
diff --git a/src/test/java/org/apache/commons/io/DirectoryWalkerTestCaseJava4.java b/src/test/java/org/apache/commons/io/DirectoryWalkerTestCaseJava4.java
index e2dab3b..dc32859 100644
--- a/src/test/java/org/apache/commons/io/DirectoryWalkerTestCaseJava4.java
+++ b/src/test/java/org/apache/commons/io/DirectoryWalkerTestCaseJava4.java
@@ -16,10 +16,10 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.File;
import java.io.FileFilter;
@@ -32,7 +32,7 @@ import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.NameFileFilter;
import org.apache.commons.io.filefilter.OrFileFilter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* This is used to test DirectoryWalker for correctness when using Java4 (i.e. no generics).
@@ -78,8 +78,8 @@ public class DirectoryWalkerTestCaseJava4 {
@Test
public void testFilter() {
final List<File> results = new TestFileFinder(dirsAndFilesFilter, -1).find(javaDir);
- assertEquals("Result Size", 1 + dirs.length + ioFiles.length + outputFiles.length, results.size());
- assertTrue("Start Dir", results.contains(javaDir));
+ assertEquals(1 + dirs.length + ioFiles.length + outputFiles.length, results.size(), "Result Size");
+ assertTrue(results.contains(javaDir), "Start Dir");
checkContainsFiles("Dir", dirs, results);
checkContainsFiles("IO File", ioFiles, results);
checkContainsFiles("Output File", outputFiles, results);
@@ -91,8 +91,8 @@ public class DirectoryWalkerTestCaseJava4 {
@Test
public void testFilterAndLimitA() {
final List<File> results = new TestFileFinder(NOT_SVN, 0).find(javaDir);
- assertEquals("[A] Result Size", 1, results.size());
- assertTrue("[A] Start Dir", results.contains(javaDir));
+ assertEquals(1, results.size(), "[A] Result Size");
+ assertTrue(results.contains(javaDir), "[A] Start Dir");
}
/**
@@ -101,9 +101,9 @@ public class DirectoryWalkerTestCaseJava4 {
@Test
public void testFilterAndLimitB() {
final List<File> results = new TestFileFinder(NOT_SVN, 1).find(javaDir);
- assertEquals("[B] Result Size", 2, results.size());
- assertTrue("[B] Start Dir", results.contains(javaDir));
- assertTrue("[B] Org Dir", results.contains(orgDir));
+ assertEquals(2, results.size(), "[B] Result Size");
+ assertTrue(results.contains(javaDir), "[B] Start Dir");
+ assertTrue(results.contains(orgDir), "[B] Org Dir");
}
/**
@@ -112,11 +112,11 @@ public class DirectoryWalkerTestCaseJava4 {
@Test
public void testFilterAndLimitC() {
final List<File> results = new TestFileFinder(NOT_SVN, 3).find(javaDir);
- assertEquals("[C] Result Size", 4, results.size());
- assertTrue("[C] Start Dir", results.contains(javaDir));
- assertTrue("[C] Org Dir", results.contains(orgDir));
- assertTrue("[C] Apache Dir", results.contains(apacheDir));
- assertTrue("[C] Commons Dir", results.contains(commonsDir));
+ assertEquals(4, results.size(), "[C] Result Size");
+ assertTrue(results.contains(javaDir), "[C] Start Dir");
+ assertTrue(results.contains(orgDir), "[C] Org Dir");
+ assertTrue(results.contains(apacheDir), "[C] Apache Dir");
+ assertTrue(results.contains(commonsDir), "[C] Commons Dir");
}
/**
@@ -125,8 +125,8 @@ public class DirectoryWalkerTestCaseJava4 {
@Test
public void testFilterAndLimitD() {
final List<File> results = new TestFileFinder(dirsAndFilesFilter, 5).find(javaDir);
- assertEquals("[D] Result Size", 1 + dirs.length + ioFiles.length, results.size());
- assertTrue("[D] Start Dir", results.contains(javaDir));
+ assertEquals(1 + dirs.length + ioFiles.length, results.size(), "[D] Result Size");
+ assertTrue(results.contains(javaDir), "[D] Start Dir");
checkContainsFiles("[D] Dir", dirs, results);
checkContainsFiles("[D] File", ioFiles, results);
}
@@ -137,8 +137,8 @@ public class DirectoryWalkerTestCaseJava4 {
@Test
public void testFilterDirAndFile1() {
final List<File> results = new TestFileFinder(dirsFilter, iofilesFilter, -1).find(javaDir);
- assertEquals("[DirAndFile1] Result Size", 1 + dirs.length + ioFiles.length, results.size());
- assertTrue("[DirAndFile1] Start Dir", results.contains(javaDir));
+ assertEquals(1 + dirs.length + ioFiles.length, results.size(), "[DirAndFile1] Result Size");
+ assertTrue(results.contains(javaDir), "[DirAndFile1] Start Dir");
checkContainsFiles("[DirAndFile1] Dir", dirs, results);
checkContainsFiles("[DirAndFile1] File", ioFiles, results);
}
@@ -149,8 +149,8 @@ public class DirectoryWalkerTestCaseJava4 {
@Test
public void testFilterDirAndFile2() {
final List<File> results = new TestFileFinder(null, null, -1).find(javaDir);
- assertTrue("[DirAndFile2] Result Size", results.size() > 1 + dirs.length + ioFiles.length);
- assertTrue("[DirAndFile2] Start Dir", results.contains(javaDir));
+ assertTrue(results.size() > 1 + dirs.length + ioFiles.length, "[DirAndFile2] Result Size");
+ assertTrue(results.contains(javaDir), "[DirAndFile2] Start Dir");
checkContainsFiles("[DirAndFile2] Dir", dirs, results);
checkContainsFiles("[DirAndFile2] File", ioFiles, results);
}
@@ -162,8 +162,8 @@ public class DirectoryWalkerTestCaseJava4 {
public void testFilterDirAndFile3() {
final List<File> results = new TestFileFinder(dirsFilter, null, -1).find(javaDir);
final List resultDirs = directoriesOnly(results);
- assertEquals("[DirAndFile3] Result Size", 1 + dirs.length, resultDirs.size());
- assertTrue("[DirAndFile3] Start Dir", results.contains(javaDir));
+ assertEquals(1 + dirs.length, resultDirs.size(), "[DirAndFile3] Result Size");
+ assertTrue(results.contains(javaDir), "[DirAndFile3] Start Dir");
checkContainsFiles("[DirAndFile3] Dir", dirs, resultDirs);
}
@@ -174,8 +174,8 @@ public class DirectoryWalkerTestCaseJava4 {
public void testFilterDirAndFile4() {
final List<File> results = new TestFileFinder(null, iofilesFilter, -1).find(javaDir);
final List resultFiles = filesOnly(results);
- assertEquals("[DirAndFile4] Result Size", ioFiles.length, resultFiles.size());
- assertTrue("[DirAndFile4] Start Dir", results.contains(javaDir));
+ assertEquals(ioFiles.length, resultFiles.size(), "[DirAndFile4] Result Size");
+ assertTrue(results.contains(javaDir), "[DirAndFile4] Start Dir");
checkContainsFiles("[DirAndFile4] File", ioFiles, resultFiles);
}
@@ -185,8 +185,8 @@ public class DirectoryWalkerTestCaseJava4 {
@Test
public void testLimitToCurrent() {
final List<File> results = new TestFileFinder(null, 0).find(current);
- assertEquals("Result Size", 1, results.size());
- assertTrue("Current Dir", results.contains(new File(".")));
+ assertEquals(1, results.size(), "Result Size");
+ assertTrue(results.contains(new File(".")), "Current Dir");
}
/**
@@ -198,8 +198,8 @@ public class DirectoryWalkerTestCaseJava4 {
// TODO is this what we want with invalid directory?
final File invalidDir = new File("invalid-dir");
final List<File> results = new TestFileFinder(null, -1).find(invalidDir);
- assertEquals("Result Size", 1, results.size());
- assertTrue("Current Dir", results.contains(invalidDir));
+ assertEquals(1, results.size(), "Result Size");
+ assertTrue(results.contains(invalidDir), "Current Dir");
try {
new TestFileFinder(null, -1).find(null);
@@ -216,7 +216,7 @@ public class DirectoryWalkerTestCaseJava4 {
public void testHandleStartDirectoryFalse() {
final List<File> results = new TestFalseFileFinder(null, -1).find(current);
- assertEquals("Result Size", 0, results.size());
+ assertEquals(0, results.size(), "Result Size");
}
@@ -227,7 +227,7 @@ public class DirectoryWalkerTestCaseJava4 {
*/
private void checkContainsFiles(final String prefix, final File[] files, final Collection results) {
for (int i = 0; i < files.length; i++) {
- assertTrue(prefix + "[" + i + "] " + files[i], results.contains(files[i]));
+ assertTrue(results.contains(files[i]), prefix + "[" + i + "] " + files[i]);
}
}
@@ -283,8 +283,8 @@ public class DirectoryWalkerTestCaseJava4 {
new TestCancelWalker(cancelName, false).find(javaDir);
fail("CancelException not thrown for '" + cancelName + "'");
} catch (final DirectoryWalker.CancelException cancel) {
- assertEquals("File: " + cancelName, cancelName, cancel.getFile().getName());
- assertEquals("Depth: " + cancelName, 5, cancel.getDepth());
+ assertEquals(cancelName, cancel.getFile().getName(), "File: " + cancelName);
+ assertEquals(5, cancel.getDepth(), "Depth: " + cancelName);
}
// Cancel on a directory
@@ -293,14 +293,14 @@ public class DirectoryWalkerTestCaseJava4 {
new TestCancelWalker(cancelName, false).find(javaDir);
fail("CancelException not thrown for '" + cancelName + "'");
} catch (final DirectoryWalker.CancelException cancel) {
- assertEquals("File: " + cancelName, cancelName, cancel.getFile().getName());
- assertEquals("Depth: " + cancelName, 3, cancel.getDepth());
+ assertEquals(cancelName, cancel.getFile().getName(), "File: " + cancelName);
+ assertEquals(3, cancel.getDepth(), "Depth: " + cancelName);
}
// Suppress CancelException (use same file name as preceding test)
final List results = new TestCancelWalker(cancelName, true).find(javaDir);
final File lastFile = (File) results.get(results.size() - 1);
- assertEquals("Suppress: " + cancelName, cancelName, lastFile.getName());
+ assertEquals(cancelName, lastFile.getName(), "Suppress: " + cancelName);
}
/**
@@ -318,7 +318,7 @@ public class DirectoryWalkerTestCaseJava4 {
} catch (final DirectoryWalker.CancelException cancel) {
final File last = (File) walker.results.get(walker.results.size() - 1);
assertEquals(cancelName, last.getName());
- assertEquals("Depth: " + cancelName, 5, cancel.getDepth());
+ assertEquals(5, cancel.getDepth(), "Depth: " + cancelName);
}
// Cancel on a directory
@@ -328,15 +328,15 @@ public class DirectoryWalkerTestCaseJava4 {
walker.find(javaDir);
fail("CancelException not thrown for '" + cancelName + "'");
} catch (final DirectoryWalker.CancelException cancel) {
- assertEquals("File: " + cancelName, cancelName, cancel.getFile().getName());
- assertEquals("Depth: " + cancelName, 3, cancel.getDepth());
+ assertEquals(cancelName, cancel.getFile().getName(), "File: " + cancelName);
+ assertEquals(3, cancel.getDepth(), "Depth: " + cancelName);
}
// Suppress CancelException (use same file name as preceding test)
walker = new TestMultiThreadCancelWalker(cancelName, true);
final List results = walker.find(javaDir);
final File lastFile = (File) results.get(results.size() - 1);
- assertEquals("Suppress: " + cancelName, cancelName, lastFile.getName());
+ assertEquals(cancelName, lastFile.getName(), "Suppress: " + cancelName);
}
diff --git a/src/test/java/org/apache/commons/io/EndianUtilsTest.java b/src/test/java/org/apache/commons/io/EndianUtilsTest.java
index 36ca587..4391001 100644
--- a/src/test/java/org/apache/commons/io/EndianUtilsTest.java
+++ b/src/test/java/org/apache/commons/io/EndianUtilsTest.java
@@ -16,15 +16,15 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.IOException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
*
@@ -306,11 +306,11 @@ public class EndianUtilsTest {
final long expected = 0x80000000L;
long actual = EndianUtils.readSwappedUnsignedInteger(target, 0);
- assertEquals("readSwappedUnsignedInteger(byte[], int) was incorrect", expected, actual);
+ assertEquals(expected, actual, "readSwappedUnsignedInteger(byte[], int) was incorrect");
final ByteArrayInputStream in = new ByteArrayInputStream(target);
actual = EndianUtils.readSwappedUnsignedInteger(in);
- assertEquals("readSwappedUnsignedInteger(InputStream) was incorrect", expected, actual);
+ assertEquals(expected, actual, "readSwappedUnsignedInteger(InputStream) was incorrect");
}
}
diff --git a/src/test/java/org/apache/commons/io/FileCleaningTrackerTestCase.java b/src/test/java/org/apache/commons/io/FileCleaningTrackerTestCase.java
index 72d2d6f..8f868b6 100644
--- a/src/test/java/org/apache/commons/io/FileCleaningTrackerTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileCleaningTrackerTestCase.java
@@ -16,10 +16,10 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.BufferedOutputStream;
import java.io.File;
@@ -31,11 +31,10 @@ import java.util.ArrayList;
import java.util.List;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* This is used to test {@link FileCleaningTracker} for correctness.
@@ -44,12 +43,8 @@ import org.junit.rules.TemporaryFolder;
*/
public class FileCleaningTrackerTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public File temporaryFolder;
protected FileCleaningTracker newInstance() {
return new FileCleaningTracker();
@@ -58,13 +53,13 @@ public class FileCleaningTrackerTestCase {
private File testFile;
private FileCleaningTracker theInstance;
- @Before
+ @BeforeEach
public void setUp() throws Exception {
- testFile = new File(getTestDirectory(), "file-test.txt");
+ testFile = new File(temporaryFolder, "file-test.txt");
theInstance = newInstance();
}
- @After
+ @AfterEach
public void tearDown() throws Exception {
// reset file cleaner class, so as not to break other tests
@@ -108,18 +103,18 @@ public class FileCleaningTrackerTestCase {
pauseForDeleteToComplete(new File(path));
assertEquals(0, theInstance.getTrackCount());
- assertEquals(showFailures(), false, new File(path).exists());
+ assertEquals(false, new File(path).exists(), showFailures());
}
@Test
public void testFileCleanerDirectory() throws Exception {
TestUtils.createFile(testFile, 100);
assertTrue(testFile.exists());
- assertTrue(getTestDirectory().exists());
+ assertTrue(temporaryFolder.exists());
Object obj = new Object();
assertEquals(0, theInstance.getTrackCount());
- theInstance.track(getTestDirectory(), obj);
+ theInstance.track(temporaryFolder, obj);
assertEquals(1, theInstance.getTrackCount());
obj = null;
@@ -135,11 +130,11 @@ public class FileCleaningTrackerTestCase {
public void testFileCleanerDirectory_NullStrategy() throws Exception {
TestUtils.createFile(testFile, 100);
assertTrue(testFile.exists());
- assertTrue(getTestDirectory().exists());
+ assertTrue(temporaryFolder.exists());
Object obj = new Object();
assertEquals(0, theInstance.getTrackCount());
- theInstance.track(getTestDirectory(), obj, null);
+ theInstance.track(temporaryFolder, obj, null);
assertEquals(1, theInstance.getTrackCount());
obj = null;
@@ -162,11 +157,11 @@ public class FileCleaningTrackerTestCase {
TestUtils.generateTestData(output, 100);
}
assertTrue(testFile.exists());
- assertTrue(getTestDirectory().exists());
+ assertTrue(temporaryFolder.exists());
Object obj = new Object();
assertEquals(0, theInstance.getTrackCount());
- theInstance.track(getTestDirectory(), obj, FileDeleteStrategy.FORCE);
+ theInstance.track(temporaryFolder, obj, FileDeleteStrategy.FORCE);
assertEquals(1, theInstance.getTrackCount());
obj = null;
@@ -175,8 +170,8 @@ public class FileCleaningTrackerTestCase {
pauseForDeleteToComplete(testFile.getParentFile());
assertEquals(0, theInstance.getTrackCount());
- assertEquals(showFailures(), false, new File(testFile.getPath()).exists());
- assertEquals(showFailures(), false, testFile.getParentFile().exists());
+ assertEquals(false, new File(testFile.getPath()).exists(), showFailures());
+ assertEquals(false, testFile.getParentFile().exists(), showFailures());
}
@Test
@@ -244,20 +239,20 @@ public class FileCleaningTrackerTestCase {
public void testFileCleanerExitWhenFinished1() throws Exception {
final String path = testFile.getPath();
- assertEquals("1-testFile exists: " + testFile, false, testFile.exists());
+ assertEquals(false, testFile.exists(), "1-testFile exists: " + testFile);
RandomAccessFile r = new RandomAccessFile(testFile, "rw");
- assertEquals("2-testFile exists", true, testFile.exists());
+ assertEquals(true, testFile.exists(), "2-testFile exists");
- assertEquals("3-Track Count", 0, theInstance.getTrackCount());
+ assertEquals(0, theInstance.getTrackCount(), "3-Track Count");
theInstance.track(path, r);
- assertEquals("4-Track Count", 1, theInstance.getTrackCount());
- assertEquals("5-exitWhenFinished", false, theInstance.exitWhenFinished);
- assertEquals("6-reaper.isAlive", true, theInstance.reaper.isAlive());
+ assertEquals(1, theInstance.getTrackCount(), "4-Track Count");
+ assertEquals(false, theInstance.exitWhenFinished, "5-exitWhenFinished");
+ assertEquals(true, theInstance.reaper.isAlive(), "6-reaper.isAlive");
- assertEquals("7-exitWhenFinished", false, theInstance.exitWhenFinished);
+ assertEquals(false, theInstance.exitWhenFinished, "7-exitWhenFinished");
theInstance.exitWhenFinished();
- assertEquals("8-exitWhenFinished", true, theInstance.exitWhenFinished);
- assertEquals("9-reaper.isAlive", true, theInstance.reaper.isAlive());
+ assertEquals(true, theInstance.exitWhenFinished, "8-exitWhenFinished");
+ assertEquals(true, theInstance.reaper.isAlive(), "9-reaper.isAlive");
r.close();
testFile = null;
@@ -266,10 +261,10 @@ public class FileCleaningTrackerTestCase {
waitUntilTrackCount();
pauseForDeleteToComplete(new File(path));
- assertEquals("10-Track Count", 0, theInstance.getTrackCount());
- assertEquals("11-testFile exists " + showFailures(), false, new File(path).exists());
- assertEquals("12-exitWhenFinished", true, theInstance.exitWhenFinished);
- assertEquals("13-reaper.isAlive", false, theInstance.reaper.isAlive());
+ 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");
}
@Test
@@ -294,7 +289,7 @@ public class FileCleaningTrackerTestCase {
pauseForDeleteToComplete(new File(path));
assertEquals(0, theInstance.getTrackCount());
- assertEquals(showFailures(), false, new File(path).exists());
+ assertEquals(false, new File(path).exists(), showFailures());
assertFalse(theInstance.exitWhenFinished);
assertTrue(theInstance.reaper.isAlive());
diff --git a/src/test/java/org/apache/commons/io/FileDeleteStrategyTestCase.java b/src/test/java/org/apache/commons/io/FileDeleteStrategyTestCase.java
index 08c378e..91db343 100644
--- a/src/test/java/org/apache/commons/io/FileDeleteStrategyTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileDeleteStrategyTestCase.java
@@ -16,10 +16,10 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.BufferedOutputStream;
import java.io.File;
@@ -27,10 +27,8 @@ import java.io.FileOutputStream;
import java.io.IOException;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* Test for FileDeleteStrategy.
*
@@ -38,17 +36,13 @@ import org.junit.rules.TemporaryFolder;
*/
public class FileDeleteStrategyTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public File temporaryFolder;
//-----------------------------------------------------------------------
@Test
public void testDeleteNormal() throws Exception {
- final File baseDir = getTestDirectory();
+ final File baseDir = temporaryFolder;
final File subDir = new File(baseDir, "test");
assertTrue(subDir.mkdir());
final File subFile = new File(subDir, "a.txt");
@@ -86,7 +80,7 @@ public class FileDeleteStrategyTestCase {
@Test
public void testDeleteQuietlyNormal() throws Exception {
- final File baseDir = getTestDirectory();
+ final File baseDir = temporaryFolder;
final File subDir = new File(baseDir, "test");
assertTrue(subDir.mkdir());
final File subFile = new File(subDir, "a.txt");
@@ -119,7 +113,7 @@ public class FileDeleteStrategyTestCase {
@Test
public void testDeleteForce() throws Exception {
- final File baseDir = getTestDirectory();
+ final File baseDir = temporaryFolder;
final File subDir = new File(baseDir, "test");
assertTrue(subDir.mkdir());
final File subFile = new File(subDir, "a.txt");
diff --git a/src/test/java/org/apache/commons/io/FileSystemTestCase.java b/src/test/java/org/apache/commons/io/FileSystemTestCase.java
index 9656711..cdf83d5 100644
--- a/src/test/java/org/apache/commons/io/FileSystemTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileSystemTestCase.java
@@ -17,8 +17,11 @@
package org.apache.commons.io;
-import org.junit.Assert;
-import org.junit.Test;
+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 org.junit.jupiter.api.Test;
public class FileSystemTestCase {
@@ -27,7 +30,7 @@ public class FileSystemTestCase {
for (final FileSystem fs : FileSystem.values()) {
final char[] chars = fs.getIllegalFileNameChars();
for (int i = 0; i < chars.length - 1; i++) {
- Assert.assertTrue(fs.name(), chars[i] < chars[i + 1]);
+ assertTrue(chars[i] < chars[i + 1], fs.name());
}
}
}
@@ -37,33 +40,33 @@ public class FileSystemTestCase {
final FileSystem fs = FileSystem.WINDOWS;
final char replacement = '-';
for (char i = 0; i < 32; i++) {
- Assert.assertEquals(replacement, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
+ assertEquals(replacement, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
}
final char[] illegal = new char[] { '<', '>', ':', '"', '/', '\\', '|', '?', '*' };
for (char i = 0; i < illegal.length; i++) {
- Assert.assertEquals(replacement, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
+ assertEquals(replacement, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
}
for (char i = 'a'; i < 'z'; i++) {
- Assert.assertEquals(i, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
+ assertEquals(i, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
}
for (char i = 'A'; i < 'Z'; i++) {
- Assert.assertEquals(i, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
+ assertEquals(i, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
}
for (char i = '0'; i < '9'; i++) {
- Assert.assertEquals(i, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
+ assertEquals(i, fs.toLegalFileName(String.valueOf(i), replacement).charAt(0));
}
}
@Test
public void testIsLegalName() {
for (final FileSystem fs : FileSystem.values()) {
- Assert.assertFalse(fs.name(), fs.isLegalFileName("")); // Empty is always illegal
- Assert.assertFalse(fs.name(), fs.isLegalFileName(null)); // null is always illegal
- Assert.assertFalse(fs.name(), fs.isLegalFileName("\0")); // Assume NUL is always illegal
- Assert.assertTrue(fs.name(), fs.isLegalFileName("0")); // Assume simple name always legal
+ assertFalse(fs.isLegalFileName(""), fs.name()); // Empty is always illegal
+ assertFalse(fs.isLegalFileName(null), fs.name()); // null is always illegal
+ assertFalse(fs.isLegalFileName("\0"), fs.name()); // Assume NUL is always illegal
+ assertTrue(fs.isLegalFileName("0"), fs.name()); // Assume simple name always legal
for (final String candidate : fs.getReservedFileNames()) {
// Reserved file names are not legal
- Assert.assertFalse(fs.isLegalFileName(candidate));
+ assertFalse(fs.isLegalFileName(candidate));
}
}
}
@@ -72,7 +75,7 @@ public class FileSystemTestCase {
public void testIsReservedFileName() {
for (final FileSystem fs : FileSystem.values()) {
for (final String candidate : fs.getReservedFileNames()) {
- Assert.assertTrue(fs.isReservedFileName(candidate));
+ assertTrue(fs.isReservedFileName(candidate));
}
}
}
@@ -83,7 +86,7 @@ public class FileSystemTestCase {
try {
fs.toLegalFileName("Test", '\0'); // Assume NUL is always illegal
} catch (final IllegalArgumentException iae) {
- Assert.assertTrue(iae.getMessage(), iae.getMessage().startsWith("The replacement character '\\0'"));
+ assertTrue(iae.getMessage().startsWith("The replacement character '\\0'"), iae.getMessage());
}
}
}
diff --git a/src/test/java/org/apache/commons/io/FileSystemUtilsTestCase.java b/src/test/java/org/apache/commons/io/FileSystemUtilsTestCase.java
index c78ae0f..07ef715 100644
--- a/src/test/java/org/apache/commons/io/FileSystemUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileSystemUtilsTestCase.java
@@ -16,8 +16,10 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
@@ -28,8 +30,7 @@ import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.Locale;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* This is used to test FileSystemUtils.
@@ -60,7 +61,7 @@ public class FileSystemUtilsTestCase {
boolean kilobyteBlock = true;
try (BufferedReader r = new BufferedReader(new InputStreamReader(proc.getInputStream()))){
final String line = r.readLine();
- Assert.assertNotNull("Unexpected null line", line);
+ assertNotNull("Unexpected null line", line);
if (line.contains("512")) {
kilobyteBlock = false;
}
@@ -303,22 +304,22 @@ public class FileSystemUtilsTestCase {
}
}
- @Test(expected = IOException.class)
- public void testGetFreeSpaceWindows_String_EmptyMultiLineResponse() throws Exception {
+ @Test
+ public void testGetFreeSpaceWindows_String_EmptyMultiLineResponse() {
final String lines = "\n\n";
final FileSystemUtils fsu = new MockFileSystemUtils(0, lines);
- fsu.freeSpaceWindows("C:", -1);
+ assertThrows(IOException.class, () -> fsu.freeSpaceWindows("C:", -1));
}
- @Test(expected = IOException.class)
- public void testGetFreeSpaceWindows_String_InvalidTextResponse() throws Exception {
+ @Test
+ public void testGetFreeSpaceWindows_String_InvalidTextResponse() {
final String lines = "BlueScreenOfDeath";
final FileSystemUtils fsu = new MockFileSystemUtils(0, lines);
- fsu.freeSpaceWindows("C:", -1);
+ assertThrows(IOException.class, () -> fsu.freeSpaceWindows("C:", -1));
}
- @Test(expected = IOException.class)
- public void testGetFreeSpaceWindows_String_NoSuchDirectoryResponse() throws Exception {
+ @Test
+ public void testGetFreeSpaceWindows_String_NoSuchDirectoryResponse() {
final String lines =
" Volume in drive C is HDD\n" +
" Volume Serial Number is XXXX-YYYY\n" +
@@ -326,7 +327,7 @@ public class FileSystemUtilsTestCase {
" Directory of C:\\Documents and Settings\\empty" +
"\n";
final FileSystemUtils fsu = new MockFileSystemUtils(1, lines);
- fsu.freeSpaceWindows("C:", -1);
+ assertThrows(IOException.class, () -> fsu.freeSpaceWindows("C:", -1));
}
//-----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/io/FileUtilsCleanDirectoryTestCase.java b/src/test/java/org/apache/commons/io/FileUtilsCleanDirectoryTestCase.java
index f8966d8..2586da3 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsCleanDirectoryTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsCleanDirectoryTestCase.java
@@ -16,19 +16,20 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+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 static org.junit.jupiter.api.Assumptions.assumeTrue;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledOnOs;
+import org.junit.jupiter.api.condition.OS;
+import org.junit.jupiter.api.io.TempDir;
/**
* Test cases for FileUtils.cleanDirectory() method.
@@ -36,15 +37,8 @@ import org.junit.rules.TemporaryFolder;
*/
public class FileUtilsCleanDirectoryTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File top;
-
- @Before
- public void setUp() throws Exception {
- top = temporaryFolder.getRoot();
- }
+ @TempDir
+ public File top;
//-----------------------------------------------------------------------
@Test
@@ -83,13 +77,12 @@ public class FileUtilsCleanDirectoryTestCase {
assertEquals(0, top.list().length);
}
+ @DisabledOnOs(OS.WINDOWS)
@Test
public void testThrowsOnNullList() throws Exception {
- if (System.getProperty("os.name").startsWith("Win") || !chmod(top, 0, false)) {
- // test wont work if we can't restrict permissions on the
- // directory, so skip it.
- return;
- }
+ // test wont work if we can't restrict permissions on the
+ // directory, so skip it.
+ assumeTrue(chmod(top, 0, false));
try {
FileUtils.cleanDirectory(top);
@@ -97,19 +90,18 @@ public class FileUtilsCleanDirectoryTestCase {
} catch (final IOException e) {
assertEquals("Failed to list contents of " +
top.getAbsolutePath(), e.getMessage());
+ } finally {
+ chmod(top, 755, false);
}
}
+ @DisabledOnOs(OS.WINDOWS)
@Test
public void testThrowsOnCannotDeleteFile() throws Exception {
final File file = new File(top, "restricted");
FileUtils.touch(file);
- if (System.getProperty("os.name").startsWith("Win") || !chmod(top, 500, false)) {
- // test wont work if we can't restrict permissions on the
- // directory, so skip it.
- return;
- }
+ assumeTrue(chmod(top, 500, false));
try {
FileUtils.cleanDirectory(top);
@@ -117,6 +109,8 @@ public class FileUtilsCleanDirectoryTestCase {
} catch (final IOException e) {
assertEquals("Unable to delete file: " +
file.getAbsolutePath(), e.getMessage());
+ } finally {
+ chmod(top, 755, false);
}
}
diff --git a/src/test/java/org/apache/commons/io/FileUtilsCleanSymlinksTestCase.java b/src/test/java/org/apache/commons/io/FileUtilsCleanSymlinksTestCase.java
index be1945b..1e5fb13 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsCleanSymlinksTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsCleanSymlinksTestCase.java
@@ -16,18 +16,16 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+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;
import java.util.ArrayList;
import java.util.List;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* Test cases for FileUtils.cleanDirectory() method that involve symlinks.
@@ -35,15 +33,8 @@ import org.junit.rules.TemporaryFolder;
*/
public class FileUtilsCleanSymlinksTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File top;
-
- @Before
- public void setUp() throws Exception {
- top = temporaryFolder.getRoot();
- }
+ @TempDir
+ public File top;
@Test
public void testCleanDirWithSymlinkFile() throws Exception {
@@ -112,7 +103,7 @@ public class FileUtilsCleanSymlinksTestCase {
assertEquals(0, realOuter.list().length);
// ensure that the contents of the symlink were NOT removed.
- assertEquals("Contents of sym link should not have been removed", 1, randomDirectory.list().length);
+ assertEquals(1, randomDirectory.list().length, "Contents of sym link should not have been removed");
}
@Test
@@ -151,7 +142,7 @@ public class FileUtilsCleanSymlinksTestCase {
assertEquals(0, realParent.list().length);
// ensure that the contents of the symlink were NOT removed.
- assertEquals("Contents of sym link should not have been removed", 1, randomDirectory.list().length);
+ assertEquals(1, randomDirectory.list().length, "Contents of sym link should not have been removed");
}
@Test
diff --git a/src/test/java/org/apache/commons/io/FileUtilsCopyDirectoryToDirectoryTestCase.java b/src/test/java/org/apache/commons/io/FileUtilsCopyDirectoryToDirectoryTestCase.java
index a6b0c5c..f0d716c 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsCopyDirectoryToDirectoryTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsCopyDirectoryToDirectoryTestCase.java
@@ -16,15 +16,14 @@
*/
package org.apache.commons.io;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
import java.io.File;
import java.io.IOException;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
/**
* This class ensure the correctness of {@link FileUtils#copyDirectoryToDirectory(File, File)}.
@@ -34,21 +33,24 @@ import static org.junit.Assert.fail;
*/
public class FileUtilsCopyDirectoryToDirectoryTestCase {
- @Rule
- public final TemporaryFolder temporaryFolder = new TemporaryFolder();
+ @TempDir
+ public File temporaryFolder;
@Test
public void copyDirectoryToDirectoryThrowsIllegalExceptionWithCorrectMessageWhenSrcDirIsNotDirectory() throws IOException {
- final File srcDir = temporaryFolder.newFile("notadirectory");
- final File destDir = temporaryFolder.newFolder("destinationDirectory");
+ final File srcDir = File.createTempFile("notadireotry", null, temporaryFolder);
+ final File destDir = new File(temporaryFolder, "destinationDirectory");
+ destDir.mkdirs();
final String expectedMessage = String.format("Source '%s' is not a directory", srcDir);
assertExceptionTypeAndMessage(srcDir, destDir, IllegalArgumentException.class, expectedMessage);
}
@Test
public void copyDirectoryToDirectoryThrowsIllegalArgumentExceptionWithCorrectMessageWhenDstDirIsNotDirectory() throws IOException {
- final File srcDir = temporaryFolder.newFolder("sourceDirectory");
- final File destDir = temporaryFolder.newFile("notadirectory");
+ final File srcDir = new File(temporaryFolder, "sourceDirectory");
+ srcDir.mkdir();
+ final File destDir = new File(temporaryFolder, "notadirectory");
+ destDir.createNewFile();
String expectedMessage = String.format("Destination '%s' is not a directory", destDir);
assertExceptionTypeAndMessage(srcDir, destDir, IllegalArgumentException.class, expectedMessage);
}
@@ -56,14 +58,16 @@ public class FileUtilsCopyDirectoryToDirectoryTestCase {
@Test
public void copyDirectoryToDirectoryThrowsNullPointerExceptionWithCorrectMessageWhenSrcDirIsNull() throws IOException {
final File srcDir = null;
- final File destinationDirectory = temporaryFolder.newFolder("destinationDirectory");
+ final File destinationDirectory = new File(temporaryFolder, "destinationDirectory");
+ destinationDirectory.mkdir();
final String expectedMessage = "Source must not be null";
assertExceptionTypeAndMessage(srcDir, destinationDirectory, NullPointerException.class, expectedMessage);
}
@Test
public void copyDirectoryToDirectoryThrowsNullPointerExceptionWithCorrectMessageWhenDstDirIsNull() throws IOException {
- final File srcDir = temporaryFolder.newFolder("sourceDirectory");
+ final File srcDir = new File(temporaryFolder, "sourceDirectory");
+ srcDir.mkdir();
final File destDir = null;
final String expectedMessage = "Destination must not be null";
assertExceptionTypeAndMessage(srcDir, destDir, NullPointerException.class, expectedMessage);
diff --git a/src/test/java/org/apache/commons/io/FileUtilsCopyToFileTestCase.java b/src/test/java/org/apache/commons/io/FileUtilsCopyToFileTestCase.java
index b6959fb..67dfac6 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsCopyToFileTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsCopyToFileTestCase.java
@@ -12,16 +12,17 @@
* limitations under the License. */
package org.apache.commons.io;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
@@ -29,20 +30,16 @@ import org.junit.rules.TemporaryFolder;
*/
public class FileUtilsCopyToFileTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public File temporaryFolder;
private File testFile;
private byte[] testData;
- @Before
+ @BeforeEach
public void setUp() throws Exception {
- testFile = new File(getTestDirectory(), "file1-test.txt");
+ testFile = new File(temporaryFolder, "file1-test.txt");
if(!testFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + testFile +
" as the parent directory does not exist");
@@ -62,7 +59,7 @@ public class FileUtilsCopyToFileTestCase {
public void testCopyToFile() throws IOException {
try(CheckingInputStream inputStream = new CheckingInputStream(testData)) {
FileUtils.copyToFile(inputStream, testFile);
- Assert.assertFalse("inputStream should NOT be closed", inputStream.isClosed());
+ assertFalse(inputStream.isClosed(), "inputStream should NOT be closed");
}
}
@@ -77,7 +74,7 @@ public class FileUtilsCopyToFileTestCase {
public void testCopyInputStreamToFile() throws IOException {
try(CheckingInputStream inputStream = new CheckingInputStream(testData)) {
FileUtils.copyInputStreamToFile(inputStream, testFile);
- Assert.assertTrue("inputStream should be closed", inputStream.isClosed());
+ assertTrue(inputStream.isClosed(), "inputStream should be closed");
}
}
diff --git a/src/test/java/org/apache/commons/io/FileUtilsDirectoryContainsTestCase.java b/src/test/java/org/apache/commons/io/FileUtilsDirectoryContainsTestCase.java
index 7ed9660..2466c74 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsDirectoryContainsTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsDirectoryContainsTestCase.java
@@ -16,17 +16,16 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.File;
import java.io.IOException;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* This class ensure the correctness of {@link FileUtils#directoryContains(File,File)}.
@@ -36,9 +35,6 @@ import org.junit.rules.TemporaryFolder;
*/
public class FileUtilsDirectoryContainsTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
private File directory1;
private File directory2;
private File directory3;
@@ -47,13 +43,13 @@ public class FileUtilsDirectoryContainsTestCase {
private File file2;
private File file2ByRelativeDirectory1;
private File file3;
- private File top;
+
+ @TempDir
+ public File top;
@SuppressWarnings("ResultOfMethodCallIgnored")
- @Before
+ @BeforeEach
public void setUp() throws Exception {
- top = temporaryFolder.getRoot();
-
directory1 = new File(top, "directory1");
directory2 = new File(top, "directory2");
directory3 = new File(directory2, "directory3");
@@ -158,9 +154,9 @@ public class FileUtilsDirectoryContainsTestCase {
@Test
public void testFileDoesNotExistBug() throws IOException {
final File file = new File(top, "DOESNOTEXIST");
- assertTrue("Check directory exists", top.exists());
- assertFalse("Check file does not exist", file.exists());
- assertFalse("Direcory does not contain unrealized file", FileUtils.directoryContains(top, file));
+ assertTrue(top.exists(), "Check directory exists");
+ assertFalse(file.exists(), "Check file does not exist");
+ assertFalse(FileUtils.directoryContains(top, file), "Direcory does not contain unrealized file");
}
@Test
diff --git a/src/test/java/org/apache/commons/io/FileUtilsFileNewerTestCase.java b/src/test/java/org/apache/commons/io/FileUtilsFileNewerTestCase.java
index d55434e..128701f 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsFileNewerTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsFileNewerTestCase.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.BufferedOutputStream;
import java.io.File;
@@ -26,22 +26,17 @@ import java.io.IOException;
import java.util.Date;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* This is used to test FileUtils for correctness.
*/
public class FileUtilsFileNewerTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public File temporaryFolder;
// Test data
private static final int FILE1_SIZE = 1;
@@ -50,10 +45,10 @@ public class FileUtilsFileNewerTestCase {
private File m_testFile1;
private File m_testFile2;
- @Before
+ @BeforeEach
public void setUp() throws Exception {
- m_testFile1 = new File(getTestDirectory(), "file1-test.txt");
- m_testFile2 = new File(getTestDirectory(), "file2-test.txt");
+ m_testFile1 = new File(temporaryFolder, "file1-test.txt");
+ m_testFile2 = new File(temporaryFolder, "file2-test.txt");
if (!m_testFile1.getParentFile().exists()) {
throw new IOException("Cannot create file " + m_testFile1
+ " as the parent directory does not exist");
@@ -102,7 +97,7 @@ public class FileUtilsFileNewerTestCase {
*/
@Test
public void testIsFileNewerImaginaryFile() {
- final File imaginaryFile = new File(getTestDirectory(), "imaginaryFile");
+ final File imaginaryFile = new File(temporaryFolder, "imaginaryFile");
if (imaginaryFile.exists()) {
throw new IllegalStateException("The imaginary File exists");
}
@@ -134,14 +129,14 @@ public class FileUtilsFileNewerTestCase {
* @see FileUtils#isFileNewer(File, File)
*/
protected void testIsFileNewer(final String description, final File file, final long time, final boolean wantedResult) {
- assertEquals(description + " - time", wantedResult, FileUtils.isFileNewer(file, time));
- assertEquals(description + " - date", wantedResult, FileUtils.isFileNewer(file, new Date(time)));
+ assertEquals(wantedResult, FileUtils.isFileNewer(file, time), description + " - time");
+ assertEquals(wantedResult, FileUtils.isFileNewer(file, new Date(time)), description + " - date");
final File temporaryFile = m_testFile2;
temporaryFile.setLastModified(time);
- assertEquals("The temporary file hasn't the right last modification date", time, temporaryFile.lastModified());
- assertEquals(description + " - file", wantedResult, FileUtils.isFileNewer(file, temporaryFile));
+ assertEquals(time, temporaryFile.lastModified(), "The temporary file hasn't the right last modification date");
+ assertEquals(wantedResult, FileUtils.isFileNewer(file, temporaryFile), description + " - file");
}
/**
@@ -149,10 +144,10 @@ public class FileUtilsFileNewerTestCase {
* <br>
* The test is successful if the method throws an <code>IllegalArgumentException</code>.
*/
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void testIsFileNewerNoFile() {
- FileUtils.isFileNewer(null,0);
- fail("File not specified");
+ assertThrows(IllegalArgumentException.class, () -> FileUtils.isFileNewer(null,0),
+ "File not specified");
}
/**
@@ -160,10 +155,10 @@ public class FileUtilsFileNewerTestCase {
* <br>
* The test is successful if the method throws an <code>IllegalArgumentException</code>.
*/
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void testIsFileNewerNoDate() {
- FileUtils.isFileNewer(m_testFile1, (Date) null);
- fail("Date not specified");
+ assertThrows(IllegalArgumentException.class, () -> FileUtils.isFileNewer(m_testFile1, (Date) null),
+ "Date not specified");
}
/**
@@ -171,9 +166,9 @@ public class FileUtilsFileNewerTestCase {
* <br>
* The test is successful if the method throws an <code>IllegalArgumentException</code>.
*/
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void testIsFileNewerNoFileReference() {
- FileUtils.isFileNewer(m_testFile1, (File) null);
- fail("Reference file not specified");
+ assertThrows(IllegalArgumentException.class, () -> FileUtils.isFileNewer(m_testFile1, (File) null),
+ "Reference file is not specified");
}
}
diff --git a/src/test/java/org/apache/commons/io/FileUtilsListFilesTestCase.java b/src/test/java/org/apache/commons/io/FileUtilsListFilesTestCase.java
index f7e5034..179a815 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsListFilesTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsListFilesTestCase.java
@@ -16,10 +16,10 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.File;
import java.util.ArrayList;
@@ -28,30 +28,22 @@ import java.util.Iterator;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* Test cases for FileUtils.listFiles() methods.
*/
public class FileUtilsListFilesTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
+ @TempDir
+ public File temporaryFolder;
- private File getLocalTestDirectory() {
- return temporaryFolder.getRoot();
- }
-
- /**
- * @see junit.framework.TestCase#setUp()
- */
@SuppressWarnings("ResultOfMethodCallIgnored")
- @Before
+ @BeforeEach
public void setUp() throws Exception {
- File dir = getLocalTestDirectory();
+ File dir = temporaryFolder;
File file = new File(dir, "dummy-build.xml");
FileUtils.touch(file);
file = new File(dir, "README");
@@ -100,20 +92,20 @@ public class FileUtilsListFilesTestCase {
public void testIterateFilesByExtension() throws Exception {
final String[] extensions = { "xml", "txt" };
- Iterator<File> files = FileUtils.iterateFiles(getLocalTestDirectory(), extensions, false);
+ Iterator<File> files = FileUtils.iterateFiles(temporaryFolder, extensions, false);
Collection<String> filenames = filesToFilenames(files);
assertEquals(1, filenames.size());
assertTrue(filenames.contains("dummy-build.xml"));
assertFalse(filenames.contains("README"));
assertFalse(filenames.contains("dummy-file.txt"));
- files = FileUtils.iterateFiles(getLocalTestDirectory(), extensions, true);
+ files = FileUtils.iterateFiles(temporaryFolder, extensions, true);
filenames = filesToFilenames(files);
assertEquals(4, filenames.size());
assertTrue(filenames.contains("dummy-file.txt"));
assertFalse(filenames.contains("dummy-index.html"));
- files = FileUtils.iterateFiles(getLocalTestDirectory(), null, false);
+ files = FileUtils.iterateFiles(temporaryFolder, null, false);
filenames = filesToFilenames(files);
assertEquals(2, filenames.size());
assertTrue(filenames.contains("dummy-build.xml"));
@@ -125,20 +117,20 @@ public class FileUtilsListFilesTestCase {
public void testListFilesByExtension() throws Exception {
final String[] extensions = {"xml", "txt"};
- Collection<File> files = FileUtils.listFiles(getLocalTestDirectory(), extensions, false);
+ Collection<File> files = FileUtils.listFiles(temporaryFolder, extensions, false);
assertEquals(1, files.size());
Collection<String> filenames = filesToFilenames(files);
assertTrue(filenames.contains("dummy-build.xml"));
assertFalse(filenames.contains("README"));
assertFalse(filenames.contains("dummy-file.txt"));
- files = FileUtils.listFiles(getLocalTestDirectory(), extensions, true);
+ files = FileUtils.listFiles(temporaryFolder, extensions, true);
filenames = filesToFilenames(files);
assertEquals(4, filenames.size());
assertTrue(filenames.contains("dummy-file.txt"));
assertFalse(filenames.contains("dummy-index.html"));
- files = FileUtils.listFiles(getLocalTestDirectory(), null, false);
+ files = FileUtils.listFiles(temporaryFolder, null, false);
assertEquals(2, files.size());
filenames = filesToFilenames(files);
assertTrue(filenames.contains("dummy-build.xml"));
@@ -155,42 +147,42 @@ public class FileUtilsListFilesTestCase {
//First, find non-recursively
fileFilter = FileFilterUtils.trueFileFilter();
- files = FileUtils.listFiles(getLocalTestDirectory(), fileFilter, null);
+ files = FileUtils.listFiles(temporaryFolder, fileFilter, null);
filenames = filesToFilenames(files);
- assertTrue("'dummy-build.xml' is missing", filenames.contains("dummy-build.xml"));
- assertFalse("'dummy-index.html' shouldn't be found", filenames.contains("dummy-index.html"));
- assertFalse("'Entries' shouldn't be found", filenames.contains("Entries"));
+ assertTrue(filenames.contains("dummy-build.xml"), "'dummy-build.xml' is missing");
+ assertFalse(filenames.contains("dummy-index.html"), "'dummy-index.html' shouldn't be found");
+ assertFalse(filenames.contains("Entries"), "'Entries' shouldn't be found");
//Second, find recursively
fileFilter = FileFilterUtils.trueFileFilter();
dirFilter = FileFilterUtils.notFileFilter(FileFilterUtils.nameFileFilter("CVS"));
- files = FileUtils.listFiles(getLocalTestDirectory(), fileFilter, dirFilter);
+ files = FileUtils.listFiles(temporaryFolder, fileFilter, dirFilter);
filenames = filesToFilenames(files);
- assertTrue("'dummy-build.xml' is missing", filenames.contains("dummy-build.xml"));
- assertTrue("'dummy-index.html' is missing", filenames.contains("dummy-index.html"));
- assertFalse("'Entries' shouldn't be found", filenames.contains("Entries"));
+ assertTrue(filenames.contains("dummy-build.xml"), "'dummy-build.xml' is missing");
+ assertTrue(filenames.contains("dummy-index.html"), "'dummy-index.html' is missing");
+ assertFalse(filenames.contains("Entries"), "'Entries' shouldn't be found");
//Do the same as above but now with the filter coming from FileFilterUtils
fileFilter = FileFilterUtils.trueFileFilter();
dirFilter = FileFilterUtils.makeCVSAware(null);
- files = FileUtils.listFiles(getLocalTestDirectory(), fileFilter, dirFilter);
+ files = FileUtils.listFiles(temporaryFolder, fileFilter, dirFilter);
filenames = filesToFilenames(files);
- assertTrue("'dummy-build.xml' is missing", filenames.contains("dummy-build.xml"));
- assertTrue("'dummy-index.html' is missing", filenames.contains("dummy-index.html"));
- assertFalse("'Entries' shouldn't be found", filenames.contains("Entries"));
+ assertTrue(filenames.contains("dummy-build.xml"), "'dummy-build.xml' is missing");
+ assertTrue(filenames.contains("dummy-index.html"), "'dummy-index.html' is missing");
+ assertFalse(filenames.contains("Entries"), "'Entries' shouldn't be found");
//Again with the CVS filter but now with a non-null parameter
fileFilter = FileFilterUtils.trueFileFilter();
dirFilter = FileFilterUtils.prefixFileFilter("sub");
dirFilter = FileFilterUtils.makeCVSAware(dirFilter);
- files = FileUtils.listFiles(getLocalTestDirectory(), fileFilter, dirFilter);
+ files = FileUtils.listFiles(temporaryFolder, fileFilter, dirFilter);
filenames = filesToFilenames(files);
- assertTrue("'dummy-build.xml' is missing", filenames.contains("dummy-build.xml"));
- assertTrue("'dummy-index.html' is missing", filenames.contains("dummy-index.html"));
- assertFalse("'Entries' shouldn't be found", filenames.contains("Entries"));
+ assertTrue(filenames.contains("dummy-build.xml"), "'dummy-build.xml' is missing");
+ assertTrue(filenames.contains("dummy-index.html"), "'dummy-index.html' is missing");
+ assertFalse(filenames.contains("Entries"), "'Entries' shouldn't be found");
try {
- FileUtils.listFiles(getLocalTestDirectory(), null, null);
+ FileUtils.listFiles(temporaryFolder, null, null);
fail("Expected error about null parameter");
} catch (final NullPointerException e) {
// expected
diff --git a/src/test/java/org/apache/commons/io/FileUtilsTestCase.java b/src/test/java/org/apache/commons/io/FileUtilsTestCase.java
index a6d7629..0cc6002 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsTestCase.java
@@ -16,13 +16,15 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+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.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
@@ -51,12 +53,10 @@ import java.util.zip.Checksum;
import org.apache.commons.io.filefilter.NameFileFilter;
import org.apache.commons.io.filefilter.WildcardFileFilter;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* This is used to test FileUtils for correctness.
@@ -66,12 +66,8 @@ import org.junit.rules.TemporaryFolder;
@SuppressWarnings({"deprecation", "ResultOfMethodCallIgnored"}) // unit tests include tests of many deprecated methods
public class FileUtilsTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public File temporaryFolder;
// Test data
@@ -106,10 +102,10 @@ public class FileUtilsTestCase {
private int testFile1Size;
private int testFile2Size;
- @Before
+ @BeforeEach
public void setUp() throws Exception {
- testFile1 = new File(getTestDirectory(), "file1-test.txt");
- testFile2 = new File(getTestDirectory(), "file1a-test.txt");
+ testFile1 = new File(temporaryFolder, "file1-test.txt");
+ testFile2 = new File(temporaryFolder, "file1a-test.txt");
testFile1Size = (int) testFile1.length();
testFile2Size = (int) testFile2.length();
@@ -129,8 +125,8 @@ public class FileUtilsTestCase {
new BufferedOutputStream(new FileOutputStream(testFile2))) {
TestUtils.generateTestData(output2, testFile2Size);
}
- FileUtils.deleteDirectory(getTestDirectory());
- getTestDirectory().mkdirs();
+ FileUtils.deleteDirectory(temporaryFolder);
+ temporaryFolder.mkdirs();
if (!testFile1.getParentFile().exists()) {
throw new IOException("Cannot create file " + testFile1
+ " as the parent directory does not exist");
@@ -159,9 +155,9 @@ public class FileUtilsTestCase {
final File expected_A = new File("src");
final File expected_B = new File(expected_A, "main");
final File expected_C = new File(expected_B, "java");
- assertEquals("A", expected_A, FileUtils.getFile("src"));
- assertEquals("B", expected_B, FileUtils.getFile("src", "main"));
- assertEquals("C", expected_C, FileUtils.getFile("src", "main", "java"));
+ assertEquals(expected_A, FileUtils.getFile("src"), "A");
+ assertEquals(expected_B, FileUtils.getFile("src", "main"), "B");
+ assertEquals(expected_C, FileUtils.getFile("src", "main", "java"), "C");
try {
FileUtils.getFile((String[]) null);
fail("Expected NullPointerException");
@@ -176,9 +172,9 @@ public class FileUtilsTestCase {
final File expected_A = new File(parent, "src");
final File expected_B = new File(expected_A, "main");
final File expected_C = new File(expected_B, "java");
- assertEquals("A", expected_A, FileUtils.getFile(parent, "src"));
- assertEquals("B", expected_B, FileUtils.getFile(parent, "src", "main"));
- assertEquals("C", expected_C, FileUtils.getFile(parent, "src", "main", "java"));
+ assertEquals(expected_A, FileUtils.getFile(parent, "src"), "A");
+ assertEquals(expected_B, FileUtils.getFile(parent, "src", "main"), "B");
+ assertEquals(expected_C, FileUtils.getFile(parent, "src", "main", "java"), "C");
try {
FileUtils.getFile(parent, (String[]) null);
fail("Expected NullPointerException");
@@ -220,7 +216,7 @@ public class FileUtilsTestCase {
//-----------------------------------------------------------------------
@Test
public void test_openInputStream_exists() throws Exception {
- final File file = new File(getTestDirectory(), "test.txt");
+ final File file = new File(temporaryFolder, "test.txt");
TestUtils.createLineBasedFile(file, new String[]{"Hello"});
try (FileInputStream in = FileUtils.openInputStream(file)) {
assertEquals('H', in.read());
@@ -229,7 +225,7 @@ public class FileUtilsTestCase {
@Test
public void test_openInputStream_existsButIsDirectory() throws Exception {
- final File directory = new File(getTestDirectory(), "subdir");
+ final File directory = new File(temporaryFolder, "subdir");
directory.mkdirs();
try (FileInputStream in = FileUtils.openInputStream(directory)) {
fail();
@@ -240,7 +236,7 @@ public class FileUtilsTestCase {
@Test
public void test_openInputStream_notExists() throws Exception {
- final File directory = new File(getTestDirectory(), "test.txt");
+ final File directory = new File(temporaryFolder, "test.txt");
try (FileInputStream in = FileUtils.openInputStream(directory)) {
fail();
} catch (final IOException ioe) {
@@ -279,7 +275,7 @@ public class FileUtilsTestCase {
@Test
public void test_openOutputStream_exists() throws Exception {
- final File file = new File(getTestDirectory(), "test.txt");
+ final File file = new File(temporaryFolder, "test.txt");
TestUtils.createLineBasedFile(file, new String[]{"Hello"});
try (FileOutputStream out = FileUtils.openOutputStream(file)) {
out.write(0);
@@ -289,7 +285,7 @@ public class FileUtilsTestCase {
@Test
public void test_openOutputStream_existsButIsDirectory() throws Exception {
- final File directory = new File(getTestDirectory(), "subdir");
+ final File directory = new File(temporaryFolder, "subdir");
directory.mkdirs();
try (FileOutputStream out = FileUtils.openOutputStream(directory)) {
fail();
@@ -300,7 +296,7 @@ public class FileUtilsTestCase {
@Test
public void test_openOutputStream_notExists() throws Exception {
- final File file = new File(getTestDirectory(), "a/test.txt");
+ final File file = new File(temporaryFolder, "a/test.txt");
try (FileOutputStream out = FileUtils.openOutputStream(file)) {
out.write(0);
}
@@ -317,7 +313,7 @@ public class FileUtilsTestCase {
"abcdevwxyzabcdevwxyzabcdevwxyzabcdevwxyzabcdevwxyz" +
"abcdevwxyzabcdevwxyzabcdevwxyzabcdevwxyzabcdevwxyz" +
"abcdevwxyzabcdevwxyzabcdevwxyzabcdevwxyzabcdevwxyz"; // 300 chars
- final File file = new File(getTestDirectory(), "a/" + longStr + "/test.txt");
+ final File file = new File(temporaryFolder, "a/" + longStr + "/test.txt");
try (FileOutputStream out = FileUtils.openOutputStream(file)) {
fail();
} catch (final IOException ioe) {
@@ -472,8 +468,8 @@ public class FileUtilsTestCase {
final File[] files = FileUtils.toFiles(urls);
assertEquals(urls.length, files.length);
- assertEquals("File: " + files[0], true, files[0].toString().contains("file1.txt"));
- assertEquals("File: " + files[1], true, files[1].toString().contains("file2.txt"));
+ assertEquals(true, files[0].toString().contains("file1.txt"), "File: " + files[0]);
+ assertEquals(true, files[1].toString().contains("file2.txt"), "File: " + files[1]);
}
@Test
@@ -485,8 +481,8 @@ public class FileUtilsTestCase {
final File[] files = FileUtils.toFiles(urls);
assertEquals(urls.length, files.length);
- assertEquals("File: " + files[0], true, files[0].toString().contains("file1.txt"));
- assertEquals("File: " + files[1], null, files[1]);
+ assertEquals(true, files[0].toString().contains("file1.txt"), "File: " + files[0]);
+ assertEquals(null, files[1], "File: " + files[1]);
}
@Test
@@ -523,9 +519,9 @@ public class FileUtilsTestCase {
@Test
public void testToURLs1() throws Exception {
final File[] files = new File[]{
- new File(getTestDirectory(), "file1.txt"),
- new File(getTestDirectory(), "file2.txt"),
- new File(getTestDirectory(), "test file.txt"),
+ new File(temporaryFolder, "file1.txt"),
+ new File(temporaryFolder, "file2.txt"),
+ new File(temporaryFolder, "test file.txt"),
};
final URL[] urls = FileUtils.toURLs(files);
@@ -542,7 +538,7 @@ public class FileUtilsTestCase {
// @Test public void testToURLs2() throws Exception {
// File[] files = new File[] {
-// new File(getTestDirectory(), "file1.txt"),
+// new File(temporaryFolder, "file1.txt"),
// null,
// };
// URL[] urls = FileUtils.toURLs(files);
@@ -573,8 +569,8 @@ public class FileUtilsTestCase {
@Test
public void testContentEquals() throws Exception {
// Non-existent files
- final File file = new File(getTestDirectory(), getName());
- final File file2 = new File(getTestDirectory(), getName() + "2");
+ final File file = new File(temporaryFolder, getName());
+ final File file2 = new File(temporaryFolder, getName() + "2");
// both don't exist
assertTrue(FileUtils.contentEquals(file, file));
assertTrue(FileUtils.contentEquals(file, file2));
@@ -583,7 +579,7 @@ public class FileUtilsTestCase {
// Directories
try {
- FileUtils.contentEquals(getTestDirectory(), getTestDirectory());
+ FileUtils.contentEquals(temporaryFolder, temporaryFolder);
fail("Comparing directories should fail with an IOException");
} catch (final IOException ioe) {
//expected
@@ -591,21 +587,21 @@ public class FileUtilsTestCase {
// Different files
final File objFile1 =
- new File(getTestDirectory(), getName() + ".object");
+ new File(temporaryFolder, getName() + ".object");
objFile1.deleteOnExit();
FileUtils.copyURLToFile(
getClass().getResource("/java/lang/Object.class"),
objFile1);
final File objFile1b =
- new File(getTestDirectory(), getName() + ".object2");
+ new File(temporaryFolder, getName() + ".object2");
objFile1.deleteOnExit();
FileUtils.copyURLToFile(
getClass().getResource("/java/lang/Object.class"),
objFile1b);
final File objFile2 =
- new File(getTestDirectory(), getName() + ".collection");
+ new File(temporaryFolder, getName() + ".collection");
objFile2.deleteOnExit();
FileUtils.copyURLToFile(
getClass().getResource("/java/util/Collection.class"),
@@ -629,8 +625,8 @@ public class FileUtilsTestCase {
@Test
public void testContentEqualsIgnoreEOL() throws Exception {
// Non-existent files
- final File file1 = new File(getTestDirectory(), getName());
- final File file2 = new File(getTestDirectory(), getName() + "2");
+ final File file1 = new File(temporaryFolder, getName());
+ final File file2 = new File(temporaryFolder, getName() + "2");
// both don't exist
assertTrue(FileUtils.contentEqualsIgnoreEOL(file1, file1, null));
assertTrue(FileUtils.contentEqualsIgnoreEOL(file1, file2, null));
@@ -639,22 +635,22 @@ public class FileUtilsTestCase {
// Directories
try {
- FileUtils.contentEqualsIgnoreEOL(getTestDirectory(), getTestDirectory(), null);
+ FileUtils.contentEqualsIgnoreEOL(temporaryFolder, temporaryFolder, null);
fail("Comparing directories should fail with an IOException");
} catch (final IOException ioe) {
//expected
}
// Different files
- final File tfile1 = new File(getTestDirectory(), getName() + ".txt1");
+ final File tfile1 = new File(temporaryFolder, getName() + ".txt1");
tfile1.deleteOnExit();
FileUtils.write(tfile1, "123\r");
- final File tfile2 = new File(getTestDirectory(), getName() + ".txt2");
+ final File tfile2 = new File(temporaryFolder, getName() + ".txt2");
tfile1.deleteOnExit();
FileUtils.write(tfile2, "123\n");
- final File tfile3 = new File(getTestDirectory(), getName() + ".collection");
+ final File tfile3 = new File(temporaryFolder, getName() + ".collection");
tfile3.deleteOnExit();
FileUtils.write(tfile3, "123\r\n2");
@@ -710,7 +706,7 @@ public class FileUtilsTestCase {
@Test
public void testCopyURLToFile() throws Exception {
// Creates file
- final File file = new File(getTestDirectory(), getName());
+ final File file = new File(temporaryFolder, getName());
file.deleteOnExit();
// Loads resource
@@ -719,11 +715,8 @@ public class FileUtilsTestCase {
// Tests that resuorce was copied correctly
try (FileInputStream fis = new FileInputStream(file)) {
- assertTrue(
- "Content is not equal.",
- IOUtils.contentEquals(
- getClass().getResourceAsStream(resourceName),
- fis));
+ assertTrue(IOUtils.contentEquals(getClass().getResourceAsStream(resourceName), fis),
+ "Content is not equal.");
}
//TODO Maybe test copy to itself like for copyFile()
}
@@ -731,7 +724,7 @@ public class FileUtilsTestCase {
@Test
public void testCopyURLToFileWithTimeout() throws Exception {
// Creates file
- final File file = new File(getTestDirectory(), "testCopyURLToFileWithTimeout");
+ final File file = new File(temporaryFolder, "testCopyURLToFileWithTimeout");
file.deleteOnExit();
// Loads resource
@@ -740,11 +733,8 @@ public class FileUtilsTestCase {
// Tests that resuorce was copied correctly
try (FileInputStream fis = new FileInputStream(file)) {
- assertTrue(
- "Content is not equal.",
- IOUtils.contentEquals(
- getClass().getResourceAsStream(resourceName),
- fis));
+ assertTrue(IOUtils.contentEquals(getClass().getResourceAsStream(resourceName), fis),
+ "Content is not equal.");
}
//TODO Maybe test copy to itself like for copyFile()
}
@@ -754,13 +744,13 @@ public class FileUtilsTestCase {
@Test
public void testForceMkdir() throws Exception {
// Tests with existing directory
- FileUtils.forceMkdir(getTestDirectory());
+ FileUtils.forceMkdir(temporaryFolder);
// Creates test file
- final File testFile = new File(getTestDirectory(), getName());
+ final File testFile = new File(temporaryFolder, getName());
testFile.deleteOnExit();
testFile.createNewFile();
- assertTrue("Test file does not exist.", testFile.exists());
+ assertTrue(testFile.exists(), "Test file does not exist.");
// Tests with existing file
try {
@@ -773,14 +763,14 @@ public class FileUtilsTestCase {
// Tests with non-existent directory
FileUtils.forceMkdir(testFile);
- assertTrue("Directory was not created.", testFile.exists());
+ assertTrue(testFile.exists(), "Directory was not created.");
}
@Test
public void testForceMkdirParent() throws Exception {
// Tests with existing directory
- assertTrue(getTestDirectory().exists());
- final File testParentDir = new File(getTestDirectory(), "testForceMkdirParent");
+ assertTrue(temporaryFolder.exists());
+ final File testParentDir = new File(temporaryFolder, "testForceMkdirParent");
testParentDir.delete();
assertFalse(testParentDir.exists());
final File testFile = new File(testParentDir, "test.txt");
@@ -800,7 +790,7 @@ public class FileUtilsTestCase {
@Test
public void testSizeOfDirectory() throws Exception {
- final File file = new File(getTestDirectory(), getName());
+ final File file = new File(temporaryFolder, getName());
// Non-existent file
try {
@@ -826,10 +816,7 @@ public class FileUtilsTestCase {
// Create a cyclic symlink
this.createCircularSymLink(file);
- assertEquals(
- "Unexpected directory size",
- TEST_DIRECTORY_SIZE,
- FileUtils.sizeOfDirectory(file));
+ assertEquals(TEST_DIRECTORY_SIZE, FileUtils.sizeOfDirectory(file), "Unexpected directory size");
}
private void createCircularSymLink(final File file) throws IOException {
@@ -848,7 +835,7 @@ public class FileUtilsTestCase {
@Test
public void testSizeOfDirectoryAsBigInteger() throws Exception {
- final File file = new File(getTestDirectory(), getName());
+ final File file = new File(temporaryFolder, getName());
// Non-existent file
try {
@@ -874,7 +861,7 @@ public class FileUtilsTestCase {
this.createCircularSymLink(file);
- assertEquals("Unexpected directory size", TEST_DIRECTORY_SIZE_BI, FileUtils.sizeOfDirectoryAsBigInteger(file));
+ assertEquals(TEST_DIRECTORY_SIZE_BI, FileUtils.sizeOfDirectoryAsBigInteger(file), "Unexpected directory size");
// Existing directory which size is greater than zero
file.delete();
@@ -894,8 +881,8 @@ public class FileUtilsTestCase {
}
nonEmptyFile.deleteOnExit();
- assertEquals("Unexpected directory size", TEST_DIRECTORY_SIZE_GT_ZERO_BI,
- FileUtils.sizeOfDirectoryAsBigInteger(file));
+ assertEquals(TEST_DIRECTORY_SIZE_GT_ZERO_BI, FileUtils.sizeOfDirectoryAsBigInteger(file),
+ "Unexpected directory size");
nonEmptyFile.delete();
file.delete();
@@ -908,13 +895,13 @@ public class FileUtilsTestCase {
final long sizeLong1 = FileUtils.sizeOf(start);
final BigInteger sizeBig = FileUtils.sizeOfAsBigInteger(start);
final long sizeLong2 = FileUtils.sizeOf(start);
- assertEquals("Size should not change", sizeLong1, sizeLong2);
- assertEquals("longSize should equal BigSize", sizeLong1, sizeBig.longValue());
+ assertEquals(sizeLong1, sizeLong2, "Size should not change");
+ assertEquals(sizeLong1, sizeBig.longValue(), "longSize should equal BigSize");
}
@Test
public void testSizeOf() throws Exception {
- final File file = new File(getTestDirectory(), getName());
+ final File file = new File(temporaryFolder, getName());
// Null argument
try {
@@ -939,19 +926,15 @@ public class FileUtilsTestCase {
file.delete();
// Existing file
- assertEquals("Unexpected files size",
- testFile1Size,
- FileUtils.sizeOf(testFile1));
+ assertEquals(testFile1Size, FileUtils.sizeOf(testFile1), "Unexpected files size");
// Existing directory
- assertEquals("Unexpected directory size",
- TEST_DIRECTORY_SIZE,
- FileUtils.sizeOf(getTestDirectory()));
+ assertEquals(TEST_DIRECTORY_SIZE, FileUtils.sizeOf(temporaryFolder), "Unexpected directory size");
}
@Test
public void testSizeOfAsBigInteger() throws Exception {
- final File file = new File(getTestDirectory(), getName());
+ final File file = new File(temporaryFolder, getName());
// Null argument
try {
@@ -976,23 +959,21 @@ public class FileUtilsTestCase {
file.delete();
// Existing file
- assertEquals("Unexpected files size",
- BigInteger.valueOf(testFile1Size),
- FileUtils.sizeOfAsBigInteger(testFile1));
+ assertEquals(BigInteger.valueOf(testFile1Size), FileUtils.sizeOfAsBigInteger(testFile1),
+ "Unexpected files size");
// Existing directory
- assertEquals("Unexpected directory size",
- TEST_DIRECTORY_SIZE_BI,
- FileUtils.sizeOfAsBigInteger(getTestDirectory()));
+ assertEquals(TEST_DIRECTORY_SIZE_BI, FileUtils.sizeOfAsBigInteger(temporaryFolder),
+ "Unexpected directory size");
}
// isFileNewer / isFileOlder
@Test
public void testIsFileNewerOlder() throws Exception {
- final File reference = new File(getTestDirectory(), "FileUtils-reference.txt");
- final File oldFile = new File(getTestDirectory(), "FileUtils-old.txt");
- final File newFile = new File(getTestDirectory(), "FileUtils-new.txt");
- final File invalidFile = new File(getTestDirectory(), "FileUtils-invalid-file.txt");
+ final File reference = new File(temporaryFolder, "FileUtils-reference.txt");
+ final File oldFile = new File(temporaryFolder, "FileUtils-old.txt");
+ final File newFile = new File(temporaryFolder, "FileUtils-new.txt");
+ final File invalidFile = new File(temporaryFolder, "FileUtils-invalid-file.txt");
// Create Files
if (!oldFile.getParentFile().exists()) {
@@ -1049,36 +1030,36 @@ public class FileUtilsTestCase {
} while (reference.lastModified() == newFile.lastModified());
// Test isFileNewer()
- assertFalse("Old File - Newer - File", FileUtils.isFileNewer(oldFile, reference));
- assertFalse("Old File - Newer - Date", FileUtils.isFileNewer(oldFile, date));
- assertFalse("Old File - Newer - Mili", FileUtils.isFileNewer(oldFile, now));
- assertTrue("New File - Newer - File", FileUtils.isFileNewer(newFile, reference));
- assertTrue("New File - Newer - Date", FileUtils.isFileNewer(newFile, date));
- assertTrue("New File - Newer - Mili", FileUtils.isFileNewer(newFile, now));
- assertFalse("Invalid - Newer - File", FileUtils.isFileNewer(invalidFile, reference));
+ assertFalse(FileUtils.isFileNewer(oldFile, reference), "Old File - Newer - File");
+ assertFalse(FileUtils.isFileNewer(oldFile, date), "Old File - Newer - Date");
+ assertFalse(FileUtils.isFileNewer(oldFile, now), "Old File - Newer - Mili");
+ assertTrue(FileUtils.isFileNewer(newFile, reference), "New File - Newer - File");
+ assertTrue(FileUtils.isFileNewer(newFile, date), "New File - Newer - Date");
+ assertTrue(FileUtils.isFileNewer(newFile, now), "New File - Newer - Mili");
+ assertFalse(FileUtils.isFileNewer(invalidFile, reference), "Invalid - Newer - File");
final String invalidFileName = invalidFile.getName();
try {
FileUtils.isFileNewer(newFile, invalidFile);
fail("Should have cause IllegalArgumentException");
} catch (final IllegalArgumentException iae) {
final String message = iae.getMessage();
- assertTrue("Message should contain: " + invalidFileName + " but was: " + message, message.contains(invalidFileName));
+ assertTrue(message.contains(invalidFileName), "Message should contain: " + invalidFileName + " but was: " + message);
}
// Test isFileOlder()
- assertTrue("Old File - Older - File", FileUtils.isFileOlder(oldFile, reference));
- assertTrue("Old File - Older - Date", FileUtils.isFileOlder(oldFile, date));
- assertTrue("Old File - Older - Mili", FileUtils.isFileOlder(oldFile, now));
- assertFalse("New File - Older - File", FileUtils.isFileOlder(newFile, reference));
- assertFalse("New File - Older - Date", FileUtils.isFileOlder(newFile, date));
- assertFalse("New File - Older - Mili", FileUtils.isFileOlder(newFile, now));
- assertFalse("Invalid - Older - File", FileUtils.isFileOlder(invalidFile, reference));
+ assertTrue(FileUtils.isFileOlder(oldFile, reference), "Old File - Older - File");
+ assertTrue(FileUtils.isFileOlder(oldFile, date), "Old File - Older - Date");
+ assertTrue(FileUtils.isFileOlder(oldFile, now), "Old File - Older - Mili");
+ assertFalse(FileUtils.isFileOlder(newFile, reference), "New File - Older - File");
+ assertFalse(FileUtils.isFileOlder(newFile, date), "New File - Older - Date");
+ assertFalse(FileUtils.isFileOlder(newFile, now), "New File - Older - Mili");
+ assertFalse(FileUtils.isFileOlder(invalidFile, reference), "Invalid - Older - File");
try {
FileUtils.isFileOlder(newFile, invalidFile);
fail("Should have cause IllegalArgumentException");
} catch (final IllegalArgumentException iae) {
final String message = iae.getMessage();
- assertTrue("Message should contain: " + invalidFileName + " but was: " + message, message.contains(invalidFileName));
+ assertTrue(message.contains(invalidFileName), "Message should contain: " + invalidFileName + " but was: " + message);
}
@@ -1155,15 +1136,15 @@ public class FileUtilsTestCase {
@Test
public void testCopyFile1() throws Exception {
- final File destination = new File(getTestDirectory(), "copy1.txt");
+ final File destination = new File(temporaryFolder, "copy1.txt");
//Thread.sleep(LAST_MODIFIED_DELAY);
//This is to slow things down so we can catch if
//the lastModified date is not ok
FileUtils.copyFile(testFile1, destination);
- assertTrue("Check Exist", destination.exists());
- assertEquals("Check Full copy", testFile1Size, destination.length());
+ assertTrue(destination.exists(), "Check Exist");
+ assertEquals(testFile1Size, destination.length(), "Check Full copy");
/* disabled: Thread.sleep doesn't work reliantly for this case
assertTrue("Check last modified date preserved",
testFile1.lastModified() == destination.lastModified());*/
@@ -1173,17 +1154,17 @@ public class FileUtilsTestCase {
public void testCopyFileToOutputStream() throws Exception {
final ByteArrayOutputStream destination = new ByteArrayOutputStream();
FileUtils.copyFile(testFile1, destination);
- assertEquals("Check Full copy size", testFile1Size, destination.size());
+ assertEquals(testFile1Size, destination.size(), "Check Full copy size");
final byte[] expected = FileUtils.readFileToByteArray(testFile1);
- Assert.assertArrayEquals("Check Full copy", expected, destination.toByteArray());
+ assertArrayEquals(expected, destination.toByteArray(), "Check Full copy");
}
@Test
- @Ignore
+ @Disabled
public void testCopyFileLarge() throws Exception {
- final File largeFile = new File(getTestDirectory(), "large.txt");
- final File destination = new File(getTestDirectory(), "copylarge.txt");
+ final File largeFile = new File(temporaryFolder, "large.txt");
+ final File destination = new File(temporaryFolder, "copylarge.txt");
System.out.println("START: " + new java.util.Date());
if (!largeFile.getParentFile().exists()) {
@@ -1201,29 +1182,28 @@ public class FileUtilsTestCase {
FileUtils.copyFile(largeFile, destination);
System.out.println("COPIED: " + new java.util.Date());
- assertTrue("Check Exist", destination.exists());
- assertEquals("Check Full copy", largeFile.length(), destination.length());
+ assertTrue(destination.exists(), "Check Exist");
+ assertEquals(largeFile.length(), destination.length(), "Check Full copy");
}
@Test
public void testCopyFile2() throws Exception {
- final File destination = new File(getTestDirectory(), "copy2.txt");
+ final File destination = new File(temporaryFolder, "copy2.txt");
//Thread.sleep(LAST_MODIFIED_DELAY);
//This is to slow things down so we can catch if
//the lastModified date is not ok
FileUtils.copyFile(testFile1, destination);
- assertTrue("Check Exist", destination.exists());
- assertEquals("Check Full copy", testFile2Size, destination.length());
+ assertTrue(destination.exists(), "Check Exist");
+ assertEquals(testFile2Size, destination.length(), "Check Full copy");
/* disabled: Thread.sleep doesn't work reliably for this case
- assertTrue("Check last modified date preserved",
- testFile1.lastModified() == destination.lastModified());*/
+ assertTrue(testFile1.lastModified() == destination.lastModified(), "Check last modified date preserved");*/
}
@Test
public void testCopyToSelf() throws Exception {
- final File destination = new File(getTestDirectory(), "copy3.txt");
+ final File destination = new File(temporaryFolder, "copy3.txt");
//Prepare a test file
FileUtils.copyFile(testFile1, destination);
@@ -1237,15 +1217,15 @@ public class FileUtilsTestCase {
@Test
public void testCopyFile2WithoutFileDatePreservation() throws Exception {
- final File destination = new File(getTestDirectory(), "copy2.txt");
+ final File destination = new File(temporaryFolder, "copy2.txt");
//Thread.sleep(LAST_MODIFIED_DELAY);
//This is to slow things down so we can catch if
//the lastModified date is not ok
FileUtils.copyFile(testFile1, destination, false);
- assertTrue("Check Exist", destination.exists());
- assertEquals("Check Full copy", testFile2Size, destination.length());
+ assertTrue(destination.exists(), "Check Exist");
+ assertEquals(testFile2Size, destination.length(), "Check Full copy");
/* disabled: Thread.sleep doesn't work reliantly for this case
assertTrue("Check last modified date modified",
testFile1.lastModified() != destination.lastModified());*/
@@ -1275,7 +1255,7 @@ public class FileUtilsTestCase {
} finally {
IOUtils.closeQuietly(output);
}
- final File srcDir = getTestDirectory();
+ final File srcDir = temporaryFolder;
final File subDir = new File(srcDir, "sub");
subDir.mkdir();
final File subFile = new File(subDir, "A.txt");
@@ -1286,11 +1266,11 @@ public class FileUtilsTestCase {
FileUtils.copyDirectoryToDirectory(srcDir, destDir);
- assertTrue("Check exists", destDir.exists());
- assertTrue("Check exists", actualDestDir.exists());
+ assertTrue(destDir.exists(), "Check exists");
+ assertTrue(actualDestDir.exists(), "Check exists");
final long srcSize = FileUtils.sizeOfDirectory(srcDir);
- assertTrue("Size > 0", srcSize > 0);
- assertEquals("Check size", srcSize, FileUtils.sizeOfDirectory(actualDestDir));
+ assertTrue(srcSize > 0, "Size > 0");
+ assertEquals(srcSize, FileUtils.sizeOfDirectory(actualDestDir), "Check size");
assertTrue(new File(actualDestDir, "sub/A.txt").exists());
FileUtils.deleteDirectory(destDir);
}
@@ -1319,7 +1299,7 @@ public class FileUtilsTestCase {
} finally {
IOUtils.closeQuietly(output);
}
- final File srcDir = getTestDirectory();
+ final File srcDir = temporaryFolder;
final File subDir = new File(srcDir, "sub");
subDir.mkdir();
final File subFile = new File(subDir, "A.txt");
@@ -1329,10 +1309,10 @@ public class FileUtilsTestCase {
FileUtils.copyDirectory(srcDir, destDir);
- assertTrue("Check exists", destDir.exists());
+ assertTrue(destDir.exists(), "Check exists");
final long sizeOfSrcDirectory = FileUtils.sizeOfDirectory(srcDir);
- assertTrue("Size > 0", sizeOfSrcDirectory > 0);
- assertEquals("Check size", sizeOfSrcDirectory, FileUtils.sizeOfDirectory(destDir));
+ assertTrue(sizeOfSrcDirectory > 0, "Size > 0");
+ assertEquals(sizeOfSrcDirectory, FileUtils.sizeOfDirectory(destDir), "Check size");
assertTrue(new File(destDir, "sub/A.txt").exists());
FileUtils.deleteDirectory(destDir);
}
@@ -1361,7 +1341,7 @@ public class FileUtilsTestCase {
} finally {
IOUtils.closeQuietly(output);
}
- final File srcDir = getTestDirectory();
+ final File srcDir = temporaryFolder;
final File subDir = new File(srcDir, "sub");
subDir.mkdir();
final File subFile = new File(subDir, "A.txt");
@@ -1373,20 +1353,20 @@ public class FileUtilsTestCase {
FileUtils.copyDirectory(srcDir, destDir);
final long srcSize = FileUtils.sizeOfDirectory(srcDir);
- assertTrue("Size > 0", srcSize > 0);
+ assertTrue(srcSize > 0, "Size > 0");
assertEquals(srcSize, FileUtils.sizeOfDirectory(destDir));
assertTrue(new File(destDir, "sub/A.txt").exists());
}
@Test
public void testCopyDirectoryFiltered() throws Exception {
- final File grandParentDir = new File(getTestDirectory(), "grandparent");
+ final File grandParentDir = new File(temporaryFolder, "grandparent");
final File parentDir = new File(grandParentDir, "parent");
final File childDir = new File(parentDir, "child");
createFilesForTestCopyDirectory(grandParentDir, parentDir, childDir);
final NameFileFilter filter = new NameFileFilter(new String[]{"parent", "child", "file3.txt"});
- final File destDir = new File(getTestDirectory(), "copydest");
+ final File destDir = new File(temporaryFolder, "copydest");
FileUtils.copyDirectory(grandParentDir, destDir, filter);
final List<File> files = LIST_WALKER.list(destDir);
@@ -1398,7 +1378,7 @@ public class FileUtilsTestCase {
@Test
public void testCopyDirectoryPreserveDates() throws Exception {
- final File source = new File(getTestDirectory(), "source");
+ final File source = new File(temporaryFolder, "source");
final File sourceDirectory = new File(source, "directory");
final File sourceFile = new File(sourceDirectory, "hello.txt");
@@ -1413,7 +1393,7 @@ public class FileUtilsTestCase {
sourceDirectory.setLastModified(1000000001000L);
source.setLastModified(1000000000000L);
- final File target = new File(getTestDirectory(), "target");
+ final File target = new File(temporaryFolder, "target");
final File targetDirectory = new File(target, "directory");
final File targetFile = new File(targetDirectory, "hello.txt");
@@ -1451,7 +1431,7 @@ public class FileUtilsTestCase {
/* Test for IO-141 */
@Test
public void testCopyDirectoryToChild() throws Exception {
- final File grandParentDir = new File(getTestDirectory(), "grandparent");
+ final File grandParentDir = new File(temporaryFolder, "grandparent");
final File parentDir = new File(grandParentDir, "parent");
final File childDir = new File(parentDir, "child");
createFilesForTestCopyDirectory(grandParentDir, parentDir, childDir);
@@ -1463,14 +1443,14 @@ public class FileUtilsTestCase {
FileUtils.copyDirectory(parentDir, childDir);
assertEquals(expectedCount, LIST_WALKER.list(grandParentDir).size());
assertEquals(expectedSize, FileUtils.sizeOfDirectory(grandParentDir));
- assertTrue("Count > 0", expectedCount > 0);
- assertTrue("Size > 0", expectedSize > 0);
+ assertTrue(expectedCount > 0, "Count > 0");
+ assertTrue(expectedSize > 0, "Size > 0");
}
/* Test for IO-141 */
@Test
public void testCopyDirectoryToGrandChild() throws Exception {
- final File grandParentDir = new File(getTestDirectory(), "grandparent");
+ final File grandParentDir = new File(temporaryFolder, "grandparent");
final File parentDir = new File(grandParentDir, "parent");
final File childDir = new File(parentDir, "child");
createFilesForTestCopyDirectory(grandParentDir, parentDir, childDir);
@@ -1480,13 +1460,13 @@ public class FileUtilsTestCase {
FileUtils.copyDirectory(grandParentDir, childDir);
assertEquals(expectedCount, LIST_WALKER.list(grandParentDir).size());
assertEquals(expectedSize, FileUtils.sizeOfDirectory(grandParentDir));
- assertTrue("Size > 0", expectedSize > 0);
+ assertTrue(expectedSize > 0, "Size > 0");
}
/* Test for IO-217 FileUtils.copyDirectoryToDirectory makes infinite loops */
@Test
public void testCopyDirectoryToItself() throws Exception {
- final File dir = new File(getTestDirectory(), "itself");
+ final File dir = new File(temporaryFolder, "itself");
dir.mkdirs();
FileUtils.copyDirectoryToDirectory(dir, dir);
assertEquals(1, LIST_WALKER.list(dir).size());
@@ -1541,12 +1521,12 @@ public class FileUtilsTestCase {
} catch (final IOException ignore) {
}
try {
- FileUtils.copyDirectory(getTestDirectory(), testFile1);
+ FileUtils.copyDirectory(temporaryFolder, testFile1);
fail();
} catch (final IOException ignore) {
}
try {
- FileUtils.copyDirectory(getTestDirectory(), getTestDirectory());
+ FileUtils.copyDirectory(temporaryFolder, temporaryFolder);
fail();
} catch (final IOException ignore) {
}
@@ -1556,36 +1536,37 @@ public class FileUtilsTestCase {
@Test
public void testCopyToDirectoryWithFile() throws IOException {
- final File directory = new File(getTestDirectory(), "subdir");
+ final File directory = new File(temporaryFolder, "subdir");
if (!directory.exists()) {
directory.mkdirs();
}
final File destination = new File(directory, testFile1.getName());
FileUtils.copyToDirectory(testFile1, directory);
- assertTrue("Check Exists", destination.exists());
- assertEquals("Check Full Copy", testFile1Size, destination.length());
+ assertTrue(destination.exists(), "Check Exists");
+ assertEquals(testFile1Size, destination.length(), "Check Full Copy");
}
- @Test(expected=NullPointerException.class)
- public void testCopyToDirectoryWithFileSourceIsNull() throws IOException {
- FileUtils.copyToDirectory((File) null, getTestDirectory());
+ @Test
+ public void testCopyToDirectoryWithFileSourceIsNull() {
+ assertThrows(NullPointerException.class, () -> FileUtils.copyToDirectory((File) null, temporaryFolder));
}
- @Test(expected=IOException.class)
- public void testCopyToDirectoryWithFileSourceDoesNotExist() throws IOException {
- FileUtils.copyToDirectory(new File(getTestDirectory(), "doesNotExists"), getTestDirectory());
+ @Test
+ public void testCopyToDirectoryWithFileSourceDoesNotExist() {
+ assertThrows(IOException.class,
+ () -> FileUtils.copyToDirectory(new File(temporaryFolder, "doesNotExists"), temporaryFolder));
}
@Test
public void testCopyToDirectoryWithDirectory() throws IOException {
- final File destDirectory = new File(getTestDirectory(), "destination");
+ final File destDirectory = new File(temporaryFolder, "destination");
if (!destDirectory.exists()) {
destDirectory.mkdirs();
}
// Create a test directory
- final File inputDirectory = new File(getTestDirectory(), "input");
+ final File inputDirectory = new File(temporaryFolder, "input");
if (!inputDirectory.exists()) {
inputDirectory.mkdirs();
}
@@ -1598,19 +1579,19 @@ public class FileUtilsTestCase {
FileUtils.copyToDirectory(inputDirectory, destDirectory);
// Check the directory was created
- assertTrue("Check Exists", outputDirDestination.exists());
- assertTrue("Check Directory", outputDirDestination.isDirectory());
+ assertTrue(outputDirDestination.exists(), "Check Exists");
+ assertTrue(outputDirDestination.isDirectory(), "Check Directory");
// Check each file
- assertTrue("Check Exists", destFile1.exists());
- assertEquals("Check Full Copy", testFile1Size, destFile1.length());
- assertTrue("Check Exists", destFile2.exists());
- assertEquals("Check Full Copy", testFile2Size, destFile2.length());
+ assertTrue(destFile1.exists(), "Check Exists");
+ assertEquals(testFile1Size, destFile1.length(), "Check Full Copy");
+ assertTrue(destFile2.exists(), "Check Exists");
+ assertEquals(testFile2Size, destFile2.length(), "Check Full Copy");
}
@Test
public void testCopyToDirectoryWithIterable() throws IOException {
- final File directory = new File(getTestDirectory(), "subdir");
+ final File directory = new File(temporaryFolder, "subdir");
if (!directory.exists()) {
directory.mkdirs();
}
@@ -1624,47 +1605,48 @@ public class FileUtilsTestCase {
FileUtils.copyToDirectory(input, directory);
// Check each file
- assertTrue("Check Exists", destFile1.exists());
- assertEquals("Check Full Copy", testFile1Size, destFile1.length());
- assertTrue("Check Exists", destFile2.exists());
- assertEquals("Check Full Copy", testFile2Size, destFile2.length());
+ assertTrue(destFile1.exists(), "Check Exists");
+ assertEquals(testFile1Size, destFile1.length(), "Check Full Copy");
+ assertTrue(destFile2.exists(), "Check Exists");
+ assertEquals(testFile2Size, destFile2.length(), "Check Full Copy");
}
- @Test(expected=NullPointerException.class)
- public void testCopyToDirectoryWithIterableSourceIsNull() throws IOException {
- FileUtils.copyToDirectory((List<File>) null, getTestDirectory());
+ @Test
+ public void testCopyToDirectoryWithIterableSourceIsNull() {
+ assertThrows(NullPointerException.class, () -> FileUtils.copyToDirectory((List<File>) null, temporaryFolder));
}
- @Test(expected=IOException.class)
- public void testCopyToDirectoryWithIterableSourceDoesNotExist() throws IOException {
- FileUtils.copyToDirectory(Collections.singleton(new File(getTestDirectory(), "doesNotExists")),
- getTestDirectory());
+ @Test
+ public void testCopyToDirectoryWithIterableSourceDoesNotExist() {
+ assertThrows(IOException.class,
+ () -> FileUtils.copyToDirectory(Collections.singleton(new File(temporaryFolder, "doesNotExists")),
+ temporaryFolder));
}
// forceDelete
@Test
public void testForceDeleteAFile1() throws Exception {
- final File destination = new File(getTestDirectory(), "copy1.txt");
+ final File destination = new File(temporaryFolder, "copy1.txt");
destination.createNewFile();
- assertTrue("Copy1.txt doesn't exist to delete", destination.exists());
+ assertTrue(destination.exists(), "Copy1.txt doesn't exist to delete");
FileUtils.forceDelete(destination);
- assertTrue("Check No Exist", !destination.exists());
+ assertTrue(!destination.exists(), "Check No Exist");
}
@Test
public void testForceDeleteAFile2() throws Exception {
- final File destination = new File(getTestDirectory(), "copy2.txt");
+ final File destination = new File(temporaryFolder, "copy2.txt");
destination.createNewFile();
- assertTrue("Copy2.txt doesn't exist to delete", destination.exists());
+ assertTrue(destination.exists(), "Copy2.txt doesn't exist to delete");
FileUtils.forceDelete(destination);
- assertTrue("Check No Exist", !destination.exists());
+ assertTrue(!destination.exists(), "Check No Exist");
}
@Test
public void testForceDeleteAFile3() throws Exception {
- final File destination = new File(getTestDirectory(), "no_such_file");
- assertTrue("Check No Exist", !destination.exists());
+ final File destination = new File(temporaryFolder, "no_such_file");
+ assertTrue(!destination.exists(), "Check No Exist");
try {
FileUtils.forceDelete(destination);
fail("Should generate FileNotFoundException");
@@ -1676,7 +1658,7 @@ public class FileUtilsTestCase {
@Test
public void testCopyFile1ToDir() throws Exception {
- final File directory = new File(getTestDirectory(), "subdir");
+ final File directory = new File(temporaryFolder, "subdir");
if (!directory.exists()) {
directory.mkdirs();
}
@@ -1687,8 +1669,8 @@ public class FileUtilsTestCase {
//the lastModified date is not ok
FileUtils.copyFileToDirectory(testFile1, directory);
- assertTrue("Check Exist", destination.exists());
- assertEquals("Check Full copy", testFile1Size, destination.length());
+ assertTrue(destination.exists(), "Check Exist");
+ assertEquals(testFile1Size, destination.length(), "Check Full copy");
/* disabled: Thread.sleep doesn't work reliantly for this case
assertTrue("Check last modified date preserved",
testFile1.lastModified() == destination.lastModified());*/
@@ -1703,7 +1685,7 @@ public class FileUtilsTestCase {
@Test
public void testCopyFile2ToDir() throws Exception {
- final File directory = new File(getTestDirectory(), "subdir");
+ final File directory = new File(temporaryFolder, "subdir");
if (!directory.exists()) {
directory.mkdirs();
}
@@ -1714,8 +1696,8 @@ public class FileUtilsTestCase {
//the lastModified date is not ok
FileUtils.copyFileToDirectory(testFile1, directory);
- assertTrue("Check Exist", destination.exists());
- assertEquals("Check Full copy", testFile2Size, destination.length());
+ assertTrue(destination.exists(), "Check Exist");
+ assertEquals(testFile2Size, destination.length(), "Check Full copy");
/* disabled: Thread.sleep doesn't work reliantly for this case
assertTrue("Check last modified date preserved",
testFile1.lastModified() == destination.lastModified());*/
@@ -1725,10 +1707,10 @@ public class FileUtilsTestCase {
@Test
public void testForceDeleteDir() throws Exception {
- final File testDirectory = getTestDirectory();
- assertTrue("TestDirectory must exist", testDirectory.exists());
+ final File testDirectory = temporaryFolder;
+ assertTrue(testDirectory.exists(), "TestDirectory must exist");
FileUtils.forceDelete(testDirectory);
- assertFalse("TestDirectory must not exist", testDirectory.exists());
+ assertFalse(testDirectory.exists(), "TestDirectory must not exist");
}
/*
@@ -1737,7 +1719,7 @@ public class FileUtilsTestCase {
@Test
public void testFileUtils() throws Exception {
// Loads file from classpath
- final File file1 = new File(getTestDirectory(), "test.txt");
+ final File file1 = new File(temporaryFolder, "test.txt");
final String filename = file1.getAbsolutePath();
//Create test file on-the-fly (used to be in CVS)
@@ -1745,53 +1727,51 @@ public class FileUtilsTestCase {
out.write("This is a test".getBytes("UTF-8"));
}
- final File file2 = new File(getTestDirectory(), "test2.txt");
+ final File file2 = new File(temporaryFolder, "test2.txt");
FileUtils.writeStringToFile(file2, filename, "UTF-8");
assertTrue(file2.exists());
assertTrue(file2.length() > 0);
final String file2contents = FileUtils.readFileToString(file2, "UTF-8");
- assertTrue(
- "Second file's contents correct",
- filename.equals(file2contents));
+ assertTrue(filename.equals(file2contents), "Second file's contents correct");
assertTrue(file2.delete());
final String contents = FileUtils.readFileToString(new File(filename), "UTF-8");
- assertEquals("FileUtils.fileRead()", "This is a test", contents);
+ assertEquals("This is a test", contents, "FileUtils.fileRead()");
}
@Test
public void testTouch() throws IOException {
- final File file = new File(getTestDirectory(), "touch.txt");
+ final File file = new File(temporaryFolder, "touch.txt");
if (file.exists()) {
file.delete();
}
- assertTrue("Bad test: test file still exists", !file.exists());
+ assertTrue(!file.exists(), "Bad test: test file still exists");
FileUtils.touch(file);
- assertTrue("FileUtils.touch() created file", file.exists());
+ assertTrue(file.exists(), "FileUtils.touch() created file");
final FileOutputStream out = new FileOutputStream(file);
- assertEquals("Created empty file.", 0, file.length());
+ assertEquals(0, file.length(), "Created empty file.");
out.write(0);
out.close();
- assertEquals("Wrote one byte to file", 1, file.length());
+ assertEquals(1, file.length(), "Wrote one byte to file");
final long y2k = new GregorianCalendar(2000, 0, 1).getTime().getTime();
final boolean res = file.setLastModified(y2k); // 0L fails on Win98
- assertEquals("Bad test: set lastModified failed", true, res);
- assertEquals("Bad test: set lastModified set incorrect value", y2k, file.lastModified());
+ assertEquals(true, res, "Bad test: set lastModified failed");
+ assertEquals(y2k, file.lastModified(), "Bad test: set lastModified set incorrect value");
final long now = System.currentTimeMillis();
FileUtils.touch(file);
- assertEquals("FileUtils.touch() didn't empty the file.", 1, file.length());
- assertEquals("FileUtils.touch() changed lastModified", false, y2k == file.lastModified());
- assertEquals("FileUtils.touch() changed lastModified to more than now-3s", true, file.lastModified() >= now - 3000);
- assertEquals("FileUtils.touch() changed lastModified to less than now+3s", true, file.lastModified() <= now + 3000);
+ assertEquals(1, file.length(), "FileUtils.touch() didn't empty the file.");
+ assertEquals(false, y2k == file.lastModified(), "FileUtils.touch() changed lastModified");
+ assertEquals(true, file.lastModified() >= now - 3000, "FileUtils.touch() changed lastModified to more than now-3s");
+ assertEquals(true, file.lastModified() <= now + 3000, "FileUtils.touch() changed lastModified to less than now+3s");
}
@Test
public void testListFiles() throws Exception {
- final File srcDir = getTestDirectory();
+ final File srcDir = temporaryFolder;
final File subDir = new File(srcDir, "list_test");
subDir.mkdir();
@@ -1844,7 +1824,7 @@ public class FileUtilsTestCase {
@Test
public void testListFilesWithDirs() throws IOException {
- final File srcDir = getTestDirectory();
+ final File srcDir = temporaryFolder;
final File subDir1 = new File(srcDir, "subdir");
subDir1.mkdir();
@@ -1872,17 +1852,17 @@ public class FileUtilsTestCase {
new WildcardFileFilter("*.*"), new WildcardFileFilter("*"));
assertEquals(4, files.size());
- assertTrue("Should contain the directory.", files.contains(subDir1));
- assertTrue("Should contain the directory.", files.contains(subDir2));
- assertTrue("Should contain the file.", files.contains(someFile));
- assertTrue("Should contain the directory.", files.contains(subDir3));
+ assertTrue(files.contains(subDir1), "Should contain the directory.");
+ assertTrue(files.contains(subDir2), "Should contain the directory.");
+ assertTrue(files.contains(someFile), "Should contain the file.");
+ assertTrue(files.contains(subDir3), "Should contain the directory.");
subDir1.delete();
}
@Test
public void testIterateFiles() throws Exception {
- final File srcDir = getTestDirectory();
+ final File srcDir = temporaryFolder;
final File subDir = new File(srcDir, "list_test");
subDir.mkdir();
@@ -1929,7 +1909,7 @@ public class FileUtilsTestCase {
@Test
public void testIterateFilesAndDirs() throws IOException {
- final File srcDir = getTestDirectory();
+ final File srcDir = temporaryFolder;
final File subDir1 = new File(srcDir, "subdir");
subDir1.mkdir();
@@ -1962,7 +1942,7 @@ public class FileUtilsTestCase {
while (files.hasNext()) {
filesCount++;
final File file = files.next();
- assertTrue("Should contain the directory/file", filesAndDirs.contains(file));
+ assertTrue(filesAndDirs.contains(file), "Should contain the directory/file");
}
assertEquals(filesCount, filesAndDirs.size());
@@ -1970,7 +1950,7 @@ public class FileUtilsTestCase {
@Test
public void testReadFileToStringWithDefaultEncoding() throws Exception {
- final File file = new File(getTestDirectory(), "read.obj");
+ final File file = new File(temporaryFolder, "read.obj");
final FileOutputStream out = new FileOutputStream(file);
final byte[] text = "Hello /u1234".getBytes();
out.write(text);
@@ -1982,7 +1962,7 @@ public class FileUtilsTestCase {
@Test
public void testReadFileToStringWithEncoding() throws Exception {
- final File file = new File(getTestDirectory(), "read.obj");
+ final File file = new File(temporaryFolder, "read.obj");
final FileOutputStream out = new FileOutputStream(file);
final byte[] text = "Hello /u1234".getBytes("UTF8");
out.write(text);
@@ -1994,7 +1974,7 @@ public class FileUtilsTestCase {
@Test
public void testReadFileToByteArray() throws Exception {
- final File file = new File(getTestDirectory(), "read.txt");
+ final File file = new File(temporaryFolder, "read.txt");
final FileOutputStream out = new FileOutputStream(file);
out.write(11);
out.write(21);
@@ -2010,7 +1990,7 @@ public class FileUtilsTestCase {
@Test
public void testReadLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
try {
final String[] data = new String[]{"hello", "/u1234", "", "this is", "some text"};
TestUtils.createLineBasedFile(file, data);
@@ -2024,7 +2004,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteStringToFile1() throws Exception {
- final File file = new File(getTestDirectory(), "write.txt");
+ final File file = new File(temporaryFolder, "write.txt");
FileUtils.writeStringToFile(file, "Hello /u1234", "UTF8");
final byte[] text = "Hello /u1234".getBytes("UTF8");
TestUtils.assertEqualContent(text, file);
@@ -2032,7 +2012,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteStringToFile2() throws Exception {
- final File file = new File(getTestDirectory(), "write.txt");
+ final File file = new File(temporaryFolder, "write.txt");
FileUtils.writeStringToFile(file, "Hello /u1234", (String) null);
final byte[] text = "Hello /u1234".getBytes();
TestUtils.assertEqualContent(text, file);
@@ -2040,7 +2020,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteStringToFile3() throws Exception {
- final File file = new File(getTestDirectory(), "write.txt");
+ final File file = new File(temporaryFolder, "write.txt");
FileUtils.writeStringToFile(file, "Hello /u1234", (Charset) null);
final byte[] text = "Hello /u1234".getBytes();
TestUtils.assertEqualContent(text, file);
@@ -2048,7 +2028,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteCharSequence1() throws Exception {
- final File file = new File(getTestDirectory(), "write.txt");
+ final File file = new File(temporaryFolder, "write.txt");
FileUtils.write(file, "Hello /u1234", "UTF8");
final byte[] text = "Hello /u1234".getBytes("UTF8");
TestUtils.assertEqualContent(text, file);
@@ -2056,7 +2036,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteCharSequence2() throws Exception {
- final File file = new File(getTestDirectory(), "write.txt");
+ final File file = new File(temporaryFolder, "write.txt");
FileUtils.write(file, "Hello /u1234", (String) null);
final byte[] text = "Hello /u1234".getBytes();
TestUtils.assertEqualContent(text, file);
@@ -2064,7 +2044,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteByteArrayToFile() throws Exception {
- final File file = new File(getTestDirectory(), "write.obj");
+ final File file = new File(temporaryFolder, "write.obj");
final byte[] data = new byte[]{11, 21, 31};
FileUtils.writeByteArrayToFile(file, data);
TestUtils.assertEqualContent(data, file);
@@ -2072,7 +2052,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteByteArrayToFile_WithOffsetAndLength() throws Exception {
- final File file = new File(getTestDirectory(), "write.obj");
+ final File file = new File(temporaryFolder, "write.obj");
final byte[] data = new byte[]{11, 21, 32, 41, 51};
final byte[] writtenData = new byte[3];
System.arraycopy(data, 1, writtenData, 0, 3);
@@ -2086,7 +2066,7 @@ public class FileUtilsTestCase {
"hello", new StringBuffer("world"), "", "this is", null, "some text"};
final List<Object> list = Arrays.asList(data);
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeLines(file, "US-ASCII", list, "*");
final String expected = "hello*world**this is**some text*";
@@ -2096,10 +2076,10 @@ public class FileUtilsTestCase {
@Test
public void testWriteLines_4arg_Writer_nullData() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeLines(file, "US-ASCII", null, "*");
- assertEquals("Sizes differ", 0, file.length());
+ assertEquals(0, file.length(), "Sizes differ");
}
@Test
@@ -2108,7 +2088,7 @@ public class FileUtilsTestCase {
"hello", new StringBuffer("world"), "", "this is", null, "some text"};
final List<Object> list = Arrays.asList(data);
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeLines(file, "US-ASCII", list, null);
final String expected = "hello" + IOUtils.LINE_SEPARATOR + "world" + IOUtils.LINE_SEPARATOR +
@@ -2124,7 +2104,7 @@ public class FileUtilsTestCase {
"hello", new StringBuffer("world"), "", "this is", null, "some text"};
final List<Object> list = Arrays.asList(data);
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeLines(file, "US-ASCII", list);
final String expected = "hello" + IOUtils.LINE_SEPARATOR + "world" + IOUtils.LINE_SEPARATOR +
@@ -2136,7 +2116,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteLines_5argsWithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final List<String> linesToAppend = Arrays.asList("my first line", "The second Line");
@@ -2152,7 +2132,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteLines_5argsWithAppendOptionFalse_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final List<String> linesToAppend = Arrays.asList("my first line", "The second Line");
@@ -2167,7 +2147,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteLines_4argsWithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final List<String> linesToAppend = Arrays.asList("my first line", "The second Line");
@@ -2183,7 +2163,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteLines_4argsWithAppendOptionFalse_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final List<String> linesToAppend = Arrays.asList("my first line", "The second Line");
@@ -2199,7 +2179,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteLinesEncoding_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final List<String> linesToAppend = Arrays.asList("my first line", "The second Line");
@@ -2215,7 +2195,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteLinesEncoding_WithAppendOptionFalse_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final List<String> linesToAppend = Arrays.asList("my first line", "The second Line");
@@ -2230,7 +2210,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteLines_3argsWithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final List<String> linesToAppend = Arrays.asList("my first line", "The second Line");
@@ -2246,7 +2226,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteLines_3argsWithAppendOptionFalse_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final List<String> linesToAppend = Arrays.asList("my first line", "The second Line");
@@ -2261,7 +2241,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteStringToFileWithEncoding_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.writeStringToFile(file, "this is brand new data", (String) null, true);
@@ -2274,7 +2254,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteStringToFileWithEncoding_WithAppendOptionFalse_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.writeStringToFile(file, "this is brand new data", (String) null, false);
@@ -2286,7 +2266,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteStringToFile_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.writeStringToFile(file, "this is brand new data", true);
@@ -2299,7 +2279,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteStringToFile_WithAppendOptionFalse_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.writeStringToFile(file, "this is brand new data", false);
@@ -2311,7 +2291,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteWithEncoding_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.write(file, "this is brand new data", (String) null, true);
@@ -2324,7 +2304,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteWithEncoding_WithAppendOptionFalse_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.write(file, "this is brand new data", (String) null, false);
@@ -2336,7 +2316,7 @@ public class FileUtilsTestCase {
@Test
public void testWrite_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.write(file, "this is brand new data", true);
@@ -2349,7 +2329,7 @@ public class FileUtilsTestCase {
@Test
public void testWrite_WithAppendOptionFalse_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.write(file, "this is brand new data", false);
@@ -2361,7 +2341,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteByteArrayToFile_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.writeByteArrayToFile(file, "this is brand new data".getBytes(), true);
@@ -2374,7 +2354,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteByteArrayToFile_WithAppendOptionFalse_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
FileUtils.writeByteArrayToFile(file, "this is brand new data".getBytes(), false);
@@ -2386,7 +2366,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteByteArrayToFile_WithOffsetAndLength_WithAppendOptionTrue_ShouldNotDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final byte[] data = "SKIP_THIS_this is brand new data_AND_SKIP_THIS".getBytes(Charsets.UTF_8);
@@ -2399,7 +2379,7 @@ public class FileUtilsTestCase {
@Test
public void testWriteByteArrayToFile_WithOffsetAndLength_WithAppendOptionTrue_ShouldDeletePreviousFileLines() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
FileUtils.writeStringToFile(file, "This line was there before you...");
final byte[] data = "SKIP_THIS_this is brand new data_AND_SKIP_THIS".getBytes(Charsets.UTF_8);
@@ -2415,7 +2395,7 @@ public class FileUtilsTestCase {
public void testChecksumCRC32() throws Exception {
// create a test file
final String text = "Imagination is more important than knowledge - Einstein";
- final File file = new File(getTestDirectory(), "checksum-test.txt");
+ final File file = new File(temporaryFolder, "checksum-test.txt");
FileUtils.writeStringToFile(file, text, "US-ASCII");
// compute the expected checksum
@@ -2433,7 +2413,7 @@ public class FileUtilsTestCase {
public void testChecksum() throws Exception {
// create a test file
final String text = "Imagination is more important than knowledge - Einstein";
- final File file = new File(getTestDirectory(), "checksum-test.txt");
+ final File file = new File(temporaryFolder, "checksum-test.txt");
FileUtils.writeStringToFile(file, text, "US-ASCII");
// compute the expected checksum
@@ -2464,7 +2444,7 @@ public class FileUtilsTestCase {
public void testChecksumOnNullChecksum() throws Exception {
// create a test file
final String text = "Imagination is more important than knowledge - Einstein";
- final File file = new File(getTestDirectory(), "checksum-test.txt");
+ final File file = new File(temporaryFolder, "checksum-test.txt");
FileUtils.writeStringToFile(file, text, "US-ASCII");
try {
FileUtils.checksum(file, null);
@@ -2488,12 +2468,12 @@ public class FileUtilsTestCase {
public void testChecksumDouble() throws Exception {
// create a test file
final String text1 = "Imagination is more important than knowledge - Einstein";
- final File file1 = new File(getTestDirectory(), "checksum-test.txt");
+ final File file1 = new File(temporaryFolder, "checksum-test.txt");
FileUtils.writeStringToFile(file1, text1, "US-ASCII");
// create a second test file
final String text2 = "To be or not to be - Shakespeare";
- final File file2 = new File(getTestDirectory(), "checksum-test2.txt");
+ final File file2 = new File(temporaryFolder, "checksum-test2.txt");
FileUtils.writeStringToFile(file2, text2, "US-ASCII");
// compute the expected checksum
@@ -2532,7 +2512,7 @@ public class FileUtilsTestCase {
@Test
public void testDeleteQuietlyDir() throws IOException {
- final File testDirectory = new File(getTestDirectory(), "testDeleteQuietlyDir");
+ final File testDirectory = new File(temporaryFolder, "testDeleteQuietlyDir");
final File testFile = new File(testDirectory, "testDeleteQuietlyFile");
testDirectory.mkdirs();
if (!testFile.getParentFile().exists()) {
@@ -2550,13 +2530,13 @@ public class FileUtilsTestCase {
assertTrue(testDirectory.exists());
assertTrue(testFile.exists());
FileUtils.deleteQuietly(testDirectory);
- assertFalse("Check No Exist", testDirectory.exists());
- assertFalse("Check No Exist", testFile.exists());
+ assertFalse(testDirectory.exists(), "Check No Exist");
+ assertFalse(testFile.exists(), "Check No Exist");
}
@Test
public void testDeleteQuietlyFile() throws IOException {
- final File testFile = new File(getTestDirectory(), "testDeleteQuietlyFile");
+ final File testFile = new File(temporaryFolder, "testDeleteQuietlyFile");
if (!testFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + testFile
+ " as the parent directory does not exist");
@@ -2571,7 +2551,7 @@ public class FileUtilsTestCase {
assertTrue(testFile.exists());
FileUtils.deleteQuietly(testFile);
- assertFalse("Check No Exist", testFile.exists());
+ assertFalse(testFile.exists(), "Check No Exist");
}
@Test
@@ -2588,16 +2568,16 @@ public class FileUtilsTestCase {
@Test
public void testMoveFile_Rename() throws Exception {
- final File destination = new File(getTestDirectory(), "move1.txt");
+ final File destination = new File(temporaryFolder, "move1.txt");
FileUtils.moveFile(testFile1, destination);
- assertTrue("Check Exist", destination.exists());
- assertTrue("Original deleted", !testFile1.exists());
+ assertTrue(destination.exists(), "Check Exist");
+ assertTrue(!testFile1.exists(), "Original deleted");
}
@Test
public void testMoveFile_CopyDelete() throws Exception {
- final File destination = new File(getTestDirectory(), "move2.txt");
+ final File destination = new File(temporaryFolder, "move2.txt");
final File src = new File(testFile1.getAbsolutePath()) {
private static final long serialVersionUID = 1L;
@@ -2609,13 +2589,13 @@ public class FileUtilsTestCase {
}
};
FileUtils.moveFile(src, destination);
- assertTrue("Check Exist", destination.exists());
- assertTrue("Original deleted", !src.exists());
+ assertTrue(destination.exists(), "Check Exist");
+ assertTrue(!src.exists(), "Original deleted");
}
@Test
public void testMoveFile_CopyDelete_Failed() throws Exception {
- final File destination = new File(getTestDirectory(), "move3.txt");
+ final File destination = new File(temporaryFolder, "move3.txt");
final File src = new File(testFile1.getAbsolutePath()) {
private static final long serialVersionUID = 1L;
@@ -2638,8 +2618,8 @@ public class FileUtilsTestCase {
fail("move should have failed as src has not been deleted");
} catch (final IOException e) {
// exepected
- assertTrue("Check Rollback", !destination.exists());
- assertTrue("Original exists", src.exists());
+ assertTrue(!destination.exists(), "Check Rollback");
+ assertTrue(src.exists(), "Original exists");
}
}
@@ -2664,13 +2644,13 @@ public class FileUtilsTestCase {
// expected
}
try {
- FileUtils.moveFile(getTestDirectory(), new File("foo"));
+ FileUtils.moveFile(temporaryFolder, new File("foo"));
fail("Expected IOException when source is a directory");
} catch (final IOException e) {
// expected
}
- final File testSourceFile = new File(getTestDirectory(), "testMoveFileSource");
- final File testDestFile = new File(getTestDirectory(), "testMoveFileSource");
+ final File testSourceFile = new File(temporaryFolder, "testMoveFileSource");
+ final File testDestFile = new File(temporaryFolder, "testMoveFileSource");
if (!testSourceFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + testSourceFile
+ " as the parent directory does not exist");
@@ -2703,14 +2683,14 @@ public class FileUtilsTestCase {
@Test
public void testMoveFileToDirectory() throws Exception {
- final File destDir = new File(getTestDirectory(), "moveFileDestDir");
+ final File destDir = new File(temporaryFolder, "moveFileDestDir");
final File movedFile = new File(destDir, testFile1.getName());
- assertFalse("Check Exist before", destDir.exists());
- assertFalse("Check Exist before", movedFile.exists());
+ assertFalse(destDir.exists(), "Check Exist before");
+ assertFalse(movedFile.exists(), "Check Exist before");
FileUtils.moveFileToDirectory(testFile1, destDir, true);
- assertTrue("Check Exist after", movedFile.exists());
- assertTrue("Original deleted", !testFile1.exists());
+ assertTrue(movedFile.exists(), "Check Exist after");
+ assertTrue(!testFile1.exists(), "Original deleted");
}
@Test
@@ -2727,8 +2707,8 @@ public class FileUtilsTestCase {
} catch (final NullPointerException e) {
// expected
}
- final File testFile1 = new File(getTestDirectory(), "testMoveFileFile1");
- final File testFile2 = new File(getTestDirectory(), "testMoveFileFile2");
+ final File testFile1 = new File(temporaryFolder, "testMoveFileFile1");
+ final File testFile2 = new File(temporaryFolder, "testMoveFileFile2");
if (!testFile1.getParentFile().exists()) {
throw new IOException("Cannot create file " + testFile1
+ " as the parent directory does not exist");
@@ -2758,7 +2738,7 @@ public class FileUtilsTestCase {
// expected
}
- final File nonexistant = new File(getTestDirectory(), "testMoveFileNonExistant");
+ final File nonexistant = new File(temporaryFolder, "testMoveFileNonExistant");
try {
FileUtils.moveFileToDirectory(testFile1, nonexistant, false);
fail("Expected IOException when dest does not exist and create=false");
@@ -2770,7 +2750,7 @@ public class FileUtilsTestCase {
@Test
public void testMoveDirectory_Rename() throws Exception {
- final File dir = getTestDirectory();
+ final File dir = temporaryFolder;
final File src = new File(dir, "testMoveDirectory1Source");
final File testDir = new File(src, "foo");
final File testFile = new File(testDir, "bar");
@@ -2793,18 +2773,18 @@ public class FileUtilsTestCase {
FileUtils.moveDirectory(src, destination);
// Check results
- assertTrue("Check Exist", destination.exists());
- assertTrue("Original deleted", !src.exists());
+ assertTrue(destination.exists(), "Check Exist");
+ assertTrue(!src.exists(), "Original deleted");
final File movedDir = new File(destination, testDir.getName());
final File movedFile = new File(movedDir, testFile.getName());
- assertTrue("Check dir moved", movedDir.exists());
- assertTrue("Check file moved", movedFile.exists());
+ assertTrue(movedDir.exists(), "Check dir moved");
+ assertTrue(movedFile.exists(), "Check file moved");
}
@Test
public void testMoveDirectory_CopyDelete() throws Exception {
- final File dir = getTestDirectory();
+ final File dir = temporaryFolder;
final File src = new File(dir, "testMoveDirectory2Source") {
private static final long serialVersionUID = 1L;
@@ -2835,12 +2815,12 @@ public class FileUtilsTestCase {
FileUtils.moveDirectory(src, destination);
// Check results
- assertTrue("Check Exist", destination.exists());
- assertTrue("Original deleted", !src.exists());
+ assertTrue(destination.exists(), "Check Exist");
+ assertTrue(!src.exists(), "Original deleted");
final File movedDir = new File(destination, testDir.getName());
final File movedFile = new File(movedDir, testFile.getName());
- assertTrue("Check dir moved", movedDir.exists());
- assertTrue("Check file moved", movedFile.exists());
+ assertTrue(movedDir.exists(), "Check dir moved");
+ assertTrue(movedFile.exists(), "Check file moved");
}
@Test
@@ -2863,7 +2843,7 @@ public class FileUtilsTestCase {
} catch (final FileNotFoundException e) {
// expected
}
- final File testFile = new File(getTestDirectory(), "testMoveDirectoryFile");
+ final File testFile = new File(temporaryFolder, "testMoveDirectoryFile");
if (!testFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + testFile
+ " as the parent directory does not exist");
@@ -2881,8 +2861,8 @@ public class FileUtilsTestCase {
} catch (final IOException e) {
// expected
}
- final File testSrcFile = new File(getTestDirectory(), "testMoveDirectorySource");
- final File testDestFile = new File(getTestDirectory(), "testMoveDirectoryDest");
+ final File testSrcFile = new File(temporaryFolder, "testMoveDirectorySource");
+ final File testDestFile = new File(temporaryFolder, "testMoveDirectoryDest");
testSrcFile.mkdir();
testDestFile.mkdir();
try {
@@ -2895,7 +2875,7 @@ public class FileUtilsTestCase {
@Test
public void testMoveDirectoryToDirectory() throws Exception {
- final File dir = getTestDirectory();
+ final File dir = temporaryFolder;
final File src = new File(dir, "testMoveDirectory1Source");
final File testChildDir = new File(src, "foo");
final File testFile = new File(testChildDir, "bar");
@@ -2913,20 +2893,20 @@ public class FileUtilsTestCase {
}
final File destDir = new File(dir, "testMoveDirectory1Dest");
FileUtils.deleteDirectory(destDir);
- assertFalse("Check Exist before", destDir.exists());
+ assertFalse(destDir.exists(), "Check Exist before");
// Move the directory
FileUtils.moveDirectoryToDirectory(src, destDir, true);
// Check results
- assertTrue("Check Exist after", destDir.exists());
- assertTrue("Original deleted", !src.exists());
+ assertTrue(destDir.exists(), "Check Exist after");
+ assertTrue(!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());
- assertTrue("Check dir moved", movedDir.exists());
- assertTrue("Check child dir moved", movedChildDir.exists());
- assertTrue("Check file moved", movedFile.exists());
+ assertTrue(movedDir.exists(), "Check dir moved");
+ assertTrue(movedChildDir.exists(), "Check child dir moved");
+ assertTrue(movedFile.exists(), "Check file moved");
}
@Test
@@ -2943,8 +2923,8 @@ public class FileUtilsTestCase {
} catch (final NullPointerException e) {
// expected
}
- final File testFile1 = new File(getTestDirectory(), "testMoveFileFile1");
- final File testFile2 = new File(getTestDirectory(), "testMoveFileFile2");
+ final File testFile1 = new File(temporaryFolder, "testMoveFileFile1");
+ final File testFile2 = new File(temporaryFolder, "testMoveFileFile2");
if (!testFile1.getParentFile().exists()) {
throw new IOException("Cannot create file " + testFile1
+ " as the parent directory does not exist");
@@ -2974,7 +2954,7 @@ public class FileUtilsTestCase {
// expected
}
- final File nonexistant = new File(getTestDirectory(), "testMoveFileNonExistant");
+ final File nonexistant = new File(temporaryFolder, "testMoveFileNonExistant");
try {
FileUtils.moveDirectoryToDirectory(testFile1, nonexistant, false);
fail("Expected IOException when dest does not exist and create=false");
@@ -2985,9 +2965,9 @@ public class FileUtilsTestCase {
@Test
public void testMoveToDirectory() throws Exception {
- final File destDir = new File(getTestDirectory(), "testMoveToDirectoryDestDir");
- final File testDir = new File(getTestDirectory(), "testMoveToDirectoryTestDir");
- final File testFile = new File(getTestDirectory(), "testMoveToDirectoryTestFile");
+ final File destDir = new File(temporaryFolder, "testMoveToDirectoryDestDir");
+ final File testDir = new File(temporaryFolder, "testMoveToDirectoryTestDir");
+ final File testFile = new File(temporaryFolder, "testMoveToDirectoryTestFile");
testDir.mkdirs();
if (!testFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + testFile
@@ -3003,18 +2983,18 @@ public class FileUtilsTestCase {
final File movedFile = new File(destDir, testFile.getName());
final File movedDir = new File(destDir, testFile.getName());
- assertFalse("Check File Doesnt exist", movedFile.exists());
- assertFalse("Check Dir Doesnt exist", movedDir.exists());
+ assertFalse(movedFile.exists(), "Check File Doesnt exist");
+ assertFalse(movedDir.exists(), "Check Dir Doesnt exist");
// Test moving a file
FileUtils.moveToDirectory(testFile, destDir, true);
- assertTrue("Check File exists", movedFile.exists());
- assertFalse("Check Original File doesn't exist", testFile.exists());
+ assertTrue(movedFile.exists(), "Check File exists");
+ assertFalse(testFile.exists(), "Check Original File doesn't exist");
// Test moving a directory
FileUtils.moveToDirectory(testDir, destDir, true);
- assertTrue("Check Dir exists", movedDir.exists());
- assertFalse("Check Original Dir doesn't exist", testDir.exists());
+ assertTrue(movedDir.exists(), "Check Dir exists");
+ assertFalse(testDir.exists(), "Check Original Dir doesn't exist");
}
@Test
@@ -3031,8 +3011,8 @@ public class FileUtilsTestCase {
} catch (final NullPointerException e) {
// expected
}
- final File nonexistant = new File(getTestDirectory(), "nonexistant");
- final File destDir = new File(getTestDirectory(), "MoveToDirectoryDestDir");
+ final File nonexistant = new File(temporaryFolder, "nonexistant");
+ final File destDir = new File(temporaryFolder, "MoveToDirectoryDestDir");
try {
FileUtils.moveToDirectory(nonexistant, destDir, true);
fail("Expected IOException when source does not exist");
@@ -3043,7 +3023,7 @@ public class FileUtilsTestCase {
@Test
public void testIO300() throws Exception {
- final File testDirectory = getTestDirectory();
+ final File testDirectory = temporaryFolder;
final File src = new File(testDirectory, "dir1");
final File dest = new File(src, "dir2");
assertTrue(dest.mkdirs());
@@ -3060,9 +3040,9 @@ public class FileUtilsTestCase {
@Test
public void testIO276() throws Exception {
final File dir = new File("target", "IO276");
- assertTrue(dir + " should not be present", dir.mkdirs());
+ assertTrue(dir.mkdirs(), dir + " should not be present");
final File file = new File(dir, "IO276.txt");
- assertTrue(file + " should not be present", file.createNewFile());
+ assertTrue(file.createNewFile(), file + " should not be present");
FileUtils.forceDeleteOnExit(dir);
// If this does not work, test will fail next time (assuming target is not cleaned)
}
@@ -3091,7 +3071,7 @@ public class FileUtilsTestCase {
fail("Expected IOException");
} catch (final Exception e) {
final String msg = e.toString();
- assertTrue(msg, msg.contains("Failed to copy full contents"));
+ assertTrue(msg.contains("Failed to copy full contents"), msg);
} finally {
outFile.delete(); // tidy up
}
diff --git a/src/test/java/org/apache/commons/io/FileUtilsWaitForTestCase.java b/src/test/java/org/apache/commons/io/FileUtilsWaitForTestCase.java
index c4081dd..a06f640 100644
--- a/src/test/java/org/apache/commons/io/FileUtilsWaitForTestCase.java
+++ b/src/test/java/org/apache/commons/io/FileUtilsWaitForTestCase.java
@@ -16,13 +16,13 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* This is used to test FileUtils.waitFor() method for correctness.
diff --git a/src/test/java/org/apache/commons/io/FilenameUtilsTestCase.java b/src/test/java/org/apache/commons/io/FilenameUtilsTestCase.java
index 38f1555..7fd7cd3 100644
--- a/src/test/java/org/apache/commons/io/FilenameUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/io/FilenameUtilsTestCase.java
@@ -16,10 +16,11 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+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 static org.junit.jupiter.api.Assertions.fail;
import java.io.BufferedOutputStream;
import java.io.File;
@@ -30,10 +31,9 @@ import java.util.Arrays;
import java.util.Collection;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* This is used to test FilenameUtils for correctness.
@@ -42,8 +42,8 @@ import org.junit.rules.TemporaryFolder;
*/
public class FilenameUtilsTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
+ @TempDir
+ public File temporaryFolder;
private static final String SEP = "" + File.separatorChar;
private static final boolean WINDOWS = File.separatorChar == '\\';
@@ -54,10 +54,10 @@ public class FilenameUtilsTestCase {
private int testFile1Size;
private int testFile2Size;
- @Before
+ @BeforeEach
public void setUp() throws Exception {
- testFile1 = temporaryFolder.newFile("file1-test.txt");
- testFile2 = temporaryFolder.newFile("file1a-test.txt");
+ testFile1 = File.createTempFile("test", "1", temporaryFolder);
+ testFile2 = File.createTempFile("test", "2", temporaryFolder);
testFile1Size = (int) testFile1.length();
testFile2Size = (int) testFile2.length();
@@ -717,9 +717,9 @@ public class FilenameUtilsTestCase {
assertEquals("a/b/", FilenameUtils.getPath("~user/a/b/c.txt"));
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void testGetPath_with_nullbyte() {
- assertEquals("a/b/", FilenameUtils.getPath("~user/a/\u0000b/c.txt"));
+ assertThrows(IllegalArgumentException.class, () -> FilenameUtils.getPath("~user/a/\u0000b/c.txt"));
}
diff --git a/src/test/java/org/apache/commons/io/FilenameUtilsWildcardTestCase.java b/src/test/java/org/apache/commons/io/FilenameUtilsWildcardTestCase.java
index 35191d9..d596e8f 100644
--- a/src/test/java/org/apache/commons/io/FilenameUtilsWildcardTestCase.java
+++ b/src/test/java/org/apache/commons/io/FilenameUtilsWildcardTestCase.java
@@ -16,15 +16,15 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+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.assertTrue;
import java.io.File;
import java.util.Locale;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class FilenameUtilsWildcardTestCase {
@@ -134,7 +134,7 @@ public class FilenameUtilsWildcardTestCase {
}
private void assertMatch(final String text, final String wildcard, final boolean expected) {
- assertEquals(text + " " + wildcard, expected, FilenameUtils.wildcardMatch(text, wildcard));
+ assertEquals(expected, FilenameUtils.wildcardMatch(text, wildcard), text + " " + wildcard);
}
// A separate set of tests, added to this batch
@@ -233,9 +233,9 @@ public class FilenameUtilsWildcardTestCase {
for (int i = 0; i < data.length; i++) {
for (final Locale locale : locales) {
Locale.setDefault(locale);
- assertTrue("Test data corrupt: " + i, data[i][0].equalsIgnoreCase(data[i][1]));
+ assertTrue(data[i][0].equalsIgnoreCase(data[i][1]), "Test data corrupt: " + i);
final boolean match = FilenameUtils.wildcardMatch(data[i][0], data[i][1], IOCase.INSENSITIVE);
- assertTrue(Locale.getDefault().toString() + ": " + i, match);
+ assertTrue(match, Locale.getDefault().toString() + ": " + i);
}
}
} finally {
diff --git a/src/test/java/org/apache/commons/io/HexDumpTest.java b/src/test/java/org/apache/commons/io/HexDumpTest.java
index dbb7e80..cef0b5c 100644
--- a/src/test/java/org/apache/commons/io/HexDumpTest.java
+++ b/src/test/java/org/apache/commons/io/HexDumpTest.java
@@ -16,13 +16,13 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.IOException;
import org.apache.commons.io.output.ByteArrayOutputStream;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
@@ -78,11 +78,9 @@ public class HexDumpTest {
}
byte[] actualOutput = stream.toByteArray();
- assertEquals("array size mismatch", outputArray.length,
- actualOutput.length);
+ assertEquals(outputArray.length, actualOutput.length, "array size mismatch");
for (int j = 0; j < outputArray.length; j++) {
- assertEquals("array[ " + j + "] mismatch", outputArray[j],
- actualOutput[j]);
+ assertEquals(outputArray[j], actualOutput[j], "array[ " + j + "] mismatch");
}
// verify proper behavior with non-zero offset
@@ -113,11 +111,9 @@ public class HexDumpTest {
HexDump.EOL.getBytes().length);
}
actualOutput = stream.toByteArray();
- assertEquals("array size mismatch", outputArray.length,
- actualOutput.length);
+ assertEquals(outputArray.length, actualOutput.length, "array size mismatch");
for (int j = 0; j < outputArray.length; j++) {
- assertEquals("array[ " + j + "] mismatch", outputArray[j],
- actualOutput[j]);
+ assertEquals(outputArray[j], actualOutput[j], "array[ " + j + "] mismatch");
}
// verify proper behavior with negative offset
@@ -148,11 +144,9 @@ public class HexDumpTest {
HexDump.EOL.getBytes().length);
}
actualOutput = stream.toByteArray();
- assertEquals("array size mismatch", outputArray.length,
- actualOutput.length);
+ assertEquals(outputArray.length, actualOutput.length, "array size mismatch");
for (int j = 0; j < outputArray.length; j++) {
- assertEquals("array[ " + j + "] mismatch", outputArray[j],
- actualOutput[j]);
+ assertEquals(outputArray[j], actualOutput[j], "array[ " + j + "] mismatch");
}
// verify proper behavior with non-zero index
@@ -194,11 +188,9 @@ public class HexDumpTest {
HexDump.EOL.getBytes().length);
}
actualOutput = stream.toByteArray();
- assertEquals("array size mismatch", outputArray.length,
- actualOutput.length);
+ assertEquals(outputArray.length, actualOutput.length, "array size mismatch");
for (int j = 0; j < outputArray.length; j++) {
- assertEquals("array[ " + j + "] mismatch", outputArray[j],
- actualOutput[j]);
+ assertEquals(outputArray[j], actualOutput[j], "array[ " + j + "] mismatch");
}
// verify proper behavior with negative index
diff --git a/src/test/java/org/apache/commons/io/IOCaseTestCase.java b/src/test/java/org/apache/commons/io/IOCaseTestCase.java
index 2638787..1939d90 100644
--- a/src/test/java/org/apache/commons/io/IOCaseTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOCaseTestCase.java
@@ -16,11 +16,11 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@@ -28,7 +28,7 @@ import java.io.File;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* This is used to test IOCase for correctness.
diff --git a/src/test/java/org/apache/commons/io/IOExceptionListTestCase.java b/src/test/java/org/apache/commons/io/IOExceptionListTestCase.java
index 7289129..1dc889e 100644
--- a/src/test/java/org/apache/commons/io/IOExceptionListTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOExceptionListTestCase.java
@@ -17,12 +17,15 @@
package org.apache.commons.io;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
import java.io.EOFException;
import java.util.Collections;
import java.util.List;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class IOExceptionListTestCase {
@@ -31,21 +34,21 @@ public class IOExceptionListTestCase {
final EOFException cause = new EOFException();
final List<EOFException> list = Collections.singletonList(cause);
final IOExceptionList sqlExceptionList = new IOExceptionList(list);
- Assert.assertEquals(cause, sqlExceptionList.getCause());
- Assert.assertEquals(cause, sqlExceptionList.getCause(0));
- Assert.assertEquals(list, sqlExceptionList.getCauseList());
- Assert.assertEquals(list, sqlExceptionList.getCauseList(EOFException.class));
- Assert.assertEquals(cause, sqlExceptionList.getCause(0, EOFException.class));
+ assertEquals(cause, sqlExceptionList.getCause());
+ assertEquals(cause, sqlExceptionList.getCause(0));
+ assertEquals(list, sqlExceptionList.getCauseList());
+ assertEquals(list, sqlExceptionList.getCauseList(EOFException.class));
+ assertEquals(cause, sqlExceptionList.getCause(0, EOFException.class));
// No CCE:
final List<EOFException> causeList = sqlExceptionList.getCauseList();
- Assert.assertEquals(list, causeList);
+ assertEquals(list, causeList);
}
@Test
public void testNullCause() {
final IOExceptionList sqlExceptionList = new IOExceptionList(null);
- Assert.assertNull(sqlExceptionList.getCause());
- Assert.assertTrue(sqlExceptionList.getCauseList().isEmpty());
+ assertNull(sqlExceptionList.getCause());
+ assertTrue(sqlExceptionList.getCauseList().isEmpty());
}
@Test
diff --git a/src/test/java/org/apache/commons/io/IOExceptionWithCauseTestCase.java b/src/test/java/org/apache/commons/io/IOExceptionWithCauseTestCase.java
index cd2eabf..60f32f8 100644
--- a/src/test/java/org/apache/commons/io/IOExceptionWithCauseTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOExceptionWithCauseTestCase.java
@@ -17,12 +17,12 @@
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
import java.io.IOException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Tests IOExceptionWithCause
diff --git a/src/test/java/org/apache/commons/io/IOIndexedExceptionTestCase.java b/src/test/java/org/apache/commons/io/IOIndexedExceptionTestCase.java
index bed9157..fb9c808 100644
--- a/src/test/java/org/apache/commons/io/IOIndexedExceptionTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOIndexedExceptionTestCase.java
@@ -17,10 +17,12 @@
package org.apache.commons.io;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
import java.io.EOFException;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Tests {@link IOIndexedException}.
@@ -32,17 +34,17 @@ public class IOIndexedExceptionTestCase {
@Test
public void testEdge() {
final IOIndexedException exception = new IOIndexedException(-1, null);
- Assert.assertEquals(-1, exception.getIndex());
- Assert.assertEquals(null, exception.getCause());
- Assert.assertNotNull(exception.getMessage());
+ assertEquals(-1, exception.getIndex());
+ assertEquals(null, exception.getCause());
+ assertNotNull(exception.getMessage());
}
@Test
public void testPlain() {
final EOFException e = new EOFException("end");
final IOIndexedException exception = new IOIndexedException(0, e);
- Assert.assertEquals(0, exception.getIndex());
- Assert.assertEquals(e, exception.getCause());
- Assert.assertNotNull(exception.getMessage());
+ assertEquals(0, exception.getIndex());
+ assertEquals(e, 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 a50b054..755e93c 100644
--- a/src/test/java/org/apache/commons/io/IOUtilsCopyTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOUtilsCopyTestCase.java
@@ -16,8 +16,9 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
@@ -36,7 +37,7 @@ import org.apache.commons.io.output.NullWriter;
import org.apache.commons.io.testtools.TestUtils;
import org.apache.commons.io.testtools.YellOnCloseInputStream;
import org.apache.commons.io.testtools.YellOnFlushAndCloseOutputStream;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* JUnit tests for IOUtils copy methods.
@@ -69,9 +70,9 @@ public class IOUtilsCopyTestCase {
final int count = IOUtils.copy(in, out);
- assertEquals("Not all bytes were read", 0, in.available());
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(0, in.available(), "Not all bytes were read");
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
assertEquals(inData.length,count);
}
@@ -91,19 +92,19 @@ public class IOUtilsCopyTestCase {
in.close();
// Test copyLarge() method
- assertEquals("copyLarge()", size, IOUtils.copyLarge(in, out));
+ assertEquals(size, IOUtils.copyLarge(in, out), "copyLarge()");
}
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_inputStreamToOutputStream_nullIn() throws Exception {
final OutputStream out = new ByteArrayOutputStream();
- IOUtils.copy((InputStream) null, out);
+ assertThrows(NullPointerException.class, () -> IOUtils.copy((InputStream) null, out));
}
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_inputStreamToOutputStream_nullOut() throws Exception {
final InputStream in = new ByteArrayInputStream(inData);
- IOUtils.copy(in, (OutputStream) null);
+ assertThrows(NullPointerException.class, () -> IOUtils.copy(in, (OutputStream) null));
}
@Test
@@ -135,9 +136,9 @@ public class IOUtilsCopyTestCase {
final long count = IOUtils.copy(in, out, bufferSize);
- assertEquals("Not all bytes were read", 0, in.available());
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(0, in.available(), "Not all bytes were read");
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
assertEquals(inData.length,count);
}
@@ -156,9 +157,9 @@ public class IOUtilsCopyTestCase {
out.off();
writer.flush();
- assertEquals("Not all bytes were read", 0, in.available());
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(0, in.available(), "Not all bytes were read");
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
//-----------------------------------------------------------------------
@@ -176,10 +177,10 @@ public class IOUtilsCopyTestCase {
out.off();
writer.flush();
- assertEquals("Not all bytes were read", 0, in.available());
+ assertEquals(0, in.available(), "Not all bytes were read");
byte[] bytes = baout.toByteArray();
bytes = new String(bytes, "UTF8").getBytes("US-ASCII");
- assertTrue("Content differs", Arrays.equals(inData, bytes));
+ assertTrue(Arrays.equals(inData, bytes), "Content differs");
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
@@ -196,39 +197,39 @@ public class IOUtilsCopyTestCase {
out.off();
writer.flush();
- assertEquals("Not all bytes were read", 0, in.available());
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(0, in.available(), "Not all bytes were read");
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_inputStreamToWriter_Encoding_nullIn() throws Exception {
final ByteArrayOutputStream baout = new ByteArrayOutputStream();
final OutputStream out = new YellOnFlushAndCloseOutputStream(baout, true, true);
final Writer writer = new OutputStreamWriter(out, "US-ASCII");
- IOUtils.copy(null, writer, "UTF8");
+ assertThrows(NullPointerException.class, () -> IOUtils.copy(null, writer, "UTF8"));
}
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_inputStreamToWriter_Encoding_nullOut() throws Exception {
final InputStream in = new ByteArrayInputStream(inData);
- IOUtils.copy(in, null, "UTF8");
+ assertThrows(NullPointerException.class, () -> IOUtils.copy(in, null, "UTF8"));
}
@SuppressWarnings("deprecation") // deliberately testing deprecated method
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_inputStreamToWriter_nullIn() throws Exception {
final ByteArrayOutputStream baout = new ByteArrayOutputStream();
final OutputStream out = new YellOnFlushAndCloseOutputStream(baout, true, true);
final Writer writer = new OutputStreamWriter(out, "US-ASCII");
- IOUtils.copy((InputStream) null, writer);
+ assertThrows(NullPointerException.class, () -> IOUtils.copy((InputStream) null, writer));
}
@SuppressWarnings("deprecation") // deliberately testing deprecated method
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_inputStreamToWriter_nullOut() throws Exception {
final InputStream in = new ByteArrayInputStream(inData);
- IOUtils.copy(in, (Writer) null); // deliberately testing deprecated method
+ assertThrows(NullPointerException.class, () -> IOUtils.copy(in, (Writer) null)); // deliberately testing deprecated method
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
@@ -245,9 +246,9 @@ public class IOUtilsCopyTestCase {
final long count = IOUtils.copy(reader, (Appendable) writer);
out.off();
writer.flush();
- assertEquals("The number of characters returned by copy is wrong", inData.length, count);
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ 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");
}
@Test
@@ -263,25 +264,25 @@ public class IOUtilsCopyTestCase {
reader.close();
// Test copyLarge() method
- assertEquals("copy()", size, IOUtils.copyLarge(reader, writer));
+ assertEquals(size, IOUtils.copyLarge(reader, writer), "copy()");
}
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_readerToAppendable_nullIn() throws Exception {
final ByteArrayOutputStream baout = new ByteArrayOutputStream();
final OutputStream out = new YellOnFlushAndCloseOutputStream(baout, true, true);
final Appendable writer = new OutputStreamWriter(out, "US-ASCII");
- IOUtils.copy((Reader) null, writer);
+ assertThrows(NullPointerException.class, () -> IOUtils.copy((Reader) null, writer));
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_readerToAppendable_nullOut() throws Exception {
InputStream in = new ByteArrayInputStream(inData);
in = new YellOnCloseInputStream(in);
final Reader reader = new InputStreamReader(in, "US-ASCII");
- IOUtils.copy(reader, (Appendable) null);
+ assertThrows(NullPointerException.class, () -> IOUtils.copy(reader, (Appendable) null));
}
//-----------------------------------------------------------------------
@@ -303,8 +304,8 @@ public class IOUtilsCopyTestCase {
// out = fout;
// Note: rely on the method to flush
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
//-----------------------------------------------------------------------
@@ -324,7 +325,7 @@ public class IOUtilsCopyTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes, "UTF16").getBytes("US-ASCII");
- assertTrue("Content differs", Arrays.equals(inData, bytes));
+ assertTrue(Arrays.equals(inData, bytes), "Content differs");
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
@@ -341,41 +342,41 @@ public class IOUtilsCopyTestCase {
// note: this method *does* flush.
// note: we don't flush here; this IOUtils method does it for us
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_readerToOutputStream_Encoding_nullIn() throws Exception {
final ByteArrayOutputStream baout = new ByteArrayOutputStream();
final OutputStream out = new YellOnFlushAndCloseOutputStream(baout, true, true);
- IOUtils.copy(null, out, "UTF16");
+ assertThrows(NullPointerException.class, () -> IOUtils.copy(null, out, "UTF16"));
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_readerToOutputStream_Encoding_nullOut() throws Exception {
InputStream in = new ByteArrayInputStream(inData);
in = new YellOnCloseInputStream(in);
final Reader reader = new InputStreamReader(in, "US-ASCII");
- IOUtils.copy(reader, null, "UTF16");
+ assertThrows(NullPointerException.class, () -> IOUtils.copy(reader, null, "UTF16"));
}
@SuppressWarnings("deprecation")
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_readerToOutputStream_nullIn() throws Exception { // deliberately testing deprecated method
final ByteArrayOutputStream baout = new ByteArrayOutputStream();
final OutputStream out = new YellOnFlushAndCloseOutputStream(baout, true, true);
- IOUtils.copy((Reader) null, out);
+ assertThrows(NullPointerException.class, () -> IOUtils.copy((Reader) null, out));
}
@SuppressWarnings({ "resource", "deprecation" }) // 'in' is deliberately not closed
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_readerToOutputStream_nullOut() throws Exception {
InputStream in = new ByteArrayInputStream(inData);
in = new YellOnCloseInputStream(in);
final Reader reader = new InputStreamReader(in, "US-ASCII");
- IOUtils.copy(reader, (OutputStream) null); // deliberately testing deprecated method
+ assertThrows(NullPointerException.class, () -> IOUtils.copy(reader, (OutputStream) null)); // deliberately testing deprecated method
}
//-----------------------------------------------------------------------
@@ -393,9 +394,9 @@ public class IOUtilsCopyTestCase {
final int count = IOUtils.copy(reader, writer);
out.off();
writer.flush();
- assertEquals("The number of characters returned by copy is wrong", inData.length, count);
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ 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");
}
/*
@@ -414,25 +415,25 @@ public class IOUtilsCopyTestCase {
reader.close();
// Test copyLarge() method
- assertEquals("copyLarge()", size, IOUtils.copyLarge(reader, writer));
+ assertEquals(size, IOUtils.copyLarge(reader, writer), "copyLarge()");
}
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_readerToWriter_nullIn() throws Exception {
final ByteArrayOutputStream baout = new ByteArrayOutputStream();
final OutputStream out = new YellOnFlushAndCloseOutputStream(baout, true, true);
final Writer writer = new OutputStreamWriter(out, "US-ASCII");
- IOUtils.copy((Reader) null, writer);
+ assertThrows(NullPointerException.class, () -> IOUtils.copy((Reader) null, writer));
}
@SuppressWarnings("resource") // 'in' is deliberately not closed
- @Test(expected = NullPointerException.class)
+ @Test
public void testCopy_readerToWriter_nullOut() throws Exception {
InputStream in = new ByteArrayInputStream(inData);
in = new YellOnCloseInputStream(in);
final Reader reader = new InputStreamReader(in, "US-ASCII");
- IOUtils.copy(reader, (Writer) null);
+ assertThrows(NullPointerException.class, () -> IOUtils.copy(reader, (Writer) null));
}
}
diff --git a/src/test/java/org/apache/commons/io/IOUtilsTestCase.java b/src/test/java/org/apache/commons/io/IOUtilsTestCase.java
index 2993772..cc4c3b1 100644
--- a/src/test/java/org/apache/commons/io/IOUtilsTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOUtilsTestCase.java
@@ -16,13 +16,15 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+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.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
@@ -61,11 +63,9 @@ import java.util.List;
import org.apache.commons.io.output.AppendableWriter;
import org.apache.commons.io.output.StringBuilderWriter;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* This is used to test IOUtils for correctness. The following checks are performed:
@@ -80,12 +80,8 @@ import org.junit.rules.TemporaryFolder;
@SuppressWarnings("deprecation") // deliberately testing deprecated code
public class IOUtilsTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public File temporaryFolder;
private static final int FILE_SIZE = 1024 * 4 + 1;
@@ -105,13 +101,13 @@ public class IOUtilsTestCase {
/** Assert that the contents of two byte arrays are the same. */
private void assertEqualContent(final byte[] b0, final byte[] b1) {
- assertTrue("Content not equal according to java.util.Arrays#equals()", Arrays.equals(b0, b1));
+ assertTrue(Arrays.equals(b0, b1), "Content not equal according to java.util.Arrays#equals()");
}
- @Before
+ @BeforeEach
public void setUp() {
try {
- m_testFile = new File(getTestDirectory(), "file2-test.txt");
+ m_testFile = new File(temporaryFolder, "file2-test.txt");
if (!m_testFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + m_testFile
@@ -304,7 +300,7 @@ public class IOUtilsTestCase {
}
@Test public void testCopy_ByteArray_OutputStream() throws Exception {
- final File destination = TestUtils.newFile(getTestDirectory(), "copy8.txt");
+ final File destination = TestUtils.newFile(temporaryFolder, "copy8.txt");
byte[] in;
try (FileInputStream fin = new FileInputStream(m_testFile)) {
// Create our byte[]. Rely on testInputStreamToByteArray() to make sure this is valid.
@@ -323,7 +319,7 @@ public class IOUtilsTestCase {
}
@Test public void testCopy_ByteArray_Writer() throws Exception {
- final File destination = TestUtils.newFile(getTestDirectory(), "copy7.txt");
+ final File destination = TestUtils.newFile(temporaryFolder, "copy7.txt");
byte[] in;
try (FileInputStream fin = new FileInputStream(m_testFile)) {
// Create our byte[]. Rely on testInputStreamToByteArray() to make sure this is valid.
@@ -340,7 +336,7 @@ public class IOUtilsTestCase {
}
@Test public void testCopy_String_Writer() throws Exception {
- final File destination = TestUtils.newFile(getTestDirectory(), "copy6.txt");
+ final File destination = TestUtils.newFile(temporaryFolder, "copy6.txt");
String str;
try (FileReader fin = new FileReader(m_testFile)) {
// Create our String. Rely on testReaderToString() to make sure this is valid.
@@ -717,7 +713,7 @@ public class IOUtilsTestCase {
}
@Test public void testReadLines_InputStream() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
InputStream in = null;
try {
final String[] data = new String[] { "hello", "world", "", "this is", "some text" };
@@ -734,7 +730,7 @@ public class IOUtilsTestCase {
}
@Test public void testReadLines_InputStream_String() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
InputStream in = null;
try {
final String[] data = new String[] { "hello", "/u1234", "", "this is", "some text" };
@@ -751,7 +747,7 @@ public class IOUtilsTestCase {
}
@Test public void testReadLines_Reader() throws Exception {
- final File file = TestUtils.newFile(getTestDirectory(), "lines.txt");
+ final File file = TestUtils.newFile(temporaryFolder, "lines.txt");
Reader in = null;
try {
final String[] data = new String[] { "hello", "/u1234", "", "this is", "some text" };
@@ -862,7 +858,7 @@ public class IOUtilsTestCase {
}
@Test public void testStringToOutputStream() throws Exception {
- final File destination = TestUtils.newFile(getTestDirectory(), "copy5.txt");
+ final File destination = TestUtils.newFile(temporaryFolder, "copy5.txt");
String str;
try (FileReader fin = new FileReader(m_testFile)) {
// Create our String. Rely on testReaderToString() to make sure this is valid.
@@ -889,8 +885,8 @@ public class IOUtilsTestCase {
final InputStream in = IOUtils.toBufferedInputStream(fin);
final byte[] out = IOUtils.toByteArray(in);
assertNotNull(out);
- assertEquals("Not all bytes were read", 0, fin.available());
- assertEquals("Wrong output size", FILE_SIZE, out.length);
+ assertEquals(0, fin.available(), "Not all bytes were read");
+ assertEquals(FILE_SIZE, out.length, "Wrong output size");
TestUtils.assertEqualContent(out, m_testFile);
}
}
@@ -900,8 +896,8 @@ public class IOUtilsTestCase {
final InputStream in = IOUtils.toBufferedInputStream(fin, 2048);
final byte[] out = IOUtils.toByteArray(in);
assertNotNull(out);
- assertEquals("Not all bytes were read", 0, fin.available());
- assertEquals("Wrong output size", FILE_SIZE, out.length);
+ assertEquals(0, fin.available(), "Not all bytes were read");
+ assertEquals(FILE_SIZE, out.length, "Wrong output size");
TestUtils.assertEqualContent(out, m_testFile);
}
}
@@ -910,8 +906,8 @@ public class IOUtilsTestCase {
try (FileInputStream fin = new FileInputStream(m_testFile)) {
final byte[] out = IOUtils.toByteArray(fin);
assertNotNull(out);
- assertEquals("Not all bytes were read", 0, fin.available());
- assertEquals("Wrong output size", FILE_SIZE, out.length);
+ assertEquals(0, fin.available(), "Not all bytes were read");
+ assertEquals(FILE_SIZE, out.length, "Wrong output size");
TestUtils.assertEqualContent(out, m_testFile);
}
}
@@ -922,8 +918,8 @@ public class IOUtilsTestCase {
IOUtils.toByteArray(fin, -1);
fail("IllegalArgumentException expected");
} catch (final IllegalArgumentException exc) {
- assertTrue("Exception message does not start with \"Size must be equal or greater than zero\"", exc
- .getMessage().startsWith("Size must be equal or greater than zero"));
+ assertTrue(exc.getMessage().startsWith("Size must be equal or greater than zero"),
+ "Exception message does not start with \"Size must be equal or greater than zero\"");
}
}
@@ -932,8 +928,8 @@ public class IOUtilsTestCase {
try (FileInputStream fin = new FileInputStream(m_testFile)) {
final byte[] out = IOUtils.toByteArray(fin, m_testFile.length());
assertNotNull(out);
- assertEquals("Not all bytes were read", 0, fin.available());
- assertEquals("Wrong output size: out.length=" + out.length + "!=" + FILE_SIZE, FILE_SIZE, out.length);
+ assertEquals(0, fin.available(), "Not all bytes were read");
+ assertEquals(FILE_SIZE, out.length, "Wrong output size: out.length=" + out.length + "!=" + FILE_SIZE);
TestUtils.assertEqualContent(out, m_testFile);
}
}
@@ -944,8 +940,8 @@ public class IOUtilsTestCase {
IOUtils.toByteArray(fin, m_testFile.length() + 1);
fail("IOException expected");
} catch (final IOException exc) {
- assertTrue("Exception message does not start with \"Unexpected read size\"",
- exc.getMessage().startsWith("Unexpected read size"));
+ assertTrue(exc.getMessage().startsWith("Unexpected read size"),
+ "Exception message does not start with \"Unexpected read size\"");
}
}
@@ -956,8 +952,8 @@ public class IOUtilsTestCase {
IOUtils.toByteArray(fin, (long) Integer.MAX_VALUE + 1);
fail("IOException expected");
} catch (final IllegalArgumentException exc) {
- assertTrue("Exception message does not start with \"Size cannot be greater than Integer max value\"", exc
- .getMessage().startsWith("Size cannot be greater than Integer max value"));
+ assertTrue(exc.getMessage().startsWith("Size cannot be greater than Integer max value"),
+ "Exception message does not start with \"Size cannot be greater than Integer max value\"");
}
}
@@ -966,8 +962,8 @@ public class IOUtilsTestCase {
try (FileInputStream fin = new FileInputStream(m_testFile)) {
final byte[] out = IOUtils.toByteArray(fin, 0);
- assertNotNull("Out cannot be null", out);
- assertEquals("Out length must be 0", 0, out.length);
+ assertNotNull(out, "Out cannot be null");
+ assertEquals(0, out.length, "Out length must be 0");
}
}
@@ -975,9 +971,9 @@ public class IOUtilsTestCase {
final String charsetName = "UTF-8";
final byte[] expecteds = charsetName.getBytes(charsetName);
byte[] actuals = IOUtils.toByteArray(new InputStreamReader(new ByteArrayInputStream(expecteds)));
- Assert.assertArrayEquals(expecteds, actuals);
+ assertArrayEquals(expecteds, actuals);
actuals = IOUtils.toByteArray(new InputStreamReader(new ByteArrayInputStream(expecteds)), charsetName);
- Assert.assertArrayEquals(expecteds, actuals);
+ assertArrayEquals(expecteds, actuals);
}
@Test public void testToByteArray_String() throws Exception {
@@ -1017,8 +1013,8 @@ public class IOUtilsTestCase {
try (FileInputStream fin = new FileInputStream(m_testFile)) {
final char[] out = IOUtils.toCharArray(fin);
assertNotNull(out);
- assertEquals("Not all chars were read", 0, fin.available());
- assertEquals("Wrong output size", FILE_SIZE, out.length);
+ assertEquals(0, fin.available(), "Not all chars were read");
+ assertEquals(FILE_SIZE, out.length, "Wrong output size");
TestUtils.assertEqualContent(out, m_testFile);
}
}
@@ -1027,8 +1023,8 @@ public class IOUtilsTestCase {
try (FileInputStream fin = new FileInputStream(m_testFile)) {
final char[] out = IOUtils.toCharArray(fin, "UTF-8");
assertNotNull(out);
- assertEquals("Not all chars were read", 0, fin.available());
- assertEquals("Wrong output size", FILE_SIZE, out.length);
+ assertEquals(0, fin.available(), "Not all chars were read");
+ assertEquals(FILE_SIZE, out.length, "Wrong output size");
TestUtils.assertEqualContent(out, m_testFile);
}
}
@@ -1037,7 +1033,7 @@ public class IOUtilsTestCase {
try (FileReader fr = new FileReader(m_testFile)) {
final char[] out = IOUtils.toCharArray(fr);
assertNotNull(out);
- assertEquals("Wrong output size", FILE_SIZE, out.length);
+ assertEquals(FILE_SIZE, out.length, "Wrong output size");
TestUtils.assertEqualContent(out, m_testFile);
}
}
@@ -1099,8 +1095,8 @@ public class IOUtilsTestCase {
try (FileInputStream fin = new FileInputStream(m_testFile)) {
final String out = IOUtils.toString(fin);
assertNotNull(out);
- assertEquals("Not all bytes were read", 0, fin.available());
- assertEquals("Wrong output size", FILE_SIZE, out.length());
+ assertEquals(0, fin.available(), "Not all bytes were read");
+ assertEquals(FILE_SIZE, out.length(), "Wrong output size");
}
}
@@ -1108,7 +1104,7 @@ public class IOUtilsTestCase {
try (FileReader fin = new FileReader(m_testFile)) {
final String out = IOUtils.toString(fin);
assertNotNull(out);
- assertEquals("Wrong output size", FILE_SIZE, out.length());
+ assertEquals(FILE_SIZE, out.length(), "Wrong output size");
}
}
@@ -1116,14 +1112,14 @@ public class IOUtilsTestCase {
final URI url = m_testFile.toURI();
final String out = IOUtils.toString(url);
assertNotNull(out);
- assertEquals("Wrong output size", FILE_SIZE, out.length());
+ assertEquals(FILE_SIZE, out.length(), "Wrong output size");
}
private void testToString_URI(final String encoding) throws Exception {
final URI uri = m_testFile.toURI();
final String out = IOUtils.toString(uri, encoding);
assertNotNull(out);
- assertEquals("Wrong output size", FILE_SIZE, out.length());
+ assertEquals(FILE_SIZE, out.length(), "Wrong output size");
}
@Test public void testToString_URI_CharsetName() throws Exception {
@@ -1138,14 +1134,14 @@ public class IOUtilsTestCase {
final URL url = m_testFile.toURI().toURL();
final String out = IOUtils.toString(url);
assertNotNull(out);
- assertEquals("Wrong output size", FILE_SIZE, out.length());
+ assertEquals(FILE_SIZE, out.length(), "Wrong output size");
}
private void testToString_URL(final String encoding) throws Exception {
final URL url = m_testFile.toURI().toURL();
final String out = IOUtils.toString(url, encoding);
assertNotNull(out);
- assertEquals("Wrong output size", FILE_SIZE, out.length());
+ assertEquals(FILE_SIZE, out.length(), "Wrong output size");
}
@Test public void testToString_URL_CharsetName() throws Exception {
@@ -1196,12 +1192,14 @@ public class IOUtilsTestCase {
assertEquals(fileSize, content.getBytes().length);
}
- @Test(expected = IOException.class) public void testResourceToString_NonExistingResource() throws Exception {
- IOUtils.resourceToString("/non-existing-file.bin", StandardCharsets.UTF_8);
+ @Test public void testResourceToString_NonExistingResource() {
+ assertThrows(IOException.class,
+ () -> IOUtils.resourceToString("/non-existing-file.bin", StandardCharsets.UTF_8));
}
- @Test(expected = IOException.class) public void testResourceToString_NonExistingResource_WithClassLoader() throws Exception {
- IOUtils.resourceToString("non-existing-file.bin", StandardCharsets.UTF_8, ClassLoader.getSystemClassLoader());
+ @Test public void testResourceToString_NonExistingResource_WithClassLoader() {
+ assertThrows(IOException.class,
+ () -> IOUtils.resourceToString("non-existing-file.bin", StandardCharsets.UTF_8, ClassLoader.getSystemClassLoader()));
}
@Test public void testResourceToString_NullResource() throws Exception {
@@ -1268,12 +1266,13 @@ public class IOUtilsTestCase {
assertEquals(fileSize, bytes.length);
}
- @Test(expected = IOException.class) public void testResourceToByteArray_NonExistingResource() throws Exception {
- IOUtils.resourceToByteArray("/non-existing-file.bin");
+ @Test public void testResourceToByteArray_NonExistingResource() {
+ assertThrows(IOException.class, () -> IOUtils.resourceToByteArray("/non-existing-file.bin"));
}
- @Test(expected = IOException.class) public void testResourceToByteArray_NonExistingResource_WithClassLoader() throws Exception {
- IOUtils.resourceToByteArray("non-existing-file.bin", ClassLoader.getSystemClassLoader());
+ @Test public void testResourceToByteArray_NonExistingResource_WithClassLoader() {
+ assertThrows(IOException.class,
+ () -> IOUtils.resourceToByteArray("non-existing-file.bin", ClassLoader.getSystemClassLoader()));
}
@Test public void testResourceToByteArray_Null() throws Exception {
@@ -1332,12 +1331,13 @@ public class IOUtilsTestCase {
assertTrue(url.getFile().endsWith("/org/apache/commons/io/FileUtilsTestDataCR.dat"));
}
- @Test(expected = IOException.class) public void testResourceToURL_NonExistingResource() throws Exception {
- IOUtils.resourceToURL("/non-existing-file.bin");
+ @Test public void testResourceToURL_NonExistingResource() {
+ assertThrows(IOException.class, () -> IOUtils.resourceToURL("/non-existing-file.bin"));
}
- @Test(expected = IOException.class) public void testResourceToURL_NonExistingResource_WithClassLoader() throws Exception {
- IOUtils.resourceToURL("non-existing-file.bin", ClassLoader.getSystemClassLoader());
+ @Test public void testResourceToURL_NonExistingResource_WithClassLoader() {
+ assertThrows(IOException.class,
+ () -> IOUtils.resourceToURL("non-existing-file.bin", ClassLoader.getSystemClassLoader()));
}
@Test public void testResourceToURL_Null() throws Exception {
diff --git a/src/test/java/org/apache/commons/io/IOUtilsWriteTestCase.java b/src/test/java/org/apache/commons/io/IOUtilsWriteTestCase.java
index f5cb338..2480306 100644
--- a/src/test/java/org/apache/commons/io/IOUtilsWriteTestCase.java
+++ b/src/test/java/org/apache/commons/io/IOUtilsWriteTestCase.java
@@ -16,9 +16,9 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+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;
import java.io.OutputStreamWriter;
@@ -29,7 +29,7 @@ import java.util.List;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.io.testtools.TestUtils;
import org.apache.commons.io.testtools.YellOnFlushAndCloseOutputStream;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* JUnit tests for IOUtils write methods.
@@ -57,8 +57,8 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -70,7 +70,7 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -94,8 +94,8 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -109,7 +109,7 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -135,7 +135,7 @@ public class IOUtilsWriteTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes, "UTF8").getBytes("US-ASCII");
- assertTrue("Content differs", Arrays.equals(inData, bytes));
+ assertTrue(Arrays.equals(inData, bytes), "Content differs");
}
@Test
@@ -149,7 +149,7 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -172,8 +172,8 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
//-----------------------------------------------------------------------
@@ -188,8 +188,8 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -201,7 +201,7 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -228,7 +228,7 @@ public class IOUtilsWriteTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes, "UTF16").getBytes("US-ASCII");
- assertTrue("Content differs", Arrays.equals(inData, bytes));
+ assertTrue(Arrays.equals(inData, bytes), "Content differs");
}
@Test
@@ -240,7 +240,7 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -264,8 +264,8 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
//-----------------------------------------------------------------------
@@ -282,8 +282,8 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -297,7 +297,7 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -322,8 +322,8 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -335,7 +335,7 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -362,7 +362,7 @@ public class IOUtilsWriteTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes, "UTF16").getBytes("US-ASCII");
- assertTrue("Content differs", Arrays.equals(inData, bytes));
+ assertTrue(Arrays.equals(inData, bytes), "Content differs");
}
@Test
@@ -374,7 +374,7 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -398,8 +398,8 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
//-----------------------------------------------------------------------
@@ -416,8 +416,8 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -431,7 +431,7 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -456,8 +456,8 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -469,7 +469,7 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -496,7 +496,7 @@ public class IOUtilsWriteTestCase {
byte[] bytes = baout.toByteArray();
bytes = new String(bytes, "UTF16").getBytes("US-ASCII");
- assertTrue("Content differs", Arrays.equals(inData, bytes));
+ assertTrue(Arrays.equals(inData, bytes), "Content differs");
}
@Test
@@ -508,7 +508,7 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -532,8 +532,8 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
//-----------------------------------------------------------------------
@@ -550,8 +550,8 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", inData.length, baout.size());
- assertTrue("Content differs", Arrays.equals(inData, baout.toByteArray()));
+ assertEquals(inData.length, baout.size(), "Sizes differ");
+ assertTrue(Arrays.equals(inData, baout.toByteArray()), "Content differs");
}
@Test
@@ -565,7 +565,7 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -607,7 +607,7 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -667,7 +667,7 @@ public class IOUtilsWriteTestCase {
out.off();
out.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
@@ -750,7 +750,7 @@ public class IOUtilsWriteTestCase {
out.off();
writer.flush();
- assertEquals("Sizes differ", 0, baout.size());
+ assertEquals(0, baout.size(), "Sizes differ");
}
@Test
diff --git a/src/test/java/org/apache/commons/io/LineIteratorTestCase.java b/src/test/java/org/apache/commons/io/LineIteratorTestCase.java
index 52a8901..272f572 100644
--- a/src/test/java/org/apache/commons/io/LineIteratorTestCase.java
+++ b/src/test/java/org/apache/commons/io/LineIteratorTestCase.java
@@ -16,11 +16,11 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.BufferedReader;
import java.io.File;
@@ -34,10 +34,8 @@ import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* This is used to test LineIterator for correctness.
@@ -45,20 +43,16 @@ import org.junit.rules.TemporaryFolder;
*/
public class LineIteratorTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public File temporaryFolder;
private void assertLines(final List<String> lines, final LineIterator iterator) {
try {
for (int i = 0; i < lines.size(); i++) {
final String line = iterator.nextLine();
- assertEquals("nextLine() line " + i, lines.get(i), line);
+ assertEquals(lines.get(i), line, "nextLine() line " + i);
}
- assertFalse("No more expected", iterator.hasNext());
+ assertFalse(iterator.hasNext(), "No more expected");
} finally {
LineIterator.closeQuietly(iterator);
}
@@ -107,15 +101,6 @@ public class LineIteratorTestCase {
return lines;
}
- @Before
- public void setUp() throws Exception {
- final File dir = getTestDirectory();
- if (dir.exists()) {
- FileUtils.deleteDirectory(dir);
- }
- dir.mkdirs();
-
- }
// -----------------------------------------------------------------------
@@ -151,7 +136,7 @@ public class LineIteratorTestCase {
@Test
public void testMissingFile() throws Exception {
- final File testFile = new File(getTestDirectory(), "dummy-missing-file.txt");
+ final File testFile = new File(temporaryFolder, "dummy-missing-file.txt");
LineIterator iterator = null;
try {
@@ -168,7 +153,7 @@ public class LineIteratorTestCase {
public void testValidEncoding() throws Exception {
final String encoding = "UTF-8";
- final File testFile = new File(getTestDirectory(), "LineIterator-validEncoding.txt");
+ final File testFile = new File(temporaryFolder, "LineIterator-validEncoding.txt");
createLinesFile(testFile, encoding, 3);
final LineIterator iterator = FileUtils.lineIterator(testFile, encoding);
@@ -188,7 +173,7 @@ public class LineIteratorTestCase {
public void testInvalidEncoding() throws Exception {
final String encoding = "XXXXXXXX";
- final File testFile = new File(getTestDirectory(), "LineIterator-invalidEncoding.txt");
+ final File testFile = new File(temporaryFolder, "LineIterator-invalidEncoding.txt");
createLinesFile(testFile, "UTF-8", 3);
LineIterator iterator = null;
@@ -204,7 +189,7 @@ public class LineIteratorTestCase {
@Test
public void testNextLineOnlyDefaultEncoding() throws Exception {
- final File testFile = new File(getTestDirectory(), "LineIterator-nextOnly.txt");
+ final File testFile = new File(temporaryFolder, "LineIterator-nextOnly.txt");
final List<String> lines = createLinesFile(testFile, 3);
final LineIterator iterator = FileUtils.lineIterator(testFile);
@@ -215,7 +200,7 @@ public class LineIteratorTestCase {
public void testNextLineOnlyNullEncoding() throws Exception {
final String encoding = null;
- final File testFile = new File(getTestDirectory(), "LineIterator-nextOnly.txt");
+ final File testFile = new File(temporaryFolder, "LineIterator-nextOnly.txt");
final List<String> lines = createLinesFile(testFile, encoding, 3);
final LineIterator iterator = FileUtils.lineIterator(testFile, encoding);
@@ -226,7 +211,7 @@ public class LineIteratorTestCase {
public void testNextLineOnlyUtf8Encoding() throws Exception {
final String encoding = "UTF-8";
- final File testFile = new File(getTestDirectory(), "LineIterator-nextOnly.txt");
+ final File testFile = new File(temporaryFolder, "LineIterator-nextOnly.txt");
final List<String> lines = createLinesFile(testFile, encoding, 3);
final LineIterator iterator = FileUtils.lineIterator(testFile, encoding);
@@ -237,16 +222,16 @@ public class LineIteratorTestCase {
public void testNextOnly() throws Exception {
final String encoding = null;
- final File testFile = new File(getTestDirectory(), "LineIterator-nextOnly.txt");
+ final File testFile = new File(temporaryFolder, "LineIterator-nextOnly.txt");
final List<String> lines = createLinesFile(testFile, encoding, 3);
final LineIterator iterator = FileUtils.lineIterator(testFile, encoding);
try {
for (int i = 0; i < lines.size(); i++) {
final String line = iterator.next();
- assertEquals("next() line " + i, lines.get(i), line);
+ assertEquals(lines.get(i), line, "next() line " + i);
}
- assertEquals("No more expected", false, iterator.hasNext());
+ assertEquals(false, iterator.hasNext(), "No more expected");
} finally {
LineIterator.closeQuietly(iterator);
}
@@ -272,18 +257,18 @@ public class LineIteratorTestCase {
public void testCloseEarly() throws Exception {
final String encoding = "UTF-8";
- final File testFile = new File(getTestDirectory(), "LineIterator-closeEarly.txt");
+ final File testFile = new File(temporaryFolder, "LineIterator-closeEarly.txt");
createLinesFile(testFile, encoding, 3);
final LineIterator iterator = FileUtils.lineIterator(testFile, encoding);
try {
// get
assertNotNull("Line expected", iterator.next());
- assertTrue("More expected", iterator.hasNext());
+ assertTrue(iterator.hasNext(), "More expected");
// close
iterator.close();
- assertFalse("No more expected", iterator.hasNext());
+ assertFalse(iterator.hasNext(), "No more expected");
try {
iterator.next();
fail();
@@ -327,7 +312,7 @@ public class LineIteratorTestCase {
final String encoding = "UTF-8";
final String fileName = "LineIterator-" + lineCount + "-test.txt";
- final File testFile = new File(getTestDirectory(), fileName);
+ final File testFile = new File(temporaryFolder, fileName);
final List<String> lines = createLinesFile(testFile, encoding, lineCount);
final LineIterator iterator = FileUtils.lineIterator(testFile, encoding);
@@ -342,11 +327,11 @@ public class LineIteratorTestCase {
int idx = 0;
while (iterator.hasNext()) {
final String line = iterator.next();
- assertEquals("Comparing line " + idx, lines.get(idx), line);
- assertTrue("Exceeded expected idx=" + idx + " size=" + lines.size(), idx < lines.size());
+ assertEquals(lines.get(idx), line, "Comparing line " + idx);
+ assertTrue(idx < lines.size(), "Exceeded expected idx=" + idx + " size=" + lines.size());
idx++;
}
- assertEquals("Line Count doesn't match", idx, lines.size());
+ assertEquals(idx, lines.size(), "Line Count doesn't match");
// try calling next() after file processed
try {
@@ -372,7 +357,7 @@ public class LineIteratorTestCase {
final String encoding = "UTF-8";
final String fileName = "LineIterator-Filter-test.txt";
- final File testFile = new File(getTestDirectory(), fileName);
+ final File testFile = new File(temporaryFolder, fileName);
final List<String> lines = createLinesFile(testFile, encoding, 9);
final Reader reader = new FileReader(testFile);
@@ -384,7 +369,7 @@ public class LineIteratorTestCase {
final String encoding = "UTF-8";
final String fileName = "LineIterator-Filter-test.txt";
- final File testFile = new File(getTestDirectory(), fileName);
+ final File testFile = new File(temporaryFolder, fileName);
final List<String> lines = createLinesFile(testFile, encoding, 9);
final Reader reader = new BufferedReader(new FileReader(testFile));
@@ -412,16 +397,16 @@ public class LineIteratorTestCase {
while (iterator.hasNext()) {
final String line = iterator.next();
actualLines++;
- assertEquals("Comparing line " + idx, lines.get(idx), line);
- assertTrue("Exceeded expected idx=" + idx + " size=" + lines.size(), idx < lines.size());
+ assertEquals(lines.get(idx), line, "Comparing line " + idx);
+ assertTrue(idx < lines.size(), "Exceeded expected idx=" + idx + " size=" + lines.size());
idx++;
if (idx % 3 == 1) {
idx++;
}
}
- assertEquals("Line Count doesn't match", 9, lines.size());
- assertEquals("Line Count doesn't match", 9, idx);
- assertEquals("Line Count doesn't match", 6, actualLines);
+ assertEquals(9, lines.size(), "Line Count doesn't match");
+ assertEquals(9, idx, "Line Count doesn't match");
+ assertEquals(6, actualLines, "Line Count doesn't match");
// try calling next() after file processed
try {
diff --git a/src/test/java/org/apache/commons/io/TaggedIOExceptionTest.java b/src/test/java/org/apache/commons/io/TaggedIOExceptionTest.java
index 8b7c6a0..a009d43 100644
--- a/src/test/java/org/apache/commons/io/TaggedIOExceptionTest.java
+++ b/src/test/java/org/apache/commons/io/TaggedIOExceptionTest.java
@@ -16,15 +16,15 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+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.IOException;
import java.io.Serializable;
import java.util.UUID;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link TaggedIOException}.
diff --git a/src/test/java/org/apache/commons/io/ThreadMonitorTestCase.java b/src/test/java/org/apache/commons/io/ThreadMonitorTestCase.java
index 6718639..33ff5b4 100644
--- a/src/test/java/org/apache/commons/io/ThreadMonitorTestCase.java
+++ b/src/test/java/org/apache/commons/io/ThreadMonitorTestCase.java
@@ -16,11 +16,11 @@
*/
package org.apache.commons.io;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.fail;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Tests for {@link ThreadMonitor}.
@@ -65,7 +65,7 @@ public class ThreadMonitorTestCase {
// timeout = -1
try {
final Thread monitor = ThreadMonitor.start(-1);
- assertNull("Timeout -1, Monitor should be null", monitor);
+ assertNull(monitor,"Timeout -1, Monitor should be null");
TestUtils.sleep(100);
ThreadMonitor.stop(monitor);
} catch (final Exception e) {
@@ -75,7 +75,7 @@ public class ThreadMonitorTestCase {
// timeout = 0
try {
final Thread monitor = ThreadMonitor.start(0);
- assertNull("Timeout 0, Monitor should be null", monitor);
+ assertNull(monitor, "Timeout 0, Monitor should be null");
TestUtils.sleep(100);
ThreadMonitor.stop(monitor);
} catch (final Exception e) {
diff --git a/src/test/java/org/apache/commons/io/comparator/ComparatorAbstractTestCase.java b/src/test/java/org/apache/commons/io/comparator/ComparatorAbstractTestCase.java
index a867d58..131b451 100644
--- a/src/test/java/org/apache/commons/io/comparator/ComparatorAbstractTestCase.java
+++ b/src/test/java/org/apache/commons/io/comparator/ComparatorAbstractTestCase.java
@@ -16,32 +16,27 @@
*/
package org.apache.commons.io.comparator;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
+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 static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* Base Test case for Comparator implementations.
*/
public abstract class ComparatorAbstractTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- protected File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public File dir;
/** comparator instance */
protected AbstractFileComparator comparator;
@@ -66,9 +61,9 @@ public abstract class ComparatorAbstractTestCase {
*/
@Test
public void testComparator() {
- assertEquals("equal", 0, comparator.compare(equalFile1, equalFile2));
- assertTrue("less", comparator.compare(lessFile, moreFile) < 0);
- assertTrue("more", comparator.compare(moreFile, lessFile) > 0);
+ assertEquals(0, comparator.compare(equalFile1, equalFile2), "equal");
+ assertTrue(comparator.compare(lessFile, moreFile) < 0, "less");
+ assertTrue(comparator.compare(moreFile, lessFile) > 0, "more");
}
/**
@@ -76,9 +71,9 @@ public abstract class ComparatorAbstractTestCase {
*/
@Test
public void testReverseComparator() {
- assertEquals("equal", 0, reverse.compare(equalFile1, equalFile2));
- assertTrue("less", reverse.compare(moreFile, lessFile) < 0);
- assertTrue("more", reverse.compare(lessFile, moreFile) > 0);
+ assertEquals(0, reverse.compare(equalFile1, equalFile2), "equal");
+ assertTrue(reverse.compare(moreFile, lessFile) < 0, "less");
+ assertTrue(reverse.compare(lessFile, moreFile) > 0, "more");
}
/**
@@ -99,9 +94,9 @@ public abstract class ComparatorAbstractTestCase {
files[1] = moreFile;
files[2] = lessFile;
comparator.sort(files);
- assertSame("equal", lessFile, files[0]);
- assertSame("less", equalFile1, files[1]);
- assertSame("more", moreFile, files[2]);
+ assertSame(lessFile, files[0], "equal");
+ assertSame(equalFile1, files[1], "less");
+ assertSame(moreFile, files[2], "more");
}
/**
@@ -114,9 +109,9 @@ public abstract class ComparatorAbstractTestCase {
files.add(moreFile);
files.add(lessFile);
comparator.sort(files);
- assertSame("equal", lessFile, files.get(0));
- assertSame("less", equalFile1, files.get(1));
- assertSame("more", moreFile, files.get(2));
+ assertSame(lessFile, files.get(0), "equal");
+ assertSame(equalFile1, files.get(1), "less");
+ assertSame(moreFile, files.get(2), "more");
}
/**
@@ -132,7 +127,7 @@ public abstract class ComparatorAbstractTestCase {
*/
@Test
public void testToString() {
- assertNotNull("comparator", comparator.toString());
- assertTrue("reverse", reverse.toString().startsWith("ReverseComparator["));
+ assertNotNull(comparator.toString(), "comparator");
+ assertTrue(reverse.toString().startsWith("ReverseComparator["), "reverse");
}
}
diff --git a/src/test/java/org/apache/commons/io/comparator/CompositeFileComparatorTest.java b/src/test/java/org/apache/commons/io/comparator/CompositeFileComparatorTest.java
index 6c543b9..df2bd40 100644
--- a/src/test/java/org/apache/commons/io/comparator/CompositeFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/CompositeFileComparatorTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.io.comparator;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.BufferedOutputStream;
import java.io.File;
@@ -28,22 +28,21 @@ import java.util.Comparator;
import java.util.List;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test case for {@link CompositeFileComparator}.
*/
public class CompositeFileComparatorTest extends ComparatorAbstractTestCase {
- @Before
+ @BeforeEach
public void setUp() throws Exception {
comparator = new CompositeFileComparator(
new AbstractFileComparator[] {
(AbstractFileComparator) SizeFileComparator.SIZE_COMPARATOR,
(AbstractFileComparator) ExtensionFileComparator.EXTENSION_COMPARATOR});
reverse = new ReverseComparator(comparator);
- final File dir = getTestDirectory();
lessFile = new File(dir, "xyz.txt");
equalFile1 = new File(dir, "foo.txt");
equalFile2 = new File(dir, "bar.txt");
@@ -93,9 +92,9 @@ public class CompositeFileComparatorTest extends ComparatorAbstractTestCase {
list.add(ExtensionFileComparator.EXTENSION_COMPARATOR);
final Comparator<File> c = new CompositeFileComparator(list);
- assertEquals("equal", 0, c.compare(equalFile1, equalFile2));
- assertTrue("less", c.compare(lessFile, moreFile) < 0);
- assertTrue("more", c.compare(moreFile, lessFile) > 0);
+ assertEquals(0, c.compare(equalFile1, equalFile2), "equal");
+ assertTrue(c.compare(lessFile, moreFile) < 0, "less");
+ assertTrue(c.compare(moreFile, lessFile) > 0, "more");
}
/**
@@ -104,9 +103,9 @@ public class CompositeFileComparatorTest extends ComparatorAbstractTestCase {
@Test
public void constructorIterable_Null() {
final Comparator<File> c = new CompositeFileComparator((Iterable<Comparator<File>>)null);
- assertEquals("less,more", 0, c.compare(lessFile, moreFile));
- assertEquals("more,less", 0, c.compare(moreFile, lessFile));
- assertEquals("toString", "CompositeFileComparator{}", c.toString());
+ assertEquals(0, c.compare(lessFile, moreFile), "less,more");
+ assertEquals(0, c.compare(moreFile, lessFile), "more,less");
+ assertEquals("CompositeFileComparator{}", c.toString(), "toString");
}
/**
@@ -115,8 +114,8 @@ public class CompositeFileComparatorTest extends ComparatorAbstractTestCase {
@Test
public void constructorArray_Null() {
final Comparator<File> c = new CompositeFileComparator((Comparator<File>[])null);
- assertEquals("less,more", 0, c.compare(lessFile, moreFile));
- assertEquals("more,less", 0, c.compare(moreFile, lessFile));
- assertEquals("toString", "CompositeFileComparator{}", c.toString());
+ assertEquals(0, c.compare(lessFile, moreFile), "less,more");
+ assertEquals(0, c.compare(moreFile, lessFile), "more,less");
+ assertEquals("CompositeFileComparator{}", c.toString(), "toString");
}
}
diff --git a/src/test/java/org/apache/commons/io/comparator/DefaultFileComparatorTest.java b/src/test/java/org/apache/commons/io/comparator/DefaultFileComparatorTest.java
index 392f465..48c44b2 100644
--- a/src/test/java/org/apache/commons/io/comparator/DefaultFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/DefaultFileComparatorTest.java
@@ -18,14 +18,14 @@ package org.apache.commons.io.comparator;
import java.io.File;
-import org.junit.Before;
+import org.junit.jupiter.api.BeforeEach;
/**
* Test case for {@link DefaultFileComparator}.
*/
public class DefaultFileComparatorTest extends ComparatorAbstractTestCase {
- @Before
+ @BeforeEach
public void setUp() throws Exception {
comparator = (AbstractFileComparator) DefaultFileComparator.DEFAULT_COMPARATOR;
reverse = DefaultFileComparator.DEFAULT_REVERSE;
diff --git a/src/test/java/org/apache/commons/io/comparator/DirectoryFileComparatorTest.java b/src/test/java/org/apache/commons/io/comparator/DirectoryFileComparatorTest.java
index e4649d3..cd5d13c 100644
--- a/src/test/java/org/apache/commons/io/comparator/DirectoryFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/DirectoryFileComparatorTest.java
@@ -18,15 +18,15 @@ package org.apache.commons.io.comparator;
import java.io.File;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test case for {@link DirectoryFileComparator}.
*/
public class DirectoryFileComparatorTest extends ComparatorAbstractTestCase {
- @Before
+ @BeforeEach
public void setUp() throws Exception {
comparator = (AbstractFileComparator) DirectoryFileComparator.DIRECTORY_COMPARATOR;
reverse = DirectoryFileComparator.DIRECTORY_REVERSE;
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 dc5d73c..da2386e 100644
--- a/src/test/java/org/apache/commons/io/comparator/ExtensionFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/ExtensionFileComparatorTest.java
@@ -16,13 +16,13 @@
*/
package org.apache.commons.io.comparator;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
import java.util.Comparator;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test case for {@link ExtensionFileComparator}.
@@ -30,7 +30,7 @@ import org.junit.Test;
public class ExtensionFileComparatorTest extends ComparatorAbstractTestCase {
- @Before
+ @BeforeEach
public void setUp() throws Exception {
comparator = (AbstractFileComparator) ExtensionFileComparator.EXTENSION_COMPARATOR;
reverse = ExtensionFileComparator.EXTENSION_REVERSE;
@@ -45,14 +45,14 @@ 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 file1 & file2 = 0", sensitive.compare(equalFile1, equalFile2) == 0);
- assertTrue("sensitive file1 & file3 > 0", sensitive.compare(equalFile1, file3) > 0);
- assertTrue("sensitive file1 & less > 0", sensitive.compare(equalFile1, lessFile) > 0);
+ assertTrue(sensitive.compare(equalFile1, equalFile2) == 0, "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 file1 & file2 = 0", insensitive.compare(equalFile1, equalFile2) == 0);
- assertTrue("insensitive file1 & file3 = 0", insensitive.compare(equalFile1, file3) == 0);
- assertTrue("insensitive file1 & file4 > 0", insensitive.compare(equalFile1, lessFile) > 0);
- assertTrue("insensitive file3 & less > 0", insensitive.compare(file3, lessFile) > 0);
+ assertTrue(insensitive.compare(equalFile1, equalFile2) == 0, "insensitive file1 & file2 = 0");
+ assertTrue(insensitive.compare(equalFile1, file3) == 0, "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/LastModifiedFileComparatorTest.java b/src/test/java/org/apache/commons/io/comparator/LastModifiedFileComparatorTest.java
index 887303a..c4fa672 100644
--- a/src/test/java/org/apache/commons/io/comparator/LastModifiedFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/LastModifiedFileComparatorTest.java
@@ -22,18 +22,16 @@ import java.io.FileOutputStream;
import java.io.IOException;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Before;
+import org.junit.jupiter.api.BeforeEach;
/**
* Test case for {@link LastModifiedFileComparator}.
*/
public class LastModifiedFileComparatorTest extends ComparatorAbstractTestCase {
-
- @Before
+ @BeforeEach
public void setUp() throws Exception {
comparator = (AbstractFileComparator) LastModifiedFileComparator.LASTMODIFIED_COMPARATOR;
reverse = LastModifiedFileComparator.LASTMODIFIED_REVERSE;
- final File dir = getTestDirectory();
final File olderFile = new File(dir, "older.txt");
if (!olderFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + olderFile
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 d60bbc3..6b47575 100644
--- a/src/test/java/org/apache/commons/io/comparator/NameFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/NameFileComparatorTest.java
@@ -16,21 +16,20 @@
*/
package org.apache.commons.io.comparator;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
import java.util.Comparator;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test case for {@link NameFileComparator}.
*/
public class NameFileComparatorTest extends ComparatorAbstractTestCase {
- /** @see junit.framework.TestCase#setUp() */
- @Before
+ @BeforeEach
public void setUp() throws Exception {
comparator = (AbstractFileComparator) NameFileComparator.NAME_INSENSITIVE_COMPARATOR;
reverse = NameFileComparator.NAME_REVERSE;
@@ -45,14 +44,14 @@ 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 file1 & file2 = 0", sensitive.compare(equalFile1, equalFile2) == 0);
- assertTrue("sensitive file1 & file3 > 0", sensitive.compare(equalFile1, file3) > 0);
- assertTrue("sensitive file1 & less > 0", sensitive.compare(equalFile1, lessFile) > 0);
+ assertTrue(sensitive.compare(equalFile1, equalFile2) == 0, "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 file1 & file2 = 0", insensitive.compare(equalFile1, equalFile2) == 0);
- assertTrue("insensitive file1 & file3 = 0", insensitive.compare(equalFile1, file3) == 0);
- assertTrue("insensitive file1 & file4 > 0", insensitive.compare(equalFile1, lessFile) > 0);
- assertTrue("insensitive file3 & less > 0", insensitive.compare(file3, lessFile) > 0);
+ assertTrue(insensitive.compare(equalFile1, equalFile2) == 0, "insensitive file1 & file2 = 0");
+ assertTrue(insensitive.compare(equalFile1, file3) == 0, "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 5d36833..89283e3 100644
--- a/src/test/java/org/apache/commons/io/comparator/PathFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/PathFileComparatorTest.java
@@ -16,13 +16,13 @@
*/
package org.apache.commons.io.comparator;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
import java.util.Comparator;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test case for {@link PathFileComparator}.
@@ -30,7 +30,7 @@ import org.junit.Test;
public class PathFileComparatorTest extends ComparatorAbstractTestCase {
- @Before
+ @BeforeEach
public void setUp() throws Exception {
comparator = (AbstractFileComparator) PathFileComparator.PATH_COMPARATOR;
reverse = PathFileComparator.PATH_REVERSE;
@@ -45,14 +45,14 @@ 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 file1 & file2 = 0", sensitive.compare(equalFile1, equalFile2) == 0);
- assertTrue("sensitive file1 & file3 > 0", sensitive.compare(equalFile1, file3) > 0);
- assertTrue("sensitive file1 & less > 0", sensitive.compare(equalFile1, lessFile) > 0);
+ assertTrue(sensitive.compare(equalFile1, equalFile2) == 0, "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 file1 & file2 = 0", insensitive.compare(equalFile1, equalFile2) == 0);
- assertTrue("insensitive file1 & file3 = 0", insensitive.compare(equalFile1, file3) == 0);
- assertTrue("insensitive file1 & file4 > 0", insensitive.compare(equalFile1, lessFile) > 0);
- assertTrue("insensitive file3 & less > 0", insensitive.compare(file3, lessFile) > 0);
+ assertTrue(insensitive.compare(equalFile1, equalFile2) == 0, "insensitive file1 & file2 = 0");
+ assertTrue(insensitive.compare(equalFile1, file3) == 0, "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/SizeFileComparatorTest.java b/src/test/java/org/apache/commons/io/comparator/SizeFileComparatorTest.java
index 5c3d61b..ec37b03 100644
--- a/src/test/java/org/apache/commons/io/comparator/SizeFileComparatorTest.java
+++ b/src/test/java/org/apache/commons/io/comparator/SizeFileComparatorTest.java
@@ -16,9 +16,9 @@
*/
package org.apache.commons.io.comparator;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+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.BufferedOutputStream;
import java.io.File;
@@ -26,8 +26,8 @@ import java.io.FileOutputStream;
import java.io.IOException;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test case for {@link SizeFileComparator}.
@@ -39,12 +39,10 @@ public class SizeFileComparatorTest extends ComparatorAbstractTestCase {
private File smallerFile;
private File largerFile;
- /** @see junit.framework.TestCase#setUp() */
- @Before
+ @BeforeEach
public void setUp() throws Exception {
comparator = (AbstractFileComparator) SizeFileComparator.SIZE_COMPARATOR;
reverse = SizeFileComparator.SIZE_REVERSE;
- final File dir = getTestDirectory();
smallerDir = new File(dir, "smallerdir");
largerDir = new File(dir, "largerdir");
smallerFile = new File(smallerDir, "smaller.txt");
@@ -89,7 +87,7 @@ public class SizeFileComparatorTest extends ComparatorAbstractTestCase {
public void testNonexistantFile() {
final File nonexistantFile = new File(new File("."), "nonexistant.txt");
assertFalse(nonexistantFile.exists());
- assertTrue("less", comparator.compare(nonexistantFile, moreFile) < 0);
+ assertTrue(comparator.compare(nonexistantFile, moreFile) < 0, "less");
}
/**
@@ -97,8 +95,8 @@ public class SizeFileComparatorTest extends ComparatorAbstractTestCase {
*/
@Test
public void testCompareDirectorySizes() {
- assertEquals("sumDirectoryContents=false", 0, comparator.compare(smallerDir, largerDir));
- assertEquals("less", -1, SizeFileComparator.SIZE_SUMDIR_COMPARATOR.compare(smallerDir, largerDir));
- assertEquals("less", 1, SizeFileComparator.SIZE_SUMDIR_REVERSE.compare(smallerDir, largerDir));
+ assertEquals(0, comparator.compare(smallerDir, largerDir), "sumDirectoryContents=false");
+ assertEquals(-1, SizeFileComparator.SIZE_SUMDIR_COMPARATOR.compare(smallerDir, largerDir), "less");
+ assertEquals(1, SizeFileComparator.SIZE_SUMDIR_REVERSE.compare(smallerDir, largerDir), "less");
}
}
diff --git a/src/test/java/org/apache/commons/io/filefilter/AndFileFilterTestCase.java b/src/test/java/org/apache/commons/io/filefilter/AndFileFilterTestCase.java
index 1e69ab1..169964e 100644
--- a/src/test/java/org/apache/commons/io/filefilter/AndFileFilterTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/AndFileFilterTestCase.java
@@ -19,7 +19,7 @@ package org.apache.commons.io.filefilter;
import java.util.ArrayList;
import java.util.List;
-import org.junit.Before;
+import org.junit.jupiter.api.BeforeEach;
public class AndFileFilterTestCase extends ConditionalFileFilterAbstractTestCase {
@@ -86,7 +86,7 @@ public class AndFileFilterTestCase extends ConditionalFileFilterAbstractTestCase
return WORKING_PATH_NAME_PROPERTY_KEY;
}
- @Before
+ @BeforeEach
public void setUpTestFilters() {
// filters
//tests
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 2c320fe..a5f82cb 100644
--- a/src/test/java/org/apache/commons/io/filefilter/ConditionalFileFilterAbstractTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/ConditionalFileFilterAbstractTestCase.java
@@ -16,15 +16,15 @@
*/
package org.apache.commons.io.filefilter;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
public abstract class ConditionalFileFilterAbstractTestCase extends IOFileFilterAbstractTestCase {
@@ -37,7 +37,7 @@ public abstract class ConditionalFileFilterAbstractTestCase extends IOFileFilter
private File file;
private File workingPath;
- @Before
+ @BeforeEach
public void setUp() throws Exception {
this.workingPath = determineWorkingDirectoryPath(this.getWorkingPathNamePropertyKey(), this.getDefaultWorkingPath());
this.file = new File(this.workingPath, TEST_FILE_NAME_PREFIX + 1 + TEST_FILE_TYPE);
@@ -60,14 +60,14 @@ public abstract class ConditionalFileFilterAbstractTestCase extends IOFileFilter
filters.add(new TesterTrueFileFilter());
filters.add(new TesterTrueFileFilter());
for (int i = 0; i < filters.size(); i++) {
- assertEquals("file filters count: ", i, fileFilter.getFileFilters().size());
+ assertEquals(i, fileFilter.getFileFilters().size(), "file filters count: ");
fileFilter.addFileFilter(filters.get(i));
- assertEquals("file filters count: ", i + 1, fileFilter.getFileFilters().size());
+ assertEquals(i + 1, fileFilter.getFileFilters().size(), "file filters count: ");
}
for (final IOFileFilter filter : fileFilter.getFileFilters()) {
- assertTrue("found file filter", filters.contains(filter));
+ assertTrue(filters.contains(filter), "found file filter");
}
- assertEquals("file filters count", filters.size(), fileFilter.getFileFilters().size());
+ assertEquals(filters.size(), fileFilter.getFileFilters().size(), "file filters count");
}
@Test
@@ -80,9 +80,9 @@ public abstract class ConditionalFileFilterAbstractTestCase extends IOFileFilter
filters.add(new TesterTrueFileFilter());
for (final TesterTrueFileFilter filter : filters) {
fileFilter.removeFileFilter(filter);
- assertTrue("file filter removed", !fileFilter.getFileFilters().contains(filter));
+ assertTrue(!fileFilter.getFileFilters().contains(filter), "file filter removed");
}
- assertEquals("file filters count", 0, fileFilter.getFileFilters().size());
+ assertEquals(0, fileFilter.getFileFilters().size(), "file filters count");
}
@Test
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 b6091d8..fbf3b30 100644
--- a/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
@@ -16,12 +16,14 @@
*/
package org.apache.commons.io.filefilter;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
import java.io.BufferedOutputStream;
import java.io.File;
@@ -44,23 +46,16 @@ import org.apache.commons.io.IOCase;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.testtools.TestUtils;
import org.apache.commons.lang3.SystemUtils;
-import org.junit.Assert;
-import org.junit.Assume;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* Used to test FileFilterUtils.
*/
public class FileFilterTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public File temporaryFolder;
/**
* The subversion directory name.
@@ -72,18 +67,15 @@ public class FileFilterTestCase {
public void assertFiltering(final IOFileFilter filter, final File file, final boolean expected) throws Exception {
// Note. This only tests the (File, String) version if the parent of
// the File passed in is not null
- assertEquals(
- "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file,
- expected, filter.accept(file));
+ assertEquals(expected, filter.accept(file),
+ "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
if (file != null && file.getParentFile() != null) {
- assertEquals(
- "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file,
- expected, filter.accept(file.getParentFile(), file.getName()));
+ assertEquals(expected, filter.accept(file.getParentFile(), file.getName()),
+ "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file);
} else if (file == null) {
- assertEquals(
- "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null",
- expected, filter.accept(file));
+ assertEquals(expected, filter.accept(file),
+ "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null");
}
assertNotNull(filter.toString());
}
@@ -402,17 +394,15 @@ public class FileFilterTestCase {
}
}
- @Test(expected = IllegalArgumentException.class)
- public void testNameFilterNullArrayArgument() throws Exception {
- new NameFileFilter((String[]) null);
- fail( "constructing a NameFileFilter with a null String[] argument should fail.");
+ @Test
+ public void testNameFilterNullArrayArgument() {
+ assertThrows(IllegalArgumentException.class, () -> new NameFileFilter((String[]) null));
}
- @Test(expected = IllegalArgumentException.class)
- public void testNameFilterNullListArgument() throws Exception {
+ @Test
+ public void testNameFilterNullListArgument() {
final List<String> test = null;
- new NameFileFilter(test);
- fail("constructing a NameFileFilter with a null List argument should fail.");
+ assertThrows(IllegalArgumentException.class, () -> new NameFileFilter(test));
}
@Test
@@ -433,13 +423,13 @@ public class FileFilterTestCase {
assertSame(FalseFileFilter.FALSE, FalseFileFilter.INSTANCE);
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void testNot() throws Exception {
final IOFileFilter filter = FileFilterUtils.notFileFilter(FileFilterUtils.trueFileFilter());
assertFiltering(filter, new File("foo.test"), false);
assertFiltering(filter, new File("foo"), false);
assertFiltering(filter, null, false);
- new NotFileFilter(null);
+ assertThrows(IllegalArgumentException.class, () -> new NotFileFilter(null));
}
@Test
@@ -703,13 +693,13 @@ public class FileFilterTestCase {
final IOFileFilter filter2 = FileFilterUtils.makeCVSAware(FileFilterUtils
.nameFileFilter("test-file1.txt"));
- File file = new File(getTestDirectory(), "CVS");
+ File file = new File(temporaryFolder, "CVS");
file.mkdirs();
assertFiltering(filter1, file, false);
assertFiltering(filter2, file, false);
FileUtils.deleteDirectory(file);
- file = new File(getTestDirectory(), "test-file1.txt");
+ file = new File(temporaryFolder, "test-file1.txt");
if (!file.getParentFile().exists()) {
throw new IOException("Cannot create file " + file
+ " as the parent directory does not exist");
@@ -721,7 +711,7 @@ public class FileFilterTestCase {
assertFiltering(filter1, file, true);
assertFiltering(filter2, file, true);
- file = new File(getTestDirectory(), "test-file2.log");
+ file = new File(temporaryFolder, "test-file2.log");
if (!file.getParentFile().exists()) {
throw new IOException("Cannot create file " + file
+ " as the parent directory does not exist");
@@ -733,7 +723,7 @@ public class FileFilterTestCase {
assertFiltering(filter1, file, true);
assertFiltering(filter2, file, false);
- file = new File(getTestDirectory(), "CVS");
+ file = new File(temporaryFolder, "CVS");
if (!file.getParentFile().exists()) {
throw new IOException("Cannot create file " + file
+ " as the parent directory does not exist");
@@ -752,13 +742,13 @@ public class FileFilterTestCase {
final IOFileFilter filter2 = FileFilterUtils.makeSVNAware(FileFilterUtils
.nameFileFilter("test-file1.txt"));
- File file = new File(getTestDirectory(), SVN_DIR_NAME);
+ File file = new File(temporaryFolder, SVN_DIR_NAME);
file.mkdirs();
assertFiltering(filter1, file, false);
assertFiltering(filter2, file, false);
FileUtils.deleteDirectory(file);
- file = new File(getTestDirectory(), "test-file1.txt");
+ file = new File(temporaryFolder, "test-file1.txt");
if (!file.getParentFile().exists()) {
throw new IOException("Cannot create file " + file
+ " as the parent directory does not exist");
@@ -770,7 +760,7 @@ public class FileFilterTestCase {
assertFiltering(filter1, file, true);
assertFiltering(filter2, file, true);
- file = new File(getTestDirectory(), "test-file2.log");
+ file = new File(temporaryFolder, "test-file2.log");
if (!file.getParentFile().exists()) {
throw new IOException("Cannot create file " + file
+ " as the parent directory does not exist");
@@ -782,7 +772,7 @@ public class FileFilterTestCase {
assertFiltering(filter1, file, true);
assertFiltering(filter2, file, false);
- file = new File(getTestDirectory(), SVN_DIR_NAME);
+ file = new File(temporaryFolder, SVN_DIR_NAME);
if (!file.getParentFile().exists()) {
throw new IOException("Cannot create file " + file
+ " as the parent directory does not exist");
@@ -797,9 +787,9 @@ public class FileFilterTestCase {
@Test
public void testAgeFilter() throws Exception {
- final File oldFile = new File(getTestDirectory(), "old.txt");
- final File reference = new File(getTestDirectory(), "reference.txt");
- final File newFile = new File(getTestDirectory(), "new.txt");
+ final File oldFile = new File(temporaryFolder, "old.txt");
+ final File reference = new File(temporaryFolder, "reference.txt");
+ final File newFile = new File(temporaryFolder, "new.txt");
if (!oldFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + oldFile
@@ -877,7 +867,7 @@ public class FileFilterTestCase {
@Test
public void testSizeFilter() throws Exception {
- final File smallFile = new File(getTestDirectory(), "small.txt");
+ final File smallFile = new File(temporaryFolder, "small.txt");
if (!smallFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + smallFile
+ " as the parent directory does not exist");
@@ -886,7 +876,7 @@ public class FileFilterTestCase {
new BufferedOutputStream(new FileOutputStream(smallFile))) {
TestUtils.generateTestData(output1, 32);
}
- final File largeFile = new File(getTestDirectory(), "large.txt");
+ final File largeFile = new File(temporaryFolder, "large.txt");
if (!largeFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + largeFile
+ " as the parent directory does not exist");
@@ -938,19 +928,19 @@ public class FileFilterTestCase {
assertFiltering(HiddenFileFilter.HIDDEN, hiddenDir, hiddenDir.isHidden());
assertFiltering(HiddenFileFilter.VISIBLE, hiddenDir, !hiddenDir.isHidden());
}
- assertFiltering(HiddenFileFilter.HIDDEN, getTestDirectory(), false);
- assertFiltering(HiddenFileFilter.VISIBLE, getTestDirectory(), true);
+ assertFiltering(HiddenFileFilter.HIDDEN, temporaryFolder, false);
+ assertFiltering(HiddenFileFilter.VISIBLE, temporaryFolder, true);
}
@Test
public void testCanExecute() throws Exception {
- Assume.assumeTrue(SystemUtils.IS_OS_WINDOWS);
+ assumeTrue(SystemUtils.IS_OS_WINDOWS);
final File executableFile = File.createTempFile(getClass().getSimpleName(), ".temp");
try {
try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(executableFile))) {
TestUtils.generateTestData(output, 32);
}
- Assert.assertTrue(executableFile.setExecutable(true));
+ assertTrue(executableFile.setExecutable(true));
assertFiltering(CanExecuteFileFilter.CAN_EXECUTE, executableFile, true);
executableFile.setExecutable(false);
assertFiltering(CanExecuteFileFilter.CANNOT_EXECUTE, executableFile, false);
@@ -961,7 +951,7 @@ public class FileFilterTestCase {
@Test
public void testCanRead() throws Exception {
- final File readOnlyFile = new File(getTestDirectory(), "read-only-file1.txt");
+ final File readOnlyFile = new File(temporaryFolder, "read-only-file1.txt");
if (!readOnlyFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + readOnlyFile
+ " as the parent directory does not exist");
@@ -970,7 +960,7 @@ public class FileFilterTestCase {
new BufferedOutputStream(new FileOutputStream(readOnlyFile))){
TestUtils.generateTestData(output, 32);
}
- Assert.assertTrue(readOnlyFile.setReadOnly());
+ assertTrue(readOnlyFile.setReadOnly());
assertFiltering(CanReadFileFilter.CAN_READ, readOnlyFile, true);
assertFiltering(CanReadFileFilter.CANNOT_READ, readOnlyFile, false);
assertFiltering(CanReadFileFilter.READ_ONLY, readOnlyFile, true);
@@ -979,7 +969,7 @@ public class FileFilterTestCase {
@Test
public void testCanWrite() throws Exception {
- final File readOnlyFile = new File(getTestDirectory(), "read-only-file2.txt");
+ final File readOnlyFile = new File(temporaryFolder, "read-only-file2.txt");
if (!readOnlyFile.getParentFile().exists()) {
throw new IOException("Cannot create file " + readOnlyFile
+ " as the parent directory does not exist");
@@ -988,9 +978,9 @@ public class FileFilterTestCase {
new BufferedOutputStream(new FileOutputStream(readOnlyFile))){
TestUtils.generateTestData(output, 32);
}
- Assert.assertTrue(readOnlyFile.setReadOnly());
- assertFiltering(CanWriteFileFilter.CAN_WRITE, getTestDirectory(), true);
- assertFiltering(CanWriteFileFilter.CANNOT_WRITE, getTestDirectory(), false);
+ assertTrue(readOnlyFile.setReadOnly());
+ assertFiltering(CanWriteFileFilter.CAN_WRITE, temporaryFolder, true);
+ assertFiltering(CanWriteFileFilter.CANNOT_WRITE, temporaryFolder, false);
assertFiltering(CanWriteFileFilter.CAN_WRITE, readOnlyFile, false);
assertFiltering(CanWriteFileFilter.CANNOT_WRITE, readOnlyFile, true);
readOnlyFile.delete();
@@ -1000,7 +990,7 @@ public class FileFilterTestCase {
public void testEmpty() throws Exception {
// Empty Dir
- final File emptyDir = new File(getTestDirectory(), "empty-dir");
+ final File emptyDir = new File(temporaryFolder, "empty-dir");
emptyDir.mkdirs();
assertFiltering(EmptyFileFilter.EMPTY, emptyDir, true);
assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, false);
@@ -1045,8 +1035,8 @@ public class FileFilterTestCase {
final IOFileFilter filter = FileFilterUtils.makeDirectoryOnly(
FileFilterUtils.nameFileFilter("B"));
- final File fileA = new File(getTestDirectory(), "A");
- final File fileB = new File(getTestDirectory(), "B");
+ final File fileA = new File(temporaryFolder, "A");
+ final File fileB = new File(temporaryFolder, "B");
fileA.mkdirs();
fileB.mkdirs();
@@ -1089,8 +1079,8 @@ public class FileFilterTestCase {
final IOFileFilter filter = FileFilterUtils.makeFileOnly(
FileFilterUtils.nameFileFilter("B"));
- final File fileA = new File(getTestDirectory(), "A");
- final File fileB = new File(getTestDirectory(), "B");
+ final File fileA = new File(temporaryFolder, "A");
+ final File fileB = new File(temporaryFolder, "B");
fileA.mkdirs();
fileB.mkdirs();
@@ -1134,10 +1124,10 @@ public class FileFilterTestCase {
final String xmlFileContent = "<?xml version=\"1.0\" encoding=\"UTF-8\">\n" +
"<element>text</element>";
- final File classFileA = new File(getTestDirectory(), "A.class");
- final File xmlFileB = new File(getTestDirectory(), "B.xml");
- final File emptyFile = new File(getTestDirectory(), "C.xml");
- final File dir = new File(getTestDirectory(), "D");
+ final File classFileA = new File(temporaryFolder, "A.class");
+ final File xmlFileB = new File(temporaryFolder, "B.xml");
+ final File emptyFile = new File(temporaryFolder, "C.xml");
+ final File dir = new File(temporaryFolder, "D");
dir.mkdirs();
final OutputStream classFileAStream = FileUtils.openOutputStream(classFileA);
@@ -1169,9 +1159,9 @@ public class FileFilterTestCase {
final byte[] tarMagicNumber = new byte[] {0x75, 0x73, 0x74, 0x61, 0x72};
final long tarMagicNumberOffset = 257;
- final File tarFileA = new File(getTestDirectory(), "A.tar");
- final File randomFileB = new File(getTestDirectory(), "B.txt");
- final File dir = new File(getTestDirectory(), "D");
+ final File tarFileA = new File(temporaryFolder, "A.tar");
+ final File randomFileB = new File(temporaryFolder, "B.txt");
+ final File dir = new File(temporaryFolder, "D");
dir.mkdirs();
final OutputStream tarFileAStream = FileUtils.openOutputStream(tarFileA);
@@ -1211,9 +1201,9 @@ public class FileFilterTestCase {
"<element>text</element>";
final String xmlMagicNumber = "<?xml version=\"1.0\"";
- final File classFileA = new File(getTestDirectory(), "A.class");
- final File xmlFileB = new File(getTestDirectory(), "B.xml");
- final File dir = new File(getTestDirectory(), "D");
+ final File classFileA = new File(temporaryFolder, "A.class");
+ final File xmlFileB = new File(temporaryFolder, "B.xml");
+ final File dir = new File(temporaryFolder, "D");
dir.mkdirs();
final OutputStream classFileAStream = FileUtils.openOutputStream(classFileA);
@@ -1241,9 +1231,9 @@ public class FileFilterTestCase {
final String tarMagicNumber = "ustar";
final long tarMagicNumberOffset = 257;
- final File tarFileA = new File(getTestDirectory(), "A.tar");
- final File randomFileB = new File(getTestDirectory(), "B.txt");
- final File dir = new File(getTestDirectory(), "D");
+ final File tarFileA = new File(temporaryFolder, "A.tar");
+ final File randomFileB = new File(temporaryFolder, "B.txt");
+ final File dir = new File(temporaryFolder, "D");
dir.mkdirs();
final OutputStream tarFileAStream = FileUtils.openOutputStream(tarFileA);
@@ -1321,8 +1311,8 @@ public class FileFilterTestCase {
*/
@Test
public void testFilterArray() throws Exception {
- final File fileA = TestUtils.newFile(getTestDirectory(), "A");
- final File fileB = TestUtils.newFile(getTestDirectory(), "B");
+ final File fileA = TestUtils.newFile(temporaryFolder, "A");
+ final File fileB = TestUtils.newFile(temporaryFolder, "B");
final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
@@ -1338,8 +1328,8 @@ public class FileFilterTestCase {
*/
@Test
public void testFilterArray_fromList() throws Exception {
- final File fileA = TestUtils.newFile(getTestDirectory(), "A");
- final File fileB = TestUtils.newFile(getTestDirectory(), "B");
+ final File fileA = TestUtils.newFile(temporaryFolder, "A");
+ final File fileB = TestUtils.newFile(temporaryFolder, "B");
final List<File> fileList = Arrays.asList(fileA, fileB);
final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
@@ -1357,8 +1347,8 @@ public class FileFilterTestCase {
*/
@Test
public void testFilterArrayNullParameters() throws Exception {
- final File fileA = TestUtils.newFile(getTestDirectory(), "A");
- final File fileB = TestUtils.newFile(getTestDirectory(), "B");
+ final File fileA = TestUtils.newFile(temporaryFolder, "A");
+ final File fileB = TestUtils.newFile(temporaryFolder, "B");
try {
FileFilterUtils.filter(null, fileA, fileB);
fail();
@@ -1384,8 +1374,8 @@ public class FileFilterTestCase {
*/
@Test
public void testFilterList() throws Exception {
- final File fileA = TestUtils.newFile(getTestDirectory(), "A");
- final File fileB = TestUtils.newFile(getTestDirectory(), "B");
+ final File fileA = TestUtils.newFile(temporaryFolder, "A");
+ final File fileB = TestUtils.newFile(temporaryFolder, "B");
final List<File> fileList = Arrays.asList(fileA, fileB);
final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
@@ -1402,8 +1392,8 @@ public class FileFilterTestCase {
*/
@Test
public void testFilterList_fromArray() throws Exception {
- final File fileA = TestUtils.newFile(getTestDirectory(), "A");
- final File fileB = TestUtils.newFile(getTestDirectory(), "B");
+ final File fileA = TestUtils.newFile(temporaryFolder, "A");
+ final File fileB = TestUtils.newFile(temporaryFolder, "B");
final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
@@ -1445,8 +1435,8 @@ public class FileFilterTestCase {
*/
@Test
public void testFilterSet() throws Exception {
- final File fileA = TestUtils.newFile(getTestDirectory(), "A");
- final File fileB = TestUtils.newFile(getTestDirectory(), "B");
+ final File fileA = TestUtils.newFile(temporaryFolder, "A");
+ final File fileB = TestUtils.newFile(temporaryFolder, "B");
final Set<File> fileList = new HashSet<>(Arrays.asList(fileA, fileB));
final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
@@ -1463,8 +1453,8 @@ public class FileFilterTestCase {
*/
@Test
public void testFilterSet_fromArray() throws Exception {
- final File fileA = TestUtils.newFile(getTestDirectory(), "A");
- final File fileB = TestUtils.newFile(getTestDirectory(), "B");
+ final File fileA = TestUtils.newFile(temporaryFolder, "A");
+ final File fileB = TestUtils.newFile(temporaryFolder, "B");
final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
diff --git a/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java b/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java
index a2bec0f..3b2783f 100644
--- a/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.io.filefilter;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.File;
@@ -24,47 +24,42 @@ public abstract class IOFileFilterAbstractTestCase {
public static void assertFileFiltering(final int testNumber, final IOFileFilter filter, final File file, final boolean expected)
throws Exception {
- assertEquals(
- "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file,
- expected, filter.accept(file));
+ assertEquals(expected, filter.accept(file),
+ "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
}
public static void assertFilenameFiltering(final int testNumber, final IOFileFilter filter, final File file, final boolean expected)
throws Exception {
// Assumes file has parent and is not passed as null
- assertEquals(
- "test " + testNumber + " Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file,
- expected, filter.accept(file.getParentFile(), file.getName()));
+ assertEquals(expected, filter.accept(file.getParentFile(), file.getName()),
+ "test " + testNumber + " Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file);
}
public static void assertFiltering(final int testNumber, final IOFileFilter filter, final File file, final boolean expected)
throws Exception {
// Note. This only tests the (File, String) version if the parent of
// the File passed in is not null
- assertEquals(
- "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file,
- expected, filter.accept(file));
+ assertEquals(expected, filter.accept(file),
+ "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
if (file != null && file.getParentFile() != null) {
- assertEquals(
- "test " + testNumber + " Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file,
- expected, filter.accept(file.getParentFile(), file.getName()));
+ assertEquals(expected, filter.accept(file.getParentFile(), file.getName()),
+ "test " + testNumber + " Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file);
} else if (file == null) {
- assertEquals(
- "test " + testNumber + " Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null",
- expected, filter.accept(file));
+ assertEquals(expected, filter.accept(file),
+ "test " + testNumber + " Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null");
}
}
public static void assertTrueFiltersInvoked(final int testNumber, final TesterTrueFileFilter[] filters, final boolean[] invoked) {
for (int i = 1; i < filters.length; i++) {
- assertEquals("test " + testNumber + " filter " + i + " invoked", invoked[i - 1], filters[i].isInvoked());
+ assertEquals(invoked[i - 1], filters[i].isInvoked(), "test " + testNumber + " filter " + i + " invoked");
}
}
public static void assertFalseFiltersInvoked(final int testNumber, final TesterFalseFileFilter[] filters, final boolean[] invoked) {
for (int i = 1; i < filters.length; i++) {
- assertEquals("test " + testNumber + " filter " + i + " invoked", invoked[i - 1], filters[i].isInvoked());
+ assertEquals(invoked[i - 1], filters[i].isInvoked(), "test " + testNumber + " filter " + i + " invoked");
}
}
diff --git a/src/test/java/org/apache/commons/io/filefilter/OrFileFilterTestCase.java b/src/test/java/org/apache/commons/io/filefilter/OrFileFilterTestCase.java
index a3b9c30..e01c01a 100644
--- a/src/test/java/org/apache/commons/io/filefilter/OrFileFilterTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/OrFileFilterTestCase.java
@@ -19,7 +19,7 @@ package org.apache.commons.io.filefilter;
import java.util.ArrayList;
import java.util.List;
-import org.junit.Before;
+import org.junit.jupiter.api.BeforeEach;
public class OrFileFilterTestCase extends ConditionalFileFilterAbstractTestCase {
@@ -86,7 +86,7 @@ public class OrFileFilterTestCase extends ConditionalFileFilterAbstractTestCase
return WORKING_PATH_NAME_PROPERTY_KEY;
}
- @Before
+ @BeforeEach
public void setUpTestFilters() {
// filters
//tests
diff --git a/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java b/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java
index 120c857..ed75f14 100644
--- a/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java
@@ -16,40 +16,32 @@
*/
package org.apache.commons.io.filefilter;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.File;
import java.util.regex.Pattern;
import org.apache.commons.io.IOCase;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
/**
* Used to test RegexFileFilterUtils.
*/
public class RegexFileFilterTestCase {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
public void assertFiltering(final IOFileFilter filter, final File file, final boolean expected) throws Exception {
// Note. This only tests the (File, String) version if the parent of
// the File passed in is not null
- assertEquals(
- "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file,
- expected, filter.accept(file));
+ assertEquals(expected, filter.accept(file),
+ "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
if (file != null && file.getParentFile() != null) {
- assertEquals(
- "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file,
- expected, filter.accept(file.getParentFile(), file.getName()));
+ assertEquals(expected, filter.accept(file.getParentFile(), file.getName()),
+ "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file);
} else if (file == null) {
- assertEquals(
- "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null",
- expected, filter.accept(file));
+ assertEquals(expected, filter.accept(file),
+ "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null");
}
}
diff --git a/src/test/java/org/apache/commons/io/input/AutoCloseInputStreamTest.java b/src/test/java/org/apache/commons/io/input/AutoCloseInputStreamTest.java
index 09c4e9f..c067f6f 100644
--- a/src/test/java/org/apache/commons/io/input/AutoCloseInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/AutoCloseInputStreamTest.java
@@ -16,16 +16,16 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+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.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link AutoCloseInputStream}.
@@ -38,7 +38,7 @@ public class AutoCloseInputStreamTest {
private boolean closed;
- @Before
+ @BeforeEach
public void setUp() {
data = new byte[] { 'x', 'y', 'z' };
stream = new AutoCloseInputStream(new ByteArrayInputStream(data) {
@@ -53,19 +53,19 @@ public class AutoCloseInputStreamTest {
@Test
public void testClose() throws IOException {
stream.close();
- assertTrue("closed", closed);
- assertEquals("read()", -1, stream.read());
+ assertTrue(closed, "closed");
+ assertEquals(-1, stream.read(), "read()");
}
@Test
public void testRead() throws IOException {
for (final byte element : data) {
- assertEquals("read()", element, stream.read());
- assertFalse("closed", closed);
+ assertEquals(element, stream.read(), "read()");
+ assertFalse(closed, "closed");
}
- assertEquals("read()", -1, stream.read());
- assertTrue("closed", closed);
+ assertEquals(-1, stream.read(), "read()");
+ assertTrue(closed, "closed");
}
@Test
@@ -73,15 +73,15 @@ public class AutoCloseInputStreamTest {
final byte[] b = new byte[data.length * 2];
int total = 0;
for (int n = 0; n != -1; n = stream.read(b)) {
- assertFalse("closed", closed);
+ assertFalse(closed, "closed");
for (int i = 0; i < n; i++) {
- assertEquals("read(b)", data[total + i], b[i]);
+ assertEquals(data[total + i], b[i], "read(b)");
}
total += n;
}
- assertEquals("read(b)", data.length, total);
- assertTrue("closed", closed);
- assertEquals("read(b)", -1, stream.read(b));
+ assertEquals(data.length, total, "read(b)");
+ assertTrue(closed, "closed");
+ assertEquals(-1, stream.read(b), "read(b)");
}
@Test
@@ -89,15 +89,15 @@ public class AutoCloseInputStreamTest {
final byte[] b = new byte[data.length * 2];
int total = 0;
for (int n = 0; n != -1; n = stream.read(b, total, b.length - total)) {
- assertFalse("closed", closed);
+ assertFalse(closed, "closed");
total += n;
}
- assertEquals("read(b, off, len)", data.length, total);
+ assertEquals(data.length, total, "read(b, off, len)");
for (int i = 0; i < data.length; i++) {
- assertEquals("read(b, off, len)", data[i], b[i]);
+ assertEquals(data[i], b[i], "read(b, off, len)");
}
- assertTrue("closed", closed);
- assertEquals("read(b, off, len)", -1, stream.read(b, 0, b.length));
+ assertTrue(closed, "closed");
+ assertEquals(-1, stream.read(b, 0, b.length), "read(b, off, len)");
}
}
diff --git a/src/test/java/org/apache/commons/io/input/BOMInputStreamTest.java b/src/test/java/org/apache/commons/io/input/BOMInputStreamTest.java
index d5a19b1..015535a 100644
--- a/src/test/java/org/apache/commons/io/input/BOMInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/BOMInputStreamTest.java
@@ -16,12 +16,14 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assumptions.assumeFalse;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
import java.io.ByteArrayInputStream;
import java.io.IOException;
@@ -35,9 +37,7 @@ import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.apache.commons.io.ByteOrderMark;
-import org.junit.Assert;
-import org.junit.Assume;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
@@ -76,9 +76,9 @@ public class BOMInputStreamTest {
private void assertData(final byte[] expected, final byte[] actual, final int len)
throws Exception {
- assertEquals("length", expected.length, len);
+ assertEquals(expected.length, len, "length");
for (int ii = 0; ii < expected.length; ii++) {
- assertEquals("byte " + ii, expected[ii], actual[ii]);
+ assertEquals(expected[ii], actual[ii], "byte " + ii);
}
}
@@ -175,7 +175,7 @@ public class BOMInputStreamTest {
private void readBOMInputStreamTwice(final String resource) throws Exception {
final InputStream inputStream = this.getClass().getResourceAsStream(resource);
- Assert.assertNotNull(inputStream);
+ assertNotNull(inputStream);
final BOMInputStream bomInputStream = new BOMInputStream(inputStream);
bomInputStream.mark(1000000);
@@ -243,9 +243,9 @@ public class BOMInputStreamTest {
public void testGetBOMFirstThenRead() throws Exception {
final byte[] data = new byte[] { 'A', 'B', 'C' };
try (final BOMInputStream in = new BOMInputStream(createUtf8DataStream(data, true))) {
- assertEquals("getBOM", ByteOrderMark.UTF_8, in.getBOM());
- assertTrue("hasBOM()", in.hasBOM());
- assertTrue("hasBOM(UTF-8)", in.hasBOM(ByteOrderMark.UTF_8));
+ assertEquals(ByteOrderMark.UTF_8, in.getBOM(), "getBOM");
+ assertTrue(in.hasBOM(), "hasBOM()");
+ assertTrue(in.hasBOM(ByteOrderMark.UTF_8), "hasBOM(UTF-8)");
assertEquals('A', in.read());
assertEquals('B', in.read());
assertEquals('C', in.read());
@@ -257,9 +257,9 @@ public class BOMInputStreamTest {
public void testGetBOMFirstThenReadInclude() throws Exception {
final byte[] data = new byte[] { 'A', 'B', 'C' };
try (final BOMInputStream in = new BOMInputStream(createUtf8DataStream(data, true), true)) {
- assertTrue("hasBOM()", in.hasBOM());
- assertTrue("hasBOM(UTF-8)", in.hasBOM(ByteOrderMark.UTF_8));
- assertEquals("getBOM", ByteOrderMark.UTF_8, in.getBOM());
+ assertTrue(in.hasBOM(), "hasBOM()");
+ assertTrue(in.hasBOM(ByteOrderMark.UTF_8), "hasBOM(UTF-8)");
+ assertEquals(ByteOrderMark.UTF_8, in.getBOM(), "getBOM");
assertEquals(0xEF, in.read());
assertEquals(0xBB, in.read());
assertEquals(0xBF, in.read());
@@ -396,9 +396,9 @@ public class BOMInputStreamTest {
final byte[] data = new byte[] {};
try (final BOMInputStream in = new BOMInputStream(createUtf8DataStream(data, false))) {
assertEquals(-1, in.read());
- assertFalse("hasBOM()", in.hasBOM());
- assertFalse("hasBOM(UTF-8)", in.hasBOM(ByteOrderMark.UTF_8));
- assertNull("getBOM", in.getBOM());
+ assertFalse(in.hasBOM(), "hasBOM()");
+ assertFalse(in.hasBOM(ByteOrderMark.UTF_8), "hasBOM(UTF-8)");
+ assertNull(in.getBOM(), "getBOM");
}
}
@@ -409,9 +409,9 @@ public class BOMInputStreamTest {
assertEquals('A', in.read());
assertEquals('B', in.read());
assertEquals(-1, in.read());
- assertFalse("hasBOM()", in.hasBOM());
- assertFalse("hasBOM(UTF-8)", in.hasBOM(ByteOrderMark.UTF_8));
- assertNull("getBOM", in.getBOM());
+ assertFalse(in.hasBOM(), "hasBOM()");
+ assertFalse(in.hasBOM(ByteOrderMark.UTF_8), "hasBOM(UTF-8)");
+ assertNull(in.getBOM(), "getBOM");
}
}
@@ -436,9 +436,9 @@ public class BOMInputStreamTest {
assertEquals('B', in.read());
assertEquals('C', in.read());
assertEquals(-1, in.read());
- assertTrue("hasBOM()", in.hasBOM());
- assertTrue("hasBOM(UTF-8)", in.hasBOM(ByteOrderMark.UTF_8));
- assertEquals("getBOM", ByteOrderMark.UTF_8, in.getBOM());
+ assertTrue(in.hasBOM(), "hasBOM()");
+ assertTrue(in.hasBOM(ByteOrderMark.UTF_8), "hasBOM(UTF-8)");
+ assertEquals(ByteOrderMark.UTF_8, in.getBOM(), "getBOM");
}
}
@@ -454,9 +454,9 @@ public class BOMInputStreamTest {
assertEquals(0, in.read());
assertEquals('C', in.read());
assertEquals(-1, in.read());
- assertTrue("hasBOM()", in.hasBOM());
- assertTrue("hasBOM(UTF-16BE)", in.hasBOM(ByteOrderMark.UTF_16BE));
- assertEquals("getBOM", ByteOrderMark.UTF_16BE, in.getBOM());
+ assertTrue(in.hasBOM(), "hasBOM()");
+ assertTrue(in.hasBOM(ByteOrderMark.UTF_16BE), "hasBOM(UTF-16BE)");
+ assertEquals(ByteOrderMark.UTF_16BE, in.getBOM(), "getBOM");
try {
in.hasBOM(ByteOrderMark.UTF_16LE);
fail("Expected IllegalArgumentException");
@@ -478,9 +478,9 @@ public class BOMInputStreamTest {
assertEquals('C', in.read());
assertEquals(0, in.read());
assertEquals(-1, in.read());
- assertTrue("hasBOM()", in.hasBOM());
- assertTrue("hasBOM(UTF-16LE)", in.hasBOM(ByteOrderMark.UTF_16LE));
- assertEquals("getBOM", ByteOrderMark.UTF_16LE, in.getBOM());
+ assertTrue(in.hasBOM(), "hasBOM()");
+ assertTrue(in.hasBOM(ByteOrderMark.UTF_16LE), "hasBOM(UTF-16LE)");
+ assertEquals(ByteOrderMark.UTF_16LE, in.getBOM(), "getBOM");
try {
in.hasBOM(ByteOrderMark.UTF_16BE);
fail("Expected IllegalArgumentException");
@@ -492,7 +492,7 @@ public class BOMInputStreamTest {
@Test
public void testReadWithBOMUtf32Be() throws Exception {
- Assume.assumeTrue(Charset.isSupported("UTF_32BE"));
+ assumeTrue(Charset.isSupported("UTF_32BE"));
final byte[] data = "ABC".getBytes("UTF_32BE");
try (final BOMInputStream in = new BOMInputStream(createUtf32BeDataStream(data, true),
ByteOrderMark.UTF_32BE)) {
@@ -509,9 +509,9 @@ public class BOMInputStreamTest {
assertEquals(0, in.read());
assertEquals('C', in.read());
assertEquals(-1, in.read());
- assertTrue("hasBOM()", in.hasBOM());
- assertTrue("hasBOM(UTF-32BE)", in.hasBOM(ByteOrderMark.UTF_32BE));
- assertEquals("getBOM", ByteOrderMark.UTF_32BE, in.getBOM());
+ assertTrue(in.hasBOM(), "hasBOM()");
+ assertTrue(in.hasBOM(ByteOrderMark.UTF_32BE), "hasBOM(UTF-32BE)");
+ assertEquals(ByteOrderMark.UTF_32BE, in.getBOM(), "getBOM");
try {
in.hasBOM(ByteOrderMark.UTF_32LE);
fail("Expected IllegalArgumentException");
@@ -523,7 +523,7 @@ public class BOMInputStreamTest {
@Test
public void testReadWithBOMUtf32Le() throws Exception {
- Assume.assumeTrue(Charset.isSupported("UTF_32LE"));
+ assumeTrue(Charset.isSupported("UTF_32LE"));
final byte[] data = "ABC".getBytes("UTF_32LE");
try (final BOMInputStream in = new BOMInputStream(createUtf32LeDataStream(data, true),
ByteOrderMark.UTF_32LE)) {
@@ -540,9 +540,9 @@ public class BOMInputStreamTest {
assertEquals(0, in.read());
assertEquals(0, in.read());
assertEquals(-1, in.read());
- assertTrue("hasBOM()", in.hasBOM());
- assertTrue("hasBOM(UTF-32LE)", in.hasBOM(ByteOrderMark.UTF_32LE));
- assertEquals("getBOM", ByteOrderMark.UTF_32LE, in.getBOM());
+ assertTrue(in.hasBOM(), "hasBOM()");
+ assertTrue(in.hasBOM(ByteOrderMark.UTF_32LE), "hasBOM(UTF-32LE)");
+ assertEquals(ByteOrderMark.UTF_32LE, in.getBOM(), "getBOM");
try {
in.hasBOM(ByteOrderMark.UTF_32BE);
fail("Expected IllegalArgumentException");
@@ -560,9 +560,9 @@ public class BOMInputStreamTest {
assertEquals('B', in.read());
assertEquals('C', in.read());
assertEquals(-1, in.read());
- assertTrue("hasBOM()", in.hasBOM());
- assertTrue("hasBOM(UTF-8)", in.hasBOM(ByteOrderMark.UTF_8));
- assertEquals("getBOM", ByteOrderMark.UTF_8, in.getBOM());
+ assertTrue(in.hasBOM(), "hasBOM()");
+ assertTrue(in.hasBOM(ByteOrderMark.UTF_8), "hasBOM(UTF-8)");
+ assertEquals(ByteOrderMark.UTF_8, in.getBOM(), "getBOM");
try {
in.hasBOM(ByteOrderMark.UTF_16BE);
fail("Expected IllegalArgumentException");
@@ -581,10 +581,10 @@ public class BOMInputStreamTest {
assertEquals('B', in.read());
assertEquals('C', in.read());
assertEquals(-1, in.read());
- assertTrue("hasBOM()", in.hasBOM());
- assertTrue("hasBOM(UTF-8)", in.hasBOM(ByteOrderMark.UTF_8));
- assertFalse("hasBOM(UTF-16BE)", in.hasBOM(ByteOrderMark.UTF_16BE));
- assertEquals("getBOM", ByteOrderMark.UTF_8, in.getBOM());
+ assertTrue(in.hasBOM(), "hasBOM()");
+ assertTrue(in.hasBOM(ByteOrderMark.UTF_8), "hasBOM(UTF-8)");
+ assertFalse(in.hasBOM(ByteOrderMark.UTF_16BE), "hasBOM(UTF-16BE)");
+ assertEquals(ByteOrderMark.UTF_8, in.getBOM(), "getBOM");
}
}
@@ -596,18 +596,18 @@ public class BOMInputStreamTest {
assertEquals('B', in.read());
assertEquals('C', in.read());
assertEquals(-1, in.read());
- assertFalse("hasBOM()", in.hasBOM());
- assertFalse("hasBOM(UTF-8)", in.hasBOM(ByteOrderMark.UTF_8));
- assertNull("getBOM", in.getBOM());
+ assertFalse(in.hasBOM(), "hasBOM()");
+ assertFalse(in.hasBOM(ByteOrderMark.UTF_8), "hasBOM(UTF-8)");
+ assertNull(in.getBOM(), "getBOM");
}
}
@Test
public void testReadXmlWithBOMUcs2() throws Exception {
- Assume.assumeFalse("This test does not pass on some IBM VMs xml parsers", System.getProperty("java.vendor").contains("IBM"));
+ assumeFalse(System.getProperty("java.vendor").contains("IBM"), "This test does not pass on some IBM VMs xml parsers");
// UCS-2 is BE.
- Assume.assumeTrue(Charset.isSupported("ISO-10646-UCS-2"));
+ assumeTrue(Charset.isSupported("ISO-10646-UCS-2"));
final byte[] data = "<?xml version=\"1.0\" encoding=\"ISO-10646-UCS-2\"?><X/>".getBytes("ISO-10646-UCS-2");
try (BOMInputStream in = new BOMInputStream(createUtf16BeDataStream(data, true), ByteOrderMark.UTF_16BE)) {
parseXml(in);
@@ -619,13 +619,13 @@ public class BOMInputStreamTest {
public void testReadXmlWithBOMUcs4() throws Exception {
// UCS-4 is BE or LE?
// Hm: ISO-10646-UCS-4 is not supported on Oracle 1.6.0_31
- Assume.assumeTrue(Charset.isSupported("ISO-10646-UCS-4"));
+ assumeTrue(Charset.isSupported("ISO-10646-UCS-4"));
final byte[] data = "<?xml version=\"1.0\" encoding=\"ISO-10646-UCS-4\"?><X/>".getBytes("ISO-10646-UCS-4");
// XML parser does not know what to do with UTF-32
try (BOMInputStream in = new BOMInputStream(createUtf32BeDataStream(data, true), ByteOrderMark.UTF_32BE)) {
parseXml(in);
// XML parser does not know what to do with UTF-32
- Assume.assumeTrue("JVM and SAX need to support UTF_32LE for this", jvmAndSaxBothSupportCharset("UTF_32LE"));
+ assumeTrue(jvmAndSaxBothSupportCharset("UTF_32LE"), "JVM and SAX need to support UTF_32LE for this");
}
parseXml(createUtf32BeDataStream(data, true));
}
@@ -650,7 +650,7 @@ public class BOMInputStreamTest {
@Test
public void testReadXmlWithBOMUtf32Be() throws Exception {
- Assume.assumeTrue("JVM and SAX need to support UTF_32BE for this", jvmAndSaxBothSupportCharset("UTF_32BE"));
+ assumeTrue(jvmAndSaxBothSupportCharset("UTF_32BE"), "JVM and SAX need to support UTF_32BE for this");
final byte[] data = "<?xml version=\"1.0\" encoding=\"UTF-32BE\"?><X/>".getBytes("UTF_32BE");
try (BOMInputStream in = new BOMInputStream(createUtf32BeDataStream(data, true), ByteOrderMark.UTF_32BE)) {
parseXml(in);
@@ -663,7 +663,7 @@ public class BOMInputStreamTest {
@Test
public void testReadXmlWithBOMUtf32Le() throws Exception {
- Assume.assumeTrue("JVM and SAX need to support UTF_32LE for this", jvmAndSaxBothSupportCharset("UTF_32LE"));
+ assumeTrue(jvmAndSaxBothSupportCharset("UTF_32LE"), "JVM and SAX need to support UTF_32LE for this");
final byte[] data = "<?xml version=\"1.0\" encoding=\"UTF-32LE\"?><X/>".getBytes("UTF_32LE");
try (BOMInputStream in = new BOMInputStream(createUtf32LeDataStream(data, true), ByteOrderMark.UTF_32LE)) {
parseXml(in);
@@ -685,7 +685,7 @@ public class BOMInputStreamTest {
@Test
public void testReadXmlWithoutBOMUtf32Be() throws Exception {
- Assume.assumeTrue("JVM and SAX need to support UTF_32BE for this", jvmAndSaxBothSupportCharset("UTF_32BE"));
+ assumeTrue(jvmAndSaxBothSupportCharset("UTF_32BE"), "JVM and SAX need to support UTF_32BE for this");
final byte[] data = "<?xml version=\"1.0\" encoding=\"UTF_32BE\"?><X/>".getBytes("UTF_32BE");
try (BOMInputStream in = new BOMInputStream(createUtf32BeDataStream(data, false))) {
parseXml(in);
@@ -695,7 +695,7 @@ public class BOMInputStreamTest {
@Test
public void testReadXmlWithoutBOMUtf32Le() throws Exception {
- Assume.assumeTrue("JVM and SAX need to support UTF_32LE for this", jvmAndSaxBothSupportCharset("UTF_32LE"));
+ assumeTrue(jvmAndSaxBothSupportCharset("UTF_32LE"), "JVM and SAX need to support UTF_32LE for this");
final byte[] data = "<?xml version=\"1.0\" encoding=\"UTF-32LE\"?><X/>".getBytes("UTF_32LE");
try (BOMInputStream in = new BOMInputStream(createUtf32LeDataStream(data, false))) {
parseXml(in);
diff --git a/src/test/java/org/apache/commons/io/input/BoundedInputStreamTest.java b/src/test/java/org/apache/commons/io/input/BoundedInputStreamTest.java
index 5ff73b3..9845829 100644
--- a/src/test/java/org/apache/commons/io/input/BoundedInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/BoundedInputStreamTest.java
@@ -16,12 +16,12 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.ByteArrayInputStream;
import org.apache.commons.io.IOUtils;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Tests for {@link BoundedInputStream}.
@@ -38,23 +38,23 @@ public class BoundedInputStreamTest {
// limit = length
bounded = new BoundedInputStream(new ByteArrayInputStream(helloWorld), helloWorld.length);
for (int i = 0; i < helloWorld.length; i++) {
- assertEquals("limit = length byte[" + i + "]", helloWorld[i], bounded.read());
+ assertEquals(helloWorld[i], bounded.read(), "limit = length byte[" + i + "]");
}
- assertEquals("limit = length end", -1, bounded.read());
+ assertEquals(-1, bounded.read(), "limit = length end");
// limit > length
bounded = new BoundedInputStream(new ByteArrayInputStream(helloWorld), helloWorld.length + 1);
for (int i = 0; i < helloWorld.length; i++) {
- assertEquals("limit > length byte[" + i + "]", helloWorld[i], bounded.read());
+ assertEquals(helloWorld[i], bounded.read(), "limit > length byte[" + i + "]");
}
- assertEquals("limit > length end", -1, bounded.read());
+ assertEquals(-1, bounded.read(), "limit > length end");
// limit < length
bounded = new BoundedInputStream(new ByteArrayInputStream(helloWorld), hello.length);
for (int i = 0; i < hello.length; i++) {
- assertEquals("limit < length byte[" + i + "]", hello[i], bounded.read());
+ assertEquals(hello[i], bounded.read(), "limit < length byte[" + i + "]");
}
- assertEquals("limit < length end", -1, bounded.read());
+ assertEquals(-1, bounded.read(), "limit < length end");
}
@Test
@@ -81,9 +81,9 @@ public class BoundedInputStreamTest {
}
private void compare(final String msg, final byte[] expected, final byte[] actual) {
- assertEquals(msg + " length", expected.length, actual.length);
+ assertEquals(expected.length, actual.length, msg + " length");
for (int i = 0; i < expected.length; i++) {
- assertEquals(msg + " byte[" + i + "]", expected[i], actual[i]);
+ assertEquals(expected[i], actual[i], msg + " byte[" + i + "]");
}
}
}
diff --git a/src/test/java/org/apache/commons/io/input/BoundedReaderTest.java b/src/test/java/org/apache/commons/io/input/BoundedReaderTest.java
index f40cbad..c78f035 100644
--- a/src/test/java/org/apache/commons/io/input/BoundedReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/BoundedReaderTest.java
@@ -18,8 +18,9 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTimeout;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.BufferedReader;
import java.io.File;
@@ -31,10 +32,11 @@ import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
+import java.time.Duration;
import java.util.concurrent.atomic.AtomicBoolean;
import org.apache.commons.io.FileUtils;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class BoundedReaderTest {
private static final String STRING_END_NO_EOL = "0\n1\n2";
@@ -198,24 +200,24 @@ public class BoundedReaderTest {
}
}
- @Test(timeout = 5000)
- public void testLineNumberReaderAndStringReaderLastLineEolNo() throws IOException {
- testLineNumberReader(new StringReader(STRING_END_NO_EOL));
+ @Test
+ public void testLineNumberReaderAndStringReaderLastLineEolNo() {
+ assertTimeout(Duration.ofMillis(5000), () -> testLineNumberReader(new StringReader(STRING_END_NO_EOL)));
}
- @Test(timeout = 5000)
+ @Test
public void testLineNumberReaderAndStringReaderLastLineEolYes() throws IOException {
- testLineNumberReader(new StringReader(STRING_END_EOL));
+ assertTimeout(Duration.ofMillis(5000), () -> testLineNumberReader(new StringReader(STRING_END_EOL)));
}
- @Test(timeout = 5000)
+ @Test
public void testLineNumberReaderAndFileReaderLastLineEolNo() throws IOException {
- testLineNumberReaderAndFileReaderLastLine(STRING_END_NO_EOL);
+ assertTimeout(Duration.ofMillis(5000), () -> testLineNumberReaderAndFileReaderLastLine(STRING_END_NO_EOL));
}
- @Test(timeout = 5000)
+ @Test
public void testLineNumberReaderAndFileReaderLastLineEolYes() throws IOException {
- testLineNumberReaderAndFileReaderLastLine(STRING_END_EOL);
+ assertTimeout(Duration.ofMillis(5000), () -> testLineNumberReaderAndFileReaderLastLine(STRING_END_EOL));
}
public void testLineNumberReaderAndFileReaderLastLine(final String data) throws IOException {
@@ -231,13 +233,14 @@ public class BoundedReaderTest {
}
}
- @Test(timeout = 5000)
+ @Test
public void testReadBytesEOF() throws IOException {
- final BoundedReader mr = new BoundedReader(sr, 3);
- try (BufferedReader br = new BufferedReader(mr)) {
- br.readLine();
- br.readLine();
- }
+ assertTimeout(Duration.ofMillis(5000), () -> {
+ final BoundedReader mr = new BoundedReader(sr, 3);
+ try (BufferedReader br = new BufferedReader(mr)) {
+ br.readLine();
+ br.readLine();
+ }
+ });
}
-
}
diff --git a/src/test/java/org/apache/commons/io/input/BrokenInputStreamTest.java b/src/test/java/org/apache/commons/io/input/BrokenInputStreamTest.java
index 361d11a..0394162 100644
--- a/src/test/java/org/apache/commons/io/input/BrokenInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/BrokenInputStreamTest.java
@@ -16,14 +16,14 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.IOException;
import java.io.InputStream;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link BrokenInputStream}.
@@ -35,7 +35,7 @@ public class BrokenInputStreamTest {
private InputStream stream;
- @Before
+ @BeforeEach
public void setUp() {
exception = new IOException("test exception");
stream = new BrokenInputStream(exception);
diff --git a/src/test/java/org/apache/commons/io/input/BrokenReaderTest.java b/src/test/java/org/apache/commons/io/input/BrokenReaderTest.java
index c61b309..5ad04b2 100644
--- a/src/test/java/org/apache/commons/io/input/BrokenReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/BrokenReaderTest.java
@@ -16,14 +16,14 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.IOException;
import java.io.Reader;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link BrokenReader}.
@@ -35,7 +35,7 @@ public class BrokenReaderTest {
private Reader reader;
- @Before
+ @BeforeEach
public void setUp() {
exception = new IOException("test exception");
reader = new BrokenReader(exception);
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 e55f88b..04fc61f 100644
--- a/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java
@@ -16,11 +16,11 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+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.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.IOException;
import java.io.InputStream;
@@ -29,8 +29,8 @@ import java.util.Random;
import java.util.Set;
import org.apache.commons.io.Charsets;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
public class CharSequenceInputStreamTest {
@@ -57,20 +57,19 @@ public class CharSequenceInputStreamTest {
final byte[] expected = testString.getBytes(charsetName);
try (InputStream in = new CharSequenceInputStream(testString, charsetName, 512)) {
final byte[] buffer = new byte[128];
- int offset = 0;
- while (true) {
+ int offset = 0; while (true) {
int bufferOffset = random.nextInt(64);
final int bufferLength = random.nextInt(64);
int read = in.read(buffer, bufferOffset, bufferLength);
if (read == -1) {
- assertEquals("EOF: offset should equal length for charset " + charsetName, expected.length, offset);
+ assertEquals(expected.length, offset, "EOF: offset should equal length for charset " + charsetName);
break;
}
- assertTrue("Read " + read + " <= " + bufferLength, read <= bufferLength);
+ assertTrue(read <= bufferLength, "Read " + read + " <= " + bufferLength);
while (read > 0) {
- assertTrue("offset for " + charsetName + " " + offset + " < " + expected.length, offset <
- expected.length);
- assertEquals("bytes should agree for " + charsetName, expected[offset], buffer[bufferOffset]);
+ assertTrue(offset < expected.length,
+ "offset for " + charsetName + " " + offset + " < " + expected.length);
+ assertEquals(expected[offset], buffer[bufferOffset], "bytes should agree for " + charsetName);
offset++;
bufferOffset++;
read--;
@@ -151,7 +150,7 @@ public class CharSequenceInputStreamTest {
is.close();
// data buffers should be identical
- assertArrayEquals("bufferSize=" + bufferSize + " dataSize=" + dataSize, data1, data2);
+ assertArrayEquals(data1, data2, "bufferSize=" + bufferSize + " dataSize=" + dataSize);
}
@Test
@@ -236,20 +235,20 @@ public class CharSequenceInputStreamTest {
try (InputStream r = new CharSequenceInputStream("test", csName)) {
assertEquals(2, r.skip(2));
r.mark(0);
- assertEquals(csName, 's', r.read());
- assertEquals(csName, 't', r.read());
- assertEquals(csName, -1, r.read());
+ assertEquals('s', r.read(), csName);
+ assertEquals('t', r.read(), csName);
+ assertEquals(-1, r.read(), csName);
r.reset();
- assertEquals(csName, 's', r.read());
- assertEquals(csName, 't', r.read());
- assertEquals(csName, -1, r.read());
+ assertEquals('s', r.read(), csName);
+ assertEquals('t', r.read(), csName);
+ assertEquals(-1, r.read(), csName);
r.reset();
r.reset();
}
}
@Test
- @Ignore // Test broken for charsets that create multiple bytes for a single char
+ @Disabled // Test broken for charsets that create multiple bytes for a single char
public void testMarkReset_RequiredCharsets() throws Exception {
for (final String csName : getRequiredCharsetNames()) {
testMarkReset(csName);
@@ -300,9 +299,9 @@ public class CharSequenceInputStreamTest {
try (InputStream in = new CharSequenceInputStream(testString, charsetName, 512)) {
for (final byte b : bytes) {
final int read = in.read();
- assertTrue("read " + read + " >=0 ", read >= 0);
- assertTrue("read " + read + " <= 255", read <= 255);
- assertEquals("Should agree with input", b, (byte) read);
+ assertTrue(read >= 0, "read " + read + " >=0 ");
+ assertTrue(read <= 255, "read " + read + " <= 255");
+ assertEquals(b, (byte) read, "Should agree with input");
}
assertEquals(-1, in.read());
}
@@ -330,14 +329,14 @@ public class CharSequenceInputStreamTest {
try (InputStream r = new CharSequenceInputStream("test", csName)) {
assertEquals(1, r.skip(1));
assertEquals(2, r.skip(2));
- assertEquals(csName, 't', r.read());
+ assertEquals('t', r.read(), csName);
r.skip(100);
- assertEquals(csName, -1, r.read());
+ assertEquals(-1, r.read(), csName);
}
}
@Test
- @Ignore // test is broken for charsets that generate multiple bytes per char.
+ @Disabled // test is broken for charsets that generate multiple bytes per char.
public void testSkip_RequiredCharsets() throws Exception {
for (final String csName : getRequiredCharsetNames()) {
testSkip(csName);
@@ -356,7 +355,7 @@ public class CharSequenceInputStreamTest {
private int checkAvail(final InputStream is, final int min) throws Exception {
final int available = is.available();
- assertTrue("avail should be >= " + min + ", but was " + available, available >= min);
+ assertTrue(available >= min, "avail should be >= " + min + ", but was " + available);
return available;
}
diff --git a/src/test/java/org/apache/commons/io/input/CharSequenceReaderTest.java b/src/test/java/org/apache/commons/io/input/CharSequenceReaderTest.java
index a245a9b..12873c6 100644
--- a/src/test/java/org/apache/commons/io/input/CharSequenceReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/CharSequenceReaderTest.java
@@ -16,14 +16,14 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import java.io.Reader;
import java.nio.CharBuffer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Test case for {@link CharSequenceReader}.
@@ -142,14 +142,13 @@ public class CharSequenceReaderTest {
private void checkRead(final Reader reader, final String expected) throws IOException {
for (int i = 0; i < expected.length(); i++) {
- assertEquals("Read[" + i + "] of '" + expected + "'",
- expected.charAt(i), (char)reader.read());
+ assertEquals(expected.charAt(i), (char)reader.read(), "Read[" + i + "] of '" + expected + "'");
}
}
private void checkArray(final char[] expected, final char[] actual) {
for (int i = 0; i < expected.length; i++) {
- assertEquals("Compare[" +i + "]", expected[i], actual[i]);
+ assertEquals(expected[i], actual[i], "Compare[" +i + "]");
}
}
}
diff --git a/src/test/java/org/apache/commons/io/input/CharacterFilterReaderTest.java b/src/test/java/org/apache/commons/io/input/CharacterFilterReaderTest.java
index fda062d..adb9093 100644
--- a/src/test/java/org/apache/commons/io/input/CharacterFilterReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/CharacterFilterReaderTest.java
@@ -16,12 +16,13 @@
*/
package org.apache.commons.io.input;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import java.io.IOException;
import java.io.StringReader;
import java.util.HashSet;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class CharacterFilterReaderTest {
@@ -31,7 +32,7 @@ public class CharacterFilterReaderTest {
final HashSet<Integer> codePoints = new HashSet<>();
codePoints.add(Integer.valueOf('a'));
try (CharacterFilterReader reader = new CharacterFilterReader(input, 'A')) {
- Assert.assertEquals(-1, reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -39,7 +40,7 @@ public class CharacterFilterReaderTest {
public void testInputSize1FilterSize1() throws IOException {
try (StringReader input = new StringReader("a");
CharacterFilterReader reader = new CharacterFilterReader(input, 'a')) {
- Assert.assertEquals(-1, reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -47,7 +48,7 @@ public class CharacterFilterReaderTest {
public void testInputSize2FilterSize1FilterAll() throws IOException {
final StringReader input = new StringReader("aa");
try (CharacterFilterReader reader = new CharacterFilterReader(input, 'a')) {
- Assert.assertEquals(-1, reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -55,8 +56,8 @@ public class CharacterFilterReaderTest {
public void testInputSize2FilterSize1FilterFirst() throws IOException {
final StringReader input = new StringReader("ab");
try (CharacterFilterReader reader = new CharacterFilterReader(input, 'a')) {
- Assert.assertEquals('b', reader.read());
- Assert.assertEquals(-1, reader.read());
+ assertEquals('b', reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -64,8 +65,8 @@ public class CharacterFilterReaderTest {
public void testInputSize2FilterSize1FilterLast() throws IOException {
final StringReader input = new StringReader("ab");
try (CharacterFilterReader reader = new CharacterFilterReader(input, 'b')) {
- Assert.assertEquals('a', reader.read());
- Assert.assertEquals(-1, reader.read());
+ assertEquals('a', reader.read());
+ assertEquals(-1, reader.read());
}
}
diff --git a/src/test/java/org/apache/commons/io/input/CharacterSetFilterReaderTest.java b/src/test/java/org/apache/commons/io/input/CharacterSetFilterReaderTest.java
index f1a2dc0..dc92449 100644
--- a/src/test/java/org/apache/commons/io/input/CharacterSetFilterReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/CharacterSetFilterReaderTest.java
@@ -16,12 +16,13 @@
*/
package org.apache.commons.io.input;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import java.io.IOException;
import java.io.StringReader;
import java.util.HashSet;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class CharacterSetFilterReaderTest {
@@ -29,7 +30,7 @@ public class CharacterSetFilterReaderTest {
public void testInputSize0FilterSize0() throws IOException {
final StringReader input = new StringReader("");
try (CharacterSetFilterReader reader = new CharacterSetFilterReader(input, new HashSet<Integer>(0))) {
- Assert.assertEquals(-1, reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -39,7 +40,7 @@ public class CharacterSetFilterReaderTest {
final HashSet<Integer> codePoints = new HashSet<>();
codePoints.add(Integer.valueOf('a'));
try (CharacterSetFilterReader reader = new CharacterSetFilterReader(input, codePoints)) {
- Assert.assertEquals(-1, reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -47,7 +48,7 @@ public class CharacterSetFilterReaderTest {
public void testInputSize0NullFilter() throws IOException {
final StringReader input = new StringReader("");
try (CharacterSetFilterReader reader = new CharacterSetFilterReader(input, null)) {
- Assert.assertEquals(-1, reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -57,7 +58,7 @@ public class CharacterSetFilterReaderTest {
final HashSet<Integer> codePoints = new HashSet<>();
codePoints.add(Integer.valueOf('a'));
final CharacterSetFilterReader reader = new CharacterSetFilterReader(input, codePoints);
- Assert.assertEquals(-1, reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -67,7 +68,7 @@ public class CharacterSetFilterReaderTest {
final HashSet<Integer> codePoints = new HashSet<>();
codePoints.add(Integer.valueOf('a'));
try (CharacterSetFilterReader reader = new CharacterSetFilterReader(input, codePoints)) {
- Assert.assertEquals(-1, reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -77,8 +78,8 @@ public class CharacterSetFilterReaderTest {
final HashSet<Integer> codePoints = new HashSet<>();
codePoints.add(Integer.valueOf('a'));
try (CharacterSetFilterReader reader = new CharacterSetFilterReader(input, codePoints)) {
- Assert.assertEquals('b', reader.read());
- Assert.assertEquals(-1, reader.read());
+ assertEquals('b', reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -88,8 +89,8 @@ public class CharacterSetFilterReaderTest {
final HashSet<Integer> codePoints = new HashSet<>();
codePoints.add(Integer.valueOf('b'));
try (CharacterSetFilterReader reader = new CharacterSetFilterReader(input, codePoints)) {
- Assert.assertEquals('a', reader.read());
- Assert.assertEquals(-1, reader.read());
+ assertEquals('a', reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -100,8 +101,8 @@ public class CharacterSetFilterReaderTest {
codePoints.add(Integer.valueOf('a'));
codePoints.add(Integer.valueOf('y'));
try (CharacterSetFilterReader reader = new CharacterSetFilterReader(input, codePoints)) {
- Assert.assertEquals('b', reader.read());
- Assert.assertEquals(-1, reader.read());
+ assertEquals('b', reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -112,8 +113,8 @@ public class CharacterSetFilterReaderTest {
codePoints.add(Integer.valueOf('x'));
codePoints.add(Integer.valueOf('b'));
try (CharacterSetFilterReader reader = new CharacterSetFilterReader(input, codePoints)) {
- Assert.assertEquals('a', reader.read());
- Assert.assertEquals(-1, reader.read());
+ assertEquals('a', reader.read());
+ assertEquals(-1, reader.read());
}
}
@@ -124,8 +125,8 @@ public class CharacterSetFilterReaderTest {
codePoints.add(Integer.valueOf('x'));
codePoints.add(Integer.valueOf('y'));
try (CharacterSetFilterReader reader = new CharacterSetFilterReader(input, codePoints)) {
- Assert.assertEquals('a', reader.read());
- Assert.assertEquals('b', reader.read());
+ assertEquals('a', reader.read());
+ assertEquals('b', reader.read());
}
}
}
diff --git a/src/test/java/org/apache/commons/io/input/ClassLoaderObjectInputStreamTest.java b/src/test/java/org/apache/commons/io/input/ClassLoaderObjectInputStreamTest.java
index 34b93cd..115778f 100644
--- a/src/test/java/org/apache/commons/io/input/ClassLoaderObjectInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/ClassLoaderObjectInputStreamTest.java
@@ -16,9 +16,9 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+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.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@@ -39,7 +39,7 @@ public class ClassLoaderObjectInputStreamTest {
*/
- @org.junit.Test
+ @org.junit.jupiter.api.Test
public void testExpected() throws Exception {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -57,7 +57,7 @@ public class ClassLoaderObjectInputStreamTest {
}
}
- @org.junit.Test
+ @org.junit.jupiter.api.Test
public void testLong() throws Exception {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -75,7 +75,7 @@ public class ClassLoaderObjectInputStreamTest {
}
}
- @org.junit.Test
+ @org.junit.jupiter.api.Test
public void testPrimitiveLong() throws Exception {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -134,7 +134,7 @@ public class ClassLoaderObjectInputStreamTest {
}
}
- @org.junit.Test
+ @org.junit.jupiter.api.Test
public void testObject1() throws Exception {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -153,7 +153,7 @@ public class ClassLoaderObjectInputStreamTest {
}
}
- @org.junit.Test
+ @org.junit.jupiter.api.Test
public void testObject2() throws Exception {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -172,7 +172,7 @@ public class ClassLoaderObjectInputStreamTest {
}
}
- @org.junit.Test
+ @org.junit.jupiter.api.Test
public void testResolveProxyClass() throws Exception {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -184,11 +184,11 @@ public class ClassLoaderObjectInputStreamTest {
bais)) {
final String[] interfaces = new String[] { Comparable.class.getName() };
final Class<?> result = clois.resolveProxyClass(interfaces);
- assertTrue("Assignable", Comparable.class.isAssignableFrom(result));
+ assertTrue(Comparable.class.isAssignableFrom(result), "Assignable");
}
}
- @org.junit.Test
+ @org.junit.jupiter.api.Test
public void testResolveProxyClassWithMultipleInterfaces() throws Exception {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -201,10 +201,10 @@ public class ClassLoaderObjectInputStreamTest {
final String[] interfaces = new String[] { Comparable.class.getName(), Serializable.class.getName(),
Runnable.class.getName() };
final Class<?> result = clois.resolveProxyClass(interfaces);
- assertTrue("Assignable", Comparable.class.isAssignableFrom(result));
- assertTrue("Assignable", Runnable.class.isAssignableFrom(result));
- assertTrue("Assignable", Serializable.class.isAssignableFrom(result));
- assertFalse("Not Assignable", Flushable.class.isAssignableFrom(result));
+ assertTrue(Comparable.class.isAssignableFrom(result), "Assignable");
+ assertTrue(Runnable.class.isAssignableFrom(result), "Assignable");
+ assertTrue(Serializable.class.isAssignableFrom(result), "Assignable");
+ assertFalse(Flushable.class.isAssignableFrom(result), "Not Assignable");
}
}
}
diff --git a/src/test/java/org/apache/commons/io/input/CloseShieldInputStreamTest.java b/src/test/java/org/apache/commons/io/input/CloseShieldInputStreamTest.java
index 5ae4c80..62b6cda 100644
--- a/src/test/java/org/apache/commons/io/input/CloseShieldInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/CloseShieldInputStreamTest.java
@@ -16,15 +16,15 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link CloseShieldInputStream}.
@@ -39,7 +39,7 @@ public class CloseShieldInputStreamTest {
private boolean closed;
- @Before
+ @BeforeEach
public void setUp() {
data = new byte[] { 'x', 'y', 'z' };
original = new ByteArrayInputStream(data) {
@@ -55,9 +55,9 @@ public class CloseShieldInputStreamTest {
@Test
public void testClose() throws IOException {
shielded.close();
- assertFalse("closed", closed);
- assertEquals("read()", -1, shielded.read());
- assertEquals("read()", data[0], original.read());
+ assertFalse(closed, "closed");
+ assertEquals(-1, shielded.read(), "read()");
+ assertEquals(data[0], original.read(), "read()");
}
}
diff --git a/src/test/java/org/apache/commons/io/input/CloseShieldReaderTest.java b/src/test/java/org/apache/commons/io/input/CloseShieldReaderTest.java
index b609df9..dfc54ca 100644
--- a/src/test/java/org/apache/commons/io/input/CloseShieldReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/CloseShieldReaderTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
@@ -24,8 +24,8 @@ import static org.mockito.Mockito.verify;
import java.io.IOException;
import java.io.Reader;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link CloseShieldReader}.
@@ -38,7 +38,7 @@ public class CloseShieldReaderTest {
private Reader shielded;
- @Before
+ @BeforeEach
public void setUp() {
data = "xyz";
original = spy(new CharSequenceReader(data));
@@ -50,8 +50,8 @@ public class CloseShieldReaderTest {
shielded.close();
verify(original, never()).close();
final char[] cbuf = new char[10];
- assertEquals("read(cbuf, off, len)", -1, shielded.read(cbuf, 0, 10));
- assertEquals("read(cbuf, off, len)", data.length(), original.read(cbuf, 0, 10));
+ assertEquals(-1, shielded.read(cbuf, 0, 10), "read(cbuf, off, len)");
+ assertEquals(data.length(), original.read(cbuf, 0, 10), "read(cbuf, off, len)");
assertEquals(data, new String(cbuf, 0, data.length()));
}
diff --git a/src/test/java/org/apache/commons/io/input/ClosedInputStreamTest.java b/src/test/java/org/apache/commons/io/input/ClosedInputStreamTest.java
index 04ec66f..11dc38a 100644
--- a/src/test/java/org/apache/commons/io/input/ClosedInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/ClosedInputStreamTest.java
@@ -16,9 +16,9 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link ClosedInputStream}.
@@ -28,7 +28,7 @@ public class ClosedInputStreamTest {
@Test
public void testRead() throws Exception {
try (final ClosedInputStream cis = new ClosedInputStream()) {
- assertEquals("read()", -1, cis.read());
+ assertEquals(-1, cis.read(), "read()");
}
}
diff --git a/src/test/java/org/apache/commons/io/input/ClosedReaderTest.java b/src/test/java/org/apache/commons/io/input/ClosedReaderTest.java
index 75f8112..0faad8d 100644
--- a/src/test/java/org/apache/commons/io/input/ClosedReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/ClosedReaderTest.java
@@ -16,9 +16,9 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link ClosedReader}.
@@ -28,7 +28,7 @@ public class ClosedReaderTest {
@Test
public void testRead() throws Exception {
try (final ClosedReader cr = new ClosedReader()) {
- assertEquals("read(cbuf, off, len)", -1, cr.read(new char[10], 0, 10));
+ assertEquals(-1, cr.read(new char[10], 0, 10), "read(cbuf, off, len)");
}
}
diff --git a/src/test/java/org/apache/commons/io/input/CountingInputStreamTest.java b/src/test/java/org/apache/commons/io/input/CountingInputStreamTest.java
index 0bc4c92..31a4072 100644
--- a/src/test/java/org/apache/commons/io/input/CountingInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/CountingInputStreamTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.ByteArrayInputStream;
import java.io.IOException;
@@ -25,7 +25,7 @@ import java.io.OutputStream;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.output.NullOutputStream;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Tests the CountingInputStream.
@@ -97,8 +97,8 @@ public class CountingInputStreamTest {
// Test long methods
IOUtils.copyLarge(cis, out);
- assertEquals("getByteCount()", size, cis.getByteCount());
- assertEquals("resetByteCount()", size, cis.resetByteCount());
+ assertEquals(size, cis.getByteCount(), "getByteCount()");
+ assertEquals(size, cis.resetByteCount(), "resetByteCount()");
}
@Test
diff --git a/src/test/java/org/apache/commons/io/input/InfiniteCircularInputStreamTest.java b/src/test/java/org/apache/commons/io/input/InfiniteCircularInputStreamTest.java
index cd5828b..0e034a3 100644
--- a/src/test/java/org/apache/commons/io/input/InfiniteCircularInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/InfiniteCircularInputStreamTest.java
@@ -16,12 +16,14 @@
*/
package org.apache.commons.io.input;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class InfiniteCircularInputStreamTest {
@@ -53,8 +55,8 @@ public class InfiniteCircularInputStreamTest {
try (InputStream infStream = new InfiniteCircularInputStream(toCycle)) {
final int actualReadBytes = infStream.read(actual);
- Assert.assertArrayEquals(expected, actual);
- Assert.assertEquals(expected.length, actualReadBytes);
+ assertArrayEquals(expected, actual);
+ assertEquals(expected.length, actualReadBytes);
}
}
diff --git a/src/test/java/org/apache/commons/io/input/MessageDigestCalculatingInputStreamTest.java b/src/test/java/org/apache/commons/io/input/MessageDigestCalculatingInputStreamTest.java
index 7d5b7ce..2be1ccb 100644
--- a/src/test/java/org/apache/commons/io/input/MessageDigestCalculatingInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/MessageDigestCalculatingInputStreamTest.java
@@ -16,13 +16,13 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import java.io.ByteArrayInputStream;
import java.security.MessageDigest;
import java.util.Random;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class MessageDigestCalculatingInputStreamTest {
public static byte[] generateRandomByteStream(final int pSize) {
diff --git a/src/test/java/org/apache/commons/io/input/NullInputStreamTest.java b/src/test/java/org/apache/commons/io/input/NullInputStreamTest.java
index 5377264..eaca82b 100644
--- a/src/test/java/org/apache/commons/io/input/NullInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/NullInputStreamTest.java
@@ -16,16 +16,16 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link NullInputStream}.
@@ -38,14 +38,14 @@ public class NullInputStreamTest {
final int size = 5;
final InputStream input = new TestNullInputStream(size);
for (int i = 0; i < size; i++) {
- assertEquals("Check Size [" + i + "]", size - i, input.available());
- assertEquals("Check Value [" + i + "]", i, input.read());
+ assertEquals(size - i, input.available(), "Check Size [" + i + "]");
+ assertEquals(i, input.read(), "Check Value [" + i + "]");
}
- assertEquals("Available after contents all read", 0, input.available());
+ assertEquals(0, input.available(), "Available after contents all read");
// Check availbale is zero after End of file
- assertEquals("End of File", -1, input.read());
- assertEquals("Available after End of File", 0, input.available());
+ assertEquals(-1, input.read(), "End of File");
+ assertEquals(0, input.available(), "Available after End of File");
// Test reading after the end of file
try {
@@ -57,7 +57,7 @@ public class NullInputStreamTest {
// Close - should reset
input.close();
- assertEquals("Available after close", size, input.available());
+ assertEquals(size, input.available(), "Available after close");
}
@Test
@@ -67,21 +67,21 @@ public class NullInputStreamTest {
// Read into array
final int count1 = input.read(bytes);
- assertEquals("Read 1", bytes.length, count1);
+ assertEquals(bytes.length, count1, "Read 1");
for (int i = 0; i < count1; i++) {
- assertEquals("Check Bytes 1", i, bytes[i]);
+ assertEquals(i, bytes[i], "Check Bytes 1");
}
// Read into array
final int count2 = input.read(bytes);
- assertEquals("Read 2", 5, count2);
+ assertEquals(5, count2, "Read 2");
for (int i = 0; i < count2; i++) {
- assertEquals("Check Bytes 2", count1 + i, bytes[i]);
+ assertEquals(count1 + i, bytes[i], "Check Bytes 2");
}
// End of File
final int count3 = input.read(bytes);
- assertEquals("Read 3 (EOF)", -1, count3);
+ assertEquals(-1, count3, "Read 3 (EOF)");
// Test reading after the end of file
try {
@@ -98,17 +98,17 @@ public class NullInputStreamTest {
final int offset = 2;
final int lth = 4;
final int count5 = input.read(bytes, offset, lth);
- assertEquals("Read 5", lth, count5);
+ assertEquals(lth, count5, "Read 5");
for (int i = offset; i < lth; i++) {
- assertEquals("Check Bytes 2", i, bytes[i]);
+ assertEquals(i, bytes[i], "Check Bytes 2");
}
}
@Test
public void testEOFException() throws Exception {
final InputStream input = new TestNullInputStream(2, false, true);
- assertEquals("Read 1", 0, input.read());
- assertEquals("Read 2", 1, input.read());
+ assertEquals(0, input.read(), "Read 1");
+ assertEquals(1, input.read(), "Read 2");
try {
final int result = input.read();
fail("Should have thrown an EOFException, byte=[" + result + "]");
@@ -124,20 +124,18 @@ public class NullInputStreamTest {
final int readlimit = 10;
final InputStream input = new TestNullInputStream(100, true, false);
- assertTrue("Mark Should be Supported", input.markSupported());
+ assertTrue(input.markSupported(), "Mark Should be Supported");
// No Mark
try {
input.reset();
fail("Read limit exceeded, expected IOException ");
} catch (final IOException e) {
- assertEquals("No Mark IOException message",
- "No position has been marked",
- e.getMessage());
+ assertEquals("No position has been marked", e.getMessage(), "No Mark IOException message");
}
for (; position < 3; position++) {
- assertEquals("Read Before Mark [" + position +"]", position, input.read());
+ assertEquals(position, input.read(), "Read Before Mark [" + position +"]");
}
// Mark
@@ -145,7 +143,7 @@ public class NullInputStreamTest {
// Read further
for (int i = 0; i < 3; i++) {
- assertEquals("Read After Mark [" + i +"]", position + i, input.read());
+ assertEquals(position + i, input.read(), "Read After Mark [" + i +"]");
}
// Reset
@@ -153,7 +151,7 @@ public class NullInputStreamTest {
// Read From marked position
for (int i = 0; i < readlimit + 1; i++) {
- assertEquals("Read After Reset [" + i +"]", position + i, input.read());
+ assertEquals(position + i, input.read(), "Read After Reset [" + i +"]");
}
// Reset after read limit passed
@@ -161,11 +159,11 @@ public class NullInputStreamTest {
input.reset();
fail("Read limit exceeded, expected IOException ");
} catch (final IOException e) {
- assertEquals("Read limit IOException message",
- "Marked position [" + position
+ assertEquals("Marked position [" + position
+ "] is no longer valid - passed the read limit ["
+ readlimit + "]",
- e.getMessage());
+ e.getMessage(),
+ "Read limit IOException message");
}
input.close();
}
@@ -173,20 +171,20 @@ public class NullInputStreamTest {
@Test
public void testMarkNotSupported() throws Exception {
final InputStream input = new TestNullInputStream(100, false, true);
- assertFalse("Mark Should NOT be Supported", input.markSupported());
+ assertFalse(input.markSupported(), "Mark Should NOT be Supported");
try {
input.mark(5);
fail("mark() should throw UnsupportedOperationException");
} catch (final UnsupportedOperationException e) {
- assertEquals("mark() error message", "Mark not supported", e.getMessage());
+ assertEquals("Mark not supported", e.getMessage(), "mark() error message");
}
try {
input.reset();
fail("reset() should throw UnsupportedOperationException");
} catch (final UnsupportedOperationException e) {
- assertEquals("reset() error message", "Mark not supported", e.getMessage());
+ assertEquals("Mark not supported", e.getMessage(), "reset() error message");
}
input.close();
}
@@ -194,19 +192,17 @@ public class NullInputStreamTest {
@Test
public void testSkip() throws Exception {
final InputStream input = new TestNullInputStream(10, true, false);
- assertEquals("Read 1", 0, input.read());
- assertEquals("Read 2", 1, input.read());
- assertEquals("Skip 1", 5, input.skip(5));
- assertEquals("Read 3", 7, input.read());
- assertEquals("Skip 2", 2, input.skip(5)); // only 2 left to skip
- assertEquals("Skip 3 (EOF)", -1, input.skip(5)); // End of file
+ assertEquals(0, input.read(), "Read 1");
+ assertEquals(1, input.read(), "Read 2");
+ assertEquals(5, input.skip(5), "Skip 1");
+ assertEquals(7, input.read(), "Read 3");
+ assertEquals(2, input.skip(5), "Skip 2"); // only 2 left to skip
+ assertEquals(-1, input.skip(5), "Skip 3 (EOF)"); // End of file
try {
input.skip(5); //
fail("Expected IOException for skipping after end of file");
} catch (final IOException e) {
- assertEquals("Skip after EOF IOException message",
- "Skip after end of file",
- e.getMessage());
+ assertEquals("Skip after end of file", e.getMessage(), "Skip after EOF IOException message");
}
input.close();
}
diff --git a/src/test/java/org/apache/commons/io/input/NullReaderTest.java b/src/test/java/org/apache/commons/io/input/NullReaderTest.java
index af15b5f..e0bd0d7 100644
--- a/src/test/java/org/apache/commons/io/input/NullReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/NullReaderTest.java
@@ -16,16 +16,16 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.EOFException;
import java.io.IOException;
import java.io.Reader;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link NullReader}.
@@ -38,11 +38,11 @@ public class NullReaderTest {
final int size = 5;
final TestNullReader reader = new TestNullReader(size);
for (int i = 0; i < size; i++) {
- assertEquals("Check Value [" + i + "]", i, reader.read());
+ assertEquals(i, reader.read(), "Check Value [" + i + "]");
}
// Check End of File
- assertEquals("End of File", -1, reader.read());
+ assertEquals(-1, reader.read(), "End of File");
// Test reading after the end of file
try {
@@ -54,7 +54,7 @@ public class NullReaderTest {
// Close - should reset
reader.close();
- assertEquals("Available after close", 0, reader.getPosition());
+ assertEquals(0, reader.getPosition(), "Available after close");
}
@Test
@@ -64,21 +64,21 @@ public class NullReaderTest {
// Read into array
final int count1 = reader.read(chars);
- assertEquals("Read 1", chars.length, count1);
+ assertEquals(chars.length, count1, "Read 1");
for (int i = 0; i < count1; i++) {
- assertEquals("Check Chars 1", i, chars[i]);
+ assertEquals(i, chars[i], "Check Chars 1");
}
// Read into array
final int count2 = reader.read(chars);
- assertEquals("Read 2", 5, count2);
+ assertEquals(5, count2, "Read 2");
for (int i = 0; i < count2; i++) {
- assertEquals("Check Chars 2", count1 + i, chars[i]);
+ assertEquals(count1 + i, chars[i], "Check Chars 2");
}
// End of File
final int count3 = reader.read(chars);
- assertEquals("Read 3 (EOF)", -1, count3);
+ assertEquals(-1, count3, "Read 3 (EOF)");
// Test reading after the end of file
try {
@@ -95,17 +95,17 @@ public class NullReaderTest {
final int offset = 2;
final int lth = 4;
final int count5 = reader.read(chars, offset, lth);
- assertEquals("Read 5", lth, count5);
+ assertEquals(lth, count5, "Read 5");
for (int i = offset; i < lth; i++) {
- assertEquals("Check Chars 3", i, chars[i]);
+ assertEquals(i, chars[i], "Check Chars 3");
}
}
@Test
public void testEOFException() throws Exception {
final Reader reader = new TestNullReader(2, false, true);
- assertEquals("Read 1", 0, reader.read());
- assertEquals("Read 2", 1, reader.read());
+ assertEquals(0, reader.read(), "Read 1");
+ assertEquals(1, reader.read(), "Read 2");
try {
final int result = reader.read();
fail("Should have thrown an EOFException, value=[" + result + "]");
@@ -121,20 +121,18 @@ public class NullReaderTest {
final int readlimit = 10;
final Reader reader = new TestNullReader(100, true, false);
- assertTrue("Mark Should be Supported", reader.markSupported());
+ assertTrue(reader.markSupported(), "Mark Should be Supported");
// No Mark
try {
reader.reset();
fail("Read limit exceeded, expected IOException ");
} catch (final IOException e) {
- assertEquals("No Mark IOException message",
- "No position has been marked",
- e.getMessage());
+ assertEquals("No position has been marked", e.getMessage(), "No Mark IOException message");
}
for (; position < 3; position++) {
- assertEquals("Read Before Mark [" + position +"]", position, reader.read());
+ assertEquals(position, reader.read(), "Read Before Mark [" + position +"]");
}
// Mark
@@ -142,7 +140,7 @@ public class NullReaderTest {
// Read further
for (int i = 0; i < 3; i++) {
- assertEquals("Read After Mark [" + i +"]", position + i, reader.read());
+ assertEquals(position + i, reader.read(), "Read After Mark [" + i +"]");
}
// Reset
@@ -150,7 +148,7 @@ public class NullReaderTest {
// Read From marked position
for (int i = 0; i < readlimit + 1; i++) {
- assertEquals("Read After Reset [" + i +"]", position + i, reader.read());
+ assertEquals(position + i, reader.read(), "Read After Reset [" + i +"]");
}
// Reset after read limit passed
@@ -158,11 +156,11 @@ public class NullReaderTest {
reader.reset();
fail("Read limit exceeded, expected IOException ");
} catch (final IOException e) {
- assertEquals("Read limit IOException message",
- "Marked position [" + position
+ assertEquals("Marked position [" + position
+ "] is no longer valid - passed the read limit ["
+ readlimit + "]",
- e.getMessage());
+ e.getMessage(),
+ "Read limit IOException message");
}
reader.close();
}
@@ -170,20 +168,20 @@ public class NullReaderTest {
@Test
public void testMarkNotSupported() throws Exception {
final Reader reader = new TestNullReader(100, false, true);
- assertFalse("Mark Should NOT be Supported", reader.markSupported());
+ assertFalse(reader.markSupported(), "Mark Should NOT be Supported");
try {
reader.mark(5);
fail("mark() should throw UnsupportedOperationException");
} catch (final UnsupportedOperationException e) {
- assertEquals("mark() error message", "Mark not supported", e.getMessage());
+ assertEquals("Mark not supported", e.getMessage(), "mark() error message");
}
try {
reader.reset();
fail("reset() should throw UnsupportedOperationException");
} catch (final UnsupportedOperationException e) {
- assertEquals("reset() error message", "Mark not supported", e.getMessage());
+ assertEquals("Mark not supported", e.getMessage(), "reset() error message");
}
reader.close();
}
@@ -191,19 +189,18 @@ public class NullReaderTest {
@Test
public void testSkip() throws Exception {
final Reader reader = new TestNullReader(10, true, false);
- assertEquals("Read 1", 0, reader.read());
- assertEquals("Read 2", 1, reader.read());
- assertEquals("Skip 1", 5, reader.skip(5));
- assertEquals("Read 3", 7, reader.read());
- assertEquals("Skip 2", 2, reader.skip(5)); // only 2 left to skip
- assertEquals("Skip 3 (EOF)", -1, reader.skip(5)); // End of file
+ assertEquals(0, reader.read(), "Read 1");
+ assertEquals(1, reader.read(), "Read 2");
+ assertEquals(5, reader.skip(5), "Skip 1");
+ assertEquals(7, reader.read(), "Read 3");
+ assertEquals(2, reader.skip(5), "Skip 2"); // only 2 left to skip
+ assertEquals(-1, reader.skip(5), "Skip 3 (EOF)"); // End of file
try {
reader.skip(5); //
fail("Expected IOException for skipping after end of file");
} catch (final IOException e) {
- assertEquals("Skip after EOF IOException message",
- "Skip after end of file",
- e.getMessage());
+ assertEquals("Skip after end of file", e.getMessage(),
+ "Skip after EOF IOException message");
}
reader.close();
}
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 7827bea..d792ba9 100644
--- a/src/test/java/org/apache/commons/io/input/ObservableInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/ObservableInputStreamTest.java
@@ -16,15 +16,15 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+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.ByteArrayInputStream;
import java.io.IOException;
import org.apache.commons.io.input.ObservableInputStream.Observer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class ObservableInputStreamTest {
private static class LastByteKeepingObserver extends Observer {
diff --git a/src/test/java/org/apache/commons/io/input/ProxyReaderTest.java b/src/test/java/org/apache/commons/io/input/ProxyReaderTest.java
index c62c6eb..fdaea8f 100644
--- a/src/test/java/org/apache/commons/io/input/ProxyReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/ProxyReaderTest.java
@@ -20,7 +20,7 @@ import java.io.IOException;
import java.io.Reader;
import java.nio.CharBuffer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* Test {@link ProxyReader}.
diff --git a/src/test/java/org/apache/commons/io/input/ReaderInputStreamTest.java b/src/test/java/org/apache/commons/io/input/ReaderInputStreamTest.java
index c7295a5..33fbc8c 100644
--- a/src/test/java/org/apache/commons/io/input/ReaderInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/ReaderInputStreamTest.java
@@ -16,8 +16,8 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.CharArrayReader;
import java.io.IOException;
@@ -25,7 +25,7 @@ import java.io.StringReader;
import java.nio.charset.Charset;
import java.util.Random;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class ReaderInputStreamTest {
private static final String TEST_STRING = "\u00e0 peine arriv\u00e9s nous entr\u00e2mes dans sa chambre";
diff --git a/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestParamBlockSize.java b/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestParamBlockSize.java
index 4db33fd..963674a 100644
--- a/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestParamBlockSize.java
+++ b/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestParamBlockSize.java
@@ -16,42 +16,35 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
+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 java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
-import java.util.Arrays;
-import java.util.Collection;
+import java.util.stream.IntStream;
-import org.junit.After;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
-@RunWith(Parameterized.class)
public class ReversedLinesFileReaderTestParamBlockSize {
private static final String UTF_8 = "UTF-8";
private static final String ISO_8859_1 = "ISO-8859-1";
- @SuppressWarnings("boxing")
+ private static final int[] BLOCK_SIZES = {1, 3, 8, 256, 4096};
+
// small and uneven block sizes are not used in reality but are good to show that the algorithm is solid
- @Parameters(name = "BlockSize={0}")
- public static Collection<Integer[]> blockSizes() {
- return Arrays.asList(new Integer[][]{{1}, {3}, {8}, {256}, {4096}});
+ public static IntStream blockSizes() {
+ return IntStream.of(1, 3, 8, 256, 4096);
}
private ReversedLinesFileReader reversedLinesFileReader;
- private final int testParamBlockSize;
-
- public ReversedLinesFileReaderTestParamBlockSize(final Integer testWithBlockSize) {
- testParamBlockSize = testWithBlockSize;
- }
// Strings are escaped in constants to avoid java source encoding issues (source file enc is UTF-8):
@@ -75,7 +68,7 @@ public class ReversedLinesFileReaderTestParamBlockSize {
private static final String TEST_LINE_X_WINDOWS_950_2 = "\u7E41\u9AD4\u4E2D\u6587";
- @After
+ @AfterEach
public void closeReader() {
try {
reversedLinesFileReader.close();
@@ -84,96 +77,108 @@ public class ReversedLinesFileReaderTestParamBlockSize {
}
}
- @Test
- public void testIsoFileDefaults() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testIsoFileDefaults(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileIso = new File(this.getClass().getResource("/test-file-iso8859-1.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileIso, testParamBlockSize, ISO_8859_1);
assertFileWithShrinkingTestLines(reversedLinesFileReader);
}
- @Test
- public void testUTF8FileWindowsBreaks() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testUTF8FileWindowsBreaks(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileIso = new File(this.getClass().getResource("/test-file-utf8-win-linebr.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileIso, testParamBlockSize, UTF_8);
assertFileWithShrinkingTestLines(reversedLinesFileReader);
}
- @Test
- public void testUTF8FileCRBreaks() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testUTF8FileCRBreaks(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileIso = new File(this.getClass().getResource("/test-file-utf8-cr-only.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileIso, testParamBlockSize, UTF_8);
assertFileWithShrinkingTestLines(reversedLinesFileReader);
}
- @Test
- public void testUTF8File() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testUTF8File(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileIso = new File(this.getClass().getResource("/test-file-utf8.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileIso, testParamBlockSize, UTF_8);
assertFileWithShrinkingTestLines(reversedLinesFileReader);
}
- @Test
- public void testEmptyFile() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testEmptyFile(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileEmpty = new File(this.getClass().getResource("/test-file-empty.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileEmpty, testParamBlockSize, UTF_8);
assertNull(reversedLinesFileReader.readLine());
}
- @Test
- public void testUTF16BEFile() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testUTF16BEFile(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileUTF16BE = new File(this.getClass().getResource("/test-file-utf16be.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileUTF16BE, testParamBlockSize, "UTF-16BE");
assertFileWithShrinkingTestLines(reversedLinesFileReader);
}
- @Test
- public void testUTF16LEFile() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testUTF16LEFile(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileUTF16LE = new File(this.getClass().getResource("/test-file-utf16le.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileUTF16LE, testParamBlockSize, "UTF-16LE");
assertFileWithShrinkingTestLines(reversedLinesFileReader);
}
- @Test
- public void testShiftJISFile() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testShiftJISFile(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileShiftJIS = new File(this.getClass().getResource("/test-file-shiftjis.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileShiftJIS, testParamBlockSize, "Shift_JIS");
assertEqualsAndNoLineBreaks(TEST_LINE_SHIFT_JIS2, reversedLinesFileReader.readLine());
assertEqualsAndNoLineBreaks(TEST_LINE_SHIFT_JIS1, reversedLinesFileReader.readLine());
}
- @Test
- public void testWindows31jFile() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testWindows31jFile(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileWindows31J = new File(this.getClass().getResource("/test-file-windows-31j.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileWindows31J, testParamBlockSize, "windows-31j");
assertEqualsAndNoLineBreaks(TEST_LINE_WINDOWS_31J_2, reversedLinesFileReader.readLine());
assertEqualsAndNoLineBreaks(TEST_LINE_WINDOWS_31J_1, reversedLinesFileReader.readLine());
}
- @Test
- public void testGBK() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testGBK(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileGBK = new File(this.getClass().getResource("/test-file-gbk.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileGBK, testParamBlockSize, "GBK");
assertEqualsAndNoLineBreaks(TEST_LINE_GBK_2, reversedLinesFileReader.readLine());
assertEqualsAndNoLineBreaks(TEST_LINE_GBK_1, reversedLinesFileReader.readLine());
}
- @Test
- public void testxWindows949File() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testxWindows949File(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFilexWindows949 = new File(this.getClass().getResource("/test-file-x-windows-949.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFilexWindows949, testParamBlockSize, "x-windows-949");
assertEqualsAndNoLineBreaks(TEST_LINE_X_WINDOWS_949_2, reversedLinesFileReader.readLine());
assertEqualsAndNoLineBreaks(TEST_LINE_X_WINDOWS_949_1, reversedLinesFileReader.readLine());
}
- @Test
- public void testxWindows950File() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testxWindows950File(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFilexWindows950 = new File(this.getClass().getResource("/test-file-x-windows-950.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFilexWindows950, testParamBlockSize, "x-windows-950");
assertEqualsAndNoLineBreaks(TEST_LINE_X_WINDOWS_950_2, reversedLinesFileReader.readLine());
assertEqualsAndNoLineBreaks(TEST_LINE_X_WINDOWS_950_1, reversedLinesFileReader.readLine());
}
- @Test // this test is run 3x for same block size as we want to test with 10
+ @Test
public void testFileSizeIsExactMultipleOfBlockSize() throws URISyntaxException, IOException {
final int blockSize = 10;
final File testFile20Bytes = new File(this.getClass().getResource("/test-file-20byteslength.bin").toURI());
@@ -183,15 +188,17 @@ public class ReversedLinesFileReaderTestParamBlockSize {
assertEqualsAndNoLineBreaks(testLine, reversedLinesFileReader.readLine());
}
- @Test
- public void testUTF8FileWindowsBreaksSmallBlockSize2VerifyBlockSpanningNewLines() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testUTF8FileWindowsBreaksSmallBlockSize2VerifyBlockSpanningNewLines(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileUtf8 = new File(this.getClass().getResource("/test-file-utf8-win-linebr.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileUtf8, testParamBlockSize, UTF_8);
assertFileWithShrinkingTestLines(reversedLinesFileReader);
}
- @Test
- public void testIsoFileManyWindowsBreaksSmallBlockSize2VerifyBlockSpanningNewLines() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testIsoFileManyWindowsBreaksSmallBlockSize2VerifyBlockSpanningNewLines(int testParamBlockSize) throws URISyntaxException, IOException {
final File testFileIso = new File(this.getClass().getResource("/test-file-iso8859-1-shortlines-win-linebr.bin").toURI());
reversedLinesFileReader = new ReversedLinesFileReader(testFileIso, testParamBlockSize, ISO_8859_1);
@@ -203,16 +210,20 @@ public class ReversedLinesFileReaderTestParamBlockSize {
}
}
- @Test(expected = UnsupportedEncodingException.class)
- public void testUnsupportedEncodingUTF16() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testUnsupportedEncodingUTF16(int testParamBlockSize) throws URISyntaxException {
final File testFileEmpty = new File(this.getClass().getResource("/test-file-empty.bin").toURI());
- new ReversedLinesFileReader(testFileEmpty, testParamBlockSize, "UTF-16").close();
+ assertThrows(UnsupportedEncodingException.class,
+ () -> new ReversedLinesFileReader(testFileEmpty, testParamBlockSize, "UTF-16").close());
}
- @Test(expected = UnsupportedEncodingException.class)
- public void testUnsupportedEncodingBig5() throws URISyntaxException, IOException {
+ @ParameterizedTest(name = "BlockSize={0}")
+ @MethodSource("blockSizes")
+ public void testUnsupportedEncodingBig5(int testParamBlockSize) throws URISyntaxException {
final File testFileEncodingBig5 = new File(this.getClass().getResource("/test-file-empty.bin").toURI());
- new ReversedLinesFileReader(testFileEncodingBig5, testParamBlockSize, "Big5").close();
+ assertThrows(UnsupportedEncodingException.class,
+ () -> new ReversedLinesFileReader(testFileEncodingBig5, testParamBlockSize, "Big5").close());
}
private void assertFileWithShrinkingTestLines(final ReversedLinesFileReader reversedLinesFileReader) throws IOException {
@@ -226,10 +237,10 @@ public class ReversedLinesFileReaderTestParamBlockSize {
static void assertEqualsAndNoLineBreaks(final String msg, final String expected, final String actual) {
if (actual != null) {
- assertFalse("Line contains \\n: line=" + actual, actual.contains("\n"));
- assertFalse("Line contains \\r: line=" + actual, actual.contains("\r"));
+ assertFalse(actual.contains("\n"), "Line contains \\n: line=" + actual);
+ assertFalse(actual.contains("\r"), "Line contains \\r: line=" + actual);
}
- assertEquals(msg, expected, actual);
+ assertEquals(expected, actual, msg);
}
static void assertEqualsAndNoLineBreaks(final String expected, final String actual) {
diff --git a/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestParamFile.java b/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestParamFile.java
index 72a2a5b..3aa017d 100644
--- a/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestParamFile.java
+++ b/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestParamFile.java
@@ -16,120 +16,86 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.BufferedReader;
import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.nio.file.*;
-import java.util.Arrays;
-import java.util.Collection;
import java.util.Stack;
+import java.util.stream.Stream;
import com.google.common.jimfs.Configuration;
import com.google.common.jimfs.Jimfs;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
/**
* Test checks symmetric behaviour with BufferedReader
*/
-@RunWith(Parameterized.class)
public class ReversedLinesFileReaderTestParamFile {
- @Parameters(name = "{0}, encoding={1}, blockSize={2}, useNonDefaultFileSystem={3}")
- public static Collection<Object[]> parameters() {
- return Arrays.asList(new Object[][]{
- {"test-file-20byteslength.bin", "ISO_8859_1", null, false},
- {"test-file-iso8859-1-shortlines-win-linebr.bin", "ISO_8859_1", null, false},
- {"test-file-iso8859-1.bin", "ISO_8859_1", null, false},
- {"test-file-shiftjis.bin", "Shift_JIS", null, false},
- {"test-file-utf16be.bin", "UTF-16BE", null, false},
- {"test-file-utf16le.bin", "UTF-16LE", null, false},
- {"test-file-utf8-cr-only.bin", "UTF-8", null, false},
- {"test-file-utf8-win-linebr.bin", "UTF-8", null, false},
- {"test-file-utf8-win-linebr.bin", "UTF-8", 1, false},
- {"test-file-utf8-win-linebr.bin", "UTF-8", 2, false},
- {"test-file-utf8-win-linebr.bin", "UTF-8", 3, false},
- {"test-file-utf8-win-linebr.bin", "UTF-8", 4, false},
- {"test-file-utf8.bin", "UTF-8", null, false},
- {"test-file-utf8.bin", "UTF-8", null, true},
- {"test-file-windows-31j.bin", "windows-31j", null, false},
- {"test-file-gbk.bin", "gbk", null, false},
- {"test-file-x-windows-949.bin", "x-windows-949", null, false},
- {"test-file-x-windows-950.bin", "x-windows-950", null, false},
- });
+ public static Stream<Arguments> testDataIntegrityWithBufferedReader() {
+ return Stream.of(
+ Arguments.of("test-file-20byteslength.bin", "ISO_8859_1", null, false),
+ Arguments.of("test-file-iso8859-1-shortlines-win-linebr.bin", "ISO_8859_1", null, false),
+ Arguments.of("test-file-iso8859-1.bin", "ISO_8859_1", null, false),
+ Arguments.of("test-file-shiftjis.bin", "Shift_JIS", null, false),
+ Arguments.of("test-file-utf16be.bin", "UTF-16BE", null, false),
+ Arguments.of("test-file-utf16le.bin", "UTF-16LE", null, false),
+ Arguments.of("test-file-utf8-cr-only.bin", "UTF-8", null, false),
+ Arguments.of("test-file-utf8-win-linebr.bin", "UTF-8", null, false),
+ Arguments.of("test-file-utf8-win-linebr.bin", "UTF-8", 1, false),
+ Arguments.of("test-file-utf8-win-linebr.bin", "UTF-8", 2, false),
+ Arguments.of("test-file-utf8-win-linebr.bin", "UTF-8", 3, false),
+ Arguments.of("test-file-utf8-win-linebr.bin", "UTF-8", 4, false),
+ Arguments.of("test-file-utf8.bin", "UTF-8", null, false),
+ Arguments.of("test-file-utf8.bin", "UTF-8", null, true),
+ Arguments.of("test-file-windows-31j.bin", "windows-31j", null, false),
+ Arguments.of("test-file-gbk.bin", "gbk", null, false),
+ Arguments.of("test-file-x-windows-949.bin", "x-windows-949", null, false),
+ Arguments.of("test-file-x-windows-950.bin", "x-windows-950", null, false)
+ );
}
- private Path file;
- private FileSystem fileSystem;
- private ReversedLinesFileReader reversedLinesFileReader;
- private BufferedReader bufferedReader;
+ @ParameterizedTest(name = "{0}, encoding={1}, blockSize={2}, useNonDefaultFileSystem={3}")
+ @MethodSource
+ public void testDataIntegrityWithBufferedReader
+ (final String fileName, final String encodingName, final Integer blockSize, final boolean useNonDefaultFileSystem)
+ throws IOException, URISyntaxException {
- private final String fileName;
- private final Charset encoding;
- private final Integer blockSize;
- private final boolean useNonDefaultFileSystem;
-
- public ReversedLinesFileReaderTestParamFile(final String fileName, final String encoding, final Integer blockSize, final boolean useNonDefaultFileSystem) {
- this.fileName = fileName;
- this.encoding = Charset.forName(encoding);
- this.blockSize = blockSize;
- this.useNonDefaultFileSystem = useNonDefaultFileSystem;
- }
-
- @Before
- public void prepareFile() throws URISyntaxException, IOException {
- file = Paths.get(getClass().getResource("/" + fileName).toURI());
+ Path file = Paths.get(getClass().getResource("/" + fileName).toURI());
+ FileSystem fileSystem = null;
if (useNonDefaultFileSystem) {
fileSystem = Jimfs.newFileSystem(Configuration.unix());
file = Files.copy(file, fileSystem.getPath("/" + fileName));
}
- }
- @Test
- public void testDataIntegrityWithBufferedReader() throws IOException {
- reversedLinesFileReader = blockSize == null
+ Charset encoding = Charset.forName(encodingName);
+ try (ReversedLinesFileReader reversedLinesFileReader = blockSize == null
? new ReversedLinesFileReader(file, encoding)
- : new ReversedLinesFileReader(file, blockSize, encoding);
-
- final Stack<String> lineStack = new Stack<>();
+ : new ReversedLinesFileReader(file, blockSize, encoding)) {
- bufferedReader = Files.newBufferedReader(file, encoding);
- String line;
+ final Stack<String> lineStack = new Stack<>();
+ String line;
- // read all lines in normal order
- while ((line = bufferedReader.readLine()) != null) {
- lineStack.push(line);
- }
+ try (BufferedReader bufferedReader = Files.newBufferedReader(file, encoding)) {
+ // read all lines in normal order
+ while ((line = bufferedReader.readLine()) != null) {
+ lineStack.push(line);
+ }
+ }
- // read in reverse order and compare with lines from stack
- while ((line = reversedLinesFileReader.readLine()) != null) {
- final String lineFromBufferedReader = lineStack.pop();
- assertEquals(lineFromBufferedReader, line);
- }
- }
+ // read in reverse order and compare with lines from stack
+ while ((line = reversedLinesFileReader.readLine()) != null) {
+ final String lineFromBufferedReader = lineStack.pop();
+ assertEquals(lineFromBufferedReader, line);
+ }
- @After
- public void releaseResources() {
- try {
- bufferedReader.close();
- } catch (final Exception e) {
- // ignore
- }
- try {
- reversedLinesFileReader.close();
- } catch (final Exception e) {
- // ignore
- }
- try {
- fileSystem.close();
- } catch (final Exception e) {
- // ignore
+ if (fileSystem != null) {
+ fileSystem.close();
+ }
}
}
}
diff --git a/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestSimple.java b/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestSimple.java
index 1ee222c..8c1a62c 100644
--- a/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestSimple.java
+++ b/src/test/java/org/apache/commons/io/input/ReversedLinesFileReaderTestSimple.java
@@ -17,21 +17,22 @@
package org.apache.commons.io.input;
import static org.apache.commons.io.input.ReversedLinesFileReaderTestParamBlockSize.assertEqualsAndNoLineBreaks;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
-import org.junit.After;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
public class ReversedLinesFileReaderTestSimple {
private ReversedLinesFileReader reversedLinesFileReader;
- @After
+ @AfterEach
public void closeReader() {
try {
reversedLinesFileReader.close();
@@ -50,16 +51,18 @@ public class ReversedLinesFileReaderTestSimple {
assertEqualsAndNoLineBreaks(testLine, reversedLinesFileReader.readLine());
}
- @Test(expected=UnsupportedEncodingException.class)
- public void testUnsupportedEncodingUTF16() throws URISyntaxException, IOException {
+ @Test
+ public void testUnsupportedEncodingUTF16() throws URISyntaxException {
final File testFileEmpty = new File(this.getClass().getResource("/test-file-empty.bin").toURI());
- new ReversedLinesFileReader(testFileEmpty, 4096, "UTF-16").close();
+ assertThrows(UnsupportedEncodingException.class,
+ () -> new ReversedLinesFileReader(testFileEmpty, 4096, "UTF-16").close());
}
- @Test(expected=UnsupportedEncodingException.class)
- public void testUnsupportedEncodingBig5() throws URISyntaxException, IOException {
+ @Test
+ public void testUnsupportedEncodingBig5() throws URISyntaxException {
final File testFileEncodingBig5 = new File(this.getClass().getResource("/test-file-empty.bin").toURI());
- new ReversedLinesFileReader(testFileEncodingBig5, 4096, "Big5").close();
+ assertThrows(UnsupportedEncodingException.class,
+ () -> new ReversedLinesFileReader(testFileEncodingBig5, 4096, "Big5").close());
}
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 9b2ecca..072be05 100644
--- a/src/test/java/org/apache/commons/io/input/SwappedDataInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/SwappedDataInputStreamTest.java
@@ -17,15 +17,15 @@
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.ByteArrayInputStream;
import java.io.IOException;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
@@ -39,7 +39,7 @@ public class SwappedDataInputStreamTest {
private SwappedDataInputStream sdis;
private byte[] bytes;
- @Before
+ @BeforeEach
public void setUp() {
bytes = new byte[] {
0x01,
@@ -55,7 +55,7 @@ public class SwappedDataInputStreamTest {
this.sdis = new SwappedDataInputStream( bais );
}
- @After
+ @AfterEach
public void tearDown() {
this.sdis = null;
}
@@ -109,10 +109,10 @@ public class SwappedDataInputStreamTest {
assertEquals( 0x04030201, this.sdis.readInt() );
}
- @Test(expected = UnsupportedOperationException.class)
- public void testReadLine() throws IOException {
- this.sdis.readLine();
- fail("readLine should be unsupported. ");
+ @Test
+ public void testReadLine() {
+ assertThrows(UnsupportedOperationException.class, () -> this.sdis.readLine(),
+ "readLine should be unsupported. ");
}
@Test
@@ -135,10 +135,10 @@ public class SwappedDataInputStreamTest {
assertEquals( (short) 0x0201, this.sdis.readUnsignedShort() );
}
- @Test(expected = UnsupportedOperationException.class)
+ @Test
public void testReadUTF() throws IOException {
- this.sdis.readUTF();
- fail("readUTF should be unsupported. ");
+ assertThrows(UnsupportedOperationException.class, () -> this.sdis.readUTF(),
+ "readUTF should be unsupported. ");
}
@Test
diff --git a/src/test/java/org/apache/commons/io/input/TaggedInputStreamTest.java b/src/test/java/org/apache/commons/io/input/TaggedInputStreamTest.java
index d69d8c1..6e72b5b 100644
--- a/src/test/java/org/apache/commons/io/input/TaggedInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/TaggedInputStreamTest.java
@@ -16,10 +16,10 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.ByteArrayInputStream;
import java.io.IOException;
@@ -27,7 +27,7 @@ import java.io.InputStream;
import java.util.UUID;
import org.apache.commons.io.TaggedIOException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link TaggedInputStream}.
diff --git a/src/test/java/org/apache/commons/io/input/TaggedReaderTest.java b/src/test/java/org/apache/commons/io/input/TaggedReaderTest.java
index d5d6a97..a4003f0 100644
--- a/src/test/java/org/apache/commons/io/input/TaggedReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/TaggedReaderTest.java
@@ -16,10 +16,10 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.IOException;
import java.io.Reader;
@@ -27,7 +27,7 @@ import java.io.StringReader;
import java.util.UUID;
import org.apache.commons.io.TaggedIOException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link TaggedReader}.
diff --git a/src/test/java/org/apache/commons/io/input/TailerTest.java b/src/test/java/org/apache/commons/io/input/TailerTest.java
index 0bd0e3e..8185781 100644
--- a/src/test/java/org/apache/commons/io/input/TailerTest.java
+++ b/src/test/java/org/apache/commons/io/input/TailerTest.java
@@ -16,12 +16,12 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
@@ -46,10 +46,9 @@ import java.util.concurrent.ScheduledThreadPoolExecutor;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.testtools.TestUtils;
-import org.junit.After;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
/**
* Tests for {@link Tailer}.
@@ -57,16 +56,12 @@ import org.junit.rules.TemporaryFolder;
*/
public class TailerTest {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
- private File getTestDirectory() {
- return temporaryFolder.getRoot();
- }
+ @TempDir
+ public static File temporaryFolder;
private Tailer tailer;
- @After
+ @AfterEach
public void tearDown() throws Exception {
if (tailer != null) {
tailer.stop();
@@ -77,7 +72,7 @@ public class TailerTest {
public void testLongFile() throws Exception {
final long delay = 50;
- final File file = new File(getTestDirectory(), "testLongFile.txt");
+ final File file = new File(temporaryFolder, "testLongFile.txt");
createFile(file, 0);
try (final Writer writer = new FileWriter(file, true)) {
for (int i = 0; i < 100000; i++) {
@@ -107,7 +102,7 @@ public class TailerTest {
public void testBufferBreak() throws Exception {
final long delay = 50;
- final File file = new File(getTestDirectory(), "testBufferBreak.txt");
+ final File file = new File(temporaryFolder, "testBufferBreak.txt");
createFile(file, 0);
writeString(file, "SBTOURIST\n");
@@ -130,7 +125,7 @@ public class TailerTest {
// System.out.println("testMultiByteBreak() Default charset: " + Charset.defaultCharset().displayName());
final long delay = 50;
final File origin = new File(this.getClass().getResource("/test-file-utf8.bin").toURI());
- final File file = new File(getTestDirectory(), "testMultiByteBreak.txt");
+ final File file = new File(temporaryFolder, "testMultiByteBreak.txt");
createFile(file, 0);
final TestTailerListener listener = new TestTailerListener();
final String osname = System.getProperty("os.name");
@@ -155,7 +150,7 @@ public class TailerTest {
final long testDelayMillis = delay * 10;
TestUtils.sleep(testDelayMillis);
final List<String> tailerlines = listener.getLines();
- assertEquals("line count",lines.size(),tailerlines.size());
+ assertEquals(lines.size(), tailerlines.size(), "line count");
for(int i = 0,len = lines.size();i<len;i++){
final String expected = lines.get(i);
final String actual = tailerlines.get(i);
@@ -172,7 +167,7 @@ public class TailerTest {
public void testTailerEof() throws Exception {
// Create & start the Tailer
final long delay = 50;
- final File file = new File(getTestDirectory(), "tailer2-test.txt");
+ final File file = new File(temporaryFolder, "tailer2-test.txt");
createFile(file, 0);
final TestTailerListener listener = new TestTailerListener();
tailer = new Tailer(file, listener, delay, false);
@@ -184,14 +179,14 @@ public class TailerTest {
TestUtils.sleep(delay * 2);
List<String> lines = listener.getLines();
- assertEquals("1 line count", 0, lines.size());
+ assertEquals(0, lines.size(), "1 line count");
writeString(file, " one\n");
TestUtils.sleep(delay * 2);
lines = listener.getLines();
- assertEquals("1 line count", 1, lines.size());
- assertEquals("1 line 1", "Line one", lines.get(0));
+ assertEquals(1, lines.size(), "1 line count");
+ assertEquals("Line one", lines.get(0), "1 line 1");
listener.clear();
}
@@ -201,7 +196,7 @@ public class TailerTest {
// Create & start the Tailer
final long delayMillis = 50;
- final File file = new File(getTestDirectory(), "tailer1-test.txt");
+ final File file = new File(temporaryFolder, "tailer1-test.txt");
createFile(file, 0);
final TestTailerListener listener = new TestTailerListener();
final String osname = System.getProperty("os.name");
@@ -215,30 +210,30 @@ public class TailerTest {
final long testDelayMillis = delayMillis * 10;
TestUtils.sleep(testDelayMillis);
List<String> lines = listener.getLines();
- assertEquals("1 line count", 2, lines.size());
- assertEquals("1 line 1", "Line one", lines.get(0));
- assertEquals("1 line 2", "Line two", lines.get(1));
+ assertEquals(2, lines.size(), "1 line count");
+ assertEquals("Line one", lines.get(0), "1 line 1");
+ assertEquals("Line two", lines.get(1), "1 line 2");
listener.clear();
// Write another line to the file
write(file, "Line three");
TestUtils.sleep(testDelayMillis);
lines = listener.getLines();
- assertEquals("2 line count", 1, lines.size());
- assertEquals("2 line 3", "Line three", lines.get(0));
+ assertEquals(1, lines.size(), "2 line count");
+ assertEquals("Line three", lines.get(0), "2 line 3");
listener.clear();
// Check file does actually have all the lines
lines = FileUtils.readLines(file, "UTF-8");
- assertEquals("3 line count", 3, lines.size());
- assertEquals("3 line 1", "Line one", lines.get(0));
- assertEquals("3 line 2", "Line two", lines.get(1));
- assertEquals("3 line 3", "Line three", lines.get(2));
+ assertEquals(3, lines.size(), "3 line count");
+ assertEquals("Line one", lines.get(0), "3 line 1");
+ assertEquals("Line two", lines.get(1), "3 line 2");
+ assertEquals("Line three", lines.get(2), "3 line 3");
// Delete & re-create
file.delete();
final boolean exists = file.exists();
- assertFalse("File should not exist", exists);
+ assertFalse(exists, "File should not exist");
createFile(file, 0);
TestUtils.sleep(testDelayMillis);
@@ -246,20 +241,20 @@ public class TailerTest {
write(file, "Line four");
TestUtils.sleep(testDelayMillis);
lines = listener.getLines();
- assertEquals("4 line count", 1, lines.size());
- assertEquals("4 line 3", "Line four", lines.get(0));
+ assertEquals(1, lines.size(), "4 line count");
+ assertEquals("Line four", lines.get(0), "4 line 3");
listener.clear();
// Stop
thread.interrupt();
TestUtils.sleep(testDelayMillis * 4);
write(file, "Line five");
- assertEquals("4 line count", 0, listener.getLines().size());
- assertNotNull("Missing InterruptedException", listener.exception);
- assertTrue("Unexpected Exception: " + listener.exception, listener.exception instanceof InterruptedException);
- assertEquals("Expected init to be called", 1 , listener.initialised);
- assertEquals("fileNotFound should not be called", 0 , listener.notFound);
- assertEquals("fileRotated should be be called", 1 , listener.rotated);
+ assertEquals(0, listener.getLines().size(), "4 line count");
+ assertNotNull(listener.exception, "Missing InterruptedException");
+ assertTrue(listener.exception instanceof InterruptedException, "Unexpected Exception: " + listener.exception);
+ assertEquals(1 , listener.initialised, "Expected init to be called");
+ assertEquals(0 , listener.notFound, "fileNotFound should not be called");
+ assertEquals(1 , listener.rotated, "fileRotated should be be called");
}
@Test
@@ -267,7 +262,7 @@ public class TailerTest {
// Create & start the Tailer
final long delayMillis = 50;
final long testDelayMillis = delayMillis * 10;
- final File file = new File(getTestDirectory(), "tailer-eof-test.txt");
+ final File file = new File(temporaryFolder, "tailer-eof-test.txt");
createFile(file, 0);
final TestTailerListener listener = new TestTailerListener();
final String osname = System.getProperty("os.name");
@@ -289,7 +284,7 @@ public class TailerTest {
TestUtils.sleep(testDelayMillis);
// May be > 3 times due to underlying OS behaviour wrt streams
- assertTrue("end of file reached at least 3 times", listener.reachedEndOfFile >= 3);
+ assertTrue(listener.reachedEndOfFile >= 3, "end of file reached at least 3 times");
}
protected void createFile(final File file, final long size)
@@ -343,8 +338,8 @@ public class TailerTest {
@Test
public void testStopWithNoFile() throws Exception {
- final File file = new File(getTestDirectory(),"nosuchfile");
- assertFalse("nosuchfile should not exist", file.exists());
+ final File file = new File(temporaryFolder,"nosuchfile");
+ assertFalse(file.exists(), "nosuchfile should not exist");
final TestTailerListener listener = new TestTailerListener();
final int delay = 100;
final int idle = 50; // allow time for thread to work
@@ -352,11 +347,11 @@ public class TailerTest {
TestUtils.sleep(idle);
tailer.stop();
TestUtils.sleep(delay+idle);
- assertNull("Should not generate Exception", listener.exception);
- assertEquals("Expected init to be called", 1 , listener.initialised);
- assertTrue("fileNotFound should be called", listener.notFound > 0);
- assertEquals("fileRotated should be not be called", 0 , listener.rotated);
- assertEquals("end of file never reached", 0, listener.reachedEndOfFile);
+ assertNull(listener.exception, "Should not generate Exception");
+ assertEquals(1 , listener.initialised, "Expected init to be called");
+ assertTrue(listener.notFound > 0, "fileNotFound should be called");
+ assertEquals(0 , listener.rotated, "fileRotated should be not be called");
+ assertEquals(0, listener.reachedEndOfFile, "end of file never reached");
}
/*
@@ -364,8 +359,8 @@ public class TailerTest {
*/
@Test
public void testInterrupt() throws Exception {
- final File file = new File(getTestDirectory(), "nosuchfile");
- assertFalse("nosuchfile should not exist", file.exists());
+ final File file = new File(temporaryFolder, "nosuchfile");
+ assertFalse(file.exists(), "nosuchfile should not exist");
final TestTailerListener listener = new TestTailerListener();
// Use a long delay to try to make sure the test thread calls interrupt() while the tailer thread is sleeping.
final int delay = 1000;
@@ -377,18 +372,18 @@ public class TailerTest {
TestUtils.sleep(idle);
thread.interrupt();
TestUtils.sleep(delay + idle);
- assertNotNull("Missing InterruptedException", listener.exception);
- assertTrue("Unexpected Exception: " + listener.exception, listener.exception instanceof InterruptedException);
- assertEquals("Expected init to be called", 1, listener.initialised);
- assertTrue("fileNotFound should be called", listener.notFound > 0);
- assertEquals("fileRotated should be not be called", 0, listener.rotated);
- assertEquals("end of file never reached", 0, listener.reachedEndOfFile);
+ assertNotNull(listener.exception, "Missing InterruptedException");
+ assertTrue(listener.exception instanceof InterruptedException, "Unexpected Exception: " + listener.exception);
+ assertEquals(1, listener.initialised, "Expected init to be called");
+ assertTrue(listener.notFound > 0, "fileNotFound should be called");
+ assertEquals(0, listener.rotated, "fileRotated should be not be called");
+ assertEquals(0, listener.reachedEndOfFile, "end of file never reached");
}
@Test
public void testStopWithNoFileUsingExecutor() throws Exception {
- final File file = new File(getTestDirectory(),"nosuchfile");
- assertFalse("nosuchfile should not exist", file.exists());
+ final File file = new File(temporaryFolder,"nosuchfile");
+ assertFalse(file.exists(), "nosuchfile should not exist");
final TestTailerListener listener = new TestTailerListener();
final int delay = 100;
final int idle = 50; // allow time for thread to work
@@ -398,18 +393,18 @@ public class TailerTest {
TestUtils.sleep(idle);
tailer.stop();
TestUtils.sleep(delay+idle);
- assertNull("Should not generate Exception", listener.exception);
- assertEquals("Expected init to be called", 1 , listener.initialised);
- assertTrue("fileNotFound should be called", listener.notFound > 0);
- assertEquals("fileRotated should be not be called", 0 , listener.rotated);
- assertEquals("end of file never reached", 0, listener.reachedEndOfFile);
+ assertNull(listener.exception, "Should not generate Exception");
+ assertEquals(1 , listener.initialised, "Expected init to be called");
+ assertTrue(listener.notFound > 0, "fileNotFound should be called");
+ assertEquals(0 , listener.rotated, "fileRotated should be not be called");
+ assertEquals(0, listener.reachedEndOfFile, "end of file never reached");
}
@Test
public void testIO335() throws Exception { // test CR behaviour
// Create & start the Tailer
final long delayMillis = 50;
- final File file = new File(getTestDirectory(), "tailer-testio334.txt");
+ final File file = new File(temporaryFolder, "tailer-testio334.txt");
createFile(file, 0);
final TestTailerListener listener = new TestTailerListener();
tailer = new Tailer(file, listener, delayMillis, false);
@@ -421,11 +416,11 @@ public class TailerTest {
final long testDelayMillis = delayMillis * 10;
TestUtils.sleep(testDelayMillis);
final List<String> lines = listener.getLines();
- assertEquals("line count", 4, lines.size());
- assertEquals("line 1", "CRLF", lines.get(0));
- assertEquals("line 2", "LF", lines.get(1));
- assertEquals("line 3", "CR", lines.get(2));
- assertEquals("line 4", "CRCR\r", lines.get(3));
+ assertEquals(4, lines.size(), "line count");
+ assertEquals("CRLF", lines.get(0), "line 1");
+ assertEquals("LF", lines.get(1), "line 2");
+ assertEquals("CR", lines.get(2), "line 3");
+ assertEquals("CRCR\r", lines.get(3), "line 4");
}
/**
diff --git a/src/test/java/org/apache/commons/io/input/TeeInputStreamTest.java b/src/test/java/org/apache/commons/io/input/TeeInputStreamTest.java
index bfb4f3f..1d60c41 100644
--- a/src/test/java/org/apache/commons/io/input/TeeInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/TeeInputStreamTest.java
@@ -16,7 +16,8 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
@@ -30,9 +31,8 @@ import java.io.OutputStream;
import org.apache.commons.io.testtools.YellOnCloseInputStream;
import org.apache.commons.io.testtools.YellOnCloseOutputStream;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link TeeInputStream}.
@@ -45,7 +45,7 @@ public class TeeInputStreamTest {
private ByteArrayOutputStream output;
- @Before
+ @BeforeEach
public void setUp() throws Exception {
final InputStream input = new ByteArrayInputStream("abc".getBytes(ASCII));
output = new ByteArrayOutputStream();
@@ -131,7 +131,7 @@ public class TeeInputStreamTest {
final TeeInputStream closingTis = new TeeInputStream(goodIs, badOs, true);
try {
closingTis.close();
- Assert.fail("Expected " + IOException.class.getName());
+ fail("Expected " + IOException.class.getName());
} catch (final IOException e) {
verify(goodIs, times(2)).close();
}
@@ -149,7 +149,7 @@ public class TeeInputStreamTest {
final TeeInputStream nonClosingTis = new TeeInputStream(badIs, goodOs, false);
try {
nonClosingTis.close();
- Assert.fail("Expected " + IOException.class.getName());
+ fail("Expected " + IOException.class.getName());
} catch (final IOException e) {
verify(goodOs, never()).close();
}
@@ -157,7 +157,7 @@ public class TeeInputStreamTest {
final TeeInputStream closingTis = new TeeInputStream(badIs, goodOs, true);
try {
closingTis.close();
- Assert.fail("Expected " + IOException.class.getName());
+ fail("Expected " + IOException.class.getName());
} catch (final IOException e) {
verify(goodOs).close();
}
diff --git a/src/test/java/org/apache/commons/io/input/TeeReaderTest.java b/src/test/java/org/apache/commons/io/input/TeeReaderTest.java
index de175bb..4b8d30b 100644
--- a/src/test/java/org/apache/commons/io/input/TeeReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/TeeReaderTest.java
@@ -16,7 +16,8 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
@@ -32,9 +33,8 @@ import java.nio.CharBuffer;
import org.apache.commons.io.output.StringBuilderWriter;
import org.apache.commons.io.testtools.YellOnCloseReader;
import org.apache.commons.io.testtools.YellOnCloseWriter;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* JUnit Test Case for {@link TeeReader}.
@@ -45,7 +45,7 @@ public class TeeReaderTest {
private Reader tee;
- @Before
+ @BeforeEach
public void setUp() throws Exception {
final Reader input = new CharSequenceReader("abc");
output = new StringBuilderWriter();
@@ -68,7 +68,7 @@ public class TeeReaderTest {
final TeeReader closingTr = new TeeReader(goodR, badW, true);
try {
closingTr.close();
- Assert.fail("Expected " + IOException.class.getName());
+ fail("Expected " + IOException.class.getName());
} catch (final IOException e) {
verify(goodR, times(2)).close();
}
@@ -86,7 +86,7 @@ public class TeeReaderTest {
final TeeReader nonClosingTr = new TeeReader(badR, goodW, false);
try {
nonClosingTr.close();
- Assert.fail("Expected " + IOException.class.getName());
+ fail("Expected " + IOException.class.getName());
} catch (final IOException e) {
verify(goodW, never()).close();
}
@@ -94,7 +94,7 @@ public class TeeReaderTest {
final TeeReader closingTr = new TeeReader(badR, goodW, true);
try {
closingTr.close();
- Assert.fail("Expected " + IOException.class.getName());
+ fail("Expected " + IOException.class.getName());
} catch (final IOException e) {
//Assert.assertTrue(goodW.closed);
verify(goodW).close();
diff --git a/src/test/java/org/apache/commons/io/input/UnixLineEndingInputStreamTest.java b/src/test/java/org/apache/commons/io/input/UnixLineEndingInputStreamTest.java
index 4809d5b..e7b78ab 100644
--- a/src/test/java/org/apache/commons/io/input/UnixLineEndingInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/UnixLineEndingInputStreamTest.java
@@ -16,12 +16,12 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.IOException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class UnixLineEndingInputStreamTest
{
diff --git a/src/test/java/org/apache/commons/io/input/WindowsLineEndingInputStreamTest.java b/src/test/java/org/apache/commons/io/input/WindowsLineEndingInputStreamTest.java
index 28626c5..6ecbbdf 100644
--- a/src/test/java/org/apache/commons/io/input/WindowsLineEndingInputStreamTest.java
+++ b/src/test/java/org/apache/commons/io/input/WindowsLineEndingInputStreamTest.java
@@ -16,12 +16,12 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.IOException;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class WindowsLineEndingInputStreamTest {
@Test
diff --git a/src/test/java/org/apache/commons/io/input/XmlStreamReaderTest.java b/src/test/java/org/apache/commons/io/input/XmlStreamReaderTest.java
index 38d2968..019729f 100644
--- a/src/test/java/org/apache/commons/io/input/XmlStreamReaderTest.java
+++ b/src/test/java/org/apache/commons/io/input/XmlStreamReaderTest.java
@@ -16,9 +16,9 @@
*/
package org.apache.commons.io.input;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
... 3272 lines suppressed ...