mock_client.go

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

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

import (
	context "context"
	reflect "reflect"
	time "time"

	remote "github.com/A-Zee029/rocketmq-client-go/v2/internal/remote"
	primitive "github.com/A-Zee029/rocketmq-client-go/v2/primitive"
	gomock "github.com/golang/mock/gomock"
)

// MockInnerProducer is a mock of InnerProducer interface.
type MockInnerProducer struct {
	ctrl     *gomock.Controller
	recorder *MockInnerProducerMockRecorder
}

// MockInnerProducerMockRecorder is the mock recorder for MockInnerProducer.
type MockInnerProducerMockRecorder struct {
	mock *MockInnerProducer
}

// NewMockInnerProducer creates a new mock instance.
func NewMockInnerProducer(ctrl *gomock.Controller) *MockInnerProducer {
	mock := &MockInnerProducer{ctrl: ctrl}
	mock.recorder = &MockInnerProducerMockRecorder{mock}
	return mock
}

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

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

// IsPublishTopicNeedUpdate indicates an expected call of IsPublishTopicNeedUpdate.
func (mr *MockInnerProducerMockRecorder) IsPublishTopicNeedUpdate(topic interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPublishTopicNeedUpdate", reflect.TypeOf((*MockInnerProducer)(nil).IsPublishTopicNeedUpdate), topic)
}

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

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

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

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

// UpdateTopicPublishInfo mocks base method.
func (m *MockInnerProducer) UpdateTopicPublishInfo(topic string, info *TopicPublishInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateTopicPublishInfo", topic, info)
}

// UpdateTopicPublishInfo indicates an expected call of UpdateTopicPublishInfo.
func (mr *MockInnerProducerMockRecorder) UpdateTopicPublishInfo(topic, info interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTopicPublishInfo", reflect.TypeOf((*MockInnerProducer)(nil).UpdateTopicPublishInfo), topic, info)
}

// MockInnerConsumer is a mock of InnerConsumer interface.
type MockInnerConsumer struct {
	ctrl     *gomock.Controller
	recorder *MockInnerConsumerMockRecorder
}

// MockInnerConsumerMockRecorder is the mock recorder for MockInnerConsumer.
type MockInnerConsumerMockRecorder struct {
	mock *MockInnerConsumer
}

// NewMockInnerConsumer creates a new mock instance.
func NewMockInnerConsumer(ctrl *gomock.Controller) *MockInnerConsumer {
	mock := &MockInnerConsumer{ctrl: ctrl}
	mock.recorder = &MockInnerConsumerMockRecorder{mock}
	return mock
}

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

// ConsumeMessageDirectly mocks base method.
func (m *MockInnerConsumer) ConsumeMessageDirectly(msg *primitive.MessageExt, brokerName string) *ConsumeMessageDirectlyResult {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConsumeMessageDirectly", msg, brokerName)
	ret0, _ := ret[0].(*ConsumeMessageDirectlyResult)
	return ret0
}

// ConsumeMessageDirectly indicates an expected call of ConsumeMessageDirectly.
func (mr *MockInnerConsumerMockRecorder) ConsumeMessageDirectly(msg, brokerName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsumeMessageDirectly", reflect.TypeOf((*MockInnerConsumer)(nil).ConsumeMessageDirectly), msg, brokerName)
}

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

// GetConsumerRunningInfo indicates an expected call of GetConsumerRunningInfo.
func (mr *MockInnerConsumerMockRecorder) GetConsumerRunningInfo(stack interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsumerRunningInfo", reflect.TypeOf((*MockInnerConsumer)(nil).GetConsumerRunningInfo), stack)
}

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

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

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

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

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

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

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

// IsSubscribeTopicNeedUpdate indicates an expected call of IsSubscribeTopicNeedUpdate.
func (mr *MockInnerConsumerMockRecorder) IsSubscribeTopicNeedUpdate(topic interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSubscribeTopicNeedUpdate", reflect.TypeOf((*MockInnerConsumer)(nil).IsSubscribeTopicNeedUpdate), topic)
}

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

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

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

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

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

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

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

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

// ResetOffset mocks base method.
func (m *MockInnerConsumer) ResetOffset(topic string, table map[primitive.MessageQueue]int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ResetOffset", topic, table)
}

// ResetOffset indicates an expected call of ResetOffset.
func (mr *MockInnerConsumerMockRecorder) ResetOffset(topic, table interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetOffset", reflect.TypeOf((*MockInnerConsumer)(nil).ResetOffset), topic, table)
}

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

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

// UpdateTopicSubscribeInfo mocks base method.
func (m *MockInnerConsumer) UpdateTopicSubscribeInfo(topic string, mqs []*primitive.MessageQueue) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateTopicSubscribeInfo", topic, mqs)
}

// UpdateTopicSubscribeInfo indicates an expected call of UpdateTopicSubscribeInfo.
func (mr *MockInnerConsumerMockRecorder) UpdateTopicSubscribeInfo(topic, mqs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTopicSubscribeInfo", reflect.TypeOf((*MockInnerConsumer)(nil).UpdateTopicSubscribeInfo), topic, mqs)
}

// MockRMQClient is a mock of RMQClient interface.
type MockRMQClient struct {
	ctrl     *gomock.Controller
	recorder *MockRMQClientMockRecorder
	Namesrv  *MockNamesrvs
}

// MockRMQClientMockRecorder is the mock recorder for MockRMQClient.
type MockRMQClientMockRecorder struct {
	mock *MockRMQClient
}

