then:
        def previousJavaHome = getPrintedJavaHome(result)
        previousJavaHome.startsWith(jdkDir)

        and:
        jdkRepository.expectHead()

        when:

            """
        }
    }

    def "EclipseProject model has dependencies substituted in composite"() {
        when:
        def eclipseProject = withConnection {
            model(EclipseProject).withArguments('--include-build', 'buildB').get()
        }

        then:
        assert eclipseProject.classpath.empty
        assert eclipseProject.projectDependencies.size() == 1

        """

        then:
        def handle1 = executer.withArguments(':a:build', '-i').start()
        poll(120) {
            assert handle1.standardOutput.contains('waiting for file...')
        }
        //first build is waiting for file, so the lock should be releasable now (for example: the task history lock)

        and:
        def handle2 = executer.withArguments('b:build', '-is').start()
        handle2.waitForFinish()

        given:
        prepareWrapper()
        def gradleUserHome = testDirectory.file('some-custom-user-home')

        when:
        def executer = wrapperExecuter.withGradleUserHomeDir(null)
        executer.withArguments("-Dgradle.user.home=$gradleUserHome.absolutePath")
        executer.run()

        then:
        installationIn gradleUserHome
    }

    @Issue('https://issues.gradle.org/browse/GRADLE-2802')

        javaProject(file("a"))
        javaProject(file("b"), """
            dependencies {
                implementation(project(':a'))
            }
        """)

        when:
        executer.withArguments(ENABLE_CLI)
        runBuildAction(new FetchCustomModelForEachProjectInParallel())

        then:
        fixture.assertStateStored {
            projectsConfigured(":buildSrc", ":", ":a", ":b")

            if (option != null) {
                // important to set arguments, and not JVM arguments, as it's what is used by Android Studio to set the option
                it.withArguments("-Dorg.gradle.internal.GradleProjectBuilderOptions=$option")
            }
        }

        then:
        result.assertOutputContains("realizing non-lazy task")
        if (realizesLazy) {

            buildFile << """
                apply plugin: 'java'
            """
        }

        when:
        withConnection {
            def executer = action(new FetchIdeaProject())
            executer.withArguments("--warning-mode", "all")
            collectOutputs(executer)
            executer.run()
        }

        then:
        !stdout.toString().contains("was resolved without accessing the project in a safe manner")

    }

    void runPrevious() {
        previousExecuter.withArguments(argFor(previous.version), 'help').run()
    }

    void runCurrent() {
        currentExecuter.withArguments(argFor(current.version), 'help').run()
    }

    private static String argFor(GradleVersion version) {
        version.baseVersion < GradleVersion.version("6.6")

        and:
        file("init.gradle") << """
allprojects {
    task worker
}
rootProject {
    task root(dependsOn: allprojects*.worker)
}
        """

        when:
        executer.withArguments("-I", "init.gradle")
        run "root"

        then:
        result.assertTasksExecuted(':worker', ':a:worker', ':b:worker', ':root')
    }

    void startBuild(String javaHome = null, String buildEncoding = null) {
        run {
            executer.withTasks("watch")
            executer.withDaemonIdleTimeoutSecs(daemonIdleTimeout)
            executer.withArguments(
                "-Dorg.gradle.daemon.healthcheckinterval=${periodicCheckInterval * 1000}",
                "--debug" // Need debug logging so we can extract the `DefaultDaemonContext`
            )
            if (javaHome) {