sh := b.Shell(a)

	// Build the metafilecollection object.
	var collection coverage.MetaFileCollection
	for i := range a.Deps {
		dep := a.Deps[i]
		if dep.Mode != "build" {
			panic("unexpected mode " + dep.Mode)
		}
		metaFilesFile := dep.Objdir + covcmd.MetaFileForPackage(dep.Package.ImportPath)
		// Check to make sure the meta-data file fragment exists
		//  and has content (may be empty if package has no functions).

        given: "a project used as a dependency"
        file('dep/build.gradle') << """
            plugins {
                id 'java-library'
            }

            group = "org.example.gradle"
        """
        file('dep/src/main/java/org/example/dep/Dep.java') << """
            package org.example.dep;
            public class Dep {}
        """

}
// end::custom-class-runtime-api[]

// tag::inferred-task-dep-via-outputs[]
tasks.register<Zip>("packageFiles") {
    from(processTemplates.map { it.outputDir })
}
// end::inferred-task-dep-via-outputs[]

// tag::inferred-task-dep-via-task[]
tasks.register<Zip>("packageFiles2") {
    from(processTemplates)
}
// end::inferred-task-dep-via-task[]


// tag::adhoc-destroyable-task[]

            gradle.projectsEvaluated {
                allprojects {
                    configurations.all {
                        dependencies.all { dep ->
                            if (!(dep instanceof ProjectDependency) && dep.hasProperty('transitive')) {
                                dep.transitive = false
                            }
                        }
                    }
                }
            }
        """

            getName() >> "dep-name"
            getClassifier() >> "artifact-classifier"
            getType() >> "artifact-type"
        }
        def excludeRule = Mock(ExcludeRule)

        when:
        moduleDependency.group >> "dep-group"
        moduleDependency.name >> "dep-name"
        moduleDependency.version >> "dep-version"
        moduleDependency.artifacts >> [artifact]

    //
    void handleReactorDependencies(TransformerContext context, Model model) {
        for (Dependency dep : model.getDependencies()) {
            if (dep.getVersion() == null) {
                Model depModel =
                        context.getRawModel(model.getDelegate().getPomFile(), dep.getGroupId(), dep.getArtifactId());
                if (depModel != null) {
                    String v = depModel.getVersion();

        Task dep = task("dep", type: Async)
        Task a = task("a", type: Async, finalizedBy: [finalizer], dependsOn: [dep])
        Task b = task("b", type: Async, finalizedBy: [finalizer])

        when:
        addToGraphAndPopulate(a, b)

        then:
        executionPlan.tasks as List == [dep, a, b, finalizerDep, finalizer]
        assertTasksReady(dep, b)
        assertTaskReady(a)

        assertResolveOutput("""
            files: [java.jar, file-dep.jar, other-java.jar, implementation-1.0.jar, runtime-only-1.0.jar]
            java.jar (project :java) {artifactType=jar, org.gradle.category=library, org.gradle.dependency.bundling=external, ${defaultTargetPlatform()}, org.gradle.libraryelements=jar, org.gradle.usage=java-runtime}
            file-dep.jar {artifactType=jar}

class MavenGradleMetadataRedirectionIntegrationTest extends AbstractHttpDependencyResolutionTest {
    MavenHttpModule mainModule
    MavenHttpModule dep
    ResolveTestFixture resolve

    def setup() {
        mainModule = mavenHttpRepo.module("org", "main", "1.0").withModuleMetadata()
        dep = mavenHttpRepo.module("org", "foo", "1.9").publish()
        settingsFile << "rootProject.name = 'test'"
        buildFile << """

// tag::configuration-with-dependencies[]
configurations {
    implementation {
        withDependencies { DependencySet dependencies ->
            ExternalModuleDependency dep = dependencies.find { it.name == 'to-modify' } as ExternalModuleDependency
            dep.version {
                strictly "1.2"
            }
        }
    }
}