RootCAs:      rootCAs,
	}

	tlsServer := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		w.WriteHeader(200)
		w.Write([]byte("ok"))
	}))

	tlsServer.TLS = tlsConfig
	tlsServer.StartTLS()

	serverURL, err := url.Parse(tlsServer.URL)
	if err != nil {
		tlsServer.Close()
		t.Fatalf("failed to parse the testserver URL: %v", err)
	}

    String mavenVersion = "1.45"
    String projectName = "publishGcsTest"
    String bucket = 'testGcsbucket'
    String repositoryPath = '/maven/release/'

    @Rule
    public final 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}=/")

		NotBefore:    caCertNotBefore,
		TTL:          caCertTTL,
		SignerCert:   nil,
		SignerPriv:   nil,
		Org:          "MyOrg",
		IsCA:         true,
		IsSelfSigned: true,
		IsClient:     false,
		IsServer:     true,
		RSAKeySize:   2048,
	}

	rsaCaCertPem, rsaCaPrivPem, err := GenCertKeyFromOptions(rsaCaCertOptions)
	if err != nil {
		t.Fatal(err)
	}

	// Options to generate a CA cert with EC.

class IvyGcsModule extends DelegatingIvyModule<IvyGcsModule> implements RemoteIvyModule {
    IvyFileModule backingModule
    String bucket
    GcsServer server
    String repositoryPath

    IvyGcsModule(GcsServer server, IvyFileModule backingModule, String repositoryPath, String bucket) {
        super(backingModule)
        this.bucket = bucket
        this.server = server

	return nil
}

func (s *httpInstance) isUDS() bool {
	return s.UDSServer != ""
}

func (s *httpInstance) awaitReady(onReady OnReadyFunc, address string) {
	defer onReady()

	client := http.Client{}
	var url string
	if s.isUDS() {
		url = "http://unix/" + s.UDSServer
		client.Transport = &http.Transport{
			DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {

import org.gradle.test.fixtures.ivy.RemoteIvyRepository

class IvyGcsRepository implements RemoteIvyRepository {

    GcsServer server
    String bucket
    IvyFileRepository backingRepository
    String repositoryPath

class MavenGcsModule extends DelegatingMavenModule<MavenGcsModule> implements RemoteMavenModule {
    MavenFileModule backingModule
    GcsServer server
    String bucket
    String repositoryPath

    MavenGcsModule(GcsServer server, MavenFileModule backingModule, String repositoryPath, String bucket) {
        super(backingModule)
        this.bucket = bucket
        this.server = server

import org.gradle.test.fixtures.resource.RemoteResource

class GcsDirectoryResource implements RemoteResource {

    private final GcsServer server
    private final TestFile directory
    private final String bucket
    private final String path

    GcsDirectoryResource(GcsServer server, String bucket, TestFile directory) {
        this.bucket = bucket
        this.directory = directory
        this.server = server

    final String bucketName = 'org.gradle.artifacts'

    @Rule
    final TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())

    @Rule
    final GcsServer server = new GcsServer(temporaryFolder)

    def "should perform put, get and list on an Gcs bucket"() {
        setup:
        def fileContents = 'This is only a test'
        File file = temporaryFolder.createFile(FILE_NAME)

import static org.gradle.internal.resource.transport.gcp.gcs.GcsConnectionProperties.GCS_SERVICE_PATH_PROPERTY

class IvyGcsRepoResolveIntegrationTest extends AbstractIvyRemoteRepoResolveIntegrationTest {

    @Rule
    GcsServer server = new GcsServer(temporaryFolder)

    @Override
    RepositoryServer getServer() {
        return server
    }

    protected ExecutionResult succeeds(String... tasks) {