eclipseChild2.projectDependencies.collect { it.path } == []
        // jars that replace the project dependencies + the transitive dependency from :a
        eclipseChild2.classpath.collect { it.file.name } == ['child1.jar', 'child1-tests.jar', 'test-1.0.jar']
    }

    def "custom project dependencies are replaced when project is closed"() {
        setup:

            }
        """
    }

    @NoDebug
    def "fails appropriately if runner is loaded from a JAR that is not part of the distribution and no explicit version set"() {
        when:
        executer.withStackTraceChecksDisabled()
        def jarsDir = file('jars').createDir()

        new File(distribution.gradleHomeDir, 'lib').eachFileRecurse(FileType.FILES) { f ->

import org.gradle.work.DisableCachingByDefault;

import java.io.File;

/**
 * Artifact transform that instruments project based artifacts with Gradle instrumentation.
 */
@DisableCachingByDefault(because = "Instrumented jars are too big to cache.")
public abstract class ProjectDependencyInstrumentingArtifactTransform extends BaseInstrumentingArtifactTransform {

    @Override
    @Classpath
    @InputArtifact

    abstract Provider<FileSystemLocation> getArtifact()

    @Override
    void transform(TransformOutputs outputs) {
        File baselineJarsDirectory = artifact.get().asFile
        if (baselineJarsDirectory.name == 'gradle-jars') {
            baselineJarsDirectory.listFiles().each {
                outputs.file(it)
            }
        }
    }

It is roughly structured as follows:

[listing]
----
├── caches                  // <1>
│   ├── 4.8                     // <2>
│   ├── 4.9                     // <2>
│   ├── ⋮
│   ├── jars-3                  // <3>
│   └── modules-2               // <3>
├── daemon // <4>
│   ├── ⋮
│   ├── 4.8
│   └── 4.9
├── init.d                  // <5>
│   └── my-setup.gradle
├── jdks                    // <6>

        """
        when:
        succeeds("myTaskMyPlugin")
        then:
        outputContains("From MyPlugin")
    }

    def "build uses jars from multi-project buildSrc"() {
        writeBuildSrcPlugin("buildSrc", "MyPlugin")
        writeBuildSrcPlugin("buildSrc/subproject", "MyPluginSub")
        file("buildSrc/build.gradle") << """
            allprojects {
                apply plugin: 'groovy'

/**
 * Artifact transform that instruments external artifacts with Gradle instrumentation.
 */
@DisableCachingByDefault(because = "Instrumented jars are too big to cache")
public abstract class ExternalDependencyInstrumentingArtifactTransform extends BaseInstrumentingArtifactTransform {

    @Override
    public void transform(TransformOutputs outputs) {

        apiClasspath.removeAll(groovyImpl);
        apiClasspath.removeAll(installationBeacon);
        // Remove Kotlin DSL and Kotlin jars
        removeKotlin(apiClasspath);

        ImmutableSet.Builder<File> builder = ImmutableSet.builder();
        builder.add(relocatedDepsJar(apiClasspath, RuntimeShadedJarType.API));
        builder.addAll(groovyImpl);

    }

    private ClassPath initGradleApi() {
        // This gradleApi() method creates a Gradle API classpath based on real jars for embedded test running.
        // Currently, this leaks additional dependencies that may cause unexpected issues.
        // This method is involved in generating the gradleApi() Jar which is used in a real Gradle run.
        // See: `org.gradle.api.internal.notations.DependencyClassPathNotationConverter`

        def headingIndex = lines.indexOf(heading)
        def classpathSize = Integer.parseInt(lines[headingIndex + 1])
        // The gradle-launcher.jar is mandatory.
        // The gradle-instrumentation-agent.jar may not be available if the build runs in no-daemon mode.
        // There should not be more jars on the system classpath.
        classpathSize == 1 || classpathSize == 2
        def maybeHasAgent = classpathSize > 1