// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/pingcap/tiflow/dm/pb (interfaces: MasterClient,MasterServer)

// Package pbmock is a generated GoMock package.
package pbmock

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	pb "github.com/pingcap/tiflow/dm/pb"
	grpc "google.golang.org/grpc"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockMasterClient is a mock of MasterClient interface.
type MockMasterClient struct {
	ctrl     *gomock.Controller
	recorder *MockMasterClientMockRecorder
}

// MockMasterClientMockRecorder is the mock recorder for MockMasterClient.
type MockMasterClientMockRecorder struct {
	mock *MockMasterClient
}

// NewMockMasterClient creates a new mock instance.
func NewMockMasterClient(ctrl *gomock.Controller) *MockMasterClient {
	mock := &MockMasterClient{ctrl: ctrl}
	mock.recorder = &MockMasterClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMasterClient) EXPECT() *MockMasterClientMockRecorder {
	return m.recorder
}

// CheckTask mocks base method.
func (m *MockMasterClient) CheckTask(arg0 context.Context, arg1 *pb.CheckTaskRequest, arg2 ...grpc.CallOption) (*pb.CheckTaskResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CheckTask", varargs...)
	ret0, _ := ret[0].(*pb.CheckTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckTask indicates an expected call of CheckTask.
func (mr *MockMasterClientMockRecorder) CheckTask(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckTask", reflect.TypeOf((*MockMasterClient)(nil).CheckTask), varargs...)
}

// Encrypt mocks base method.
func (m *MockMasterClient) Encrypt(arg0 context.Context, arg1 *pb.EncryptRequest, arg2 ...grpc.CallOption) (*pb.EncryptResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Encrypt", varargs...)
	ret0, _ := ret[0].(*pb.EncryptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Encrypt indicates an expected call of Encrypt.
func (mr *MockMasterClientMockRecorder) Encrypt(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Encrypt", reflect.TypeOf((*MockMasterClient)(nil).Encrypt), varargs...)
}

// GetCfg mocks base method.
func (m *MockMasterClient) GetCfg(arg0 context.Context, arg1 *pb.GetCfgRequest, arg2 ...grpc.CallOption) (*pb.GetCfgResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCfg", varargs...)
	ret0, _ := ret[0].(*pb.GetCfgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCfg indicates an expected call of GetCfg.
func (mr *MockMasterClientMockRecorder) GetCfg(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCfg", reflect.TypeOf((*MockMasterClient)(nil).GetCfg), varargs...)
}

// GetMasterCfg mocks base method.
func (m *MockMasterClient) GetMasterCfg(arg0 context.Context, arg1 *pb.GetMasterCfgRequest, arg2 ...grpc.CallOption) (*pb.GetMasterCfgResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMasterCfg", varargs...)
	ret0, _ := ret[0].(*pb.GetMasterCfgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMasterCfg indicates an expected call of GetMasterCfg.
func (mr *MockMasterClientMockRecorder) GetMasterCfg(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMasterCfg", reflect.TypeOf((*MockMasterClient)(nil).GetMasterCfg), varargs...)
}

// GetSubTaskCfg mocks base method.
func (m *MockMasterClient) GetSubTaskCfg(arg0 context.Context, arg1 *pb.GetSubTaskCfgRequest, arg2 ...grpc.CallOption) (*pb.GetSubTaskCfgResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSubTaskCfg", varargs...)
	ret0, _ := ret[0].(*pb.GetSubTaskCfgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubTaskCfg indicates an expected call of GetSubTaskCfg.
func (mr *MockMasterClientMockRecorder) GetSubTaskCfg(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubTaskCfg", reflect.TypeOf((*MockMasterClient)(nil).GetSubTaskCfg), varargs...)
}

// GetValidationError mocks base method.
func (m *MockMasterClient) GetValidationError(arg0 context.Context, arg1 *pb.GetValidationErrorRequest, arg2 ...grpc.CallOption) (*pb.GetValidationErrorResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetValidationError", varargs...)
	ret0, _ := ret[0].(*pb.GetValidationErrorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetValidationError indicates an expected call of GetValidationError.
func (mr *MockMasterClientMockRecorder) GetValidationError(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidationError", reflect.TypeOf((*MockMasterClient)(nil).GetValidationError), varargs...)
}

// GetValidationStatus mocks base method.
func (m *MockMasterClient) GetValidationStatus(arg0 context.Context, arg1 *pb.GetValidationStatusRequest, arg2 ...grpc.CallOption) (*pb.GetValidationStatusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetValidationStatus", varargs...)
	ret0, _ := ret[0].(*pb.GetValidationStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetValidationStatus indicates an expected call of GetValidationStatus.
func (mr *MockMasterClientMockRecorder) GetValidationStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidationStatus", reflect.TypeOf((*MockMasterClient)(nil).GetValidationStatus), varargs...)
}

// HandleError mocks base method.
func (m *MockMasterClient) HandleError(arg0 context.Context, arg1 *pb.HandleErrorRequest, arg2 ...grpc.CallOption) (*pb.HandleErrorResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HandleError", varargs...)
	ret0, _ := ret[0].(*pb.HandleErrorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleError indicates an expected call of HandleError.
func (mr *MockMasterClientMockRecorder) HandleError(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleError", reflect.TypeOf((*MockMasterClient)(nil).HandleError), varargs...)
}

// ListMember mocks base method.
func (m *MockMasterClient) ListMember(arg0 context.Context, arg1 *pb.ListMemberRequest, arg2 ...grpc.CallOption) (*pb.ListMemberResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMember", varargs...)
	ret0, _ := ret[0].(*pb.ListMemberResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMember indicates an expected call of ListMember.
func (mr *MockMasterClientMockRecorder) ListMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMember", reflect.TypeOf((*MockMasterClient)(nil).ListMember), varargs...)
}

// ListSourceConfigs mocks base method.
func (m *MockMasterClient) ListSourceConfigs(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*pb.ListSourceConfigsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSourceConfigs", varargs...)
	ret0, _ := ret[0].(*pb.ListSourceConfigsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSourceConfigs indicates an expected call of ListSourceConfigs.
func (mr *MockMasterClientMockRecorder) ListSourceConfigs(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSourceConfigs", reflect.TypeOf((*MockMasterClient)(nil).ListSourceConfigs), varargs...)
}

// ListTaskConfigs mocks base method.
func (m *MockMasterClient) ListTaskConfigs(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*pb.ListTaskConfigsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTaskConfigs", varargs...)
	ret0, _ := ret[0].(*pb.ListTaskConfigsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskConfigs indicates an expected call of ListTaskConfigs.
func (mr *MockMasterClientMockRecorder) ListTaskConfigs(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskConfigs", reflect.TypeOf((*MockMasterClient)(nil).ListTaskConfigs), varargs...)
}

// OfflineMember mocks base method.
func (m *MockMasterClient) OfflineMember(arg0 context.Context, arg1 *pb.OfflineMemberRequest, arg2 ...grpc.CallOption) (*pb.OfflineMemberResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OfflineMember", varargs...)
	ret0, _ := ret[0].(*pb.OfflineMemberResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OfflineMember indicates an expected call of OfflineMember.
func (mr *MockMasterClientMockRecorder) OfflineMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OfflineMember", reflect.TypeOf((*MockMasterClient)(nil).OfflineMember), varargs...)
}

// OperateLeader mocks base method.
func (m *MockMasterClient) OperateLeader(arg0 context.Context, arg1 *pb.OperateLeaderRequest, arg2 ...grpc.CallOption) (*pb.OperateLeaderResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OperateLeader", varargs...)
	ret0, _ := ret[0].(*pb.OperateLeaderResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateLeader indicates an expected call of OperateLeader.
func (mr *MockMasterClientMockRecorder) OperateLeader(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateLeader", reflect.TypeOf((*MockMasterClient)(nil).OperateLeader), varargs...)
}

// OperateRelay mocks base method.
func (m *MockMasterClient) OperateRelay(arg0 context.Context, arg1 *pb.OperateRelayRequest, arg2 ...grpc.CallOption) (*pb.OperateRelayResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OperateRelay", varargs...)
	ret0, _ := ret[0].(*pb.OperateRelayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateRelay indicates an expected call of OperateRelay.
func (mr *MockMasterClientMockRecorder) OperateRelay(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateRelay", reflect.TypeOf((*MockMasterClient)(nil).OperateRelay), varargs...)
}

// OperateSchema mocks base method.
func (m *MockMasterClient) OperateSchema(arg0 context.Context, arg1 *pb.OperateSchemaRequest, arg2 ...grpc.CallOption) (*pb.OperateSchemaResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OperateSchema", varargs...)
	ret0, _ := ret[0].(*pb.OperateSchemaResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateSchema indicates an expected call of OperateSchema.
func (mr *MockMasterClientMockRecorder) OperateSchema(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateSchema", reflect.TypeOf((*MockMasterClient)(nil).OperateSchema), varargs...)
}

// OperateSource mocks base method.
func (m *MockMasterClient) OperateSource(arg0 context.Context, arg1 *pb.OperateSourceRequest, arg2 ...grpc.CallOption) (*pb.OperateSourceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OperateSource", varargs...)
	ret0, _ := ret[0].(*pb.OperateSourceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateSource indicates an expected call of OperateSource.
func (mr *MockMasterClientMockRecorder) OperateSource(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateSource", reflect.TypeOf((*MockMasterClient)(nil).OperateSource), varargs...)
}

// OperateTask mocks base method.
func (m *MockMasterClient) OperateTask(arg0 context.Context, arg1 *pb.OperateTaskRequest, arg2 ...grpc.CallOption) (*pb.OperateTaskResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OperateTask", varargs...)
	ret0, _ := ret[0].(*pb.OperateTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateTask indicates an expected call of OperateTask.
func (mr *MockMasterClientMockRecorder) OperateTask(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateTask", reflect.TypeOf((*MockMasterClient)(nil).OperateTask), varargs...)
}

// OperateValidationError mocks base method.
func (m *MockMasterClient) OperateValidationError(arg0 context.Context, arg1 *pb.OperateValidationErrorRequest, arg2 ...grpc.CallOption) (*pb.OperateValidationErrorResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OperateValidationError", varargs...)
	ret0, _ := ret[0].(*pb.OperateValidationErrorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateValidationError indicates an expected call of OperateValidationError.
func (mr *MockMasterClientMockRecorder) OperateValidationError(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateValidationError", reflect.TypeOf((*MockMasterClient)(nil).OperateValidationError), varargs...)
}

// OperateWorkerRelayTask mocks base method.
func (m *MockMasterClient) OperateWorkerRelayTask(arg0 context.Context, arg1 *pb.OperateWorkerRelayRequest, arg2 ...grpc.CallOption) (*pb.OperateWorkerRelayResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OperateWorkerRelayTask", varargs...)
	ret0, _ := ret[0].(*pb.OperateWorkerRelayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateWorkerRelayTask indicates an expected call of OperateWorkerRelayTask.
func (mr *MockMasterClientMockRecorder) OperateWorkerRelayTask(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateWorkerRelayTask", reflect.TypeOf((*MockMasterClient)(nil).OperateWorkerRelayTask), varargs...)
}

// PurgeWorkerRelay mocks base method.
func (m *MockMasterClient) PurgeWorkerRelay(arg0 context.Context, arg1 *pb.PurgeWorkerRelayRequest, arg2 ...grpc.CallOption) (*pb.PurgeWorkerRelayResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurgeWorkerRelay", varargs...)
	ret0, _ := ret[0].(*pb.PurgeWorkerRelayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurgeWorkerRelay indicates an expected call of PurgeWorkerRelay.
func (mr *MockMasterClientMockRecorder) PurgeWorkerRelay(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeWorkerRelay", reflect.TypeOf((*MockMasterClient)(nil).PurgeWorkerRelay), varargs...)
}

// QueryStatus mocks base method.
func (m *MockMasterClient) QueryStatus(arg0 context.Context, arg1 *pb.QueryStatusListRequest, arg2 ...grpc.CallOption) (*pb.QueryStatusListResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryStatus", varargs...)
	ret0, _ := ret[0].(*pb.QueryStatusListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryStatus indicates an expected call of QueryStatus.
func (mr *MockMasterClientMockRecorder) QueryStatus(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryStatus", reflect.TypeOf((*MockMasterClient)(nil).QueryStatus), varargs...)
}

// RegisterWorker mocks base method.
func (m *MockMasterClient) RegisterWorker(arg0 context.Context, arg1 *pb.RegisterWorkerRequest, arg2 ...grpc.CallOption) (*pb.RegisterWorkerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterWorker", varargs...)
	ret0, _ := ret[0].(*pb.RegisterWorkerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterWorker indicates an expected call of RegisterWorker.
func (mr *MockMasterClientMockRecorder) RegisterWorker(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorker", reflect.TypeOf((*MockMasterClient)(nil).RegisterWorker), varargs...)
}

// ShowDDLLocks mocks base method.
func (m *MockMasterClient) ShowDDLLocks(arg0 context.Context, arg1 *pb.ShowDDLLocksRequest, arg2 ...grpc.CallOption) (*pb.ShowDDLLocksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShowDDLLocks", varargs...)
	ret0, _ := ret[0].(*pb.ShowDDLLocksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShowDDLLocks indicates an expected call of ShowDDLLocks.
func (mr *MockMasterClientMockRecorder) ShowDDLLocks(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShowDDLLocks", reflect.TypeOf((*MockMasterClient)(nil).ShowDDLLocks), varargs...)
}

// StartTask mocks base method.
func (m *MockMasterClient) StartTask(arg0 context.Context, arg1 *pb.StartTaskRequest, arg2 ...grpc.CallOption) (*pb.StartTaskResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartTask", varargs...)
	ret0, _ := ret[0].(*pb.StartTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartTask indicates an expected call of StartTask.
func (mr *MockMasterClientMockRecorder) StartTask(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTask", reflect.TypeOf((*MockMasterClient)(nil).StartTask), varargs...)
}

// StartValidation mocks base method.
func (m *MockMasterClient) StartValidation(arg0 context.Context, arg1 *pb.StartValidationRequest, arg2 ...grpc.CallOption) (*pb.StartValidationResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartValidation", varargs...)
	ret0, _ := ret[0].(*pb.StartValidationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartValidation indicates an expected call of StartValidation.
func (mr *MockMasterClientMockRecorder) StartValidation(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartValidation", reflect.TypeOf((*MockMasterClient)(nil).StartValidation), varargs...)
}

// StopValidation mocks base method.
func (m *MockMasterClient) StopValidation(arg0 context.Context, arg1 *pb.StopValidationRequest, arg2 ...grpc.CallOption) (*pb.StopValidationResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopValidation", varargs...)
	ret0, _ := ret[0].(*pb.StopValidationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopValidation indicates an expected call of StopValidation.
func (mr *MockMasterClientMockRecorder) StopValidation(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopValidation", reflect.TypeOf((*MockMasterClient)(nil).StopValidation), varargs...)
}

// TransferSource mocks base method.
func (m *MockMasterClient) TransferSource(arg0 context.Context, arg1 *pb.TransferSourceRequest, arg2 ...grpc.CallOption) (*pb.TransferSourceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TransferSource", varargs...)
	ret0, _ := ret[0].(*pb.TransferSourceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransferSource indicates an expected call of TransferSource.
func (mr *MockMasterClientMockRecorder) TransferSource(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferSource", reflect.TypeOf((*MockMasterClient)(nil).TransferSource), varargs...)
}

// UnlockDDLLock mocks base method.
func (m *MockMasterClient) UnlockDDLLock(arg0 context.Context, arg1 *pb.UnlockDDLLockRequest, arg2 ...grpc.CallOption) (*pb.UnlockDDLLockResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnlockDDLLock", varargs...)
	ret0, _ := ret[0].(*pb.UnlockDDLLockResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnlockDDLLock indicates an expected call of UnlockDDLLock.
func (mr *MockMasterClientMockRecorder) UnlockDDLLock(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockDDLLock", reflect.TypeOf((*MockMasterClient)(nil).UnlockDDLLock), varargs...)
}

// UpdateTask mocks base method.
func (m *MockMasterClient) UpdateTask(arg0 context.Context, arg1 *pb.UpdateTaskRequest, arg2 ...grpc.CallOption) (*pb.UpdateTaskResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTask", varargs...)
	ret0, _ := ret[0].(*pb.UpdateTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTask indicates an expected call of UpdateTask.
func (mr *MockMasterClientMockRecorder) UpdateTask(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTask", reflect.TypeOf((*MockMasterClient)(nil).UpdateTask), varargs...)
}

// UpdateValidation mocks base method.
func (m *MockMasterClient) UpdateValidation(arg0 context.Context, arg1 *pb.UpdateValidationRequest, arg2 ...grpc.CallOption) (*pb.UpdateValidationResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateValidation", varargs...)
	ret0, _ := ret[0].(*pb.UpdateValidationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateValidation indicates an expected call of UpdateValidation.
func (mr *MockMasterClientMockRecorder) UpdateValidation(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateValidation", reflect.TypeOf((*MockMasterClient)(nil).UpdateValidation), varargs...)
}

// MockMasterServer is a mock of MasterServer interface.
type MockMasterServer struct {
	ctrl     *gomock.Controller
	recorder *MockMasterServerMockRecorder
}

// MockMasterServerMockRecorder is the mock recorder for MockMasterServer.
type MockMasterServerMockRecorder struct {
	mock *MockMasterServer
}

// NewMockMasterServer creates a new mock instance.
func NewMockMasterServer(ctrl *gomock.Controller) *MockMasterServer {
	mock := &MockMasterServer{ctrl: ctrl}
	mock.recorder = &MockMasterServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMasterServer) EXPECT() *MockMasterServerMockRecorder {
	return m.recorder
}

// CheckTask mocks base method.
func (m *MockMasterServer) CheckTask(arg0 context.Context, arg1 *pb.CheckTaskRequest) (*pb.CheckTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckTask", arg0, arg1)
	ret0, _ := ret[0].(*pb.CheckTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckTask indicates an expected call of CheckTask.
func (mr *MockMasterServerMockRecorder) CheckTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckTask", reflect.TypeOf((*MockMasterServer)(nil).CheckTask), arg0, arg1)
}

// Encrypt mocks base method.
func (m *MockMasterServer) Encrypt(arg0 context.Context, arg1 *pb.EncryptRequest) (*pb.EncryptResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Encrypt", arg0, arg1)
	ret0, _ := ret[0].(*pb.EncryptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Encrypt indicates an expected call of Encrypt.
func (mr *MockMasterServerMockRecorder) Encrypt(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Encrypt", reflect.TypeOf((*MockMasterServer)(nil).Encrypt), arg0, arg1)
}

// GetCfg mocks base method.
func (m *MockMasterServer) GetCfg(arg0 context.Context, arg1 *pb.GetCfgRequest) (*pb.GetCfgResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCfg", arg0, arg1)
	ret0, _ := ret[0].(*pb.GetCfgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCfg indicates an expected call of GetCfg.
func (mr *MockMasterServerMockRecorder) GetCfg(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCfg", reflect.TypeOf((*MockMasterServer)(nil).GetCfg), arg0, arg1)
}

// GetMasterCfg mocks base method.
func (m *MockMasterServer) GetMasterCfg(arg0 context.Context, arg1 *pb.GetMasterCfgRequest) (*pb.GetMasterCfgResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMasterCfg", arg0, arg1)
	ret0, _ := ret[0].(*pb.GetMasterCfgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMasterCfg indicates an expected call of GetMasterCfg.
func (mr *MockMasterServerMockRecorder) GetMasterCfg(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMasterCfg", reflect.TypeOf((*MockMasterServer)(nil).GetMasterCfg), arg0, arg1)
}

// GetSubTaskCfg mocks base method.
func (m *MockMasterServer) GetSubTaskCfg(arg0 context.Context, arg1 *pb.GetSubTaskCfgRequest) (*pb.GetSubTaskCfgResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubTaskCfg", arg0, arg1)
	ret0, _ := ret[0].(*pb.GetSubTaskCfgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubTaskCfg indicates an expected call of GetSubTaskCfg.
func (mr *MockMasterServerMockRecorder) GetSubTaskCfg(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubTaskCfg", reflect.TypeOf((*MockMasterServer)(nil).GetSubTaskCfg), arg0, arg1)
}

// GetValidationError mocks base method.
func (m *MockMasterServer) GetValidationError(arg0 context.Context, arg1 *pb.GetValidationErrorRequest) (*pb.GetValidationErrorResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetValidationError", arg0, arg1)
	ret0, _ := ret[0].(*pb.GetValidationErrorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetValidationError indicates an expected call of GetValidationError.
func (mr *MockMasterServerMockRecorder) GetValidationError(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidationError", reflect.TypeOf((*MockMasterServer)(nil).GetValidationError), arg0, arg1)
}

// GetValidationStatus mocks base method.
func (m *MockMasterServer) GetValidationStatus(arg0 context.Context, arg1 *pb.GetValidationStatusRequest) (*pb.GetValidationStatusResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetValidationStatus", arg0, arg1)
	ret0, _ := ret[0].(*pb.GetValidationStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetValidationStatus indicates an expected call of GetValidationStatus.
func (mr *MockMasterServerMockRecorder) GetValidationStatus(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidationStatus", reflect.TypeOf((*MockMasterServer)(nil).GetValidationStatus), arg0, arg1)
}

// HandleError mocks base method.
func (m *MockMasterServer) HandleError(arg0 context.Context, arg1 *pb.HandleErrorRequest) (*pb.HandleErrorResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleError", arg0, arg1)
	ret0, _ := ret[0].(*pb.HandleErrorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleError indicates an expected call of HandleError.
func (mr *MockMasterServerMockRecorder) HandleError(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleError", reflect.TypeOf((*MockMasterServer)(nil).HandleError), arg0, arg1)
}

// ListMember mocks base method.
func (m *MockMasterServer) ListMember(arg0 context.Context, arg1 *pb.ListMemberRequest) (*pb.ListMemberResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMember", arg0, arg1)
	ret0, _ := ret[0].(*pb.ListMemberResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMember indicates an expected call of ListMember.
func (mr *MockMasterServerMockRecorder) ListMember(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMember", reflect.TypeOf((*MockMasterServer)(nil).ListMember), arg0, arg1)
}

// ListSourceConfigs mocks base method.
func (m *MockMasterServer) ListSourceConfigs(arg0 context.Context, arg1 *emptypb.Empty) (*pb.ListSourceConfigsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSourceConfigs", arg0, arg1)
	ret0, _ := ret[0].(*pb.ListSourceConfigsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSourceConfigs indicates an expected call of ListSourceConfigs.
func (mr *MockMasterServerMockRecorder) ListSourceConfigs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSourceConfigs", reflect.TypeOf((*MockMasterServer)(nil).ListSourceConfigs), arg0, arg1)
}

// ListTaskConfigs mocks base method.
func (m *MockMasterServer) ListTaskConfigs(arg0 context.Context, arg1 *emptypb.Empty) (*pb.ListTaskConfigsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskConfigs", arg0, arg1)
	ret0, _ := ret[0].(*pb.ListTaskConfigsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskConfigs indicates an expected call of ListTaskConfigs.
func (mr *MockMasterServerMockRecorder) ListTaskConfigs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskConfigs", reflect.TypeOf((*MockMasterServer)(nil).ListTaskConfigs), arg0, arg1)
}

// OfflineMember mocks base method.
func (m *MockMasterServer) OfflineMember(arg0 context.Context, arg1 *pb.OfflineMemberRequest) (*pb.OfflineMemberResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OfflineMember", arg0, arg1)
	ret0, _ := ret[0].(*pb.OfflineMemberResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OfflineMember indicates an expected call of OfflineMember.
func (mr *MockMasterServerMockRecorder) OfflineMember(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OfflineMember", reflect.TypeOf((*MockMasterServer)(nil).OfflineMember), arg0, arg1)
}

// OperateLeader mocks base method.
func (m *MockMasterServer) OperateLeader(arg0 context.Context, arg1 *pb.OperateLeaderRequest) (*pb.OperateLeaderResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OperateLeader", arg0, arg1)
	ret0, _ := ret[0].(*pb.OperateLeaderResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateLeader indicates an expected call of OperateLeader.
func (mr *MockMasterServerMockRecorder) OperateLeader(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateLeader", reflect.TypeOf((*MockMasterServer)(nil).OperateLeader), arg0, arg1)
}

// OperateRelay mocks base method.
func (m *MockMasterServer) OperateRelay(arg0 context.Context, arg1 *pb.OperateRelayRequest) (*pb.OperateRelayResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OperateRelay", arg0, arg1)
	ret0, _ := ret[0].(*pb.OperateRelayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateRelay indicates an expected call of OperateRelay.
func (mr *MockMasterServerMockRecorder) OperateRelay(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateRelay", reflect.TypeOf((*MockMasterServer)(nil).OperateRelay), arg0, arg1)
}

// OperateSchema mocks base method.
func (m *MockMasterServer) OperateSchema(arg0 context.Context, arg1 *pb.OperateSchemaRequest) (*pb.OperateSchemaResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OperateSchema", arg0, arg1)
	ret0, _ := ret[0].(*pb.OperateSchemaResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateSchema indicates an expected call of OperateSchema.
func (mr *MockMasterServerMockRecorder) OperateSchema(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateSchema", reflect.TypeOf((*MockMasterServer)(nil).OperateSchema), arg0, arg1)
}

// OperateSource mocks base method.
func (m *MockMasterServer) OperateSource(arg0 context.Context, arg1 *pb.OperateSourceRequest) (*pb.OperateSourceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OperateSource", arg0, arg1)
	ret0, _ := ret[0].(*pb.OperateSourceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateSource indicates an expected call of OperateSource.
func (mr *MockMasterServerMockRecorder) OperateSource(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateSource", reflect.TypeOf((*MockMasterServer)(nil).OperateSource), arg0, arg1)
}

// OperateTask mocks base method.
func (m *MockMasterServer) OperateTask(arg0 context.Context, arg1 *pb.OperateTaskRequest) (*pb.OperateTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OperateTask", arg0, arg1)
	ret0, _ := ret[0].(*pb.OperateTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateTask indicates an expected call of OperateTask.
func (mr *MockMasterServerMockRecorder) OperateTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateTask", reflect.TypeOf((*MockMasterServer)(nil).OperateTask), arg0, arg1)
}

// OperateValidationError mocks base method.
func (m *MockMasterServer) OperateValidationError(arg0 context.Context, arg1 *pb.OperateValidationErrorRequest) (*pb.OperateValidationErrorResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OperateValidationError", arg0, arg1)
	ret0, _ := ret[0].(*pb.OperateValidationErrorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateValidationError indicates an expected call of OperateValidationError.
func (mr *MockMasterServerMockRecorder) OperateValidationError(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateValidationError", reflect.TypeOf((*MockMasterServer)(nil).OperateValidationError), arg0, arg1)
}

// OperateWorkerRelayTask mocks base method.
func (m *MockMasterServer) OperateWorkerRelayTask(arg0 context.Context, arg1 *pb.OperateWorkerRelayRequest) (*pb.OperateWorkerRelayResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OperateWorkerRelayTask", arg0, arg1)
	ret0, _ := ret[0].(*pb.OperateWorkerRelayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OperateWorkerRelayTask indicates an expected call of OperateWorkerRelayTask.
func (mr *MockMasterServerMockRecorder) OperateWorkerRelayTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OperateWorkerRelayTask", reflect.TypeOf((*MockMasterServer)(nil).OperateWorkerRelayTask), arg0, arg1)
}

// PurgeWorkerRelay mocks base method.
func (m *MockMasterServer) PurgeWorkerRelay(arg0 context.Context, arg1 *pb.PurgeWorkerRelayRequest) (*pb.PurgeWorkerRelayResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurgeWorkerRelay", arg0, arg1)
	ret0, _ := ret[0].(*pb.PurgeWorkerRelayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurgeWorkerRelay indicates an expected call of PurgeWorkerRelay.
func (mr *MockMasterServerMockRecorder) PurgeWorkerRelay(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeWorkerRelay", reflect.TypeOf((*MockMasterServer)(nil).PurgeWorkerRelay), arg0, arg1)
}

// QueryStatus mocks base method.
func (m *MockMasterServer) QueryStatus(arg0 context.Context, arg1 *pb.QueryStatusListRequest) (*pb.QueryStatusListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryStatus", arg0, arg1)
	ret0, _ := ret[0].(*pb.QueryStatusListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryStatus indicates an expected call of QueryStatus.
func (mr *MockMasterServerMockRecorder) QueryStatus(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryStatus", reflect.TypeOf((*MockMasterServer)(nil).QueryStatus), arg0, arg1)
}

// RegisterWorker mocks base method.
func (m *MockMasterServer) RegisterWorker(arg0 context.Context, arg1 *pb.RegisterWorkerRequest) (*pb.RegisterWorkerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterWorker", arg0, arg1)
	ret0, _ := ret[0].(*pb.RegisterWorkerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterWorker indicates an expected call of RegisterWorker.
func (mr *MockMasterServerMockRecorder) RegisterWorker(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorker", reflect.TypeOf((*MockMasterServer)(nil).RegisterWorker), arg0, arg1)
}

// ShowDDLLocks mocks base method.
func (m *MockMasterServer) ShowDDLLocks(arg0 context.Context, arg1 *pb.ShowDDLLocksRequest) (*pb.ShowDDLLocksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShowDDLLocks", arg0, arg1)
	ret0, _ := ret[0].(*pb.ShowDDLLocksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShowDDLLocks indicates an expected call of ShowDDLLocks.
func (mr *MockMasterServerMockRecorder) ShowDDLLocks(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShowDDLLocks", reflect.TypeOf((*MockMasterServer)(nil).ShowDDLLocks), arg0, arg1)
}

// StartTask mocks base method.
func (m *MockMasterServer) StartTask(arg0 context.Context, arg1 *pb.StartTaskRequest) (*pb.StartTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartTask", arg0, arg1)
	ret0, _ := ret[0].(*pb.StartTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartTask indicates an expected call of StartTask.
func (mr *MockMasterServerMockRecorder) StartTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTask", reflect.TypeOf((*MockMasterServer)(nil).StartTask), arg0, arg1)
}

// StartValidation mocks base method.
func (m *MockMasterServer) StartValidation(arg0 context.Context, arg1 *pb.StartValidationRequest) (*pb.StartValidationResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartValidation", arg0, arg1)
	ret0, _ := ret[0].(*pb.StartValidationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartValidation indicates an expected call of StartValidation.
func (mr *MockMasterServerMockRecorder) StartValidation(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartValidation", reflect.TypeOf((*MockMasterServer)(nil).StartValidation), arg0, arg1)
}

// StopValidation mocks base method.
func (m *MockMasterServer) StopValidation(arg0 context.Context, arg1 *pb.StopValidationRequest) (*pb.StopValidationResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopValidation", arg0, arg1)
	ret0, _ := ret[0].(*pb.StopValidationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopValidation indicates an expected call of StopValidation.
func (mr *MockMasterServerMockRecorder) StopValidation(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopValidation", reflect.TypeOf((*MockMasterServer)(nil).StopValidation), arg0, arg1)
}

// TransferSource mocks base method.
func (m *MockMasterServer) TransferSource(arg0 context.Context, arg1 *pb.TransferSourceRequest) (*pb.TransferSourceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferSource", arg0, arg1)
	ret0, _ := ret[0].(*pb.TransferSourceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransferSource indicates an expected call of TransferSource.
func (mr *MockMasterServerMockRecorder) TransferSource(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferSource", reflect.TypeOf((*MockMasterServer)(nil).TransferSource), arg0, arg1)
}

// UnlockDDLLock mocks base method.
func (m *MockMasterServer) UnlockDDLLock(arg0 context.Context, arg1 *pb.UnlockDDLLockRequest) (*pb.UnlockDDLLockResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnlockDDLLock", arg0, arg1)
	ret0, _ := ret[0].(*pb.UnlockDDLLockResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnlockDDLLock indicates an expected call of UnlockDDLLock.
func (mr *MockMasterServerMockRecorder) UnlockDDLLock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockDDLLock", reflect.TypeOf((*MockMasterServer)(nil).UnlockDDLLock), arg0, arg1)
}

// UpdateTask mocks base method.
func (m *MockMasterServer) UpdateTask(arg0 context.Context, arg1 *pb.UpdateTaskRequest) (*pb.UpdateTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTask", arg0, arg1)
	ret0, _ := ret[0].(*pb.UpdateTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTask indicates an expected call of UpdateTask.
func (mr *MockMasterServerMockRecorder) UpdateTask(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTask", reflect.TypeOf((*MockMasterServer)(nil).UpdateTask), arg0, arg1)
}

// UpdateValidation mocks base method.
func (m *MockMasterServer) UpdateValidation(arg0 context.Context, arg1 *pb.UpdateValidationRequest) (*pb.UpdateValidationResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateValidation", arg0, arg1)
	ret0, _ := ret[0].(*pb.UpdateValidationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateValidation indicates an expected call of UpdateValidation.
func (mr *MockMasterServerMockRecorder) UpdateValidation(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateValidation", reflect.TypeOf((*MockMasterServer)(nil).UpdateValidation), arg0, arg1)
}