rocketmq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ding...@apache.org
Subject [rocketmq-client-go] branch native updated: [ISSUE #128]update mockgen command line
Date Wed, 24 Jul 2019 03:21:05 GMT
This is an automated email from the ASF dual-hosted git repository.

dinglei pushed a commit to branch native
in repository https://gitbox.apache.org/repos/asf/rocketmq-client-go.git


The following commit(s) were added to refs/heads/native by this push:
     new 86498ea  [ISSUE #128]update mockgen command line
86498ea is described below

commit 86498eafde1bbc70b5bdb2b0445c89d5a84ca138
Author: cloes <wayne511200295@163.com>
AuthorDate: Wed Jul 24 11:21:00 2019 +0800

    [ISSUE #128]update mockgen command line
    
    #128
---
 internal/client.go      |  2 +-
 internal/mock_client.go | 91 +++++++++++++++++++++++++++++++++----------------
 2 files changed, 63 insertions(+), 30 deletions(-)

diff --git a/internal/client.go b/internal/client.go
index ff4157d..558c28d 100644
--- a/internal/client.go
+++ b/internal/client.go
@@ -119,7 +119,7 @@ func (opt *ClientOptions) String() string {
 		opt.InstanceName, opt.UnitMode, opt.UnitName, opt.VIPChannelEnabled, opt.ACLEnabled)
 }
 
-//go:generate mockgen -source client.go -destination mock_client.go --package internal RMQClient
+//go:generate mockgen -source client.go -destination mock_client.go -self_package github.com/apache/rocketmq-client-go/internal
 --package internal RMQClient
 type RMQClient interface {
 	Start()
 	Shutdown()
diff --git a/internal/mock_client.go b/internal/mock_client.go
index 3ee3f50..825c9e4 100644
--- a/internal/mock_client.go
+++ b/internal/mock_client.go
@@ -38,6 +38,7 @@ func (m *MockInnerProducer) EXPECT() *MockInnerProducerMockRecorder {
 
 // 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
@@ -45,21 +46,25 @@ func (m *MockInnerProducer) PublishTopicList() []string {
 
 // 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)
 }
 
 // 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
@@ -67,11 +72,13 @@ func (m *MockInnerProducer) IsPublishTopicNeedUpdate(topic string) bool
{
 
 // 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
@@ -79,6 +86,7 @@ func (m *MockInnerProducer) IsUnitMode() bool {
 
 // 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))
 }
 
@@ -106,27 +114,34 @@ func (m *MockInnerConsumer) EXPECT() *MockInnerConsumerMockRecorder
{
 }
 
 // PersistConsumerOffset mocks base method
-func (m *MockInnerConsumer) PersistConsumerOffset() {
-	m.ctrl.Call(m, "PersistConsumerOffset")
+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))
 }
 
 // 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)
 }
 
 // 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
@@ -134,11 +149,13 @@ func (m *MockInnerConsumer) IsSubscribeTopicNeedUpdate(topic string)
bool {
 
 // 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)
 }
 
 // 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
@@ -146,21 +163,25 @@ func (m *MockInnerConsumer) SubscriptionDataList() []*SubscriptionData
{
 
 // 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))
 }
 
 // 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))
 }
 
 // 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
@@ -168,6 +189,7 @@ func (m *MockInnerConsumer) IsUnitMode() bool {
 
 // 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))
 }
 
@@ -196,26 +218,31 @@ func (m *MockRMQClient) EXPECT() *MockRMQClientMockRecorder {
 
 // 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))
 }
 
 // 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))
 }
 
 // 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
@@ -223,21 +250,25 @@ func (m *MockRMQClient) ClientID() string {
 
 // 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))
 }
 
 // RegisterProducer mocks base method
 func (m *MockRMQClient) RegisterProducer(group string, producer InnerProducer) {
+	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RegisterProducer", group, producer)
 }
 
 // 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)
 }
 
 // InvokeSync mocks base method
 func (m *MockRMQClient) InvokeSync(addr string, request *remote.RemotingCommand, timeoutMillis
time.Duration) (*remote.RemotingCommand, error) {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "InvokeSync", addr, request, timeoutMillis)
 	ret0, _ := ret[0].(*remote.RemotingCommand)
 	ret1, _ := ret[1].(error)
@@ -246,11 +277,13 @@ func (m *MockRMQClient) InvokeSync(addr string, request *remote.RemotingCommand,
 
 // InvokeSync indicates an expected call of InvokeSync
 func (mr *MockRMQClientMockRecorder) InvokeSync(addr, request, timeoutMillis interface{})
*gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeSync", reflect.TypeOf((*MockRMQClient)(nil).InvokeSync),
addr, request, timeoutMillis)
 }
 
 // InvokeAsync mocks base method
 func (m *MockRMQClient) InvokeAsync(addr string, request *remote.RemotingCommand, timeoutMillis
time.Duration, f func(*remote.RemotingCommand, error)) error {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "InvokeAsync", addr, request, timeoutMillis, f)
 	ret0, _ := ret[0].(error)
 	return ret0
