tasks/common/persistence/data_interfaces_mock.go

// The MIT License
//
// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
//
// Copyright (c) 2020 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

// Code generated by MockGen. DO NOT EDIT.
// Source: data_interfaces.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockCloseable is a mock of Closeable interface.
type MockCloseable struct {
	ctrl     *gomock.Controller
	recorder *MockCloseableMockRecorder
}

// MockCloseableMockRecorder is the mock recorder for MockCloseable.
type MockCloseableMockRecorder struct {
	mock *MockCloseable
}

// NewMockCloseable creates a new mock instance.
func NewMockCloseable(ctrl *gomock.Controller) *MockCloseable {
	mock := &MockCloseable{ctrl: ctrl}
	mock.recorder = &MockCloseableMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockCloseable) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockCloseableMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCloseable)(nil).Close))
}

// MockShardManager is a mock of ShardManager interface.
type MockShardManager struct {
	ctrl     *gomock.Controller
	recorder *MockShardManagerMockRecorder
}

// MockShardManagerMockRecorder is the mock recorder for MockShardManager.
type MockShardManagerMockRecorder struct {
	mock *MockShardManager
}

// NewMockShardManager creates a new mock instance.
func NewMockShardManager(ctrl *gomock.Controller) *MockShardManager {
	mock := &MockShardManager{ctrl: ctrl}
	mock.recorder = &MockShardManagerMockRecorder{mock}
	return mock
}

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

// AssertShardOwnership mocks base method.
func (m *MockShardManager) AssertShardOwnership(ctx context.Context, request *AssertShardOwnershipRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssertShardOwnership", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// AssertShardOwnership indicates an expected call of AssertShardOwnership.
func (mr *MockShardManagerMockRecorder) AssertShardOwnership(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssertShardOwnership", reflect.TypeOf((*MockShardManager)(nil).AssertShardOwnership), ctx, request)
}

// Close mocks base method.
func (m *MockShardManager) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockShardManagerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockShardManager)(nil).Close))
}

// GetName mocks base method.
func (m *MockShardManager) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetName indicates an expected call of GetName.
func (mr *MockShardManagerMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockShardManager)(nil).GetName))
}

// GetOrCreateShard mocks base method.
func (m *MockShardManager) GetOrCreateShard(ctx context.Context, request *GetOrCreateShardRequest) (*GetOrCreateShardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrCreateShard", ctx, request)
	ret0, _ := ret[0].(*GetOrCreateShardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrCreateShard indicates an expected call of GetOrCreateShard.
func (mr *MockShardManagerMockRecorder) GetOrCreateShard(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateShard", reflect.TypeOf((*MockShardManager)(nil).GetOrCreateShard), ctx, request)
}

// UpdateShard mocks base method.
func (m *MockShardManager) UpdateShard(ctx context.Context, request *UpdateShardRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateShard", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateShard indicates an expected call of UpdateShard.
func (mr *MockShardManagerMockRecorder) UpdateShard(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShard", reflect.TypeOf((*MockShardManager)(nil).UpdateShard), ctx, request)
}

// MockExecutionManager is a mock of ExecutionManager interface.
type MockExecutionManager struct {
	ctrl     *gomock.Controller
	recorder *MockExecutionManagerMockRecorder
}

// MockExecutionManagerMockRecorder is the mock recorder for MockExecutionManager.
type MockExecutionManagerMockRecorder struct {
	mock *MockExecutionManager
}

// NewMockExecutionManager creates a new mock instance.
func NewMockExecutionManager(ctrl *gomock.Controller) *MockExecutionManager {
	mock := &MockExecutionManager{ctrl: ctrl}
	mock.recorder = &MockExecutionManagerMockRecorder{mock}
	return mock
}

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

// AddHistoryTasks mocks base method.
func (m *MockExecutionManager) AddHistoryTasks(ctx context.Context, request *AddHistoryTasksRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddHistoryTasks", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddHistoryTasks indicates an expected call of AddHistoryTasks.
func (mr *MockExecutionManagerMockRecorder) AddHistoryTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHistoryTasks", reflect.TypeOf((*MockExecutionManager)(nil).AddHistoryTasks), ctx, request)
}

// AppendHistoryNodes mocks base method.
func (m *MockExecutionManager) AppendHistoryNodes(ctx context.Context, request *AppendHistoryNodesRequest) (*AppendHistoryNodesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendHistoryNodes", ctx, request)
	ret0, _ := ret[0].(*AppendHistoryNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppendHistoryNodes indicates an expected call of AppendHistoryNodes.
func (mr *MockExecutionManagerMockRecorder) AppendHistoryNodes(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendHistoryNodes", reflect.TypeOf((*MockExecutionManager)(nil).AppendHistoryNodes), ctx, request)
}

// AppendRawHistoryNodes mocks base method.
func (m *MockExecutionManager) AppendRawHistoryNodes(ctx context.Context, request *AppendRawHistoryNodesRequest) (*AppendHistoryNodesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendRawHistoryNodes", ctx, request)
	ret0, _ := ret[0].(*AppendHistoryNodesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AppendRawHistoryNodes indicates an expected call of AppendRawHistoryNodes.
func (mr *MockExecutionManagerMockRecorder) AppendRawHistoryNodes(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendRawHistoryNodes", reflect.TypeOf((*MockExecutionManager)(nil).AppendRawHistoryNodes), ctx, request)
}

// Close mocks base method.
func (m *MockExecutionManager) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockExecutionManagerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockExecutionManager)(nil).Close))
}

// CompleteHistoryTask mocks base method.
func (m *MockExecutionManager) CompleteHistoryTask(ctx context.Context, request *CompleteHistoryTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteHistoryTask", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// CompleteHistoryTask indicates an expected call of CompleteHistoryTask.
func (mr *MockExecutionManagerMockRecorder) CompleteHistoryTask(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteHistoryTask", reflect.TypeOf((*MockExecutionManager)(nil).CompleteHistoryTask), ctx, request)
}

// ConflictResolveWorkflowExecution mocks base method.
func (m *MockExecutionManager) ConflictResolveWorkflowExecution(ctx context.Context, request *ConflictResolveWorkflowExecutionRequest) (*ConflictResolveWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConflictResolveWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*ConflictResolveWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConflictResolveWorkflowExecution indicates an expected call of ConflictResolveWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) ConflictResolveWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConflictResolveWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).ConflictResolveWorkflowExecution), ctx, request)
}

