repo.expectCloneSomething()
        succeeds('resolve')

        when:
        executer.withArgument('--offline')
        succeeds('resolve')

        then:
        noExceptionThrown()
    }

    def "fails when previous checkout is not available"() {
        when:
        executer.withArgument('--offline')
        fails('resolve')

        then:

allprojects {
    apply plugin: 'java-library'

    task copyLibs(type: Copy) {
        from configurations.runtimeClasspath
        into 'deps'
    }

    compileJava.dependsOn copyLibs
}
"""
        executer.withArgument('--info')
    }

    def "project dependency c->[a,b]"() {
        projectDependency from: 'c', to: ['a', 'b']
        when:
        run ':c:build'

        then:
        jarsBuilt 'a', 'b', 'c'

            print 'update remote script'
        """

        and:
        executer.withArgument("--offline")
        configurationCacheRun 'ok'

        then:
        configurationCache.assertStateStored()

        and:
        outputDoesNotContain 'update remote script'

        when:
        executer.withArgument("--offline")
        configurationCacheRun 'ok'

        then:

        when:
        GradleExecuter executor = prepareWrapperExecuter(previous, current).withJavaHome(jdk.javaHome)

        then:
        def result = executor.usingExecutable('gradlew').withArgument('help').runWithFailure()
        result.hasErrorOutput("Gradle ${GradleVersion.current().version} requires Java 1.8 or later to run. You are currently using Java ${jdk.javaVersion}.")

        where:

        when:
        executer.withArgument("--foreground")
        def allArgs = executer.getAllArgs()

        then:
        !allArgs.contains("--daemon")
        !allArgs.contains("--no-daemon")
    }

    def "when argument is added explicitly, no --daemon argument is added and requireDaemon gets overridden"() {
        when:
        executer.withArgument(argument)
        executer.requireDaemon()

            args.each {
                executer.withArgument(it)
            }
        } else {
            executer.withBuildJvmOpts(args)
        }
    }

    void configureServerAndClientCerts(GradleExecuter executer) {
        def args = getServerAndClientCertArgs()
        if (GradleContextualExecuter.embedded) {
            args.each {
                executer.withArgument(it)
            }
        } else {

    def setup() {
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
    }

    void stopDaemonsNow() {
        result = executer.withArguments("--stop", "--info").run()
    }

    void buildSucceeds() {
        result = executer.withArguments("--info").run()
    }

    DaemonsFixture getDaemons() {
        new DaemonLogsAnalyzer(executer.daemonBaseDir)
    }

        setupSubproject("subproject2", "Bar", otherJdkMetadata)

        when:
        result = executer
                .withTasks("compileJava")
                .withArgument("--info")
                .run()


        then:
        result.plainTextOutput.matches("(?s).*Compiling with toolchain.*${DefaultJdkCacheDirectory.getInstallFolderName(jdkMetadata)}.*")

@SelfType(AbstractIntegrationSpec)
trait IsolatedProjectsExecuterFixture {

    private static final String ENABLE_CLI = "-D${PROPERTY_NAME}=true"

    void withIsolatedProjects() {
        executer.withArgument(ENABLE_CLI)
    }

        run("a")

        then:
        result.assertTaskSkipped(":a")

        when:
        executer.withArgument("-Dname=b")
        run("a")

        then:
        result.assertTaskNotSkipped(":a")
        file("out.txt").text == "b"

        when:
        executer.withArgument("-Dname=b")
        run("a")

        then:
        result.assertTaskSkipped(":a")
    }