// In a nutshell, this tests that we don't even try to load classes that are there, but that we shouldn't see.

        when:
        executer
            .withArgument("-Porg.gradle.java.installations.paths=${AvailableJavaHomes.getAvailableJvms().collect { it.javaHome.absolutePath }.join(",")}")
            .withToolchainDetectionEnabled()
        buildFile << """
            plugins {

        given:
        buildFile << publicationBuildWithoutCredentials(version, group, ivyHttpRepo.uri)

        if (!extraChecksums) {
            executer.withArgument("-Dorg.gradle.internal.publish.checksums.insecure=true")
            module.withoutExtraChecksums()
        }

        and:
        module.jar.expectPut()
        module.jar.sha1.expectPut()

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

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

            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: