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 java.io.File;
20 import java.io.FileFilter;
21 import java.io.FilenameFilter;
22 import java.util.ArrayList;
23 import java.util.Arrays;
24 import java.util.Date;
25 import java.util.List;
26
27 import junit.framework.TestSuite;
28 import junit.textui.TestRunner;
29
30 import org.apache.commons.io.FileUtils;
31 import org.apache.commons.io.IOCase;
32 import org.apache.commons.io.testtools.FileBasedTestCase;
33
34
35
36
37 public class FileFilterTestCase extends FileBasedTestCase {
38
39
40
41
42 static final String SVN_DIR_NAME = ".svn";
43
44 private static final boolean WINDOWS = (File.separatorChar == '\\');
45
46 public FileFilterTestCase(String name) {
47 super(name);
48 }
49
50 public static void main(String[] args) {
51 TestRunner.run(suite());
52 }
53
54 public static TestSuite suite() {
55 return new TestSuite(FileFilterTestCase.class);
56 }
57
58 public void setUp() {
59 getTestDirectory().mkdirs();
60 }
61
62 public void tearDown() throws Exception {
63 FileUtils.deleteDirectory(getTestDirectory());
64 }
65
66 public void assertFiltering(IOFileFilter filter, File file, boolean expected) throws Exception {
67
68
69 assertTrue(
70 "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file,
71 (filter.accept(file) == expected));
72
73 if (file != null && file.getParentFile() != null) {
74 assertTrue(
75 "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for " + file,
76 (filter.accept(file.getParentFile(), file.getName()) == expected));
77 } else if (file == null) {
78 assertTrue(
79 "Filter(File, String) " + filter.getClass().getName() + " not " + expected + " for null",
80 filter.accept(file) == expected);
81 }
82 }
83
84 public void testSuffix() throws Exception {
85 IOFileFilter filter = new SuffixFileFilter(new String[] { "tes", "est" });
86 File testFile = new File( "test" );
87 File fredFile = new File( "fred" );
88 assertFiltering(filter, new File("fred.tes"), true);
89 assertFiltering(filter, new File("fred.est"), true);
90 assertFiltering(filter, new File("fred.EST"), false);
91 assertFiltering(filter, new File("fred.exe"), false);
92
93 filter = FileFilterUtils.orFileFilter(
94 FileFilterUtils.suffixFileFilter( "tes" ),
95 FileFilterUtils.suffixFileFilter( "est" ) );
96 assertFiltering(filter, new File("fred"), false);
97 assertFiltering(filter, new File(".tes"), true);
98 assertFiltering(filter, new File("fred.test"), true);
99
100 filter = new SuffixFileFilter("est");
101 assertFiltering(filter, new File("test"), true);
102 assertFiltering(filter, new File("fred"), false);
103
104 assertTrue( filter.accept( testFile.getParentFile(), testFile.getName() ) );
105 assertTrue( !filter.accept( fredFile.getParentFile(), fredFile.getName() ) );
106
107 List prefixes = Arrays.asList( new String[] { "ood", "red" } );
108 IOFileFilter listFilter = new SuffixFileFilter( prefixes );
109
110 assertTrue( !listFilter.accept( testFile.getParentFile(), testFile.getName() ) );
111 assertTrue( listFilter.accept( fredFile.getParentFile(), fredFile.getName() ) );
112
113 try {
114 new SuffixFileFilter((String) null);
115 fail();
116 } catch (IllegalArgumentException ex) {
117 }
118
119 try {
120 new SuffixFileFilter((String[]) null);
121 fail();
122 } catch (IllegalArgumentException ex) {
123 }
124
125 try {
126 new SuffixFileFilter((List) null);
127 fail();
128 } catch (IllegalArgumentException ex) {
129 }
130 }
131
132 public void testDirectory() throws Exception {
133
134 IOFileFilter filter = new DirectoryFileFilter();
135
136 assertFiltering(filter, new File("src/"), true);
137 assertFiltering(filter, new File("src/java/"), true);
138
139 assertFiltering(filter, new File("project.xml"), false);
140
141 assertFiltering(filter, new File("imaginary"), false);
142 assertFiltering(filter, new File("imaginary/"), false);
143
144 assertFiltering(filter, new File("LICENSE.txt"), false);
145
146 assertSame(DirectoryFileFilter.DIRECTORY, DirectoryFileFilter.INSTANCE);
147 }
148
149 public void testFiles() throws Exception {
150
151 IOFileFilter filter = FileFileFilter.FILE;
152
153 assertFiltering(filter, new File("src/"), false);
154 assertFiltering(filter, new File("src/java/"), false);
155
156 assertFiltering(filter, new File("project.xml"), true);
157
158 assertFiltering(filter, new File("imaginary"), false);
159 assertFiltering(filter, new File("imaginary/"), false);
160
161 assertFiltering(filter, new File("LICENSE.txt"), true);
162 }
163
164 public void testPrefix() throws Exception {
165 IOFileFilter filter = new PrefixFileFilter(new String[] { "foo", "bar" });
166 File testFile = new File( "test" );
167 File fredFile = new File( "fred" );
168
169 assertFiltering(filter, new File("foo.test"), true);
170 assertFiltering(filter, new File("FOO.test"), false);
171 assertFiltering(filter, new File("foo"), true);
172 assertFiltering(filter, new File("bar"), true);
173 assertFiltering(filter, new File("food/"), true);
174
175 filter = FileFilterUtils.prefixFileFilter( "bar" );
176 assertFiltering(filter, new File("barred\\"), true);
177 assertFiltering(filter, new File("test"), false);
178 assertFiltering(filter, new File("fo_o.test"), false);
179 assertFiltering(filter, new File("abar.exe"), false);
180
181 filter = new PrefixFileFilter("tes");
182 assertFiltering(filter, new File("test"), true);
183 assertFiltering(filter, new File("fred"), false);
184
185 assertTrue( filter.accept( testFile.getParentFile(), testFile.getName() ) );
186 assertTrue( !filter.accept( fredFile.getParentFile(), fredFile.getName() ) );
187
188 List prefixes = Arrays.asList( new String[] { "foo", "fre" } );
189 IOFileFilter listFilter = new PrefixFileFilter( prefixes );
190
191 assertTrue( !listFilter.accept( testFile.getParentFile(), testFile.getName() ) );
192 assertTrue( listFilter.accept( fredFile.getParentFile(), fredFile.getName() ) );
193
194
195 try {
196 new PrefixFileFilter((String) null);
197 fail();
198 } catch (IllegalArgumentException ex) {
199 }
200
201 try {
202 new PrefixFileFilter((String[]) null);
203 fail();
204 } catch (IllegalArgumentException ex) {
205 }
206
207 try {
208 new PrefixFileFilter((List) null);
209 fail();
210 } catch (IllegalArgumentException ex) {
211 }
212 }
213
214 public void testNameFilter() throws Exception {
215 IOFileFilter filter = new NameFileFilter(new String[] { "foo", "bar" });
216 assertFiltering(filter, new File("foo"), true);
217 assertFiltering(filter, new File("bar"), true);
218 assertFiltering(filter, new File("fred"), false);
219
220 filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.SENSITIVE);
221 assertFiltering(filter, new File("foo"), true);
222 assertFiltering(filter, new File("bar"), true);
223 assertFiltering(filter, new File("FOO"), false);
224 assertFiltering(filter, new File("BAR"), false);
225
226 filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.INSENSITIVE);
227 assertFiltering(filter, new File("foo"), true);
228 assertFiltering(filter, new File("bar"), true);
229 assertFiltering(filter, new File("FOO"), true);
230 assertFiltering(filter, new File("BAR"), true);
231
232 filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.SYSTEM);
233 assertFiltering(filter, new File("foo"), true);
234 assertFiltering(filter, new File("bar"), true);
235 assertFiltering(filter, new File("FOO"), WINDOWS);
236 assertFiltering(filter, new File("BAR"), WINDOWS);
237
238 filter = new NameFileFilter(new String[] { "foo", "bar" }, (IOCase) null);
239 assertFiltering(filter, new File("foo"), true);
240 assertFiltering(filter, new File("bar"), true);
241 assertFiltering(filter, new File("FOO"), false);
242 assertFiltering(filter, new File("BAR"), false);
243
244
245 java.util.ArrayList list = new java.util.ArrayList();
246 list.add("foo");
247 list.add("bar");
248 filter = new NameFileFilter(list);
249 assertFiltering(filter, new File("foo"), true);
250 assertFiltering(filter, new File("bar"), true);
251 assertFiltering(filter, new File("fred"), false);
252
253 filter = new NameFileFilter("foo");
254 assertFiltering(filter, new File("foo"), true);
255 assertFiltering(filter, new File("FOO"), false);
256 assertFiltering(filter, new File("barfoo"), false);
257 assertFiltering(filter, new File("foobar"), false);
258 assertFiltering(filter, new File("fred"), false);
259 }
260
261 public void testNameFilterNullArgument() throws Exception {
262 String test = null;
263 try {
264 new NameFileFilter(test);
265 fail( "constructing a NameFileFilter with a null String argument should fail.");
266 } catch( IllegalArgumentException iae ) {
267 }
268 }
269
270 public void testNameFilterNullArrayArgument() throws Exception {
271 String[] test = null;
272 try {
273 new NameFileFilter(test);
274 fail( "constructing a NameFileFilter with a null String[] argument should fail.");
275 } catch( IllegalArgumentException iae ) {
276 }
277 }
278
279 public void testNameFilterNullListArgument() throws Exception {
280 List test = null;
281 try {
282 new NameFileFilter(test);
283 fail( "constructing a NameFileFilter with a null List argument should fail.");
284 } catch( IllegalArgumentException iae ) {
285 }
286 }
287
288 public void testTrue() throws Exception {
289 IOFileFilter filter = FileFilterUtils.trueFileFilter();
290 assertFiltering(filter, new File("foo.test"), true);
291 assertFiltering(filter, new File("foo"), true);
292 assertFiltering(filter, null, true);
293 assertSame(TrueFileFilter.TRUE, TrueFileFilter.INSTANCE);
294 }
295
296 public void testFalse() throws Exception {
297 IOFileFilter filter = FileFilterUtils.falseFileFilter();
298 assertFiltering(filter, new File("foo.test"), false);
299 assertFiltering(filter, new File("foo"), false);
300 assertFiltering(filter, null, false);
301 assertSame(FalseFileFilter.FALSE, FalseFileFilter.INSTANCE);
302 }
303
304 public void testNot() throws Exception {
305 IOFileFilter filter = FileFilterUtils.notFileFilter(FileFilterUtils.trueFileFilter());
306 assertFiltering(filter, new File("foo.test"), false);
307 assertFiltering(filter, new File("foo"), false);
308 assertFiltering(filter, null, false);
309 try {
310 new NotFileFilter(null);
311 fail();
312 } catch (IllegalArgumentException ex) {
313 }
314 }
315
316 public void testAnd() throws Exception {
317 IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
318 IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
319 assertFiltering(new AndFileFilter(trueFilter, trueFilter), new File("foo.test"), true);
320 assertFiltering(new AndFileFilter(trueFilter, falseFilter), new File("foo.test"), false);
321 assertFiltering(new AndFileFilter(falseFilter, trueFilter), new File("foo.test"), false);
322 assertFiltering(new AndFileFilter(falseFilter, falseFilter), new File("foo.test"), false);
323
324 List filters = new ArrayList();
325 assertFiltering( new AndFileFilter( filters ), new File( "test" ), false );
326 assertFiltering( new AndFileFilter(), new File( "test" ), false );
327
328 try {
329 new AndFileFilter(falseFilter, null);
330 fail();
331 } catch (IllegalArgumentException ex) {
332 }
333
334 AndFileFilter f = new AndFileFilter((List) null);
335 assertEquals(true, f.getFileFilters().isEmpty());
336 }
337
338 public void testOr() throws Exception {
339 IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
340 IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
341 File testFile = new File( "foo.test" );
342 assertFiltering(new OrFileFilter(trueFilter, trueFilter), testFile, true);
343 assertFiltering(new OrFileFilter(trueFilter, falseFilter), testFile, true);
344 assertFiltering(new OrFileFilter(falseFilter, trueFilter), testFile, true);
345 assertFiltering(new OrFileFilter(falseFilter, falseFilter), testFile, false);
346 assertFiltering(new OrFileFilter(), testFile, false);
347
348 List filters = new ArrayList();
349 filters.add( trueFilter );
350 filters.add( falseFilter );
351
352 OrFileFilter orFilter = new OrFileFilter( filters );
353
354 assertFiltering(orFilter, testFile, true);
355 assertEquals( orFilter.getFileFilters(), filters );
356 orFilter.removeFileFilter( trueFilter );
357 assertFiltering(orFilter, testFile, false);
358 orFilter.setFileFilters( filters );
359 assertFiltering(orFilter, testFile, true);
360
361 assertTrue( orFilter.accept( testFile.getParentFile(), testFile.getName() ) );
362 orFilter.removeFileFilter( trueFilter );
363 assertTrue( !orFilter.accept( testFile.getParentFile(), testFile.getName() ) );
364
365 try {
366 new OrFileFilter(falseFilter, null);
367 fail();
368 } catch (IllegalArgumentException ex) {
369 }
370
371 OrFileFilter f = new OrFileFilter((List) null);
372 assertEquals(true, f.getFileFilters().isEmpty());
373 }
374
375 public void testDeprecatedWildcard() throws Exception {
376 IOFileFilter filter = new WildcardFilter("*.txt");
377 List patternList = Arrays.asList( new String[] { "*.txt", "*.xml", "*.gif" } );
378 IOFileFilter listFilter = new WildcardFilter( patternList );
379 File txtFile = new File( "test.txt" );
380 File bmpFile = new File( "test.bmp" );
381 File dir = new File( "src/java" );
382
383 assertFiltering(filter, new File("log.txt"), true);
384
385
386 filter = new WildcardFilter("log?.txt");
387 assertFiltering(filter, new File("log1.txt"), true);
388 assertFiltering(filter, new File("log12.txt"), false);
389
390 filter = new WildcardFilter("open??.????04");
391 assertFiltering(filter, new File("openAB.102504"), true);
392 assertFiltering(filter, new File("openA.102504"), false);
393 assertFiltering(filter, new File("openXY.123103"), false);
394
395
396 filter = new WildcardFilter(new String[] {"*.java", "*.class"});
397 assertFiltering(filter, new File("Test.java"), true);
398 assertFiltering(filter, new File("Test.class"), true);
399 assertFiltering(filter, new File("Test.jsp"), false);
400
401 assertFiltering(listFilter, new File("Test.txt"), true);
402 assertFiltering(listFilter, new File("Test.xml"), true);
403 assertFiltering(listFilter, new File("Test.gif"), true);
404 assertFiltering(listFilter, new File("Test.bmp"), false);
405
406 assertTrue( listFilter.accept( txtFile ) );
407 assertTrue( !listFilter.accept( bmpFile ) );
408 assertTrue( !listFilter.accept( dir ) );
409
410 assertTrue( listFilter.accept( txtFile.getParentFile(), txtFile.getName() ) );
411 assertTrue( !listFilter.accept( bmpFile.getParentFile(), bmpFile.getName() ) );
412 assertTrue( !listFilter.accept( dir.getParentFile(), dir.getName() ) );
413
414 try {
415 new WildcardFilter((String) null);
416 fail();
417 } catch (IllegalArgumentException ex) {
418
419 }
420
421 try {
422 new WildcardFilter((String[]) null);
423 fail();
424 } catch (IllegalArgumentException ex) {
425
426 }
427
428 try {
429 new WildcardFilter((List) null);
430 fail();
431 } catch (IllegalArgumentException ex) {
432
433 }
434 }
435
436 public void testWildcard() throws Exception {
437 IOFileFilter filter = new WildcardFileFilter("*.txt");
438 assertFiltering(filter, new File("log.txt"), true);
439 assertFiltering(filter, new File("log.TXT"), false);
440
441 filter = new WildcardFileFilter("*.txt", IOCase.SENSITIVE);
442 assertFiltering(filter, new File("log.txt"), true);
443 assertFiltering(filter, new File("log.TXT"), false);
444
445 filter = new WildcardFileFilter("*.txt", IOCase.INSENSITIVE);
446 assertFiltering(filter, new File("log.txt"), true);
447 assertFiltering(filter, new File("log.TXT"), true);
448
449 filter = new WildcardFileFilter("*.txt", IOCase.SYSTEM);
450 assertFiltering(filter, new File("log.txt"), true);
451 assertFiltering(filter, new File("log.TXT"), WINDOWS);
452
453 filter = new WildcardFileFilter("*.txt", (IOCase) null);
454 assertFiltering(filter, new File("log.txt"), true);
455 assertFiltering(filter, new File("log.TXT"), false);
456
457 filter = new WildcardFileFilter(new String[] {"*.java", "*.class"});
458 assertFiltering(filter, new File("Test.java"), true);
459 assertFiltering(filter, new File("Test.class"), true);
460 assertFiltering(filter, new File("Test.jsp"), false);
461
462 filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.SENSITIVE);
463 assertFiltering(filter, new File("Test.java"), true);
464 assertFiltering(filter, new File("Test.JAVA"), false);
465
466 filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.INSENSITIVE);
467 assertFiltering(filter, new File("Test.java"), true);
468 assertFiltering(filter, new File("Test.JAVA"), true);
469
470 filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.SYSTEM);
471 assertFiltering(filter, new File("Test.java"), true);
472 assertFiltering(filter, new File("Test.JAVA"), WINDOWS);
473
474 filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, (IOCase) null);
475 assertFiltering(filter, new File("Test.java"), true);
476 assertFiltering(filter, new File("Test.JAVA"), false);
477
478 List patternList = Arrays.asList( new String[] { "*.txt", "*.xml", "*.gif" } );
479 IOFileFilter listFilter = new WildcardFileFilter( patternList );
480 assertFiltering(listFilter, new File("Test.txt"), true);
481 assertFiltering(listFilter, new File("Test.xml"), true);
482 assertFiltering(listFilter, new File("Test.gif"), true);
483 assertFiltering(listFilter, new File("Test.bmp"), false);
484
485 File txtFile = new File( "test.txt" );
486 File bmpFile = new File( "test.bmp" );
487 File dir = new File( "src/java" );
488 assertTrue( listFilter.accept( txtFile ) );
489 assertTrue( !listFilter.accept( bmpFile ) );
490 assertTrue( !listFilter.accept( dir ) );
491
492 assertTrue( listFilter.accept( txtFile.getParentFile(), txtFile.getName() ) );
493 assertTrue( !listFilter.accept( bmpFile.getParentFile(), bmpFile.getName() ) );
494 assertTrue( !listFilter.accept( dir.getParentFile(), dir.getName() ) );
495
496 try {
497 new WildcardFileFilter((String) null);
498 fail();
499 } catch (IllegalArgumentException ex) {}
500 try {
501 new WildcardFileFilter((String[]) null);
502 fail();
503 } catch (IllegalArgumentException ex) {}
504 try {
505 new WildcardFileFilter((List) null);
506 fail();
507 } catch (IllegalArgumentException ex) {}
508 }
509
510 public void testDelegateFileFilter() throws Exception {
511 OrFileFilter orFilter = new OrFileFilter();
512 File testFile = new File( "test.txt" );
513
514 IOFileFilter filter = new DelegateFileFilter((FileFilter) orFilter);
515 assertFiltering( filter, testFile, false );
516
517 filter = new DelegateFileFilter((FilenameFilter) orFilter);
518 assertFiltering( filter, testFile, false );
519
520 try {
521 new DelegateFileFilter((FileFilter) null);
522 fail();
523 } catch( IllegalArgumentException iae ) {
524 }
525
526 try {
527 new DelegateFileFilter((FilenameFilter) null);
528 fail();
529 } catch( IllegalArgumentException iae ) {
530 }
531
532 }
533
534 public void testMakeCVSAware() throws Exception {
535 IOFileFilter filter1 = FileFilterUtils.makeCVSAware(null);
536 IOFileFilter filter2 = FileFilterUtils.makeCVSAware(FileFilterUtils
537 .nameFileFilter("test-file1.txt"));
538
539 File file = new File(getTestDirectory(), "CVS");
540 file.mkdirs();
541 assertFiltering(filter1, file, false);
542 assertFiltering(filter2, file, false);
543 FileUtils.deleteDirectory(file);
544
545 file = new File(getTestDirectory(), "test-file1.txt");
546 createFile(file, 0);
547 assertFiltering(filter1, file, true);
548 assertFiltering(filter2, file, true);
549
550 file = new File(getTestDirectory(), "test-file2.log");
551 createFile(file, 0);
552 assertFiltering(filter1, file, true);
553 assertFiltering(filter2, file, false);
554
555 file = new File(getTestDirectory(), "CVS");
556 createFile(file, 0);
557 assertFiltering(filter1, file, true);
558 assertFiltering(filter2, file, false);
559 }
560
561 public void testMakeSVNAware() throws Exception {
562 IOFileFilter filter1 = FileFilterUtils.makeSVNAware(null);
563 IOFileFilter filter2 = FileFilterUtils.makeSVNAware(FileFilterUtils
564 .nameFileFilter("test-file1.txt"));
565
566 File file = new File(getTestDirectory(), SVN_DIR_NAME);
567 file.mkdirs();
568 assertFiltering(filter1, file, false);
569 assertFiltering(filter2, file, false);
570 FileUtils.deleteDirectory(file);
571
572 file = new File(getTestDirectory(), "test-file1.txt");
573 createFile(file, 0);
574 assertFiltering(filter1, file, true);
575 assertFiltering(filter2, file, true);
576
577 file = new File(getTestDirectory(), "test-file2.log");
578 createFile(file, 0);
579 assertFiltering(filter1, file, true);
580 assertFiltering(filter2, file, false);
581
582 file = new File(getTestDirectory(), SVN_DIR_NAME);
583 createFile(file, 0);
584 assertFiltering(filter1, file, true);
585 assertFiltering(filter2, file, false);
586 }
587
588 public void testAgeFilter() throws Exception {
589 File oldFile = new File(getTestDirectory(), "old.txt");
590 File reference = new File(getTestDirectory(), "reference.txt");
591 File newFile = new File(getTestDirectory(), "new.txt");
592
593 createFile(oldFile, 0);
594
595 do {
596 try {
597 Thread.sleep(1000);
598 } catch(InterruptedException ie) {
599
600 }
601 createFile(reference, 0);
602 } while( oldFile.lastModified() == reference.lastModified() );
603
604 Date date = new Date();
605 long now = date.getTime();
606
607 do {
608 try {
609 Thread.sleep(1000);
610 } catch(InterruptedException ie) {
611
612 }
613 createFile(newFile, 0);
614 } while( reference.lastModified() == newFile.lastModified() );
615
616 IOFileFilter filter1 = FileFilterUtils.ageFileFilter(now);
617 IOFileFilter filter2 = FileFilterUtils.ageFileFilter(now, true);
618 IOFileFilter filter3 = FileFilterUtils.ageFileFilter(now, false);
619 IOFileFilter filter4 = FileFilterUtils.ageFileFilter(date);
620 IOFileFilter filter5 = FileFilterUtils.ageFileFilter(date, true);
621 IOFileFilter filter6 = FileFilterUtils.ageFileFilter(date, false);
622 IOFileFilter filter7 = FileFilterUtils.ageFileFilter(reference);
623 IOFileFilter filter8 = FileFilterUtils.ageFileFilter(reference, true);
624 IOFileFilter filter9 = FileFilterUtils.ageFileFilter(reference, false);
625
626 assertFiltering(filter1, oldFile, true);
627 assertFiltering(filter2, oldFile, true);
628 assertFiltering(filter3, oldFile, false);
629 assertFiltering(filter4, oldFile, true);
630 assertFiltering(filter5, oldFile, true);
631 assertFiltering(filter6, oldFile, false);
632 assertFiltering(filter7, oldFile, true);
633 assertFiltering(filter8, oldFile, true);
634 assertFiltering(filter9, oldFile, false);
635 assertFiltering(filter1, newFile, false);
636 assertFiltering(filter2, newFile, false);
637 assertFiltering(filter3, newFile, true);
638 assertFiltering(filter4, newFile, false);
639 assertFiltering(filter5, newFile, false);
640 assertFiltering(filter6, newFile, true);
641 assertFiltering(filter7, newFile, false);
642 assertFiltering(filter8, newFile, false);
643 assertFiltering(filter9, newFile, true);
644 }
645
646 public void testSizeFilter() throws Exception {
647 File smallFile = new File(getTestDirectory(), "small.txt");
648 createFile(smallFile, 32);
649 File largeFile = new File(getTestDirectory(), "large.txt");
650 createFile(largeFile, 128);
651 IOFileFilter filter1 = FileFilterUtils.sizeFileFilter(64);
652 IOFileFilter filter2 = FileFilterUtils.sizeFileFilter(64, true);
653 IOFileFilter filter3 = FileFilterUtils.sizeFileFilter(64, false);
654
655 assertFiltering(filter1, smallFile, false);
656 assertFiltering(filter2, smallFile, false);
657 assertFiltering(filter3, smallFile, true);
658 assertFiltering(filter1, largeFile, true);
659 assertFiltering(filter2, largeFile, true);
660 assertFiltering(filter3, largeFile, false);
661
662
663 IOFileFilter filter4 = FileFilterUtils.sizeRangeFileFilter(33, 127);
664 IOFileFilter filter5 = FileFilterUtils.sizeRangeFileFilter(32, 127);
665 IOFileFilter filter6 = FileFilterUtils.sizeRangeFileFilter(33, 128);
666 IOFileFilter filter7 = FileFilterUtils.sizeRangeFileFilter(31, 129);
667 IOFileFilter filter8 = FileFilterUtils.sizeRangeFileFilter(128, 128);
668
669 assertFiltering(filter4, smallFile, false);
670 assertFiltering(filter4, largeFile, false);
671 assertFiltering(filter5, smallFile, true);
672 assertFiltering(filter5, largeFile, false);
673 assertFiltering(filter6, smallFile, false);
674 assertFiltering(filter6, largeFile, true);
675 assertFiltering(filter7, smallFile, true);
676 assertFiltering(filter7, largeFile, true);
677 assertFiltering(filter8, largeFile, true);
678
679 try {
680 FileFilterUtils.sizeFileFilter(-1);
681 fail();
682 } catch (IllegalArgumentException ex) {
683
684 }
685 }
686
687 public void testHidden() throws Exception {
688 File hiddenDir = new File(SVN_DIR_NAME);
689 if (hiddenDir.exists()) {
690 assertFiltering(HiddenFileFilter.HIDDEN, hiddenDir, hiddenDir.isHidden());
691 assertFiltering(HiddenFileFilter.VISIBLE, hiddenDir, !hiddenDir.isHidden());
692 }
693 assertFiltering(HiddenFileFilter.HIDDEN, getTestDirectory(), false);
694 assertFiltering(HiddenFileFilter.VISIBLE, getTestDirectory(), true);
695 }
696
697 public void testCanRead() throws Exception {
698 File readOnlyFile = new File(getTestDirectory(), "read-only-file1.txt");
699 createFile(readOnlyFile, 32);
700 readOnlyFile.setReadOnly();
701 assertFiltering(CanReadFileFilter.CAN_READ, readOnlyFile, true);
702 assertFiltering(CanReadFileFilter.CANNOT_READ, readOnlyFile, false);
703 assertFiltering(CanReadFileFilter.READ_ONLY, readOnlyFile, true);
704 readOnlyFile.delete();
705 }
706
707 public void testCanWrite() throws Exception {
708 File readOnlyFile = new File(getTestDirectory(), "read-only-file2.txt");
709 createFile(readOnlyFile, 32);
710 readOnlyFile.setReadOnly();
711 assertFiltering(CanWriteFileFilter.CAN_WRITE, getTestDirectory(), true);
712 assertFiltering(CanWriteFileFilter.CANNOT_WRITE, getTestDirectory(), false);
713 assertFiltering(CanWriteFileFilter.CAN_WRITE, readOnlyFile, false);
714 assertFiltering(CanWriteFileFilter.CANNOT_WRITE, readOnlyFile, true);
715 readOnlyFile.delete();
716 }
717
718 public void testEmpty() throws Exception {
719
720
721 File emptyDir = new File(getTestDirectory(), "empty-dir");
722 emptyDir.mkdirs();
723 assertFiltering(EmptyFileFilter.EMPTY, emptyDir, true);
724 assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, false);
725
726
727 File emptyFile = new File(emptyDir, "empty-file.txt");
728 createFile(emptyFile, 0);
729 assertFiltering(EmptyFileFilter.EMPTY, emptyFile, true);
730 assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyFile, false);
731
732
733 assertFiltering(EmptyFileFilter.EMPTY, emptyDir, false);
734 assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, true);
735
736
737 File notEmptyFile = new File(emptyDir, "not-empty-file.txt");
738 createFile(notEmptyFile, 32);
739 assertFiltering(EmptyFileFilter.EMPTY, notEmptyFile, false);
740 assertFiltering(EmptyFileFilter.NOT_EMPTY, notEmptyFile, true);
741 FileUtils.forceDelete(emptyDir);
742 }
743
744
745 public void testMakeDirectoryOnly() throws Exception {
746 assertSame(DirectoryFileFilter.DIRECTORY, FileFilterUtils.makeDirectoryOnly(null));
747
748 IOFileFilter filter = FileFilterUtils.makeDirectoryOnly(
749 FileFilterUtils.nameFileFilter("B"));
750
751 File fileA = new File(getTestDirectory(), "A");
752 File fileB = new File(getTestDirectory(), "B");
753
754 fileA.mkdirs();
755 fileB.mkdirs();
756
757 assertFiltering(filter, fileA, false);
758 assertFiltering(filter, fileB, true);
759
760 FileUtils.deleteDirectory(fileA);
761 FileUtils.deleteDirectory(fileB);
762
763 createFile(fileA, 32);
764 createFile(fileB, 32);
765
766 assertFiltering(filter, fileA, false);
767 assertFiltering(filter, fileB, false);
768
769 fileA.delete();
770 fileB.delete();
771 }
772
773
774 public void testMakeFileOnly() throws Exception {
775 assertSame(FileFileFilter.FILE, FileFilterUtils.makeFileOnly(null));
776
777 IOFileFilter filter = FileFilterUtils.makeFileOnly(
778 FileFilterUtils.nameFileFilter("B"));
779
780 File fileA = new File(getTestDirectory(), "A");
781 File fileB = new File(getTestDirectory(), "B");
782
783 fileA.mkdirs();
784 fileB.mkdirs();
785
786 assertFiltering(filter, fileA, false);
787 assertFiltering(filter, fileB, false);
788
789 FileUtils.deleteDirectory(fileA);
790 FileUtils.deleteDirectory(fileB);
791
792 createFile(fileA, 32);
793 createFile(fileB, 32);
794
795 assertFiltering(filter, fileA, false);
796 assertFiltering(filter, fileB, true);
797
798 fileA.delete();
799 fileB.delete();
800 }
801
802 }