node_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/m3em/node (interfaces: ServiceNode,Options)

// Copyright (c) 2018 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.

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

import (
	"reflect"
	"time"

	"github.com/m3db/m3/src/cluster/generated/proto/placementpb"
	"github.com/m3db/m3/src/cluster/placement"
	"github.com/m3db/m3/src/cluster/shard"
	"github.com/m3db/m3/src/m3em/build"
	"github.com/m3db/m3x/instrument"
	"github.com/m3db/m3x/retry"

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

// MockServiceNode is a mock of ServiceNode interface
type MockServiceNode struct {
	ctrl     *gomock.Controller
	recorder *MockServiceNodeMockRecorder
}

// MockServiceNodeMockRecorder is the mock recorder for MockServiceNode
type MockServiceNodeMockRecorder struct {
	mock *MockServiceNode
}

// NewMockServiceNode creates a new mock instance
func NewMockServiceNode(ctrl *gomock.Controller) *MockServiceNode {
	mock := &MockServiceNode{ctrl: ctrl}
	mock.recorder = &MockServiceNodeMockRecorder{mock}
	return mock
}

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

// Clone mocks base method
func (m *MockServiceNode) Clone() placement.Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clone")
	ret0, _ := ret[0].(placement.Instance)
	return ret0
}

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

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

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

// DeregisterListener mocks base method
func (m *MockServiceNode) DeregisterListener(arg0 ListenerID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeregisterListener", arg0)
}

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

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

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

// GetRemoteOutput mocks base method
func (m *MockServiceNode) GetRemoteOutput(arg0 RemoteOutputType, arg1 string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRemoteOutput", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Proto mocks base method
func (m *MockServiceNode) Proto() (*placementpb.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proto")
	ret0, _ := ret[0].(*placementpb.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterListener mocks base method
func (m *MockServiceNode) RegisterListener(arg0 Listener) ListenerID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterListener", arg0)
	ret0, _ := ret[0].(ListenerID)
	return ret0
}

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

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

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

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

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

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

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

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

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

// SetPort mocks base method
func (m *MockServiceNode) SetPort(arg0 uint32) placement.Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPort", arg0)
	ret0, _ := ret[0].(placement.Instance)
	return ret0
}

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

// SetShardSetID mocks base method
func (m *MockServiceNode) SetShardSetID(arg0 uint32) placement.Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetShardSetID", arg0)
	ret0, _ := ret[0].(placement.Instance)
	return ret0
}

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

// SetShards mocks base method
func (m *MockServiceNode) SetShards(arg0 shard.Shards) placement.Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetShards", arg0)
	ret0, _ := ret[0].(placement.Instance)
	return ret0
}

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

// SetWeight mocks base method
func (m *MockServiceNode) SetWeight(arg0 uint32) placement.Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetWeight", arg0)
	ret0, _ := ret[0].(placement.Instance)
	return ret0
}

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

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

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

// Setup mocks base method
func (m *MockServiceNode) Setup(arg0 build.ServiceBuild, arg1 build.ServiceConfiguration, arg2 string, arg3 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Setup", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// Setup indicates an expected call of Setup
func (mr *MockServiceNodeMockRecorder) Setup(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Setup", reflect.TypeOf((*MockServiceNode)(nil).Setup), arg0, arg1, arg2, arg3)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// TransferLocalFile mocks base method
func (m *MockServiceNode) TransferLocalFile(arg0 string, arg1 []string, arg2 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferLocalFile", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// MockOptions is a mock of Options interface
type MockOptions struct {
	ctrl     *gomock.Controller
	recorder *MockOptionsMockRecorder
}

// MockOptionsMockRecorder is the mock recorder for MockOptions
type MockOptionsMockRecorder struct {
	mock *MockOptions
}

// NewMockOptions creates a new mock instance
func NewMockOptions(ctrl *gomock.Controller) *MockOptions {
	mock := &MockOptions{ctrl: ctrl}
	mock.recorder = &MockOptionsMockRecorder{mock}
	return mock
}

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

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

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

// InstrumentOptions mocks base method
func (m *MockOptions) InstrumentOptions() instrument.Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstrumentOptions")
	ret0, _ := ret[0].(instrument.Options)
	return ret0
}

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

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

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

// OperationTimeout mocks base method
func (m *MockOptions) OperationTimeout() time.Duration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OperationTimeout")
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

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

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

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

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

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

// SetHeartbeatOptions mocks base method
func (m *MockOptions) SetHeartbeatOptions(arg0 HeartbeatOptions) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeartbeatOptions", arg0)
	ret0, _ := ret[0].(Options)
	return ret0
}

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

// SetInstrumentOptions mocks base method
func (m *MockOptions) SetInstrumentOptions(arg0 instrument.Options) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInstrumentOptions", arg0)
	ret0, _ := ret[0].(Options)
	return ret0
}

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

// SetMaxPullSize mocks base method
func (m *MockOptions) SetMaxPullSize(arg0 int64) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMaxPullSize", arg0)
	ret0, _ := ret[0].(Options)
	return ret0
}

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

// SetOperationTimeout mocks base method
func (m *MockOptions) SetOperationTimeout(arg0 time.Duration) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOperationTimeout", arg0)
	ret0, _ := ret[0].(Options)
	return ret0
}

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

// SetOperatorClientFn mocks base method
func (m *MockOptions) SetOperatorClientFn(arg0 OperatorClientFn) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOperatorClientFn", arg0)
	ret0, _ := ret[0].(Options)
	return ret0
}

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

// SetRetrier mocks base method
func (m *MockOptions) SetRetrier(arg0 retry.Retrier) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRetrier", arg0)
	ret0, _ := ret[0].(Options)
	return ret0
}

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

// SetTransferBufferSize mocks base method
func (m *MockOptions) SetTransferBufferSize(arg0 int) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTransferBufferSize", arg0)
	ret0, _ := ret[0].(Options)
	return ret0
}

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

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

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

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

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