)

// CAClient is the mocked CAClient for testing.
type CAClient struct {
	SignInvokeCount uint64
	bundle          *util.KeyCertBundle
	certLifetime    time.Duration
	GeneratedCerts  [][]string // Cache the generated certificates for verification purpose.
	mockTrustAnchor bool
}

// NewMockCAClient creates an instance of CAClient. errors is used to specify the number of errors

        }

        when:
        gcsClient.put(Mock(InputStream), 0, uri)
        then:
        def ex = thrown(ResourceException)
        ex.message.startsWith("Could not write to resource 'https://somehost/file.txt'")
    }

    def "should not fail on GcsClient.list() returning null"() {
        def gcsStorageClient = Mock(Storage)
        GcsClient gcsClient = new GcsClient(gcsStorageClient)

    def name = new ExternalResourceName(uri)

    def "should list resources"() {
        GcsClient gcsClient = Mock()
        when:
        new GcsResourceConnector(gcsClient).list(name)
        then:
        1 * gcsClient.list(uri)
    }

    def "should get a resource"() {
        GcsClient gcsClient = Mock {
            1 * getResource(uri) >> new StorageObject()
        }

        when:

    def "should list resources"() {
        S3Client s3Client = Mock()
        when:
        new S3ResourceConnector(s3Client).list(name)
        then:
        1 * s3Client.listDirectChildren(uri)
    }

    def "should get a resource"() {
        ObjectMetadata objectMetadata = Mock()
        S3Client s3Client = Mock {
            1 * getResource(uri) >> Mock(S3Object) {

 */

package org.gradle.integtests.resource.gcs

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential
import com.google.api.client.http.HttpRequest
import com.google.api.client.http.HttpRequestInitializer
import com.google.api.client.http.javanet.NetHttpTransport
import com.google.api.client.json.gson.GsonFactory
import com.google.api.services.storage.Storage

public class GcsResource implements ExternalResourceReadResponse {

    private final GcsClient gcsClient;
    private final StorageObject gcsObject;
    private final URI uri;

    public GcsResource(GcsClient gcsClient, StorageObject gcsObject, URI uri) {
        this.gcsClient = gcsClient;
        this.gcsObject = gcsObject;
        this.uri = uri;
    }

    @Override

    private final S3Client s3Client;

    public S3ResourceConnector(S3Client s3Client) {
        this.s3Client = s3Client;
    }

    @Override
    public List<String> list(ExternalResourceName parent) {
        LOGGER.debug("Listing parent resources: {}", parent);
        return s3Client.listDirectChildren(parent.getUri());
    }

    @Override

    private final GcsClient gcsClient;

    public GcsResourceConnector(GcsClient gcsClient) {
        this.gcsClient = gcsClient;
    }

    @Nullable
    @Override
    public List<String> list(ExternalResourceName parent) throws ResourceException {
        LOGGER.debug("Listing parent resources: {}", parent);
        return gcsClient.list(parent.getUri());
    }

    @Nullable

				return
			}

			tt.inClient = NewDeltaWithBackoffPolicy(tt.inClient.cfg.Address, tt.inClient.cfg, nil, handlers...)
			if err := tt.inClient.Run(context.TODO()); err != nil {
				t.Errorf("ADSC: failed running %v", err)
				return
			}
			assert.EventuallyEqual(t, func() bool {
				tt.inClient.mutex.Lock()
				defer tt.inClient.mutex.Unlock()
				rec := tt.inClient.lastReceived

  /** Lazily initialized on first use. */
  private var messageDeflater: MessageDeflater? = null

  // Masks are only a concern for client writers.
  private val maskKey: ByteArray? = if (isClient) ByteArray(4) else null
  private val maskCursor: Buffer.UnsafeCursor? = if (isClient) Buffer.UnsafeCursor() else null

  /** Send a ping with the supplied [payload]. */
  @Throws(IOException::class)
  fun writePing(payload: ByteString) {