def build1 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        def build2 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        def build3 = executer.withStackTraceChecksDisabled().withArguments("-d").withTasks("lock").start()
        poll(120) {
            assert requestReceived

        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        def models = runPhasedBuildAction(new FetchPartialCustomModelForEachProject(), new FetchCustomModelForEachProject())

        then:
        def messages = models.left
        messages.size() == 2

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

        and:
        jdkRepository.expectHead()

        when:

        given:
        server.expect("configure-root")
        server.expectConcurrent("model-root", "configure-a", "configure-b")
        server.expectConcurrent("model-a", "model-b")

        when:
        executer.withArguments(ENABLE_CLI)
        def model = runBuildAction(new FetchCustomModelForEachProjectInParallel())

        then:
        model.size() == 3
        model[0].message == "It works from project :"

            """
        }
    }

    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

            def args = executer.allArgs
            args.remove("--no-daemon")

            model = connection.model(type)
                .forTasks(tasks)
                .withArguments(args)
                .setStandardOutput(new TeeOutputStream(output, System.out))
                .setStandardError(new TeeOutputStream(error, System.err))
                .get()

        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        when:
        executer.withArguments("-D$NATIVE_SERVICES_OPTION=$firstRunNativeServicesOption")
        succeeds()

        then:
        daemons.daemon.becomesIdle()

        when:
        executer.withArguments("-D$NATIVE_SERVICES_OPTION=$secondRunNativeServicesOption")
        succeeds()

        then:

        """

        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")