}

    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:

        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']
    }

    }

    public List<String> getExcludes() {
        return excludes;
    }

    public void setExcludes(List<String> excludes) {
        this.excludes = excludes;
    }

    public File getDir() {
        return dir;
    }

    public void setDir(File dir) {
        this.dir = dir;
    }

    public String getName() {
        return name;
    }

        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())));

        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

        this(selector, excludes, constraint, endorsing, reason, force, artifact == null ? ImmutableList.of() : ImmutableList.of(artifact));
    }

    private GradleDependencyMetadata(ModuleComponentSelector selector, List<ExcludeMetadata> excludes, boolean constraint, boolean endorsing, @Nullable String reason, boolean force, List<IvyArtifactName> artifacts) {
        this.selector = selector;
        this.excludes = excludes;
        this.reason = reason;

        List<ExcludeMetadata> excludes,
        boolean force, boolean changing, boolean transitive,
        boolean constraint, boolean endorsing, boolean fromLock,
        @Nullable String reason
    ) {
        this.selector = selector;
        this.dependencyConfiguration = dependencyConfiguration;
        this.artifactNames = asImmutable(artifactNames);
        this.excludes = excludes;
        this.force = force;

            ImmutableSet<LocalFileDependencyMetadata> files,
            ImmutableList<ExcludeMetadata> excludes
        ) {
            this.dependencies = dependencies;
            this.files = files;
            this.excludes = excludes;
        }
    }

    public void updateCurrentDefaultExcludes(Set<String> excludes) {
        for (String oldExclude : DirectoryScanner.getDefaultExcludes()) {
            if (!excludes.contains(oldExclude)) {
                DirectoryScanner.removeDefaultExclude(oldExclude);
            }
        }
        for (String exclude : excludes) {
            DirectoryScanner.addDefaultExclude(exclude);
        }