// CreateWorkflowExecution mocks base method.
func (m *MockExecutionManager) CreateWorkflowExecution(ctx context.Context, request *CreateWorkflowExecutionRequest) (*CreateWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*CreateWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateWorkflowExecution indicates an expected call of CreateWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) CreateWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).CreateWorkflowExecution), ctx, request)
}

// DeleteCurrentWorkflowExecution mocks base method.
func (m *MockExecutionManager) DeleteCurrentWorkflowExecution(ctx context.Context, request *DeleteCurrentWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCurrentWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCurrentWorkflowExecution indicates an expected call of DeleteCurrentWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) DeleteCurrentWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).DeleteCurrentWorkflowExecution), ctx, request)
}

// DeleteHistoryBranch mocks base method.
func (m *MockExecutionManager) DeleteHistoryBranch(ctx context.Context, request *DeleteHistoryBranchRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteHistoryBranch", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteHistoryBranch indicates an expected call of DeleteHistoryBranch.
func (mr *MockExecutionManagerMockRecorder) DeleteHistoryBranch(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHistoryBranch", reflect.TypeOf((*MockExecutionManager)(nil).DeleteHistoryBranch), ctx, request)
}

// DeleteReplicationTaskFromDLQ mocks base method.
func (m *MockExecutionManager) DeleteReplicationTaskFromDLQ(ctx context.Context, request *DeleteReplicationTaskFromDLQRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicationTaskFromDLQ", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReplicationTaskFromDLQ indicates an expected call of DeleteReplicationTaskFromDLQ.
func (mr *MockExecutionManagerMockRecorder) DeleteReplicationTaskFromDLQ(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationTaskFromDLQ", reflect.TypeOf((*MockExecutionManager)(nil).DeleteReplicationTaskFromDLQ), ctx, request)
}

// DeleteWorkflowExecution mocks base method.
func (m *MockExecutionManager) DeleteWorkflowExecution(ctx context.Context, request *DeleteWorkflowExecutionRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWorkflowExecution indicates an expected call of DeleteWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) DeleteWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).DeleteWorkflowExecution), ctx, request)
}

