← Back to branch summary

~ubuntu-branches/ubuntu/karmic/commons-io/karmic

« back to all changes in this revision

Viewing changes to src/test/org/apache/commons/io/filefilter/FileFilterTestCase.java

  • Committer: Bazaar Package Importer
  • Author(s): Arnaud Vandyck
  • Date: 2007-04-13 08:20:49 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070413082049-2hd3s5ixtxsgvnvm
Tags: 1.3.1.dfsg.1-1
http://bugs.debian.org/418973
http://bugs.debian.org/397567
* New upstream (closes: #418973)
* java-gcj-compat-dev and cdbs transition
* Removed junit at the moment (closes: #397567)
* No javadoc at the moment

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/org/apache/commons/io/filefilter/FileFilterTestCase.java
1
1
/*
2
 
 * Copyright 2002-2004 The Apache Software Foundation.
3
 
 * 
4
 
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 
 * you may not use this file except in compliance with the License.
6
 
 * You may obtain a copy of the License at
 
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
7
8
 * 
8
9
 *      http://www.apache.org/licenses/LICENSE-2.0
9
10
 * 
16
17
package org.apache.commons.io.filefilter;
17
18
 
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;
19
26
 
20
 
import junit.framework.TestCase;
21
27
import junit.framework.TestSuite;
22
28
import junit.textui.TestRunner;
23
29
 
 
30
import org.apache.commons.io.FileUtils;
 
31
import org.apache.commons.io.IOCase;
 
32
import org.apache.commons.io.testtools.FileBasedTestCase;
 
33
 
24
34
/**
25
 
 * Used to test an unknown FileFilter
 
35
 * Used to test FileFilterUtils.
26
36
 */
27
 
public class FileFilterTestCase extends TestCase {
 
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 == '\\');
28
45
 
29
46
    public FileFilterTestCase(String name) {
30
47
        super(name);
31
48
    }
32
 
    
 
49
 
33
50
    public static void main(String[] args) {
34
51
        TestRunner.run(suite());
35
52
    }
36
 
    
 
53
 
37
54
    public static TestSuite suite() {
38
55
        return new TestSuite(FileFilterTestCase.class);
39
56
    }
40
57
 
41
58
    public void setUp() {
 
59
        getTestDirectory().mkdirs();
42
60
    }
43
61
 
44
 
    public void tearDown() {
 
62
    public void tearDown() throws Exception {
 
63
        FileUtils.deleteDirectory(getTestDirectory());
45
64
    }
46
65
 
47
66
    public void assertFiltering(IOFileFilter filter, File file, boolean expected) throws Exception {
48
 
        // Note. This only tests the (File, String) version if the parent of 
 
67
        // Note. This only tests the (File, String) version if the parent of
49
68
        //       the File passed in is not null
50
69
        assertTrue(
51
70
            "Filter(File) " + filter.getClass().getName() + " not " + expected + " for " + file,
64
83
 
65
84
    public void testSuffix() throws Exception {
66
85
        IOFileFilter filter = new SuffixFileFilter(new String[] { "tes", "est" });
 
86
        File testFile = new File( "test" );
 
87
        File fredFile = new File( "fred" );
67
88
        assertFiltering(filter, new File("fred.tes"), true);
68
89
        assertFiltering(filter, new File("fred.est"), true);
69
90
        assertFiltering(filter, new File("fred.EST"), false); //case-sensitive
70
91
        assertFiltering(filter, new File("fred.exe"), false);
 
92
 
 
93
        filter = FileFilterUtils.orFileFilter( 
 
94
                                FileFilterUtils.suffixFileFilter( "tes" ),
 
95
                                FileFilterUtils.suffixFileFilter( "est" ) );
71
96
        assertFiltering(filter, new File("fred"), false);
72
97
        assertFiltering(filter, new File(".tes"), true);
73
98
        assertFiltering(filter, new File("fred.test"), true);
74
 
        
 
99
 
75
100
        filter = new SuffixFileFilter("est");
76
101
        assertFiltering(filter, new File("test"), true);
77
102
        assertFiltering(filter, new File("fred"), false);
78
 
        
 
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
 
79
113
        try {
80
114
            new SuffixFileFilter((String) null);
81
115
            fail();
82
116
        } catch (IllegalArgumentException ex) {
83
117
        }
84
 
    }
 
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
}
85
131
 
86
132
    public void testDirectory() throws Exception {
 
133
        // XXX: This test presumes the current working dir is the base dir of the source checkout.
87
134
        IOFileFilter filter = new DirectoryFileFilter();
88
135
 
89
136
        assertFiltering(filter, new File("src/"), true);
94
141
        assertFiltering(filter, new File("imaginary"), false);
95
142
        assertFiltering(filter, new File("imaginary/"), false);
96
143
 
97
 
        assertFiltering(filter, new File("STATUS.html"), false);
 
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);
98
162
    }
99
163
 
100
164
    public void testPrefix() throws Exception {
101
165
        IOFileFilter filter = new PrefixFileFilter(new String[] { "foo", "bar" });
 
166
        File testFile = new File( "test" );
 
167
        File fredFile = new File( "fred" );
 
168
 
102
169
        assertFiltering(filter, new File("foo.test"), true);
103
170
        assertFiltering(filter, new File("FOO.test"), false);  //case-sensitive
104
171
        assertFiltering(filter, new File("foo"), true);
105
172
        assertFiltering(filter, new File("bar"), true);
106
173
        assertFiltering(filter, new File("food/"), true);
 
174
 
 
175
        filter = FileFilterUtils.prefixFileFilter( "bar" );
107
176
        assertFiltering(filter, new File("barred\\"), true);
108
177
        assertFiltering(filter, new File("test"), false);
109
178
        assertFiltering(filter, new File("fo_o.test"), false);
110
179
        assertFiltering(filter, new File("abar.exe"), false);
111
 
        
 
180
 
112
181
        filter = new PrefixFileFilter("tes");
113
182
        assertFiltering(filter, new File("test"), true);
114
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
        
115
194
        
116
195
        try {
117
196
            new PrefixFileFilter((String) null);
118
197
            fail();
119
198
        } catch (IllegalArgumentException ex) {
120
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
        }
121
212
    }
122
 
    
 
213
 
123
214
    public void testNameFilter() throws Exception {
124
215
        IOFileFilter filter = new NameFileFilter(new String[] { "foo", "bar" });
125
216
        assertFiltering(filter, new File("foo"), true);
126
217
        assertFiltering(filter, new File("bar"), true);
127
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);
128
243
 
129
244
        // repeat for a List
130
245
        java.util.ArrayList list = new java.util.ArrayList();
143
258
        assertFiltering(filter, new File("fred"), false);
144
259
    }
145
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
 
146
288
    public void testTrue() throws Exception {
147
289
        IOFileFilter filter = FileFilterUtils.trueFileFilter();
148
290
        assertFiltering(filter, new File("foo.test"), true);
149
291
        assertFiltering(filter, new File("foo"), true);
150
292
        assertFiltering(filter, null, true);
 
293
        assertSame(TrueFileFilter.TRUE, TrueFileFilter.INSTANCE);
151
294
    }
152
295
 
153
296
    public void testFalse() throws Exception {
155
298
        assertFiltering(filter, new File("foo.test"), false);
156
299
        assertFiltering(filter, new File("foo"), false);
157
300
        assertFiltering(filter, null, false);
 
301
        assertSame(FalseFileFilter.FALSE, FalseFileFilter.INSTANCE);
158
302
    }
159
303
 
160
304
    public void testNot() throws Exception {
176
320
        assertFiltering(new AndFileFilter(trueFilter, falseFilter), new File("foo.test"), false);
177
321
        assertFiltering(new AndFileFilter(falseFilter, trueFilter), new File("foo.test"), false);
178
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
        
179
328
        try {
180
329
            new AndFileFilter(falseFilter, null);
181
330
            fail();
182
331
        } catch (IllegalArgumentException ex) {
183
332
        }
 
333
 
 
334
        AndFileFilter f = new AndFileFilter((List) null);
 
335
        assertEquals(true, f.getFileFilters().isEmpty());
184
336
    }
185
337
 
186
338
    public void testOr() throws Exception {
187
339
        IOFileFilter trueFilter = TrueFileFilter.INSTANCE;
188
340
        IOFileFilter falseFilter = FalseFileFilter.INSTANCE;
189
 
        assertFiltering(new OrFileFilter(trueFilter, trueFilter), new File("foo.test"), true);
190
 
        assertFiltering(new OrFileFilter(trueFilter, falseFilter), new File("foo.test"), true);
191
 
        assertFiltering(new OrFileFilter(falseFilter, trueFilter), new File("foo.test"), true);
192
 
        assertFiltering(new OrFileFilter(falseFilter, falseFilter), new File("foo.test"), false);
 
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
        
193
365
        try {
194
366
            new OrFileFilter(falseFilter, null);
195
367
            fail();
196
368
        } catch (IllegalArgumentException ex) {
197
369
        }
198
 
    }
199
 
 
 
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
         
200
802
}