}
            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
        }
    }

    fun run(vararg args: String) = GradleRunner.create()
        .withProjectDir(projectDir)
        .withTestKitDir(projectDir.resolve("test-kit"))
        .withPluginClasspath()
        .forwardOutput()
        .withArguments(*args)


    protected
    fun assertChangesProperlyOrdered() {
        val result = run(":verifyAcceptedApiChangesOrdering").build()

            configurations.compileClasspath.files.collect { it.file }
        }
    }
}
"""
        executer.requireOwnGradleUserHomeDir().requireIsolatedDaemons()

        expect:
        def build = executer.withArguments('query:query', ':resolve:resolve', '--parallel').start()

        handler.waitForAllPendingCalls()
        handler.release('/sync')
        Thread.sleep(1000)
        handler.release(module.pom.path)

        blockingServer.expectConcurrent(2, "a", "b", "c")

        run ":a:ping", ":b:ping", ":c:ping"
    }

    void withParallelThreads(int threadCount) {
        executer.beforeExecute {
            withArguments("--max-workers=$threadCount", "--parallel")
        }
    }

        val inputBuildDir = setupRunBinaryCompatibility(v1, v2)

        val runner = GradleRunner.create()
            .withProjectDir(inputBuildDir)
            .withPluginClasspath()
            .withArguments(":binary-compatibility:checkBinaryCompatibility", "-s")

        val (buildResult, failure) = try {
            runner.build()!! to null
        } catch (ex: UnexpectedBuildFailure) {

                        }
                    '''

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

                    then:
                    noExceptionThrown()
                }
            }
        """

    }

    private void runCacheableBuild(listener, String task = "cacheable") {
        withConnection {
            ProjectConnection connection ->
                connection.newBuild().withArguments("--build-cache").forTasks(task).addProgressListener(listener, EnumSet.of(OperationType.GENERIC, OperationType.TASK)).run()
        }
    }

    int maybeIncludeLocalBuildOperations(int expectedNumber) {

        requestedTasks << [['a'], ['a', 'b'], ['d', 'a']]
    }

    void 'finalizer tasks work with task excluding (#excludedTask)'() {
        setupProject()
        executer.beforeExecute {
            withArguments('-x', excludedTask)
        }

        tasksNotInGraph.each { task ->
            buildFile << """
                gradle.taskGraph.whenReady { graph ->
                    assert !graph.hasTask('$task')

        initScript << 'throw new RuntimeException("broken")'

        when:
        withConnection {
            it.action(new ActionQueriesModelThatRequiresOnlySettingsEvaluation())
                .withArguments("-I${initScript}")
                .run()
        }

        then:
        BuildActionFailureException e = thrown()
        e.message.startsWith('The supplied build action failed with an exception.')

                    createBuildFile("plugins { id 'org.example.test' }");

                    BuildResult result = GradleRunner.create()
                        .withProjectDir(testProjectDir)
                        .withArguments("customTask")
                        .withPluginClasspath()
                        .build();

                    assertTrue(result.getOutput().contains("Hello from plugin"));