// ForkHistoryBranch mocks base method.
func (m *MockExecutionManager) ForkHistoryBranch(ctx context.Context, request *ForkHistoryBranchRequest) (*ForkHistoryBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForkHistoryBranch", ctx, request)
	ret0, _ := ret[0].(*ForkHistoryBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForkHistoryBranch indicates an expected call of ForkHistoryBranch.
func (mr *MockExecutionManagerMockRecorder) ForkHistoryBranch(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForkHistoryBranch", reflect.TypeOf((*MockExecutionManager)(nil).ForkHistoryBranch), ctx, request)
}

// GetAllHistoryTreeBranches mocks base method.
func (m *MockExecutionManager) GetAllHistoryTreeBranches(ctx context.Context, request *GetAllHistoryTreeBranchesRequest) (*GetAllHistoryTreeBranchesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllHistoryTreeBranches", ctx, request)
	ret0, _ := ret[0].(*GetAllHistoryTreeBranchesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllHistoryTreeBranches indicates an expected call of GetAllHistoryTreeBranches.
func (mr *MockExecutionManagerMockRecorder) GetAllHistoryTreeBranches(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllHistoryTreeBranches", reflect.TypeOf((*MockExecutionManager)(nil).GetAllHistoryTreeBranches), ctx, request)
}

// GetCurrentExecution mocks base method.
func (m *MockExecutionManager) GetCurrentExecution(ctx context.Context, request *GetCurrentExecutionRequest) (*GetCurrentExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentExecution", ctx, request)
	ret0, _ := ret[0].(*GetCurrentExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentExecution indicates an expected call of GetCurrentExecution.
func (mr *MockExecutionManagerMockRecorder) GetCurrentExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentExecution", reflect.TypeOf((*MockExecutionManager)(nil).GetCurrentExecution), ctx, request)
}

// GetHistoryBranchUtil mocks base method.
func (m *MockExecutionManager) GetHistoryBranchUtil() HistoryBranchUtil {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHistoryBranchUtil")
	ret0, _ := ret[0].(HistoryBranchUtil)
	return ret0
}

// GetHistoryBranchUtil indicates an expected call of GetHistoryBranchUtil.
func (mr *MockExecutionManagerMockRecorder) GetHistoryBranchUtil() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryBranchUtil", reflect.TypeOf((*MockExecutionManager)(nil).GetHistoryBranchUtil))
}

// GetHistoryTasks mocks base method.
func (m *MockExecutionManager) GetHistoryTasks(ctx context.Context, request *GetHistoryTasksRequest) (*GetHistoryTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHistoryTasks", ctx, request)
	ret0, _ := ret[0].(*GetHistoryTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHistoryTasks indicates an expected call of GetHistoryTasks.
func (mr *MockExecutionManagerMockRecorder) GetHistoryTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryTasks", reflect.TypeOf((*MockExecutionManager)(nil).GetHistoryTasks), ctx, request)
}

// GetHistoryTree mocks base method.
func (m *MockExecutionManager) GetHistoryTree(ctx context.Context, request *GetHistoryTreeRequest) (*GetHistoryTreeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHistoryTree", ctx, request)
	ret0, _ := ret[0].(*GetHistoryTreeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetHistoryTree indicates an expected call of GetHistoryTree.
func (mr *MockExecutionManagerMockRecorder) GetHistoryTree(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryTree", reflect.TypeOf((*MockExecutionManager)(nil).GetHistoryTree), ctx, request)
}

// GetName mocks base method.
func (m *MockExecutionManager) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetName indicates an expected call of GetName.
func (mr *MockExecutionManagerMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockExecutionManager)(nil).GetName))
}

// GetReplicationTasksFromDLQ mocks base method.
func (m *MockExecutionManager) GetReplicationTasksFromDLQ(ctx context.Context, request *GetReplicationTasksFromDLQRequest) (*GetHistoryTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationTasksFromDLQ", ctx, request)
	ret0, _ := ret[0].(*GetHistoryTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReplicationTasksFromDLQ indicates an expected call of GetReplicationTasksFromDLQ.
func (mr *MockExecutionManagerMockRecorder) GetReplicationTasksFromDLQ(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicationTasksFromDLQ", reflect.TypeOf((*MockExecutionManager)(nil).GetReplicationTasksFromDLQ), ctx, request)
}

// GetWorkflowExecution mocks base method.
func (m *MockExecutionManager) GetWorkflowExecution(ctx context.Context, request *GetWorkflowExecutionRequest) (*GetWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*GetWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkflowExecution indicates an expected call of GetWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) GetWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).GetWorkflowExecution), ctx, request)
}

// IsReplicationDLQEmpty mocks base method.
func (m *MockExecutionManager) IsReplicationDLQEmpty(ctx context.Context, request *GetReplicationTasksFromDLQRequest) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsReplicationDLQEmpty", ctx, request)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsReplicationDLQEmpty indicates an expected call of IsReplicationDLQEmpty.
func (mr *MockExecutionManagerMockRecorder) IsReplicationDLQEmpty(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsReplicationDLQEmpty", reflect.TypeOf((*MockExecutionManager)(nil).IsReplicationDLQEmpty), ctx, request)
}

// ListConcreteExecutions mocks base method.
func (m *MockExecutionManager) ListConcreteExecutions(ctx context.Context, request *ListConcreteExecutionsRequest) (*ListConcreteExecutionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConcreteExecutions", ctx, request)
	ret0, _ := ret[0].(*ListConcreteExecutionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConcreteExecutions indicates an expected call of ListConcreteExecutions.
func (mr *MockExecutionManagerMockRecorder) ListConcreteExecutions(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConcreteExecutions", reflect.TypeOf((*MockExecutionManager)(nil).ListConcreteExecutions), ctx, request)
}

// PutReplicationTaskToDLQ mocks base method.
func (m *MockExecutionManager) PutReplicationTaskToDLQ(ctx context.Context, request *PutReplicationTaskToDLQRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutReplicationTaskToDLQ", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// PutReplicationTaskToDLQ indicates an expected call of PutReplicationTaskToDLQ.
func (mr *MockExecutionManagerMockRecorder) PutReplicationTaskToDLQ(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutReplicationTaskToDLQ", reflect.TypeOf((*MockExecutionManager)(nil).PutReplicationTaskToDLQ), ctx, request)
}

// RangeCompleteHistoryTasks mocks base method.
func (m *MockExecutionManager) RangeCompleteHistoryTasks(ctx context.Context, request *RangeCompleteHistoryTasksRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeCompleteHistoryTasks", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeCompleteHistoryTasks indicates an expected call of RangeCompleteHistoryTasks.
func (mr *MockExecutionManagerMockRecorder) RangeCompleteHistoryTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeCompleteHistoryTasks", reflect.TypeOf((*MockExecutionManager)(nil).RangeCompleteHistoryTasks), ctx, request)
}

// RangeDeleteReplicationTaskFromDLQ mocks base method.
func (m *MockExecutionManager) RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *RangeDeleteReplicationTaskFromDLQRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeDeleteReplicationTaskFromDLQ", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// RangeDeleteReplicationTaskFromDLQ indicates an expected call of RangeDeleteReplicationTaskFromDLQ.
func (mr *MockExecutionManagerMockRecorder) RangeDeleteReplicationTaskFromDLQ(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationTaskFromDLQ", reflect.TypeOf((*MockExecutionManager)(nil).RangeDeleteReplicationTaskFromDLQ), ctx, request)
}

// ReadHistoryBranch mocks base method.
func (m *MockExecutionManager) ReadHistoryBranch(ctx context.Context, request *ReadHistoryBranchRequest) (*ReadHistoryBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadHistoryBranch", ctx, request)
	ret0, _ := ret[0].(*ReadHistoryBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadHistoryBranch indicates an expected call of ReadHistoryBranch.
func (mr *MockExecutionManagerMockRecorder) ReadHistoryBranch(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadHistoryBranch", reflect.TypeOf((*MockExecutionManager)(nil).ReadHistoryBranch), ctx, request)
}

// ReadHistoryBranchByBatch mocks base method.
func (m *MockExecutionManager) ReadHistoryBranchByBatch(ctx context.Context, request *ReadHistoryBranchRequest) (*ReadHistoryBranchByBatchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadHistoryBranchByBatch", ctx, request)
	ret0, _ := ret[0].(*ReadHistoryBranchByBatchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadHistoryBranchByBatch indicates an expected call of ReadHistoryBranchByBatch.
func (mr *MockExecutionManagerMockRecorder) ReadHistoryBranchByBatch(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadHistoryBranchByBatch", reflect.TypeOf((*MockExecutionManager)(nil).ReadHistoryBranchByBatch), ctx, request)
}

// ReadHistoryBranchReverse mocks base method.
func (m *MockExecutionManager) ReadHistoryBranchReverse(ctx context.Context, request *ReadHistoryBranchReverseRequest) (*ReadHistoryBranchReverseResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadHistoryBranchReverse", ctx, request)
	ret0, _ := ret[0].(*ReadHistoryBranchReverseResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadHistoryBranchReverse indicates an expected call of ReadHistoryBranchReverse.
func (mr *MockExecutionManagerMockRecorder) ReadHistoryBranchReverse(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadHistoryBranchReverse", reflect.TypeOf((*MockExecutionManager)(nil).ReadHistoryBranchReverse), ctx, request)
}

// ReadRawHistoryBranch mocks base method.
func (m *MockExecutionManager) ReadRawHistoryBranch(ctx context.Context, request *ReadHistoryBranchRequest) (*ReadRawHistoryBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadRawHistoryBranch", ctx, request)
	ret0, _ := ret[0].(*ReadRawHistoryBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadRawHistoryBranch indicates an expected call of ReadRawHistoryBranch.
func (mr *MockExecutionManagerMockRecorder) ReadRawHistoryBranch(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRawHistoryBranch", reflect.TypeOf((*MockExecutionManager)(nil).ReadRawHistoryBranch), ctx, request)
}

// RegisterHistoryTaskReader mocks base method.
func (m *MockExecutionManager) RegisterHistoryTaskReader(ctx context.Context, request *RegisterHistoryTaskReaderRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterHistoryTaskReader", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterHistoryTaskReader indicates an expected call of RegisterHistoryTaskReader.
func (mr *MockExecutionManagerMockRecorder) RegisterHistoryTaskReader(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterHistoryTaskReader", reflect.TypeOf((*MockExecutionManager)(nil).RegisterHistoryTaskReader), ctx, request)
}

// SetWorkflowExecution mocks base method.
func (m *MockExecutionManager) SetWorkflowExecution(ctx context.Context, request *SetWorkflowExecutionRequest) (*SetWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*SetWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetWorkflowExecution indicates an expected call of SetWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) SetWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).SetWorkflowExecution), ctx, request)
}

// TrimHistoryBranch mocks base method.
func (m *MockExecutionManager) TrimHistoryBranch(ctx context.Context, request *TrimHistoryBranchRequest) (*TrimHistoryBranchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TrimHistoryBranch", ctx, request)
	ret0, _ := ret[0].(*TrimHistoryBranchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TrimHistoryBranch indicates an expected call of TrimHistoryBranch.
func (mr *MockExecutionManagerMockRecorder) TrimHistoryBranch(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrimHistoryBranch", reflect.TypeOf((*MockExecutionManager)(nil).TrimHistoryBranch), ctx, request)
}

// UnregisterHistoryTaskReader mocks base method.
func (m *MockExecutionManager) UnregisterHistoryTaskReader(ctx context.Context, request *UnregisterHistoryTaskReaderRequest) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UnregisterHistoryTaskReader", ctx, request)
}

// UnregisterHistoryTaskReader indicates an expected call of UnregisterHistoryTaskReader.
func (mr *MockExecutionManagerMockRecorder) UnregisterHistoryTaskReader(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterHistoryTaskReader", reflect.TypeOf((*MockExecutionManager)(nil).UnregisterHistoryTaskReader), ctx, request)
}

// UpdateHistoryTaskReaderProgress mocks base method.
func (m *MockExecutionManager) UpdateHistoryTaskReaderProgress(ctx context.Context, request *UpdateHistoryTaskReaderProgressRequest) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateHistoryTaskReaderProgress", ctx, request)
}

// UpdateHistoryTaskReaderProgress indicates an expected call of UpdateHistoryTaskReaderProgress.
func (mr *MockExecutionManagerMockRecorder) UpdateHistoryTaskReaderProgress(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHistoryTaskReaderProgress", reflect.TypeOf((*MockExecutionManager)(nil).UpdateHistoryTaskReaderProgress), ctx, request)
}

// UpdateWorkflowExecution mocks base method.
func (m *MockExecutionManager) UpdateWorkflowExecution(ctx context.Context, request *UpdateWorkflowExecutionRequest) (*UpdateWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkflowExecution", ctx, request)
	ret0, _ := ret[0].(*UpdateWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkflowExecution indicates an expected call of UpdateWorkflowExecution.
func (mr *MockExecutionManagerMockRecorder) UpdateWorkflowExecution(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecution", reflect.TypeOf((*MockExecutionManager)(nil).UpdateWorkflowExecution), ctx, request)
}

// MockTaskManager is a mock of TaskManager interface.
type MockTaskManager struct {
	ctrl     *gomock.Controller
	recorder *MockTaskManagerMockRecorder
}

// MockTaskManagerMockRecorder is the mock recorder for MockTaskManager.
type MockTaskManagerMockRecorder struct {
	mock *MockTaskManager
}

// NewMockTaskManager creates a new mock instance.
func NewMockTaskManager(ctrl *gomock.Controller) *MockTaskManager {
	mock := &MockTaskManager{ctrl: ctrl}
	mock.recorder = &MockTaskManagerMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockTaskManager) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockTaskManagerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTaskManager)(nil).Close))
}

// CompleteTask mocks base method.
func (m *MockTaskManager) CompleteTask(ctx context.Context, request *CompleteTaskRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTask", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// CompleteTask indicates an expected call of CompleteTask.
func (mr *MockTaskManagerMockRecorder) CompleteTask(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTask", reflect.TypeOf((*MockTaskManager)(nil).CompleteTask), ctx, request)
}

// CompleteTasksLessThan mocks base method.
func (m *MockTaskManager) CompleteTasksLessThan(ctx context.Context, request *CompleteTasksLessThanRequest) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteTasksLessThan", ctx, request)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompleteTasksLessThan indicates an expected call of CompleteTasksLessThan.
func (mr *MockTaskManagerMockRecorder) CompleteTasksLessThan(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTasksLessThan", reflect.TypeOf((*MockTaskManager)(nil).CompleteTasksLessThan), ctx, request)
}

// CountTaskQueuesByBuildId mocks base method.
func (m *MockTaskManager) CountTaskQueuesByBuildId(ctx context.Context, request *CountTaskQueuesByBuildIdRequest) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountTaskQueuesByBuildId", ctx, request)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountTaskQueuesByBuildId indicates an expected call of CountTaskQueuesByBuildId.
func (mr *MockTaskManagerMockRecorder) CountTaskQueuesByBuildId(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountTaskQueuesByBuildId", reflect.TypeOf((*MockTaskManager)(nil).CountTaskQueuesByBuildId), ctx, request)
}

// CreateTaskQueue mocks base method.
func (m *MockTaskManager) CreateTaskQueue(ctx context.Context, request *CreateTaskQueueRequest) (*CreateTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTaskQueue", ctx, request)
	ret0, _ := ret[0].(*CreateTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTaskQueue indicates an expected call of CreateTaskQueue.
func (mr *MockTaskManagerMockRecorder) CreateTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTaskQueue", reflect.TypeOf((*MockTaskManager)(nil).CreateTaskQueue), ctx, request)
}

// CreateTasks mocks base method.
func (m *MockTaskManager) CreateTasks(ctx context.Context, request *CreateTasksRequest) (*CreateTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTasks", ctx, request)
	ret0, _ := ret[0].(*CreateTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTasks indicates an expected call of CreateTasks.
func (mr *MockTaskManagerMockRecorder) CreateTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTasks", reflect.TypeOf((*MockTaskManager)(nil).CreateTasks), ctx, request)
}

// DeleteTaskQueue mocks base method.
func (m *MockTaskManager) DeleteTaskQueue(ctx context.Context, request *DeleteTaskQueueRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTaskQueue", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTaskQueue indicates an expected call of DeleteTaskQueue.
func (mr *MockTaskManagerMockRecorder) DeleteTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskQueue", reflect.TypeOf((*MockTaskManager)(nil).DeleteTaskQueue), ctx, request)
}

// GetName mocks base method.
func (m *MockTaskManager) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetName indicates an expected call of GetName.
func (mr *MockTaskManagerMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockTaskManager)(nil).GetName))
}

// GetTaskQueue mocks base method.
func (m *MockTaskManager) GetTaskQueue(ctx context.Context, request *GetTaskQueueRequest) (*GetTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskQueue", ctx, request)
	ret0, _ := ret[0].(*GetTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskQueue indicates an expected call of GetTaskQueue.
func (mr *MockTaskManagerMockRecorder) GetTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueue", reflect.TypeOf((*MockTaskManager)(nil).GetTaskQueue), ctx, request)
}

// GetTaskQueueUserData mocks base method.
func (m *MockTaskManager) GetTaskQueueUserData(ctx context.Context, request *GetTaskQueueUserDataRequest) (*GetTaskQueueUserDataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskQueueUserData", ctx, request)
	ret0, _ := ret[0].(*GetTaskQueueUserDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskQueueUserData indicates an expected call of GetTaskQueueUserData.
func (mr *MockTaskManagerMockRecorder) GetTaskQueueUserData(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueUserData", reflect.TypeOf((*MockTaskManager)(nil).GetTaskQueueUserData), ctx, request)
}

// GetTaskQueuesByBuildId mocks base method.
func (m *MockTaskManager) GetTaskQueuesByBuildId(ctx context.Context, request *GetTaskQueuesByBuildIdRequest) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskQueuesByBuildId", ctx, request)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskQueuesByBuildId indicates an expected call of GetTaskQueuesByBuildId.
func (mr *MockTaskManagerMockRecorder) GetTaskQueuesByBuildId(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueuesByBuildId", reflect.TypeOf((*MockTaskManager)(nil).GetTaskQueuesByBuildId), ctx, request)
}

// GetTasks mocks base method.
func (m *MockTaskManager) GetTasks(ctx context.Context, request *GetTasksRequest) (*GetTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTasks", ctx, request)
	ret0, _ := ret[0].(*GetTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTasks indicates an expected call of GetTasks.
func (mr *MockTaskManagerMockRecorder) GetTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTasks", reflect.TypeOf((*MockTaskManager)(nil).GetTasks), ctx, request)
}

// ListTaskQueue mocks base method.
func (m *MockTaskManager) ListTaskQueue(ctx context.Context, request *ListTaskQueueRequest) (*ListTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskQueue", ctx, request)
	ret0, _ := ret[0].(*ListTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskQueue indicates an expected call of ListTaskQueue.
func (mr *MockTaskManagerMockRecorder) ListTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskQueue", reflect.TypeOf((*MockTaskManager)(nil).ListTaskQueue), ctx, request)
}

// ListTaskQueueUserDataEntries mocks base method.
func (m *MockTaskManager) ListTaskQueueUserDataEntries(ctx context.Context, request *ListTaskQueueUserDataEntriesRequest) (*ListTaskQueueUserDataEntriesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskQueueUserDataEntries", ctx, request)
	ret0, _ := ret[0].(*ListTaskQueueUserDataEntriesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTaskQueueUserDataEntries indicates an expected call of ListTaskQueueUserDataEntries.
func (mr *MockTaskManagerMockRecorder) ListTaskQueueUserDataEntries(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskQueueUserDataEntries", reflect.TypeOf((*MockTaskManager)(nil).ListTaskQueueUserDataEntries), ctx, request)
}

// UpdateTaskQueue mocks base method.
func (m *MockTaskManager) UpdateTaskQueue(ctx context.Context, request *UpdateTaskQueueRequest) (*UpdateTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskQueue", ctx, request)
	ret0, _ := ret[0].(*UpdateTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTaskQueue indicates an expected call of UpdateTaskQueue.
func (mr *MockTaskManagerMockRecorder) UpdateTaskQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueue", reflect.TypeOf((*MockTaskManager)(nil).UpdateTaskQueue), ctx, request)
}

// UpdateTaskQueueUserData mocks base method.
func (m *MockTaskManager) UpdateTaskQueueUserData(ctx context.Context, request *UpdateTaskQueueUserDataRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskQueueUserData", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTaskQueueUserData indicates an expected call of UpdateTaskQueueUserData.
func (mr *MockTaskManagerMockRecorder) UpdateTaskQueueUserData(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueueUserData", reflect.TypeOf((*MockTaskManager)(nil).UpdateTaskQueueUserData), ctx, request)
}

// MockMetadataManager is a mock of MetadataManager interface.
type MockMetadataManager struct {
	ctrl     *gomock.Controller
	recorder *MockMetadataManagerMockRecorder
}

// MockMetadataManagerMockRecorder is the mock recorder for MockMetadataManager.
type MockMetadataManagerMockRecorder struct {
	mock *MockMetadataManager
}

// NewMockMetadataManager creates a new mock instance.
func NewMockMetadataManager(ctrl *gomock.Controller) *MockMetadataManager {
	mock := &MockMetadataManager{ctrl: ctrl}
	mock.recorder = &MockMetadataManagerMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockMetadataManager) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockMetadataManagerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockMetadataManager)(nil).Close))
}

// CreateNamespace mocks base method.
func (m *MockMetadataManager) CreateNamespace(ctx context.Context, request *CreateNamespaceRequest) (*CreateNamespaceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamespace", ctx, request)
	ret0, _ := ret[0].(*CreateNamespaceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNamespace indicates an expected call of CreateNamespace.
func (mr *MockMetadataManagerMockRecorder) CreateNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamespace", reflect.TypeOf((*MockMetadataManager)(nil).CreateNamespace), ctx, request)
}

// DeleteNamespace mocks base method.
func (m *MockMetadataManager) DeleteNamespace(ctx context.Context, request *DeleteNamespaceRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespace", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNamespace indicates an expected call of DeleteNamespace.
func (mr *MockMetadataManagerMockRecorder) DeleteNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespace", reflect.TypeOf((*MockMetadataManager)(nil).DeleteNamespace), ctx, request)
}

// DeleteNamespaceByName mocks base method.
func (m *MockMetadataManager) DeleteNamespaceByName(ctx context.Context, request *DeleteNamespaceByNameRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespaceByName", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNamespaceByName indicates an expected call of DeleteNamespaceByName.
func (mr *MockMetadataManagerMockRecorder) DeleteNamespaceByName(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespaceByName", reflect.TypeOf((*MockMetadataManager)(nil).DeleteNamespaceByName), ctx, request)
}

// GetMetadata mocks base method.
func (m *MockMetadataManager) GetMetadata(ctx context.Context) (*GetMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetadata", ctx)
	ret0, _ := ret[0].(*GetMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMetadata indicates an expected call of GetMetadata.
func (mr *MockMetadataManagerMockRecorder) GetMetadata(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockMetadataManager)(nil).GetMetadata), ctx)
}

// GetName mocks base method.
func (m *MockMetadataManager) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetName indicates an expected call of GetName.
func (mr *MockMetadataManagerMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockMetadataManager)(nil).GetName))
}

// GetNamespace mocks base method.
func (m *MockMetadataManager) GetNamespace(ctx context.Context, request *GetNamespaceRequest) (*GetNamespaceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespace", ctx, request)
	ret0, _ := ret[0].(*GetNamespaceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespace indicates an expected call of GetNamespace.
func (mr *MockMetadataManagerMockRecorder) GetNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockMetadataManager)(nil).GetNamespace), ctx, request)
}

// InitializeSystemNamespaces mocks base method.
func (m *MockMetadataManager) InitializeSystemNamespaces(ctx context.Context, currentClusterName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InitializeSystemNamespaces", ctx, currentClusterName)
	ret0, _ := ret[0].(error)
	return ret0
}

// InitializeSystemNamespaces indicates an expected call of InitializeSystemNamespaces.
func (mr *MockMetadataManagerMockRecorder) InitializeSystemNamespaces(ctx, currentClusterName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitializeSystemNamespaces", reflect.TypeOf((*MockMetadataManager)(nil).InitializeSystemNamespaces), ctx, currentClusterName)
}

// ListNamespaces mocks base method.
func (m *MockMetadataManager) ListNamespaces(ctx context.Context, request *ListNamespacesRequest) (*ListNamespacesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamespaces", ctx, request)
	ret0, _ := ret[0].(*ListNamespacesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNamespaces indicates an expected call of ListNamespaces.
func (mr *MockMetadataManagerMockRecorder) ListNamespaces(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamespaces", reflect.TypeOf((*MockMetadataManager)(nil).ListNamespaces), ctx, request)
}

// RenameNamespace mocks base method.
func (m *MockMetadataManager) RenameNamespace(ctx context.Context, request *RenameNamespaceRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenameNamespace", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenameNamespace indicates an expected call of RenameNamespace.
func (mr *MockMetadataManagerMockRecorder) RenameNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNamespace", reflect.TypeOf((*MockMetadataManager)(nil).RenameNamespace), ctx, request)
}

// UpdateNamespace mocks base method.
func (m *MockMetadataManager) UpdateNamespace(ctx context.Context, request *UpdateNamespaceRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNamespace", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateNamespace indicates an expected call of UpdateNamespace.
func (mr *MockMetadataManagerMockRecorder) UpdateNamespace(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespace", reflect.TypeOf((*MockMetadataManager)(nil).UpdateNamespace), ctx, request)
}

// MockClusterMetadataManager is a mock of ClusterMetadataManager interface.
type MockClusterMetadataManager struct {
	ctrl     *gomock.Controller
	recorder *MockClusterMetadataManagerMockRecorder
}

// MockClusterMetadataManagerMockRecorder is the mock recorder for MockClusterMetadataManager.
type MockClusterMetadataManagerMockRecorder struct {
	mock *MockClusterMetadataManager
}

// NewMockClusterMetadataManager creates a new mock instance.
func NewMockClusterMetadataManager(ctrl *gomock.Controller) *MockClusterMetadataManager {
	mock := &MockClusterMetadataManager{ctrl: ctrl}
	mock.recorder = &MockClusterMetadataManagerMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockClusterMetadataManager) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockClusterMetadataManagerMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClusterMetadataManager)(nil).Close))
}

// DeleteClusterMetadata mocks base method.
func (m *MockClusterMetadataManager) DeleteClusterMetadata(ctx context.Context, request *DeleteClusterMetadataRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteClusterMetadata", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteClusterMetadata indicates an expected call of DeleteClusterMetadata.
func (mr *MockClusterMetadataManagerMockRecorder) DeleteClusterMetadata(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterMetadata", reflect.TypeOf((*MockClusterMetadataManager)(nil).DeleteClusterMetadata), ctx, request)
}

// GetClusterMembers mocks base method.
func (m *MockClusterMetadataManager) GetClusterMembers(ctx context.Context, request *GetClusterMembersRequest) (*GetClusterMembersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterMembers", ctx, request)
	ret0, _ := ret[0].(*GetClusterMembersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterMembers indicates an expected call of GetClusterMembers.
func (mr *MockClusterMetadataManagerMockRecorder) GetClusterMembers(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMembers", reflect.TypeOf((*MockClusterMetadataManager)(nil).GetClusterMembers), ctx, request)
}

// GetClusterMetadata mocks base method.
func (m *MockClusterMetadataManager) GetClusterMetadata(ctx context.Context, request *GetClusterMetadataRequest) (*GetClusterMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterMetadata", ctx, request)
	ret0, _ := ret[0].(*GetClusterMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterMetadata indicates an expected call of GetClusterMetadata.
func (mr *MockClusterMetadataManagerMockRecorder) GetClusterMetadata(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMetadata", reflect.TypeOf((*MockClusterMetadataManager)(nil).GetClusterMetadata), ctx, request)
}

// GetCurrentClusterMetadata mocks base method.
func (m *MockClusterMetadataManager) GetCurrentClusterMetadata(ctx context.Context) (*GetClusterMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentClusterMetadata", ctx)
	ret0, _ := ret[0].(*GetClusterMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentClusterMetadata indicates an expected call of GetCurrentClusterMetadata.
func (mr *MockClusterMetadataManagerMockRecorder) GetCurrentClusterMetadata(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentClusterMetadata", reflect.TypeOf((*MockClusterMetadataManager)(nil).GetCurrentClusterMetadata), ctx)
}

// GetName mocks base method.
func (m *MockClusterMetadataManager) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetName indicates an expected call of GetName.
func (mr *MockClusterMetadataManagerMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockClusterMetadataManager)(nil).GetName))
}

// ListClusterMetadata mocks base method.
func (m *MockClusterMetadataManager) ListClusterMetadata(ctx context.Context, request *ListClusterMetadataRequest) (*ListClusterMetadataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusterMetadata", ctx, request)
	ret0, _ := ret[0].(*ListClusterMetadataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterMetadata indicates an expected call of ListClusterMetadata.
func (mr *MockClusterMetadataManagerMockRecorder) ListClusterMetadata(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterMetadata", reflect.TypeOf((*MockClusterMetadataManager)(nil).ListClusterMetadata), ctx, request)
}

// PruneClusterMembership mocks base method.
func (m *MockClusterMetadataManager) PruneClusterMembership(ctx context.Context, request *PruneClusterMembershipRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PruneClusterMembership", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// PruneClusterMembership indicates an expected call of PruneClusterMembership.
func (mr *MockClusterMetadataManagerMockRecorder) PruneClusterMembership(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PruneClusterMembership", reflect.TypeOf((*MockClusterMetadataManager)(nil).PruneClusterMembership), ctx, request)
}

// SaveClusterMetadata mocks base method.
func (m *MockClusterMetadataManager) SaveClusterMetadata(ctx context.Context, request *SaveClusterMetadataRequest) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveClusterMetadata", ctx, request)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SaveClusterMetadata indicates an expected call of SaveClusterMetadata.
func (mr *MockClusterMetadataManagerMockRecorder) SaveClusterMetadata(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveClusterMetadata", reflect.TypeOf((*MockClusterMetadataManager)(nil).SaveClusterMetadata), ctx, request)
}

// UpsertClusterMembership mocks base method.
func (m *MockClusterMetadataManager) UpsertClusterMembership(ctx context.Context, request *UpsertClusterMembershipRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertClusterMembership", ctx, request)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertClusterMembership indicates an expected call of UpsertClusterMembership.
func (mr *MockClusterMetadataManagerMockRecorder) UpsertClusterMembership(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertClusterMembership", reflect.TypeOf((*MockClusterMetadataManager)(nil).UpsertClusterMembership), ctx, request)
}

// MockHistoryTaskQueueManager is a mock of HistoryTaskQueueManager interface.
type MockHistoryTaskQueueManager struct {
	ctrl     *gomock.Controller
	recorder *MockHistoryTaskQueueManagerMockRecorder
}

// MockHistoryTaskQueueManagerMockRecorder is the mock recorder for MockHistoryTaskQueueManager.
type MockHistoryTaskQueueManagerMockRecorder struct {
	mock *MockHistoryTaskQueueManager
}

// NewMockHistoryTaskQueueManager creates a new mock instance.
func NewMockHistoryTaskQueueManager(ctrl *gomock.Controller) *MockHistoryTaskQueueManager {
	mock := &MockHistoryTaskQueueManager{ctrl: ctrl}
	mock.recorder = &MockHistoryTaskQueueManagerMockRecorder{mock}
	return mock
}

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

// CreateQueue mocks base method.
func (m *MockHistoryTaskQueueManager) CreateQueue(ctx context.Context, request *CreateQueueRequest) (*CreateQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateQueue", ctx, request)
	ret0, _ := ret[0].(*CreateQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateQueue indicates an expected call of CreateQueue.
func (mr *MockHistoryTaskQueueManagerMockRecorder) CreateQueue(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueue", reflect.TypeOf((*MockHistoryTaskQueueManager)(nil).CreateQueue), ctx, request)
}

// DeleteTasks mocks base method.
func (m *MockHistoryTaskQueueManager) DeleteTasks(ctx context.Context, request *DeleteTasksRequest) (*DeleteTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTasks", ctx, request)
	ret0, _ := ret[0].(*DeleteTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTasks indicates an expected call of DeleteTasks.
func (mr *MockHistoryTaskQueueManagerMockRecorder) DeleteTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTasks", reflect.TypeOf((*MockHistoryTaskQueueManager)(nil).DeleteTasks), ctx, request)
}

// EnqueueTask mocks base method.
func (m *MockHistoryTaskQueueManager) EnqueueTask(ctx context.Context, request *EnqueueTaskRequest) (*EnqueueTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnqueueTask", ctx, request)
	ret0, _ := ret[0].(*EnqueueTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnqueueTask indicates an expected call of EnqueueTask.
func (mr *MockHistoryTaskQueueManagerMockRecorder) EnqueueTask(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueTask", reflect.TypeOf((*MockHistoryTaskQueueManager)(nil).EnqueueTask), ctx, request)
}

// ListQueues mocks base method.
func (m *MockHistoryTaskQueueManager) ListQueues(ctx context.Context, request *ListQueuesRequest) (*ListQueuesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueues", ctx, request)
	ret0, _ := ret[0].(*ListQueuesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListQueues indicates an expected call of ListQueues.
func (mr *MockHistoryTaskQueueManagerMockRecorder) ListQueues(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueues", reflect.TypeOf((*MockHistoryTaskQueueManager)(nil).ListQueues), ctx, request)
}

// ReadRawTasks mocks base method.
func (m *MockHistoryTaskQueueManager) ReadRawTasks(ctx context.Context, request *ReadRawTasksRequest) (*ReadRawTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadRawTasks", ctx, request)
	ret0, _ := ret[0].(*ReadRawTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadRawTasks indicates an expected call of ReadRawTasks.
func (mr *MockHistoryTaskQueueManagerMockRecorder) ReadRawTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRawTasks", reflect.TypeOf((*MockHistoryTaskQueueManager)(nil).ReadRawTasks), ctx, request)
}

// ReadTasks mocks base method.
func (m *MockHistoryTaskQueueManager) ReadTasks(ctx context.Context, request *ReadTasksRequest) (*ReadTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadTasks", ctx, request)
	ret0, _ := ret[0].(*ReadTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadTasks indicates an expected call of ReadTasks.
func (mr *MockHistoryTaskQueueManagerMockRecorder) ReadTasks(ctx, request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadTasks", reflect.TypeOf((*MockHistoryTaskQueueManager)(nil).ReadTasks), ctx, request)
}