1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.io.filefilter;
18
19 import static org.junit.jupiter.api.Assertions.assertEquals;
20 import static org.junit.jupiter.api.Assertions.assertFalse;
21 import static org.junit.jupiter.api.Assertions.assertNotNull;
22 import static org.junit.jupiter.api.Assertions.assertNull;
23 import static org.junit.jupiter.api.Assertions.assertSame;
24 import static org.junit.jupiter.api.Assertions.assertThrows;
25 import static org.junit.jupiter.api.Assertions.assertTrue;
26 import static org.junit.jupiter.api.Assertions.fail;
27 import static org.junit.jupiter.api.Assumptions.assumeTrue;
28
29 import java.io.BufferedOutputStream;
30 import java.io.File;
31 import java.io.FileFilter;
32 import java.io.FilenameFilter;
33 import java.io.IOException;
34 import java.io.OutputStream;
35 import java.nio.charset.StandardCharsets;
36 import java.nio.file.FileVisitResult;
37 import java.nio.file.Files;
38 import java.nio.file.Path;
39 import java.nio.file.Paths;
40 import java.util.ArrayList;
41 import java.util.Arrays;
42 import java.util.Collections;
43 import java.util.Date;
44 import java.util.HashSet;
45 import java.util.List;
46 import java.util.Set;
47
48 import org.apache.commons.io.FileUtils;
49 import org.apache.commons.io.IOCase;
50 import org.apache.commons.io.IOUtils;
51 import org.apache.commons.io.file.PathUtils;
52 import org.apache.commons.io.file.TempFile;
53 import org.apache.commons.io.test.TestUtils;
54 import org.apache.commons.lang3.SystemUtils;
55 import org.junit.jupiter.api.Test;
56
57
58
59
60 public class FileFilterTest extends AbstractFilterTest {
61
62 @Test
63 public void testAgeFilter() throws Exception {
64 final File oldFile = new File(temporaryFolder, "old.txt");
65 final Path oldPath = oldFile.toPath();
66 final File reference = new File(temporaryFolder, "reference.txt");
67 final File newFile = new File(temporaryFolder, "new.txt");
68 final Path newPath = newFile.toPath();
69
70 if (!oldFile.getParentFile().exists()) {
71 fail("Cannot create file " + oldFile + " as the parent directory does not exist");
72 }
73 try (BufferedOutputStream output1 = new BufferedOutputStream(Files.newOutputStream(oldFile.toPath()))) {
74 TestUtils.generateTestData(output1, 0);
75 }
76
77 do {
78 try {
79 TestUtils.sleep(1000);
80 } catch (final InterruptedException ie) {
81
82 }
83 if (!reference.getParentFile().exists()) {
84 fail("Cannot create file " + reference + " as the parent directory does not exist");
85 }
86 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(reference.toPath()))) {
87 TestUtils.generateTestData(output, 0);
88 }
89 } while (equalsLastModified(oldFile, reference));
90
91 final Date date = new Date();
92 final long now = date.getTime();
93
94 do {
95 try {
96 TestUtils.sleep(1000);
97 } catch (final InterruptedException ie) {
98
99 }
100 if (!newFile.getParentFile().exists()) {
101 fail("Cannot create file " + newFile + " as the parent directory does not exist");
102 }
103 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(newFile.toPath()))) {
104 TestUtils.generateTestData(output, 0);
105 }
106 } while (equalsLastModified(reference, newFile));
107
108 final IOFileFilter filter1 = FileFilterUtils.ageFileFilter(now);
109 final IOFileFilter filter2 = FileFilterUtils.ageFileFilter(now, true);
110 final IOFileFilter filter3 = FileFilterUtils.ageFileFilter(now, false);
111 final IOFileFilter filter4 = FileFilterUtils.ageFileFilter(date);
112 final IOFileFilter filter5 = FileFilterUtils.ageFileFilter(date, true);
113 final IOFileFilter filter6 = FileFilterUtils.ageFileFilter(date, false);
114 final IOFileFilter filter7 = FileFilterUtils.ageFileFilter(reference);
115 final IOFileFilter filter8 = FileFilterUtils.ageFileFilter(reference, true);
116 final IOFileFilter filter9 = FileFilterUtils.ageFileFilter(reference, false);
117
118 assertFiltering(filter1, oldFile, true);
119 assertFiltering(filter2, oldFile, true);
120 assertFiltering(filter3, oldFile, false);
121 assertFiltering(filter4, oldFile, true);
122 assertFiltering(filter5, oldFile, true);
123 assertFiltering(filter6, oldFile, false);
124 assertFiltering(filter7, oldFile, true);
125 assertFiltering(filter8, oldFile, true);
126 assertFiltering(filter9, oldFile, false);
127 assertFiltering(filter1, newFile, false);
128 assertFiltering(filter2, newFile, false);
129 assertFiltering(filter3, newFile, true);
130 assertFiltering(filter4, newFile, false);
131 assertFiltering(filter5, newFile, false);
132 assertFiltering(filter6, newFile, true);
133 assertFiltering(filter7, newFile, false);
134 assertFiltering(filter8, newFile, false);
135 assertFiltering(filter9, newFile, true);
136
137 assertFiltering(filter1, oldPath, true);
138 assertFiltering(filter2, oldPath, true);
139 assertFiltering(filter3, oldPath, false);
140 assertFiltering(filter4, oldPath, true);
141 assertFiltering(filter5, oldPath, true);
142 assertFiltering(filter6, oldPath, false);
143 assertFiltering(filter7, oldPath, true);
144 assertFiltering(filter8, oldPath, true);
145 assertFiltering(filter9, oldPath, false);
146 assertFiltering(filter1, newPath, false);
147 assertFiltering(filter2, newPath, false);
148 assertFiltering(filter3, newPath, true);
149 assertFiltering(filter4, newPath, false);
150 assertFiltering(filter5, newPath, false);
151 assertFiltering(filter6, newPath, true);
152 assertFiltering(filter7, newPath, false);
153 assertFiltering(filter8, newPath, false);
154 assertFiltering(filter9, newPath, true);
155 }
156
157 @Test
158 public void testAnd() throws IOException {
159 final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
160 final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
161 assertFiltering(trueFilter.and(trueFilter), new File("foo.test"), true);
162 assertFiltering(trueFilter.and(falseFilter), new File("foo.test"), false);
163 assertFiltering(falseFilter.and(trueFilter), new File("foo.test"), false);
164 assertFiltering(falseFilter.and(falseFilter), new File("foo.test"), false);
165 }
166
167 @Test
168 public void testAnd2() throws IOException {
169 final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
170 final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
171 assertFiltering(new AndFileFilter(trueFilter, trueFilter), new File("foo.test"), true);
172 assertFiltering(new AndFileFilter(trueFilter, falseFilter), new File("foo.test"), false);
173 assertFiltering(new AndFileFilter(falseFilter, trueFilter), new File("foo.test"), false);
174 assertFiltering(new AndFileFilter(falseFilter, falseFilter), new File("foo.test"), false);
175
176 final List<IOFileFilter> filters = new ArrayList<>();
177 assertFiltering(new AndFileFilter(filters), new File("test"), false);
178 assertFiltering(new AndFileFilter(), new File("test"), false);
179
180 assertThrows(NullPointerException.class, () -> new AndFileFilter(falseFilter, null));
181 assertThrows(NullPointerException.class, () -> new AndFileFilter(null, falseFilter));
182 assertThrows(NullPointerException.class, () -> new AndFileFilter((List<IOFileFilter>) null));
183 }
184
185 @Test
186 public void testAndArray() throws IOException {
187 final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
188 final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
189 assertFiltering(new AndFileFilter(trueFilter, trueFilter, trueFilter), new File("foo.test"), true);
190 assertFiltering(new AndFileFilter(trueFilter, falseFilter, falseFilter), new File("foo.test"), false);
191 assertFiltering(new AndFileFilter(falseFilter, trueFilter, trueFilter), new File("foo.test"), false);
192 assertFiltering(new AndFileFilter(falseFilter, falseFilter, falseFilter), new File("foo.test"), false);
193
194 final List<IOFileFilter> filters = new ArrayList<>();
195 assertFiltering(new AndFileFilter(filters), new File("test"), false);
196 assertFiltering(new AndFileFilter(), new File("test"), false);
197 }
198
199 @Test
200 public void testCanExecute() throws Exception {
201 assumeTrue(SystemUtils.IS_OS_WINDOWS);
202 try (TempFile executablePath = TempFile.create(getClass().getSimpleName(), null)) {
203 final File executableFile = executablePath.toFile();
204 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(executablePath.get()))) {
205 TestUtils.generateTestData(output, 32);
206 }
207 assertTrue(executableFile.setExecutable(true));
208 assertFiltering(CanExecuteFileFilter.CAN_EXECUTE, executablePath.get(), true);
209 assertFiltering(CanExecuteFileFilter.CAN_EXECUTE, (Path) null, false);
210 assertFiltering(CanExecuteFileFilter.CAN_EXECUTE, executableFile, true);
211 assertFiltering(CanExecuteFileFilter.CAN_EXECUTE, (File) null, false);
212 executableFile.setExecutable(false);
213 assertFiltering(CanExecuteFileFilter.CANNOT_EXECUTE, executablePath.get(), false);
214 assertFiltering(CanExecuteFileFilter.CANNOT_EXECUTE, (Path) null, true);
215 assertFiltering(CanExecuteFileFilter.CANNOT_EXECUTE, executableFile, false);
216 assertFiltering(CanExecuteFileFilter.CANNOT_EXECUTE, (File) null, true);
217 }
218 }
219
220 @Test
221 public void testCanRead() throws Exception {
222 final File readOnlyFile = new File(temporaryFolder, "read-only-file1.txt");
223 final Path readOnlyPath = readOnlyFile.toPath();
224 if (!readOnlyFile.getParentFile().exists()) {
225 fail("Cannot create file " + readOnlyFile + " as the parent directory does not exist");
226 }
227 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(readOnlyFile.toPath()))) {
228 TestUtils.generateTestData(output, 32);
229 }
230 assertTrue(readOnlyFile.setReadOnly());
231 assertFiltering(CanReadFileFilter.CAN_READ, readOnlyFile, true);
232 assertFiltering(CanReadFileFilter.CAN_READ, (File) null, false);
233 assertFiltering(CanReadFileFilter.CAN_READ, readOnlyPath, true);
234 assertFiltering(CanReadFileFilter.CAN_READ, (Path) null, false);
235 assertFiltering(CanReadFileFilter.CANNOT_READ, readOnlyFile, false);
236 assertFiltering(CanReadFileFilter.CANNOT_READ, (File) null, true);
237 assertFiltering(CanReadFileFilter.CANNOT_READ, readOnlyPath, false);
238 assertFiltering(CanReadFileFilter.CANNOT_READ, (Path) null, true);
239 assertFiltering(CanReadFileFilter.READ_ONLY, readOnlyFile, true);
240 assertFiltering(CanReadFileFilter.READ_ONLY, (File) null, false);
241 assertFiltering(CanReadFileFilter.READ_ONLY, readOnlyPath, true);
242 assertFiltering(CanReadFileFilter.READ_ONLY, (Path) null, false);
243 readOnlyFile.delete();
244 }
245
246 @Test
247 public void testCanWrite() throws Exception {
248 final File readOnlyFile = new File(temporaryFolder, "read-only-file2.txt");
249 final Path readOnlyPath = readOnlyFile.toPath();
250 if (!readOnlyFile.getParentFile().exists()) {
251 fail("Cannot create file " + readOnlyFile + " as the parent directory does not exist");
252 }
253 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(readOnlyFile.toPath()))) {
254 TestUtils.generateTestData(output, 32);
255 }
256 assertTrue(readOnlyFile.setReadOnly());
257 assertFiltering(CanWriteFileFilter.CAN_WRITE, temporaryFolder, true);
258 assertFiltering(CanWriteFileFilter.CAN_WRITE, readOnlyFile, false);
259 assertFiltering(CanWriteFileFilter.CAN_WRITE, (File) null, false);
260 assertFiltering(CanWriteFileFilter.CAN_WRITE, readOnlyPath, false);
261 assertFiltering(CanWriteFileFilter.CAN_WRITE, (Path) null, false);
262 assertFiltering(CanWriteFileFilter.CANNOT_WRITE, temporaryFolder, false);
263 assertFiltering(CanWriteFileFilter.CANNOT_WRITE, readOnlyFile, true);
264 assertFiltering(CanWriteFileFilter.CANNOT_WRITE, readOnlyPath, true);
265 assertFiltering(CanWriteFileFilter.CANNOT_WRITE, (File) null, true);
266 assertFiltering(CanWriteFileFilter.CANNOT_WRITE, (Path) null, true);
267 readOnlyFile.delete();
268 }
269
270 @Test
271 public void testDelegateFileFilter() throws IOException {
272 final OrFileFilter orFilter = new OrFileFilter();
273 final File testFile = new File("test.txt");
274
275 IOFileFilter filter = new DelegateFileFilter((FileFilter) orFilter);
276 assertFiltering(filter, testFile, false);
277 assertNotNull(filter.toString());
278
279 filter = new DelegateFileFilter((FilenameFilter) orFilter);
280 assertFiltering(filter, testFile, false);
281 assertNotNull(filter.toString());
282
283 assertThrows(NullPointerException.class, () -> new DelegateFileFilter((FileFilter) null));
284 assertThrows(NullPointerException.class, () -> new DelegateFileFilter((FilenameFilter) null));
285 }
286
287 @Test
288 public void testDelegation() {
289 assertNotNull(FileFilterUtils.asFileFilter((FileFilter) FalseFileFilter.INSTANCE));
290 assertNotNull(FileFilterUtils.asFileFilter((FilenameFilter) FalseFileFilter.INSTANCE).toString());
291 }
292
293 @SuppressWarnings("deprecation")
294 @Test
295 public void testDeprecatedWildcard() throws IOException {
296 IOFileFilter filter = new WildcardFilter("*.txt");
297 final List<String> patternList = Arrays.asList("*.txt", "*.xml", "*.gif");
298 final IOFileFilter listFilter = new WildcardFilter(patternList);
299 final File txtFile = new File("test.txt");
300 final Path txtPath = txtFile.toPath();
301 final File bmpFile = new File("test.bmp");
302 final Path bmpPath = bmpFile.toPath();
303 final File dirFile = new File("src/java");
304 final Path dirPath = dirFile.toPath();
305
306 assertFiltering(filter, new File("log.txt"), true);
307
308 assertFiltering(filter, new File("log.txt").toPath(), true);
309
310 filter = new WildcardFilter("log?.txt");
311 assertFiltering(filter, new File("log1.txt"), true);
312 assertFiltering(filter, new File("log12.txt"), false);
313
314 assertFiltering(filter, new File("log1.txt").toPath(), true);
315 assertFiltering(filter, new File("log12.txt").toPath(), false);
316
317 filter = new WildcardFilter("open??.????04");
318 assertFiltering(filter, new File("openAB.102504"), true);
319 assertFiltering(filter, new File("openA.102504"), false);
320 assertFiltering(filter, new File("openXY.123103"), false);
321
322
323 assertFiltering(filter, new File("openAB.102504").toPath(), true);
324 assertFiltering(filter, new File("openA.102504").toPath(), false);
325 assertFiltering(filter, new File("openXY.123103").toPath(), false);
326
327
328 filter = new WildcardFilter("*.java", "*.class");
329 assertFiltering(filter, new File("Test.java"), true);
330 assertFiltering(filter, new File("Test.class"), true);
331 assertFiltering(filter, new File("Test.jsp"), false);
332
333 assertFiltering(filter, new File("Test.java").toPath(), true);
334 assertFiltering(filter, new File("Test.class").toPath(), true);
335 assertFiltering(filter, new File("Test.jsp").toPath(), false);
336
337 assertFiltering(listFilter, new File("Test.txt"), true);
338 assertFiltering(listFilter, new File("Test.xml"), true);
339 assertFiltering(listFilter, new File("Test.gif"), true);
340 assertFiltering(listFilter, new File("Test.bmp"), false);
341
342 assertFiltering(listFilter, new File("Test.txt").toPath(), true);
343 assertFiltering(listFilter, new File("Test.xml").toPath(), true);
344 assertFiltering(listFilter, new File("Test.gif").toPath(), true);
345 assertFiltering(listFilter, new File("Test.bmp").toPath(), false);
346
347
348 assertTrue(listFilter.accept(txtFile));
349 assertFalse(listFilter.accept(bmpFile));
350 assertFalse(listFilter.accept(dirFile));
351
352 assertTrue(listFilter.matches(txtPath));
353 assertFalse(listFilter.matches(bmpPath));
354 assertFalse(listFilter.matches(dirPath));
355
356 assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath, null));
357 assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath, null));
358 assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirPath, null));
359
360 assertTrue(listFilter.accept(txtFile.getParentFile(), txtFile.getName()));
361 assertFalse(listFilter.accept(bmpFile.getParentFile(), bmpFile.getName()));
362 assertFalse(listFilter.accept(dirFile.getParentFile(), dirFile.getName()));
363
364 assertEquals(FileVisitResult.CONTINUE, listFilter.accept(txtPath, null));
365 assertEquals(FileVisitResult.TERMINATE, listFilter.accept(bmpPath, null));
366 assertEquals(FileVisitResult.TERMINATE, listFilter.accept(dirPath, null));
367
368 assertThrows(NullPointerException.class, () -> new WildcardFilter((String) null));
369 assertThrows(NullPointerException.class, () -> new WildcardFilter((String[]) null));
370 assertThrows(NullPointerException.class, () -> new WildcardFilter((List<String>) null));
371 }
372
373 @Test
374 public void testDirectory() throws IOException {
375
376 final IOFileFilter filter = new DirectoryFileFilter();
377
378 assertFiltering(filter, new File("src/"), true);
379 assertFiltering(filter, new File("src/").toPath(), true);
380 assertFiltering(filter, new File("src/main/java/"), true);
381 assertFiltering(filter, new File("src/main/java/").toPath(), true);
382
383 assertFiltering(filter, new File("pom.xml"), false);
384 assertFiltering(filter, new File("pom.xml").toPath(), false);
385
386 assertFiltering(filter, new File("imaginary"), false);
387 assertFiltering(filter, new File("imaginary").toPath(), false);
388 assertFiltering(filter, new File("imaginary/"), false);
389 assertFiltering(filter, new File("imaginary/").toPath(), false);
390
391 assertFiltering(filter, new File("LICENSE.txt"), false);
392 assertFiltering(filter, new File("LICENSE.txt").toPath(), false);
393
394 assertFiltering(filter, (File) null, false);
395 assertFiltering(filter, (Path) null, false);
396
397 assertSame(DirectoryFileFilter.DIRECTORY, DirectoryFileFilter.INSTANCE);
398 }
399
400 @Test
401 public void testEmpty() throws Exception {
402
403
404 final File emptyDirFile = new File(temporaryFolder, "empty-dir");
405 final Path emptyDirPath = emptyDirFile.toPath();
406 emptyDirFile.mkdirs();
407 assertFiltering(EmptyFileFilter.EMPTY, emptyDirFile, true);
408 assertFiltering(EmptyFileFilter.EMPTY, emptyDirPath, true);
409 assertFiltering(EmptyFileFilter.EMPTY, (File) null, true);
410 assertFiltering(EmptyFileFilter.EMPTY, (Path) null, true);
411 assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirFile, false);
412 assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirPath, false);
413 assertFiltering(EmptyFileFilter.NOT_EMPTY, (File) null, false);
414 assertFiltering(EmptyFileFilter.NOT_EMPTY, (Path) null, false);
415
416
417 final File emptyFile = new File(emptyDirFile, "empty-file.txt");
418 final Path emptyPath = emptyFile.toPath();
419 if (!emptyFile.getParentFile().exists()) {
420 fail("Cannot create file " + emptyFile + " as the parent directory does not exist");
421 }
422 try (BufferedOutputStream output1 = new BufferedOutputStream(Files.newOutputStream(emptyFile.toPath()))) {
423 TestUtils.generateTestData(output1, 0);
424 }
425 assertFiltering(EmptyFileFilter.EMPTY, emptyFile, true);
426 assertFiltering(EmptyFileFilter.EMPTY, emptyPath, true);
427 assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyFile, false);
428 assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyPath, false);
429
430
431 assertFiltering(EmptyFileFilter.EMPTY, emptyDirFile, false);
432 assertFiltering(EmptyFileFilter.EMPTY, emptyDirPath, false);
433 assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirFile, true);
434 assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDirPath, true);
435
436
437 final File notEmptyFile = new File(emptyDirFile, "not-empty-file.txt");
438 final Path notEmptyPath = notEmptyFile.toPath();
439 if (!notEmptyFile.getParentFile().exists()) {
440 fail("Cannot create file " + notEmptyFile + " as the parent directory does not exist");
441 }
442 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(notEmptyFile.toPath()))) {
443 TestUtils.generateTestData(output, 32);
444 }
445 assertFiltering(EmptyFileFilter.EMPTY, notEmptyFile, false);
446 assertFiltering(EmptyFileFilter.EMPTY, notEmptyPath, false);
447 assertFiltering(EmptyFileFilter.NOT_EMPTY, notEmptyFile, true);
448 assertFiltering(EmptyFileFilter.NOT_EMPTY, notEmptyPath, true);
449 FileUtils.forceDelete(emptyDirFile);
450 }
451
452 @Test
453 public void testEnsureTestCoverage() {
454 assertNotNull(new FileFilterUtils());
455 }
456
457 @Test
458 public void testFalse() throws IOException {
459 final IOFileFilter filter = FileFilterUtils.falseFileFilter();
460 assertFiltering(filter, new File("foo.test"), false);
461 assertFiltering(filter, new File("foo.test").toPath(), false);
462 assertFiltering(filter, new File("foo"), false);
463 assertFiltering(filter, new File("foo").toPath(), false);
464 assertFiltering(filter, (File) null, false);
465 assertFiltering(filter, (Path) null, false);
466 assertSame(FalseFileFilter.FALSE, FalseFileFilter.INSTANCE);
467 assertSame(TrueFileFilter.TRUE, FalseFileFilter.INSTANCE.negate());
468 assertSame(TrueFileFilter.INSTANCE, FalseFileFilter.INSTANCE.negate());
469 assertNotNull(FalseFileFilter.INSTANCE.toString());
470 }
471
472 @Test
473 public void testFileEqualsFilter() throws IOException {
474 assertFooBarFileFiltering(
475 new FileEqualsFileFilter(new File("foo")).or(new FileEqualsFileFilter(new File("bar"))));
476 }
477
478 @Test
479 public void testFileFilterUtils_and() throws IOException {
480 final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
481 final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
482 assertFiltering(FileFilterUtils.and(trueFilter, trueFilter, trueFilter), new File("foo.test"), true);
483 assertFiltering(FileFilterUtils.and(trueFilter, falseFilter, trueFilter), new File("foo.test"), false);
484 assertFiltering(FileFilterUtils.and(falseFilter, trueFilter), new File("foo.test"), false);
485 assertFiltering(FileFilterUtils.and(falseFilter, falseFilter), new File("foo.test"), false);
486 }
487
488 @Test
489 public void testFileFilterUtils_or() throws IOException {
490 final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
491 final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
492 final File testFile = new File("foo.test");
493 assertFiltering(FileFilterUtils.or(trueFilter, trueFilter), testFile, true);
494 assertFiltering(FileFilterUtils.or(trueFilter, trueFilter, falseFilter), testFile, true);
495 assertFiltering(FileFilterUtils.or(falseFilter, trueFilter), testFile, true);
496 assertFiltering(FileFilterUtils.or(falseFilter, falseFilter, falseFilter), testFile, false);
497 }
498
499 @Test
500 public void testFiles() throws IOException {
501
502 final IOFileFilter filter = FileFileFilter.INSTANCE;
503
504 assertFiltering(filter, (File) null, false);
505 assertFiltering(filter, new File("src/"), false);
506 assertFiltering(filter, new File("src/").toPath(), false);
507 assertFiltering(filter, new File("src/java/"), false);
508 assertFiltering(filter, new File("src/java/").toPath(), false);
509
510 assertFiltering(filter, new File("pom.xml"), true);
511 assertFiltering(filter, new File("pom.xml").toPath(), true);
512
513 assertFiltering(filter, new File("imaginary"), false);
514 assertFiltering(filter, new File("imaginary").toPath(), false);
515 assertFiltering(filter, new File("imaginary/"), false);
516 assertFiltering(filter, new File("imaginary/").toPath(), false);
517
518 assertFiltering(filter, new File("LICENSE.txt"), true);
519 assertFiltering(filter, new File("LICENSE.txt").toPath(), true);
520 }
521
522
523
524
525
526 @Test
527 public void testFilterArray_fromList() throws Exception {
528 final File fileA = TestUtils.newFile(temporaryFolder, "A");
529 final File fileB = TestUtils.newFile(temporaryFolder, "B");
530 final List<File> fileList = Arrays.asList(fileA, fileB);
531
532 final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
533
534 final File[] filtered = FileFilterUtils.filter(filter, fileList);
535
536 assertEquals(1, filtered.length);
537 assertEquals(fileA, filtered[0]);
538 }
539
540
541
542
543
544 @Test
545 public void testFilterArray_IOFileFilter() throws Exception {
546 final File fileA = TestUtils.newFile(temporaryFolder, "A");
547 final File fileB = TestUtils.newFile(temporaryFolder, "B");
548
549 final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
550
551 final File[] filtered = FileFilterUtils.filter(filter, fileA, fileB);
552
553 assertEquals(1, filtered.length);
554 assertEquals(fileA, filtered[0]);
555 }
556
557
558
559
560
561 @Test
562 public void testFilterArray_PathVisitorFileFilter_FileExistsNo() throws Exception {
563 final File fileA = TestUtils.newFile(temporaryFolder, "A");
564 final File fileB = TestUtils.newFile(temporaryFolder, "B");
565
566 final IOFileFilter filter = new PathVisitorFileFilter(new NameFileFilter("A"));
567
568 final File[] filtered = FileFilterUtils.filter(filter, fileA, fileB);
569
570 assertEquals(1, filtered.length);
571 assertEquals(fileA, filtered[0]);
572 }
573
574
575
576
577
578 @Test
579 public void testFilterArray_PathVisitorFileFilter_FileExistsYes() throws Exception {
580 final File fileA = TestUtils.newFile(temporaryFolder, "A");
581 final File fileB = TestUtils.newFile(temporaryFolder, "B");
582 FileUtils.write(fileA, "test", StandardCharsets.US_ASCII);
583
584 final IOFileFilter filter = new PathVisitorFileFilter(new NameFileFilter("A"));
585
586 final File[] filtered = FileFilterUtils.filter(filter, fileA, fileB);
587
588 assertEquals(1, filtered.length);
589 assertEquals(fileA, filtered[0]);
590 }
591
592
593
594
595 @Test
596 public void testFilterFilesArrayNullParameters() throws Exception {
597 final File fileA = TestUtils.newFile(temporaryFolder, "A");
598 final File fileB = TestUtils.newFile(temporaryFolder, "B");
599 assertThrows(NullPointerException.class, () -> FileFilterUtils.filter(null, fileA, fileB));
600
601 final IOFileFilter filter = FileFilterUtils.trueFileFilter();
602 FileFilterUtils.filter(filter, fileA, null);
603
604 final File[] filtered = FileFilterUtils.filter(filter, (File[]) null);
605 assertEquals(0, filtered.length);
606 }
607
608
609
610
611
612 @Test
613 public void testFilterList() throws Exception {
614 final File fileA = TestUtils.newFile(temporaryFolder, "A");
615 final File fileB = TestUtils.newFile(temporaryFolder, "B");
616 final List<File> fileList = Arrays.asList(fileA, fileB);
617
618 final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
619
620 final List<File> filteredList = FileFilterUtils.filterList(filter, fileList);
621
622 assertTrue(filteredList.contains(fileA));
623 assertFalse(filteredList.contains(fileB));
624 }
625
626
627
628
629
630 @Test
631 public void testFilterList_fromArray() throws Exception {
632 final File fileA = TestUtils.newFile(temporaryFolder, "A");
633 final File fileB = TestUtils.newFile(temporaryFolder, "B");
634
635 final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
636
637 final List<File> filteredList = FileFilterUtils.filterList(filter, fileA, fileB);
638
639 assertTrue(filteredList.contains(fileA));
640 assertFalse(filteredList.contains(fileB));
641 }
642
643
644
645
646
647 @Test
648 public void testFilterListNullParameters() {
649 assertThrows(NullPointerException.class, () -> FileFilterUtils.filterList(null, Collections.emptyList()));
650
651 final IOFileFilter filter = FileFilterUtils.trueFileFilter();
652 List<File> filteredList = FileFilterUtils.filterList(filter, Collections.singletonList(null));
653 assertEquals(1, filteredList.size());
654 assertNull(filteredList.get(0));
655
656 filteredList = FileFilterUtils.filterList(filter, (List<File>) null);
657 assertEquals(0, filteredList.size());
658 }
659
660
661
662
663 @Test
664 public void testFilterPathsArrayNullParameters() throws Exception {
665 final Path fileA = TestUtils.newFile(temporaryFolder, "A").toPath();
666 final Path fileB = TestUtils.newFile(temporaryFolder, "B").toPath();
667 assertThrows(NullPointerException.class, () -> PathUtils.filter(null, fileA, fileB));
668
669 final IOFileFilter filter = FileFilterUtils.trueFileFilter();
670 PathUtils.filter(filter, fileA, null);
671
672 final File[] filtered = FileFilterUtils.filter(filter, (File[]) null);
673 assertEquals(0, filtered.length);
674 }
675
676
677
678
679
680 @Test
681 public void testFilterSet() throws Exception {
682 final File fileA = TestUtils.newFile(temporaryFolder, "A");
683 final File fileB = TestUtils.newFile(temporaryFolder, "B");
684 final Set<File> fileList = new HashSet<>(Arrays.asList(fileA, fileB));
685
686 final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
687
688 final Set<File> filteredSet = FileFilterUtils.filterSet(filter, fileList);
689
690 assertTrue(filteredSet.contains(fileA));
691 assertFalse(filteredSet.contains(fileB));
692 }
693
694
695
696
697
698 @Test
699 public void testFilterSet_fromArray() throws Exception {
700 final File fileA = TestUtils.newFile(temporaryFolder, "A");
701 final File fileB = TestUtils.newFile(temporaryFolder, "B");
702
703 final IOFileFilter filter = FileFilterUtils.nameFileFilter("A");
704
705 final Set<File> filteredSet = FileFilterUtils.filterSet(filter, fileA, fileB);
706
707 assertTrue(filteredSet.contains(fileA));
708 assertFalse(filteredSet.contains(fileB));
709 }
710
711
712
713
714
715 @Test
716 public void testFilterSetNullParameters() {
717 assertThrows(NullPointerException.class, () -> FileFilterUtils.filterSet(null, Collections.emptySet()));
718
719 final IOFileFilter filter = FileFilterUtils.trueFileFilter();
720 FileFilterUtils.filterSet(filter, new HashSet<>(Collections.singletonList(null)));
721
722 final Set<File> filteredSet = FileFilterUtils.filterSet(filter, (Set<File>) null);
723 assertEquals(0, filteredSet.size());
724 }
725
726 @Test
727 public void testHidden() throws IOException {
728 final File hiddenDirFile = new File(SVN_DIR_NAME);
729 final Path hiddenDirPath = hiddenDirFile.toPath();
730 if (hiddenDirFile.exists()) {
731 assertFiltering(HiddenFileFilter.HIDDEN, hiddenDirFile, hiddenDirFile.isHidden());
732 assertFiltering(HiddenFileFilter.HIDDEN, hiddenDirPath, hiddenDirFile.isHidden());
733 assertFiltering(HiddenFileFilter.VISIBLE, hiddenDirFile, !hiddenDirFile.isHidden());
734 assertFiltering(HiddenFileFilter.VISIBLE, hiddenDirPath, !hiddenDirFile.isHidden());
735 }
736 final Path path = temporaryFolder.toPath();
737 assertFiltering(HiddenFileFilter.HIDDEN, temporaryFolder, false);
738 assertFiltering(HiddenFileFilter.HIDDEN, path, false);
739 assertFiltering(HiddenFileFilter.HIDDEN, (Path) null, true);
740 assertFiltering(HiddenFileFilter.VISIBLE, temporaryFolder, true);
741 assertFiltering(HiddenFileFilter.VISIBLE, path, true);
742 assertFiltering(HiddenFileFilter.VISIBLE, (Path) null, false);
743 }
744
745 @Test
746 public void testMagicNumberFileFilterBytes() throws Exception {
747 final byte[] classFileMagicNumber = {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE};
748 final String xmlFileContent = "<?xml version=\"1.0\" encoding=\"UTF-8\">\n" + "<element>text</element>";
749
750 final File classAFile = new File(temporaryFolder, "A.class");
751 final Path classAPath = classAFile.toPath();
752 final File xmlBFile = new File(temporaryFolder, "B.xml");
753 final Path xmlBPath = xmlBFile.toPath();
754 final File emptyFile = new File(temporaryFolder, "C.xml");
755 final Path emptyPath = emptyFile.toPath();
756 final File dirFile = new File(temporaryFolder, "D");
757 final Path dirPath = dirFile.toPath();
758 dirFile.mkdirs();
759
760 try (OutputStream classFileAStream = FileUtils.openOutputStream(classAFile)) {
761 IOUtils.write(classFileMagicNumber, classFileAStream);
762 TestUtils.generateTestData(classFileAStream, 32);
763 }
764
765 FileUtils.write(xmlBFile, xmlFileContent, StandardCharsets.UTF_8);
766 FileUtils.touch(emptyFile);
767
768 IOFileFilter filter = new MagicNumberFileFilter(classFileMagicNumber);
769
770 assertFiltering(filter, classAFile, true);
771 assertFiltering(filter, classAPath, true);
772 assertFiltering(filter, xmlBFile, false);
773 assertFiltering(filter, xmlBPath, false);
774 assertFiltering(filter, emptyFile, false);
775 assertFiltering(filter, emptyPath, false);
776 assertFiltering(filter, dirFile, false);
777 assertFiltering(filter, dirPath, false);
778
779 filter = FileFilterUtils.magicNumberFileFilter(classFileMagicNumber);
780
781 assertFiltering(filter, classAFile, true);
782 assertFiltering(filter, classAPath, true);
783 assertFiltering(filter, xmlBFile, false);
784 assertFiltering(filter, xmlBPath, false);
785 assertFiltering(filter, emptyFile, false);
786 assertFiltering(filter, emptyPath, false);
787 assertFiltering(filter, dirFile, false);
788 assertFiltering(filter, dirPath, false);
789 }
790
791 @Test
792 public void testMagicNumberFileFilterBytesOffset() throws Exception {
793 final byte[] tarMagicNumber = {0x75, 0x73, 0x74, 0x61, 0x72};
794 final long tarMagicNumberOffset = 257;
795
796 final File tarFileA = new File(temporaryFolder, "A.tar");
797 final File randomFileB = new File(temporaryFolder, "B.txt");
798 final File dir = new File(temporaryFolder, "D");
799 dir.mkdirs();
800
801 try (OutputStream tarFileAStream = FileUtils.openOutputStream(tarFileA)) {
802 TestUtils.generateTestData(tarFileAStream, tarMagicNumberOffset);
803 IOUtils.write(tarMagicNumber, tarFileAStream);
804 }
805
806 if (!randomFileB.getParentFile().exists()) {
807 fail("Cannot create file " + randomFileB + " as the parent directory does not exist");
808 }
809 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(randomFileB.toPath()))) {
810 TestUtils.generateTestData(output, 2 * tarMagicNumberOffset);
811 }
812
813 IOFileFilter filter = new MagicNumberFileFilter(tarMagicNumber, tarMagicNumberOffset);
814
815 assertFiltering(filter, tarFileA, true);
816 assertFiltering(filter, randomFileB, false);
817 assertFiltering(filter, dir, false);
818
819 filter = FileFilterUtils.magicNumberFileFilter(tarMagicNumber, tarMagicNumberOffset);
820
821 assertFiltering(filter, tarFileA, true);
822 assertFiltering(filter, randomFileB, false);
823 assertFiltering(filter, dir, false);
824 }
825
826 @Test
827 public void testMagicNumberFileFilterString() throws Exception {
828 final byte[] classFileMagicNumber = {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE};
829 final String xmlFileContent = "<?xml version=\"1.0\" encoding=\"UTF-8\">\n" + "<element>text</element>";
830 final String xmlMagicNumber = "<?xml version=\"1.0\"";
831
832 final File classFileA = new File(temporaryFolder, "A.class");
833 final File xmlFileB = new File(temporaryFolder, "B.xml");
834 final File dir = new File(temporaryFolder, "D");
835 dir.mkdirs();
836
837 try (OutputStream classFileAStream = FileUtils.openOutputStream(classFileA)) {
838 IOUtils.write(classFileMagicNumber, classFileAStream);
839 TestUtils.generateTestData(classFileAStream, 32);
840 }
841
842 FileUtils.write(xmlFileB, xmlFileContent, StandardCharsets.UTF_8);
843
844 IOFileFilter filter = new MagicNumberFileFilter(xmlMagicNumber);
845
846 assertFiltering(filter, classFileA, false);
847 assertFiltering(filter, xmlFileB, true);
848 assertFiltering(filter, dir, false);
849
850 filter = FileFilterUtils.magicNumberFileFilter(xmlMagicNumber);
851
852 assertFiltering(filter, classFileA, false);
853 assertFiltering(filter, xmlFileB, true);
854 assertFiltering(filter, dir, false);
855 }
856
857 @Test
858 public void testMagicNumberFileFilterStringOffset() throws Exception {
859 final String tarMagicNumber = "ustar";
860 final long tarMagicNumberOffset = 257;
861
862 final File tarFileA = new File(temporaryFolder, "A.tar");
863 final File randomFileB = new File(temporaryFolder, "B.txt");
864 final File dir = new File(temporaryFolder, "D");
865 dir.mkdirs();
866
867 try (OutputStream tarFileAStream = FileUtils.openOutputStream(tarFileA)) {
868 TestUtils.generateTestData(tarFileAStream, tarMagicNumberOffset);
869 IOUtils.write(tarMagicNumber, tarFileAStream, StandardCharsets.UTF_8);
870 }
871
872 if (!randomFileB.getParentFile().exists()) {
873 fail("Cannot create file " + randomFileB + " as the parent directory does not exist");
874 }
875 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(randomFileB.toPath()))) {
876 TestUtils.generateTestData(output, 2 * tarMagicNumberOffset);
877 }
878
879 IOFileFilter filter = new MagicNumberFileFilter(tarMagicNumber, tarMagicNumberOffset);
880
881 assertFiltering(filter, tarFileA, true);
882 assertFiltering(filter, randomFileB, false);
883 assertFiltering(filter, dir, false);
884
885 filter = FileFilterUtils.magicNumberFileFilter(tarMagicNumber, tarMagicNumberOffset);
886
887 assertFiltering(filter, tarFileA, true);
888 assertFiltering(filter, randomFileB, false);
889 assertFiltering(filter, dir, false);
890 }
891
892 @Test
893 public void testMagicNumberFileFilterValidation() {
894 assertThrows(NullPointerException.class, () -> new MagicNumberFileFilter((String) null, 0));
895 assertThrows(IllegalArgumentException.class, () -> new MagicNumberFileFilter("0", -1));
896 assertThrows(IllegalArgumentException.class, () -> new MagicNumberFileFilter("", 0));
897 assertThrows(NullPointerException.class, () -> new MagicNumberFileFilter((byte[]) null, 0));
898 assertThrows(IllegalArgumentException.class, () -> new MagicNumberFileFilter(new byte[] {0}, -1));
899 assertThrows(IllegalArgumentException.class, () -> new MagicNumberFileFilter(new byte[] {}, 0));
900 }
901
902 @Test
903 public void testMakeCVSAware() throws Exception {
904 final IOFileFilter filter1 = FileFilterUtils.makeCVSAware(null);
905 final IOFileFilter filter2 = FileFilterUtils.makeCVSAware(FileFilterUtils.nameFileFilter("test-file1.txt"));
906
907 File file = new File(temporaryFolder, "CVS");
908 file.mkdirs();
909 assertFiltering(filter1, file, false);
910 assertFiltering(filter2, file, false);
911 FileUtils.deleteDirectory(file);
912
913 file = new File(temporaryFolder, "test-file1.txt");
914 if (!file.getParentFile().exists()) {
915 fail("Cannot create file " + file + " as the parent directory does not exist");
916 }
917 try (BufferedOutputStream output2 = new BufferedOutputStream(Files.newOutputStream(file.toPath()))) {
918 TestUtils.generateTestData(output2, 0);
919 }
920 assertFiltering(filter1, file, true);
921 assertFiltering(filter2, file, true);
922
923 file = new File(temporaryFolder, "test-file2.log");
924 if (!file.getParentFile().exists()) {
925 fail("Cannot create file " + file + " as the parent directory does not exist");
926 }
927 try (BufferedOutputStream output1 = new BufferedOutputStream(Files.newOutputStream(file.toPath()))) {
928 TestUtils.generateTestData(output1, 0);
929 }
930 assertFiltering(filter1, file, true);
931 assertFiltering(filter2, file, false);
932
933 file = new File(temporaryFolder, "CVS");
934 if (!file.getParentFile().exists()) {
935 fail("Cannot create file " + file + " as the parent directory does not exist");
936 }
937 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(file.toPath()))) {
938 TestUtils.generateTestData(output, 0);
939 }
940 assertFiltering(filter1, file, true);
941 assertFiltering(filter2, file, false);
942 }
943
944 @Test
945 public void testMakeDirectoryOnly() throws Exception {
946 assertSame(DirectoryFileFilter.DIRECTORY, FileFilterUtils.makeDirectoryOnly(null));
947
948 final IOFileFilter filter = FileFilterUtils.makeDirectoryOnly(FileFilterUtils.nameFileFilter("B"));
949
950 final File fileA = new File(temporaryFolder, "A");
951 final File fileB = new File(temporaryFolder, "B");
952
953 fileA.mkdirs();
954 fileB.mkdirs();
955
956 assertFiltering(filter, fileA, false);
957 assertFiltering(filter, fileB, true);
958
959 FileUtils.deleteDirectory(fileA);
960 FileUtils.deleteDirectory(fileB);
961
962 if (!fileA.getParentFile().exists()) {
963 fail("Cannot create file " + fileA + " as the parent directory does not exist");
964 }
965 try (BufferedOutputStream output1 = new BufferedOutputStream(Files.newOutputStream(fileA.toPath()))) {
966 TestUtils.generateTestData(output1, 32);
967 }
968 if (!fileB.getParentFile().exists()) {
969 fail("Cannot create file " + fileB + " as the parent directory does not exist");
970 }
971 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(fileB.toPath()))) {
972 TestUtils.generateTestData(output, 32);
973 }
974
975 assertFiltering(filter, fileA, false);
976 assertFiltering(filter, fileB, false);
977
978 fileA.delete();
979 fileB.delete();
980 }
981
982 @Test
983 public void testMakeFileOnly() throws Exception {
984 assertSame(FileFileFilter.INSTANCE, FileFilterUtils.makeFileOnly(null));
985
986 final IOFileFilter filter = FileFilterUtils.makeFileOnly(FileFilterUtils.nameFileFilter("B"));
987
988 final File fileA = new File(temporaryFolder, "A");
989 final File fileB = new File(temporaryFolder, "B");
990
991 fileA.mkdirs();
992 fileB.mkdirs();
993
994 assertFiltering(filter, fileA, false);
995 assertFiltering(filter, fileB, false);
996
997 FileUtils.deleteDirectory(fileA);
998 FileUtils.deleteDirectory(fileB);
999
1000 if (!fileA.getParentFile().exists()) {
1001 fail("Cannot create file " + fileA + " as the parent directory does not exist");
1002 }
1003 try (BufferedOutputStream output1 = new BufferedOutputStream(Files.newOutputStream(fileA.toPath()))) {
1004 TestUtils.generateTestData(output1, 32);
1005 }
1006 if (!fileB.getParentFile().exists()) {
1007 fail("Cannot create file " + fileB + " as the parent directory does not exist");
1008 }
1009 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(fileB.toPath()))) {
1010 TestUtils.generateTestData(output, 32);
1011 }
1012
1013 assertFiltering(filter, fileA, false);
1014 assertFiltering(filter, fileB, true);
1015
1016 fileA.delete();
1017 fileB.delete();
1018 }
1019
1020 @Test
1021 public void testMakeSVNAware() throws Exception {
1022 final IOFileFilter filter1 = FileFilterUtils.makeSVNAware(null);
1023 final IOFileFilter filter2 = FileFilterUtils.makeSVNAware(FileFilterUtils.nameFileFilter("test-file1.txt"));
1024
1025 File file = new File(temporaryFolder, SVN_DIR_NAME);
1026 file.mkdirs();
1027 assertFiltering(filter1, file, false);
1028 assertFiltering(filter2, file, false);
1029 FileUtils.deleteDirectory(file);
1030
1031 file = new File(temporaryFolder, "test-file1.txt");
1032 if (!file.getParentFile().exists()) {
1033 fail("Cannot create file " + file + " as the parent directory does not exist");
1034 }
1035 try (BufferedOutputStream output2 = new BufferedOutputStream(Files.newOutputStream(file.toPath()))) {
1036 TestUtils.generateTestData(output2, 0);
1037 }
1038 assertFiltering(filter1, file, true);
1039 assertFiltering(filter2, file, true);
1040
1041 file = new File(temporaryFolder, "test-file2.log");
1042 if (!file.getParentFile().exists()) {
1043 fail("Cannot create file " + file + " as the parent directory does not exist");
1044 }
1045 try (BufferedOutputStream output1 = new BufferedOutputStream(Files.newOutputStream(file.toPath()))) {
1046 TestUtils.generateTestData(output1, 0);
1047 }
1048 assertFiltering(filter1, file, true);
1049 assertFiltering(filter2, file, false);
1050
1051 file = new File(temporaryFolder, SVN_DIR_NAME);
1052 if (!file.getParentFile().exists()) {
1053 fail("Cannot create file " + file + " as the parent directory does not exist");
1054 }
1055 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(file.toPath()))) {
1056 TestUtils.generateTestData(output, 0);
1057 }
1058 assertFiltering(filter1, file, true);
1059 assertFiltering(filter2, file, false);
1060 }
1061
1062 @Test
1063 public void testNameFilter() throws IOException {
1064 final NameFileFilter filter = new NameFileFilter("foo", "bar");
1065 assertFooBarFileFiltering(filter);
1066 assertFiltering(filter, (File) null, false);
1067 assertFiltering(filter, (Path) null, false);
1068 }
1069
1070 @Test
1071 public void testNameFilterNullArgument() {
1072 final String test = null;
1073 final String failMessage = "constructing a NameFileFilter with a null String argument should fail.";
1074 assertThrows(NullPointerException.class, () -> new NameFileFilter(test), failMessage);
1075 assertThrows(NullPointerException.class, () -> FileFilterUtils.nameFileFilter(test, IOCase.INSENSITIVE), failMessage);
1076 }
1077
1078 @Test
1079 public void testNameFilterNullArrayArgument() {
1080 assertThrows(NullPointerException.class, () -> new NameFileFilter((String[]) null));
1081 }
1082
1083 @Test
1084 public void testNameFilterNullListArgument() {
1085 final List<String> test = null;
1086 assertThrows(NullPointerException.class, () -> new NameFileFilter(test));
1087 }
1088
1089 @Test
1090 public void testNegate() throws IOException {
1091 final IOFileFilter filter = FileFilterUtils.notFileFilter(FileFilterUtils.trueFileFilter());
1092 assertFiltering(filter, new File("foo.test"), false);
1093 assertFiltering(filter, new File("foo"), false);
1094 assertFiltering(filter.negate(), new File("foo"), true);
1095 assertFiltering(filter, (File) null, false);
1096 assertThrows(NullPointerException.class, () -> new NotFileFilter(null));
1097 }
1098
1099 @Test
1100 public void testNullFilters() {
1101 assertThrows(NullPointerException.class, () -> FileFilterUtils.toList((IOFileFilter) null));
1102 assertThrows(NullPointerException.class, () -> FileFilterUtils.toList(new IOFileFilter[] {null}));
1103 }
1104
1105 @Test
1106 public void testOr() throws IOException {
1107 final IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
1108 final IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
1109 final File testFile = new File("foo.test");
1110 final Path testPath = testFile.toPath();
1111 assertFiltering(new OrFileFilter(trueFilter, trueFilter), testFile, true);
1112 assertFiltering(new OrFileFilter(trueFilter, falseFilter), testFile, true);
1113 assertFiltering(new OrFileFilter(falseFilter, trueFilter), testFile, true);
1114 assertFiltering(new OrFileFilter(falseFilter, falseFilter), testFile, false);
1115 assertFiltering(new OrFileFilter(), testFile, false);
1116
1117 assertFiltering(new OrFileFilter(trueFilter, trueFilter), testPath, true);
1118 assertFiltering(new OrFileFilter(trueFilter, falseFilter), testPath, true);
1119 assertFiltering(new OrFileFilter(falseFilter, trueFilter), testPath, true);
1120 assertFiltering(new OrFileFilter(falseFilter, falseFilter), testPath, false);
1121 assertFiltering(new OrFileFilter(), testPath, false);
1122
1123 assertFiltering(falseFilter.or(trueFilter), testPath, true);
1124
1125 final List<IOFileFilter> filters = new ArrayList<>();
1126 filters.add(trueFilter);
1127 filters.add(falseFilter);
1128
1129 final OrFileFilter orFilter = new OrFileFilter(filters);
1130
1131 assertFiltering(orFilter, testFile, true);
1132 assertFiltering(orFilter, testPath, true);
1133 assertEquals(orFilter.getFileFilters(), filters);
1134 orFilter.removeFileFilter(trueFilter);
1135 assertFiltering(orFilter, testFile, false);
1136 assertFiltering(orFilter, testPath, false);
1137 orFilter.setFileFilters(filters);
1138 assertFiltering(orFilter, testFile, true);
1139 assertFiltering(orFilter, testPath, true);
1140
1141 assertTrue(orFilter.accept(testFile.getParentFile(), testFile.getName()));
1142 assertEquals(FileVisitResult.CONTINUE, orFilter.accept(testPath, null));
1143 assertTrue(orFilter.matches(testPath));
1144 orFilter.removeFileFilter(trueFilter);
1145 assertFalse(orFilter.accept(testFile.getParentFile(), testFile.getName()));
1146 assertEquals(FileVisitResult.TERMINATE, orFilter.accept(testPath, null));
1147 assertFalse(orFilter.matches(testPath));
1148
1149 assertThrows(NullPointerException.class, () -> new OrFileFilter(falseFilter, null));
1150 }
1151
1152 @Test
1153 public void testPathEqualsFilter() throws IOException {
1154 assertFooBarFileFiltering(
1155 new PathEqualsFileFilter(Paths.get("foo")).or(new PathEqualsFileFilter(Paths.get("bar"))));
1156 }
1157
1158 @Test
1159 public void testPrefix() throws IOException {
1160 IOFileFilter filter = new PrefixFileFilter("foo", "bar");
1161 final File testFile = new File("test");
1162 final Path testPath = testFile.toPath();
1163 final File fredFile = new File("fred");
1164 final Path fredPath = fredFile.toPath();
1165
1166 assertFiltering(filter, new File("foo.test"), true);
1167 assertFiltering(filter, new File("FOO.test"), false);
1168 assertFiltering(filter, new File("foo"), true);
1169 assertFiltering(filter, new File("bar"), true);
1170 assertFiltering(filter, new File("food/"), true);
1171
1172 assertFiltering(filter, new File("foo.test").toPath(), true);
1173 assertFiltering(filter, new File("FOO.test").toPath(), false);
1174 assertFiltering(filter, new File("foo").toPath(), true);
1175 assertFiltering(filter, new File("bar").toPath(), true);
1176 assertFiltering(filter, new File("food/").toPath(), true);
1177
1178 filter = FileFilterUtils.prefixFileFilter("bar");
1179 assertFiltering(filter, new File("barred\\"), true);
1180 assertFiltering(filter, new File("test"), false);
1181 assertFiltering(filter, new File("fo_o.test"), false);
1182 assertFiltering(filter, new File("abar.exe"), false);
1183
1184 assertFiltering(filter, new File("barred\\").toPath(), true);
1185 assertFiltering(filter, new File("test").toPath(), false);
1186 assertFiltering(filter, new File("fo_o.test").toPath(), false);
1187 assertFiltering(filter, new File("abar.exe").toPath(), false);
1188
1189 filter = new PrefixFileFilter("tes");
1190 assertFiltering(filter, new File("test"), true);
1191 assertFiltering(filter, new File("fred"), false);
1192
1193 assertFiltering(filter, new File("test").toPath(), true);
1194 assertFiltering(filter, new File("fred").toPath(), false);
1195
1196 assertTrue(filter.accept(testFile.getParentFile(), testFile.getName()));
1197 assertFalse(filter.accept(fredFile.getParentFile(), fredFile.getName()));
1198
1199 assertEquals(FileVisitResult.CONTINUE, filter.accept(testPath, null));
1200 assertEquals(FileVisitResult.TERMINATE, filter.accept(fredPath, null));
1201
1202 assertTrue(filter.matches(testPath));
1203 assertFalse(filter.matches(fredPath));
1204
1205 final List<String> prefixes = Arrays.asList("foo", "fre");
1206 final IOFileFilter listFilter = new PrefixFileFilter(prefixes);
1207
1208 assertFalse(listFilter.accept(testFile.getParentFile(), testFile.getName()));
1209 assertTrue(listFilter.accept(fredFile.getParentFile(), fredFile.getName()));
1210
1211 assertEquals(FileVisitResult.TERMINATE, listFilter.accept(testPath, null));
1212 assertEquals(FileVisitResult.CONTINUE, listFilter.accept(fredPath, null));
1213
1214 assertFalse(listFilter.matches(testPath));
1215 assertTrue(listFilter.matches(fredPath));
1216
1217 assertThrows(NullPointerException.class, () -> new PrefixFileFilter((String) null));
1218 assertThrows(NullPointerException.class, () -> new PrefixFileFilter((String[]) null));
1219 assertThrows(NullPointerException.class, () -> new PrefixFileFilter((List<String>) null));
1220 }
1221
1222 @Test
1223 public void testPrefixCaseInsensitive() throws IOException {
1224
1225 IOFileFilter filter = new PrefixFileFilter(new String[] {"foo", "bar"}, IOCase.INSENSITIVE);
1226 assertFiltering(filter, new File("foo.test1"), true);
1227 assertFiltering(filter, new File("bar.test1"), true);
1228 assertFiltering(filter, new File("FOO.test1"), true);
1229 assertFiltering(filter, new File("BAR.test1"), true);
1230
1231 filter = new PrefixFileFilter("bar", IOCase.INSENSITIVE);
1232 assertFiltering(filter, new File("foo.test2"), false);
1233 assertFiltering(filter, new File("bar.test2"), true);
1234 assertFiltering(filter, new File("FOO.test2"), false);
1235 assertFiltering(filter, new File("BAR.test2"), true);
1236
1237 final List<String> prefixes = Arrays.asList("foo", "bar");
1238 filter = new PrefixFileFilter(prefixes, IOCase.INSENSITIVE);
1239 assertFiltering(filter, new File("foo.test3"), true);
1240 assertFiltering(filter, new File("bar.test3"), true);
1241 assertFiltering(filter, new File("FOO.test3"), true);
1242 assertFiltering(filter, new File("BAR.test3"), true);
1243
1244 assertThrows(NullPointerException.class, () -> new PrefixFileFilter((String) null, IOCase.INSENSITIVE));
1245 assertThrows(NullPointerException.class, () -> new PrefixFileFilter((String[]) null, IOCase.INSENSITIVE));
1246 assertThrows(NullPointerException.class, () -> new PrefixFileFilter((List<String>) null, IOCase.INSENSITIVE));
1247
1248 filter = FileFilterUtils.prefixFileFilter("bar", IOCase.INSENSITIVE);
1249 assertFiltering(filter, new File("foo.test2"), false);
1250 assertFiltering(filter, new File("bar.test2"), true);
1251 assertFiltering(filter, new File("FOO.test2"), false);
1252 assertFiltering(filter, new File("BAR.test2"), true);
1253
1254 assertThrows(NullPointerException.class, () -> FileFilterUtils.prefixFileFilter(null, IOCase.INSENSITIVE));
1255 }
1256
1257 @Test
1258 public void testSizeFilterOnFiles() throws Exception {
1259 final File smallFile = new File(temporaryFolder, "small.txt");
1260 if (!smallFile.getParentFile().exists()) {
1261 fail("Cannot create file " + smallFile + " as the parent directory does not exist");
1262 }
1263 try (BufferedOutputStream output1 = new BufferedOutputStream(Files.newOutputStream(smallFile.toPath()))) {
1264 TestUtils.generateTestData(output1, 32);
1265 }
1266 final File largeFile = new File(temporaryFolder, "large.txt");
1267 if (!largeFile.getParentFile().exists()) {
1268 fail("Cannot create file " + largeFile + " as the parent directory does not exist");
1269 }
1270 try (BufferedOutputStream output = new BufferedOutputStream(Files.newOutputStream(largeFile.toPath()))) {
1271 TestUtils.generateTestData(output, 128);
1272 }
1273 final IOFileFilter filter1 = FileFilterUtils.sizeFileFilter(64);
1274 final IOFileFilter filter2 = FileFilterUtils.sizeFileFilter(64, true);
1275 final IOFileFilter filter3 = FileFilterUtils.sizeFileFilter(64, false);
1276
1277 assertFiltering(filter1, smallFile, false);
1278 assertFiltering(filter2, smallFile, false);
1279 assertFiltering(filter3, smallFile, true);
1280 assertFiltering(filter1, largeFile, true);
1281 assertFiltering(filter2, largeFile, true);
1282 assertFiltering(filter3, largeFile, false);
1283
1284
1285 final IOFileFilter filter4 = FileFilterUtils.sizeRangeFileFilter(33, 127);
1286 final IOFileFilter filter5 = FileFilterUtils.sizeRangeFileFilter(32, 127);
1287 final IOFileFilter filter6 = FileFilterUtils.sizeRangeFileFilter(33, 128);
1288 final IOFileFilter filter7 = FileFilterUtils.sizeRangeFileFilter(31, 129);
1289 final IOFileFilter filter8 = FileFilterUtils.sizeRangeFileFilter(128, 128);
1290
1291 assertFiltering(filter4, smallFile, false);
1292 assertFiltering(filter4, largeFile, false);
1293 assertFiltering(filter5, smallFile, true);
1294 assertFiltering(filter5, largeFile, false);
1295 assertFiltering(filter6, smallFile, false);
1296 assertFiltering(filter6, largeFile, true);
1297 assertFiltering(filter7, smallFile, true);
1298 assertFiltering(filter7, largeFile, true);
1299 assertFiltering(filter8, largeFile, true);
1300
1301 assertThrows(IllegalArgumentException.class, () -> FileFilterUtils.sizeFileFilter(-1));
1302 }
1303
1304 @Test
1305 public void testSizeFilterOnPaths() throws Exception {
1306 final Path smallFile = Paths.get(temporaryFolder.toString(), "small.txt");
1307 if (Files.notExists(smallFile.getParent())) {
1308 fail("Cannot create file " + smallFile + " as the parent directory does not exist");
1309 }
1310 try (OutputStream output = Files.newOutputStream(smallFile)) {
1311 TestUtils.generateTestData(output, 32);
1312 }
1313 final Path largeFile = Paths.get(temporaryFolder.toString(), "large.txt");
1314 if (Files.notExists(largeFile.getParent())) {
1315 fail("Cannot create file " + largeFile + " as the parent directory does not exist");
1316 }
1317 try (OutputStream output = Files.newOutputStream(largeFile)) {
1318 TestUtils.generateTestData(output, 128);
1319 }
1320 final IOFileFilter filter1 = FileFilterUtils.sizeFileFilter(64);
1321 final IOFileFilter filter2 = FileFilterUtils.sizeFileFilter(64, true);
1322 final IOFileFilter filter3 = FileFilterUtils.sizeFileFilter(64, false);
1323
1324 assertFiltering(filter1, smallFile, false);
1325 assertFiltering(filter2, smallFile, false);
1326 assertFiltering(filter3, smallFile, true);
1327 assertFiltering(filter1, largeFile, true);
1328 assertFiltering(filter2, largeFile, true);
1329 assertFiltering(filter3, largeFile, false);
1330
1331
1332 final IOFileFilter filter4 = FileFilterUtils.sizeRangeFileFilter(33, 127);
1333 final IOFileFilter filter5 = FileFilterUtils.sizeRangeFileFilter(32, 127);
1334 final IOFileFilter filter6 = FileFilterUtils.sizeRangeFileFilter(33, 128);
1335 final IOFileFilter filter7 = FileFilterUtils.sizeRangeFileFilter(31, 129);
1336 final IOFileFilter filter8 = FileFilterUtils.sizeRangeFileFilter(128, 128);
1337
1338 assertFiltering(filter4, smallFile, false);
1339 assertFiltering(filter4, largeFile, false);
1340 assertFiltering(filter5, smallFile, true);
1341 assertFiltering(filter5, largeFile, false);
1342 assertFiltering(filter6, smallFile, false);
1343 assertFiltering(filter6, largeFile, true);
1344 assertFiltering(filter7, smallFile, true);
1345 assertFiltering(filter7, largeFile, true);
1346 assertFiltering(filter8, largeFile, true);
1347
1348 assertThrows(IllegalArgumentException.class, () -> FileFilterUtils.sizeFileFilter(-1));
1349 }
1350
1351 @Test
1352 public void testSuffix() throws IOException {
1353 IOFileFilter filter = new SuffixFileFilter("tes", "est");
1354 final File testFile = new File("test");
1355 final Path testPath = testFile.toPath();
1356 final File fredFile = new File("fred");
1357 final Path fredPath = fredFile.toPath();
1358
1359 assertFiltering(filter, new File("fred.tes"), true);
1360 assertFiltering(filter, new File("fred.est"), true);
1361 assertFiltering(filter, new File("fred.EST"), false);
1362 assertFiltering(filter, new File("fred.exe"), false);
1363
1364 assertFiltering(filter, new File("fred.tes").toPath(), true);
1365 assertFiltering(filter, new File("fred.est").toPath(), true);
1366 assertFiltering(filter, new File("fred.EST").toPath(), false);
1367 assertFiltering(filter, new File("fred.exe").toPath(), false);
1368
1369 filter = FileFilterUtils.or(FileFilterUtils.suffixFileFilter("tes"), FileFilterUtils.suffixFileFilter("est"));
1370 assertFiltering(filter, new File("fred"), false);
1371 assertFiltering(filter, new File(".tes"), true);
1372 assertFiltering(filter, new File("fred.test"), true);
1373
1374 assertFiltering(filter, new File("fred").toPath(), false);
1375 assertFiltering(filter, new File(".tes").toPath(), true);
1376 assertFiltering(filter, new File("fred.test").toPath(), true);
1377
1378 filter = new SuffixFileFilter("est");
1379 assertFiltering(filter, new File("test"), true);
1380 assertFiltering(filter, new File("fred"), false);
1381
1382 assertFiltering(filter, new File("test").toPath(), true);
1383 assertFiltering(filter, new File("fred").toPath(), false);
1384
1385 assertTrue(filter.accept(testFile.getParentFile(), testFile.getName()));
1386 assertFalse(filter.accept(fredFile.getParentFile(), fredFile.getName()));
1387
1388 assertEquals(FileVisitResult.CONTINUE, filter.accept(testPath, null));
1389 assertEquals(FileVisitResult.TERMINATE, filter.accept(fredPath, null));
1390
1391 assertTrue(filter.matches(testPath));
1392 assertFalse(filter.matches(fredPath));
1393
1394 final List<String> prefixes = Arrays.asList("ood", "red");
1395 final IOFileFilter listFilter = new SuffixFileFilter(prefixes);
1396
1397 assertFalse(listFilter.accept(testFile.getParentFile(), testFile.getName()));
1398 assertTrue(listFilter.accept(fredFile.getParentFile(), fredFile.getName()));
1399
1400 assertEquals(FileVisitResult.TERMINATE, listFilter.accept(testPath, null));
1401 assertEquals(FileVisitResult.CONTINUE, listFilter.accept(fredPath, null));
1402
1403 assertThrows(NullPointerException.class, () -> new SuffixFileFilter((String) null));
1404 assertThrows(NullPointerException.class, () -> new SuffixFileFilter((String[]) null));
1405 assertThrows(NullPointerException.class, () -> new SuffixFileFilter((List<String>) null));
1406 }
1407
1408 @Test
1409 public void testSuffixCaseInsensitive() throws IOException {
1410
1411 IOFileFilter filter = new SuffixFileFilter(new String[] {"tes", "est"}, IOCase.INSENSITIVE);
1412 assertFiltering(filter, new File("foo.tes"), true);
1413 assertFiltering(filter, new File("foo.est"), true);
1414 assertFiltering(filter, new File("foo.EST"), true);
1415 assertFiltering(filter, new File("foo.TES"), true);
1416 assertFiltering(filter, new File("foo.exe"), false);
1417
1418 filter = new SuffixFileFilter("est", IOCase.INSENSITIVE);
1419 assertFiltering(filter, new File("test"), true);
1420 assertFiltering(filter, new File("TEST"), true);
1421
1422 final List<String> suffixes = Arrays.asList("tes", "est");
1423 filter = new SuffixFileFilter(suffixes, IOCase.INSENSITIVE);
1424 assertFiltering(filter, new File("bar.tes"), true);
1425 assertFiltering(filter, new File("bar.est"), true);
1426 assertFiltering(filter, new File("bar.EST"), true);
1427 assertFiltering(filter, new File("bar.TES"), true);
1428 assertFiltering(filter, new File("bar.exe"), false);
1429
1430 assertThrows(NullPointerException.class, () -> new SuffixFileFilter((String) null, IOCase.INSENSITIVE));
1431 assertThrows(NullPointerException.class, () -> new SuffixFileFilter((String[]) null, IOCase.INSENSITIVE));
1432 assertThrows(NullPointerException.class, () -> new SuffixFileFilter((List<String>) null, IOCase.INSENSITIVE));
1433
1434
1435 filter = FileFilterUtils.suffixFileFilter("est", IOCase.INSENSITIVE);
1436 assertFiltering(filter, new File("test"), true);
1437 assertFiltering(filter, new File("TEST"), true);
1438
1439 assertThrows(NullPointerException.class, () -> FileFilterUtils.suffixFileFilter(null, IOCase.INSENSITIVE));
1440 }
1441
1442 @Test
1443 public void testTrue() throws IOException {
1444 final IOFileFilter filter = FileFilterUtils.trueFileFilter();
1445 assertFiltering(filter, new File("foo.test"), true);
1446 assertFiltering(filter, new File("foo"), true);
1447 assertFiltering(filter, (File) null, true);
1448
1449 assertFiltering(filter, new File("foo.test").toPath(), true);
1450 assertFiltering(filter, new File("foo").toPath(), true);
1451 assertFiltering(filter, (Path) null, true);
1452
1453 assertSame(TrueFileFilter.TRUE, TrueFileFilter.INSTANCE);
1454 assertSame(FalseFileFilter.FALSE, TrueFileFilter.INSTANCE.negate());
1455 assertSame(FalseFileFilter.INSTANCE, TrueFileFilter.INSTANCE.negate());
1456 assertNotNull(TrueFileFilter.INSTANCE.toString());
1457 }
1458
1459 }