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

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

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

    }

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

        runner.withJvmArguments("-javaagent:${agentJar}")
        if (!GradleContextualExecuter.embedded) {
            runner.withGradleInstallation(buildContext.gradleHomeDir)
        }
        runner.withArguments("--configuration-cache")
        runner.forwardOutput()
        runner.withProjectDir(testDirectory)
        runner.withPluginClasspath([new File("some-dir")])
        def result = runner.buildAndFail()

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

        usingToolingConnection(workingDir) { connection ->
            connection.newBuild()
                .withArguments(args)
                .addJvmArguments(jvmArgs)
                .setStandardOutput(new TeeOutputStream(output, System.out))
                .setStandardError(new TeeOutputStream(error, System.err))
                .run()

        then:
        outputContains("foo")
        configurationCache.assertStateLoaded()

        when:
        def commandLineArgs = commandLine.split("\\s+")
        executer.withArguments(commandLineArgs)
        configurationCacheRun "myTask"

        then:
        outputContains("bar")

            }
            runner.withTestKitDir(testKitDir)
            runner.withProjectDir(workingDir)
            def args = allArgs
            args.remove("--no-daemon")
            runner.withArguments(args)
            runner.withPluginClasspath(pluginClasspath)
            runner.withEnvironment(environmentVars)
            runner.forwardOutput()
            runner
        }
    }

                        }
                    '''

                    when:
                    def result = GradleRunner.create()
                        .withProjectDir(testProjectDir)
                        .withArguments('helloWorld')
                        .withDebug($debug)
                        .build()

                    then:
                    noExceptionThrown()
                }
            }
        """