then:
        included file('ac')
        included file('13')
        excluded file('a')
        excluded file('1')
        excluded file('c')
        excluded file('3')
        excluded file('acb')
        excluded file('acd')
        excluded file('132')
        excluded file('132')

        when:
        patternSet = new PatternSet().copyFrom(patternSet)
        then:
        included file('ac')

        where:
        condition             | bExcludes       | cExcludes       | expectResolved
        'excluded on b'       | [[module: 'd']] | []              | ['a', 'b', 'c']
        'excluded on c'       | []              | [[module: 'd']] | ['a', 'b', 'c']
        'excluded on both'    | [[module: 'd']] | [[module: 'd']] | ['a', 'b', 'c']
        'excluded on neither' | []              | []              | ['a', 'b', 'c', 'd']

        "name exclude"             | [name: "dep_module-*"]                     | ['mod_one-1.1.jar', 'mod_one-1.1.war', 'mod_one-2.1.jar', 'mod_two-2.2.jar']
    }

    def "transitive dependencies are only excluded if excluded from each dependency declaration"() {
//        c -> d,e
//        a -> c (excludes 'd')
//        b -> c (excludes 'd', 'e')
        given:
        ivyRepo.module("d").publish()
        ivyRepo.module("e").publish()

    }

    /**
     * Module exclude of transitive dependency with a single artifact does not exclude its transitive module by using a combination of artifact exclude rules.
     *
     * Dependency graph:
     * a -> b, c
     * b -> d -> f
     * c -> e
     */
    def "module exclude for transitive dependency having single artifact with #name does not exclude its transitive module"() {
        given:

func (c Clusters) Primaries(excluded ...Cluster) Clusters {
	return c.filterClusters(func(cc Cluster) bool {
		return cc.IsPrimary()
	}, exclude(excluded...))
}

// Exclude returns all clusters not given as input.
func (c Clusters) Exclude(excluded ...Cluster) Clusters {
	return c.filterClusters(func(cc Cluster) bool {
		return true
	}, exclude(excluded...))
}

     * Sets list of elements that should be excluded from check.
     *
     * @param excludes Exclusions
     */
    void setExcludes(List<String> excludes);

    /**
     * List of elements that should be excluded from check. Names can use wildcards (* and ?).
     * If left empty, no elements will be excluded. Defaults to an empty list.
     */
    @Input
    List<String> getExcludes();

    /**

    maven { url '${repo.uri}' }
}
configurations {
    excluded {
        exclude module: 'direct'
        exclude module: 'transitive'
    }
    extendedExcluded.extendsFrom excluded
}
dependencies {
    excluded 'org.gradle.test:external:1.0'
    excluded 'org.gradle.test:direct:1.0'
}

task test {
    def excluded = configurations.excluded
    def extendedExcluded = configurations.extendedExcluded

            nestedVisitor.visitDir(included)
            nestedVisitor.visitDir(excluded)
        }
        1 * visitor.visitDir(included)
        0 * _
    }

    def "ignores file that is not included"() {
        def spec = Mock(Spec)
        def included = Stub(FileVisitDetails)
        def excluded = Stub(FileVisitDetails)
        def visitor = Mock(FileVisitor)

        when:

			if f.String() != tc.expected {
				t.Errorf("expected %q, got %q", tc.expected, f.String())
			}
			if tc.included >= 0 && !pr.Contains(tc.included) {
				t.Errorf("expected %q to include %d", f.String(), tc.included)
			}
			if tc.excluded >= 0 && pr.Contains(tc.excluded) {
				t.Errorf("expected %q to exclude %d", f.String(), tc.excluded)
			}
		}
	}

}

// Included returns a copy of the list of resources that the expression-based admission controllers
// should intercept.
func Included() []schema.GroupResource {
	return slices.Clone(included)
}

// Excluded returns a copy of the list of resources that the expression-based admission controllers
// should ignore.
func Excluded() []schema.GroupResource {
	return slices.Clone(excluded)