// NewMockRMQClient creates a new mock instance.
func NewMockRMQClient(ctrl *gomock.Controller) *MockRMQClient {
	mock := &MockRMQClient{ctrl: ctrl}
	mock.recorder = &MockRMQClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// GetNameSrv mocks base method.
func (m *MockRMQClient) GetNameSrv() Namesrvs {
	return m.Namesrv
}

func (m *MockRMQClient) SetNameSrv(mockNamesrvs *MockNamesrvs) {
	m.Namesrv = mockNamesrvs
}

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

// InvokeAsync mocks base method.
func (m *MockRMQClient) InvokeAsync(ctx context.Context, addr string, request *remote.RemotingCommand, f func(*remote.RemotingCommand, error)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InvokeAsync", ctx, addr, request, f)
	ret0, _ := ret[0].(error)
	return ret0
}

// InvokeAsync indicates an expected call of InvokeAsync.
func (mr *MockRMQClientMockRecorder) InvokeAsync(ctx, addr, request, f interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeAsync", reflect.TypeOf((*MockRMQClient)(nil).InvokeAsync), ctx, addr, request, f)
}

// InvokeOneWay mocks base method.
func (m *MockRMQClient) InvokeOneWay(ctx context.Context, addr string, request *remote.RemotingCommand, timeoutMillis time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InvokeOneWay", ctx, addr, request, timeoutMillis)
	ret0, _ := ret[0].(error)
	return ret0
}

// InvokeOneWay indicates an expected call of InvokeOneWay.
func (mr *MockRMQClientMockRecorder) InvokeOneWay(ctx, addr, request, timeoutMillis interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeOneWay", reflect.TypeOf((*MockRMQClient)(nil).InvokeOneWay), ctx, addr, request, timeoutMillis)
}

// InvokeSync mocks base method.
func (m *MockRMQClient) InvokeSync(ctx context.Context, addr string, request *remote.RemotingCommand, timeoutMillis time.Duration) (*remote.RemotingCommand, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InvokeSync", ctx, addr, request, timeoutMillis)
	ret0, _ := ret[0].(*remote.RemotingCommand)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InvokeSync indicates an expected call of InvokeSync.
func (mr *MockRMQClientMockRecorder) InvokeSync(ctx, addr, request, timeoutMillis interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeSync", reflect.TypeOf((*MockRMQClient)(nil).InvokeSync), ctx, addr, request, timeoutMillis)
}

// ProcessSendResponse mocks base method.
func (m *MockRMQClient) ProcessSendResponse(brokerName string, cmd *remote.RemotingCommand, resp *primitive.SendResult, msgs ...*primitive.Message) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{brokerName, cmd, resp}
	for _, a := range msgs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProcessSendResponse", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ProcessSendResponse indicates an expected call of ProcessSendResponse.
func (mr *MockRMQClientMockRecorder) ProcessSendResponse(brokerName, cmd, resp interface{}, msgs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{brokerName, cmd, resp}, msgs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessSendResponse", reflect.TypeOf((*MockRMQClient)(nil).ProcessSendResponse), varargs...)
}

// PullMessage mocks base method.
func (m *MockRMQClient) PullMessage(ctx context.Context, brokerAddrs string, request *PullMessageRequestHeader) (*primitive.PullResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PullMessage", ctx, brokerAddrs, request)
	ret0, _ := ret[0].(*primitive.PullResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// RegisterConsumer mocks base method.
func (m *MockRMQClient) RegisterConsumer(group string, consumer InnerConsumer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterConsumer", group, consumer)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterConsumer indicates an expected call of RegisterConsumer.
func (mr *MockRMQClientMockRecorder) RegisterConsumer(group, consumer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterConsumer", reflect.TypeOf((*MockRMQClient)(nil).RegisterConsumer), group, consumer)
}

// RegisterProducer mocks base method.
func (m *MockRMQClient) RegisterProducer(group string, producer InnerProducer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterProducer", group, producer)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterProducer indicates an expected call of RegisterProducer.
func (mr *MockRMQClientMockRecorder) RegisterProducer(group, producer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterProducer", reflect.TypeOf((*MockRMQClient)(nil).RegisterProducer), group, producer)
}

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

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

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

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

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

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

// UnregisterConsumer mocks base method.
func (m *MockRMQClient) UnregisterConsumer(group string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UnregisterConsumer", group)
}

// UnregisterConsumer indicates an expected call of UnregisterConsumer.
func (mr *MockRMQClientMockRecorder) UnregisterConsumer(group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterConsumer", reflect.TypeOf((*MockRMQClient)(nil).UnregisterConsumer), group)
}

// UnregisterProducer mocks base method.
func (m *MockRMQClient) UnregisterProducer(group string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UnregisterProducer", group)
}

// UnregisterProducer indicates an expected call of UnregisterProducer.
func (mr *MockRMQClientMockRecorder) UnregisterProducer(group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterProducer", reflect.TypeOf((*MockRMQClient)(nil).UnregisterProducer), group)
}

// UpdatePublishInfo mocks base method.
func (m *MockRMQClient) UpdatePublishInfo(topic string, data *TopicRouteData, changed bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdatePublishInfo", topic, data, changed)
}

// UpdatePublishInfo indicates an expected call of UpdatePublishInfo.
func (mr *MockRMQClientMockRecorder) UpdatePublishInfo(topic, data, changed interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePublishInfo", reflect.TypeOf((*MockRMQClient)(nil).UpdatePublishInfo), topic, data, changed)
}

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

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