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

    def setup() {
        executer.beforeExecute {
            executer.withArgument("-D${SOCKET_TIMEOUT_SYSTEM_PROPERTY}=60000")
            executer.withArgument("-D${CONNECTION_TIMEOUT_SYSTEM_PROPERTY}=60000")
        }
    }

    IvyHttpRepository getIvyHttpRepo(HttpRepository.MetadataType metadataType = HttpRepository.MetadataType.DEFAULT) {

        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:

            executer.withArgument("-D${projectName}OutputDir=${buildDirPath}")
        }

        void setOutputFileName(String outputFileName) {
            executer.withArgument("-D${projectName}FileName=${outputFileName}")
        }

        void setOutputDirName(String outputDirName) {
            executer.withArgument("-D${projectName}DirName=${outputDirName}")
        }

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:

        expectEvent("block")
        def client = new DaemonClientFixture(executer.withArgument("--debug").withTasks("block").start())
        waitFor("started")
        daemons.daemon.assertBusy()
        client.kill()
        daemons.daemon.becomesCanceled()

        when:
        def build = executer.withTasks("help").withArguments("--info").start()
        ConcurrentTestUtil.poll {

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

                    bar
                }

                dependencies {
                    bar "test:test-jar:1.0"
                }
            }
        """
        executer.withArgument("--parallel")

        expect:

    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: