.expectResult(MODULE_B),
                scenario("Excluded project")
                        .inactiveRequiredProjects(MODULE_B)
                        .expectResult(PARENT_MODULE, MODULE_C, MODULE_C_1, MODULE_A, MODULE_C_2, INDEPENDENT_MODULE),
                scenario("Excluded optional project")
                        .inactiveOptionalProjects(MODULE_B)

        // experimentation shows the following, excluded modules are
        // inherited from parent POMs if either of the following is true:
        // the <exclusions> element is missing or the <exclusions> element
        // is present, but empty.
        List<ExcludeMetadata> excludes = new ArrayList<>();
        List<ModuleIdentifier> excluded = dep.getExcludedModules();
        if (excluded.isEmpty()) {

        succeeds 'copyFiles'

        then: // Currently fails: excluded dependency is copied as part of configuration
        file('libs').assertHasDescendants('direct-dep-1.0.jar')
    }

    // This emulates the behaviour of the Spring Dependency Management plugin when applying dependency excludes from a BOM
    def "can use beforeResolve hook to modify dependency excludes for configuration hierarchy"() {

        [included1, included2, excluded1, excluded2, ignored1].each { File file ->
            file.parentFile.mkdirs()
            file.text = 'some text'
        }

        fileTree.exclude '**/excluded*'

        FileTree filtered = fileTree.matching {
            include('*/*included*')
            exclude('**/not*')
        }

        expect:
        filtered.files == [included1, included2] as Set

			expr, f := tm["expr"]
			if !f {
				continue
			}
			queries = append(queries, expr.(string))
		}
	}
	return queries, nil
}

func includeQuery(query string, excluded []string) bool {
	for _, f := range excluded {
		if strings.Contains(query, f) {
			return false
		}
	}
	return true

.Excludes only apply if all dependency declarations agree on an exclude
====
include::sample[dir="snippets/dependencyManagement/managingTransitiveDependencies-excludeForDependency/kotlin",files="build.gradle.kts[tags=exclude-transitive-dependencies-2]"]

	var (
		added    = make(map[module.Version]bool)
		rdeps    = make(map[module.Version][]module.Version)
		excluded = make(map[module.Version]bool)
	)
	var exclude func(module.Version)
	exclude = func(m module.Version) {
		if excluded[m] {
			return
		}
		excluded[m] = true
		for _, p := range rdeps[m] {
			exclude(p)
		}
	}
	var add func(module.Version)
	add = func(m module.Version) {
		if added[m] {

				t.Skipf("skipping: GOROOT/test not present")
			}
		}
		t.Fatal(err)
	}

	excluded := make(map[string]bool)
	for _, filename := range ignore {
		excluded[filename] = true
	}

	for _, f := range files {
		// filter directory contents
		if f.IsDir() || !strings.HasSuffix(f.Name(), ".go") || excluded[f.Name()] {
			continue
		}

		// get per-file instructions
		expectErrors := false

labels.createdTime=Created Time
labels.depth=Depth
labels.excludedPaths=Excluded Paths For Crawling
labels.excludedUrls=Excluded URLs For Crawling
labels.excludedDocPaths=Excluded Paths For Indexing
labels.excludedDocUrls=Excluded URLs For Indexing
labels.hostname=Hostname
labels.id=ID
labels.includedPaths=Included Paths For Crawling
labels.includedUrls=Included URLs For Crawling
labels.includedDocPaths=Included Paths For Indexing

                    if (logger.isInfoEnabled()) {
                        logger.info("Included URL: {}", urlValue);
                    }
                } else if (line.startsWith(DISABLE_URL_ENCODE)) {
                    urlEncodeDisabled.set(true);
                }
            }));

            // set excluded urls
            urlEncodeDisabled.set(false);