github.com/enbility/spine-go@v0.7.0/mocks/SenderInterface.go (about)

     1  // Code generated by mockery v2.45.0. DO NOT EDIT.
     2  
     3  package mocks
     4  
     5  import (
     6  	model "github.com/enbility/spine-go/model"
     7  	mock "github.com/stretchr/testify/mock"
     8  )
     9  
    10  // SenderInterface is an autogenerated mock type for the SenderInterface type
    11  type SenderInterface struct {
    12  	mock.Mock
    13  }
    14  
    15  type SenderInterface_Expecter struct {
    16  	mock *mock.Mock
    17  }
    18  
    19  func (_m *SenderInterface) EXPECT() *SenderInterface_Expecter {
    20  	return &SenderInterface_Expecter{mock: &_m.Mock}
    21  }
    22  
    23  // Bind provides a mock function with given fields: senderAddress, destinationAddress, serverFeatureType
    24  func (_m *SenderInterface) Bind(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, serverFeatureType model.FeatureTypeType) (*model.MsgCounterType, error) {
    25  	ret := _m.Called(senderAddress, destinationAddress, serverFeatureType)
    26  
    27  	if len(ret) == 0 {
    28  		panic("no return value specified for Bind")
    29  	}
    30  
    31  	var r0 *model.MsgCounterType
    32  	var r1 error
    33  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) (*model.MsgCounterType, error)); ok {
    34  		return rf(senderAddress, destinationAddress, serverFeatureType)
    35  	}
    36  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) *model.MsgCounterType); ok {
    37  		r0 = rf(senderAddress, destinationAddress, serverFeatureType)
    38  	} else {
    39  		if ret.Get(0) != nil {
    40  			r0 = ret.Get(0).(*model.MsgCounterType)
    41  		}
    42  	}
    43  
    44  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) error); ok {
    45  		r1 = rf(senderAddress, destinationAddress, serverFeatureType)
    46  	} else {
    47  		r1 = ret.Error(1)
    48  	}
    49  
    50  	return r0, r1
    51  }
    52  
    53  // SenderInterface_Bind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bind'
    54  type SenderInterface_Bind_Call struct {
    55  	*mock.Call
    56  }
    57  
    58  // Bind is a helper method to define mock.On call
    59  //   - senderAddress *model.FeatureAddressType
    60  //   - destinationAddress *model.FeatureAddressType
    61  //   - serverFeatureType model.FeatureTypeType
    62  func (_e *SenderInterface_Expecter) Bind(senderAddress interface{}, destinationAddress interface{}, serverFeatureType interface{}) *SenderInterface_Bind_Call {
    63  	return &SenderInterface_Bind_Call{Call: _e.mock.On("Bind", senderAddress, destinationAddress, serverFeatureType)}
    64  }
    65  
    66  func (_c *SenderInterface_Bind_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, serverFeatureType model.FeatureTypeType)) *SenderInterface_Bind_Call {
    67  	_c.Call.Run(func(args mock.Arguments) {
    68  		run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType), args[2].(model.FeatureTypeType))
    69  	})
    70  	return _c
    71  }
    72  
    73  func (_c *SenderInterface_Bind_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Bind_Call {
    74  	_c.Call.Return(_a0, _a1)
    75  	return _c
    76  }
    77  
    78  func (_c *SenderInterface_Bind_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) (*model.MsgCounterType, error)) *SenderInterface_Bind_Call {
    79  	_c.Call.Return(run)
    80  	return _c
    81  }
    82  
    83  // DatagramForMsgCounter provides a mock function with given fields: msgCounter
    84  func (_m *SenderInterface) DatagramForMsgCounter(msgCounter model.MsgCounterType) (model.DatagramType, error) {
    85  	ret := _m.Called(msgCounter)
    86  
    87  	if len(ret) == 0 {
    88  		panic("no return value specified for DatagramForMsgCounter")
    89  	}
    90  
    91  	var r0 model.DatagramType
    92  	var r1 error
    93  	if rf, ok := ret.Get(0).(func(model.MsgCounterType) (model.DatagramType, error)); ok {
    94  		return rf(msgCounter)
    95  	}
    96  	if rf, ok := ret.Get(0).(func(model.MsgCounterType) model.DatagramType); ok {
    97  		r0 = rf(msgCounter)
    98  	} else {
    99  		r0 = ret.Get(0).(model.DatagramType)
   100  	}
   101  
   102  	if rf, ok := ret.Get(1).(func(model.MsgCounterType) error); ok {
   103  		r1 = rf(msgCounter)
   104  	} else {
   105  		r1 = ret.Error(1)
   106  	}
   107  
   108  	return r0, r1
   109  }
   110  
   111  // SenderInterface_DatagramForMsgCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DatagramForMsgCounter'
   112  type SenderInterface_DatagramForMsgCounter_Call struct {
   113  	*mock.Call
   114  }
   115  
   116  // DatagramForMsgCounter is a helper method to define mock.On call
   117  //   - msgCounter model.MsgCounterType
   118  func (_e *SenderInterface_Expecter) DatagramForMsgCounter(msgCounter interface{}) *SenderInterface_DatagramForMsgCounter_Call {
   119  	return &SenderInterface_DatagramForMsgCounter_Call{Call: _e.mock.On("DatagramForMsgCounter", msgCounter)}
   120  }
   121  
   122  func (_c *SenderInterface_DatagramForMsgCounter_Call) Run(run func(msgCounter model.MsgCounterType)) *SenderInterface_DatagramForMsgCounter_Call {
   123  	_c.Call.Run(func(args mock.Arguments) {
   124  		run(args[0].(model.MsgCounterType))
   125  	})
   126  	return _c
   127  }
   128  
   129  func (_c *SenderInterface_DatagramForMsgCounter_Call) Return(_a0 model.DatagramType, _a1 error) *SenderInterface_DatagramForMsgCounter_Call {
   130  	_c.Call.Return(_a0, _a1)
   131  	return _c
   132  }
   133  
   134  func (_c *SenderInterface_DatagramForMsgCounter_Call) RunAndReturn(run func(model.MsgCounterType) (model.DatagramType, error)) *SenderInterface_DatagramForMsgCounter_Call {
   135  	_c.Call.Return(run)
   136  	return _c
   137  }
   138  
   139  // Notify provides a mock function with given fields: senderAddress, destinationAddress, cmd
   140  func (_m *SenderInterface) Notify(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, cmd model.CmdType) (*model.MsgCounterType, error) {
   141  	ret := _m.Called(senderAddress, destinationAddress, cmd)
   142  
   143  	if len(ret) == 0 {
   144  		panic("no return value specified for Notify")
   145  	}
   146  
   147  	var r0 *model.MsgCounterType
   148  	var r1 error
   149  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) (*model.MsgCounterType, error)); ok {
   150  		return rf(senderAddress, destinationAddress, cmd)
   151  	}
   152  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) *model.MsgCounterType); ok {
   153  		r0 = rf(senderAddress, destinationAddress, cmd)
   154  	} else {
   155  		if ret.Get(0) != nil {
   156  			r0 = ret.Get(0).(*model.MsgCounterType)
   157  		}
   158  	}
   159  
   160  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) error); ok {
   161  		r1 = rf(senderAddress, destinationAddress, cmd)
   162  	} else {
   163  		r1 = ret.Error(1)
   164  	}
   165  
   166  	return r0, r1
   167  }
   168  
   169  // SenderInterface_Notify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Notify'
   170  type SenderInterface_Notify_Call struct {
   171  	*mock.Call
   172  }
   173  
   174  // Notify is a helper method to define mock.On call
   175  //   - senderAddress *model.FeatureAddressType
   176  //   - destinationAddress *model.FeatureAddressType
   177  //   - cmd model.CmdType
   178  func (_e *SenderInterface_Expecter) Notify(senderAddress interface{}, destinationAddress interface{}, cmd interface{}) *SenderInterface_Notify_Call {
   179  	return &SenderInterface_Notify_Call{Call: _e.mock.On("Notify", senderAddress, destinationAddress, cmd)}
   180  }
   181  
   182  func (_c *SenderInterface_Notify_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, cmd model.CmdType)) *SenderInterface_Notify_Call {
   183  	_c.Call.Run(func(args mock.Arguments) {
   184  		run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType), args[2].(model.CmdType))
   185  	})
   186  	return _c
   187  }
   188  
   189  func (_c *SenderInterface_Notify_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Notify_Call {
   190  	_c.Call.Return(_a0, _a1)
   191  	return _c
   192  }
   193  
   194  func (_c *SenderInterface_Notify_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) (*model.MsgCounterType, error)) *SenderInterface_Notify_Call {
   195  	_c.Call.Return(run)
   196  	return _c
   197  }
   198  
   199  // ProcessResponseForMsgCounterReference provides a mock function with given fields: msgCounterRef
   200  func (_m *SenderInterface) ProcessResponseForMsgCounterReference(msgCounterRef *model.MsgCounterType) {
   201  	_m.Called(msgCounterRef)
   202  }
   203  
   204  // SenderInterface_ProcessResponseForMsgCounterReference_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProcessResponseForMsgCounterReference'
   205  type SenderInterface_ProcessResponseForMsgCounterReference_Call struct {
   206  	*mock.Call
   207  }
   208  
   209  // ProcessResponseForMsgCounterReference is a helper method to define mock.On call
   210  //   - msgCounterRef *model.MsgCounterType
   211  func (_e *SenderInterface_Expecter) ProcessResponseForMsgCounterReference(msgCounterRef interface{}) *SenderInterface_ProcessResponseForMsgCounterReference_Call {
   212  	return &SenderInterface_ProcessResponseForMsgCounterReference_Call{Call: _e.mock.On("ProcessResponseForMsgCounterReference", msgCounterRef)}
   213  }
   214  
   215  func (_c *SenderInterface_ProcessResponseForMsgCounterReference_Call) Run(run func(msgCounterRef *model.MsgCounterType)) *SenderInterface_ProcessResponseForMsgCounterReference_Call {
   216  	_c.Call.Run(func(args mock.Arguments) {
   217  		run(args[0].(*model.MsgCounterType))
   218  	})
   219  	return _c
   220  }
   221  
   222  func (_c *SenderInterface_ProcessResponseForMsgCounterReference_Call) Return() *SenderInterface_ProcessResponseForMsgCounterReference_Call {
   223  	_c.Call.Return()
   224  	return _c
   225  }
   226  
   227  func (_c *SenderInterface_ProcessResponseForMsgCounterReference_Call) RunAndReturn(run func(*model.MsgCounterType)) *SenderInterface_ProcessResponseForMsgCounterReference_Call {
   228  	_c.Call.Return(run)
   229  	return _c
   230  }
   231  
   232  // Reply provides a mock function with given fields: requestHeader, senderAddress, cmd
   233  func (_m *SenderInterface) Reply(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType, cmd model.CmdType) error {
   234  	ret := _m.Called(requestHeader, senderAddress, cmd)
   235  
   236  	if len(ret) == 0 {
   237  		panic("no return value specified for Reply")
   238  	}
   239  
   240  	var r0 error
   241  	if rf, ok := ret.Get(0).(func(*model.HeaderType, *model.FeatureAddressType, model.CmdType) error); ok {
   242  		r0 = rf(requestHeader, senderAddress, cmd)
   243  	} else {
   244  		r0 = ret.Error(0)
   245  	}
   246  
   247  	return r0
   248  }
   249  
   250  // SenderInterface_Reply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reply'
   251  type SenderInterface_Reply_Call struct {
   252  	*mock.Call
   253  }
   254  
   255  // Reply is a helper method to define mock.On call
   256  //   - requestHeader *model.HeaderType
   257  //   - senderAddress *model.FeatureAddressType
   258  //   - cmd model.CmdType
   259  func (_e *SenderInterface_Expecter) Reply(requestHeader interface{}, senderAddress interface{}, cmd interface{}) *SenderInterface_Reply_Call {
   260  	return &SenderInterface_Reply_Call{Call: _e.mock.On("Reply", requestHeader, senderAddress, cmd)}
   261  }
   262  
   263  func (_c *SenderInterface_Reply_Call) Run(run func(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType, cmd model.CmdType)) *SenderInterface_Reply_Call {
   264  	_c.Call.Run(func(args mock.Arguments) {
   265  		run(args[0].(*model.HeaderType), args[1].(*model.FeatureAddressType), args[2].(model.CmdType))
   266  	})
   267  	return _c
   268  }
   269  
   270  func (_c *SenderInterface_Reply_Call) Return(_a0 error) *SenderInterface_Reply_Call {
   271  	_c.Call.Return(_a0)
   272  	return _c
   273  }
   274  
   275  func (_c *SenderInterface_Reply_Call) RunAndReturn(run func(*model.HeaderType, *model.FeatureAddressType, model.CmdType) error) *SenderInterface_Reply_Call {
   276  	_c.Call.Return(run)
   277  	return _c
   278  }
   279  
   280  // Request provides a mock function with given fields: cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd
   281  func (_m *SenderInterface) Request(cmdClassifier model.CmdClassifierType, senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, ackRequest bool, cmd []model.CmdType) (*model.MsgCounterType, error) {
   282  	ret := _m.Called(cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd)
   283  
   284  	if len(ret) == 0 {
   285  		panic("no return value specified for Request")
   286  	}
   287  
   288  	var r0 *model.MsgCounterType
   289  	var r1 error
   290  	if rf, ok := ret.Get(0).(func(model.CmdClassifierType, *model.FeatureAddressType, *model.FeatureAddressType, bool, []model.CmdType) (*model.MsgCounterType, error)); ok {
   291  		return rf(cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd)
   292  	}
   293  	if rf, ok := ret.Get(0).(func(model.CmdClassifierType, *model.FeatureAddressType, *model.FeatureAddressType, bool, []model.CmdType) *model.MsgCounterType); ok {
   294  		r0 = rf(cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd)
   295  	} else {
   296  		if ret.Get(0) != nil {
   297  			r0 = ret.Get(0).(*model.MsgCounterType)
   298  		}
   299  	}
   300  
   301  	if rf, ok := ret.Get(1).(func(model.CmdClassifierType, *model.FeatureAddressType, *model.FeatureAddressType, bool, []model.CmdType) error); ok {
   302  		r1 = rf(cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd)
   303  	} else {
   304  		r1 = ret.Error(1)
   305  	}
   306  
   307  	return r0, r1
   308  }
   309  
   310  // SenderInterface_Request_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Request'
   311  type SenderInterface_Request_Call struct {
   312  	*mock.Call
   313  }
   314  
   315  // Request is a helper method to define mock.On call
   316  //   - cmdClassifier model.CmdClassifierType
   317  //   - senderAddress *model.FeatureAddressType
   318  //   - destinationAddress *model.FeatureAddressType
   319  //   - ackRequest bool
   320  //   - cmd []model.CmdType
   321  func (_e *SenderInterface_Expecter) Request(cmdClassifier interface{}, senderAddress interface{}, destinationAddress interface{}, ackRequest interface{}, cmd interface{}) *SenderInterface_Request_Call {
   322  	return &SenderInterface_Request_Call{Call: _e.mock.On("Request", cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd)}
   323  }
   324  
   325  func (_c *SenderInterface_Request_Call) Run(run func(cmdClassifier model.CmdClassifierType, senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, ackRequest bool, cmd []model.CmdType)) *SenderInterface_Request_Call {
   326  	_c.Call.Run(func(args mock.Arguments) {
   327  		run(args[0].(model.CmdClassifierType), args[1].(*model.FeatureAddressType), args[2].(*model.FeatureAddressType), args[3].(bool), args[4].([]model.CmdType))
   328  	})
   329  	return _c
   330  }
   331  
   332  func (_c *SenderInterface_Request_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Request_Call {
   333  	_c.Call.Return(_a0, _a1)
   334  	return _c
   335  }
   336  
   337  func (_c *SenderInterface_Request_Call) RunAndReturn(run func(model.CmdClassifierType, *model.FeatureAddressType, *model.FeatureAddressType, bool, []model.CmdType) (*model.MsgCounterType, error)) *SenderInterface_Request_Call {
   338  	_c.Call.Return(run)
   339  	return _c
   340  }
   341  
   342  // ResultError provides a mock function with given fields: requestHeader, senderAddress, err
   343  func (_m *SenderInterface) ResultError(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType, err *model.ErrorType) error {
   344  	ret := _m.Called(requestHeader, senderAddress, err)
   345  
   346  	if len(ret) == 0 {
   347  		panic("no return value specified for ResultError")
   348  	}
   349  
   350  	var r0 error
   351  	if rf, ok := ret.Get(0).(func(*model.HeaderType, *model.FeatureAddressType, *model.ErrorType) error); ok {
   352  		r0 = rf(requestHeader, senderAddress, err)
   353  	} else {
   354  		r0 = ret.Error(0)
   355  	}
   356  
   357  	return r0
   358  }
   359  
   360  // SenderInterface_ResultError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResultError'
   361  type SenderInterface_ResultError_Call struct {
   362  	*mock.Call
   363  }
   364  
   365  // ResultError is a helper method to define mock.On call
   366  //   - requestHeader *model.HeaderType
   367  //   - senderAddress *model.FeatureAddressType
   368  //   - err *model.ErrorType
   369  func (_e *SenderInterface_Expecter) ResultError(requestHeader interface{}, senderAddress interface{}, err interface{}) *SenderInterface_ResultError_Call {
   370  	return &SenderInterface_ResultError_Call{Call: _e.mock.On("ResultError", requestHeader, senderAddress, err)}
   371  }
   372  
   373  func (_c *SenderInterface_ResultError_Call) Run(run func(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType, err *model.ErrorType)) *SenderInterface_ResultError_Call {
   374  	_c.Call.Run(func(args mock.Arguments) {
   375  		run(args[0].(*model.HeaderType), args[1].(*model.FeatureAddressType), args[2].(*model.ErrorType))
   376  	})
   377  	return _c
   378  }
   379  
   380  func (_c *SenderInterface_ResultError_Call) Return(_a0 error) *SenderInterface_ResultError_Call {
   381  	_c.Call.Return(_a0)
   382  	return _c
   383  }
   384  
   385  func (_c *SenderInterface_ResultError_Call) RunAndReturn(run func(*model.HeaderType, *model.FeatureAddressType, *model.ErrorType) error) *SenderInterface_ResultError_Call {
   386  	_c.Call.Return(run)
   387  	return _c
   388  }
   389  
   390  // ResultSuccess provides a mock function with given fields: requestHeader, senderAddress
   391  func (_m *SenderInterface) ResultSuccess(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType) error {
   392  	ret := _m.Called(requestHeader, senderAddress)
   393  
   394  	if len(ret) == 0 {
   395  		panic("no return value specified for ResultSuccess")
   396  	}
   397  
   398  	var r0 error
   399  	if rf, ok := ret.Get(0).(func(*model.HeaderType, *model.FeatureAddressType) error); ok {
   400  		r0 = rf(requestHeader, senderAddress)
   401  	} else {
   402  		r0 = ret.Error(0)
   403  	}
   404  
   405  	return r0
   406  }
   407  
   408  // SenderInterface_ResultSuccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResultSuccess'
   409  type SenderInterface_ResultSuccess_Call struct {
   410  	*mock.Call
   411  }
   412  
   413  // ResultSuccess is a helper method to define mock.On call
   414  //   - requestHeader *model.HeaderType
   415  //   - senderAddress *model.FeatureAddressType
   416  func (_e *SenderInterface_Expecter) ResultSuccess(requestHeader interface{}, senderAddress interface{}) *SenderInterface_ResultSuccess_Call {
   417  	return &SenderInterface_ResultSuccess_Call{Call: _e.mock.On("ResultSuccess", requestHeader, senderAddress)}
   418  }
   419  
   420  func (_c *SenderInterface_ResultSuccess_Call) Run(run func(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType)) *SenderInterface_ResultSuccess_Call {
   421  	_c.Call.Run(func(args mock.Arguments) {
   422  		run(args[0].(*model.HeaderType), args[1].(*model.FeatureAddressType))
   423  	})
   424  	return _c
   425  }
   426  
   427  func (_c *SenderInterface_ResultSuccess_Call) Return(_a0 error) *SenderInterface_ResultSuccess_Call {
   428  	_c.Call.Return(_a0)
   429  	return _c
   430  }
   431  
   432  func (_c *SenderInterface_ResultSuccess_Call) RunAndReturn(run func(*model.HeaderType, *model.FeatureAddressType) error) *SenderInterface_ResultSuccess_Call {
   433  	_c.Call.Return(run)
   434  	return _c
   435  }
   436  
   437  // Subscribe provides a mock function with given fields: senderAddress, destinationAddress, serverFeatureType
   438  func (_m *SenderInterface) Subscribe(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, serverFeatureType model.FeatureTypeType) (*model.MsgCounterType, error) {
   439  	ret := _m.Called(senderAddress, destinationAddress, serverFeatureType)
   440  
   441  	if len(ret) == 0 {
   442  		panic("no return value specified for Subscribe")
   443  	}
   444  
   445  	var r0 *model.MsgCounterType
   446  	var r1 error
   447  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) (*model.MsgCounterType, error)); ok {
   448  		return rf(senderAddress, destinationAddress, serverFeatureType)
   449  	}
   450  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) *model.MsgCounterType); ok {
   451  		r0 = rf(senderAddress, destinationAddress, serverFeatureType)
   452  	} else {
   453  		if ret.Get(0) != nil {
   454  			r0 = ret.Get(0).(*model.MsgCounterType)
   455  		}
   456  	}
   457  
   458  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) error); ok {
   459  		r1 = rf(senderAddress, destinationAddress, serverFeatureType)
   460  	} else {
   461  		r1 = ret.Error(1)
   462  	}
   463  
   464  	return r0, r1
   465  }
   466  
   467  // SenderInterface_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
   468  type SenderInterface_Subscribe_Call struct {
   469  	*mock.Call
   470  }
   471  
   472  // Subscribe is a helper method to define mock.On call
   473  //   - senderAddress *model.FeatureAddressType
   474  //   - destinationAddress *model.FeatureAddressType
   475  //   - serverFeatureType model.FeatureTypeType
   476  func (_e *SenderInterface_Expecter) Subscribe(senderAddress interface{}, destinationAddress interface{}, serverFeatureType interface{}) *SenderInterface_Subscribe_Call {
   477  	return &SenderInterface_Subscribe_Call{Call: _e.mock.On("Subscribe", senderAddress, destinationAddress, serverFeatureType)}
   478  }
   479  
   480  func (_c *SenderInterface_Subscribe_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, serverFeatureType model.FeatureTypeType)) *SenderInterface_Subscribe_Call {
   481  	_c.Call.Run(func(args mock.Arguments) {
   482  		run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType), args[2].(model.FeatureTypeType))
   483  	})
   484  	return _c
   485  }
   486  
   487  func (_c *SenderInterface_Subscribe_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Subscribe_Call {
   488  	_c.Call.Return(_a0, _a1)
   489  	return _c
   490  }
   491  
   492  func (_c *SenderInterface_Subscribe_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) (*model.MsgCounterType, error)) *SenderInterface_Subscribe_Call {
   493  	_c.Call.Return(run)
   494  	return _c
   495  }
   496  
   497  // Unbind provides a mock function with given fields: senderAddress, destinationAddress
   498  func (_m *SenderInterface) Unbind(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType) (*model.MsgCounterType, error) {
   499  	ret := _m.Called(senderAddress, destinationAddress)
   500  
   501  	if len(ret) == 0 {
   502  		panic("no return value specified for Unbind")
   503  	}
   504  
   505  	var r0 *model.MsgCounterType
   506  	var r1 error
   507  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType) (*model.MsgCounterType, error)); ok {
   508  		return rf(senderAddress, destinationAddress)
   509  	}
   510  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType) *model.MsgCounterType); ok {
   511  		r0 = rf(senderAddress, destinationAddress)
   512  	} else {
   513  		if ret.Get(0) != nil {
   514  			r0 = ret.Get(0).(*model.MsgCounterType)
   515  		}
   516  	}
   517  
   518  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType) error); ok {
   519  		r1 = rf(senderAddress, destinationAddress)
   520  	} else {
   521  		r1 = ret.Error(1)
   522  	}
   523  
   524  	return r0, r1
   525  }
   526  
   527  // SenderInterface_Unbind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unbind'
   528  type SenderInterface_Unbind_Call struct {
   529  	*mock.Call
   530  }
   531  
   532  // Unbind is a helper method to define mock.On call
   533  //   - senderAddress *model.FeatureAddressType
   534  //   - destinationAddress *model.FeatureAddressType
   535  func (_e *SenderInterface_Expecter) Unbind(senderAddress interface{}, destinationAddress interface{}) *SenderInterface_Unbind_Call {
   536  	return &SenderInterface_Unbind_Call{Call: _e.mock.On("Unbind", senderAddress, destinationAddress)}
   537  }
   538  
   539  func (_c *SenderInterface_Unbind_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType)) *SenderInterface_Unbind_Call {
   540  	_c.Call.Run(func(args mock.Arguments) {
   541  		run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType))
   542  	})
   543  	return _c
   544  }
   545  
   546  func (_c *SenderInterface_Unbind_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Unbind_Call {
   547  	_c.Call.Return(_a0, _a1)
   548  	return _c
   549  }
   550  
   551  func (_c *SenderInterface_Unbind_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType) (*model.MsgCounterType, error)) *SenderInterface_Unbind_Call {
   552  	_c.Call.Return(run)
   553  	return _c
   554  }
   555  
   556  // Unsubscribe provides a mock function with given fields: senderAddress, destinationAddress
   557  func (_m *SenderInterface) Unsubscribe(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType) (*model.MsgCounterType, error) {
   558  	ret := _m.Called(senderAddress, destinationAddress)
   559  
   560  	if len(ret) == 0 {
   561  		panic("no return value specified for Unsubscribe")
   562  	}
   563  
   564  	var r0 *model.MsgCounterType
   565  	var r1 error
   566  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType) (*model.MsgCounterType, error)); ok {
   567  		return rf(senderAddress, destinationAddress)
   568  	}
   569  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType) *model.MsgCounterType); ok {
   570  		r0 = rf(senderAddress, destinationAddress)
   571  	} else {
   572  		if ret.Get(0) != nil {
   573  			r0 = ret.Get(0).(*model.MsgCounterType)
   574  		}
   575  	}
   576  
   577  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType) error); ok {
   578  		r1 = rf(senderAddress, destinationAddress)
   579  	} else {
   580  		r1 = ret.Error(1)
   581  	}
   582  
   583  	return r0, r1
   584  }
   585  
   586  // SenderInterface_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe'
   587  type SenderInterface_Unsubscribe_Call struct {
   588  	*mock.Call
   589  }
   590  
   591  // Unsubscribe is a helper method to define mock.On call
   592  //   - senderAddress *model.FeatureAddressType
   593  //   - destinationAddress *model.FeatureAddressType
   594  func (_e *SenderInterface_Expecter) Unsubscribe(senderAddress interface{}, destinationAddress interface{}) *SenderInterface_Unsubscribe_Call {
   595  	return &SenderInterface_Unsubscribe_Call{Call: _e.mock.On("Unsubscribe", senderAddress, destinationAddress)}
   596  }
   597  
   598  func (_c *SenderInterface_Unsubscribe_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType)) *SenderInterface_Unsubscribe_Call {
   599  	_c.Call.Run(func(args mock.Arguments) {
   600  		run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType))
   601  	})
   602  	return _c
   603  }
   604  
   605  func (_c *SenderInterface_Unsubscribe_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Unsubscribe_Call {
   606  	_c.Call.Return(_a0, _a1)
   607  	return _c
   608  }
   609  
   610  func (_c *SenderInterface_Unsubscribe_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType) (*model.MsgCounterType, error)) *SenderInterface_Unsubscribe_Call {
   611  	_c.Call.Return(run)
   612  	return _c
   613  }
   614  
   615  // Write provides a mock function with given fields: senderAddress, destinationAddress, cmd
   616  func (_m *SenderInterface) Write(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, cmd model.CmdType) (*model.MsgCounterType, error) {
   617  	ret := _m.Called(senderAddress, destinationAddress, cmd)
   618  
   619  	if len(ret) == 0 {
   620  		panic("no return value specified for Write")
   621  	}
   622  
   623  	var r0 *model.MsgCounterType
   624  	var r1 error
   625  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) (*model.MsgCounterType, error)); ok {
   626  		return rf(senderAddress, destinationAddress, cmd)
   627  	}
   628  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) *model.MsgCounterType); ok {
   629  		r0 = rf(senderAddress, destinationAddress, cmd)
   630  	} else {
   631  		if ret.Get(0) != nil {
   632  			r0 = ret.Get(0).(*model.MsgCounterType)
   633  		}
   634  	}
   635  
   636  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) error); ok {
   637  		r1 = rf(senderAddress, destinationAddress, cmd)
   638  	} else {
   639  		r1 = ret.Error(1)
   640  	}
   641  
   642  	return r0, r1
   643  }
   644  
   645  // SenderInterface_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
   646  type SenderInterface_Write_Call struct {
   647  	*mock.Call
   648  }
   649  
   650  // Write is a helper method to define mock.On call
   651  //   - senderAddress *model.FeatureAddressType
   652  //   - destinationAddress *model.FeatureAddressType
   653  //   - cmd model.CmdType
   654  func (_e *SenderInterface_Expecter) Write(senderAddress interface{}, destinationAddress interface{}, cmd interface{}) *SenderInterface_Write_Call {
   655  	return &SenderInterface_Write_Call{Call: _e.mock.On("Write", senderAddress, destinationAddress, cmd)}
   656  }
   657  
   658  func (_c *SenderInterface_Write_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, cmd model.CmdType)) *SenderInterface_Write_Call {
   659  	_c.Call.Run(func(args mock.Arguments) {
   660  		run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType), args[2].(model.CmdType))
   661  	})
   662  	return _c
   663  }
   664  
   665  func (_c *SenderInterface_Write_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Write_Call {
   666  	_c.Call.Return(_a0, _a1)
   667  	return _c
   668  }
   669  
   670  func (_c *SenderInterface_Write_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) (*model.MsgCounterType, error)) *SenderInterface_Write_Call {
   671  	_c.Call.Return(run)
   672  	return _c
   673  }
   674  
   675  // NewSenderInterface creates a new instance of SenderInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
   676  // The first argument is typically a *testing.T value.
   677  func NewSenderInterface(t interface {
   678  	mock.TestingT
   679  	Cleanup(func())
   680  }) *SenderInterface {
   681  	mock := &SenderInterface{}
   682  	mock.Mock.Test(t)
   683  
   684  	t.Cleanup(func() { mock.AssertExpectations(t) })
   685  
   686  	return mock
   687  }