}
        executer.withArguments('--max-workers', '4')
        succeeds("resolve")

        where:
        expression                                                       | _
        "configurations.compile"                                         | _

        return delegate.getArguments()
    }

    @Override
    SmokeTestGradleRunner withArguments(List<String> arguments) {
        delegate.withArguments(arguments)
        return this
    }

    @Override
    SmokeTestGradleRunner withArguments(String... arguments) {
        delegate.withArguments(arguments)
        return this
    }

    @Override

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

        artifactOps.size() == 1
        artifactOps[0].details.artifactIdentifier == 'impl-1.3.jar (org.utils:impl:1.3)'

        when:
        executer.withArguments("--refresh-dependencies")
        run "help"

        then:
        def metaDataOps2 = buildOperations.all(ExternalResourceReadMetadataBuildOperationType)
        metaDataOps2.size() == 2

    }

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

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

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

                void close() { }
            }

            when:
            def result = GradleRunner.create()
                .withProjectDir(testProjectDir)
                .withArguments('$DUMMY_TASK_NAME')
                .withDebug($debug)
                .withStandardInput(stdin)
                .forwardStdOutput(stdout)
                .build()

            then: