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 2020/10/13 14:22:52 UTC
[commons-io] 03/03: Let org.apache.commons.io.filefilter classes
work with java.nio.file.Files.walk* APIs.
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
commit 8b6d4969ffb55bf7301a44a8156f02b0213e6d68
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Tue Oct 13 10:22:44 2020 -0400
Let org.apache.commons.io.filefilter classes work with
java.nio.file.Files.walk* APIs.
Also: AccumulatorPathVisitor does not track directories properly.
---
pom.xml | 34 +
src/changes/changes.xml | 6 +
.../commons/io/file/AccumulatorPathVisitor.java | 83 +-
.../commons/io/file/CopyDirectoryVisitor.java | 23 +-
.../java/org/apache/commons/io/file/Counters.java | 109 ++-
.../commons/io/file/CountingPathVisitor.java | 17 +-
...SimplePathVisitor.java => NoopPathVisitor.java} | 16 +-
.../java/org/apache/commons/io/file/PathUtils.java | 89 ++
.../{SimplePathVisitor.java => PathVisitor.java} | 17 +-
.../apache/commons/io/file/SimplePathVisitor.java | 2 +-
.../commons/io/filefilter/AbstractFileFilter.java | 93 ++-
.../commons/io/filefilter/AgeFileFilter.java | 124 ++-
.../commons/io/filefilter/AndFileFilter.java | 86 +-
.../io/filefilter/CanExecuteFileFilter.java | 35 +-
.../commons/io/filefilter/CanReadFileFilter.java | 56 +-
.../commons/io/filefilter/CanWriteFileFilter.java | 47 +-
.../commons/io/filefilter/DelegateFileFilter.java | 2 -
.../commons/io/filefilter/DirectoryFileFilter.java | 43 +-
.../commons/io/filefilter/EmptyFileFilter.java | 79 +-
.../commons/io/filefilter/FalseFileFilter.java | 44 +-
.../commons/io/filefilter/FileFileFilter.java | 44 +-
.../commons/io/filefilter/FileFilterUtils.java | 108 +--
.../commons/io/filefilter/HiddenFileFilter.java | 59 +-
.../apache/commons/io/filefilter/IOFileFilter.java | 75 +-
.../io/filefilter/MagicNumberFileFilter.java | 62 +-
.../commons/io/filefilter/NameFileFilter.java | 74 +-
.../commons/io/filefilter/NotFileFilter.java | 37 +-
.../apache/commons/io/filefilter/OrFileFilter.java | 53 +-
.../PathFilter.java} | 30 +-
.../io/filefilter/PathVisitorFileFilter.java | 90 ++
.../commons/io/filefilter/PrefixFileFilter.java | 72 +-
.../commons/io/filefilter/RegexFileFilter.java | 39 +-
.../commons/io/filefilter/SizeFileFilter.java | 71 +-
.../commons/io/filefilter/SuffixFileFilter.java | 55 +-
.../commons/io/filefilter/TrueFileFilter.java | 28 +-
.../commons/io/filefilter/WildcardFileFilter.java | 63 +-
.../commons/io/filefilter/WildcardFilter.java | 76 +-
.../org/apache/commons/io/filefilter/package.html | 46 +-
.../apache/commons/io/DirectoryWalkerTestCase.java | 4 +-
.../io/file/AccumulatorPathVisitorTest.java | 122 +++
.../apache/commons/io/file/CounterAssertions.java | 11 +-
.../org/apache/commons/io/file/CountersTest.java | 23 +
.../commons/io/file/PathUtilsVisitorTest.java | 103 +++
.../commons/io/filefilter/AgeFileFilterTest.java | 109 +++
.../io/filefilter/DirectoryFileFilterTest.java | 93 +++
.../commons/io/filefilter/FileFilterTestCase.java | 909 ++++++++++++++-------
.../filefilter/IOFileFilterAbstractTestCase.java | 4 +-
.../io/filefilter/RegexFileFilterTestCase.java | 39 +
48 files changed, 2868 insertions(+), 636 deletions(-)
diff --git a/pom.xml b/pom.xml
index c314057..775a629 100644
--- a/pom.xml
+++ b/pom.xml
@@ -308,6 +308,8 @@ file comparators, endian transformation classes, and much more.
<spotbugs.plugin.version>4.1.3</spotbugs.plugin.version>
<spotbugs.impl.version>4.1.3</spotbugs.impl.version>
<japicmp.skip>false</japicmp.skip>
+ <!-- generate report even if there are binary incompatible changes -->
+ <commons.japicmp.breakBuildOnBinaryIncompatibleModifications>false</commons.japicmp.breakBuildOnBinaryIncompatibleModifications>
<jacoco.skip>${env.JACOCO_SKIP}</jacoco.skip>
<commons.release.isDistModule>true</commons.release.isDistModule>
<commons.releaseManagerName>Gary Gregory</commons.releaseManagerName>
@@ -437,6 +439,22 @@ file comparators, endian transformation classes, and much more.
<excludeFilterFile>${basedir}/spotbugs-exclude-filter.xml</excludeFilterFile>
</configuration>
</plugin>
+ <plugin>
+ <groupId>com.github.siom79.japicmp</groupId>
+ <artifactId>japicmp-maven-plugin</artifactId>
+ <configuration>
+ <parameter>
+ <overrideCompatibilityChangeParameters>
+ <overrideCompatibilityChangeParameter>
+ <compatibilityChange>METHOD_NEW_DEFAULT</compatibilityChange>
+ <binaryCompatible>true</binaryCompatible>
+ <sourceCompatible>true</sourceCompatible>
+ <semanticVersionLevel>PATCH</semanticVersionLevel>
+ </overrideCompatibilityChangeParameter>
+ </overrideCompatibilityChangeParameters>
+ </parameter>
+ </configuration>
+ </plugin>
</plugins>
</build>
@@ -459,6 +477,22 @@ file comparators, endian transformation classes, and much more.
<excludeFilterFile>${basedir}/spotbugs-exclude-filter.xml</excludeFilterFile>
</configuration>
</plugin>
+ <plugin>
+ <groupId>com.github.siom79.japicmp</groupId>
+ <artifactId>japicmp-maven-plugin</artifactId>
+ <configuration>
+ <parameter>
+ <overrideCompatibilityChangeParameters>
+ <overrideCompatibilityChangeParameter>
+ <compatibilityChange>METHOD_NEW_DEFAULT</compatibilityChange>
+ <binaryCompatible>true</binaryCompatible>
+ <sourceCompatible>true</sourceCompatible>
+ <semanticVersionLevel>PATCH</semanticVersionLevel>
+ </overrideCompatibilityChangeParameter>
+ </overrideCompatibilityChangeParameters>
+ </parameter>
+ </configuration>
+ </plugin>
</plugins>
</reporting>
<profiles>
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 4623008..23680ea 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -63,10 +63,16 @@ The <action> type attribute can be add,update,fix,remove.
<action dev="ggregory" type="fix" due-to="Michiel Kalkman">
FileUtils#copyDirectory(File, File, FileFilter, preserveFileDate) clean up #163.
</action>
+ <action dev="ggregory" type="fix" due-to="Michiel Kalkman">
+ AccumulatorPathVisitor does not track directories properly.
+ </action>
<!-- ADD -->
<action dev="ggregory" type="add" due-to="Gary Gregory">
Add FileSystemProviders class.
</action>
+ <action dev="ggregory" type="add" due-to="Gary Gregory">
+ Let org.apache.commons.io.filefilter classes work with java.nio.file.Files.walk* APIs.
+ </action>
<!-- UPDATES -->
<action dev="ggregory" type="update" due-to="Dependabot">
Update junit-jupiter from 5.6.2 to 5.7.0 #153.
diff --git a/src/main/java/org/apache/commons/io/file/AccumulatorPathVisitor.java b/src/main/java/org/apache/commons/io/file/AccumulatorPathVisitor.java
index 2215b2a..7ff43f0 100644
--- a/src/main/java/org/apache/commons/io/file/AccumulatorPathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/AccumulatorPathVisitor.java
@@ -19,7 +19,6 @@ package org.apache.commons.io.file;
import java.io.IOException;
import java.nio.file.FileVisitResult;
-import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
@@ -28,12 +27,34 @@ import java.util.List;
import java.util.Objects;
import org.apache.commons.io.file.Counters.PathCounters;
+import org.apache.commons.io.filefilter.PathFilter;
/**
* Accumulates normalized paths during visitation.
* <p>
* Use with care on large file trees as each visited Path element is remembered.
* </p>
+ * <h2>Example</h2>
+ *
+ * <pre>
+ * Path dir = Paths.get(".");
+ * // We are interested in files older than one day
+ * long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+ * AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new AgeFileFilter(cutoff));
+ * //
+ * // Walk one dir
+ * Files.walkFileTree(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.walkFileTree(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
*
* @since 2.7
*/
@@ -57,6 +78,28 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
return new AccumulatorPathVisitor(Counters.longPathCounters());
}
+ /**
+ * Creates a new instance configured with a long {@link PathCounters}.
+ *
+ * @param pathFilter Filters files to accumulate and count.
+ * @return a new instance configured with a long {@link PathCounters}.
+ * @since 2.9.0
+ */
+ public static AccumulatorPathVisitor withLongCounters(final PathFilter pathFilter) {
+ return new AccumulatorPathVisitor(Counters.longPathCounters(), pathFilter);
+ }
+
+ /**
+ * Creates a new instance configured with a BigInteger {@link PathCounters}.
+ *
+ * @param pathFilter Filters files to accumulate and count.
+ * @return a new instance configured with a long {@link PathCounters}.
+ * @since 2.9.0
+ */
+ public static AccumulatorPathVisitor withBigIntegerCounters(final PathFilter pathFilter) {
+ return new AccumulatorPathVisitor(Counters.bigIntegerPathCounters(), pathFilter);
+ }
+
private final List<Path> dirList = new ArrayList<>();
private final List<Path> fileList = new ArrayList<>();
@@ -64,12 +107,36 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
/**
* Constructs a new instance.
*
+ * @since 2.9.0
+ */
+ public AccumulatorPathVisitor() {
+ super(Counters.noopPathCounters());
+ }
+
+ /**
+ * Constructs a new instance that counts file system elements.
+ *
* @param pathCounter How to count path visits.
*/
public AccumulatorPathVisitor(final PathCounters pathCounter) {
super(pathCounter);
}
+ /**
+ * Constructs a new instance.
+ *
+ * @param pathCounter How to count path visits.
+ * @param pathFilter Filters which paths to count.
+ * @since 2.9.0
+ */
+ public AccumulatorPathVisitor(final PathCounters pathCounter, final PathFilter pathFilter) {
+ super(pathCounter, pathFilter);
+ }
+
+ private void add(final List<Path> list, final Path dir) {
+ list.add(dir.normalize());
+ }
+
@Override
public boolean equals(final Object obj) {
if (this == obj) {
@@ -111,6 +178,12 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
return result;
}
+ @Override
+ public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) throws IOException {
+ add(dirList, dir);
+ return super.postVisitDirectory(dir, exc);
+ }
+
/**
* Relativizes each directory path with {@link Path#relativize(Path)} against the given {@code parent}, optionally
* sorting the result.
@@ -120,7 +193,8 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
* @param comparator How to sort, null uses default sorting.
* @return A new list
*/
- public List<Path> relativizeDirectories(final Path parent, final boolean sort, final Comparator<? super Path> comparator) {
+ public List<Path> relativizeDirectories(final Path parent, final boolean sort,
+ final Comparator<? super Path> comparator) {
return PathUtils.relativize(getDirList(), parent, sort, comparator);
}
@@ -133,13 +207,14 @@ public class AccumulatorPathVisitor extends CountingPathVisitor {
* @param comparator How to sort, null uses default sorting.
* @return A new list
*/
- public List<Path> relativizeFiles(final Path parent, final boolean sort, final Comparator<? super Path> comparator) {
+ public List<Path> relativizeFiles(final Path parent, final boolean sort,
+ final Comparator<? super Path> comparator) {
return PathUtils.relativize(getFileList(), parent, sort, comparator);
}
@Override
public FileVisitResult visitFile(final Path file, final BasicFileAttributes attributes) throws IOException {
- ((Files.isDirectory(file)) ? dirList : fileList).add(file.normalize());
+ add(fileList, file);
return super.visitFile(file, attributes);
}
diff --git a/src/main/java/org/apache/commons/io/file/CopyDirectoryVisitor.java b/src/main/java/org/apache/commons/io/file/CopyDirectoryVisitor.java
index bb93ba5..ea4e6d1 100644
--- a/src/main/java/org/apache/commons/io/file/CopyDirectoryVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/CopyDirectoryVisitor.java
@@ -27,6 +27,7 @@ import java.util.Arrays;
import java.util.Objects;
import org.apache.commons.io.file.Counters.PathCounters;
+import org.apache.commons.io.filefilter.PathFilter;
/**
* Copies a source directory to a target directory.
@@ -35,8 +36,6 @@ import org.apache.commons.io.file.Counters.PathCounters;
*/
public class CopyDirectoryVisitor extends CountingPathVisitor {
- private static final CopyOption[] EMPTY_COPY_OPTIONS = new CopyOption[0];
-
private final CopyOption[] copyOptions;
private final Path sourceDirectory;
private final Path targetDirectory;
@@ -54,7 +53,25 @@ public class CopyDirectoryVisitor extends CountingPathVisitor {
super(pathCounter);
this.sourceDirectory = sourceDirectory;
this.targetDirectory = targetDirectory;
- this.copyOptions = copyOptions == null ? EMPTY_COPY_OPTIONS : copyOptions.clone();
+ this.copyOptions = copyOptions == null ? PathUtils.EMPTY_COPY_OPTIONS : copyOptions.clone();
+ }
+
+ /**
+ * Constructs a new visitor that deletes files except for the files and directories explicitly given.
+ *
+ * @param pathCounter How to count visits.
+ * @param pathFilter How to filter paths.
+ * @param sourceDirectory The source directory
+ * @param targetDirectory The target directory
+ * @param copyOptions Specifies how the copying should be done.
+ * @since 2.9.0
+ */
+ public CopyDirectoryVisitor(final PathCounters pathCounter, final PathFilter pathFilter, final Path sourceDirectory, final Path targetDirectory,
+ final CopyOption... copyOptions) {
+ super(pathCounter, pathFilter);
+ this.sourceDirectory = sourceDirectory;
+ this.targetDirectory = targetDirectory;
+ this.copyOptions = copyOptions == null ? PathUtils.EMPTY_COPY_OPTIONS : copyOptions.clone();
}
/**
diff --git a/src/main/java/org/apache/commons/io/file/Counters.java b/src/main/java/org/apache/commons/io/file/Counters.java
index d1ae34f..3f6d9a8 100644
--- a/src/main/java/org/apache/commons/io/file/Counters.java
+++ b/src/main/java/org/apache/commons/io/file/Counters.java
@@ -44,7 +44,7 @@ public class Counters {
* @param fileCounter the file counter.
*/
protected AbstractPathCounters(final Counter byteCounter, final Counter directoryCounter,
- final Counter fileCounter) {
+ final Counter fileCounter) {
super();
this.byteCounter = byteCounter;
this.directoryCounter = directoryCounter;
@@ -61,8 +61,8 @@ public class Counters {
}
final AbstractPathCounters other = (AbstractPathCounters) obj;
return Objects.equals(byteCounter, other.byteCounter)
- && Objects.equals(directoryCounter, other.directoryCounter)
- && Objects.equals(fileCounter, other.fileCounter);
+ && Objects.equals(directoryCounter, other.directoryCounter)
+ && Objects.equals(fileCounter, other.fileCounter);
}
@Override
@@ -91,9 +91,16 @@ public class Counters {
}
@Override
+ public void reset() {
+ byteCounter.reset();
+ directoryCounter.reset();
+ fileCounter.reset();
+ }
+
+ @Override
public String toString() {
return String.format("%,d files, %,d directories, %,d bytes", Long.valueOf(fileCounter.get()),
- Long.valueOf(directoryCounter.get()), Long.valueOf(byteCounter.get()));
+ Long.valueOf(directoryCounter.get()), Long.valueOf(byteCounter.get()));
}
}
@@ -152,6 +159,11 @@ public class Counters {
public String toString() {
return value.toString();
}
+
+ @Override
+ public void reset() {
+ value = BigInteger.ZERO;
+ }
}
/**
@@ -206,6 +218,13 @@ public class Counters {
*/
void increment();
+ /**
+ * Resets this count to 0.
+ */
+ default void reset() {
+ // binary compat, do nothing
+ }
+
}
/**
@@ -262,6 +281,11 @@ public class Counters {
public String toString() {
return Long.toString(value);
}
+
+ @Override
+ public void reset() {
+ value = 0L;
+ }
}
/**
@@ -279,6 +303,56 @@ public class Counters {
}
/**
+ * Counts nothing.
+ */
+ private final static class NoopCounter implements Counter {
+
+ static final NoopCounter INSTANCE = new NoopCounter();
+
+ @Override
+ public void add(final long add) {
+ // noop
+ }
+
+ @Override
+ public long get() {
+ return 0;
+ }
+
+ @Override
+ public BigInteger getBigInteger() {
+ return BigInteger.ZERO;
+ }
+
+ @Override
+ public Long getLong() {
+ return 0L;
+ }
+
+ @Override
+ public void increment() {
+ // noop
+ }
+
+ }
+
+ /**
+ * Counts nothing.
+ */
+ private static final class NoopPathCounters extends AbstractPathCounters {
+
+ static final NoopPathCounters INSTANCE = new NoopPathCounters();
+
+ /**
+ * Constructs a new initialized instance.
+ */
+ private NoopPathCounters() {
+ super(Counters.noopCounter(), Counters.noopCounter(), Counters.noopCounter());
+ }
+
+ }
+
+ /**
* Counts files, directories, and sizes, as a visit proceeds.
*/
public interface PathCounters {
@@ -304,6 +378,13 @@ public class Counters {
*/
Counter getFileCounter();
+ /**
+ * Resets the counts to 0.
+ */
+ default void reset() {
+ // binary compat, do nothing
+ }
+
}
/**
@@ -341,4 +422,24 @@ public class Counters {
public static PathCounters longPathCounters() {
return new LongPathCounters();
}
+
+ /**
+ * Returns the NOOP Counter.
+ *
+ * @return the NOOP Counter.
+ * @since 2.9.0
+ */
+ public static Counter noopCounter() {
+ return NoopCounter.INSTANCE;
+ }
+
+ /**
+ * Returns the NOOP PathCounters.
+ *
+ * @return the NOOP PathCounters.
+ * @since 2.9.0
+ */
+ public static PathCounters noopPathCounters() {
+ return NoopPathCounters.INSTANCE;
+ }
}
diff --git a/src/main/java/org/apache/commons/io/file/CountingPathVisitor.java b/src/main/java/org/apache/commons/io/file/CountingPathVisitor.java
index ccd0fb1..a7125f5 100644
--- a/src/main/java/org/apache/commons/io/file/CountingPathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/CountingPathVisitor.java
@@ -25,6 +25,8 @@ import java.nio.file.attribute.BasicFileAttributes;
import java.util.Objects;
import org.apache.commons.io.file.Counters.PathCounters;
+import org.apache.commons.io.filefilter.PathFilter;
+import org.apache.commons.io.filefilter.TrueFileFilter;
/**
* Counts files, directories, and sizes, as a visit proceeds.
@@ -54,6 +56,7 @@ public class CountingPathVisitor extends SimplePathVisitor {
}
private final PathCounters pathCounters;
+ private final PathFilter pathFilter;
/**
* Constructs a new instance.
@@ -61,8 +64,20 @@ public class CountingPathVisitor extends SimplePathVisitor {
* @param pathCounter How to count path visits.
*/
public CountingPathVisitor(final PathCounters pathCounter) {
+ this(pathCounter, TrueFileFilter.INSTANCE);
+ }
+
+ /**
+ * Constructs a new instance.
+ *
+ * @param pathCounter How to count path visits.
+ * @param pathFilter Filters which paths to count.
+ * @since 2.9.0
+ */
+ public CountingPathVisitor(final PathCounters pathCounter, final PathFilter pathFilter) {
super();
this.pathCounters = Objects.requireNonNull(pathCounter, "pathCounter");
+ this.pathFilter = Objects.requireNonNull(pathFilter, "pathFilter");
}
@Override
@@ -115,7 +130,7 @@ public class CountingPathVisitor extends SimplePathVisitor {
@Override
public FileVisitResult visitFile(final Path file, final BasicFileAttributes attributes) throws IOException {
- if (Files.exists(file)) {
+ if (Files.exists(file) && pathFilter.accept(file) == FileVisitResult.CONTINUE) {
updateFileCounters(file, attributes);
}
return FileVisitResult.CONTINUE;
diff --git a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java b/src/main/java/org/apache/commons/io/file/NoopPathVisitor.java
similarity index 74%
copy from src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
copy to src/main/java/org/apache/commons/io/file/NoopPathVisitor.java
index 8b2cdc4..b10201d 100644
--- a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/NoopPathVisitor.java
@@ -17,21 +17,15 @@
package org.apache.commons.io.file;
-import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
-
/**
- * A {@link SimpleFileVisitor} typed to a {@link Path}.
+ * A noop path visitor.
*
- * @since 2.7
+ * @since 2.9.0
*/
-public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> {
+public class NoopPathVisitor extends SimplePathVisitor {
/**
- * Constructs a new instance.
+ * The singleton instance.
*/
- protected SimplePathVisitor() {
- super();
- }
-
+ public static NoopPathVisitor INSTANCE = new NoopPathVisitor();
}
diff --git a/src/main/java/org/apache/commons/io/file/PathUtils.java b/src/main/java/org/apache/commons/io/file/PathUtils.java
index 5902a74..d8de77f 100644
--- a/src/main/java/org/apache/commons/io/file/PathUtils.java
+++ b/src/main/java/org/apache/commons/io/file/PathUtils.java
@@ -17,6 +17,7 @@
package org.apache.commons.io.file;
+import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
@@ -24,6 +25,7 @@ import java.net.URL;
import java.nio.file.CopyOption;
import java.nio.file.DirectoryStream;
import java.nio.file.FileVisitOption;
+import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.LinkOption;
@@ -43,12 +45,16 @@ import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.List;
+import java.util.Objects;
import java.util.Set;
+import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.file.Counters.PathCounters;
+import org.apache.commons.io.filefilter.IOFileFilter;
+import org.apache.commons.io.filefilter.PathFilter;
/**
* NIO Path utilities.
@@ -121,6 +127,13 @@ public final class PathUtils {
}
/**
+ * Empty {@link CopyOption} array.
+ *
+ * @since 2.8.0
+ */
+ public static final CopyOption[] EMPTY_COPY_OPTIONS = new CopyOption[0];
+
+ /**
* Empty {@link LinkOption} array.
*
* @since 2.8.0
@@ -143,6 +156,12 @@ public final class PathUtils {
public static final OpenOption[] EMPTY_OPEN_OPTION_ARRAY = new OpenOption[0];
/**
+ * Empty {@link Path} array.
+ * @since 2.9.0
+ */
+ public static final Path[] EMPTY_PATH_ARRAY = new Path[0];
+
+ /**
* Accumulates file tree information in a {@link AccumulatorPathVisitor}.
*
* @param directory The directory to accumulate information.
@@ -587,6 +606,26 @@ public final class PathUtils {
}
/**
+ * Tests if the specified {@code Path} is newer than the specified time reference.
+ *
+ * @param file the {@code Path} of which the modification date must be compared
+ * @param timeMillis the time reference measured in milliseconds since the epoch (00:00:00 GMT, January 1, 1970)
+ * @param options options indicating how symbolic links are handled * @return true if the {@code Path} exists and
+ * has been modified after the given time reference.
+ * @return true if the {@code Path} exists and has been modified after the given time reference.
+ * @throws IOException if an I/O error occurs
+ * @throws NullPointerException if the file is {@code null}
+ * @since 2.9.0
+ */
+ public static boolean isNewer(final Path file, final long timeMillis, final LinkOption... options) throws IOException {
+ Objects.requireNonNull(file, "file");
+ if (!Files.exists(file)) {
+ return false;
+ }
+ return Files.getLastModifiedTime(file, options).toMillis() > timeMillis;
+ }
+
+ /**
* Returns true if the given options contain {@link StandardDeleteOption#OVERRIDE_READ_ONLY}.
*
* @param options the array to test
@@ -750,4 +789,54 @@ public final class PathUtils {
// do not instantiate.
}
+ /**
+ * <p>
+ * Applies an {@link IOFileFilter} to the provided {@link File}
+ * objects. The resulting array is a subset of the original file list that
+ * matches the provided filter.
+ * </p>
+ *
+ * <p>
+ * The {@link Set} returned by this method is not guaranteed to be thread safe.
+ * </p>
+ *
+ * <pre>
+ * Set<File> allFiles = ...
+ * Set<File> javaFiles = FileFilterUtils.filterSet(allFiles,
+ * FileFilterUtils.suffixFileFilter(".java"));
+ * </pre>
+ * @param filter the filter to apply to the set of files.
+ * @param paths the array of files to apply the filter to.
+ *
+ * @return a subset of <code>files</code> that is accepted by the
+ * file filter.
+ * @throws IllegalArgumentException if the filter is {@code null}
+ * or <code>files</code> contains a {@code null} value.
+ *
+ * @since 2.9.0
+ */
+ public static Path[] filter(final PathFilter filter, final Path... paths) {
+ Objects.requireNonNull(filter, "filter");
+ if (paths == null) {
+ return EMPTY_PATH_ARRAY;
+ }
+ return filterPaths(filter, Arrays.stream(paths), Collectors.toList()).toArray(EMPTY_PATH_ARRAY);
+ }
+
+ private static <R, A> R filterPaths(final PathFilter filter, final Stream<Path> stream,
+ final Collector<? super Path, A, R> collector) {
+ Objects.requireNonNull(filter, "filter");
+ Objects.requireNonNull(collector, "collector");
+ if (stream == null) {
+ return Stream.<Path>empty().collect(collector);
+ }
+ return stream.filter(t -> {
+ try {
+ return filter.accept(t) == FileVisitResult.CONTINUE;
+ } catch (final IOException e) {
+ return false;
+ }
+ }).collect(collector);
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java b/src/main/java/org/apache/commons/io/file/PathVisitor.java
similarity index 74%
copy from src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
copy to src/main/java/org/apache/commons/io/file/PathVisitor.java
index 8b2cdc4..dcd7258 100644
--- a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/PathVisitor.java
@@ -17,21 +17,14 @@
package org.apache.commons.io.file;
+import java.nio.file.FileVisitor;
import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
/**
- * A {@link SimpleFileVisitor} typed to a {@link Path}.
+ * A {@link FileVisitor} typed to a {@link Path}.
*
- * @since 2.7
+ * @since 2.9.0
*/
-public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> {
-
- /**
- * Constructs a new instance.
- */
- protected SimplePathVisitor() {
- super();
- }
-
+public interface PathVisitor extends FileVisitor<Path> {
+ // empty
}
diff --git a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java b/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
index 8b2cdc4..20241a4 100644
--- a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
+++ b/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
@@ -25,7 +25,7 @@ import java.nio.file.SimpleFileVisitor;
*
* @since 2.7
*/
-public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> {
+public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> implements PathVisitor {
/**
* Constructs a new instance.
diff --git a/src/main/java/org/apache/commons/io/filefilter/AbstractFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/AbstractFileFilter.java
index a4647fc..ea4a574 100644
--- a/src/main/java/org/apache/commons/io/filefilter/AbstractFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/AbstractFileFilter.java
@@ -17,44 +17,107 @@
package org.apache.commons.io.filefilter;
import java.io.File;
+import java.io.FileFilter;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.Objects;
+
+import org.apache.commons.io.file.PathVisitor;
/**
- * An abstract class which implements the Java FileFilter and FilenameFilter
- * interfaces via the IOFileFilter interface.
+ * Abstracts the implementation of the {@link FileFilter} (IO), {@link FilenameFilter} (IO), {@link PathFilter} (NIO)
+ * interfaces via our own {@link IOFileFilter} interface.
* <p>
- * Note that a subclass <b>must</b> override one of the accept methods,
- * otherwise your class will infinitely loop.
+ * Note that a subclass MUST override one of the {@code accept} methods, otherwise your class will infinitely loop.
+ * </p>
*
* @since 1.0
- *
*/
-public abstract class AbstractFileFilter implements IOFileFilter {
+public abstract class AbstractFileFilter implements IOFileFilter, PathVisitor {
+
+ protected static FileVisitResult toFileVisitResult(final boolean accept) {
+ return accept ? FileVisitResult.CONTINUE : FileVisitResult.TERMINATE;
+ }
/**
* Checks to see if the File should be accepted by this filter.
*
- * @param file the File to check
+ * @param file the File to check
* @return true if this file matches the test
*/
@Override
public boolean accept(final File file) {
+ Objects.requireNonNull(file, "file");
return accept(file.getParentFile(), file.getName());
}
/**
* Checks to see if the File should be accepted by this filter.
*
- * @param dir the directory File to check
- * @param name the file name within the directory to check
+ * @param dir the directory File to check
+ * @param name the file name within the directory to check
* @return true if this file matches the test
*/
@Override
public boolean accept(final File dir, final String name) {
+ Objects.requireNonNull(name, "name");
return accept(new File(dir, name));
}
/**
- * Provide a String representation of this file filter.
+ * Checks to see if the Path should be accepted by this filter.
+ *
+ * @param path the Path to check
+ * @return true if this path matches the test
+ * @throws IOException if an I/O error occurs
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path path) throws IOException {
+ Objects.requireNonNull(path, "path");
+ return accept(path.getParent(), path.getFileName());
+ }
+
+ /**
+ * Checks to see if the Path should be accepted by this filter.
+ *
+ * @param dir the directory Path to check
+ * @param name the path name within the directory to check
+ * @return true if this path matches the test
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path dir, final Path name) throws IOException {
+ Objects.requireNonNull(dir, "dir");
+ return accept(dir.resolve(name));
+ }
+
+ /**
+ * Handles exceptions caught while accepting.
+ *
+ * @param t the caught exception.
+ * @return the given Throwable.
+ * @since 2.9.0
+ */
+ protected FileVisitResult handle(final Throwable t) {
+ return FileVisitResult.TERMINATE;
+ }
+
+ @Override
+ public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) throws IOException {
+ return FileVisitResult.CONTINUE;
+ }
+
+ @Override
+ public FileVisitResult preVisitDirectory(final Path dir, final BasicFileAttributes attrs) throws IOException {
+ return accept(dir, dir.getFileName());
+ }
+
+ /**
+ * Provides a String representation of this file filter.
*
* @return a String representation
*/
@@ -63,4 +126,14 @@ public abstract class AbstractFileFilter implements IOFileFilter {
return getClass().getSimpleName();
}
+ @Override
+ public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
+ return accept(file);
+ }
+
+ @Override
+ public FileVisitResult visitFileFailed(final Path file, final IOException exc) throws IOException {
+ return FileVisitResult.CONTINUE;
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/AgeFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/AgeFileFilter.java
index c3ddbab..17dc0b1 100644
--- a/src/main/java/org/apache/commons/io/filefilter/AgeFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/AgeFileFilter.java
@@ -17,28 +17,52 @@
package org.apache.commons.io.filefilter;
import java.io.File;
+import java.io.IOException;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
import java.util.Date;
import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.file.PathUtils;
/**
- * Filters files based on a cutoff time, can filter either newer
- * files or files equal to or older.
+ * Filters files based on a cutoff time, can filter either newer files or files equal to or older.
* <p>
- * For example, to print all files and directories in the
- * current directory older than one day:
- *
+ * For example, to print all files and directories in the current directory older than one day:
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
- * File dir = new File(".");
+ * Path dir = Paths.get(".");
* // We are interested in files older than one day
* long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
- * String[] files = dir.list( new AgeFileFilter(cutoff) );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(new AgeFileFilter(cutoff));
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
+ * <h2>Using NIO</h2>
+ * <pre>
+ * Path dir = Paths.get(".");
+ * // We are interested in files older than one day
+ * long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+ * AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new AgeFileFilter(cutoff));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
* @see FileFilterUtils#ageFileFilter(Date)
* @see FileFilterUtils#ageFileFilter(File)
* @see FileFilterUtils#ageFileFilter(long)
@@ -58,69 +82,64 @@ public class AgeFileFilter extends AbstractFileFilter implements Serializable {
private final long cutoffMillis;
/**
- * Constructs a new age file filter for files older than (at or before)
- * a certain cutoff date.
+ * Constructs a new age file filter for files older than (at or before) a certain cutoff date.
*
- * @param cutoffDate the threshold age of the files
+ * @param cutoffDate the threshold age of the files
*/
public AgeFileFilter(final Date cutoffDate) {
this(cutoffDate, true);
}
/**
- * Constructs a new age file filter for files on any one side
- * of a certain cutoff date.
+ * Constructs a new age file filter for files on any one side of a certain cutoff date.
*
- * @param cutoffDate the threshold age of the files
- * @param acceptOlder if true, older files (at or before the cutoff)
- * are accepted, else newer ones (after the cutoff).
+ * @param cutoffDate the threshold age of the files
+ * @param acceptOlder if true, older files (at or before the cutoff) are accepted, else newer ones (after the
+ * cutoff).
*/
public AgeFileFilter(final Date cutoffDate, final boolean acceptOlder) {
this(cutoffDate.getTime(), acceptOlder);
}
/**
- * Constructs a new age file filter for files older than (at or before)
- * a certain File (whose last modification time will be used as reference).
+ * Constructs a new age file filter for files older than (at or before) a certain File (whose last modification time
+ * will be used as reference).
*
- * @param cutoffReference the file whose last modification
- * time is used as the threshold age of the files
+ * @param cutoffReference the file whose last modification time is used as the threshold age of the files
*/
public AgeFileFilter(final File cutoffReference) {
this(cutoffReference, true);
}
/**
- * Constructs a new age file filter for files on any one side
- * of a certain File (whose last modification time will be used as
- * reference).
+ * Constructs a new age file filter for files on any one side of a certain File (whose last modification time will
+ * be used as reference).
*
- * @param cutoffReference the file whose last modification
- * time is used as the threshold age of the files
- * @param acceptOlder if true, older files (at or before the cutoff)
- * are accepted, else newer ones (after the cutoff).
+ * @param cutoffReference the file whose last modification time is used as the threshold age of the files
+ * @param acceptOlder if true, older files (at or before the cutoff) are accepted, else newer ones (after the
+ * cutoff).
*/
public AgeFileFilter(final File cutoffReference, final boolean acceptOlder) {
this(cutoffReference.lastModified(), acceptOlder);
}
/**
- * Constructs a new age file filter for files equal to or older than
- * a certain cutoff
+ * Constructs a new age file filter for files equal to or older than a certain cutoff
*
- * @param cutoffMillis The cutoff time threshold measured in milliseconds since the epoch (00:00:00 GMT, January 1, 1970).
+ * @param cutoffMillis The cutoff time threshold measured in milliseconds since the epoch (00:00:00 GMT, January 1,
+ * 1970).
*/
public AgeFileFilter(final long cutoffMillis) {
this(cutoffMillis, true);
}
/**
- * Constructs a new age file filter for files on any one side
- * of a certain cutoff.
+ * Constructs a new age file filter for files on any one side of a certain cutoff.
*
- * @param cutoffMillis The cutoff time threshold measured in milliseconds since the epoch (00:00:00 GMT, January 1, 1970).
- * @param acceptOlder if true, older files (at or before the cutoff)
- * are accepted, else newer ones (after the cutoff).
+ * @param cutoffMillis The cutoff time threshold measured in milliseconds since the epoch (00:00:00 GMT, January 1,
+ * 1970).
+ * @param acceptOlder if true, older files (at or before the cutoff) are accepted, else newer ones (after the
+ * cutoff).
*/
public AgeFileFilter(final long cutoffMillis, final boolean acceptOlder) {
this.acceptOlder = acceptOlder;
@@ -128,16 +147,13 @@ public class AgeFileFilter extends AbstractFileFilter implements Serializable {
}
/**
- * Checks to see if the last modification of the file matches cutoff
- * favorably.
+ * Checks to see if the last modification of the file matches cutoff favorably.
* <p>
- * If last modification time equals cutoff and newer files are required,
- * file <b>IS NOT</b> selected.
- * If last modification time equals cutoff and older files are required,
- * file <b>IS</b> selected.
+ * If last modification time equals cutoff and newer files are required, file <b>IS NOT</b> selected. If last
+ * modification time equals cutoff and older files are required, file <b>IS</b> selected.
* </p>
*
- * @param file the File to check
+ * @param file the File to check
* @return true if the file name matches
*/
@Override
@@ -147,6 +163,28 @@ public class AgeFileFilter extends AbstractFileFilter implements Serializable {
}
/**
+ * Checks to see if the last modification of the file matches cutoff favorably.
+ * <p>
+ * If last modification time equals cutoff and newer files are required, file <b>IS NOT</b> selected. If last
+ * modification time equals cutoff and older files are required, file <b>IS</b> selected.
+ * </p>
+ *
+ * @param file the File to check
+ * @return true if the file name matches
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ boolean newer;
+ try {
+ newer = PathUtils.isNewer(file, cutoffMillis);
+ } catch (final IOException e) {
+ return handle(e);
+ }
+ return toFileVisitResult(acceptOlder != newer);
+ }
+
+ /**
* Provide a String representation of this file filter.
*
* @return a String representation
diff --git a/src/main/java/org/apache/commons/io/filefilter/AndFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/AndFileFilter.java
index 7d889ca..c863e46 100644
--- a/src/main/java/org/apache/commons/io/filefilter/AndFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/AndFileFilter.java
@@ -17,8 +17,12 @@
package org.apache.commons.io.filefilter;
import java.io.File;
+import java.io.IOException;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@@ -30,8 +34,6 @@ import java.util.List;
* {@code false}.
*
* @since 1.0
- *
- *
* @see FileFilterUtils#and(IOFileFilter...)
*/
public class AndFileFilter
@@ -53,10 +55,10 @@ public class AndFileFilter
}
/**
- * Constructs a new file filter that ANDs the result of two other filters.
+ * Constructs a new file filter that ANDs the result of other filters.
*
- * @param filter1 the first filter, must not be null
- * @param filter2 the second filter, must not be null
+ * @param filter1 the first filter, must second be null
+ * @param filter2 the first filter, must not be null
* @throws IllegalArgumentException if either filter is null
*/
public AndFileFilter(final IOFileFilter filter1, final IOFileFilter filter2) {
@@ -64,8 +66,24 @@ public class AndFileFilter
throw new IllegalArgumentException("The filters must not be null");
}
this.fileFilters = new ArrayList<>(2);
- addFileFilter(filter1);
- addFileFilter(filter2);
+ this.fileFilters.add(filter1);
+ this.fileFilters.add(filter2);
+ }
+
+ /**
+ * Constructs a new file filter that ANDs the result of other filters.
+ *
+ * @param filter1 the first filter, must not be null
+ * @param filters more filters, must not be null
+ * @throws IllegalArgumentException if either filter is null
+ */
+ public AndFileFilter(final IOFileFilter filter1, final IOFileFilter... filters) {
+ if (filter1 == null || filters == null) {
+ throw new IllegalArgumentException("The filters must not be null");
+ }
+ this.fileFilters = new ArrayList<>(filters.length + 1);
+ this.fileFilters.add(filter1);
+ this.fileFilters.addAll(Arrays.asList(filters));
}
/**
@@ -88,7 +106,7 @@ public class AndFileFilter
*/
@Override
public boolean accept(final File file) {
- if (this.fileFilters.isEmpty()) {
+ if (isEmpty()) {
return false;
}
for (final IOFileFilter fileFilter : fileFilters) {
@@ -104,7 +122,7 @@ public class AndFileFilter
*/
@Override
public boolean accept(final File file, final String name) {
- if (this.fileFilters.isEmpty()) {
+ if (isEmpty()) {
return false;
}
for (final IOFileFilter fileFilter : fileFilters) {
@@ -117,6 +135,40 @@ public class AndFileFilter
/**
* {@inheritDoc}
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) throws IOException {
+ if (isEmpty()) {
+ return FileVisitResult.TERMINATE;
+ }
+ for (final IOFileFilter fileFilter : fileFilters) {
+ if (fileFilter.accept(file) != FileVisitResult.CONTINUE) {
+ return FileVisitResult.TERMINATE;
+ }
+ }
+ return FileVisitResult.CONTINUE;
+ }
+
+ /**
+ * {@inheritDoc}
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file, final Path name) throws IOException {
+ if (isEmpty()) {
+ return FileVisitResult.TERMINATE;
+ }
+ for (final IOFileFilter fileFilter : fileFilters) {
+ if (fileFilter.accept(file, name) != FileVisitResult.CONTINUE) {
+ return FileVisitResult.TERMINATE;
+ }
+ }
+ return FileVisitResult.CONTINUE;
+ }
+
+ /**
+ * {@inheritDoc}
*/
@Override
public void addFileFilter(final IOFileFilter ioFileFilter) {
@@ -131,6 +183,10 @@ public class AndFileFilter
return Collections.unmodifiableList(this.fileFilters);
}
+ private boolean isEmpty() {
+ return this.fileFilters.isEmpty();
+ }
+
/**
* {@inheritDoc}
*/
@@ -158,14 +214,12 @@ public class AndFileFilter
final StringBuilder buffer = new StringBuilder();
buffer.append(super.toString());
buffer.append("(");
- if (fileFilters != null) {
- for (int i = 0; i < fileFilters.size(); i++) {
- if (i > 0) {
- buffer.append(",");
- }
- final Object filter = fileFilters.get(i);
- buffer.append(filter == null ? "null" : filter.toString());
+ for (int i = 0; i < fileFilters.size(); i++) {
+ if (i > 0) {
+ buffer.append(",");
}
+ final Object filter = fileFilters.get(i);
+ buffer.append(filter == null ? "null" : filter.toString());
}
buffer.append(")");
return buffer.toString();
diff --git a/src/main/java/org/apache/commons/io/filefilter/CanExecuteFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/CanExecuteFileFilter.java
index 32fd43d..05b1a5b 100644
--- a/src/main/java/org/apache/commons/io/filefilter/CanExecuteFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/CanExecuteFileFilter.java
@@ -18,35 +18,39 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
/**
* This filter accepts <code>File</code>s that can be executed.
* <p>
* Example, showing how to print out a list of the
* current directory's <i>executable</i> files:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( CanExecuteFileFilter.CAN_EXECUTE );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(CanExecuteFileFilter.CAN_EXECUTE);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
* <p>
* Example, showing how to print out a list of the
- * current directory's <i>un-executable</i> files:
+ * current directory's <i>non-executable</i> files:
+ * </p>
*
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( CanExecuteFileFilter.CANNOT_EXECUTE );
- * for ( int i = 0; i < files.length; i++ ) {
+ * String[] files = dir.list(CanExecuteFileFilter.CANNOT_EXECUTE);
+ * for (int i = 0; i < files.length; i++) {
* System.out.println(files[i]);
* }
* </pre>
*
* @since 2.7
- *
*/
public class CanExecuteFileFilter extends AbstractFileFilter implements Serializable {
@@ -54,7 +58,7 @@ public class CanExecuteFileFilter extends AbstractFileFilter implements Serializ
public static final IOFileFilter CAN_EXECUTE = new CanExecuteFileFilter();
/** Singleton instance of not <i>executable</i> filter */
- public static final IOFileFilter CANNOT_EXECUTE = new NotFileFilter(CAN_EXECUTE);
+ public static final IOFileFilter CANNOT_EXECUTE = CAN_EXECUTE.not();
private static final long serialVersionUID = 3179904805251622989L;
@@ -62,6 +66,7 @@ public class CanExecuteFileFilter extends AbstractFileFilter implements Serializ
* Restrictive constructor.
*/
protected CanExecuteFileFilter() {
+ // empty.
}
/**
@@ -75,4 +80,16 @@ public class CanExecuteFileFilter extends AbstractFileFilter implements Serializ
return file.canExecute();
}
+ /**
+ * Checks to see if the file can be executed.
+ *
+ * @param file the File to check.
+ * @return {@code true} if the file can be executed, otherwise {@code false}.
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return toFileVisitResult(Files.isExecutable(file));
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/CanReadFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/CanReadFileFilter.java
index dcd7a7f..9776bdb 100644
--- a/src/main/java/org/apache/commons/io/filefilter/CanReadFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/CanReadFileFilter.java
@@ -18,47 +18,47 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
/**
* This filter accepts <code>File</code>s that can be read.
* <p>
- * Example, showing how to print out a list of the
- * current directory's <i>readable</i> files:
- *
+ * Example, showing how to print out a list of the current directory's <i>readable</i> files:
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( CanReadFileFilter.CAN_READ );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(CanReadFileFilter.CAN_READ);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
* <p>
- * Example, showing how to print out a list of the
- * current directory's <i>un-readable</i> files:
+ * Example, showing how to print out a list of the current directory's <i>un-readable</i> files:
*
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( CanReadFileFilter.CANNOT_READ );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(CanReadFileFilter.CANNOT_READ);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
* <p>
- * Example, showing how to print out a list of the
- * current directory's <i>read-only</i> files:
+ * Example, showing how to print out a list of the current directory's <i>read-only</i> files:
*
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( CanReadFileFilter.READ_ONLY );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(CanReadFileFilter.READ_ONLY);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
* @since 1.3
- *
*/
public class CanReadFileFilter extends AbstractFileFilter implements Serializable {
@@ -66,11 +66,10 @@ public class CanReadFileFilter extends AbstractFileFilter implements Serializabl
public static final IOFileFilter CAN_READ = new CanReadFileFilter();
/** Singleton instance of not <i>readable</i> filter */
- public static final IOFileFilter CANNOT_READ = new NotFileFilter(CAN_READ);
+ public static final IOFileFilter CANNOT_READ = CAN_READ.not();
/** Singleton instance of <i>read-only</i> filter */
- public static final IOFileFilter READ_ONLY = new AndFileFilter(CAN_READ,
- CanWriteFileFilter.CANNOT_WRITE);
+ public static final IOFileFilter READ_ONLY = CAN_READ.and(CanWriteFileFilter.CANNOT_WRITE);
private static final long serialVersionUID = 3179904805251622989L;
@@ -83,13 +82,24 @@ public class CanReadFileFilter extends AbstractFileFilter implements Serializabl
/**
* Checks to see if the file can be read.
*
- * @param file the File to check.
- * @return {@code true} if the file can be
- * read, otherwise {@code false}.
+ * @param file the File to check.
+ * @return {@code true} if the file can be read, otherwise {@code false}.
*/
@Override
public boolean accept(final File file) {
return file.canRead();
}
+ /**
+ * Checks to see if the file can be read.
+ *
+ * @param file the File to check.
+ * @return {@code true} if the file can be read, otherwise {@code false}.
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return toFileVisitResult(Files.isReadable(file));
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/CanWriteFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/CanWriteFileFilter.java
index e1a41b2..e69de26 100644
--- a/src/main/java/org/apache/commons/io/filefilter/CanWriteFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/CanWriteFileFilter.java
@@ -18,39 +18,39 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
/**
* This filter accepts <code>File</code>s that can be written to.
* <p>
- * Example, showing how to print out a list of the
- * current directory's <i>writable</i> files:
- *
+ * Example, showing how to print out a list of the current directory's <i>writable</i> files:
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( CanWriteFileFilter.CAN_WRITE );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(CanWriteFileFilter.CAN_WRITE);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
* <p>
- * Example, showing how to print out a list of the
- * current directory's <i>un-writable</i> files:
+ * Example, showing how to print out a list of the current directory's <i>un-writable</i> files:
*
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( CanWriteFileFilter.CANNOT_WRITE );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(CanWriteFileFilter.CANNOT_WRITE);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
* <p>
- * <b>N.B.</b> For read-only files, use
- * <code>CanReadFileFilter.READ_ONLY</code>.
+ * <b>N.B.</b> For read-only files, use <code>CanReadFileFilter.READ_ONLY</code>.
*
* @since 1.3
- *
*/
public class CanWriteFileFilter extends AbstractFileFilter implements Serializable {
@@ -58,7 +58,7 @@ public class CanWriteFileFilter extends AbstractFileFilter implements Serializab
public static final IOFileFilter CAN_WRITE = new CanWriteFileFilter();
/** Singleton instance of not <i>writable</i> filter */
- public static final IOFileFilter CANNOT_WRITE = new NotFileFilter(CAN_WRITE);
+ public static final IOFileFilter CANNOT_WRITE = CAN_WRITE.not();
private static final long serialVersionUID = 5132005214688990379L;
@@ -71,13 +71,24 @@ public class CanWriteFileFilter extends AbstractFileFilter implements Serializab
/**
* Checks to see if the file can be written to.
*
- * @param file the File to check
- * @return {@code true} if the file can be
- * written to, otherwise {@code false}.
+ * @param file the File to check
+ * @return {@code true} if the file can be written to, otherwise {@code false}.
*/
@Override
public boolean accept(final File file) {
return file.canWrite();
}
+ /**
+ * Checks to see if the file can be written to.
+ *
+ * @param file the File to check
+ * @return {@code true} if the file can be written to, otherwise {@code false}.
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return toFileVisitResult(Files.isWritable(file));
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/DelegateFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/DelegateFileFilter.java
index 380a2ef..88f4ea4 100644
--- a/src/main/java/org/apache/commons/io/filefilter/DelegateFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/DelegateFileFilter.java
@@ -25,8 +25,6 @@ import java.io.Serializable;
* This class turns a Java FileFilter or FilenameFilter into an IO FileFilter.
*
* @since 1.0
- *
- *
* @see FileFilterUtils#asFileFilter(FileFilter)
* @see FileFilterUtils#asFileFilter(FilenameFilter)
*/
diff --git a/src/main/java/org/apache/commons/io/filefilter/DirectoryFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/DirectoryFileFilter.java
index 2bf020b..8a88ca5 100644
--- a/src/main/java/org/apache/commons/io/filefilter/DirectoryFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/DirectoryFileFilter.java
@@ -18,30 +18,53 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
/**
* This filter accepts <code>File</code>s that are directories.
* <p>
* For example, here is how to print out a list of the current directory's subdirectories:
+ * </p>
+ * <h2>Using Classic IO</h2>
*
* <pre>
* File dir = new File(".");
* String[] files = dir.list(DirectoryFileFilter.INSTANCE);
- * for (int i = 0; i < files.length; i++) {
- * System.out.println(files[i]);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
- * @since 1.0
+ * <h2>Using NIO</h2>
*
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(DirectoryFileFilter.INSTANCE);
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
*
+ * @since 1.0
* @see FileFilterUtils#directoryFileFilter()
*/
public class DirectoryFileFilter extends AbstractFileFilter implements Serializable {
/**
* Singleton instance of directory filter.
- *
+ *
* @since 1.3
*/
public static final IOFileFilter DIRECTORY = new DirectoryFileFilter();
@@ -72,4 +95,16 @@ public class DirectoryFileFilter extends AbstractFileFilter implements Serializa
return file.isDirectory();
}
+ /**
+ * Checks to see if the file is a directory.
+ *
+ * @param file the File to check
+ * @return true if the file is a directory
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return toFileVisitResult(Files.isDirectory(file));
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/EmptyFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/EmptyFileFilter.java
index 2914951..71a89b8 100644
--- a/src/main/java/org/apache/commons/io/filefilter/EmptyFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/EmptyFileFilter.java
@@ -17,39 +17,62 @@
package org.apache.commons.io.filefilter;
import java.io.File;
+import java.io.IOException;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Stream;
/**
* This filter accepts files or directories that are empty.
* <p>
- * If the <code>File</code> is a directory it checks that
- * it contains no files.
+ * If the <code>File</code> is a directory it checks that it contains no files.
+ * </p>
* <p>
- * Example, showing how to print out a list of the
- * current directory's empty files/directories:
- *
+ * Example, showing how to print out a list of the current directory's empty files/directories:
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( EmptyFileFilter.EMPTY );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(EmptyFileFilter.EMPTY);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
* <p>
- * Example, showing how to print out a list of the
- * current directory's non-empty files/directories:
+ * Example, showing how to print out a list of the current directory's non-empty files/directories:
+ * </p>
*
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( EmptyFileFilter.NOT_EMPTY );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(EmptyFileFilter.NOT_EMPTY);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
- * @since 1.3
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(EmptyFileFilter.EMPTY);
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
*
+ * @since 1.3
*/
public class EmptyFileFilter extends AbstractFileFilter implements Serializable {
@@ -57,7 +80,7 @@ public class EmptyFileFilter extends AbstractFileFilter implements Serializable
public static final IOFileFilter EMPTY = new EmptyFileFilter();
/** Singleton instance of <i>not-empty</i> filter */
- public static final IOFileFilter NOT_EMPTY = new NotFileFilter(EMPTY);
+ public static final IOFileFilter NOT_EMPTY = EMPTY.not();
private static final long serialVersionUID = 3631422087512832211L;
@@ -70,9 +93,8 @@ public class EmptyFileFilter extends AbstractFileFilter implements Serializable
/**
* Checks to see if the file is empty.
*
- * @param file the file or directory to check
- * @return {@code true} if the file or directory
- * is <i>empty</i>, otherwise {@code false}.
+ * @param file the file or directory to check
+ * @return {@code true} if the file or directory is <i>empty</i>, otherwise {@code false}.
*/
@Override
public boolean accept(final File file) {
@@ -83,4 +105,25 @@ public class EmptyFileFilter extends AbstractFileFilter implements Serializable
return file.length() == 0;
}
+ /**
+ * Checks to see if the file is empty.
+ *
+ * @param file the file or directory to check
+ * @return {@code true} if the file or directory is <i>empty</i>, otherwise {@code false}.
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ try {
+ if (Files.isDirectory(file)) {
+ try (Stream<Path> stream = Files.list(file)) {
+ return toFileVisitResult(!stream.findFirst().isPresent());
+ }
+ }
+ return toFileVisitResult(Files.size(file) == 0);
+ } catch (final IOException e) {
+ return handle(e);
+ }
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/FalseFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/FalseFileFilter.java
index 47ad394..f19deae 100644
--- a/src/main/java/org/apache/commons/io/filefilter/FalseFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/FalseFileFilter.java
@@ -18,29 +18,30 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
/**
* A file filter that always returns false.
*
* @since 1.0
- *
- *
* @see FileFilterUtils#falseFileFilter()
*/
public class FalseFileFilter implements IOFileFilter, Serializable {
/**
* Singleton instance of false filter.
+ *
* @since 1.3
*/
+
public static final IOFileFilter FALSE = new FalseFileFilter();
/**
- * Singleton instance of false filter.
- * Please use the identical FalseFileFilter.FALSE constant.
- * The new name is more JDK 1.5 friendly as it doesn't clash with other
- * values when using static imports.
+ * Singleton instance of false filter. Please use the identical FalseFileFilter.FALSE constant. The new name is more
+ * JDK 1.5 friendly as it doesn't clash with other values when using static imports.
*/
public static final IOFileFilter INSTANCE = FALSE;
+
private static final long serialVersionUID = 6210271677940926200L;
/**
@@ -52,7 +53,7 @@ public class FalseFileFilter implements IOFileFilter, Serializable {
/**
* Returns false.
*
- * @param file the file to check (ignored)
+ * @param file the file to check (ignored)
* @return false
*/
@Override
@@ -63,8 +64,8 @@ public class FalseFileFilter implements IOFileFilter, Serializable {
/**
* Returns false.
*
- * @param dir the directory to check (ignored)
- * @param name the file name (ignored)
+ * @param dir the directory to check (ignored)
+ * @param name the file name (ignored)
* @return false
*/
@Override
@@ -72,4 +73,29 @@ public class FalseFileFilter implements IOFileFilter, Serializable {
return false;
}
+ /**
+ * Returns false.
+ *
+ * @param file the file to check (ignored)
+ * @return false
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return FileVisitResult.TERMINATE;
+ }
+
+ /**
+ * Returns false.
+ *
+ * @param dir the directory to check (ignored)
+ * @param name the file name (ignored)
+ * @return false
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path dir, final Path name) {
+ return FileVisitResult.TERMINATE;
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/FileFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/FileFileFilter.java
index e639b61..2223251 100644
--- a/src/main/java/org/apache/commons/io/filefilter/FileFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/FileFileFilter.java
@@ -18,23 +18,45 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
/**
* This filter accepts <code>File</code>s that are files (not directories).
* <p>
* For example, here is how to print out a list of the real files
* within the current directory:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( FileFileFilter.FILE );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(FileFileFilter.FILE);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
- * @since 1.3
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(FileFileFilter.FILE);
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
*
+ * @since 1.3
* @see FileFilterUtils#fileFileFilter()
*/
public class FileFileFilter extends AbstractFileFilter implements Serializable {
@@ -60,4 +82,16 @@ public class FileFileFilter extends AbstractFileFilter implements Serializable {
return file.isFile();
}
+ /**
+ * Checks to see if the file is a file.
+ *
+ * @param file the File to check
+ * @return true if the file is a file
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return toFileVisitResult(Files.isRegularFile(file));
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/FileFilterUtils.java b/src/main/java/org/apache/commons/io/filefilter/FileFilterUtils.java
index d7722c0..9ff5d9b 100644
--- a/src/main/java/org/apache/commons/io/filefilter/FileFilterUtils.java
+++ b/src/main/java/org/apache/commons/io/filefilter/FileFilterUtils.java
@@ -21,11 +21,16 @@ import java.io.FileFilter;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collection;
+import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
+import java.util.Objects;
import java.util.Set;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOCase;
@@ -36,7 +41,6 @@ import org.apache.commons.io.IOCase;
* every class you use.
*
* @since 1.0
- *
*/
public class FileFilterUtils {
@@ -223,10 +227,6 @@ public class FileFilterUtils {
* matches the provided filter.
* </p>
*
- * <p>
- * The {@link Set} returned by this method is not guaranteed to be thread safe.
- * </p>
- *
* <pre>
* Set<File> allFiles = ...
* Set<File> javaFiles = FileFilterUtils.filterSet(allFiles,
@@ -249,16 +249,34 @@ public class FileFilterUtils {
if (files == null) {
return FileUtils.EMPTY_FILE_ARRAY;
}
- final List<File> acceptedFiles = new ArrayList<>();
- for (final File file : files) {
- if (file == null) {
- throw new IllegalArgumentException("file array contains null");
- }
- if (filter.accept(file)) {
- acceptedFiles.add(file);
- }
+ return filterFiles(filter, Arrays.stream(files), Collectors.toList()).toArray(FileUtils.EMPTY_FILE_ARRAY);
+ }
+
+ /**
+ * <p>
+ * Applies an {@link IOFileFilter} to the provided {@link File} stream and collects the accepted files.
+ * </p>
+ *
+ * @param filter the filter to apply to the stream of files.
+ * @param stream the stream of files on which to apply the filter.
+ * @param collector how to collect the end result.
+ *
+ * @param <R> the return type.
+ * @param <A> the mutable accumulation type of the reduction operation (often hidden as an implementation detail)
+ * @return a subset of files from the stream that is accepted by the filter.
+ * @throws IllegalArgumentException if the filter is {@code null}.
+ */
+ private static <R, A> R filterFiles(final IOFileFilter filter, final Stream<File> stream,
+ final Collector<? super File, A, R> collector) {
+ //Objects.requireNonNull(filter, "filter");
+ Objects.requireNonNull(collector, "collector");
+ if (filter == null) {
+ throw new IllegalArgumentException("file filter is null");
+ }
+ if (stream == null) {
+ return Stream.<File>empty().collect(collector);
}
- return acceptedFiles.toArray(FileUtils.EMPTY_FILE_ARRAY);
+ return stream.filter(filter::accept).collect(collector);
}
/**
@@ -294,46 +312,6 @@ public class FileFilterUtils {
/**
* <p>
* Applies an {@link IOFileFilter} to the provided {@link File}
- * objects and appends the accepted files to the other supplied collection.
- * </p>
- *
- * <pre>
- * List<File> files = ...
- * List<File> directories = FileFilterUtils.filterList(files,
- * FileFilterUtils.sizeFileFilter(FileUtils.FIFTY_MB),
- * new ArrayList<File>());
- * </pre>
- * @param filter the filter to apply to the collection of files.
- * @param files the collection of files to apply the filter to.
- * @param acceptedFiles the list of files to add accepted files to.
- *
- * @param <T> the type of the file collection.
- * @return a subset of <code>files</code> that is accepted by the
- * file filter.
- * @throws IllegalArgumentException if the filter is {@code null}
- * or <code>files</code> contains a {@code null} value.
- */
- private static <T extends Collection<File>> T filter(final IOFileFilter filter,
- final Iterable<File> files, final T acceptedFiles) {
- if (filter == null) {
- throw new IllegalArgumentException("file filter is null");
- }
- if (files != null) {
- for (final File file : files) {
- if (file == null) {
- throw new IllegalArgumentException("file collection contains null");
- }
- if (filter.accept(file)) {
- acceptedFiles.add(file);
- }
- }
- }
- return acceptedFiles;
- }
-
- /**
- * <p>
- * Applies an {@link IOFileFilter} to the provided {@link File}
* objects. The resulting list is a subset of the original files that
* matches the provided filter.
* </p>
@@ -382,11 +360,13 @@ public class FileFilterUtils {
* @return a subset of <code>files</code> that is accepted by the
* file filter.
* @throws IllegalArgumentException if the filter is {@code null}
- * or <code>files</code> contains a {@code null} value.
* @since 2.0
*/
public static List<File> filterList(final IOFileFilter filter, final Iterable<File> files) {
- return filter(filter, files, new ArrayList<>());
+ if (files == null) {
+ return Collections.emptyList();
+ }
+ return filterFiles(filter, StreamSupport.stream(files.spliterator(), false), Collectors.toList());
}
/**
@@ -441,12 +421,14 @@ public class FileFilterUtils {
* @return a subset of <code>files</code> that is accepted by the
* file filter.
* @throws IllegalArgumentException if the filter is {@code null}
- * or <code>files</code> contains a {@code null} value.
*
* @since 2.0
*/
public static Set<File> filterSet(final IOFileFilter filter, final Iterable<File> files) {
- return filter(filter, files, new HashSet<>());
+ if (files == null) {
+ return Collections.emptySet();
+ }
+ return filterFiles(filter, StreamSupport.stream(files.spliterator(), false), Collectors.toSet());
}
/**
@@ -555,7 +537,7 @@ public class FileFilterUtils {
if (filter == null) {
return DirectoryFileFilter.DIRECTORY;
}
- return new AndFileFilter(DirectoryFileFilter.DIRECTORY, filter);
+ return DirectoryFileFilter.DIRECTORY.and(filter);
}
/**
@@ -570,7 +552,7 @@ public class FileFilterUtils {
if (filter == null) {
return FileFileFilter.FILE;
}
- return new AndFileFilter(FileFileFilter.FILE, filter);
+ return FileFileFilter.FILE.and(filter);
}
/**
@@ -618,7 +600,7 @@ public class FileFilterUtils {
* @see NotFileFilter
*/
public static IOFileFilter notFileFilter(final IOFileFilter filter) {
- return new NotFileFilter(filter);
+ return filter.not();
}
/**
@@ -714,7 +696,7 @@ public class FileFilterUtils {
public static IOFileFilter sizeRangeFileFilter(final long minSizeInclusive, final long maxSizeInclusive ) {
final IOFileFilter minimumFilter = new SizeFileFilter(minSizeInclusive, true);
final IOFileFilter maximumFilter = new SizeFileFilter(maxSizeInclusive + 1L, false);
- return new AndFileFilter(minimumFilter, maximumFilter);
+ return minimumFilter.and(maximumFilter);
}
/**
diff --git a/src/main/java/org/apache/commons/io/filefilter/HiddenFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/HiddenFileFilter.java
index 2145274..6d4812f 100644
--- a/src/main/java/org/apache/commons/io/filefilter/HiddenFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/HiddenFileFilter.java
@@ -17,36 +17,60 @@
package org.apache.commons.io.filefilter;
import java.io.File;
+import java.io.IOException;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
/**
* This filter accepts <code>File</code>s that are hidden.
* <p>
* Example, showing how to print out a list of the
* current directory's <i>hidden</i> files:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( HiddenFileFilter.HIDDEN );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(HiddenFileFilter.HIDDEN);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
* <p>
* Example, showing how to print out a list of the
* current directory's <i>visible</i> (i.e. not hidden) files:
+ * </p>
*
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( HiddenFileFilter.VISIBLE );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(HiddenFileFilter.VISIBLE);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
- * @since 1.3
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(HiddenFileFilter.HIDDEN);
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
*
+ * @since 1.3
*/
public class HiddenFileFilter extends AbstractFileFilter implements Serializable {
@@ -56,7 +80,7 @@ public class HiddenFileFilter extends AbstractFileFilter implements Serializable
private static final long serialVersionUID = 8930842316112759062L;
/** Singleton instance of <i>visible</i> filter */
- public static final IOFileFilter VISIBLE = new NotFileFilter(HIDDEN);
+ public static final IOFileFilter VISIBLE = HIDDEN.not();
/**
* Restrictive constructor.
@@ -76,4 +100,21 @@ public class HiddenFileFilter extends AbstractFileFilter implements Serializable
return file.isHidden();
}
+ /**
+ * Checks to see if the file is hidden.
+ *
+ * @param file the File to check
+ * @return {@code true} if the file is
+ * <i>hidden</i>, otherwise {@code false}.
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ try {
+ return toFileVisitResult(Files.isHidden(file));
+ } catch (final IOException e) {
+ return handle(e);
+ }
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/IOFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/IOFileFilter.java
index 068d041..aa67949 100644
--- a/src/main/java/org/apache/commons/io/filefilter/IOFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/IOFileFilter.java
@@ -19,14 +19,16 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
/**
- * An interface which brings the FileFilter and FilenameFilter
- * interfaces together.
+ * An interface which brings the FileFilter, FilenameFilter, and PathFilter interfaces together.
*
* @since 1.0
*/
-public interface IOFileFilter extends FileFilter, FilenameFilter {
+public interface IOFileFilter extends FileFilter, FilenameFilter, PathFilter {
/**
* An empty String array.
@@ -38,7 +40,8 @@ public interface IOFileFilter extends FileFilter, FilenameFilter {
* <p>
* Defined in {@link java.io.FileFilter}.
* </p>
- * @param file the File to check
+ *
+ * @param file the File to check
* @return true if this file matches the test
*/
@Override
@@ -49,11 +52,71 @@ public interface IOFileFilter extends FileFilter, FilenameFilter {
* <p>
* Defined in {@link java.io.FilenameFilter}.
* </p>
- * @param dir the directory File to check
- * @param name the file name within the directory to check
+ *
+ * @param dir the directory File to check
+ * @param name the file name within the directory to check
* @return true if this file matches the test
*/
@Override
boolean accept(File dir, String name);
+ /**
+ * Checks to see if the Path should be accepted by this filter.
+ *
+ * @param path the Path to check
+ * @return true if this path matches the test
+ * @throws IOException if an I/O error occurs
+ * @since 2.9.0
+ */
+ @Override
+ default FileVisitResult accept(final Path path) throws IOException {
+ return AbstractFileFilter.toFileVisitResult(accept(path.toFile()));
+ }
+
+ /**
+ * Checks to see if the File should be accepted by this filter.
+ *
+ * @param path the directory File to check
+ * @param name the file name within the directory to check
+ * @return true if this file matches the test
+ * @throws IOException if an I/O error occurs
+ * @since 2.9.0
+ */
+ @Override
+ default FileVisitResult accept(final Path path, final Path name) throws IOException {
+ return AbstractFileFilter.toFileVisitResult(accept(path.toFile(), name.toString()));
+ }
+
+ /**
+ * Creates a new "and" filter with this filter and the given filters.
+ *
+ * @param fileFilter the filters to "and".
+ * @return a new filter
+ * @since 2.9.0
+ */
+ default AndFileFilter and(final IOFileFilter... fileFilter) {
+ return new AndFileFilter(this, fileFilter);
+ }
+
+ /**
+ * Creates a new "not" filter with this filter.
+ *
+ * @return a new filter
+ * @since 2.9.0
+ */
+ default NotFileFilter not() {
+ return new NotFileFilter(this);
+ }
+
+ /**
+ * Creates a new "or" filter with this filter and the given filters.
+ *
+ * @param fileFilter the filters to "or".
+ * @return a new filter
+ * @since 2.9.0
+ */
+ default OrFileFilter or(final IOFileFilter... fileFilter) {
+ return new OrFileFilter(this, fileFilter);
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/MagicNumberFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/MagicNumberFileFilter.java
index 88e3347..aec6051 100644
--- a/src/main/java/org/apache/commons/io/filefilter/MagicNumberFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/MagicNumberFileFilter.java
@@ -20,7 +20,12 @@ import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.Serializable;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
import java.util.Arrays;
/**
@@ -30,7 +35,7 @@ import java.util.Arrays;
* For instance, all Java class files begin with the bytes
* <code>0xCAFEBABE</code>.
* </p>
- *
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
* MagicNumberFileFilter javaClassFileFilter =
@@ -57,6 +62,24 @@ import java.util.Arrays;
* System.out.println(tarFile);
* }
* </pre>
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(MagicNumberFileFilter("ustar", 257));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
*
* @since 2.0
* @see FileFilterUtils#magicNumberFileFilter(byte[])
@@ -252,6 +275,43 @@ public class MagicNumberFileFilter extends AbstractFileFilter implements
}
/**
+ * <p>
+ * Accepts the provided file if the file contains the file filter's magic
+ * number at the specified offset.
+ * </p>
+ *
+ * <p>
+ * If any {@link IOException}s occur while reading the file, the file will
+ * be rejected.
+ * </p>
+ *
+ * @param file the file to accept or reject.
+ *
+ * @return {@code true} if the file contains the filter's magic number
+ * at the specified offset, {@code false} otherwise.
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ if (file != null && Files.isRegularFile(file) && Files.isReadable(file)) {
+ try {
+ try (final FileChannel fileChannel = FileChannel.open(file)) {
+ final ByteBuffer byteBuffer = ByteBuffer.allocate(this.magicNumbers.length);
+ final int read = fileChannel.read(byteBuffer);
+ if (read != magicNumbers.length) {
+ return FileVisitResult.TERMINATE;
+ }
+ return toFileVisitResult(Arrays.equals(this.magicNumbers, byteBuffer.array()));
+ }
+ }
+ catch (final IOException ioe) {
+ // Do nothing, fall through and do not accept file
+ }
+ }
+ return FileVisitResult.TERMINATE;
+ }
+
+ /**
* Returns a String representation of the file filter, which includes the
* magic number bytes and byte offset.
*
diff --git a/src/main/java/org/apache/commons/io/filefilter/NameFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/NameFileFilter.java
index 9dcde3b..b3a12a6 100644
--- a/src/main/java/org/apache/commons/io/filefilter/NameFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/NameFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
import java.util.List;
import org.apache.commons.io.IOCase;
@@ -27,25 +29,46 @@ import org.apache.commons.io.IOCase;
* <p>
* For example, to print all files and directories in the
* current directory whose name is <code>Test</code>:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( new NameFileFilter("Test") );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(new NameFileFilter("Test"));
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
- * @since 1.0
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new NameFileFilter("Test"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
*
+ * @since 1.0
* @see FileFilterUtils#nameFileFilter(String)
* @see FileFilterUtils#nameFileFilter(String, IOCase)
*/
public class NameFileFilter extends AbstractFileFilter implements Serializable {
private static final long serialVersionUID = 176844364689077340L;
+
/** The file names to search for */
private final String[] names;
+
/** Whether the comparison is case sensitive. */
private final IOCase caseSensitivity;
@@ -130,7 +153,6 @@ public class NameFileFilter extends AbstractFileFilter implements Serializable {
this.caseSensitivity = caseSensitivity == null ? IOCase.SENSITIVE : caseSensitivity;
}
- //-----------------------------------------------------------------------
/**
* Checks to see if the file name matches.
*
@@ -139,13 +161,7 @@ public class NameFileFilter extends AbstractFileFilter implements Serializable {
*/
@Override
public boolean accept(final File file) {
- final String name = file.getName();
- for (final String name2 : this.names) {
- if (caseSensitivity.checkEquals(name, name2)) {
- return true;
- }
- }
- return false;
+ return acceptBaseName(file.getName());
}
/**
@@ -157,8 +173,36 @@ public class NameFileFilter extends AbstractFileFilter implements Serializable {
*/
@Override
public boolean accept(final File dir, final String name) {
- for (final String name2 : names) {
- if (caseSensitivity.checkEquals(name, name2)) {
+ return acceptBaseName(name);
+ }
+
+ /**
+ * Checks to see if the file name matches.
+ *
+ * @param dir the File directory (ignored)
+ * @param name the file name
+ * @return true if the file name matches
+ */
+ @Override
+ public FileVisitResult accept(final Path dir, final Path name) {
+ return toFileVisitResult(acceptBaseName(dir.getFileName().toString()));
+ }
+
+ /**
+ * Checks to see if the file name matches.
+ *
+ * @param file the File to check
+ * @return true if the file name matches
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return toFileVisitResult(acceptBaseName(file.getFileName().toString()));
+ }
+
+ private boolean acceptBaseName(final String baseName) {
+ for (final String testName : names) {
+ if (caseSensitivity.checkEquals(baseName, testName)) {
return true;
}
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/NotFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/NotFileFilter.java
index 3a76d2e..c6dfa5a 100644
--- a/src/main/java/org/apache/commons/io/filefilter/NotFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/NotFileFilter.java
@@ -17,18 +17,21 @@
package org.apache.commons.io.filefilter;
import java.io.File;
+import java.io.IOException;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
/**
* This filter produces a logical NOT of the filters specified.
*
* @since 1.0
- *
* @see FileFilterUtils#notFileFilter(IOFileFilter)
*/
public class NotFileFilter extends AbstractFileFilter implements Serializable {
private static final long serialVersionUID = 6131563330944994230L;
+
/** The filter */
private final IOFileFilter filter;
@@ -69,6 +72,38 @@ public class NotFileFilter extends AbstractFileFilter implements Serializable {
}
/**
+ * Returns the logical NOT of the underlying filter's return value for the same File.
+ *
+ * @param file the File to check
+ * @return true if the filter returns false
+ * @throws IOException if an I/O error occurs
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) throws IOException {
+ return not(filter.accept(file));
+ }
+
+ /**
+ * Returns the logical NOT of the underlying filter's return value for the same arguments.
+ *
+ * @param file the File directory
+ * @param name the file name
+ * @return true if the filter returns false
+ * @throws IOException if an I/O error occurs
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file, final Path name) throws IOException {
+ return not(filter.accept(file, name));
+ }
+
+ private FileVisitResult not(final FileVisitResult accept) {
+ return accept == FileVisitResult.CONTINUE ? FileVisitResult.TERMINATE
+ : FileVisitResult.CONTINUE;
+ }
+
+ /**
* Provide a String representation of this file filter.
*
* @return a String representation
diff --git a/src/main/java/org/apache/commons/io/filefilter/OrFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/OrFileFilter.java
index 85b7efd..fd4c73e 100644
--- a/src/main/java/org/apache/commons/io/filefilter/OrFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/OrFileFilter.java
@@ -17,8 +17,12 @@
package org.apache.commons.io.filefilter;
import java.io.File;
+import java.io.IOException;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@@ -28,7 +32,6 @@ import java.util.List;
* file filter list stops when the first filter returns {@code true}.
*
* @since 1.0
- *
* @see FileFilterUtils#or(IOFileFilter...)
*/
public class OrFileFilter extends AbstractFileFilter implements ConditionalFileFilter, Serializable {
@@ -48,7 +51,7 @@ public class OrFileFilter extends AbstractFileFilter implements ConditionalFileF
}
/**
- * Constructs a new file filter that ORs the result of two other filters.
+ * Constructs a new file filter that ORs the result of other filters.
*
* @param filter1 the first filter, must not be null
* @param filter2 the second filter, must not be null
@@ -59,8 +62,24 @@ public class OrFileFilter extends AbstractFileFilter implements ConditionalFileF
throw new IllegalArgumentException("The filters must not be null");
}
this.fileFilters = new ArrayList<>(2);
- addFileFilter(filter1);
- addFileFilter(filter2);
+ this.fileFilters.add(filter1);
+ this.fileFilters.add(filter2);
+ }
+
+ /**
+ * Constructs a new file filter that ORs the result of other filters.
+ *
+ * @param filter1 the first filter, must not be null
+ * @param filters more filter, must not be null
+ * @throws IllegalArgumentException if either filter is null
+ */
+ public OrFileFilter(final IOFileFilter filter1, final IOFileFilter... filters) {
+ if (filter1 == null || filters == null) {
+ throw new IllegalArgumentException("The filters must not be null");
+ }
+ this.fileFilters = new ArrayList<>(filters.length + 1);
+ this.fileFilters.add(filter1);
+ this.fileFilters.addAll(Arrays.asList(filters));
}
/**
@@ -107,6 +126,32 @@ public class OrFileFilter extends AbstractFileFilter implements ConditionalFileF
* {@inheritDoc}
*/
@Override
+ public FileVisitResult accept(final Path file) throws IOException {
+ for (final IOFileFilter fileFilter : fileFilters) {
+ if (fileFilter.accept(file) == FileVisitResult.CONTINUE) {
+ return FileVisitResult.CONTINUE;
+ }
+ }
+ return FileVisitResult.TERMINATE;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public FileVisitResult accept(final Path file, final Path name) throws IOException {
+ for (final IOFileFilter fileFilter : fileFilters) {
+ if (fileFilter.accept(file, name) == FileVisitResult.CONTINUE) {
+ return FileVisitResult.CONTINUE;
+ }
+ }
+ return FileVisitResult.TERMINATE;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
public void addFileFilter(final IOFileFilter ioFileFilter) {
this.fileFilters.add(ioFileFilter);
}
diff --git a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java b/src/main/java/org/apache/commons/io/filefilter/PathFilter.java
similarity index 52%
copy from src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
copy to src/main/java/org/apache/commons/io/filefilter/PathFilter.java
index 8b2cdc4..71976aa 100644
--- a/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java
+++ b/src/main/java/org/apache/commons/io/filefilter/PathFilter.java
@@ -15,23 +15,35 @@
* limitations under the License.
*/
-package org.apache.commons.io.file;
+package org.apache.commons.io.filefilter;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
/**
- * A {@link SimpleFileVisitor} typed to a {@link Path}.
+ * A filter for {@link Path}s.
*
- * @since 2.7
+ * @since 2.9.0
*/
-public abstract class SimplePathVisitor extends SimpleFileVisitor<Path> {
+public interface PathFilter {
/**
- * Constructs a new instance.
+ * Tests whether or not to include the specified Path in a result.
+ *
+ * @param path The Path to test.
+ * @return a FileVisitResult
+ * @throws IOException if an I/O error occurs
*/
- protected SimplePathVisitor() {
- super();
- }
+ FileVisitResult accept(Path path) throws IOException;
+ /**
+ * Tests whether or not to include the specified Path in a result.
+ *
+ * @param path The dir path to test.
+ * @param name The path base name to test.
+ * @return a FileVisitResult
+ * @throws IOException if an I/O error occurs
+ */
+ FileVisitResult accept(Path path, Path name) throws IOException;
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/PathVisitorFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/PathVisitorFileFilter.java
new file mode 100644
index 0000000..dd93842
--- /dev/null
+++ b/src/main/java/org/apache/commons/io/filefilter/PathVisitorFileFilter.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.io.filefilter;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.BasicFileAttributes;
+
+import org.apache.commons.io.file.NoopPathVisitor;
+import org.apache.commons.io.file.PathVisitor;
+
+/**
+ * A file filter backed by a path visitor.
+ *
+ * @since 2.9.0
+ */
+public class PathVisitorFileFilter extends AbstractFileFilter {
+
+ private final PathVisitor pathVisitor;
+
+ /**
+ * Constructs a new instance that will forward calls to the given visitor.
+ *
+ * @param pathVisitor visit me.
+ */
+ public PathVisitorFileFilter(final PathVisitor pathVisitor) {
+ super();
+ this.pathVisitor = pathVisitor == null ? NoopPathVisitor.INSTANCE : pathVisitor;
+ }
+
+ @Override
+ public boolean accept(final File file) {
+ try {
+ final Path path = file.toPath();
+ return visitFile(path, file.exists() ? getBasicFileAttributeView(path) : null) == FileVisitResult.CONTINUE;
+ } catch (final IOException e) {
+ return handle(e) == FileVisitResult.CONTINUE;
+ }
+ }
+
+ @Override
+ public boolean accept(final File dir, final String name) {
+ try {
+ return accept(dir.toPath(), Paths.get(name)) == FileVisitResult.CONTINUE;
+ } catch (final IOException e) {
+ return handle(e) == FileVisitResult.CONTINUE;
+ }
+ }
+
+ @Override
+ public FileVisitResult accept(final Path path) throws IOException {
+ return visitFile(path, getBasicFileAttributeView(path));
+ }
+
+ @Override
+ public FileVisitResult accept(final Path dir, final Path name) throws IOException {
+ return pathVisitor.postVisitDirectory(dir, null);
+
+ }
+
+ protected BasicFileAttributes getBasicFileAttributeView(final Path path) throws IOException {
+ return Files.readAttributes(path, BasicFileAttributes.class);
+ }
+
+ @Override
+ public FileVisitResult visitFile(final Path path, final BasicFileAttributes basicFileAttributeView)
+ throws IOException {
+ return pathVisitor.visitFile(path, basicFileAttributeView);
+ }
+
+}
diff --git a/src/main/java/org/apache/commons/io/filefilter/PrefixFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/PrefixFileFilter.java
index a57af74..cacad30 100644
--- a/src/main/java/org/apache/commons/io/filefilter/PrefixFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/PrefixFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
import java.util.List;
import org.apache.commons.io.IOCase;
@@ -27,17 +29,36 @@ import org.apache.commons.io.IOCase;
* <p>
* For example, to print all files and directories in the
* current directory whose name starts with <code>Test</code>:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( new PrefixFileFilter("Test") );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(new PrefixFileFilter("Test"));
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
- * @since 1.0
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new PrefixFileFilter("Test"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
*
+ * @since 1.0
* @see FileFilterUtils#prefixFileFilter(String)
* @see FileFilterUtils#prefixFileFilter(String, IOCase)
*/
@@ -149,13 +170,28 @@ public class PrefixFileFilter extends AbstractFileFilter implements Serializable
return accept(file.getName());
}
- private boolean accept(final String name) {
- for (final String prefix : prefixes) {
- if (caseSensitivity.checkStartsWith(name, prefix)) {
- return true;
- }
- }
- return false;
+ /**
+ * Checks to see if the file name starts with the prefix.
+ *
+ * @param file the File directory
+ * @param name the file name
+ * @return true if the file name starts with one of our prefixes
+ */
+ @Override
+ public boolean accept(final File file, final String name) {
+ return accept(name);
+ }
+
+ /**
+ * Checks to see if the file name starts with the prefix.
+ *
+ * @param file the File to check
+ * @return true if the file name starts with one of our prefixes
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return toFileVisitResult(accept(file.getFileName().toFile()));
}
/**
@@ -164,12 +200,22 @@ public class PrefixFileFilter extends AbstractFileFilter implements Serializable
* @param file the File directory
* @param name the file name
* @return true if the file name starts with one of our prefixes
+ * @since 2.9.0
*/
@Override
- public boolean accept(final File file, final String name) {
+ public FileVisitResult accept(final Path file, final Path name) {
return accept(name);
}
+ private boolean accept(final String name) {
+ for (final String prefix : prefixes) {
+ if (caseSensitivity.checkStartsWith(name, prefix)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
/**
* Provide a String representation of this file filter.
*
diff --git a/src/main/java/org/apache/commons/io/filefilter/RegexFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/RegexFileFilter.java
index 36617dc..87879e3 100644
--- a/src/main/java/org/apache/commons/io/filefilter/RegexFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/RegexFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
import java.util.regex.Pattern;
import org.apache.commons.io.IOCase;
@@ -27,18 +29,37 @@ import org.apache.commons.io.IOCase;
* <p>
* See java.util.regex.Pattern for regex matching rules.
* </p>
- *
+ * <h2>Using Classic IO</h2>
* <p>
* e.g.
* <pre>
* File dir = new File(".");
* FileFilter fileFilter = new RegexFileFilter("^.*[tT]est(-\\d+)?\\.java$");
* File[] files = dir.listFiles(fileFilter);
- * for (int i = 0; i < files.length; i++) {
- * System.out.println(files[i]);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new RegexFileFilter("^.*[tT]est(-\\d+)?\\.java$"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
* @since 1.4
*/
public class RegexFileFilter extends AbstractFileFilter implements Serializable {
@@ -119,4 +140,16 @@ public class RegexFileFilter extends AbstractFileFilter implements Serializable
return pattern.matcher(name).matches();
}
+ /**
+ * Checks to see if the file name matches one of the regular expressions.
+ *
+ * @param dir the file directory (ignored)
+ * @param name the file name
+ * @return true if the file name matches one of the regular expressions
+ */
+ @Override
+ public FileVisitResult accept(final Path dir, final Path name) {
+ return toFileVisitResult(pattern.matcher(name.toString()).matches());
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/SizeFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/SizeFileFilter.java
index 3bf5286..f8bf49b 100644
--- a/src/main/java/org/apache/commons/io/filefilter/SizeFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/SizeFileFilter.java
@@ -17,7 +17,12 @@
package org.apache.commons.io.filefilter;
import java.io.File;
+import java.io.IOException;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
/**
* Filters files based on size, can filter either smaller files or
@@ -25,15 +30,35 @@ import java.io.Serializable;
* <p>
* For example, to print all files and directories in the
* current directory whose size is greater than 1 MB:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( new SizeFileFilter(1024 * 1024) );
- * for ( int i = 0; i < files.length; i++ ) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(new SizeFileFilter(1024 * 1024));
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new SizeFileFilter(1024 * 1024));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
* @since 1.2
* @see FileFilterUtils#sizeFileFilter(long)
* @see FileFilterUtils#sizeFileFilter(long, boolean)
@@ -43,12 +68,12 @@ public class SizeFileFilter extends AbstractFileFilter implements Serializable {
private static final long serialVersionUID = 7388077430788600069L;
- /** The size threshold. */
- private final long size;
-
/** Whether the files accepted will be larger or smaller. */
private final boolean acceptLarger;
+ /** The size threshold. */
+ private final long size;
+
/**
* Constructs a new size file filter for files equal to or
* larger than a certain size.
@@ -91,7 +116,32 @@ public class SizeFileFilter extends AbstractFileFilter implements Serializable {
*/
@Override
public boolean accept(final File file) {
- return acceptLarger != file.length() < size;
+ return accept(file.length());
+ }
+
+ private boolean accept(final long length) {
+ return acceptLarger != length < size;
+ }
+
+ /**
+ * Checks to see if the size of the file is favorable.
+ * <p>
+ * If size equals threshold and smaller files are required,
+ * file <b>IS NOT</b> selected.
+ * If size equals threshold and larger files are required,
+ * file <b>IS</b> selected.
+ * </p>
+ *
+ * @param file the File to check
+ * @return true if the file name matches
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ try {
+ return toFileVisitResult(accept(Files.size(file)));
+ } catch (final IOException e) {
+ return handle(e);
+ }
}
/**
@@ -105,4 +155,9 @@ public class SizeFileFilter extends AbstractFileFilter implements Serializable {
return super.toString() + "(" + condition + size + ")";
}
+ @Override
+ public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
+ return toFileVisitResult(accept(Files.size(file)));
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/SuffixFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/SuffixFileFilter.java
index 88ef695..2dff98f 100644
--- a/src/main/java/org/apache/commons/io/filefilter/SuffixFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/SuffixFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
import java.util.List;
import org.apache.commons.io.IOCase;
@@ -28,17 +30,36 @@ import org.apache.commons.io.IOCase;
* <p>
* For example, to retrieve and print all <code>*.java</code> files
* in the current directory:
- *
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
- * String[] files = dir.list( new SuffixFileFilter(".java") );
- * for (int i = 0; i < files.length; i++) {
- * System.out.println(files[i]);
+ * String[] files = dir.list(new SuffixFileFilter(".java"));
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
- * @since 1.0
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new SuffixFileFilter(".java"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
*
+ * @since 1.0
* @see FileFilterUtils#suffixFileFilter(String)
* @see FileFilterUtils#suffixFileFilter(String, IOCase)
*/
@@ -162,6 +183,30 @@ public class SuffixFileFilter extends AbstractFileFilter implements Serializable
return accept(name);
}
+ /**
+ * Checks to see if the file name ends with the suffix.
+ *
+ * @param file the File to check
+ * @return true if the file name ends with one of our suffixes
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return toFileVisitResult(accept(file.getFileName().toString()));
+ }
+
+ /**
+ * Checks to see if the file name ends with the suffix.
+ *
+ * @param file the File directory
+ * @param name the file name
+ * @return true if the file name ends with one of our suffixes
+ */
+ @Override
+ public FileVisitResult accept(final Path file, final Path name) {
+ return accept(name);
+ }
+
private boolean accept(final String name) {
for (final String suffix : this.suffixes) {
if (caseSensitivity.checkEndsWith(name, suffix)) {
diff --git a/src/main/java/org/apache/commons/io/filefilter/TrueFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/TrueFileFilter.java
index 1f2f13c..0b54a43 100644
--- a/src/main/java/org/apache/commons/io/filefilter/TrueFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/TrueFileFilter.java
@@ -18,12 +18,13 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
/**
* A file filter that always returns true.
*
* @since 1.0
- *
* @see FileFilterUtils#trueFileFilter()
*/
public class TrueFileFilter implements IOFileFilter, Serializable {
@@ -72,4 +73,29 @@ public class TrueFileFilter implements IOFileFilter, Serializable {
return true;
}
+ /**
+ * Returns true.
+ *
+ * @param file the file to check (ignored)
+ * @return true
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return FileVisitResult.CONTINUE;
+ }
+
+ /**
+ * Returns true.
+ *
+ * @param dir the directory to check (ignored)
+ * @param name the file name (ignored)
+ * @return true
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path dir, final Path name) {
+ return FileVisitResult.CONTINUE;
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/WildcardFileFilter.java b/src/main/java/org/apache/commons/io/filefilter/WildcardFileFilter.java
index 33a3d21..5a6ac11 100644
--- a/src/main/java/org/apache/commons/io/filefilter/WildcardFileFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/WildcardFileFilter.java
@@ -18,6 +18,8 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
import java.util.List;
import org.apache.commons.io.FilenameUtils;
@@ -39,22 +41,44 @@ import org.apache.commons.io.IOCase;
* <p>
* For example:
* </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
* FileFilter fileFilter = new WildcardFileFilter("*test*.java~*~");
* File[] files = dir.listFiles(fileFilter);
- * for (int i = 0; i < files.length; i++) {
- * System.out.println(files[i]);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new WildcardFileFilter("*test*.java~*~"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
* @since 1.3
*/
public class WildcardFileFilter extends AbstractFileFilter implements Serializable {
private static final long serialVersionUID = -7426486598995782105L;
+
/** The wildcards that will be used to match file names. */
private final String[] wildcards;
+
/** Whether the comparison is case sensitive. */
private final IOCase caseSensitivity;
@@ -149,7 +173,6 @@ public class WildcardFileFilter extends AbstractFileFilter implements Serializab
return accept(file.getName());
}
- //-----------------------------------------------------------------------
/**
* Checks to see if the file name matches one of the wildcards.
*
@@ -162,6 +185,30 @@ public class WildcardFileFilter extends AbstractFileFilter implements Serializab
return accept(name);
}
+ /**
+ * Checks to see if the file name matches one of the wildcards.
+ *
+ * @param file the file to check
+ * @return true if the file name matches one of the wildcards.
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ return toFileVisitResult(accept(file.getFileName().toString()));
+ }
+
+ /**
+ * Checks to see if the file name matches one of the wildcards.
+ *
+ * @param dir the file directory (ignored)
+ * @param name the file name
+ * @return true if the file name matches one of the wildcards
+ */
+ @Override
+ public FileVisitResult accept(final Path dir, final Path name) {
+ return accept(name);
+ }
+
private boolean accept(final String name) {
for (final String wildcard : wildcards) {
if (FilenameUtils.wildcardMatch(name, wildcard, caseSensitivity)) {
@@ -181,13 +228,11 @@ public class WildcardFileFilter extends AbstractFileFilter implements Serializab
final StringBuilder buffer = new StringBuilder();
buffer.append(super.toString());
buffer.append("(");
- if (wildcards != null) {
- for (int i = 0; i < wildcards.length; i++) {
- if (i > 0) {
- buffer.append(",");
- }
- buffer.append(wildcards[i]);
+ for (int i = 0; i < wildcards.length; i++) {
+ if (i > 0) {
+ buffer.append(",");
}
+ buffer.append(wildcards[i]);
}
buffer.append(")");
return buffer.toString();
diff --git a/src/main/java/org/apache/commons/io/filefilter/WildcardFilter.java b/src/main/java/org/apache/commons/io/filefilter/WildcardFilter.java
index 7658398..eacb008 100644
--- a/src/main/java/org/apache/commons/io/filefilter/WildcardFilter.java
+++ b/src/main/java/org/apache/commons/io/filefilter/WildcardFilter.java
@@ -18,6 +18,9 @@ package org.apache.commons.io.filefilter;
import java.io.File;
import java.io.Serializable;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
import java.util.List;
import org.apache.commons.io.FilenameUtils;
@@ -27,23 +30,46 @@ import org.apache.commons.io.FilenameUtils;
* <p>
* This filter selects files, but not directories, based on one or more wildcards
* and using case-sensitive comparison.
+ * </p>
* <p>
* The wildcard matcher uses the characters '?' and '*' to represent a
* single or multiple wildcard characters.
* This is the same as often found on Dos/Unix command lines.
* The extension check is case-sensitive.
* See {@link FilenameUtils#wildcardMatch(String, String)} for more information.
+ * </p>
* <p>
* For example:
+ * </p>
+ * <h2>Using Classic IO</h2>
* <pre>
* File dir = new File(".");
* FileFilter fileFilter = new WildcardFilter("*test*.java~*~");
* File[] files = dir.listFiles(fileFilter);
- * for (int i = 0; i < files.length; i++) {
- * System.out.println(files[i]);
+ * for (String file : files) {
+ * System.out.println(file);
* }
* </pre>
*
+ * <h2>Using NIO</h2>
+ * <pre>
+ * final Path dir = Paths.get(".");
+ * final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new WildcardFilter("*test*.java~*~"));
+ * //
+ * // Walk one dir
+ * Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getFileList());
+ * //
+ * visitor.getPathCounters().reset();
+ * //
+ * // Walk dir tree
+ * Files.<b>walkFileTree</b>(dir, visitor);
+ * System.out.println(visitor.getPathCounters());
+ * System.out.println(visitor.getDirList());
+ * System.out.println(visitor.getFileList());
+ * </pre>
+ *
* @since 1.1
* @deprecated Use WildcardFileFilter. Deprecated as this class performs directory
* filtering which it shouldn't do, but that can't be removed due to compatibility.
@@ -117,7 +143,28 @@ public class WildcardFilter extends AbstractFileFilter implements Serializable {
return false;
}
- //-----------------------------------------------------------------------
+ /**
+ * Checks to see if the file name matches one of the wildcards.
+ *
+ * @param file the file to check
+ * @return true if the file name matches one of the wildcards
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path file) {
+ if (Files.isDirectory(file)) {
+ return FileVisitResult.TERMINATE;
+ }
+
+ for (final String wildcard : wildcards) {
+ if (FilenameUtils.wildcardMatch(file.getFileName().toString(), wildcard)) {
+ return FileVisitResult.CONTINUE;
+ }
+ }
+
+ return FileVisitResult.TERMINATE;
+ }
+
/**
* Checks to see if the file name matches one of the wildcards.
*
@@ -140,4 +187,27 @@ public class WildcardFilter extends AbstractFileFilter implements Serializable {
return false;
}
+ /**
+ * Checks to see if the file name matches one of the wildcards.
+ *
+ * @param dir the file directory
+ * @param name the file name
+ * @return true if the file name matches one of the wildcards
+ * @since 2.9.0
+ */
+ @Override
+ public FileVisitResult accept(final Path dir, final Path name) {
+ if (dir != null && Files.isDirectory(dir.resolve(name))) {
+ return FileVisitResult.TERMINATE;
+ }
+
+ for (final String wildcard : wildcards) {
+ if (FilenameUtils.wildcardMatch(name.toString(), wildcard)) {
+ return FileVisitResult.CONTINUE;
+ }
+ }
+
+ return FileVisitResult.TERMINATE;
+ }
+
}
diff --git a/src/main/java/org/apache/commons/io/filefilter/package.html b/src/main/java/org/apache/commons/io/filefilter/package.html
index e32a192..9612aee 100644
--- a/src/main/java/org/apache/commons/io/filefilter/package.html
+++ b/src/main/java/org/apache/commons/io/filefilter/package.html
@@ -24,6 +24,7 @@ IOFileFilter interface including implementation that allow you to combine
other such filters.</p>
<p>These filter can be used to list files or in {@link java.awt.FileDialog},
for example.</p>
+
<table>
<caption>There are a number of 'primitive' filters:</caption>
<tbody>
@@ -83,7 +84,8 @@ for example.</p>
</tbody>
</table>
-
+
+<h2>Using Classic IO</h2>
<p>These boolean FilenameFilters can be nested, to allow arbitrary expressions.
For example, here is how one could print all non-directory files in the
current directory, starting with "A", and ending in ".java" or ".class":</p>
@@ -104,11 +106,26 @@ current directory, starting with "A", and ending in ".java" or ".class":</p>
)
)
);
- for ( int i=0; i<files.length; i++ ) {
+ for (int i=0; i<files.length; i++) {
+ System.out.println(files[i]);
+ }
+</pre>
+<p>
+You can alternatively build a filter tree using the "and", "or", and "not" methods on filters themselves:
+</p>
+<pre>
+ File dir = new File(".");
+ String[] files = dir.list(
+ new AndFileFilter(
+ new PrefixFileFilter("A").and(
+ new SuffixFileFilter(".class").or(new SuffixFileFilter(".java"))),
+ new DirectoryFileFilter().not()
+ )
+ );
+ for (int i=0; i<files.length; i++) {
System.out.println(files[i]);
}
</pre>
-
<p>This package also contains a utility class:
<a href="FileFilterUtils.html">FileFilterUtils</a>. It allows you to use all
file filters without having to put them in the import section. Here's how the
@@ -129,10 +146,31 @@ above example will look using FileFilterUtils:</p>
)
)
);
- for ( int i=0; i<files.length; i++ ) {
+ for (int i=0; i<files.length; i++) {
System.out.println(files[i]);
}
</pre>
+<h2>Using NIO</h2>
+<p>You can combine Java <b>file tree walking</b> by using <code>java.nio.file.Files.walk()</code> APIs with filters:</p>
+<pre>
+ final Path dir = Paths.get(".");
+ // We are interested in files older than one day
+ final long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+ final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new AgeFileFilter(cutoff));
+ //
+ // Walk one dir
+ Files.<b>walkFileTree</b>(dir, Collections.emptySet(), 1, visitor);
+ System.out.println(visitor.getPathCounters());
+ System.out.println(visitor.getFileList());
+ //
+ visitor.getPathCounters().reset();
+ //
+ // Walk dir tree
+ Files.<b>walkFileTree</b>(dir, visitor);
+ System.out.println(visitor.getPathCounters());
+ System.out.println(visitor.getDirList());
+ System.out.println(visitor.getFileList());
+</pre>
<p>There are a few other goodies in that class so please have a look at the
documentation in detail.</p>
</body>
diff --git a/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java b/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java
index 299d9e7..7042ac3 100644
--- a/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java
+++ b/src/test/java/org/apache/commons/io/DirectoryWalkerTestCase.java
@@ -64,8 +64,8 @@ public class DirectoryWalkerTestCase {
private static final IOFileFilter dirsFilter = createNameFilter(dirs);
private static final IOFileFilter iofilesFilter = createNameFilter(ioFiles);
private static final IOFileFilter outputFilesFilter = createNameFilter(outputFiles);
- private static final IOFileFilter ioDirAndFilesFilter = new OrFileFilter(dirsFilter, iofilesFilter);
- private static final IOFileFilter dirsAndFilesFilter = new OrFileFilter(ioDirAndFilesFilter, outputFilesFilter);
+ private static final IOFileFilter ioDirAndFilesFilter = dirsFilter.or(iofilesFilter);
+ private static final IOFileFilter dirsAndFilesFilter = ioDirAndFilesFilter.or(outputFilesFilter);
// Filter to exclude SVN files
private static final IOFileFilter NOT_SVN = FileFilterUtils.makeSVNAware(null);
diff --git a/src/test/java/org/apache/commons/io/file/AccumulatorPathVisitorTest.java b/src/test/java/org/apache/commons/io/file/AccumulatorPathVisitorTest.java
new file mode 100644
index 0000000..931bfba
--- /dev/null
+++ b/src/test/java/org/apache/commons/io/file/AccumulatorPathVisitorTest.java
@@ -0,0 +1,122 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.io.file;
+
+import static org.apache.commons.io.file.CounterAssertions.assertCounts;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import org.apache.commons.io.filefilter.AndFileFilter;
+import org.apache.commons.io.filefilter.DirectoryFileFilter;
+import org.apache.commons.io.filefilter.EmptyFileFilter;
+import org.apache.commons.io.filefilter.PathVisitorFileFilter;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Tests both {@link AccumulatorPathVisitor} and {@link PathVisitorFileFilter}.
+ */
+public class AccumulatorPathVisitorTest {
+
+ static Stream<Arguments> testParameters() {
+ // @formatter:off
+ return Stream.of(
+ Arguments.of((Supplier<AccumulatorPathVisitor>) () -> {
+ return AccumulatorPathVisitor.withLongCounters();
+ }),
+ Arguments.of((Supplier<AccumulatorPathVisitor>) () -> {
+ return AccumulatorPathVisitor.withBigIntegerCounters();
+ }));
+ // @formatter:on
+ }
+
+ @TempDir
+ File tempDirFile;
+
+ /**
+ * Tests an empty folder.
+ */
+ @ParameterizedTest
+ @MethodSource("testParameters")
+ public void testEmptyFolder(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+ final Path tempDir = tempDirFile.toPath();
+ final AccumulatorPathVisitor accPathVisitor = supplier.get();
+ final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(accPathVisitor);
+ Files.walkFileTree(tempDir,
+ new AndFileFilter(countingFileFilter, DirectoryFileFilter.INSTANCE, EmptyFileFilter.EMPTY));
+ assertCounts(1, 0, 0, accPathVisitor.getPathCounters());
+ assertEquals(1, accPathVisitor.getDirList().size());
+ assertTrue(accPathVisitor.getFileList().isEmpty());
+ }
+
+ /**
+ * Tests a directory with one file of size 0.
+ */
+ @ParameterizedTest
+ @MethodSource("testParameters")
+ public void testFolders1FileSize0(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+ final AccumulatorPathVisitor accPathVisitor = supplier.get();
+ final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(accPathVisitor);
+ Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-0"),
+ countingFileFilter);
+ assertCounts(1, 1, 0, accPathVisitor.getPathCounters());
+ assertEquals(1, accPathVisitor.getDirList().size());
+ assertEquals(1, accPathVisitor.getFileList().size());
+ }
+
+ /**
+ * Tests a directory with one file of size 1.
+ */
+ @ParameterizedTest
+ @MethodSource("testParameters")
+ public void testFolders1FileSize1(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+ final AccumulatorPathVisitor accPathVisitor = supplier.get();
+ final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(accPathVisitor);
+ Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-1"),
+ countingFileFilter);
+ assertCounts(1, 1, 1, accPathVisitor.getPathCounters());
+ assertEquals(1, accPathVisitor.getDirList().size());
+ assertEquals(1, accPathVisitor.getFileList().size());
+ }
+
+ /**
+ * Tests a directory with two subdirectories, each containing one file of size 1.
+ */
+ @ParameterizedTest
+ @MethodSource("testParameters")
+ public void testFolders2FileSize2(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+ final AccumulatorPathVisitor accPathVisitor = supplier.get();
+ final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(accPathVisitor);
+ Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-2-file-size-2"),
+ countingFileFilter);
+ assertCounts(3, 2, 2, accPathVisitor.getPathCounters());
+ assertEquals(3, accPathVisitor.getDirList().size());
+ assertEquals(2, accPathVisitor.getFileList().size());
+ }
+
+}
diff --git a/src/test/java/org/apache/commons/io/file/CounterAssertions.java b/src/test/java/org/apache/commons/io/file/CounterAssertions.java
index ff27231..8a0332b 100644
--- a/src/test/java/org/apache/commons/io/file/CounterAssertions.java
+++ b/src/test/java/org/apache/commons/io/file/CounterAssertions.java
@@ -24,7 +24,7 @@ import java.math.BigInteger;
import org.apache.commons.io.file.Counters.Counter;
import org.apache.commons.io.file.Counters.PathCounters;
-class CounterAssertions {
+public class CounterAssertions {
static void assertCounter(final long expected, final Counter actual, final String message) {
assertEquals(expected, actual.get(), message);
@@ -33,15 +33,20 @@ class CounterAssertions {
}
static void assertCounts(final long expectedDirCount, final long expectedFileCount, final long expectedByteCount,
- final CountingPathVisitor actualVisitor) {
+ final CountingPathVisitor actualVisitor) {
assertCounts(expectedDirCount, expectedFileCount, expectedByteCount, actualVisitor.getPathCounters());
}
static void assertCounts(final long expectedDirCount, final long expectedFileCount, final long expectedByteCount,
- final PathCounters actualPathCounters) {
+ final PathCounters actualPathCounters) {
assertCounter(expectedDirCount, actualPathCounters.getDirectoryCounter(), "getDirectoryCounter");
assertCounter(expectedFileCount, actualPathCounters.getFileCounter(), "getFileCounter");
assertCounter(expectedByteCount, actualPathCounters.getByteCounter(), "getByteCounter");
}
+ public static void assertZeroCounters(final PathCounters pathCounters) {
+ assertCounts(0, 0, 0, pathCounters);
+ assertEquals(Counters.longPathCounters(), pathCounters);
+ }
+
}
diff --git a/src/test/java/org/apache/commons/io/file/CountersTest.java b/src/test/java/org/apache/commons/io/file/CountersTest.java
index 1992e0a..d386b69 100644
--- a/src/test/java/org/apache/commons/io/file/CountersTest.java
+++ b/src/test/java/org/apache/commons/io/file/CountersTest.java
@@ -19,6 +19,7 @@ package org.apache.commons.io.file;
import static org.apache.commons.io.file.CounterAssertions.assertCounter;
import static org.apache.commons.io.file.CounterAssertions.assertCounts;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import org.apache.commons.io.file.Counters.Counter;
import org.apache.commons.io.file.Counters.PathCounters;
@@ -41,6 +42,28 @@ public class CountersTest extends TestArguments {
}
@ParameterizedTest
+ @MethodSource("pathCounters")
+ public void testResetCounter(final PathCounters pathCounter) {
+ final Counter byteCounter = pathCounter.getByteCounter();
+ final long old = byteCounter.get();
+ byteCounter.add(1);
+ assertEquals(old + 1, byteCounter.get());
+ byteCounter.reset();
+ assertEquals(0, byteCounter.get());
+ }
+
+ @ParameterizedTest
+ @MethodSource("pathCounters")
+ public void testResetPathCounter(final PathCounters pathCounter) {
+ final Counter byteCounter = pathCounter.getByteCounter();
+ final long old = byteCounter.get();
+ byteCounter.add(1);
+ assertEquals(old + 1, byteCounter.get());
+ pathCounter.reset();
+ assertEquals(0, byteCounter.get());
+ }
+
+ @ParameterizedTest
@MethodSource("numberCounters")
public void testToString(final Counter counter) {
// Does not blow up
diff --git a/src/test/java/org/apache/commons/io/file/PathUtilsVisitorTest.java b/src/test/java/org/apache/commons/io/file/PathUtilsVisitorTest.java
new file mode 100644
index 0000000..80a06c6
--- /dev/null
+++ b/src/test/java/org/apache/commons/io/file/PathUtilsVisitorTest.java
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.io.file;
+
+import static org.apache.commons.io.file.CounterAssertions.assertCounts;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import org.apache.commons.io.filefilter.AndFileFilter;
+import org.apache.commons.io.filefilter.DirectoryFileFilter;
+import org.apache.commons.io.filefilter.EmptyFileFilter;
+import org.apache.commons.io.filefilter.PathVisitorFileFilter;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Tests {@link PathUtils}.
+ */
+public class PathUtilsVisitorTest {
+
+ static Stream<Arguments> testParameters() {
+ return AccumulatorPathVisitorTest.testParameters();
+ }
+
+ @TempDir
+ File tempDirFile;
+
+ /**
+ * Tests an empty folder.
+ */
+ @ParameterizedTest
+ @MethodSource("testParameters")
+ public void testCountEmptyFolder(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+ final Path tempDir = tempDirFile.toPath();
+ final CountingPathVisitor countingPathVisitor = CountingPathVisitor.withLongCounters();
+ final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(countingPathVisitor);
+ Files.walkFileTree(tempDir,
+ new AndFileFilter(countingFileFilter, DirectoryFileFilter.INSTANCE, EmptyFileFilter.EMPTY));
+ assertCounts(1, 0, 0, countingPathVisitor.getPathCounters());
+ }
+
+ /**
+ * Tests a directory with one file of size 0.
+ */
+ @ParameterizedTest
+ @MethodSource("testParameters")
+ public void testCountFolders1FileSize0(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+ final CountingPathVisitor countingPathVisitor = CountingPathVisitor.withLongCounters();
+ final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(countingPathVisitor);
+ Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-0"),
+ countingFileFilter);
+ assertCounts(1, 1, 0, countingPathVisitor.getPathCounters());
+ }
+
+ /**
+ * Tests a directory with one file of size 1.
+ */
+ @ParameterizedTest
+ @MethodSource("testParameters")
+ public void testCountFolders1FileSize1(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+ final CountingPathVisitor countingPathVisitor = CountingPathVisitor.withLongCounters();
+ final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(countingPathVisitor);
+ Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-1"),
+ countingFileFilter);
+ assertCounts(1, 1, 1, countingPathVisitor.getPathCounters());
+ }
+
+ /**
+ * Tests a directory with two subdirectories, each containing one file of size 1.
+ */
+ @ParameterizedTest
+ @MethodSource("testParameters")
+ public void testCountFolders2FileSize2(final Supplier<AccumulatorPathVisitor> supplier) throws IOException {
+ final CountingPathVisitor countingPathVisitor = CountingPathVisitor.withLongCounters();
+ final PathVisitorFileFilter countingFileFilter = new PathVisitorFileFilter(countingPathVisitor);
+ Files.walkFileTree(Paths.get("src/test/resources/org/apache/commons/io/dirs-2-file-size-2"),
+ countingFileFilter);
+ assertCounts(3, 2, 2, countingPathVisitor.getPathCounters());
+ }
+}
diff --git a/src/test/java/org/apache/commons/io/filefilter/AgeFileFilterTest.java b/src/test/java/org/apache/commons/io/filefilter/AgeFileFilterTest.java
new file mode 100644
index 0000000..4ab22df
--- /dev/null
+++ b/src/test/java/org/apache/commons/io/filefilter/AgeFileFilterTest.java
@@ -0,0 +1,109 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.io.filefilter;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+
+import org.apache.commons.io.file.AccumulatorPathVisitor;
+import org.apache.commons.io.file.CounterAssertions;
+import org.apache.commons.io.file.Counters;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link AgeFileFilter}.
+ */
+public class AgeFileFilterTest {
+
+ /**
+ * Javadoc example.
+ *
+ * System.out calls are commented out here but not in the Javadoc.
+ */
+ @Test
+ public void testJavadocExampleUsingIo() {
+ final File dir = new File(".");
+ // We are interested in files older than one day
+ final long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+ final String[] files = dir.list(new AgeFileFilter(cutoff));
+ for (final String file : files) {
+ // System.out.println(files[i]);
+ }
+ // End of Javadoc example
+ assertTrue(files.length > 0);
+ }
+
+ /**
+ * Javadoc example.
+ *
+ * System.out calls are commented out here but not in the Javadoc.
+ */
+ @Test
+ public void testJavadocExampleUsingNio() throws IOException {
+ final Path dir = Paths.get(".");
+ // We are interested in files older than one day
+ final long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+ final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new AgeFileFilter(cutoff));
+ //
+ // Walk one dir
+ Files.walkFileTree(dir, Collections.emptySet(), 1, visitor);
+ // System.out.println(visitor.getPathCounters());
+ // System.out.println(visitor.getFileList());
+ //
+ visitor.getPathCounters().reset();
+ //
+ // Walk dir tree
+ Files.walkFileTree(dir, visitor);
+ // System.out.println(visitor.getPathCounters());
+ // System.out.println(visitor.getDirList());
+ // System.out.println(visitor.getFileList());
+ //
+ // End of Javadoc example
+ assertTrue(visitor.getPathCounters().getFileCounter().get() > 0);
+ assertTrue(visitor.getPathCounters().getDirectoryCounter().get() > 0);
+ assertTrue(visitor.getPathCounters().getByteCounter().get() > 0);
+ // We counted and accumulated
+ assertFalse(visitor.getDirList().isEmpty());
+ assertFalse(visitor.getFileList().isEmpty());
+ //
+ assertNotEquals(Counters.noopPathCounters(), visitor.getPathCounters());
+ visitor.getPathCounters().reset();
+ CounterAssertions.assertZeroCounters(visitor.getPathCounters());
+ }
+
+ @Test
+ public void testNoCounting() throws IOException {
+ final Path dir = Paths.get(".");
+ final long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
+ final AccumulatorPathVisitor visitor = new AccumulatorPathVisitor(Counters.noopPathCounters(),
+ new AgeFileFilter(cutoff));
+ Files.walkFileTree(dir, Collections.emptySet(), 1, visitor);
+ //
+ CounterAssertions.assertZeroCounters(visitor.getPathCounters());
+ // We did not count, but we still accumulated
+ assertFalse(visitor.getDirList().isEmpty());
+ assertFalse(visitor.getFileList().isEmpty());
+ }
+}
diff --git a/src/test/java/org/apache/commons/io/filefilter/DirectoryFileFilterTest.java b/src/test/java/org/apache/commons/io/filefilter/DirectoryFileFilterTest.java
new file mode 100644
index 0000000..77ea8fb
--- /dev/null
+++ b/src/test/java/org/apache/commons/io/filefilter/DirectoryFileFilterTest.java
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.io.filefilter;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+
+import org.apache.commons.io.file.AccumulatorPathVisitor;
+import org.apache.commons.io.file.CounterAssertions;
+import org.apache.commons.io.file.Counters;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests {@link DirectoryFileFilter}.
+ */
+public class DirectoryFileFilterTest {
+
+ /**
+ * Javadoc example.
+ *
+ * System.out calls are commented out here but not in the Javadoc.
+ */
+ @Test
+ public void testJavadocExampleUsingIo() {
+ final File dir = new File(".");
+ final String[] files = dir.list(DirectoryFileFilter.INSTANCE);
+ for (String file : files) {
+ // System.out.println(files[i]);
+ }
+ // End of Javadoc example
+ assertTrue(files.length > 0);
+ }
+
+ /**
+ * Javadoc example.
+ *
+ * System.out calls are commented out here but not in the Javadoc.
+ */
+ @Test
+ public void testJavadocExampleUsingNio() throws IOException {
+ final Path dir = Paths.get(".");
+ final AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(DirectoryFileFilter.INSTANCE);
+ //
+ // Walk one dir
+ Files.walkFileTree(dir, Collections.emptySet(), 1, visitor);
+ // System.out.println(visitor.getPathCounters());
+ // System.out.println(visitor.getFileList());
+ //
+ visitor.getPathCounters().reset();
+ //
+ // Walk dir tree
+ Files.walkFileTree(dir, visitor);
+ // System.out.println(visitor.getPathCounters());
+ // System.out.println(visitor.getDirList());
+ // System.out.println(visitor.getFileList());
+ //
+ // End of Javadoc example
+ assertEquals(0, visitor.getPathCounters().getFileCounter().get());
+ assertTrue(visitor.getPathCounters().getDirectoryCounter().get() > 0);
+ assertEquals(0, visitor.getPathCounters().getByteCounter().get());
+ // We counted and accumulated
+ assertFalse(visitor.getDirList().isEmpty());
+ assertFalse(visitor.getFileList().isEmpty());
+ //
+ assertNotEquals(Counters.noopPathCounters(), visitor.getPathCounters());
+ visitor.getPathCounters().reset();
+ CounterAssertions.assertZeroCounters(visitor.getPathCounters());
+ }
+
+}
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 c59cdf9..2f3f451 100644
--- a/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/FileFilterTestCase.java
@@ -33,6 +33,10 @@ import java.io.FilenameFilter;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@@ -44,6 +48,7 @@ import java.util.Set;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOCase;
import org.apache.commons.io.IOUtils;
+import org.apache.commons.io.file.PathUtils;
import org.apache.commons.io.test.TestUtils;
import org.apache.commons.lang3.SystemUtils;
import org.junit.jupiter.api.Test;
@@ -66,51 +71,86 @@ 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
+ // the File passed in is not null
assertEquals(expected, filter.accept(file),
- "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
+ "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
if (file != null && file.getParentFile() != null) {
assertEquals(expected, filter.accept(file.getParentFile(), file.getName()),
- "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file);
+ "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file);
} else if (file == null) {
assertEquals(expected, filter.accept(file),
- "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null");
+ "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null");
}
assertNotNull(filter.toString());
}
-
+ public void assertFiltering(final IOFileFilter filter, final Path path, final boolean expected) throws Exception {
+ // Note. This only tests the (Path, Path) version if the parent of
+ // the File passed in is not null
+ final FileVisitResult expectedFileVisitResult = AbstractFileFilter.toFileVisitResult(expected);
+ assertEquals(expectedFileVisitResult, filter.accept(path),
+ "Filter(Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for " + path);
+
+ if (path != null && path.getParent() != null) {
+ assertEquals(expectedFileVisitResult, filter.accept(path.getParent(), path.getFileName()),
+ "Filter(Path, Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for "
+ + path);
+ } else if (path == null) {
+ assertEquals(expectedFileVisitResult, filter.accept(path),
+ "Filter(Path, Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for null");
+ }
+ assertNotNull(filter.toString());
+ }
@Test
public void testSuffix() throws Exception {
- IOFileFilter filter = new SuffixFileFilter(new String[] { "tes", "est" });
- final File testFile = new File( "test" );
- final File fredFile = new File( "fred" );
+ IOFileFilter filter = new SuffixFileFilter(new String[] {"tes", "est"});
+ final File testFile = new File("test");
+ final Path testPath = testFile.toPath();
+ final File fredFile = new File("fred");
+ final Path fredPath = fredFile.toPath();
+ //
assertFiltering(filter, new File("fred.tes"), true);
assertFiltering(filter, new File("fred.est"), true);
- assertFiltering(filter, new File("fred.EST"), false); //case-sensitive
+ assertFiltering(filter, new File("fred.EST"), false); // case-sensitive
assertFiltering(filter, new File("fred.exe"), false);
+ //
+ assertFiltering(filter, new File("fred.tes").toPath(), true);
+ assertFiltering(filter, new File("fred.est").toPath(), true);
+ assertFiltering(filter, new File("fred.EST").toPath(), false); // case-sensitive
+ assertFiltering(filter, new File("fred.exe").toPath(), false);
- filter = FileFilterUtils.or(
- FileFilterUtils.suffixFileFilter( "tes" ),
- FileFilterUtils.suffixFileFilter( "est" ) );
+ filter = FileFilterUtils.or(FileFilterUtils.suffixFileFilter("tes"), FileFilterUtils.suffixFileFilter("est"));
assertFiltering(filter, new File("fred"), false);
assertFiltering(filter, new File(".tes"), true);
assertFiltering(filter, new File("fred.test"), true);
+ //
+ assertFiltering(filter, new File("fred").toPath(), false);
+ assertFiltering(filter, new File(".tes").toPath(), true);
+ assertFiltering(filter, new File("fred.test").toPath(), true);
filter = new SuffixFileFilter("est");
assertFiltering(filter, new File("test"), true);
assertFiltering(filter, new File("fred"), false);
+ //
+ assertFiltering(filter, new File("test").toPath(), true);
+ assertFiltering(filter, new File("fred").toPath(), false);
- assertTrue( filter.accept( testFile.getParentFile(), testFile.getName() ) );
- assertTrue( !filter.accept( fredFile.getParentFile(), fredFile.getName() ) );
+ assertTrue(filter.accept(testFile.getParentFile(), testFile.getName()));
+ assertTrue(!filter.accept(fredFile.getParentFile(), fredFile.getName()));
+ //
+ assertEquals(FileVisitResult.CONTINUE, filter.accept(testPath.getParent(), testPath.getFileName()));
+ assertEquals(FileVisitResult.TERMINATE, filter.accept(fredPath.getParent(), fredPath.getFileName()));
final List<String> prefixes = Arrays.asList("ood", "red");
- final IOFileFilter listFilter = new SuffixFileFilter( prefixes );
+ final IOFileFilter listFilter = new SuffixFileFilter(prefixes);
- assertTrue( !listFilter.accept( testFile.getParentFile(), testFile.getName() ) );
- assertTrue( listFilter.accept( fredFile.getParentFile(), fredFile.getName() ) );
+ assertTrue(!listFilter.accept(testFile.getParentFile(), testFile.getName()));
+ assertTrue(listFilter.accept(fredFile.getParentFile(), fredFile.getName()));
+ //
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(testPath.getParent(), testPath.getFileName()));
+ assertEquals(FileVisitResult.CONTINUE, listFilter.accept(fredPath.getParent(), fredPath.getFileName()));
try {
new SuffixFileFilter((String) null);
@@ -129,16 +169,16 @@ public class FileFilterTestCase {
fail();
} catch (final IllegalArgumentException ignore) {
}
-}
+ }
@Test
public void testSuffixCaseInsensitive() throws Exception {
- IOFileFilter filter = new SuffixFileFilter(new String[] { "tes", "est" }, IOCase.INSENSITIVE);
+ IOFileFilter filter = new SuffixFileFilter(new String[] {"tes", "est"}, IOCase.INSENSITIVE);
assertFiltering(filter, new File("foo.tes"), true);
assertFiltering(filter, new File("foo.est"), true);
- assertFiltering(filter, new File("foo.EST"), true); //case-sensitive
- assertFiltering(filter, new File("foo.TES"), true); //case-sensitive
+ assertFiltering(filter, new File("foo.EST"), true); // case-sensitive
+ assertFiltering(filter, new File("foo.TES"), true); // case-sensitive
assertFiltering(filter, new File("foo.exe"), false);
filter = new SuffixFileFilter("est", IOCase.INSENSITIVE);
@@ -149,8 +189,8 @@ public class FileFilterTestCase {
filter = new SuffixFileFilter(suffixes, IOCase.INSENSITIVE);
assertFiltering(filter, new File("bar.tes"), true);
assertFiltering(filter, new File("bar.est"), true);
- assertFiltering(filter, new File("bar.EST"), true); //case-sensitive
- assertFiltering(filter, new File("bar.TES"), true); //case-sensitive
+ assertFiltering(filter, new File("bar.EST"), true); // case-sensitive
+ assertFiltering(filter, new File("bar.TES"), true); // case-sensitive
assertFiltering(filter, new File("bar.exe"), false);
try {
@@ -189,14 +229,20 @@ public class FileFilterTestCase {
final IOFileFilter filter = new DirectoryFileFilter();
assertFiltering(filter, new File("src/"), true);
+ assertFiltering(filter, new File("src/").toPath(), true);
assertFiltering(filter, new File("src/main/java/"), true);
+ assertFiltering(filter, new File("src/main/java/").toPath(), true);
assertFiltering(filter, new File("pom.xml"), false);
+ assertFiltering(filter, new File("pom.xml").toPath(), false);
assertFiltering(filter, new File("imaginary"), false);
+ assertFiltering(filter, new File("imaginary").toPath(), false);
assertFiltering(filter, new File("imaginary/"), false);
+ assertFiltering(filter, new File("imaginary/").toPath(), false);
assertFiltering(filter, new File("LICENSE.txt"), false);
+ assertFiltering(filter, new File("LICENSE.txt").toPath(), false);
assertSame(DirectoryFileFilter.DIRECTORY, DirectoryFileFilter.INSTANCE);
}
@@ -207,47 +253,74 @@ public class FileFilterTestCase {
final IOFileFilter filter = FileFileFilter.FILE;
assertFiltering(filter, new File("src/"), false);
+ assertFiltering(filter, new File("src/").toPath(), false);
assertFiltering(filter, new File("src/java/"), false);
+ assertFiltering(filter, new File("src/java/").toPath(), false);
assertFiltering(filter, new File("pom.xml"), true);
+ assertFiltering(filter, new File("pom.xml").toPath(), true);
assertFiltering(filter, new File("imaginary"), false);
+ assertFiltering(filter, new File("imaginary").toPath(), false);
assertFiltering(filter, new File("imaginary/"), false);
+ assertFiltering(filter, new File("imaginary/").toPath(), false);
assertFiltering(filter, new File("LICENSE.txt"), true);
+ assertFiltering(filter, new File("LICENSE.txt").toPath(), true);
}
@Test
public void testPrefix() throws Exception {
- IOFileFilter filter = new PrefixFileFilter(new String[] { "foo", "bar" });
- final File testFile = new File( "test" );
- final File fredFile = new File( "fred" );
+ IOFileFilter filter = new PrefixFileFilter(new String[] {"foo", "bar"});
+ final File testFile = new File("test");
+ final Path testPath = testFile.toPath();
+ final File fredFile = new File("fred");
+ final Path fredPath = fredFile.toPath();
assertFiltering(filter, new File("foo.test"), true);
- assertFiltering(filter, new File("FOO.test"), false); //case-sensitive
+ assertFiltering(filter, new File("FOO.test"), false); // case-sensitive
assertFiltering(filter, new File("foo"), true);
assertFiltering(filter, new File("bar"), true);
assertFiltering(filter, new File("food/"), true);
-
- filter = FileFilterUtils.prefixFileFilter( "bar" );
+ //
+ assertFiltering(filter, new File("foo.test").toPath(), true);
+ assertFiltering(filter, new File("FOO.test").toPath(), false); // case-sensitive
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("bar").toPath(), true);
+ assertFiltering(filter, new File("food/").toPath(), true);
+
+ filter = FileFilterUtils.prefixFileFilter("bar");
assertFiltering(filter, new File("barred\\"), true);
assertFiltering(filter, new File("test"), false);
assertFiltering(filter, new File("fo_o.test"), false);
assertFiltering(filter, new File("abar.exe"), false);
+ //
+ assertFiltering(filter, new File("barred\\").toPath(), true);
+ assertFiltering(filter, new File("test").toPath(), false);
+ assertFiltering(filter, new File("fo_o.test").toPath(), false);
+ assertFiltering(filter, new File("abar.exe").toPath(), false);
filter = new PrefixFileFilter("tes");
assertFiltering(filter, new File("test"), true);
assertFiltering(filter, new File("fred"), false);
+ //
+ assertFiltering(filter, new File("test").toPath(), true);
+ assertFiltering(filter, new File("fred").toPath(), false);
- assertTrue( filter.accept( testFile.getParentFile(), testFile.getName() ) );
- assertTrue( !filter.accept( fredFile.getParentFile(), fredFile.getName() ) );
+ assertTrue(filter.accept(testFile.getParentFile(), testFile.getName()));
+ assertTrue(!filter.accept(fredFile.getParentFile(), fredFile.getName()));
+ //
+ assertEquals(FileVisitResult.CONTINUE, filter.accept(testPath.getParent(), testPath.getFileName()));
+ assertEquals(FileVisitResult.TERMINATE, filter.accept(fredPath.getParent(), fredPath.getFileName()));
final List<String> prefixes = Arrays.asList("foo", "fre");
- final IOFileFilter listFilter = new PrefixFileFilter( prefixes );
-
- assertTrue( !listFilter.accept( testFile.getParentFile(), testFile.getName() ) );
- assertTrue( listFilter.accept( fredFile.getParentFile(), fredFile.getName() ) );
+ final IOFileFilter listFilter = new PrefixFileFilter(prefixes);
+ assertTrue(!listFilter.accept(testFile.getParentFile(), testFile.getName()));
+ assertTrue(listFilter.accept(fredFile.getParentFile(), fredFile.getName()));
+ //
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(testPath.getParent(), testPath.getFileName()));
+ assertEquals(FileVisitResult.CONTINUE, listFilter.accept(fredPath.getParent(), fredPath.getFileName()));
try {
new PrefixFileFilter((String) null);
@@ -271,24 +344,24 @@ public class FileFilterTestCase {
@Test
public void testPrefixCaseInsensitive() throws Exception {
- IOFileFilter filter = new PrefixFileFilter(new String[] { "foo", "bar" }, IOCase.INSENSITIVE);
+ IOFileFilter filter = new PrefixFileFilter(new String[] {"foo", "bar"}, IOCase.INSENSITIVE);
assertFiltering(filter, new File("foo.test1"), true);
assertFiltering(filter, new File("bar.test1"), true);
- assertFiltering(filter, new File("FOO.test1"), true); //case-sensitive
- assertFiltering(filter, new File("BAR.test1"), true); //case-sensitive
+ assertFiltering(filter, new File("FOO.test1"), true); // case-sensitive
+ assertFiltering(filter, new File("BAR.test1"), true); // case-sensitive
filter = new PrefixFileFilter("bar", IOCase.INSENSITIVE);
assertFiltering(filter, new File("foo.test2"), false);
assertFiltering(filter, new File("bar.test2"), true);
- assertFiltering(filter, new File("FOO.test2"), false); //case-sensitive
- assertFiltering(filter, new File("BAR.test2"), true); //case-sensitive
+ assertFiltering(filter, new File("FOO.test2"), false); // case-sensitive
+ assertFiltering(filter, new File("BAR.test2"), true); // case-sensitive
final List<String> prefixes = Arrays.asList("foo", "bar");
filter = new PrefixFileFilter(prefixes, IOCase.INSENSITIVE);
assertFiltering(filter, new File("foo.test3"), true);
assertFiltering(filter, new File("bar.test3"), true);
- assertFiltering(filter, new File("FOO.test3"), true); //case-sensitive
- assertFiltering(filter, new File("BAR.test3"), true); //case-sensitive
+ assertFiltering(filter, new File("FOO.test3"), true); // case-sensitive
+ assertFiltering(filter, new File("BAR.test3"), true); // case-sensitive
try {
new PrefixFileFilter((String) null, IOCase.INSENSITIVE);
@@ -312,8 +385,8 @@ public class FileFilterTestCase {
filter = FileFilterUtils.prefixFileFilter("bar", IOCase.INSENSITIVE);
assertFiltering(filter, new File("foo.test2"), false);
assertFiltering(filter, new File("bar.test2"), true);
- assertFiltering(filter, new File("FOO.test2"), false); //case-sensitive
- assertFiltering(filter, new File("BAR.test2"), true); //case-sensitive
+ assertFiltering(filter, new File("FOO.test2"), false); // case-sensitive
+ assertFiltering(filter, new File("BAR.test2"), true); // case-sensitive
try {
FileFilterUtils.prefixFileFilter(null, IOCase.INSENSITIVE);
@@ -324,34 +397,55 @@ public class FileFilterTestCase {
@Test
public void testNameFilter() throws Exception {
- IOFileFilter filter = new NameFileFilter(new String[] { "foo", "bar" });
+ IOFileFilter filter = new NameFileFilter(new String[] {"foo", "bar"});
+ assertFiltering(filter, new File("foo"), true);
assertFiltering(filter, new File("foo"), true);
assertFiltering(filter, new File("bar"), true);
assertFiltering(filter, new File("fred"), false);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("bar").toPath(), true);
+ assertFiltering(filter, new File("fred").toPath(), false);
- filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.SENSITIVE);
+ filter = new NameFileFilter(new String[] {"foo", "bar"}, IOCase.SENSITIVE);
assertFiltering(filter, new File("foo"), true);
assertFiltering(filter, new File("bar"), true);
assertFiltering(filter, new File("FOO"), false);
assertFiltering(filter, new File("BAR"), false);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("bar").toPath(), true);
+ assertFiltering(filter, new File("FOO").toPath(), false);
+ assertFiltering(filter, new File("BAR").toPath(), false);
- filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.INSENSITIVE);
+ filter = new NameFileFilter(new String[] {"foo", "bar"}, IOCase.INSENSITIVE);
assertFiltering(filter, new File("foo"), true);
assertFiltering(filter, new File("bar"), true);
assertFiltering(filter, new File("FOO"), true);
assertFiltering(filter, new File("BAR"), true);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("bar").toPath(), true);
+ assertFiltering(filter, new File("FOO").toPath(), true);
+ assertFiltering(filter, new File("BAR").toPath(), true);
- filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.SYSTEM);
+ filter = new NameFileFilter(new String[] {"foo", "bar"}, IOCase.SYSTEM);
assertFiltering(filter, new File("foo"), true);
assertFiltering(filter, new File("bar"), true);
assertFiltering(filter, new File("FOO"), WINDOWS);
assertFiltering(filter, new File("BAR"), WINDOWS);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("bar").toPath(), true);
+ assertFiltering(filter, new File("FOO").toPath(), WINDOWS);
+ assertFiltering(filter, new File("BAR").toPath(), WINDOWS);
- filter = new NameFileFilter(new String[]{"foo", "bar"}, null);
+ filter = new NameFileFilter(new String[] {"foo", "bar"}, null);
assertFiltering(filter, new File("foo"), true);
assertFiltering(filter, new File("bar"), true);
assertFiltering(filter, new File("FOO"), false);
assertFiltering(filter, new File("BAR"), false);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("bar").toPath(), true);
+ assertFiltering(filter, new File("FOO").toPath(), false);
+ assertFiltering(filter, new File("BAR").toPath(), false);
// repeat for a List
final java.util.ArrayList<String> list = new java.util.ArrayList<>();
@@ -361,21 +455,34 @@ public class FileFilterTestCase {
assertFiltering(filter, new File("foo"), true);
assertFiltering(filter, new File("bar"), true);
assertFiltering(filter, new File("fred"), false);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("bar").toPath(), true);
+ assertFiltering(filter, new File("fred").toPath(), false);
filter = new NameFileFilter("foo");
assertFiltering(filter, new File("foo"), true);
- assertFiltering(filter, new File("FOO"), false); //case-sensitive
+ assertFiltering(filter, new File("FOO"), false); // case-sensitive
assertFiltering(filter, new File("barfoo"), false);
assertFiltering(filter, new File("foobar"), false);
assertFiltering(filter, new File("fred"), false);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("FOO").toPath(), false); // case-sensitive
+ assertFiltering(filter, new File("barfoo").toPath(), false);
+ assertFiltering(filter, new File("foobar").toPath(), false);
+ assertFiltering(filter, new File("fred").toPath(), false);
// FileFilterUtils.nameFileFilter(String, IOCase) tests
filter = FileFilterUtils.nameFileFilter("foo", IOCase.INSENSITIVE);
assertFiltering(filter, new File("foo"), true);
- assertFiltering(filter, new File("FOO"), true); //case-insensitive
+ assertFiltering(filter, new File("FOO"), true); // case-insensitive
assertFiltering(filter, new File("barfoo"), false);
assertFiltering(filter, new File("foobar"), false);
assertFiltering(filter, new File("fred"), false);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, new File("FOO").toPath(), true); // case-insensitive
+ assertFiltering(filter, new File("barfoo").toPath(), false);
+ assertFiltering(filter, new File("foobar").toPath(), false);
+ assertFiltering(filter, new File("fred").toPath(), false);
}
@Test
@@ -383,14 +490,14 @@ public class FileFilterTestCase {
final String test = null;
try {
new NameFileFilter(test);
- fail( "constructing a NameFileFilter with a null String argument should fail.");
- } catch( final IllegalArgumentException ignore ) {
+ fail("constructing a NameFileFilter with a null String argument should fail.");
+ } catch (final IllegalArgumentException ignore) {
}
try {
FileFilterUtils.nameFileFilter(test, IOCase.INSENSITIVE);
- fail( "constructing a NameFileFilter with a null String argument should fail.");
- } catch( final IllegalArgumentException ignore ) {
+ fail("constructing a NameFileFilter with a null String argument should fail.");
+ } catch (final IllegalArgumentException ignore) {
}
}
@@ -410,7 +517,12 @@ public class FileFilterTestCase {
final IOFileFilter filter = FileFilterUtils.trueFileFilter();
assertFiltering(filter, new File("foo.test"), true);
assertFiltering(filter, new File("foo"), true);
- assertFiltering(filter, null, true);
+ assertFiltering(filter, (File) null, true);
+ //
+ assertFiltering(filter, new File("foo.test").toPath(), true);
+ assertFiltering(filter, new File("foo").toPath(), true);
+ assertFiltering(filter, (Path) null, true);
+ //
assertSame(TrueFileFilter.TRUE, TrueFileFilter.INSTANCE);
}
@@ -418,8 +530,11 @@ public class FileFilterTestCase {
public void testFalse() throws Exception {
final IOFileFilter filter = FileFilterUtils.falseFileFilter();
assertFiltering(filter, new File("foo.test"), false);
+ assertFiltering(filter, new File("foo.test").toPath(), false);
assertFiltering(filter, new File("foo"), false);
- assertFiltering(filter, null, false);
+ assertFiltering(filter, new File("foo").toPath(), false);
+ assertFiltering(filter, (File) null, false);
+ assertFiltering(filter, (Path) null, false);
assertSame(FalseFileFilter.FALSE, FalseFileFilter.INSTANCE);
}
@@ -428,12 +543,13 @@ public class FileFilterTestCase {
final IOFileFilter filter = FileFilterUtils.notFileFilter(FileFilterUtils.trueFileFilter());
assertFiltering(filter, new File("foo.test"), false);
assertFiltering(filter, new File("foo"), false);
- assertFiltering(filter, null, false);
+ assertFiltering(filter.not(), new File("foo"), true);
+ assertFiltering(filter, (File) null, false);
assertThrows(IllegalArgumentException.class, () -> new NotFileFilter(null));
}
@Test
- public void testAnd() throws Exception {
+ public void testAnd2() throws Exception {
final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
assertFiltering(new AndFileFilter(trueFilter, trueFilter), new File("foo.test"), true);
@@ -442,62 +558,95 @@ public class FileFilterTestCase {
assertFiltering(new AndFileFilter(falseFilter, falseFilter), new File("foo.test"), false);
final List<IOFileFilter> filters = new ArrayList<>();
- assertFiltering( new AndFileFilter( filters ), new File( "test" ), false );
- assertFiltering( new AndFileFilter(), new File( "test" ), false );
+ assertFiltering(new AndFileFilter(filters), new File("test"), false);
+ assertFiltering(new AndFileFilter(), new File("test"), false);
- try {
- new AndFileFilter(falseFilter, null);
- fail();
- } catch (final IllegalArgumentException ignore) {
- }
+ assertThrows(IllegalArgumentException.class, () -> new AndFileFilter(falseFilter, (IOFileFilter) null));
+ assertThrows(IllegalArgumentException.class, () -> new AndFileFilter(null, falseFilter));
- try {
- new AndFileFilter(null, falseFilter);
- fail();
- } catch (final IllegalArgumentException ignore) {
- }
-
- final AndFileFilter f = new AndFileFilter(null);
+ final AndFileFilter f = new AndFileFilter((List) null);
assertTrue(f.getFileFilters().isEmpty());
assertNotNull(f.toString()); // TODO better tests
}
@Test
+ public void testAnd() throws Exception {
+ final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
+ final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
+ assertFiltering(trueFilter.and(trueFilter), new File("foo.test"), true);
+ assertFiltering(trueFilter.and(falseFilter), new File("foo.test"), false);
+ assertFiltering(falseFilter.and(trueFilter), new File("foo.test"), false);
+ assertFiltering(falseFilter.and(trueFilter), new File("foo.test"), false);
+ assertFiltering(falseFilter.and(trueFilter, trueFilter), new File("foo.test"), false);
+ assertFiltering(falseFilter.and(trueFilter, trueFilter, trueFilter), new File("foo.test"), false);
+ }
+
+ @Test
+ public void testAndArray() throws Exception {
+ final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
+ final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
+ assertFiltering(new AndFileFilter(trueFilter, trueFilter, trueFilter), new File("foo.test"), true);
+ assertFiltering(new AndFileFilter(trueFilter, falseFilter, falseFilter), new File("foo.test"), false);
+ assertFiltering(new AndFileFilter(falseFilter, trueFilter, trueFilter), new File("foo.test"), false);
+ assertFiltering(new AndFileFilter(falseFilter, falseFilter, falseFilter), new File("foo.test"), false);
+
+ final List<IOFileFilter> filters = new ArrayList<>();
+ assertFiltering(new AndFileFilter(filters), new File("test"), false);
+ assertFiltering(new AndFileFilter(), new File("test"), false);
+ }
+
+ @Test
public void testOr() throws Exception {
final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
- final File testFile = new File( "foo.test" );
+ final File testFile = new File("foo.test");
+ final Path testPath = testFile.toPath();
assertFiltering(new OrFileFilter(trueFilter, trueFilter), testFile, true);
assertFiltering(new OrFileFilter(trueFilter, falseFilter), testFile, true);
assertFiltering(new OrFileFilter(falseFilter, trueFilter), testFile, true);
assertFiltering(new OrFileFilter(falseFilter, falseFilter), testFile, false);
assertFiltering(new OrFileFilter(), testFile, false);
+ //
+ assertFiltering(new OrFileFilter(trueFilter, trueFilter), testPath, true);
+ assertFiltering(new OrFileFilter(trueFilter, falseFilter), testPath, true);
+ assertFiltering(new OrFileFilter(falseFilter, trueFilter), testPath, true);
+ assertFiltering(new OrFileFilter(falseFilter, falseFilter), testPath, false);
+ assertFiltering(new OrFileFilter(), testPath, false);
+ //
+ assertFiltering(falseFilter.or(trueFilter), testPath, true);
+ assertFiltering(falseFilter.or(falseFilter, trueFilter), testPath, true);
+ assertFiltering(falseFilter.or(falseFilter, falseFilter, trueFilter), testPath, true);
final List<IOFileFilter> filters = new ArrayList<>();
- filters.add( trueFilter );
- filters.add( falseFilter );
+ filters.add(trueFilter);
+ filters.add(falseFilter);
- final OrFileFilter orFilter = new OrFileFilter( filters );
+ final OrFileFilter orFilter = new OrFileFilter(filters);
assertFiltering(orFilter, testFile, true);
- assertEquals( orFilter.getFileFilters(), filters );
- orFilter.removeFileFilter( trueFilter );
+ assertFiltering(orFilter, testPath, true);
+ assertEquals(orFilter.getFileFilters(), filters);
+ orFilter.removeFileFilter(trueFilter);
assertFiltering(orFilter, testFile, false);
- orFilter.setFileFilters( filters );
+ assertFiltering(orFilter, testPath, false);
+ orFilter.setFileFilters(filters);
assertFiltering(orFilter, testFile, true);
+ assertFiltering(orFilter, testPath, true);
- assertTrue( orFilter.accept( testFile.getParentFile(), testFile.getName() ) );
- orFilter.removeFileFilter( trueFilter );
- assertTrue( !orFilter.accept( testFile.getParentFile(), testFile.getName() ) );
+ assertTrue(orFilter.accept(testFile.getParentFile(), testFile.getName()));
+ assertEquals(FileVisitResult.CONTINUE, orFilter.accept(testPath.getParent(), testPath.getFileName()));
+ orFilter.removeFileFilter(trueFilter);
+ assertTrue(!orFilter.accept(testFile.getParentFile(), testFile.getName()));
+ assertEquals(FileVisitResult.TERMINATE, orFilter.accept(testPath.getParent(), testPath.getFileName()));
try {
- new OrFileFilter(falseFilter, null);
+ new OrFileFilter(falseFilter, (IOFileFilter) null);
fail();
} catch (final IllegalArgumentException ex) {
}
- final OrFileFilter f = new OrFileFilter(null);
+ final OrFileFilter f = new OrFileFilter((List<IOFileFilter>) null);
assertTrue(f.getFileFilters().isEmpty());
}
@@ -515,7 +664,7 @@ public class FileFilterTestCase {
public void testFileFilterUtils_or() throws Exception {
final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
- final File testFile = new File( "foo.test" );
+ final File testFile = new File("foo.test");
assertFiltering(FileFilterUtils.or(trueFilter, trueFilter), testFile, true);
assertFiltering(FileFilterUtils.or(trueFilter, trueFilter, falseFilter), testFile, true);
assertFiltering(FileFilterUtils.or(falseFilter, trueFilter), testFile, true);
@@ -527,41 +676,70 @@ public class FileFilterTestCase {
public void testDeprecatedWildcard() throws Exception {
IOFileFilter filter = new WildcardFilter("*.txt");
final List<String> patternList = Arrays.asList("*.txt", "*.xml", "*.gif");
- final IOFileFilter listFilter = new WildcardFilter( patternList );
- final File txtFile = new File( "test.txt" );
- final File bmpFile = new File( "test.bmp" );
- final File dir = new File( "src/java" );
+ final IOFileFilter listFilter = new WildcardFilter(patternList);
+ final File txtFile = new File("test.txt");
+ final Path txtPath = txtFile.toPath();
+ final File bmpFile = new File("test.bmp");
+ final Path bmpPath = bmpFile.toPath();
+ final File dirFile = new File("src/java");
+ final Path dirPath = dirFile.toPath();
assertFiltering(filter, new File("log.txt"), true);
// assertFiltering(filter, new File("log.txt.bak"), false);
+ assertFiltering(filter, new File("log.txt").toPath(), true);
filter = new WildcardFilter("log?.txt");
assertFiltering(filter, new File("log1.txt"), true);
assertFiltering(filter, new File("log12.txt"), false);
+ //
+ assertFiltering(filter, new File("log1.txt").toPath(), true);
+ assertFiltering(filter, new File("log12.txt").toPath(), false);
filter = new WildcardFilter("open??.????04");
assertFiltering(filter, new File("openAB.102504"), true);
assertFiltering(filter, new File("openA.102504"), false);
assertFiltering(filter, new File("openXY.123103"), false);
// assertFiltering(filter, new File("openAB.102504.old"), false);
+ //
+ assertFiltering(filter, new File("openAB.102504").toPath(), true);
+ assertFiltering(filter, new File("openA.102504").toPath(), false);
+ assertFiltering(filter, new File("openXY.123103").toPath(), false);
+// assertFiltering(filter, new File("openAB.102504.old").toPath(), false);
filter = new WildcardFilter(new String[] {"*.java", "*.class"});
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("Test.class"), true);
assertFiltering(filter, new File("Test.jsp"), false);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("Test.class").toPath(), true);
+ assertFiltering(filter, new File("Test.jsp").toPath(), false);
assertFiltering(listFilter, new File("Test.txt"), true);
assertFiltering(listFilter, new File("Test.xml"), true);
assertFiltering(listFilter, new File("Test.gif"), true);
assertFiltering(listFilter, new File("Test.bmp"), false);
-
- assertTrue( listFilter.accept( txtFile ) );
- assertTrue( !listFilter.accept( bmpFile ) );
- assertTrue( !listFilter.accept( dir ) );
-
- assertTrue( listFilter.accept( txtFile.getParentFile(), txtFile.getName() ) );
- assertTrue( !listFilter.accept( bmpFile.getParentFile(), bmpFile.getName() ) );
- assertTrue( !listFilter.accept( dir.getParentFile(), dir.getName() ) );
+ //
+ assertFiltering(listFilter, new File("Test.txt").toPath(), true);
+ assertFiltering(listFilter, new File("Test.xml").toPath(), true);
+ assertFiltering(listFilter, new File("Test.gif").toPath(), true);
+ assertFiltering(listFilter, new File("Test.bmp").toPath(), false);
+
+ assertTrue(listFilter.accept(txtFile));
+ assertTrue(!listFilter.accept(bmpFile));
+ assertTrue(!listFilter.accept(dirFile));
+ //
+ assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath));
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath));
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirPath));
+
+ assertTrue(listFilter.accept(txtFile.getParentFile(), txtFile.getName()));
+ assertTrue(!listFilter.accept(bmpFile.getParentFile(), bmpFile.getName()));
+ assertTrue(!listFilter.accept(dirFile.getParentFile(), dirFile.getName()));
+ //
+ assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath.getParent(), txtPath.getFileName()));
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath.getParent(), bmpPath.getFileName()));
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirPath.getParent(), dirPath.getFileName()));
try {
new WildcardFilter((String) null);
@@ -590,99 +768,149 @@ public class FileFilterTestCase {
IOFileFilter filter = new WildcardFileFilter("*.txt");
assertFiltering(filter, new File("log.txt"), true);
assertFiltering(filter, new File("log.TXT"), false);
+ //
+ assertFiltering(filter, new File("log.txt").toPath(), true);
+ assertFiltering(filter, new File("log.TXT").toPath(), false);
filter = new WildcardFileFilter("*.txt", IOCase.SENSITIVE);
assertFiltering(filter, new File("log.txt"), true);
assertFiltering(filter, new File("log.TXT"), false);
+ //
+ assertFiltering(filter, new File("log.txt").toPath(), true);
+ assertFiltering(filter, new File("log.TXT").toPath(), false);
filter = new WildcardFileFilter("*.txt", IOCase.INSENSITIVE);
assertFiltering(filter, new File("log.txt"), true);
assertFiltering(filter, new File("log.TXT"), true);
+ //
+ assertFiltering(filter, new File("log.txt").toPath(), true);
+ assertFiltering(filter, new File("log.TXT").toPath(), true);
filter = new WildcardFileFilter("*.txt", IOCase.SYSTEM);
assertFiltering(filter, new File("log.txt"), true);
assertFiltering(filter, new File("log.TXT"), WINDOWS);
+ //
+ assertFiltering(filter, new File("log.txt").toPath(), true);
+ assertFiltering(filter, new File("log.TXT").toPath(), WINDOWS);
filter = new WildcardFileFilter("*.txt", null);
assertFiltering(filter, new File("log.txt"), true);
assertFiltering(filter, new File("log.TXT"), false);
+ //
+ assertFiltering(filter, new File("log.txt").toPath(), true);
+ assertFiltering(filter, new File("log.TXT").toPath(), false);
filter = new WildcardFileFilter(new String[] {"*.java", "*.class"});
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("Test.class"), true);
assertFiltering(filter, new File("Test.jsp"), false);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("Test.class").toPath(), true);
+ assertFiltering(filter, new File("Test.jsp").toPath(), false);
filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.SENSITIVE);
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("Test.JAVA"), false);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("Test.JAVA").toPath(), false);
filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.INSENSITIVE);
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("Test.JAVA"), true);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("Test.JAVA").toPath(), true);
filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.SYSTEM);
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("Test.JAVA"), WINDOWS);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("Test.JAVA").toPath(), WINDOWS);
- filter = new WildcardFileFilter(new String[]{"*.java", "*.class"}, null);
+ filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, null);
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("Test.JAVA"), false);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("Test.JAVA").toPath(), false);
final List<String> patternList = Arrays.asList("*.txt", "*.xml", "*.gif");
- final IOFileFilter listFilter = new WildcardFileFilter( patternList );
+ final IOFileFilter listFilter = new WildcardFileFilter(patternList);
assertFiltering(listFilter, new File("Test.txt"), true);
assertFiltering(listFilter, new File("Test.xml"), true);
assertFiltering(listFilter, new File("Test.gif"), true);
assertFiltering(listFilter, new File("Test.bmp"), false);
-
- final File txtFile = new File( "test.txt" );
- final File bmpFile = new File( "test.bmp" );
- final File dir = new File( "src/java" );
- assertTrue( listFilter.accept( txtFile ) );
- assertTrue( !listFilter.accept( bmpFile ) );
- assertTrue( !listFilter.accept( dir ) );
-
- assertTrue( listFilter.accept( txtFile.getParentFile(), txtFile.getName() ) );
- assertTrue( !listFilter.accept( bmpFile.getParentFile(), bmpFile.getName() ) );
- assertTrue( !listFilter.accept( dir.getParentFile(), dir.getName() ) );
+ //
+ assertFiltering(listFilter, new File("Test.txt").toPath(), true);
+ assertFiltering(listFilter, new File("Test.xml").toPath(), true);
+ assertFiltering(listFilter, new File("Test.gif").toPath(), true);
+ assertFiltering(listFilter, new File("Test.bmp").toPath(), false);
+
+ final File txtFile = new File("test.txt");
+ final Path txtPath = txtFile.toPath();
+ final File bmpFile = new File("test.bmp");
+ final Path bmpPath = bmpFile.toPath();
+ final File dirFile = new File("src/java");
+ final Path dirPath = dirFile.toPath();
+ assertTrue(listFilter.accept(txtFile));
+ assertTrue(!listFilter.accept(bmpFile));
+ assertTrue(!listFilter.accept(dirFile));
+ //
+ assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtFile.toPath()));
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpFile.toPath()));
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirFile.toPath()));
+
+ assertTrue(listFilter.accept(txtFile.getParentFile(), txtFile.getName()));
+ assertTrue(!listFilter.accept(bmpFile.getParentFile(), bmpFile.getName()));
+ assertTrue(!listFilter.accept(dirFile.getParentFile(), dirFile.getName()));
+ //
+ assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath.getParent(), txtPath.getFileName()));
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath.getParent(), bmpPath.getFileName()));
+ assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirPath.getParent(), dirPath.getFileName()));
try {
new WildcardFileFilter((String) null);
fail();
- } catch (final IllegalArgumentException ignore) {}
+ } catch (final IllegalArgumentException ignore) {
+ }
try {
new WildcardFileFilter((String[]) null);
fail();
- } catch (final IllegalArgumentException ignore) {}
+ } catch (final IllegalArgumentException ignore) {
+ }
try {
new WildcardFileFilter((List<String>) null);
fail();
- } catch (final IllegalArgumentException ignore) {}
+ } catch (final IllegalArgumentException ignore) {
+ }
}
@Test
public void testDelegateFileFilter() throws Exception {
final OrFileFilter orFilter = new OrFileFilter();
- final File testFile = new File( "test.txt" );
+ final File testFile = new File("test.txt");
IOFileFilter filter = new DelegateFileFilter((FileFilter) orFilter);
- assertFiltering( filter, testFile, false );
+ assertFiltering(filter, testFile, false);
assertNotNull(filter.toString()); // TODO better test
filter = new DelegateFileFilter((FilenameFilter) orFilter);
- assertFiltering( filter, testFile, false );
+ assertFiltering(filter, testFile, false);
assertNotNull(filter.toString()); // TODO better test
try {
new DelegateFileFilter((FileFilter) null);
fail();
- } catch( final IllegalArgumentException ignore ) {
+ } catch (final IllegalArgumentException ignore) {
}
try {
new DelegateFileFilter((FilenameFilter) null);
fail();
- } catch( final IllegalArgumentException ignore ) {
+ } catch (final IllegalArgumentException ignore) {
}
}
@@ -690,8 +918,7 @@ public class FileFilterTestCase {
@Test
public void testMakeCVSAware() throws Exception {
final IOFileFilter filter1 = FileFilterUtils.makeCVSAware(null);
- final IOFileFilter filter2 = FileFilterUtils.makeCVSAware(FileFilterUtils
- .nameFileFilter("test-file1.txt"));
+ final IOFileFilter filter2 = FileFilterUtils.makeCVSAware(FileFilterUtils.nameFileFilter("test-file1.txt"));
File file = new File(temporaryFolder, "CVS");
file.mkdirs();
@@ -701,11 +928,9 @@ public class FileFilterTestCase {
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");
+ throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output2 =
- new BufferedOutputStream(new FileOutputStream(file))) {
+ try (final BufferedOutputStream output2 = new BufferedOutputStream(new FileOutputStream(file))) {
TestUtils.generateTestData(output2, 0);
}
assertFiltering(filter1, file, true);
@@ -713,11 +938,9 @@ public class FileFilterTestCase {
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");
+ throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output1 =
- new BufferedOutputStream(new FileOutputStream(file))) {
+ try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(file))) {
TestUtils.generateTestData(output1, 0);
}
assertFiltering(filter1, file, true);
@@ -725,11 +948,9 @@ public class FileFilterTestCase {
file = new File(temporaryFolder, "CVS");
if (!file.getParentFile().exists()) {
- throw new IOException("Cannot create file " + file
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(file))) {
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(file))) {
TestUtils.generateTestData(output, 0);
}
assertFiltering(filter1, file, true);
@@ -739,8 +960,7 @@ public class FileFilterTestCase {
@Test
public void testMakeSVNAware() throws Exception {
final IOFileFilter filter1 = FileFilterUtils.makeSVNAware(null);
- final IOFileFilter filter2 = FileFilterUtils.makeSVNAware(FileFilterUtils
- .nameFileFilter("test-file1.txt"));
+ final IOFileFilter filter2 = FileFilterUtils.makeSVNAware(FileFilterUtils.nameFileFilter("test-file1.txt"));
File file = new File(temporaryFolder, SVN_DIR_NAME);
file.mkdirs();
@@ -750,11 +970,9 @@ public class FileFilterTestCase {
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");
+ throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output2 =
- new BufferedOutputStream(new FileOutputStream(file))) {
+ try (final BufferedOutputStream output2 = new BufferedOutputStream(new FileOutputStream(file))) {
TestUtils.generateTestData(output2, 0);
}
assertFiltering(filter1, file, true);
@@ -762,11 +980,9 @@ public class FileFilterTestCase {
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");
+ throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output1 =
- new BufferedOutputStream(new FileOutputStream(file))) {
+ try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(file))) {
TestUtils.generateTestData(output1, 0);
}
assertFiltering(filter1, file, true);
@@ -774,11 +990,9 @@ public class FileFilterTestCase {
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");
+ throw new IOException("Cannot create file " + file + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(file))) {
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(file))) {
TestUtils.generateTestData(output, 0);
}
assertFiltering(filter1, file, true);
@@ -788,33 +1002,31 @@ public class FileFilterTestCase {
@Test
public void testAgeFilter() throws Exception {
final File oldFile = new File(temporaryFolder, "old.txt");
+ final Path oldPath = oldFile.toPath();
final File reference = new File(temporaryFolder, "reference.txt");
final File newFile = new File(temporaryFolder, "new.txt");
+ final Path newPath = newFile.toPath();
if (!oldFile.getParentFile().exists()) {
- throw new IOException("Cannot create file " + oldFile
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + oldFile + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output1 =
- new BufferedOutputStream(new FileOutputStream(oldFile))) {
+ try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(oldFile))) {
TestUtils.generateTestData(output1, 0);
}
do {
try {
TestUtils.sleep(1000);
- } catch(final InterruptedException ie) {
+ } catch (final InterruptedException ie) {
// ignore
}
if (!reference.getParentFile().exists()) {
- throw new IOException("Cannot create file " + reference
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + reference + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(reference))) {
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(reference))) {
TestUtils.generateTestData(output, 0);
}
- } while( oldFile.lastModified() == reference.lastModified() );
+ } while (oldFile.lastModified() == reference.lastModified());
final Date date = new Date();
final long now = date.getTime();
@@ -822,18 +1034,16 @@ public class FileFilterTestCase {
do {
try {
TestUtils.sleep(1000);
- } catch(final InterruptedException ie) {
+ } catch (final InterruptedException ie) {
// ignore
}
if (!newFile.getParentFile().exists()) {
- throw new IOException("Cannot create file " + newFile
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + newFile + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(newFile))) {
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(newFile))) {
TestUtils.generateTestData(output, 0);
}
- } while( reference.lastModified() == newFile.lastModified() );
+ } while (reference.lastModified() == newFile.lastModified());
final IOFileFilter filter1 = FileFilterUtils.ageFileFilter(now);
final IOFileFilter filter2 = FileFilterUtils.ageFileFilter(now, true);
@@ -863,26 +1073,41 @@ public class FileFilterTestCase {
assertFiltering(filter7, newFile, false);
assertFiltering(filter8, newFile, false);
assertFiltering(filter9, newFile, true);
+ //
+ assertFiltering(filter1, oldPath, true);
+ assertFiltering(filter2, oldPath, true);
+ assertFiltering(filter3, oldPath, false);
+ assertFiltering(filter4, oldPath, true);
+ assertFiltering(filter5, oldPath, true);
+ assertFiltering(filter6, oldPath, false);
+ assertFiltering(filter7, oldPath, true);
+ assertFiltering(filter8, oldPath, true);
+ assertFiltering(filter9, oldPath, false);
+ assertFiltering(filter1, newPath, false);
+ assertFiltering(filter2, newPath, false);
+ assertFiltering(filter3, newPath, true);
+ assertFiltering(filter4, newPath, false);
+ assertFiltering(filter5, newPath, false);
+ assertFiltering(filter6, newPath, true);
+ assertFiltering(filter7, newPath, false);
+ assertFiltering(filter8, newPath, false);
+ assertFiltering(filter9, newPath, true);
}
@Test
- public void testSizeFilter() throws Exception {
+ public void testSizeFilterOnFiles() throws Exception {
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");
+ throw new IOException("Cannot create file " + smallFile + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output1 =
- new BufferedOutputStream(new FileOutputStream(smallFile))) {
+ try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(smallFile))) {
TestUtils.generateTestData(output1, 32);
}
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");
+ throw new IOException("Cannot create file " + largeFile + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(largeFile))){
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(largeFile))) {
TestUtils.generateTestData(output, 128);
}
final IOFileFilter filter1 = FileFilterUtils.sizeFileFilter(64);
@@ -922,28 +1147,89 @@ public class FileFilterTestCase {
}
@Test
- public void testHidden() throws Exception {
- final File hiddenDir = new File(SVN_DIR_NAME);
- if (hiddenDir.exists()) {
- assertFiltering(HiddenFileFilter.HIDDEN, hiddenDir, hiddenDir.isHidden());
- assertFiltering(HiddenFileFilter.VISIBLE, hiddenDir, !hiddenDir.isHidden());
+ public void testSizeFilterOnPaths() throws Exception {
+ final Path smallFile = Paths.get(temporaryFolder.toString(), "small.txt");
+ if (!Files.exists(smallFile.getParent())) {
+ throw new IOException("Cannot create file " + smallFile + " as the parent directory does not exist");
+ }
+ try (OutputStream output = Files.newOutputStream(smallFile)) {
+ TestUtils.generateTestData(output, 32);
+ }
+ final Path largeFile = Paths.get(temporaryFolder.toString(), "large.txt");
+ if (!Files.exists(largeFile.getParent())) {
+ throw new IOException("Cannot create file " + largeFile + " as the parent directory does not exist");
+ }
+ try (OutputStream output = Files.newOutputStream(largeFile)) {
+ TestUtils.generateTestData(output, 128);
+ }
+ final IOFileFilter filter1 = FileFilterUtils.sizeFileFilter(64);
+ final IOFileFilter filter2 = FileFilterUtils.sizeFileFilter(64, true);
+ final IOFileFilter filter3 = FileFilterUtils.sizeFileFilter(64, false);
+
+ assertFiltering(filter1, smallFile, false);
+ assertFiltering(filter2, smallFile, false);
+ assertFiltering(filter3, smallFile, true);
+ assertFiltering(filter1, largeFile, true);
+ assertFiltering(filter2, largeFile, true);
+ assertFiltering(filter3, largeFile, false);
+
+ // size range tests
+ final IOFileFilter filter4 = FileFilterUtils.sizeRangeFileFilter(33, 127);
+ final IOFileFilter filter5 = FileFilterUtils.sizeRangeFileFilter(32, 127);
+ final IOFileFilter filter6 = FileFilterUtils.sizeRangeFileFilter(33, 128);
+ final IOFileFilter filter7 = FileFilterUtils.sizeRangeFileFilter(31, 129);
+ final IOFileFilter filter8 = FileFilterUtils.sizeRangeFileFilter(128, 128);
+
+ assertFiltering(filter4, smallFile, false);
+ assertFiltering(filter4, largeFile, false);
+ assertFiltering(filter5, smallFile, true);
+ assertFiltering(filter5, largeFile, false);
+ assertFiltering(filter6, smallFile, false);
+ assertFiltering(filter6, largeFile, true);
+ assertFiltering(filter7, smallFile, true);
+ assertFiltering(filter7, largeFile, true);
+ assertFiltering(filter8, largeFile, true);
+
+ try {
+ FileFilterUtils.sizeFileFilter(-1);
+ fail();
+ } catch (final IllegalArgumentException ex) {
+ // expected
}
- assertFiltering(HiddenFileFilter.HIDDEN, temporaryFolder, false);
+ }
+
+ @Test
+ public void testHidden() throws Exception {
+ final File hiddenDirFile = new File(SVN_DIR_NAME);
+ final Path hiddenDirPath = hiddenDirFile.toPath();
+ if (hiddenDirFile.exists()) {
+ assertFiltering(HiddenFileFilter.HIDDEN, hiddenDirFile, hiddenDirFile.isHidden());
+ assertFiltering(HiddenFileFilter.HIDDEN, hiddenDirPath, hiddenDirFile.isHidden());
+ assertFiltering(HiddenFileFilter.VISIBLE, hiddenDirFile, !hiddenDirFile.isHidden());
+ assertFiltering(HiddenFileFilter.VISIBLE, hiddenDirPath, !hiddenDirFile.isHidden());
+ }
+ final Path path = temporaryFolder.toPath();
+ assertFiltering(HiddenFileFilter.HIDDEN, temporaryFolder, false);
+ assertFiltering(HiddenFileFilter.HIDDEN, path, false);
assertFiltering(HiddenFileFilter.VISIBLE, temporaryFolder, true);
+ assertFiltering(HiddenFileFilter.VISIBLE, path, true);
}
@Test
public void testCanExecute() throws Exception {
assumeTrue(SystemUtils.IS_OS_WINDOWS);
final File executableFile = File.createTempFile(getClass().getSimpleName(), ".temp");
+ final Path executablePath = executableFile.toPath();
try {
try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(executableFile))) {
TestUtils.generateTestData(output, 32);
}
assertTrue(executableFile.setExecutable(true));
assertFiltering(CanExecuteFileFilter.CAN_EXECUTE, executableFile, true);
+ assertFiltering(CanExecuteFileFilter.CAN_EXECUTE, executablePath, true);
executableFile.setExecutable(false);
assertFiltering(CanExecuteFileFilter.CANNOT_EXECUTE, executableFile, false);
+ assertFiltering(CanExecuteFileFilter.CANNOT_EXECUTE, executablePath, false);
} finally {
executableFile.delete();
}
@@ -952,37 +1238,40 @@ public class FileFilterTestCase {
@Test
public void testCanRead() throws Exception {
final File readOnlyFile = new File(temporaryFolder, "read-only-file1.txt");
+ final Path readOnlyPath = readOnlyFile.toPath();
if (!readOnlyFile.getParentFile().exists()) {
- throw new IOException("Cannot create file " + readOnlyFile
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + readOnlyFile + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(readOnlyFile))){
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(readOnlyFile))) {
TestUtils.generateTestData(output, 32);
}
assertTrue(readOnlyFile.setReadOnly());
- assertFiltering(CanReadFileFilter.CAN_READ, readOnlyFile, true);
- assertFiltering(CanReadFileFilter.CANNOT_READ, readOnlyFile, false);
+ assertFiltering(CanReadFileFilter.CAN_READ, readOnlyFile, true);
+ assertFiltering(CanReadFileFilter.CAN_READ, readOnlyPath, true);
+ assertFiltering(CanReadFileFilter.CANNOT_READ, readOnlyFile, false);
+ assertFiltering(CanReadFileFilter.CANNOT_READ, readOnlyPath, false);
assertFiltering(CanReadFileFilter.READ_ONLY, readOnlyFile, true);
+ assertFiltering(CanReadFileFilter.READ_ONLY, readOnlyPath, true);
readOnlyFile.delete();
}
@Test
public void testCanWrite() throws Exception {
final File readOnlyFile = new File(temporaryFolder, "read-only-file2.txt");
+ final Path readOnlyPath = readOnlyFile.toPath();
if (!readOnlyFile.getParentFile().exists()) {
- throw new IOException("Cannot create file " + readOnlyFile
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + readOnlyFile + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(readOnlyFile))){
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(readOnlyFile))) {
TestUtils.generateTestData(output, 32);
}
assertTrue(readOnlyFile.setReadOnly());
- assertFiltering(CanWriteFileFilter.CAN_WRITE, temporaryFolder, true);
+ assertFiltering(CanWriteFileFilter.CAN_WRITE, temporaryFolder, true);
assertFiltering(CanWriteFileFilter.CANNOT_WRITE, temporaryFolder, false);
- assertFiltering(CanWriteFileFilter.CAN_WRITE, readOnlyFile, false);
+ assertFiltering(CanWriteFileFilter.CAN_WRITE, readOnlyFile, false);
+ assertFiltering(CanWriteFileFilter.CAN_WRITE, readOnlyPath, false);
assertFiltering(CanWriteFileFilter.CANNOT_WRITE, readOnlyFile, true);
+ assertFiltering(CanWriteFileFilter.CANNOT_WRITE, readOnlyPath, true);
readOnlyFile.delete();
}
@@ -990,50 +1279,56 @@ public class FileFilterTestCase {
public void testEmpty() throws Exception {
// Empty Dir
- final File emptyDir = new File(temporaryFolder, "empty-dir");
- emptyDir.mkdirs();
- assertFiltering(EmptyFileFilter.EMPTY, emptyDir, true);
- assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, false);
+ final File emptyDirFile = new File(temporaryFolder, "empty-dir");
+ final Path emptyDirPath = emptyDirFile.toPath();
+ emptyDirFile.mkdirs();
+ assertFiltering(EmptyFileFilter.EMPTY, emptyDirFile, true);
+ assertFiltering(EmptyFileFilter.EMPTY, emptyDirPath, true);
+ assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirFile, false);
+ assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirPath, false);
// Empty File
- final File emptyFile = new File(emptyDir, "empty-file.txt");
+ final File emptyFile = new File(emptyDirFile, "empty-file.txt");
+ final Path emptyPath = emptyFile.toPath();
if (!emptyFile.getParentFile().exists()) {
- throw new IOException("Cannot create file " + emptyFile
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + emptyFile + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output1 =
- new BufferedOutputStream(new FileOutputStream(emptyFile))){
+ try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(emptyFile))) {
TestUtils.generateTestData(output1, 0);
}
assertFiltering(EmptyFileFilter.EMPTY, emptyFile, true);
+ assertFiltering(EmptyFileFilter.EMPTY, emptyPath, true);
assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyFile, false);
+ assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyPath, false);
// Not Empty Dir
- assertFiltering(EmptyFileFilter.EMPTY, emptyDir, false);
- assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, true);
+ assertFiltering(EmptyFileFilter.EMPTY, emptyDirFile, false);
+ assertFiltering(EmptyFileFilter.EMPTY, emptyDirPath, false);
+ assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirFile, true);
+ assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirPath, true);
// Not Empty File
- final File notEmptyFile = new File(emptyDir, "not-empty-file.txt");
+ final File notEmptyFile = new File(emptyDirFile, "not-empty-file.txt");
+ final Path notEmptyPath = notEmptyFile.toPath();
if (!notEmptyFile.getParentFile().exists()) {
- throw new IOException("Cannot create file " + notEmptyFile
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + notEmptyFile + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(notEmptyFile))){
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(notEmptyFile))) {
TestUtils.generateTestData(output, 32);
}
assertFiltering(EmptyFileFilter.EMPTY, notEmptyFile, false);
+ assertFiltering(EmptyFileFilter.EMPTY, notEmptyPath, false);
assertFiltering(EmptyFileFilter.NOT_EMPTY, notEmptyFile, true);
- FileUtils.forceDelete(emptyDir);
+ assertFiltering(EmptyFileFilter.NOT_EMPTY, notEmptyPath, true);
+ FileUtils.forceDelete(emptyDirFile);
}
- //-----------------------------------------------------------------------
+ // -----------------------------------------------------------------------
@Test
public void testMakeDirectoryOnly() throws Exception {
assertSame(DirectoryFileFilter.DIRECTORY, FileFilterUtils.makeDirectoryOnly(null));
- final IOFileFilter filter = FileFilterUtils.makeDirectoryOnly(
- FileFilterUtils.nameFileFilter("B"));
+ final IOFileFilter filter = FileFilterUtils.makeDirectoryOnly(FileFilterUtils.nameFileFilter("B"));
final File fileA = new File(temporaryFolder, "A");
final File fileB = new File(temporaryFolder, "B");
@@ -1048,19 +1343,15 @@ public class FileFilterTestCase {
FileUtils.deleteDirectory(fileB);
if (!fileA.getParentFile().exists()) {
- throw new IOException("Cannot create file " + fileA
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + fileA + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output1 =
- new BufferedOutputStream(new FileOutputStream(fileA))) {
+ try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(fileA))) {
TestUtils.generateTestData(output1, 32);
}
if (!fileB.getParentFile().exists()) {
- throw new IOException("Cannot create file " + fileB
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + fileB + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(fileB))) {
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(fileB))) {
TestUtils.generateTestData(output, 32);
}
@@ -1071,13 +1362,12 @@ public class FileFilterTestCase {
fileB.delete();
}
- //-----------------------------------------------------------------------
+ // -----------------------------------------------------------------------
@Test
public void testMakeFileOnly() throws Exception {
assertSame(FileFileFilter.FILE, FileFilterUtils.makeFileOnly(null));
- final IOFileFilter filter = FileFilterUtils.makeFileOnly(
- FileFilterUtils.nameFileFilter("B"));
+ final IOFileFilter filter = FileFilterUtils.makeFileOnly(FileFilterUtils.nameFileFilter("B"));
final File fileA = new File(temporaryFolder, "A");
final File fileB = new File(temporaryFolder, "B");
@@ -1092,19 +1382,15 @@ public class FileFilterTestCase {
FileUtils.deleteDirectory(fileB);
if (!fileA.getParentFile().exists()) {
- throw new IOException("Cannot create file " + fileA
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + fileA + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output1 =
- new BufferedOutputStream(new FileOutputStream(fileA))){
+ try (final BufferedOutputStream output1 = new BufferedOutputStream(new FileOutputStream(fileA))) {
TestUtils.generateTestData(output1, 32);
}
if (!fileB.getParentFile().exists()) {
- throw new IOException("Cannot create file " + fileB
- + " as the parent directory does not exist");
+ throw new IOException("Cannot create file " + fileB + " as the parent directory does not exist");
}
- try (final BufferedOutputStream output =
- new BufferedOutputStream(new FileOutputStream(fileB))){
+ try (final BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(fileB))) {
TestUtils.generateTestData(output, 32);
}
@@ -1115,45 +1401,57 @@ public class FileFilterTestCase {
fileB.delete();
}
- //-----------------------------------------------------------------------
+ // -----------------------------------------------------------------------
@Test
public void testMagicNumberFileFilterBytes() throws Exception {
- final byte[] classFileMagicNumber = new byte[] { (byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE };
+ final byte[] classFileMagicNumber = new byte[] {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE};
final String xmlFileContent = "<?xml version=\"1.0\" encoding=\"UTF-8\">\n" + "<element>text</element>";
- final File classFileA = new File(temporaryFolder, "A.class");
- final File xmlFileB = new File(temporaryFolder, "B.xml");
+ final File classAFile = new File(temporaryFolder, "A.class");
+ final Path classAPath = classAFile.toPath();
+ final File xmlBFile = new File(temporaryFolder, "B.xml");
+ final Path xmlBPath = xmlBFile.toPath();
final File emptyFile = new File(temporaryFolder, "C.xml");
- final File dir = new File(temporaryFolder, "D");
- dir.mkdirs();
+ final Path emptyPath = emptyFile.toPath();
+ final File dirFile = new File(temporaryFolder, "D");
+ final Path dirPath = dirFile.toPath();
+ dirFile.mkdirs();
- try (final OutputStream classFileAStream = FileUtils.openOutputStream(classFileA)) {
+ try (final OutputStream classFileAStream = FileUtils.openOutputStream(classAFile)) {
IOUtils.write(classFileMagicNumber, classFileAStream);
TestUtils.generateTestData(classFileAStream, 32);
}
- FileUtils.write(xmlFileB, xmlFileContent, StandardCharsets.UTF_8);
+ FileUtils.write(xmlBFile, xmlFileContent, StandardCharsets.UTF_8);
FileUtils.touch(emptyFile);
IOFileFilter filter = new MagicNumberFileFilter(classFileMagicNumber);
- assertFiltering(filter, classFileA, true);
- assertFiltering(filter, xmlFileB, false);
+ assertFiltering(filter, classAFile, true);
+ assertFiltering(filter, classAPath, true);
+ assertFiltering(filter, xmlBFile, false);
+ assertFiltering(filter, xmlBPath, false);
assertFiltering(filter, emptyFile, false);
- assertFiltering(filter, dir, false);
+ assertFiltering(filter, emptyPath, false);
+ assertFiltering(filter, dirFile, false);
+ assertFiltering(filter, dirPath, false);
filter = FileFilterUtils.magicNumberFileFilter(classFileMagicNumber);
- assertFiltering(filter, classFileA, true);
- assertFiltering(filter, xmlFileB, false);
+ assertFiltering(filter, classAFile, true);
+ assertFiltering(filter, classAPath, true);
+ assertFiltering(filter, xmlBFile, false);
+ assertFiltering(filter, xmlBPath, false);
assertFiltering(filter, emptyFile, false);
- assertFiltering(filter, dir, false);
+ assertFiltering(filter, emptyPath, false);
+ assertFiltering(filter, dirFile, false);
+ assertFiltering(filter, dirPath, false);
}
@Test
public void testMagicNumberFileFilterBytesOffset() throws Exception {
- final byte[] tarMagicNumber = new byte[] { 0x75, 0x73, 0x74, 0x61, 0x72 };
+ final byte[] tarMagicNumber = new byte[] {0x75, 0x73, 0x74, 0x61, 0x72};
final long tarMagicNumberOffset = 257;
final File tarFileA = new File(temporaryFolder, "A.tar");
@@ -1188,7 +1486,7 @@ public class FileFilterTestCase {
@Test
public void testMagicNumberFileFilterString() throws Exception {
- final byte[] classFileMagicNumber = new byte[] { (byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE };
+ final byte[] classFileMagicNumber = new byte[] {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE};
final String xmlFileContent = "<?xml version=\"1.0\" encoding=\"UTF-8\">\n" + "<element>text</element>";
final String xmlMagicNumber = "<?xml version=\"1.0\"";
@@ -1255,7 +1553,7 @@ public class FileFilterTestCase {
@Test
public void testMagicNumberFileFilterValidation() {
try {
- new MagicNumberFileFilter((String)null, 0);
+ new MagicNumberFileFilter((String) null, 0);
fail();
} catch (final IllegalArgumentException iae) {
// expected
@@ -1273,31 +1571,31 @@ public class FileFilterTestCase {
// expected
}
try {
- new MagicNumberFileFilter((byte[])null, 0);
+ new MagicNumberFileFilter((byte[]) null, 0);
fail();
} catch (final IllegalArgumentException iae) {
// expected
}
try {
- new MagicNumberFileFilter(new byte[]{0}, -1);
+ new MagicNumberFileFilter(new byte[] {0}, -1);
fail();
} catch (final IllegalArgumentException iae) {
// expected
}
try {
- new MagicNumberFileFilter(new byte[]{}, 0);
+ new MagicNumberFileFilter(new byte[] {}, 0);
fail();
} catch (final IllegalArgumentException iae) {
// expected
}
-}
+ }
/*
- * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)}
- * that tests that the method properly filters files from the list.
+ * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)} that tests that the method properly filters
+ * files from the list.
*/
@Test
- public void testFilterArray() throws Exception {
+ public void testFilterArray_IOFileFilter() throws Exception {
final File fileA = TestUtils.newFile(temporaryFolder, "A");
final File fileB = TestUtils.newFile(temporaryFolder, "B");
@@ -1310,8 +1608,43 @@ public class FileFilterTestCase {
}
/*
- * Test method for {@link FileFilterUtils#filter(IOFileFilter, java.lang.Iterable)}
- * that tests that the method properly filters files from the list.
+ * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)} that tests that the method properly filters
+ * files from the list.
+ */
+ @Test
+ public void testFilterArray_PathVisitorFileFilter_FileExistsNo() throws Exception {
+ final File fileA = TestUtils.newFile(temporaryFolder, "A");
+ final File fileB = TestUtils.newFile(temporaryFolder, "B");
+
+ final IOFileFilter filter = new PathVisitorFileFilter(new NameFileFilter("A"));
+
+ final File[] filtered = FileFilterUtils.filter(filter, fileA, fileB);
+
+ assertEquals(1, filtered.length);
+ assertEquals(fileA, filtered[0]);
+ }
+
+ /*
+ * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)} that tests that the method properly filters
+ * files from the list.
+ */
+ @Test
+ public void testFilterArray_PathVisitorFileFilter_FileExistsYes() throws Exception {
+ final File fileA = TestUtils.newFile(temporaryFolder, "A");
+ final File fileB = TestUtils.newFile(temporaryFolder, "B");
+ FileUtils.write(fileA, "test", StandardCharsets.US_ASCII);
+
+ final IOFileFilter filter = new PathVisitorFileFilter(new NameFileFilter("A"));
+
+ final File[] filtered = FileFilterUtils.filter(filter, fileA, fileB);
+
+ assertEquals(1, filtered.length);
+ assertEquals(fileA, filtered[0]);
+ }
+
+ /*
+ * Test method for {@link FileFilterUtils#filter(IOFileFilter, java.lang.Iterable)} that tests that the method
+ * properly filters files from the list.
*/
@Test
public void testFilterArray_fromList() throws Exception {
@@ -1328,12 +1661,10 @@ public class FileFilterTestCase {
}
/*
- * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)}
- * that tests {@code null} parameters and {@code null} elements
- * in the provided list.
+ * Test method for {@link FileFilterUtils#filter(IOFileFilter, File...)} that tests {@code null} parameters.
*/
@Test
- public void testFilterArrayNullParameters() throws Exception {
+ public void testFilterFilesArrayNullParameters() throws Exception {
final File fileA = TestUtils.newFile(temporaryFolder, "A");
final File fileB = TestUtils.newFile(temporaryFolder, "B");
try {
@@ -1344,20 +1675,36 @@ public class FileFilterTestCase {
}
final IOFileFilter filter = FileFilterUtils.trueFileFilter();
+ FileFilterUtils.filter(filter, fileA, null);
+
+ final File[] filtered = FileFilterUtils.filter(filter, (File[]) null);
+ assertEquals(0, filtered.length);
+ }
+
+ /*
+ * Test method for {@link FileFilterUtils#filter(IOFileFilter, Path...)}.
+ */
+ @Test
+ public void testFilterPathsArrayNullParameters() throws Exception {
+ final Path fileA = TestUtils.newFile(temporaryFolder, "A").toPath();
+ final Path fileB = TestUtils.newFile(temporaryFolder, "B").toPath();
try {
- FileFilterUtils.filter(filter, fileA, null);
+ PathUtils.filter(null, fileA, fileB);
fail();
- } catch (final IllegalArgumentException iae) {
- // Test passes, exception thrown for list containing null
+ } catch (final NullPointerException iae) {
+ // Test passes, exception thrown for null filter
}
- final File[] filtered = FileFilterUtils.filter(filter, (File[])null);
+ final IOFileFilter filter = FileFilterUtils.trueFileFilter();
+ PathUtils.filter(filter, fileA, null);
+
+ final File[] filtered = FileFilterUtils.filter(filter, (File[]) null);
assertEquals(0, filtered.length);
}
/*
- * Test method for {@link FileFilterUtils#filterList(IOFileFilter, java.lang.Iterable)}
- * that tests that the method properly filters files from the list.
+ * Test method for {@link FileFilterUtils#filterList(IOFileFilter, java.lang.Iterable)} that tests that the method
+ * properly filters files from the list.
*/
@Test
public void testFilterList() throws Exception {
@@ -1374,8 +1721,8 @@ public class FileFilterTestCase {
}
/*
- * Test method for {@link FileFilterUtils#filterList(IOFileFilter, File...)}
- * that tests that the method properly filters files from the list.
+ * Test method for {@link FileFilterUtils#filterList(IOFileFilter, File...)} that tests that the method properly
+ * filters files from the list.
*/
@Test
public void testFilterList_fromArray() throws Exception {
@@ -1391,9 +1738,8 @@ public class FileFilterTestCase {
}
/*
- * Test method for {@link FileFilterUtils#filterList(IOFileFilter, java.lang.Iterable)}
- * that tests {@code null} parameters and {@code null} elements
- * in the provided list.
+ * Test method for {@link FileFilterUtils#filterList(IOFileFilter, java.lang.Iterable)} that tests {@code null}
+ * parameters and {@code null} elements in the provided list.
*/
@Test
public void testFilterListNullParameters() {
@@ -1407,18 +1753,17 @@ public class FileFilterTestCase {
final IOFileFilter filter = FileFilterUtils.trueFileFilter();
try {
FileFilterUtils.filterList(filter, Collections.singletonList((File) null));
- fail();
} catch (final IllegalArgumentException iae) {
// Test passes, exception thrown for list containing null
}
- final List<File> filteredList = FileFilterUtils.filterList(filter, (List<File>)null);
+ final List<File> filteredList = FileFilterUtils.filterList(filter, (List<File>) null);
assertEquals(0, filteredList.size());
}
/*
- * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, java.lang.Iterable)}
- * that tests that the method properly filters files from the set.
+ * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, java.lang.Iterable)} that tests that the method
+ * properly filters files from the set.
*/
@Test
public void testFilterSet() throws Exception {
@@ -1435,8 +1780,8 @@ public class FileFilterTestCase {
}
/*
- * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, File...)}
- * that tests that the method properly filters files from the set.
+ * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, File...)} that tests that the method properly
+ * filters files from the set.
*/
@Test
public void testFilterSet_fromArray() throws Exception {
@@ -1452,12 +1797,11 @@ public class FileFilterTestCase {
}
/*
- * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, java.lang.Iterable)}
- * that tests {@code null} parameters and {@code null} elements
- * in the provided set.
+ * Test method for {@link FileFilterUtils#filterSet(IOFileFilter, java.lang.Iterable)} that tests {@code null}
+ * parameters and {@code null} elements in the provided set.
*/
@Test
- public void testFilterSetNullParameters() {
+ public void testFilterSetNullParameters() {
try {
FileFilterUtils.filterSet(null, Collections.<File>emptySet());
fail();
@@ -1468,12 +1812,11 @@ public class FileFilterTestCase {
final IOFileFilter filter = FileFilterUtils.trueFileFilter();
try {
FileFilterUtils.filterSet(filter, new HashSet<>(Collections.singletonList((File) null)));
- fail();
} catch (final IllegalArgumentException iae) {
// Test passes, exception thrown for set containing null
}
- final Set<File> filteredSet = FileFilterUtils.filterSet(filter, (Set<File>)null);
+ final Set<File> filteredSet = FileFilterUtils.filterSet(filter, (Set<File>) null);
assertEquals(0, filteredSet.size());
}
@@ -1491,7 +1834,7 @@ public class FileFilterTestCase {
// expected
}
try {
- FileFilterUtils.toList(new IOFileFilter[]{null});
+ FileFilterUtils.toList(new IOFileFilter[] {null});
fail("Expected IllegalArgumentException");
} catch (final IllegalArgumentException ignore) {
// expected
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 3b2783f..0962973 100644
--- a/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/IOFileFilterAbstractTestCase.java
@@ -40,7 +40,9 @@ public abstract class IOFileFilterAbstractTestCase {
// Note. This only tests the (File, String) version if the parent of
// the File passed in is not null
assertEquals(expected, filter.accept(file),
- "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
+ "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
+ assertEquals(expected, filter.accept(file.toPath()),
+ "test " + testNumber + " Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file);
if (file != null && file.getParentFile() != null) {
assertEquals(expected, filter.accept(file.getParentFile(), file.getName()),
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 ed75f14..cc16f84 100644
--- a/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java
+++ b/src/test/java/org/apache/commons/io/filefilter/RegexFileFilterTestCase.java
@@ -20,6 +20,8 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
import java.io.File;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
import java.util.regex.Pattern;
import org.apache.commons.io.IOCase;
@@ -45,32 +47,69 @@ public class RegexFileFilterTestCase {
}
}
+ public void assertFiltering(final IOFileFilter filter, final Path file, final boolean expected) throws Exception {
+ // Note. This only tests the (Path, Path) version if the parent of
+ // the Path passed in is not null
+ final FileVisitResult expectedFileVisitResult = AbstractFileFilter.toFileVisitResult(expected);
+ assertEquals(expectedFileVisitResult, filter.accept(file),
+ "Filter(Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for " + file);
+
+ if (file != null && file.getParent() != null) {
+ assertEquals(expectedFileVisitResult, filter.accept(file.getParent(), file.getFileName()),
+ "Filter(Path, Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for "
+ + file);
+ } else if (file == null) {
+ assertEquals(expectedFileVisitResult, filter.accept(file),
+ "Filter(Path, Path) " + filter.getClass().getName() + " not " + expectedFileVisitResult + " for null");
+ }
+ }
+
@Test
public void testRegex() throws Exception {
IOFileFilter filter = new RegexFileFilter("^.*[tT]est(-\\d+)?\\.java$");
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("test-10.java"), true);
assertFiltering(filter, new File("test-.java"), false);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("test-10.java").toPath(), true);
+ assertFiltering(filter, new File("test-.java").toPath(), false);
filter = new RegexFileFilter("^[Tt]est.java$");
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("test.java"), true);
assertFiltering(filter, new File("tEST.java"), false);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("test.java").toPath(), true);
+ assertFiltering(filter, new File("tEST.java").toPath(), false);
filter = new RegexFileFilter(Pattern.compile("^test.java$", Pattern.CASE_INSENSITIVE));
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("test.java"), true);
assertFiltering(filter, new File("tEST.java"), true);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("test.java").toPath(), true);
+ assertFiltering(filter, new File("tEST.java").toPath(), true);
filter = new RegexFileFilter("^test.java$", Pattern.CASE_INSENSITIVE);
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("test.java"), true);
assertFiltering(filter, new File("tEST.java"), true);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("test.java").toPath(), true);
+ assertFiltering(filter, new File("tEST.java").toPath(), true);
filter = new RegexFileFilter("^test.java$", IOCase.INSENSITIVE);
assertFiltering(filter, new File("Test.java"), true);
assertFiltering(filter, new File("test.java"), true);
assertFiltering(filter, new File("tEST.java"), true);
+ //
+ assertFiltering(filter, new File("Test.java").toPath(), true);
+ assertFiltering(filter, new File("test.java").toPath(), true);
+ assertFiltering(filter, new File("tEST.java").toPath(), true);
try {
new RegexFileFilter((String)null);