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