func (m *MockWriterWrapper) CloseWithError(err error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseWithError", err)
	ret0, _ := ret[0].(error)
	return ret0
}
CloseWithError mocks base method.
package connector
import (
	context "context"
	reflect "reflect"
	storage "cloud.google.com/go/storage"
	gomock "github.com/golang/mock/gomock"
)
type MockGcloudStorageClient struct {
	ctrl     *gomock.Controller
	recorder *MockGcloudStorageClientMockRecorder
}
type MockGcloudStorageClientMockRecorder struct {
	mock *MockGcloudStorageClient
}
func NewMockGcloudStorageClient(ctrl *gomock.Controller) *MockGcloudStorageClient {
	mock := &MockGcloudStorageClient{ctrl: ctrl}
	mock.recorder = &MockGcloudStorageClientMockRecorder{mock}
	return mock
}
func (m *MockGcloudStorageClient) EXPECT() *MockGcloudStorageClientMockRecorder {
	return m.recorder
}
func (m *MockGcloudStorageClient) Bucket(URI string) BucketHandleWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bucket", URI)
	ret0, _ := ret[0].(BucketHandleWrapper)
	return ret0
}
func (mr *MockGcloudStorageClientMockRecorder) Bucket(URI interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bucket", reflect.TypeOf((*MockGcloudStorageClient)(nil).Bucket), URI)
}
type MockBucketHandleWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockBucketHandleWrapperMockRecorder
}
type MockBucketHandleWrapperMockRecorder struct {
	mock *MockBucketHandleWrapper
}
func NewMockBucketHandleWrapper(ctrl *gomock.Controller) *MockBucketHandleWrapper {
	mock := &MockBucketHandleWrapper{ctrl: ctrl}
	mock.recorder = &MockBucketHandleWrapperMockRecorder{mock}
	return mock
}
func (m *MockBucketHandleWrapper) EXPECT() *MockBucketHandleWrapperMockRecorder {
	return m.recorder
}
func (m *MockBucketHandleWrapper) Attrs(ctx context.Context) (*storage.BucketAttrs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Attrs", ctx)
	ret0, _ := ret[0].(*storage.BucketAttrs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockBucketHandleWrapperMockRecorder) Attrs(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attrs", reflect.TypeOf((*MockBucketHandleWrapper)(nil).Attrs), ctx)
}
func (m *MockBucketHandleWrapper) Object(name string) ObjectHandleWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Object", name)
	ret0, _ := ret[0].(ObjectHandleWrapper)
	return ret0
}
func (mr *MockBucketHandleWrapperMockRecorder) Object(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Object", reflect.TypeOf((*MockBucketHandleWrapper)(nil).Object), name)
}
func (m *MockBucketHandleWrapper) Objects(ctx context.Context, q *storage.Query) ObjectIteratorWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Objects", ctx, q)
	ret0, _ := ret[0].(ObjectIteratorWrapper)
	return ret0
}
func (mr *MockBucketHandleWrapperMockRecorder) Objects(ctx, q interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Objects", reflect.TypeOf((*MockBucketHandleWrapper)(nil).Objects), ctx, q)
}
type MockObjectHandleWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockObjectHandleWrapperMockRecorder
}
type MockObjectHandleWrapperMockRecorder struct {
	mock *MockObjectHandleWrapper
}
func NewMockObjectHandleWrapper(ctrl *gomock.Controller) *MockObjectHandleWrapper {
	mock := &MockObjectHandleWrapper{ctrl: ctrl}
	mock.recorder = &MockObjectHandleWrapperMockRecorder{mock}
	return mock
}
func (m *MockObjectHandleWrapper) EXPECT() *MockObjectHandleWrapperMockRecorder {
	return m.recorder
}
func (m *MockObjectHandleWrapper) Attrs(ctx context.Context) (*storage.ObjectAttrs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Attrs", ctx)
	ret0, _ := ret[0].(*storage.ObjectAttrs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockObjectHandleWrapperMockRecorder) Attrs(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attrs", reflect.TypeOf((*MockObjectHandleWrapper)(nil).Attrs), ctx)
}
func (m *MockObjectHandleWrapper) NewReader(ctx context.Context) (ReaderWrapper, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReader", ctx)
	ret0, _ := ret[0].(ReaderWrapper)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockObjectHandleWrapperMockRecorder) NewReader(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReader", reflect.TypeOf((*MockObjectHandleWrapper)(nil).NewReader), ctx)
}
func (m *MockObjectHandleWrapper) NewWriter(ctx context.Context) WriterWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewWriter", ctx)
	ret0, _ := ret[0].(WriterWrapper)
	return ret0
}
func (mr *MockObjectHandleWrapperMockRecorder) NewWriter(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewWriter", reflect.TypeOf((*MockObjectHandleWrapper)(nil).NewWriter), ctx)
}
type MockWriterWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockWriterWrapperMockRecorder
}
type MockWriterWrapperMockRecorder struct {
	mock *MockWriterWrapper
}
func NewMockWriterWrapper(ctrl *gomock.Controller) *MockWriterWrapper {
	mock := &MockWriterWrapper{ctrl: ctrl}
	mock.recorder = &MockWriterWrapperMockRecorder{mock}
	return mock
}
func (m *MockWriterWrapper) EXPECT() *MockWriterWrapperMockRecorder {
	return m.recorder
}
func (m *MockWriterWrapper) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockWriterWrapperMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockWriterWrapper)(nil).Close))
}