*/
    GradleExecuter withArguments(String... args);

    /**
     * Sets the additional command-line arguments to use when executing the build. Defaults to an empty list.
     */
    GradleExecuter withArguments(List<String> args);

    /**
     * Adds an additional command-line argument to use when executing the build.
     */
    GradleExecuter withArgument(String arg);

    /**

    MavenHttpModule moduleA

    def setup() {
        moduleA = publishMavenModule(mavenHttpRepo, 'a')
        downloadedLibsDir = file('build/libs')
        executer.beforeExecute {
            executer.withArgument("-D${SOCKET_TIMEOUT_SYSTEM_PROPERTY}=1000")
        }
    }

    void blockingForProtocol(String protocol, HttpResource... resources) {
        if (protocol == 'http') {

                dependencies {
                    implementation project(':b')
                    implementation project(':c')
                }
            }
"""

        when:
        executer.withArgument("--continue")
        fails(":a:resolve")

        then:
        result.assertTasksExecuted(":a:tool", ":b:producer", ":c:producer")
        outputDoesNotContain("processing")

              outputs.files "build/marker"
              doLast {
                println "value: " + inputFile.text
              }
            }
        """

        then:
        executer.withArgument("-q")
        succeeds("myTask")
        output.contains "value: original"

        when:
        waitBeforeModification(markerFile)
        markerFile.text = "changed"

        then:

            }
        """

        file("src/main/java/Foo.java") << "public class Foo {}"

        when:
        def result = executer
            .withTasks("compileJava")
            .withArgument("--$logLevel")
            .requireOwnGradleUserHomeDir()
            .withToolchainDownloadEnabled()
            .withStackTraceChecksDisabled()
            .run()

        and:
        jdkRepository.stop()

    }

    @Override
    public GradleExecuter withArguments(String... args) {
        return withArguments(Arrays.asList(args));
    }

    @Override
    public GradleExecuter withArguments(List<String> args) {
        this.args.clear();
        this.args.addAll(args);
        return this;
    }

    @Override
    public GradleExecuter withArgument(String arg) {
        this.args.add(arg);

    def "is incremental"() {
        given:
        goodCode()

        expect:
        succeeds("checkstyleMain")
        executedAndNotSkipped(":checkstyleMain")

        executer.withArgument("-i")
        succeeds("checkstyleMain")
        skipped(":checkstyleMain")

        when:
        file("build/reports/checkstyle/main.xml").delete()
        file("build/reports/checkstyle/main.html").delete()

        // Disable daemon, so that the second run executes with the file cache
        // and therefore make sure that we read the "missing" status from disk
        executer.withArgument('--no-daemon')

        repository {
            path 'xml -> core'
            path 'json -> core'
            path 'xml:1.1 -> core:1.1'
            path 'json:1.1 -> core:1.1'
        }

            configurations {
                foo
            }

            dependencies {
                foo "org.test:module1:1.0"
            }
        """

        expect:
        executer.withArgument("--parallel")

        def original = file('build/original/original.txt')
        original.text = "Original"
        def backup = file('backup/original.txt')

        and:
        executer.beforeExecute {
            withArgument("--max-workers=1")
        }

        when:
        succeeds "backup"
        then:
        executedAndNotSkipped(':backup')

        when:
        succeeds "restore"

        then: