func (m *MockRMQClient) InvokeSync(ctx context.Context, addr string, request *remote.RemotingCommand, timeoutMillis time.Duration) (*remote.RemotingCommand, error) {
	ret := m.ctrl.Call(m, "InvokeSync", ctx, addr, request, timeoutMillis)
	ret0, _ := ret[0].(*remote.RemotingCommand)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
InvokeSync mocks base method
package internal
import (
	"context"
	"reflect"
	"time"
	"github.com/golang/mock/gomock"
	"github.com/apache/rocketmq-client-go/v2/internal/remote"
	"github.com/apache/rocketmq-client-go/v2/primitive"
)
type MockInnerProducer struct {
	ctrl     *gomock.Controller
	recorder *MockInnerProducerMockRecorder
}
type MockInnerProducerMockRecorder struct {
	mock *MockInnerProducer
}
func NewMockInnerProducer(ctrl *gomock.Controller) *MockInnerProducer {
	mock := &MockInnerProducer{ctrl: ctrl}
	mock.recorder = &MockInnerProducerMockRecorder{mock}
	return mock
}
func (m *MockInnerProducer) EXPECT() *MockInnerProducerMockRecorder {
	return m.recorder
}
func (m *MockInnerProducer) PublishTopicList() []string {
	ret := m.ctrl.Call(m, "PublishTopicList")
	ret0, _ := ret[0].([]string)
	return ret0
}
func (mr *MockInnerProducerMockRecorder) PublishTopicList() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishTopicList", reflect.TypeOf((*MockInnerProducer)(nil).PublishTopicList))
}
func (m *MockInnerProducer) UpdateTopicPublishInfo(topic string, info *TopicPublishInfo) {
	m.ctrl.Call(m, "UpdateTopicPublishInfo", topic, info)
}
func (mr *MockInnerProducerMockRecorder) UpdateTopicPublishInfo(topic, info interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTopicPublishInfo", reflect.TypeOf((*MockInnerProducer)(nil).UpdateTopicPublishInfo), topic, info)
}
func (m *MockInnerProducer) IsPublishTopicNeedUpdate(topic string) bool {
	ret := m.ctrl.Call(m, "IsPublishTopicNeedUpdate", topic)
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockInnerProducerMockRecorder) IsPublishTopicNeedUpdate(topic interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPublishTopicNeedUpdate", reflect.TypeOf((*MockInnerProducer)(nil).IsPublishTopicNeedUpdate), topic)
}
func (m *MockInnerProducer) IsUnitMode() bool {
	ret := m.ctrl.Call(m, "IsUnitMode")
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockInnerProducerMockRecorder) IsUnitMode() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnitMode", reflect.TypeOf((*MockInnerProducer)(nil).IsUnitMode))
}
type MockInnerConsumer struct {
	ctrl     *gomock.Controller
	recorder *MockInnerConsumerMockRecorder
}
type MockInnerConsumerMockRecorder struct {
	mock *MockInnerConsumer
}
func NewMockInnerConsumer(ctrl *gomock.Controller) *MockInnerConsumer {
	mock := &MockInnerConsumer{ctrl: ctrl}
	mock.recorder = &MockInnerConsumerMockRecorder{mock}
	return mock
}
func (m *MockInnerConsumer) EXPECT() *MockInnerConsumerMockRecorder {
	return m.recorder
}
func (m *MockInnerConsumer) PersistConsumerOffset() error {
	ret := m.ctrl.Call(m, "PersistConsumerOffset")
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockInnerConsumerMockRecorder) PersistConsumerOffset() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PersistConsumerOffset", reflect.TypeOf((*MockInnerConsumer)(nil).PersistConsumerOffset))
}
func (m *MockInnerConsumer) UpdateTopicSubscribeInfo(topic string, mqs []*primitive.MessageQueue) {
	m.ctrl.Call(m, "UpdateTopicSubscribeInfo", topic, mqs)
}
func (mr *MockInnerConsumerMockRecorder) UpdateTopicSubscribeInfo(topic, mqs interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTopicSubscribeInfo", reflect.TypeOf((*MockInnerConsumer)(nil).UpdateTopicSubscribeInfo), topic, mqs)
}
func (m *MockInnerConsumer) IsSubscribeTopicNeedUpdate(topic string) bool {
	ret := m.ctrl.Call(m, "IsSubscribeTopicNeedUpdate", topic)
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockInnerConsumerMockRecorder) IsSubscribeTopicNeedUpdate(topic interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSubscribeTopicNeedUpdate", reflect.TypeOf((*MockInnerConsumer)(nil).IsSubscribeTopicNeedUpdate), topic)
}
func (m *MockInnerConsumer) SubscriptionDataList() []*SubscriptionData {
	ret := m.ctrl.Call(m, "SubscriptionDataList")
	ret0, _ := ret[0].([]*SubscriptionData)
	return ret0
}
func (mr *MockInnerConsumerMockRecorder) SubscriptionDataList() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscriptionDataList", reflect.TypeOf((*MockInnerConsumer)(nil).SubscriptionDataList))
}
func (m *MockInnerConsumer) Rebalance() {
	m.ctrl.Call(m, "Rebalance")
}
func (mr *MockInnerConsumerMockRecorder) Rebalance() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rebalance", reflect.TypeOf((*MockInnerConsumer)(nil).Rebalance))
}
func (m *MockInnerConsumer) IsUnitMode() bool {
	ret := m.ctrl.Call(m, "IsUnitMode")
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockInnerConsumerMockRecorder) IsUnitMode() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnitMode", reflect.TypeOf((*MockInnerConsumer)(nil).IsUnitMode))
}
func (m *MockInnerConsumer) GetConsumerRunningInfo() *ConsumerRunningInfo {
	ret := m.ctrl.Call(m, "GetConsumerRunningInfo")
	ret0, _ := ret[0].(*ConsumerRunningInfo)
	return ret0
}
func (mr *MockInnerConsumerMockRecorder) GetConsumerRunningInfo() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsumerRunningInfo", reflect.TypeOf((*MockInnerConsumer)(nil).GetConsumerRunningInfo))
}
type MockRMQClient struct {
	ctrl     *gomock.Controller
	recorder *MockRMQClientMockRecorder
}
type MockRMQClientMockRecorder struct {
	mock *MockRMQClient
}
func NewMockRMQClient(ctrl *gomock.Controller) *MockRMQClient {
	mock := &MockRMQClient{ctrl: ctrl}
	mock.recorder = &MockRMQClientMockRecorder{mock}
	return mock
}
func (m *MockRMQClient) EXPECT() *MockRMQClientMockRecorder {
	return m.recorder
}
func (m *MockRMQClient) Start() {
	m.ctrl.Call(m, "Start")
}
func (mr *MockRMQClientMockRecorder) Start() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockRMQClient)(nil).Start))
}
func (m *MockRMQClient) Shutdown() {
	m.ctrl.Call(m, "Shutdown")
}
func (mr *MockRMQClientMockRecorder) Shutdown() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockRMQClient)(nil).Shutdown))
}
func (m *MockRMQClient) ClientID() string {
	ret := m.ctrl.Call(m, "ClientID")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockRMQClientMockRecorder) ClientID() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockRMQClient)(nil).ClientID))
}
func (m *MockRMQClient) RegisterProducer(group string, producer InnerProducer) {
	m.ctrl.Call(m, "RegisterProducer", group, producer)
}
func (mr *MockRMQClientMockRecorder) RegisterProducer(group, producer interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterProducer", reflect.TypeOf((*MockRMQClient)(nil).RegisterProducer), group, producer)
}
func (m *MockRMQClient) UnregisterProducer(group string) {
	m.ctrl.Call(m, "UnregisterProducer", group)
}
func (mr *MockRMQClientMockRecorder) UnregisterProducer(group interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterProducer", reflect.TypeOf((*MockRMQClient)(nil).UnregisterProducer), group)
}