func (mr *MockContentAddressableStorageClientMockRecorder) BatchReadBlobs(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchReadBlobs", reflect.TypeOf((*MockContentAddressableStorageClient)(nil).BatchReadBlobs), varargs...)
}
BatchReadBlobs indicates an expected call of BatchReadBlobs
package mock_remoteexecution
import (
	context "context"
	gomock "github.com/golang/mock/gomock"
	remoteexecution "github.com/twitter/scoot/bazel/remoteexecution"
	grpc "google.golang.org/grpc"
	reflect "reflect"
)
type MockExecutionClient struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionClientMockRecorder
}
type MockExecutionClientMockRecorder struct {
	mock *MockExecutionClient
}
func NewMockExecutionClient(ctrl *gomock.Controller) *MockExecutionClient {
	mock := &MockExecutionClient{ctrl: ctrl}
	mock.recorder = &MockExecutionClientMockRecorder{mock}
	return mock
}
func (m *MockExecutionClient) EXPECT() *MockExecutionClientMockRecorder {
	return m.recorder
}
func (m *MockExecutionClient) Execute(arg0 context.Context, arg1 *remoteexecution.ExecuteRequest, arg2 ...grpc.CallOption) (remoteexecution.Execution_ExecuteClient, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Execute", varargs...)
	ret0, _ := ret[0].(remoteexecution.Execution_ExecuteClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockExecutionClientMockRecorder) Execute(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockExecutionClient)(nil).Execute), varargs...)
}
func (m *MockExecutionClient) WaitExecution(arg0 context.Context, arg1 *remoteexecution.WaitExecutionRequest, arg2 ...grpc.CallOption) (remoteexecution.Execution_WaitExecutionClient, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitExecution", varargs...)
	ret0, _ := ret[0].(remoteexecution.Execution_WaitExecutionClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockExecutionClientMockRecorder) WaitExecution(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitExecution", reflect.TypeOf((*MockExecutionClient)(nil).WaitExecution), varargs...)
}
type MockActionCacheClient struct {
	ctrl     *gomock.Controller
	recorder *MockActionCacheClientMockRecorder
}
type MockActionCacheClientMockRecorder struct {
	mock *MockActionCacheClient
}
func NewMockActionCacheClient(ctrl *gomock.Controller) *MockActionCacheClient {
	mock := &MockActionCacheClient{ctrl: ctrl}
	mock.recorder = &MockActionCacheClientMockRecorder{mock}
	return mock
}
func (m *MockActionCacheClient) EXPECT() *MockActionCacheClientMockRecorder {
	return m.recorder
}
func (m *MockActionCacheClient) GetActionResult(arg0 context.Context, arg1 *remoteexecution.GetActionResultRequest, arg2 ...grpc.CallOption) (*remoteexecution.ActionResult, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetActionResult", varargs...)
	ret0, _ := ret[0].(*remoteexecution.ActionResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockActionCacheClientMockRecorder) GetActionResult(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActionResult", reflect.TypeOf((*MockActionCacheClient)(nil).GetActionResult), varargs...)
}
func (m *MockActionCacheClient) UpdateActionResult(arg0 context.Context, arg1 *remoteexecution.UpdateActionResultRequest, arg2 ...grpc.CallOption) (*remoteexecution.ActionResult, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateActionResult", varargs...)
	ret0, _ := ret[0].(*remoteexecution.ActionResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockActionCacheClientMockRecorder) UpdateActionResult(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActionResult", reflect.TypeOf((*MockActionCacheClient)(nil).UpdateActionResult), varargs...)
}
type MockContentAddressableStorageClient struct {
	ctrl     *gomock.Controller
	recorder *MockContentAddressableStorageClientMockRecorder
}
type MockContentAddressableStorageClientMockRecorder struct {
	mock *MockContentAddressableStorageClient
}
func NewMockContentAddressableStorageClient(ctrl *gomock.Controller) *MockContentAddressableStorageClient {
	mock := &MockContentAddressableStorageClient{ctrl: ctrl}
	mock.recorder = &MockContentAddressableStorageClientMockRecorder{mock}
	return mock
}
func (m *MockContentAddressableStorageClient) EXPECT() *MockContentAddressableStorageClientMockRecorder {
	return m.recorder
}
func (m *MockContentAddressableStorageClient) BatchReadBlobs(arg0 context.Context, arg1 *remoteexecution.BatchReadBlobsRequest, arg2 ...grpc.CallOption) (*remoteexecution.BatchReadBlobsResponse, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchReadBlobs", varargs...)
	ret0, _ := ret[0].(*remoteexecution.BatchReadBlobsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}