@@ -258,11 +291,13 @@ func (m *MockRMQClient) InvokeAsync(addr string, request *remote.RemotingCommand
 
 // InvokeAsync indicates an expected call of InvokeAsync
 func (mr *MockRMQClientMockRecorder) InvokeAsync(addr, request, timeoutMillis, f interface{})
*gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeAsync", reflect.TypeOf((*MockRMQClient)(nil).InvokeAsync),
addr, request, timeoutMillis, f)
 }
 
 // InvokeOneWay mocks base method
 func (m *MockRMQClient) InvokeOneWay(addr string, request *remote.RemotingCommand, timeoutMillis
time.Duration) error {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "InvokeOneWay", addr, request, timeoutMillis)
 	ret0, _ := ret[0].(error)
 	return ret0
@@ -270,81 +305,68 @@ func (m *MockRMQClient) InvokeOneWay(addr string, request *remote.RemotingComman
 
 // InvokeOneWay indicates an expected call of InvokeOneWay
 func (mr *MockRMQClientMockRecorder) InvokeOneWay(addr, request, timeoutMillis interface{})
*gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeOneWay", reflect.TypeOf((*MockRMQClient)(nil).InvokeOneWay),
addr, request, timeoutMillis)
 }
 
 // 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))
 }
 
 // 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))
 }
 
 // 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))
 }
 
-// SendMessageAsync mocks base method
-func (m *MockRMQClient) SendMessageAsync(ctx context.Context, brokerAddrs, brokerName string,
request *SendMessageRequest, msgs []*primitive.Message, f func(*primitive.SendResult)) error
{
-	ret := m.ctrl.Call(m, "SendMessageAsync", ctx, brokerAddrs, brokerName, request, msgs, f)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SendMessageAsync indicates an expected call of SendMessageAsync
-func (mr *MockRMQClientMockRecorder) SendMessageAsync(ctx, brokerAddrs, brokerName, request,
msgs, f interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageAsync", reflect.TypeOf((*MockRMQClient)(nil).SendMessageAsync),
ctx, brokerAddrs, brokerName, request, msgs, f)
-}
-
-// SendMessageOneWay mocks base method
-func (m *MockRMQClient) SendMessageOneWay(ctx context.Context, brokerAddrs string, request
*SendMessageRequest, msgs []*primitive.Message) (*primitive.SendResult, error) {
-	ret := m.ctrl.Call(m, "SendMessageOneWay", ctx, brokerAddrs, request, msgs)
-	ret0, _ := ret[0].(*primitive.SendResult)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SendMessageOneWay indicates an expected call of SendMessageOneWay
-func (mr *MockRMQClientMockRecorder) SendMessageOneWay(ctx, brokerAddrs, request, msgs interface{})
*gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageOneWay", reflect.TypeOf((*MockRMQClient)(nil).SendMessageOneWay),
ctx, brokerAddrs, request, msgs)
-}
-
 // ProcessSendResponse mocks base method
-func (m *MockRMQClient) ProcessSendResponse(brokerName string, cmd *remote.RemotingCommand,
resp *primitive.SendResult, msgs ...*primitive.Message) {
+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)
 	}
-	m.ctrl.Call(m, "ProcessSendResponse", varargs...)
+	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...)
 }
 
 // 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
@@ -352,21 +374,25 @@ func (m *MockRMQClient) RegisterConsumer(group string, consumer InnerConsumer)
e
 
 // 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)
 }
 
 // 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)
 }
 
 // PullMessage mocks base method
 func (m *MockRMQClient) PullMessage(ctx context.Context, brokerAddrs string, request *PullMessageRequest)
(*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)
@@ -375,11 +401,13 @@ func (m *MockRMQClient) PullMessage(ctx context.Context, brokerAddrs
string, req
 
 // 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)
 }
 
 // PullMessageAsync mocks base method
 func (m *MockRMQClient) PullMessageAsync(ctx context.Context, brokerAddrs string, request
*PullMessageRequest, f func(*primitive.PullResult)) error {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PullMessageAsync", ctx, brokerAddrs, request, f)
 	ret0, _ := ret[0].(error)
 	return ret0
@@ -387,25 +415,30 @@ func (m *MockRMQClient) PullMessageAsync(ctx context.Context, brokerAddrs
string
 
 // PullMessageAsync indicates an expected call of PullMessageAsync
 func (mr *MockRMQClientMockRecorder) PullMessageAsync(ctx, brokerAddrs, request, f interface{})
*gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullMessageAsync", reflect.TypeOf((*MockRMQClient)(nil).PullMessageAsync),
ctx, brokerAddrs, request, f)
 }
 
 // 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))
 }
 
 // UpdatePublishInfo mocks base method
 func (m *MockRMQClient) UpdatePublishInfo(topic string, data *TopicRouteData) {
+	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatePublishInfo", topic, data)
 }
 
 // UpdatePublishInfo indicates an expected call of UpdatePublishInfo
 func (mr *MockRMQClientMockRecorder) UpdatePublishInfo(topic, data interface{}) *gomock.Call
{
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePublishInfo", reflect.TypeOf((*MockRMQClient)(nil).UpdatePublishInfo),
topic, data)
 }


Mime
View raw message