"group": "org.springframework",
                    "module": "spring-core",
                    "version": {
                        "prefers": "2.5.6"
                    },
                    "excludes": [
                        {
                            "group": "commons-logging",
                            "module": "commons-logging"
                        }
                    ]
                },

        strictlyEquals(new PatternSet(includes: ['i']), new PatternSet(includes: ['i']))
        strictlyEquals(new PatternSet(excludes: ['e']), new PatternSet(excludes: ['e']))
        strictlyEquals(new PatternSet(includes: ['i'], excludes: ['e']), new PatternSet(includes: ['i'], excludes: ['e']))

        new PatternSet() != new PatternSet(caseSensitive: false)
        new PatternSet() != new PatternSet(includes: ['i'])

        return this;
    }

    @Override
    public PatternSet exclude(String... excludes) {
        Collections.addAll(getExcludes(), excludes);
        return this;
    }

    @Override
    public PatternSet exclude(Iterable excludes) {
        for (Object exclude : excludes) {
            getExcludes().add(PARSER.parseNotation(exclude));
        }
        return this;
    }

    @Override

     * @return this
     * @see PatternFilterable Pattern Format
     */
    PatternFilterable exclude(Iterable<String> excludes);

    /**
     * Adds an exclude spec. This method may be called multiple times to append new specs.
     *
     * If excludes are not provided, then no files will be excluded. If excludes are provided, then files must not match

    }

    MavenDependencyDescriptor createWithExcludes(ModuleComponentSelector selector, List<Exclude> excludes) {
        return mavenDependencyMetadata(MavenScope.Compile, selector, excludes)
    }

    def "excludes nothing when no exclude rules provided"() {
        def dep = createWithExcludes(requested, [])

        expect:

        _ * java.srcDirs >> [javaTree.dir]
        _ * java.excludes >> javaTree.patterns.excludes
        _ * java.includes >> javaTree.patterns.includes
        _ * java.srcDirTrees >> [javaTree]
        _ * resources.srcDirs >> [resourcesTree.dir]
        _ * resources.excludes >> resourcesTree.patterns.excludes
        _ * resources.includes >> resourcesTree.patterns.includes
        _ * resources.srcDirTrees >> [resourcesTree]

        then:
        project.sourceDirectories.size() == 1
        project.sourceDirectories[0].excludes == excludes
        project.sourceDirectories[0].includes == includes

        where:
        excludes     | includes
        ['e']        | []
        []           | ['i']
        ['e']        | ['i']
        ['e1', 'e2'] | ['i1', 'i2']
    }

			</includes>
			<outputDirectory>fess-${project.version}/lib/classes</outputDirectory>
		</fileSet>
		<!-- logs -->
		<fileSet>
			<directory>src/main/assemblies/files</directory>
			<outputDirectory>fess-${project.version}/logs</outputDirectory>
			<excludes>
				<exclude>*</exclude>
			</excludes>
			<filtered>false</filtered>
		</fileSet>
		<!-- temp -->
		<fileSet>
			<directory>src/main/assemblies/files</directory>

/**
 */
public class ExclusionSetFilter implements ArtifactFilter {
    private Set<String> excludes;

    public ExclusionSetFilter(String[] excludes) {
        this.excludes = new LinkedHashSet<>(Arrays.asList(excludes));
    }

    public ExclusionSetFilter(Set<String> excludes) {
        this.excludes = excludes;
    }

    public boolean include(Artifact artifact) {
        String id = artifact.getArtifactId();

            return false;
        }
        if (scope != that.scope) {
            return false;
        }
        if (includes != null ? !includes.equals(that.includes) : that.includes != null) {
            return false;
        }
        if (excludes != null ? !excludes.equals(that.excludes) : that.excludes != null) {
            return false;
        }
        return limits != null ? limits.equals(that.limits) : that.limits == null;