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:

        keyStore.enableSslWithServerCert(server)

        setupBuildFile(repoType)

        when:
        keyStore.configureServerAndClientCerts(executer)
        executer.withArgument("-Djavax.net.ssl.keyStore=Not-Existing-File").withArgument("--stacktrace")
        fails "libs"

        then:
        failure.assertHasCause("Could not resolve my-group:my-module:1.0")

    String bucket = 'tests3bucket'
    String repositoryPath = '/maven/release/'

    @Rule
    public final S3Server server = new S3Server(temporaryFolder)

    def setup() {
        executer.withArgument('-d')
        executer.withArgument("-Dorg.gradle.s3.endpoint=${server.uri}")
        executer.withStackTraceChecksDisabled()
    }

    def "should fail with an authentication error"() {
        setup:

        run("testClasses")

        and:
        executer.withArgument "--max-workers=$maxWorkers"

        and:
        def calls = testIndices(testCount).collect { "test_$it" } as String[]
        def handler = blockingServer.expectConcurrentAndBlock(maxConcurrency, calls)

        when:
        def gradle = executer.withArgument("-i").withTasks('test').start()

        then:

        expectPublish(module.moduleMetadata)
        module.rootMetaData.expectDownloadMissing()
        expectPublish(module.rootMetaData)

        executer.withArgument("-PmavenAccessKey=${credentials.accessKey}")
        executer.withArgument("-PmavenSecretKey=${credentials.secretKey}")
        succeeds 'publish'

        then:
        module.assertPublishedAsJavaModule()
        module.parsedPom.scopes.isEmpty()
    }

        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 {

        executer.withTasks("a", "block1", "b")
        executer.withArgument("--info")
        def build1 = executer.start()
        block1.waitForAllPendingCalls()

        // Start build 2 then wait until it has run both 'a' and 'b'.
        executer.withTasks("a", "b", "block2")
        executer.withArgument("--info")
        def build2 = executer.start()
        block2.waitForAllPendingCalls()

    }

    protected void withRichConsole(boolean enabled) {
        if (enabled) {
            executer.withConsole(ConsoleOutput.Rich)
        }
    }

    protected void withParallel() {
        executer.withArgument('--parallel')
    }