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 testDirectory() throws Exception {
133         // XXX: This test presumes the current working dir is the base dir of the source checkout.
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         // XXX: This test presumes the current working dir is the base dir of the source checkout.
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);  //case-sensitive
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         // repeat for a List
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); //case-sensitive
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 //        assertFiltering(filter, new File("log.txt.bak"), false);
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 //        assertFiltering(filter, new File("openAB.102504.old"), false);
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             // expected
419         }
420 
421         try {
422             new WildcardFilter((String[]) null);
423             fail();
424         } catch (IllegalArgumentException ex) {
425             // expected
426         }
427 
428         try {
429             new WildcardFilter((List) null);
430             fail();
431         } catch (IllegalArgumentException ex) {
432             // expected
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                 // ignore
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                 // ignore
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         // size range tests
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             // expected
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         // Empty Dir        
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         // Empty File
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         // Not Empty Dir
733         assertFiltering(EmptyFileFilter.EMPTY, emptyDir, false);
734         assertFiltering(EmptyFileFilter.NOT_EMPTY, emptyDir, true);
735 
736         // Not Empty File
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 }