List<Spec<FileTreeElement>> allExcludeSpecs = new ArrayList<>(2 + excludeSpecs.size());

        Set<String> excludes = patternSet.getExcludesView();
        if (!excludes.isEmpty()) {
            allExcludeSpecs.add(createSpec(excludes, false, patternSet.isCaseSensitive()));
        }

        allExcludeSpecs.add(getDefaultExcludeSpec(CaseSensitivity.forCaseSensitive(patternSet.isCaseSensitive())));

     * @param includes include patterns.
     * @param excludes exclude patterns.
     */
    void addResource(MavenProject project, String resourceDirectory, List<String> includes, List<String> excludes);

    /**
     * Add a test resource directory to the project.
     * @param project project reference.
     * @param resourceDirectory directory.
     * @param includes include patterns.

                excludes = ImmutableList.of();
            } else {
                attributes = baseConf.getAttributes();
                capabilities = baseConf.getCapabilities();
                dependencies = Cast.uncheckedCast(baseConf.getDependencies());
                artifacts = Cast.uncheckedCast(baseConf.getArtifacts());
                excludes = Cast.uncheckedCast(baseConf.getExcludes());

        if (excludes.isEmpty()) {
            // avoids creation of empty hashset
            return nothing;
        }
        if (excludes.size() == 1) {
            return forExclude(excludes.iterator().next());
        }
        Set<ExcludeSpec> result = new HashSet<>();
        for (ExcludeMetadata exclude : excludes) {
            result.add(forExclude(exclude));

    }

    public List<Exclude> getAllExcludes() {
        return excludes;
    }

    public List<ExcludeMetadata> getConfigurationExcludes(Collection<String> configurations) {
        if (excludes.isEmpty()) {
            return ImmutableList.of();
        }
        ImmutableList.Builder<ExcludeMetadata> rules = ImmutableList.builderWithExpectedSize(excludes.size());
        for (Exclude exclude : excludes) {

        immutableCopy.sources == sources
        immutableCopy.statusScheme == ["1", "2"]
    }

    def exclude(String group, String module, String... confs) {
        def exclude = new DefaultExclude(DefaultModuleIdentifier.newId(group, module), confs, "whatever")
        return exclude
    }

    def artifact(String name, String... confs) {

        'false'         | false
    }

    def "can check if excludes are defined"() {
        given:
        IvyDescriptorDependency ivyDescriptorDependency = new IvyDescriptorDependency(exclusions: givenExclusions)

        when:
        boolean excludes = ivyDescriptorDependency.hasExcludes()

        then:
        excludes == result

        where:
        givenExclusions                          | result

public class PatternSetAntBuilderDelegate implements AntBuilderAware {

    private final Set<String> includes;
    private final Set<String> excludes;
    private final boolean caseSensitive;

    public PatternSetAntBuilderDelegate(Set<String> includes, Set<String> excludes, boolean caseSensitive) {
        this.includes = includes;
        this.excludes = excludes;
        this.caseSensitive = caseSensitive;
    }

    def testDefaultValues() {
        expect:
        patternSet.includes.empty
        patternSet.excludes.empty
    }

    def testInclude() {
        expect:
        checkIncludesExcludes(patternSet, 'include', 'includes')
    }

    def testExclude() {
        expect:
        checkIncludesExcludes(patternSet, 'exclude', 'excludes')
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public SourceTask exclude(String... excludes) {
        patternSet.exclude(excludes);
        return this;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public SourceTask exclude(Iterable<String> excludes) {
        patternSet.exclude(excludes);
        return this;
    }

    /**
     * {@inheritDoc}
     */