/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.dev.resource.impl;
import com.google.gwt.dev.resource.impl.DefaultFilters.FilterFileType;
import junit.framework.TestCase;
import org.apache.tools.ant.types.ZipScanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* An implementation for DefaultExcludesFilterTest.
*
* Tests:
*
* 1. The filter conversion from ant to Java regex. Which cases can we handle,
* and confirm that we perform correctly in all cases.
*
* 2. checking the 4 defaultFilters, one for each combination of defaultExcludes
* and isJava.
*
* 3. Checking whether customFilter work correctly, both in presence and absence
* of Ant.
*
* TODO (amitmanjhi): clean up this test code.
*/
public class DefaultFiltersTest extends TestCase {
static class AdvancedPaths {
String baseIncluded[] = {
"Baz", "test/foo/Foo", "test/bar/Bar", "test/baz/Foo"};
String baseExcludedTesting[] = {"foo/testing/Baz"};
String baseExcludedExact[] = {"Foo", "Bar",};
String baseExcludedDoubleStar[] = {"fooz/Baz", "barz/hello/Baz"};
String baseExcluded[] = mergeArrays(baseExcludedTesting, baseExcludedExact,
baseExcludedDoubleStar);
void testAdvancedPath(ResourceFilterString expected,
ResourceFilterString actual, String suffix) {
for (String path : mergeArrays(baseIncluded, baseExcluded, getMiscPaths(
"testing", false).toArray(EMPTY_ARRAY),
getMiscPaths("a/bc/de", false).toArray(EMPTY_ARRAY))) {
assertEquals(path + suffix, expected, actual);
}
}
void testAdvancedPathAnt(ResourceFilterString expected,
ResourceFilterString actual, String suffix) {
for (String path : mergeArrays(baseIncluded, baseExcluded, getMiscPaths(
"testing", true).toArray(EMPTY_ARRAY),
getMiscPaths("a/bc/de", true).toArray(EMPTY_ARRAY))) {
assertEquals(EXCLUDED_CHARS + path + EXCLUDED_CHARS + suffix,
expected, actual);
assertEquals(path + EXCLUDED_CHARS + suffix, expected, actual);
assertEquals(path + suffix, expected, actual);
}
testAdvancedPath(expected, actual, suffix);
new BasicPaths().testBasicPath(expected, actual, suffix);
}
void testAdvancedClassFilesPathAnt(ResourceFilterString expected,
ResourceFilterString actual) {
testAdvancedPathAnt(expected, actual, CLASS_FILE_SUFFIX);
}
void testAdvancedJavaPathAnt(ResourceFilterString expected,
ResourceFilterString actual) {
testAdvancedPathAnt(expected, actual, JAVA_FILE_SUFFIX);
}
void testAdvancedPath(ResourceFilterString expected,
ResourceFilterString actual) {
for (String path : mergeArrays(baseIncluded, baseExcluded, getMiscPaths(
"testing", false).toArray(EMPTY_ARRAY),
getMiscPaths("a/bc/de", false).toArray(EMPTY_ARRAY))) {
assertEquals(path, expected, actual);
}
}
void testAdvancedPathAnt(ResourceFilterString expected,
ResourceFilterString actual) {
for (String path : mergeArrays(baseIncluded, baseExcluded, getMiscPaths(
"testing", true).toArray(EMPTY_ARRAY),
getMiscPaths("a/bc/de", true).toArray(EMPTY_ARRAY))) {
assertEquals(path, expected, actual);
assertEquals(path + EXCLUDED_CHARS, expected, actual);
assertEquals(EXCLUDED_CHARS + path + EXCLUDED_CHARS, expected, actual);
}
testAdvancedPath(expected, actual);
new BasicPaths().testBasicPath(expected, actual);
}
}
static class BasicPaths {
String baseIncluded[] = {
"foo", "/foo", "foo/bar", "/foo/bar", "/foo/bar", "/foo$/$", "/foo-_", "123FOO123", "cvs",
"cvs/cvs/svn", ".foo_bar$", "foo/asvn"};
String baseExcluded[] = {"foo/CVS/bar", "CVS/bar", "foo/.svn/bar", ".svn/bar", "foo/SCCS/bar",};
String baseSuffixExcluded[] = {
"foo/.cvsignore", "foo/CVS", "foo/.svn", "foo/SCCS",
"foo/bar/vssver.scc", "/foo/bar/.DS_Store"};
void testBasicPath(ResourceFilterString expected,
ResourceFilterString actual, String suffix) {
for (String str : mergeArrays(baseIncluded, baseExcluded,
baseSuffixExcluded,
getMiscPaths("testing", true).toArray(EMPTY_ARRAY), getMiscPaths(
"a/bc/de", true).toArray(EMPTY_ARRAY))) {
assertEquals(str, expected, actual);
assertEquals(str + suffix, expected, actual);
assertEquals(EXCLUDED_CHARS + str, expected, actual);
assertEquals(EXCLUDED_CHARS + str + EXCLUDED_CHARS, expected, actual);
assertEquals(EXCLUDED_CHARS + str + suffix, expected, actual);
assertEquals(EXCLUDED_CHARS + str + EXCLUDED_CHARS + suffix,
expected, actual);
}
}
void testBasicPath(ResourceFilterString expected,
ResourceFilterString actual) {
for (String str : mergeArrays(baseIncluded, baseExcluded,
baseSuffixExcluded,
getMiscPaths("testing", true).toArray(EMPTY_ARRAY), getMiscPaths(
"a/bc/de", true).toArray(EMPTY_ARRAY))) {
assertEquals(str, expected, actual);
assertEquals(EXCLUDED_CHARS + str, expected, actual);
assertEquals(EXCLUDED_CHARS + str + EXCLUDED_CHARS, expected, actual);
}
}
}
/*
* Sole purpose of this class is to get a useful debug message.
*/
private static class ResourceFilterString {
final ResourceFilter filter;
final String stringRepresentation;
ResourceFilterString(ResourceFilter filter, String stringRepresentation) {
this.filter = filter;
this.stringRepresentation = stringRepresentation;
}
}
private static final String EMPTY_ARRAY[] = new String[0];
private static final boolean DEFAULT_EXCLUDES = true;
private static final boolean DEFAULT_INCLUDES = false;
private static final String JAVA_FILE_SUFFIX = ".java";
private static final String CLASS_FILE_SUFFIX = ".class";
private static final String MERGED_PATTERNS[] = {
"**/testing/**", "Foo", "Bar", "fooz/**", "barz/hello/**"};
// careful that the pattern is still permitted by ant.
private static final String EXCLUDED_CHARS = "#~%*";
private static void assertEquals(String path, ResourceFilterString expected,
ResourceFilterString actual) {
boolean scanResult = expected.filter.allows(path);
assertEquals("String to be matched = " + path + ", actual filter = "
+ actual.stringRepresentation + " should yield " + scanResult
+ ", expected Filter = " + expected.stringRepresentation, scanResult,
actual.filter.allows(path));
}
private static List<String> getMiscPaths(String middleString,
boolean endInSlash) {
List<String> testPaths = new ArrayList<String>();
testPaths.addAll(Arrays.asList(new String[] {
"Foo", "Bar", "foo/xyz", "afoo/xyz-_$", "b/foo/x",
"foo/BarTestabc.java", "foo/xyz/BarTestabc.java", "a/b/testing/c/d",
"a/testing/b/c/FooBazBarTest.java", "a/testing/b/Foo/BazBar.java",
"a/testing/b/Foo$-_$Bar.class", "a/testing/b/Foo$/$.class"}));
String pathPrefixes[] = {"", "/", "foo/", "/foo/", "bar/foo/", "/bar/foo/"};
List<String> pathSuffixes = new ArrayList<String>();
if (endInSlash) {
// special handling because currently we don't handle paths that end in /
pathSuffixes.addAll(Arrays.asList(new String[] {
"", "/", "/foo", "/foo/", "/foo/bar", "/foo/bar/"}));
} else {
pathSuffixes.addAll(Arrays.asList(new String[] {"", "/foo", "/foo/bar",}));
}
for (String pathPrefix : pathPrefixes) {
for (String pathSuffix : pathSuffixes) {
testPaths.add(pathPrefix + middleString + pathSuffix);
}
}
return testPaths;
}
private static String[] mergeArrays(String[]... baseArrays) {
int count = 0;
for (String arrayElement[] : baseArrays) {
count += arrayElement.length;
}
String retArray[] = new String[count];
count = 0;
for (String arrayElement[] : baseArrays) {
for (String element : arrayElement) {
retArray[count++] = element;
}
}
return retArray;
}
public void testEmptyFilters() {
BasicPaths basicPaths = new BasicPaths();
FilterFileType fileType;
// first arg: ant filter, second arg: our custom filter
fileType = FilterFileType.RESOURCE_FILES;
basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_EXCLUDES, fileType, "antDefaultFilter"),
new ResourceFilterString(fileType.getDefaultFilter(),
"defaultFilter"));
basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_INCLUDES, fileType, "antDefaultIncludesFilter"),
new ResourceFilterString(fileType.getFileTypeFilter(),
"defaultIncludesFilter"));
fileType = FilterFileType.JAVA_FILES;
basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_EXCLUDES, fileType, "antDefaultJavaFilter"),
new ResourceFilterString(fileType.getDefaultFilter(),
"defaultJavaFilter"), fileType.getSuffix());
basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_INCLUDES, fileType, "antJustJavaFilter"),
new ResourceFilterString(fileType.getFileTypeFilter(),
"justJavaFilter"), fileType.getSuffix());
fileType = FilterFileType.CLASS_FILES;
basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES, "antDefaultClassFilesFilter"),
new ResourceFilterString(fileType.getDefaultFilter(),
"defaultClassFilesFilter"), fileType.getSuffix());
basicPaths.testBasicPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_INCLUDES, FilterFileType.CLASS_FILES, "antJustClassFilesFilter"),
new ResourceFilterString(fileType.getFileTypeFilter(),
"justClassFilesFilter"), fileType.getSuffix());
}
/**
* (a) test that filters are correctly converted to non-null and null
* patterns. (b) test that filters match the same String.
*/
public void testFilterConversion() {
List<String> nullFilters = Arrays.asList(new String[] {
"***/testing/**", "**/{/**", "**/}/**", "**/+/**",});
List<String> okayFilters = new ArrayList<String>();
okayFilters.addAll(Arrays.asList(new String[] {
"**/#/**", "**/~/**", "Foo", "Bar", "foo/**", "foo/*Test*java",
"**/testing/**", "**/testing/**/Foo*Bar*.java",
"**/testing/**/Foo$*r.class",}));
String doubleStarPrefixes[] = {"", "/", "**/", "/**/", "foo**/", "/foo**/"};
String doubleStarSuffixes[] = {"", "/", "/**", "/**/", "/**foo", "/**foo/"};
String middleString = "testing";
for (String doubleStarPrefix : doubleStarPrefixes) {
for (String doubleStarSuffix : doubleStarSuffixes) {
okayFilters.add(doubleStarPrefix + middleString + doubleStarSuffix);
}
}
List<String> testPaths = getMiscPaths("testing", false);
DefaultFilters filters = new DefaultFilters();
for (String filter : nullFilters) {
assertNull(filter + " conversion should be null",
filters.getPatternFromAntPattern(filter));
}
for (String filter : okayFilters) {
String pattern = filters.getPatternFromAntPattern(filter);
assertNotNull(filter + " conversion should be non-null", pattern);
ResourceFilterString antFilterString = getAntFilter(
new String[] {filter}, EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES,
FilterFileType.RESOURCE_FILES, "ant_" + filter);
ResourceFilterString customFilterString = new ResourceFilterString(
filters.customFilterWithCatchAll(new String[] {filter}, EMPTY_ARRAY,
EMPTY_ARRAY, true, null, FilterFileType.RESOURCE_FILES), "custom_" + pattern);
for (String path : testPaths) {
assertEquals(path, antFilterString, customFilterString);
}
}
}
public void testFilterParts() {
AdvancedPaths advancedPaths = new AdvancedPaths();
ResourceFilter filter = null;
// everything except those starting with '/' should be included
filter = new DefaultFilters().getIncludesFilterPart(EMPTY_ARRAY);
advancedPaths.testAdvancedPath(getAntFilter(EMPTY_ARRAY, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_INCLUDES, FilterFileType.RESOURCE_FILES, "antDefaultFilter"),
new ResourceFilterString(filter, "defaultFilter"));
// everything should be excluded
filter = new DefaultFilters().getExcludesFilterPart(EMPTY_ARRAY);
advancedPaths.testAdvancedPath(getAntFilter(new String[] {"a/1/2/3"},
new String[] {"**", "/**"}, EMPTY_ARRAY, DEFAULT_INCLUDES, FilterFileType.RESOURCE_FILES,
"antDefaultFilter"), new ResourceFilterString(filter, "defaultFilter"));
filter = new DefaultFilters().getIncludesFilterPart(MERGED_PATTERNS);
advancedPaths.testAdvancedPath(getAntFilter(MERGED_PATTERNS, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_INCLUDES, FilterFileType.RESOURCE_FILES, "antMergedPatterns"),
new ResourceFilterString(filter, "customMergedPatterns"));
}
// no ant, catchAll filter is null
public void testNonEmptyFilters() {
AdvancedPaths advancedPaths = new AdvancedPaths();
ResourceFilter filter = null;
// pass empty includeArray. Matches everything that is not excluded.
filter = getFilterWithoutCatchAll(EMPTY_ARRAY, MERGED_PATTERNS, EMPTY_ARRAY,
FilterFileType.RESOURCE_FILES);
advancedPaths.testAdvancedPath(getAntFilter(EMPTY_ARRAY, MERGED_PATTERNS,
EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES, "ant_emptyArray_mergedPatterns"),
new ResourceFilterString(filter, "custom_emptyArray_mergedPatterns"));
// pass empty excludeArray. Matches everything that is included.
filter = getFilterWithoutCatchAll(MERGED_PATTERNS, EMPTY_ARRAY, EMPTY_ARRAY,
FilterFileType.RESOURCE_FILES);
advancedPaths.testAdvancedPath(getAntFilter(MERGED_PATTERNS, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES, "ant_mergedPatterns_emptyArray"),
new ResourceFilterString(filter, "custom_mergedPatterns_emptyArray"));
// pass non-empty include and exclude array. Matches nothing
filter = getFilterWithoutCatchAll(MERGED_PATTERNS, MERGED_PATTERNS,
EMPTY_ARRAY, FilterFileType.RESOURCE_FILES);
advancedPaths.testAdvancedPath(
getAntFilter(MERGED_PATTERNS, MERGED_PATTERNS, EMPTY_ARRAY,
DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES, "ant_mergedPatterns_mergedPatterns"),
new ResourceFilterString(filter, "custom_mergedPatterns_mergedPatterns"));
}
// finish, catchAll filter is not-null
public void testNonEmptyFiltersAnt() {
AdvancedPaths advancedPaths = new AdvancedPaths();
ResourceFilter filter = null;
// pass empty includeArray. Matches everything that is not excluded.
filter = getFilterWithCatchAll(EMPTY_ARRAY, MERGED_PATTERNS, EMPTY_ARRAY,
FilterFileType.RESOURCE_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(EMPTY_ARRAY, MERGED_PATTERNS,
EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES,
"ant_emptyIncludeArray_mergedPatterns"),
new ResourceFilterString(filter, "custom_emptyArray_mergedPatterns"));
// pass empty excludeArray. Matches everything that is included.
filter = getFilterWithCatchAll(MERGED_PATTERNS, EMPTY_ARRAY, EMPTY_ARRAY,
FilterFileType.RESOURCE_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(MERGED_PATTERNS, EMPTY_ARRAY,
EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES,
"ant_emptyExcludeArray_mergedPatterns"),
new ResourceFilterString(filter, "custom_emptyArray_mergedPatterns"));
// pass non-empty include and exclude array. Matches nothing
filter = getFilterWithCatchAll(MERGED_PATTERNS, MERGED_PATTERNS, EMPTY_ARRAY,
FilterFileType.RESOURCE_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(MERGED_PATTERNS,
MERGED_PATTERNS, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.RESOURCE_FILES,
"ant_mergedPatterns_mergedPatterns"), new ResourceFilterString(filter,
"custom_mergedPatterns_mergedPatterns"));
}
// no ant, catchAll filter is null
public void testNonEmptyJavaFilters() {
AdvancedPaths advancedPaths = new AdvancedPaths();
String newMergedPatterns[] = getMergedPatterns(JAVA_FILE_SUFFIX);
ResourceFilter filter = null;
// pass empty includeArray. Means catch all
filter = getFilterWithoutCatchAll(EMPTY_ARRAY, newMergedPatterns,
EMPTY_ARRAY, FilterFileType.JAVA_FILES);
advancedPaths.testAdvancedPath(getAntFilter(EMPTY_ARRAY,
newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES,
"ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter,
"custom_emptyArray_newMergedPatterns"), JAVA_FILE_SUFFIX);
// pass empty excludeArray. Means catch only the pattern
filter = getFilterWithoutCatchAll(newMergedPatterns, EMPTY_ARRAY,
EMPTY_ARRAY, FilterFileType.JAVA_FILES);
advancedPaths.testAdvancedPath(getAntFilter(newMergedPatterns,
EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES,
"ant_newMergedPatterns_emptyArray"), new ResourceFilterString(filter,
"custom_newMergedPatterns_emptyArray"), JAVA_FILE_SUFFIX);
// pass non-empty include and exclude array.
filter = getFilterWithoutCatchAll(newMergedPatterns, newMergedPatterns,
EMPTY_ARRAY, FilterFileType.JAVA_FILES);
advancedPaths.testAdvancedPath(getAntFilter(newMergedPatterns,
newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES,
"ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString(
filter, "custom_newMergedPatterns_newMergedPatterns"), JAVA_FILE_SUFFIX);
}
public void testNonEmptyJavaFiltersAnt() {
AdvancedPaths advancedPaths = new AdvancedPaths();
String newMergedPatterns[] = getMergedPatterns(JAVA_FILE_SUFFIX);
ResourceFilter filter = null;
// pass empty includeArray. Means catch all
filter = getFilterWithCatchAll(EMPTY_ARRAY, newMergedPatterns, EMPTY_ARRAY,
FilterFileType.JAVA_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(EMPTY_ARRAY,
newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES,
"ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter,
"custom_emptyArray_newMergedPatterns"), JAVA_FILE_SUFFIX);
// pass empty excludeArray. Means catch only the pattern
filter = getFilterWithCatchAll(newMergedPatterns, EMPTY_ARRAY, EMPTY_ARRAY,
FilterFileType.JAVA_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns,
EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES,
"ant_newMergedPatterns_emptyArray"), new ResourceFilterString(filter,
"custom_newMergedPatterns_emptyArray"), JAVA_FILE_SUFFIX);
// pass non-empty include and exclude array.
filter = getFilterWithCatchAll(newMergedPatterns, newMergedPatterns,
EMPTY_ARRAY, FilterFileType.JAVA_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns,
newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES,
"ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString(
filter, "custom_newMergedPatterns_newMergedPatterns"), JAVA_FILE_SUFFIX);
}
public void testNonEmptyJavaSkipFiltersAnt() {
AdvancedPaths advancedPaths = new AdvancedPaths();
String newMergedPatterns[] = getMergedPatterns(JAVA_FILE_SUFFIX);
ResourceFilter filter = null;
// pass empty includeArray. Means catch all, skipping newMergedPatterns
filter = getFilterWithCatchAll(EMPTY_ARRAY, EMPTY_ARRAY, newMergedPatterns,
FilterFileType.JAVA_FILES);
advancedPaths.testAdvancedJavaPathAnt(getAntFilter(EMPTY_ARRAY,
EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES,
"ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter,
"custom_emptyArray_newMergedPatterns"));
// pass non-empty include and skip array.
filter = getFilterWithCatchAll(newMergedPatterns, EMPTY_ARRAY,
newMergedPatterns, FilterFileType.JAVA_FILES);
advancedPaths.testAdvancedJavaPathAnt(getAntFilter(newMergedPatterns,
EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES,
"ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString(
filter, "custom_newMergedPatterns_newMergedPatterns"));
// in a single filter, skip and exclude are equivalent
filter = getFilterWithCatchAll(newMergedPatterns, newMergedPatterns,
EMPTY_ARRAY, FilterFileType.JAVA_FILES);
advancedPaths.testAdvancedJavaPathAnt(getAntFilter(newMergedPatterns,
EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.JAVA_FILES,
"ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString(
filter, "custom_newMergedPatterns_newMergedPatterns"));
}
// no ant, catchAll filter is null
public void testNonEmptyClassFileFilters() {
AdvancedPaths advancedPaths = new AdvancedPaths();
String newMergedPatterns[] = getMergedPatterns(CLASS_FILE_SUFFIX);
ResourceFilter filter = null;
// pass empty includeArray. Means catch all
filter = getFilterWithoutCatchAll(EMPTY_ARRAY, newMergedPatterns,
EMPTY_ARRAY, FilterFileType.CLASS_FILES);
advancedPaths.testAdvancedPath(getAntFilter(EMPTY_ARRAY,
newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES,
"ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter,
"custom_emptyArray_newMergedPatterns"), CLASS_FILE_SUFFIX);
// pass empty excludeArray. Means catch only the pattern
filter = getFilterWithoutCatchAll(newMergedPatterns, EMPTY_ARRAY,
EMPTY_ARRAY, FilterFileType.CLASS_FILES);
advancedPaths.testAdvancedPath(getAntFilter(newMergedPatterns,
EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES,
"ant_newMergedPatterns_emptyArray"), new ResourceFilterString(filter,
"custom_newMergedPatterns_emptyArray"), CLASS_FILE_SUFFIX);
// pass non-empty include and exclude array.
filter = getFilterWithoutCatchAll(newMergedPatterns, newMergedPatterns,
EMPTY_ARRAY, FilterFileType.CLASS_FILES);
advancedPaths.testAdvancedPath(getAntFilter(newMergedPatterns,
newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES,
"ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString(
filter, "custom_newMergedPatterns_newMergedPatterns"), CLASS_FILE_SUFFIX);
}
public void testNonEmptyClassFileFiltersAnt() {
AdvancedPaths advancedPaths = new AdvancedPaths();
String newMergedPatterns[] = getMergedPatterns(CLASS_FILE_SUFFIX);
ResourceFilter filter = null;
// pass empty includeArray. Means catch all
filter = getFilterWithCatchAll(EMPTY_ARRAY, newMergedPatterns, EMPTY_ARRAY,
FilterFileType.CLASS_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(EMPTY_ARRAY,
newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES,
"ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter,
"custom_emptyArray_newMergedPatterns"), CLASS_FILE_SUFFIX);
// pass empty excludeArray. Means catch only the pattern
filter = getFilterWithCatchAll(newMergedPatterns, EMPTY_ARRAY, EMPTY_ARRAY,
FilterFileType.CLASS_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns,
EMPTY_ARRAY, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES,
"ant_newMergedPatterns_emptyArray"), new ResourceFilterString(filter,
"custom_newMergedPatterns_emptyArray"), CLASS_FILE_SUFFIX);
// pass non-empty include and exclude array.
filter = getFilterWithCatchAll(newMergedPatterns, newMergedPatterns,
EMPTY_ARRAY, FilterFileType.CLASS_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns,
newMergedPatterns, EMPTY_ARRAY, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES,
"ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString(
filter, "custom_newMergedPatterns_newMergedPatterns"), CLASS_FILE_SUFFIX);
}
private String[] getMergedPatterns(String suffix) {
String newMergedPatterns[] = new String[MERGED_PATTERNS.length];
for (int i = 0; i < MERGED_PATTERNS.length; i++) {
if (MERGED_PATTERNS[i].endsWith("*")) {
newMergedPatterns[i] = MERGED_PATTERNS[i];
} else {
newMergedPatterns[i] = MERGED_PATTERNS[i] + suffix;
}
}
return newMergedPatterns;
}
public void testNonEmptyClassFileSkipFiltersAnt() {
AdvancedPaths advancedPaths = new AdvancedPaths();
String newMergedPatterns[] = getMergedPatterns(CLASS_FILE_SUFFIX);
ResourceFilter filter = null;
// pass empty includeArray. Means catch all, skipping newMergedPatterns
filter = getFilterWithCatchAll(EMPTY_ARRAY, EMPTY_ARRAY, newMergedPatterns,
FilterFileType.CLASS_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(EMPTY_ARRAY,
EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES,
"ant_emptyArray_newMergedPatterns"), new ResourceFilterString(filter,
"custom_emptyArray_newMergedPatterns"), CLASS_FILE_SUFFIX);
// pass non-empty include and skip array.
filter = getFilterWithCatchAll(newMergedPatterns, EMPTY_ARRAY,
newMergedPatterns, FilterFileType.CLASS_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns,
EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES,
"ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString(
filter, "custom_newMergedPatterns_newMergedPatterns"), CLASS_FILE_SUFFIX);
// in a single filter, skip and exclude are equivalent
filter = getFilterWithCatchAll(newMergedPatterns, newMergedPatterns,
EMPTY_ARRAY, FilterFileType.CLASS_FILES);
advancedPaths.testAdvancedPathAnt(getAntFilter(newMergedPatterns,
EMPTY_ARRAY, newMergedPatterns, DEFAULT_EXCLUDES, FilterFileType.CLASS_FILES,
"ant_newMergedPatterns_newMergedPatterns"), new ResourceFilterString(
filter, "custom_newMergedPatterns_newMergedPatterns"), CLASS_FILE_SUFFIX);
}
private ResourceFilterString getAntFilter(String includes[],
String excludes[], String skips[], boolean defaultExcludes,
final FilterFileType filterFileType, String tag) {
final ZipScanner scanner = DefaultFilters.getScanner(includes, excludes,
skips, defaultExcludes, true);
return new ResourceFilterString(new ResourceFilter() {
@Override
public boolean allows(String path) {
return fileTypeMatches(filterFileType, path) && scanner.match(path);
}
}, tag != null ? tag : "includes: " + Arrays.toString(includes)
+ ", excludes: " + Arrays.toString(excludes));
}
private ResourceFilter getFilterWithCatchAll(String includesList[],
String excludesList[], String skipList[], FilterFileType filterFileType) {
switch (filterFileType) {
case JAVA_FILES:
return new DefaultFilters().customJavaFilter(includesList, excludesList,
skipList, true, true);
case CLASS_FILES:
return new DefaultFilters().customClassFilesFilter(includesList, excludesList,
skipList, true, true);
case RESOURCE_FILES:
default:
return new DefaultFilters().customResourceFilter(includesList,
excludesList, skipList, true, true);
}
}
// caseSensitive and excludeDefaults are set
private ResourceFilter getFilterWithoutCatchAll(String includesList[],
String excludesList[], String skipList[], FilterFileType filterFileType) {
return new DefaultFilters().customFilterWithCatchAll(includesList,
excludesList, skipList, true, null, filterFileType);
}
private boolean fileTypeMatches(FilterFileType filterFileType, String path) {
switch (filterFileType) {
case JAVA_FILES:
return path.endsWith(".java");
case CLASS_FILES:
return path.endsWith(".class");
}
return true;
}
}