@Rule
    public GcsServer server = new GcsServer(temporaryFolder)

    def setup() {
        executer.withArgument('-i')
        executer.withArgument("-D${GCS_ENDPOINT_PROPERTY}=${server.uri}")
        executer.withArgument("-D${GCS_SERVICE_PATH_PROPERTY}=/")
        executer.withArgument("-D${GCS_DISABLE_AUTH_PROPERTY}=true")
    }

    RepositoryServer getServer() {
        return server
    }

    protected ExecutionResult succeeds(String... tasks) {
        executer.withArgument("-D${GCS_ENDPOINT_PROPERTY}=${server.uri}")
        executer.withArgument("-D${GCS_SERVICE_PATH_PROPERTY}=/")
        executer.withArgument("-D${GCS_DISABLE_AUTH_PROPERTY}=true")
        result = executer.withTasks(*tasks).run()
    }

abstract class AbstractS3DependencyResolutionTest extends AbstractDependencyResolutionTest {

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

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

    String getBucket() {
        return 'tests3bucket'
    }

    abstract String getRepositoryPath()

// no point, always runs in parallel
class ConcurrentDependencyResolutionIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        requireOwnGradleUserHomeDir()
        executer.withArgument('--parallel')
        executer.withArgument('--max-workers=8')
    }

    @Issue("gradle/performance#502")
    def "local component selection harness test: thread-safety"() {
        given:
        buildFile << '''

        // build -> proxy(localhost) -> repo(localhost)
        //                           -> 127.0.0.1
        //
        executer.withArgument('-DsocksProxyHost=localhost')
        executer.withArgument("-DsocksProxyPort=${port}")
        executer.withArgument("-DsocksNonProxyHosts=127.*")
    }

    void stop() {
        socksServer?.stop()
        portFinder.releasePort(port)
    }

    @Override

                    languageVersion = JavaLanguageVersion.of(${majorVersion})
                }
            }
        """
    }

    AbstractIntegrationSpec withAutoDetection() {
        executer.withArgument("-Porg.gradle.java.installations.auto-detect=true")
        return this as AbstractIntegrationSpec
    }

    /**
     * Usage:
     * <pre>
     *     def jvm1 = Jvm.current()

    @Rule BlockingHttpServer server = new BlockingHttpServer()

    def "shows default message if no daemons are running"() {
        when:
        def out = executer.withArgument("--status").run().normalizedOutput

        then:
        out =~ """^$DaemonMessages.NO_DAEMONS_RUNNING

$ReportDaemonStatusClient.STATUS_FOOTER.*""".toString()
    }

                artifacts {
                    compile file: file('thing.txt'), builtBy: { throw new RuntimeException('broken') }
                }
            }
"""

        expect:
        executer.withArgument("--dry-run")
        fails("useCompileConfiguration")
        failure.assertHasDescription("Could not determine the dependencies of task ':useCompileConfiguration'.")
        failure.assertHasCause('broken')

        sourceArtifact.sha1.expectGetRevalidate()
        then:
        run 'retrieve'

        when:
        module.publishWithChangedContent()
        server.resetExpectations()
        then:
        executer.withArgument("--offline")
        run 'retrieve'
    }

    def "can cache and refresh non unique versioned maven artifacts with a classifier"() {
        given:
        def repo = mavenHttpRepo("repo")

                    assert !logger.isLoggable(Level.FINER)
                    assert !logger.isLoggable(Level.FINEST)
                }
            }
        """

        when:
        executer.withArgument("--debug")

        then:
        succeeds('isLoggable')
    }

    def 'JUL logger.isLoggable corresponds to gradle log level for --warn'() {
        given:
        buildFile << """