FileFilterTestCase xref


1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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   * Used to test FileFilterUtils.
36   */
37  public class FileFilterTestCase extends FileBasedTestCase {
38  
39      /**
40       * The subversion directory name.
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          // Note. This only tests the (File, String) version if the parent of
68          //       the File passed in is not null
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); //case-sensitive
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 testSuffixCaseInsensitive() throws Exception {
133 
134         IOFileFilter filter = new SuffixFileFilter(new String[] { "tes", "est" }, IOCase.INSENSITIVE);
135         assertFiltering(filter, new File("foo.tes"), true);
136         assertFiltering(filter, new File("foo.est"), true);
137         assertFiltering(filter, new File("foo.EST"), true); //case-sensitive
138         assertFiltering(filter, new File("foo.TES"), true); //case-sensitive
139         assertFiltering(filter, new File("foo.exe"), false);
140 
141         filter = new SuffixFileFilter("est", IOCase.INSENSITIVE);
142         assertFiltering(filter, new File("test"), true);
143         assertFiltering(filter, new File("TEST"), true);
144 
145         List suffixes = Arrays.asList( new String[] { "tes", "est" } );
146         filter = new SuffixFileFilter(suffixes, IOCase.INSENSITIVE);
147         assertFiltering(filter, new File("bar.tes"), true);
148         assertFiltering(filter, new File("bar.est"), true);
149         assertFiltering(filter, new File("bar.EST"), true); //case-sensitive
150         assertFiltering(filter, new File("bar.TES"), true); //case-sensitive
151         assertFiltering(filter, new File("bar.exe"), false);
152 
153         try {
154             new SuffixFileFilter((String) null, IOCase.INSENSITIVE);
155             fail();
156         } catch (IllegalArgumentException ex) {
157         }
158 
159         try {
160             new SuffixFileFilter((String[]) null, IOCase.INSENSITIVE);
161             fail();
162         } catch (IllegalArgumentException ex) {
163         }
164 
165         try {
166             new SuffixFileFilter((List) null, IOCase.INSENSITIVE);
167             fail();
168         } catch (IllegalArgumentException ex) {
169         }
170     }
171 
172     public void testDirectory() throws Exception {
173         // XXX: This test presumes the current working dir is the base dir of the source checkout.
174         IOFileFilter filter = new DirectoryFileFilter();
175 
176         assertFiltering(filter, new File("src/"), true);
177         assertFiltering(filter, new File("src/java/"), true);
178 
179         assertFiltering(filter, new File("project.xml"), false);
180 
181         assertFiltering(filter, new File("imaginary"), false);
182         assertFiltering(filter, new File("imaginary/"), false);
183 
184         assertFiltering(filter, new File("LICENSE.txt"), false);
185         
186         assertSame(DirectoryFileFilter.DIRECTORY, DirectoryFileFilter.INSTANCE);
187     }
188 
189     public void testFiles() throws Exception {
190         // XXX: This test presumes the current working dir is the base dir of the source checkout.
191         IOFileFilter filter = FileFileFilter.FILE;
192         
193         assertFiltering(filter, new File("src/"), false);
194         assertFiltering(filter, new File("src/java/"), false);
195         
196         assertFiltering(filter, new File("project.xml"), true);
197         
198         assertFiltering(filter, new File("imaginary"), false);
199         assertFiltering(filter, new File("imaginary/"), false);
200         
201         assertFiltering(filter, new File("LICENSE.txt"), true);
202     }
203 
204     public void testPrefix() throws Exception {
205         IOFileFilter filter = new PrefixFileFilter(new String[] { "foo", "bar" });
206         File testFile = new File( "test" );
207         File fredFile = new File( "fred" );
208 
209         assertFiltering(filter, new File("foo.test"), true);
210         assertFiltering(filter, new File("FOO.test"), false);  //case-sensitive
211         assertFiltering(filter, new File("foo"), true);
212         assertFiltering(filter, new File("bar"), true);
213         assertFiltering(filter, new File("food/"), true);
214 
215         filter = FileFilterUtils.prefixFileFilter( "bar" );
216         assertFiltering(filter, new File("barred\\"), true);
217         assertFiltering(filter, new File("test"), false);
218         assertFiltering(filter, new File("fo_o.test"), false);
219         assertFiltering(filter, new File("abar.exe"), false);
220 
221         filter = new PrefixFileFilter("tes");
222         assertFiltering(filter, new File("test"), true);
223         assertFiltering(filter, new File("fred"), false);
224 
225         assertTrue( filter.accept( testFile.getParentFile(), testFile.getName() ) );
226         assertTrue( !filter.accept( fredFile.getParentFile(), fredFile.getName() ) );
227 
228         List prefixes = Arrays.asList( new String[] { "foo", "fre" } );
229         IOFileFilter listFilter = new PrefixFileFilter( prefixes );
230 
231         assertTrue( !listFilter.accept( testFile.getParentFile(), testFile.getName() ) );
232         assertTrue( listFilter.accept( fredFile.getParentFile(), fredFile.getName() ) );
233         
234         
235         try {
236             new PrefixFileFilter((String) null);
237             fail();
238         } catch (IllegalArgumentException ex) {
239         }
240 
241         try {
242             new PrefixFileFilter((String[]) null);
243             fail();
244         } catch (IllegalArgumentException ex) {
245         }
246 
247         try {
248             new PrefixFileFilter((List) null);
249             fail();
250         } catch (IllegalArgumentException ex) {
251         }
252     }
253 
254     public void testPrefixCaseInsensitive() throws Exception {
255 
256         IOFileFilter filter = new PrefixFileFilter(new String[] { "foo", "bar" }, IOCase.INSENSITIVE);
257         assertFiltering(filter, new File("foo.test1"), true);
258         assertFiltering(filter, new File("bar.test1"), true);
259         assertFiltering(filter, new File("FOO.test1"), true);  //case-sensitive
260         assertFiltering(filter, new File("BAR.test1"), true);  //case-sensitive
261 
262         filter = new PrefixFileFilter("bar", IOCase.INSENSITIVE);
263         assertFiltering(filter, new File("foo.test2"), false);
264         assertFiltering(filter, new File("bar.test2"), true);
265         assertFiltering(filter, new File("FOO.test2"), false); //case-sensitive
266         assertFiltering(filter, new File("BAR.test2"), true);  //case-sensitive
267 
268         List prefixes = Arrays.asList( new String[] { "foo", "bar" } );
269         filter = new PrefixFileFilter(prefixes, IOCase.INSENSITIVE);
270         assertFiltering(filter, new File("foo.test3"), true);
271         assertFiltering(filter, new File("bar.test3"), true);
272         assertFiltering(filter, new File("FOO.test3"), true);  //case-sensitive
273         assertFiltering(filter, new File("BAR.test3"), true);  //case-sensitive
274 
275         try {
276             new PrefixFileFilter((String) null, IOCase.INSENSITIVE);
277             fail();
278         } catch (IllegalArgumentException ex) {
279         }
280 
281         try {
282             new PrefixFileFilter((String[]) null, IOCase.INSENSITIVE);
283             fail();
284         } catch (IllegalArgumentException ex) {
285         }
286 
287         try {
288             new PrefixFileFilter((List) null, IOCase.INSENSITIVE);
289             fail();
290         } catch (IllegalArgumentException ex) {
291         }
292     }
293 
294     public void testNameFilter() throws Exception {
295         IOFileFilter filter = new NameFileFilter(new String[] { "foo", "bar" });
296         assertFiltering(filter, new File("foo"), true);
297         assertFiltering(filter, new File("bar"), true);
298         assertFiltering(filter, new File("fred"), false);
299         
300         filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.SENSITIVE);
301         assertFiltering(filter, new File("foo"), true);
302         assertFiltering(filter, new File("bar"), true);
303         assertFiltering(filter, new File("FOO"), false);
304         assertFiltering(filter, new File("BAR"), false);
305         
306         filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.INSENSITIVE);
307         assertFiltering(filter, new File("foo"), true);
308         assertFiltering(filter, new File("bar"), true);
309         assertFiltering(filter, new File("FOO"), true);
310         assertFiltering(filter, new File("BAR"), true);
311         
312         filter = new NameFileFilter(new String[] { "foo", "bar" }, IOCase.SYSTEM);
313         assertFiltering(filter, new File("foo"), true);
314         assertFiltering(filter, new File("bar"), true);
315         assertFiltering(filter, new File("FOO"), WINDOWS);
316         assertFiltering(filter, new File("BAR"), WINDOWS);
317         
318         filter = new NameFileFilter(new String[] { "foo", "bar" }, (IOCase) null);
319         assertFiltering(filter, new File("foo"), true);
320         assertFiltering(filter, new File("bar"), true);
321         assertFiltering(filter, new File("FOO"), false);
322         assertFiltering(filter, new File("BAR"), false);
323 
324         // repeat for a List
325         java.util.ArrayList list = new java.util.ArrayList();
326         list.add("foo");
327         list.add("bar");
328         filter = new NameFileFilter(list);
329         assertFiltering(filter, new File("foo"), true);
330         assertFiltering(filter, new File("bar"), true);
331         assertFiltering(filter, new File("fred"), false);
332 
333         filter = new NameFileFilter("foo");
334         assertFiltering(filter, new File("foo"), true);
335         assertFiltering(filter, new File("FOO"), false); //case-sensitive
336         assertFiltering(filter, new File("barfoo"), false);
337         assertFiltering(filter, new File("foobar"), false);
338         assertFiltering(filter, new File("fred"), false);
339     }
340 
341     public void testNameFilterNullArgument() throws Exception {
342     	String test = null;
343     	try {
344     		new NameFileFilter(test);
345     		fail( "constructing a NameFileFilter with a null String argument should fail.");
346     	} catch( IllegalArgumentException iae ) {
347     	}
348     }
349 
350     public void testNameFilterNullArrayArgument() throws Exception {
351     	String[] test = null;
352     	try {
353     		new NameFileFilter(test);
354     		fail( "constructing a NameFileFilter with a null String[] argument should fail.");
355     	} catch( IllegalArgumentException iae ) {
356     	}
357     }
358 
359     public void testNameFilterNullListArgument() throws Exception {
360     	List test = null;
361     	try {
362     		new NameFileFilter(test);
363     		fail( "constructing a NameFileFilter with a null List argument should fail.");
364     	} catch( IllegalArgumentException iae ) {
365     	}
366     }
367 
368     public void testTrue() throws Exception {
369         IOFileFilter filter = FileFilterUtils.trueFileFilter();
370         assertFiltering(filter, new File("foo.test"), true);
371         assertFiltering(filter, new File("foo"), true);
372         assertFiltering(filter, null, true);
373         assertSame(TrueFileFilter.TRUE, TrueFileFilter.INSTANCE);
374     }
375 
376     public void testFalse() throws Exception {
377         IOFileFilter filter = FileFilterUtils.falseFileFilter();
378         assertFiltering(filter, new File("foo.test"), false);
379         assertFiltering(filter, new File("foo"), false);
380         assertFiltering(filter, null, false);
381         assertSame(FalseFileFilter.FALSE, FalseFileFilter.INSTANCE);
382     }
383 
384     public void testNot() throws Exception {
385         IOFileFilter filter = FileFilterUtils.notFileFilter(FileFilterUtils.trueFileFilter());
386         assertFiltering(filter, new File("foo.test"), false);
387         assertFiltering(filter, new File("foo"), false);
388         assertFiltering(filter, null, false);
389         try {
390             new NotFileFilter(null);
391             fail();
392         } catch (IllegalArgumentException ex) {
393         }
394     }
395 
396     public void testAnd() throws Exception {
397         IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
398         IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
399         assertFiltering(new AndFileFilter(trueFilter, trueFilter), new File("foo.test"), true);
400         assertFiltering(new AndFileFilter(trueFilter, falseFilter), new File("foo.test"), false);
401         assertFiltering(new AndFileFilter(falseFilter, trueFilter), new File("foo.test"), false);
402         assertFiltering(new AndFileFilter(falseFilter, falseFilter), new File("foo.test"), false);
403 
404         List filters = new ArrayList();
405         assertFiltering( new AndFileFilter( filters ), new File( "test" ), false );
406         assertFiltering( new AndFileFilter(), new File( "test" ), false );
407         
408         try {
409             new AndFileFilter(falseFilter, null);
410             fail();
411         } catch (IllegalArgumentException ex) {
412         }
413 
414         AndFileFilter f = new AndFileFilter((List) null);
415         assertEquals(true, f.getFileFilters().isEmpty());
416     }
417 
418     public void testOr() throws Exception {
419         IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
420         IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
421         File testFile = new File( "foo.test" );
422         assertFiltering(new OrFileFilter(trueFilter, trueFilter), testFile, true);
423         assertFiltering(new OrFileFilter(trueFilter, falseFilter), testFile, true);
424         assertFiltering(new OrFileFilter(falseFilter, trueFilter), testFile, true);
425         assertFiltering(new OrFileFilter(falseFilter, falseFilter), testFile, false);
426         assertFiltering(new OrFileFilter(), testFile, false);
427         
428         List filters = new ArrayList();
429         filters.add( trueFilter );
430         filters.add( falseFilter );
431 
432         OrFileFilter orFilter = new OrFileFilter( filters );
433 
434         assertFiltering(orFilter, testFile, true);
435         assertEquals( orFilter.getFileFilters(), filters );
436         orFilter.removeFileFilter( trueFilter );
437         assertFiltering(orFilter, testFile, false);
438         orFilter.setFileFilters( filters );
439         assertFiltering(orFilter, testFile, true);
440         
441         assertTrue( orFilter.accept( testFile.getParentFile(), testFile.getName() ) );
442         orFilter.removeFileFilter( trueFilter );
443         assertTrue( !orFilter.accept( testFile.getParentFile(), testFile.getName() ) );
444         
445         try {
446             new OrFileFilter(falseFilter, null);
447             fail();
448         } catch (IllegalArgumentException ex) {
449         }
450         
451         OrFileFilter f = new OrFileFilter((List) null);
452         assertEquals(true, f.getFileFilters().isEmpty());
453     }
454 
455     public void testDeprecatedWildcard() throws Exception {
456         IOFileFilter filter = new WildcardFilter("*.txt");
457         List patternList = Arrays.asList( new String[] { "*.txt", "*.xml", "*.gif" } );
458         IOFileFilter listFilter = new WildcardFilter( patternList );
459         File txtFile = new File( "test.txt" );
460         File bmpFile = new File( "test.bmp" );
461         File dir = new File( "src/java" );
462         
463         assertFiltering(filter, new File("log.txt"), true);
464 //        assertFiltering(filter, new File("log.txt.bak"), false);
465 
466         filter = new WildcardFilter("log?.txt");
467         assertFiltering(filter, new File("log1.txt"), true);
468         assertFiltering(filter, new File("log12.txt"), false);
469 
470         filter = new WildcardFilter("open??.????04");
471         assertFiltering(filter, new File("openAB.102504"), true);
472         assertFiltering(filter, new File("openA.102504"), false);
473         assertFiltering(filter, new File("openXY.123103"), false);
474 //        assertFiltering(filter, new File("openAB.102504.old"), false);
475 
476         filter = new WildcardFilter(new String[] {"*.java", "*.class"});
477         assertFiltering(filter, new File("Test.java"), true);
478         assertFiltering(filter, new File("Test.class"), true);
479         assertFiltering(filter, new File("Test.jsp"), false);
480 
481         assertFiltering(listFilter, new File("Test.txt"), true);
482         assertFiltering(listFilter, new File("Test.xml"), true);
483         assertFiltering(listFilter, new File("Test.gif"), true);
484         assertFiltering(listFilter, new File("Test.bmp"), false);
485 
486         assertTrue( listFilter.accept( txtFile ) );
487         assertTrue( !listFilter.accept( bmpFile ) );
488         assertTrue( !listFilter.accept( dir ) );
489 
490         assertTrue( listFilter.accept( txtFile.getParentFile(), txtFile.getName() ) );
491         assertTrue( !listFilter.accept( bmpFile.getParentFile(), bmpFile.getName() ) );
492         assertTrue( !listFilter.accept( dir.getParentFile(), dir.getName() ) );
493 
494         try {
495             new WildcardFilter((String) null);
496             fail();
497         } catch (IllegalArgumentException ex) {
498             // expected
499         }
500 
501         try {
502             new WildcardFilter((String[]) null);
503             fail();
504         } catch (IllegalArgumentException ex) {
505             // expected
506         }
507 
508         try {
509             new WildcardFilter((List) null);
510             fail();
511         } catch (IllegalArgumentException ex) {
512             // expected
513         }
514     }
515 
516     public void testWildcard() throws Exception {
517         IOFileFilter filter = new WildcardFileFilter("*.txt");
518         assertFiltering(filter, new File("log.txt"), true);
519         assertFiltering(filter, new File("log.TXT"), false);
520         
521         filter = new WildcardFileFilter("*.txt", IOCase.SENSITIVE);
522         assertFiltering(filter, new File("log.txt"), true);
523         assertFiltering(filter, new File("log.TXT"), false);
524         
525         filter = new WildcardFileFilter("*.txt", IOCase.INSENSITIVE);
526         assertFiltering(filter, new File("log.txt"), true);
527         assertFiltering(filter, new File("log.TXT"), true);
528         
529         filter = new WildcardFileFilter("*.txt", IOCase.SYSTEM);
530         assertFiltering(filter, new File("log.txt"), true);
531         assertFiltering(filter, new File("log.TXT"), WINDOWS);
532         
533         filter = new WildcardFileFilter("*.txt", (IOCase) null);
534         assertFiltering(filter, new File("log.txt"), true);
535         assertFiltering(filter, new File("log.TXT"), false);
536         
537         filter = new WildcardFileFilter(new String[] {"*.java", "*.class"});
538         assertFiltering(filter, new File("Test.java"), true);
539         assertFiltering(filter, new File("Test.class"), true);
540         assertFiltering(filter, new File("Test.jsp"), false);
541         
542         filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.SENSITIVE);
543         assertFiltering(filter, new File("Test.java"), true);
544         assertFiltering(filter, new File("Test.JAVA"), false);
545         
546         filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.INSENSITIVE);
547         assertFiltering(filter, new File("Test.java"), true);
548         assertFiltering(filter, new File("Test.JAVA"), true);
549         
550         filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, IOCase.SYSTEM);
551         assertFiltering(filter, new File("Test.java"), true);
552         assertFiltering(filter, new File("Test.JAVA"), WINDOWS);
553         
554         filter = new WildcardFileFilter(new String[] {"*.java", "*.class"}, (IOCase) null);
555         assertFiltering(filter, new File("Test.java"), true);
556         assertFiltering(filter, new File("Test.JAVA"), false);
557         
558         List patternList = Arrays.asList( new String[] { "*.txt", "*.xml", "*.gif" } );
559         IOFileFilter listFilter = new WildcardFileFilter( patternList );
560         assertFiltering(listFilter, new File("Test.txt"), true);
561         assertFiltering(listFilter, new File("Test.xml"), true);
562         assertFiltering(listFilter, new File("Test.gif"), true);
563         assertFiltering(listFilter, new File("Test.bmp"), false);
564         
565         File txtFile = new File( "test.txt" );
566         File bmpFile = new File( "test.bmp" );
567         File dir = new File( "src/java" );
568         assertTrue( listFilter.accept( txtFile ) );
569         assertTrue( !listFilter.accept( bmpFile ) );
570         assertTrue( !listFilter.accept( dir ) );
571         
572         assertTrue( listFilter.accept( txtFile.getParentFile(), txtFile.getName() ) );
573         assertTrue( !listFilter.accept( bmpFile.getParentFile(), bmpFile.getName() ) );
574         assertTrue( !listFilter.accept( dir.getParentFile(), dir.getName() ) );
575         
576         try {
577             new WildcardFileFilter((String) null);
578             fail();
579         } catch (IllegalArgumentException ex) {}
580         try {
581             new WildcardFileFilter((String[]) null);
582             fail();
583         } catch (IllegalArgumentException ex) {}
584         try {
585             new WildcardFileFilter((List) null);
586             fail();
587         } catch (IllegalArgumentException ex) {}
588     }
589 
590     public void testDelegateFileFilter() throws Exception {
591     	OrFileFilter orFilter = new OrFileFilter();
592     	File testFile = new File( "test.txt" );
593 
594     	IOFileFilter filter = new DelegateFileFilter((FileFilter) orFilter);
595     	assertFiltering( filter, testFile, false );
596 
597     	filter = new DelegateFileFilter((FilenameFilter) orFilter);
598     	assertFiltering( filter, testFile, false );
599 
600     	try {
601     		new DelegateFileFilter((FileFilter) null);
602     		fail();
603     	} catch( IllegalArgumentException iae ) {
604     	}
605 
606     	try {
607     		new DelegateFileFilter((FilenameFilter) null);
608     		fail();
609     	} catch( IllegalArgumentException iae ) {
610     	}
611 
612     }
613 
614     public void testMakeCVSAware() throws Exception {
615         IOFileFilter filter1 = FileFilterUtils.makeCVSAware(null);
616         IOFileFilter filter2 = FileFilterUtils.makeCVSAware(FileFilterUtils
617             .nameFileFilter("test-file1.txt"));
618 
619         File file = new File(getTestDirectory(), "CVS");
620         file.mkdirs();
621         assertFiltering(filter1, file, false);
622         assertFiltering(filter2, file, false);
623         FileUtils.deleteDirectory(file);
624 
625         file = new File(getTestDirectory(), "test-file1.txt");
626         createFile(file, 0);
627         assertFiltering(filter1, file, true);
628         assertFiltering(filter2, file, true);
629 
630         file = new File(getTestDirectory(), "test-file2.log");
631         createFile(file, 0);
632         assertFiltering(filter1, file, true);
633         assertFiltering(filter2, file, false);
634 
635         file = new File(getTestDirectory(), "CVS");
636         createFile(file, 0);
637         assertFiltering(filter1, file, true);
638         assertFiltering(filter2, file, false);
639     }
640          
641     public void testMakeSVNAware() throws Exception {
642         IOFileFilter filter1 = FileFilterUtils.makeSVNAware(null);
643         IOFileFilter filter2 = FileFilterUtils.makeSVNAware(FileFilterUtils
644             .nameFileFilter("test-file1.txt"));
645 
646         File file = new File(getTestDirectory(), SVN_DIR_NAME);
647         file.mkdirs();
648         assertFiltering(filter1, file, false);
649         assertFiltering(filter2, file, false);
650         FileUtils.deleteDirectory(file);
651 
652         file = new File(getTestDirectory(), "test-file1.txt");
653         createFile(file, 0);
654         assertFiltering(filter1, file, true);
655         assertFiltering(filter2, file, true);
656 
657         file = new File(getTestDirectory(), "test-file2.log");
658         createFile(file, 0);
659         assertFiltering(filter1, file, true);
660         assertFiltering(filter2, file, false);
661 
662         file = new File(getTestDirectory(), SVN_DIR_NAME);
663         createFile(file, 0);
664         assertFiltering(filter1, file, true);
665         assertFiltering(filter2, file, false);
666     }
667 
668     public void testAgeFilter() throws Exception {
669         File oldFile = new File(getTestDirectory(), "old.txt");
670         File reference = new File(getTestDirectory(), "reference.txt");
671         File newFile = new File(getTestDirectory(), "new.txt");
672 
673         createFile(oldFile, 0);
674 
675         do {
676             try { 
677                 Thread.sleep(1000);
678             } catch(InterruptedException ie) {
679                 // ignore
680             }
681             createFile(reference, 0);
682         } while( oldFile.lastModified() == reference.lastModified() );
683 
684         Date date = new Date();
685         long now = date.getTime();
686 
687         do {
688             try { 
689                 Thread.sleep(1000);
690             } catch(InterruptedException ie) {
691                 // ignore
692             }
693             createFile(newFile, 0);
694         } while( reference.lastModified() == newFile.lastModified() );
695 
696         IOFileFilter filter1 = FileFilterUtils.ageFileFilter(now);
697         IOFileFilter filter2 = FileFilterUtils.ageFileFilter(now, true);
698         IOFileFilter filter3 = FileFilterUtils.ageFileFilter(now, false);
699         IOFileFilter filter4 = FileFilterUtils.ageFileFilter(date);
700         IOFileFilter filter5 = FileFilterUtils.ageFileFilter(date, true);
701         IOFileFilter filter6 = FileFilterUtils.ageFileFilter(date, false);
702         IOFileFilter filter7 = FileFilterUtils.ageFileFilter(reference);
703         IOFileFilter filter8 = FileFilterUtils.ageFileFilter(reference, true);
704         IOFileFilter filter9 = FileFilterUtils.ageFileFilter(reference, false);
705 
706         assertFiltering(filter1, oldFile, true);
707         assertFiltering(filter2, oldFile, true);
708         assertFiltering(filter3, oldFile, false);
709         assertFiltering(filter4, oldFile, true);
710         assertFiltering(filter5, oldFile, true);
711         assertFiltering(filter6, oldFile, false);
712         assertFiltering(filter7, oldFile, true);
713         assertFiltering(filter8, oldFile, true);
714         assertFiltering(filter9, oldFile, false);
715         assertFiltering(filter1, newFile, false);
716         assertFiltering(filter2, newFile, false);
717         assertFiltering(filter3, newFile, true);
718         assertFiltering(filter4, newFile, false);
719         assertFiltering(filter5, newFile, false);
720         assertFiltering(filter6, newFile, true);
721         assertFiltering(filter7, newFile, false);
722         assertFiltering(filter8, newFile, false);
723         assertFiltering(filter9, newFile, true);
724     }
725 
726     public void testSizeFilter() throws Exception {
727         File smallFile = new File(getTestDirectory(), "small.txt");
728         createFile(smallFile, 32);
729         File largeFile = new File(getTestDirectory(), "large.txt");
730         createFile(largeFile, 128);
731         IOFileFilter filter1 = FileFilterUtils.sizeFileFilter(64);
732         IOFileFilter filter2 = FileFilterUtils.sizeFileFilter(64, true);
733         IOFileFilter filter3 = FileFilterUtils.sizeFileFilter(64, false);
734 
735         assertFiltering(filter1, smallFile, false);
736         assertFiltering(filter2, smallFile, false);
737         assertFiltering(filter3, smallFile, true);
738         assertFiltering(filter1, largeFile, true);
739         assertFiltering(filter2, largeFile, true);
740         assertFiltering(filter3, largeFile, false);
741 
742         // size range tests
743         IOFileFilter filter4 = FileFilterUtils.sizeRangeFileFilter(33, 127);
744         IOFileFilter filter5 = FileFilterUtils.sizeRangeFileFilter(32, 127);
745         IOFileFilter filter6 = FileFilterUtils.sizeRangeFileFilter(33, 128);
746         IOFileFilter filter7 = FileFilterUtils.sizeRangeFileFilter(31, 129);
747         IOFileFilter filter8 = FileFilterUtils.sizeRangeFileFilter(128, 128);
748 
749         assertFiltering(filter4, smallFile, false);
750         assertFiltering(filter4, largeFile, false);
751         assertFiltering(filter5, smallFile, true);
752         assertFiltering(filter5, largeFile, false);
753         assertFiltering(filter6, smallFile, false);
754         assertFiltering(filter6, largeFile, true);
755         assertFiltering(filter7, smallFile, true);
756         assertFiltering(filter7, largeFile, true);
757         assertFiltering(filter8, largeFile, true);
758 
759         try {
760             FileFilterUtils.sizeFileFilter(-1);
761             fail();
762         } catch (IllegalArgumentException ex) {
763             // expected
764         }
765     }
766 
767     public void testHidden() throws Exception {
768         File hiddenDir = new File(SVN_DIR_NAME);
769         if (hiddenDir.exists()) {
770             assertFiltering(HiddenFileFilter.HIDDEN,  hiddenDir, hiddenDir.isHidden());
771             assertFiltering(HiddenFileFilter.VISIBLE, hiddenDir, !hiddenDir.isHidden());
772         }
773         assertFiltering(HiddenFileFilter.HIDDEN,  getTestDirectory(), false);
774         assertFiltering(HiddenFileFilter.VISIBLE, getTestDirectory(), true);
775     }
776 
777     public void testCanRead() throws Exception {
778         File readOnlyFile = new File(getTestDirectory(), "read-only-file1.txt");
779         createFile(readOnlyFile, 32);
780         readOnlyFile.setReadOnly();
781         assertFiltering(CanReadFileFilter.CAN_READ,  readOnlyFile, true);
782         assertFiltering(CanReadFileFilter.CANNOT_READ,  readOnlyFile, false);
783         assertFiltering(CanReadFileFilter.READ_ONLY, readOnlyFile, true);
784         readOnlyFile.delete();
785     }
786 
787     public void testCanWrite() throws Exception {
788         File readOnlyFile = new File(getTestDirectory(), "read-only-file2.txt");
789         createFile(readOnlyFile, 32);
790         readOnlyFile.setReadOnly();
791         assertFiltering(CanWriteFileFilter.CAN_WRITE,    getTestDirectory(), true);
792         assertFiltering(CanWriteFileFilter.CANNOT_WRITE, getTestDirectory(), false);
793         assertFiltering(CanWriteFileFilter.CAN_WRITE,    readOnlyFile, false);
794         assertFiltering(CanWriteFileFilter.CANNOT_WRITE, readOnlyFile, true);
795         readOnlyFile.delete();
796     }
797 
798     public void testEmpty() throws Exception {
799 
800         // Empty Dir        
801         File emptyDir  = new File(getTestDirectory(), "empty-dir");
802         emptyDir.mkdirs();
803         assertFiltering(EmptyFileFilter.EMPTY, emptyDir, true);
804         assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, false);
805 
806         // Empty File
807         File emptyFile = new File(emptyDir, "empty-file.txt");
808         createFile(emptyFile, 0);
809         assertFiltering(EmptyFileFilter.EMPTY, emptyFile, true);
810         assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyFile, false);
811 
812         // Not Empty Dir
813         assertFiltering(EmptyFileFilter.EMPTY, emptyDir, false);
814         assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, true);
815 
816         // Not Empty File
817         File notEmptyFile = new File(emptyDir, "not-empty-file.txt");
818         createFile(notEmptyFile, 32);
819         assertFiltering(EmptyFileFilter.EMPTY, notEmptyFile, false);
820         assertFiltering(EmptyFileFilter.NOT_EMPTY, notEmptyFile, true);
821         FileUtils.forceDelete(emptyDir);
822     }
823 
824     //-----------------------------------------------------------------------
825     public void testMakeDirectoryOnly() throws Exception {
826         assertSame(DirectoryFileFilter.DIRECTORY, FileFilterUtils.makeDirectoryOnly(null));
827         
828         IOFileFilter filter = FileFilterUtils.makeDirectoryOnly(
829                 FileFilterUtils.nameFileFilter("B"));
830         
831         File fileA = new File(getTestDirectory(), "A");
832         File fileB = new File(getTestDirectory(), "B");
833         
834         fileA.mkdirs();
835         fileB.mkdirs();
836         
837         assertFiltering(filter, fileA, false);
838         assertFiltering(filter, fileB, true);
839         
840         FileUtils.deleteDirectory(fileA);
841         FileUtils.deleteDirectory(fileB);
842         
843         createFile(fileA, 32);
844         createFile(fileB, 32);
845         
846         assertFiltering(filter, fileA, false);
847         assertFiltering(filter, fileB, false);
848         
849         fileA.delete();
850         fileB.delete();
851     }
852          
853     //-----------------------------------------------------------------------
854     public void testMakeFileOnly() throws Exception {
855         assertSame(FileFileFilter.FILE, FileFilterUtils.makeFileOnly(null));
856         
857         IOFileFilter filter = FileFilterUtils.makeFileOnly(
858                 FileFilterUtils.nameFileFilter("B"));
859         
860         File fileA = new File(getTestDirectory(), "A");
861         File fileB = new File(getTestDirectory(), "B");
862         
863         fileA.mkdirs();
864         fileB.mkdirs();
865         
866         assertFiltering(filter, fileA, false);
867         assertFiltering(filter, fileB, false);
868         
869         FileUtils.deleteDirectory(fileA);
870         FileUtils.deleteDirectory(fileB);
871         
872         createFile(fileA, 32);
873         createFile(fileB, 32);
874         
875         assertFiltering(filter, fileA, false);
876         assertFiltering(filter, fileB, true);
877         
878         fileA.delete();
879         fileB.delete();
880     }
881          
882 }