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

     1  // Code generated by mockery v2.45.0. DO NOT EDIT.
     2  
     3  package mocks
     4  
     5  import (
     6  	api "github.com/enbility/spine-go/api"
     7  	mock "github.com/stretchr/testify/mock"
     8  
     9  	model "github.com/enbility/spine-go/model"
    10  
    11  	time "time"
    12  )
    13  
    14  // FeatureLocalInterface is an autogenerated mock type for the FeatureLocalInterface type
    15  type FeatureLocalInterface struct {
    16  	mock.Mock
    17  }
    18  
    19  type FeatureLocalInterface_Expecter struct {
    20  	mock *mock.Mock
    21  }
    22  
    23  func (_m *FeatureLocalInterface) EXPECT() *FeatureLocalInterface_Expecter {
    24  	return &FeatureLocalInterface_Expecter{mock: &_m.Mock}
    25  }
    26  
    27  // AddFunctionType provides a mock function with given fields: function, read, write
    28  func (_m *FeatureLocalInterface) AddFunctionType(function model.FunctionType, read bool, write bool) {
    29  	_m.Called(function, read, write)
    30  }
    31  
    32  // FeatureLocalInterface_AddFunctionType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFunctionType'
    33  type FeatureLocalInterface_AddFunctionType_Call struct {
    34  	*mock.Call
    35  }
    36  
    37  // AddFunctionType is a helper method to define mock.On call
    38  //   - function model.FunctionType
    39  //   - read bool
    40  //   - write bool
    41  func (_e *FeatureLocalInterface_Expecter) AddFunctionType(function interface{}, read interface{}, write interface{}) *FeatureLocalInterface_AddFunctionType_Call {
    42  	return &FeatureLocalInterface_AddFunctionType_Call{Call: _e.mock.On("AddFunctionType", function, read, write)}
    43  }
    44  
    45  func (_c *FeatureLocalInterface_AddFunctionType_Call) Run(run func(function model.FunctionType, read bool, write bool)) *FeatureLocalInterface_AddFunctionType_Call {
    46  	_c.Call.Run(func(args mock.Arguments) {
    47  		run(args[0].(model.FunctionType), args[1].(bool), args[2].(bool))
    48  	})
    49  	return _c
    50  }
    51  
    52  func (_c *FeatureLocalInterface_AddFunctionType_Call) Return() *FeatureLocalInterface_AddFunctionType_Call {
    53  	_c.Call.Return()
    54  	return _c
    55  }
    56  
    57  func (_c *FeatureLocalInterface_AddFunctionType_Call) RunAndReturn(run func(model.FunctionType, bool, bool)) *FeatureLocalInterface_AddFunctionType_Call {
    58  	_c.Call.Return(run)
    59  	return _c
    60  }
    61  
    62  // AddResponseCallback provides a mock function with given fields: msgCounterReference, function
    63  func (_m *FeatureLocalInterface) AddResponseCallback(msgCounterReference model.MsgCounterType, function func(api.ResponseMessage)) error {
    64  	ret := _m.Called(msgCounterReference, function)
    65  
    66  	if len(ret) == 0 {
    67  		panic("no return value specified for AddResponseCallback")
    68  	}
    69  
    70  	var r0 error
    71  	if rf, ok := ret.Get(0).(func(model.MsgCounterType, func(api.ResponseMessage)) error); ok {
    72  		r0 = rf(msgCounterReference, function)
    73  	} else {
    74  		r0 = ret.Error(0)
    75  	}
    76  
    77  	return r0
    78  }
    79  
    80  // FeatureLocalInterface_AddResponseCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddResponseCallback'
    81  type FeatureLocalInterface_AddResponseCallback_Call struct {
    82  	*mock.Call
    83  }
    84  
    85  // AddResponseCallback is a helper method to define mock.On call
    86  //   - msgCounterReference model.MsgCounterType
    87  //   - function func(api.ResponseMessage)
    88  func (_e *FeatureLocalInterface_Expecter) AddResponseCallback(msgCounterReference interface{}, function interface{}) *FeatureLocalInterface_AddResponseCallback_Call {
    89  	return &FeatureLocalInterface_AddResponseCallback_Call{Call: _e.mock.On("AddResponseCallback", msgCounterReference, function)}
    90  }
    91  
    92  func (_c *FeatureLocalInterface_AddResponseCallback_Call) Run(run func(msgCounterReference model.MsgCounterType, function func(api.ResponseMessage))) *FeatureLocalInterface_AddResponseCallback_Call {
    93  	_c.Call.Run(func(args mock.Arguments) {
    94  		run(args[0].(model.MsgCounterType), args[1].(func(api.ResponseMessage)))
    95  	})
    96  	return _c
    97  }
    98  
    99  func (_c *FeatureLocalInterface_AddResponseCallback_Call) Return(_a0 error) *FeatureLocalInterface_AddResponseCallback_Call {
   100  	_c.Call.Return(_a0)
   101  	return _c
   102  }
   103  
   104  func (_c *FeatureLocalInterface_AddResponseCallback_Call) RunAndReturn(run func(model.MsgCounterType, func(api.ResponseMessage)) error) *FeatureLocalInterface_AddResponseCallback_Call {
   105  	_c.Call.Return(run)
   106  	return _c
   107  }
   108  
   109  // AddResultCallback provides a mock function with given fields: function
   110  func (_m *FeatureLocalInterface) AddResultCallback(function func(api.ResponseMessage)) {
   111  	_m.Called(function)
   112  }
   113  
   114  // FeatureLocalInterface_AddResultCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddResultCallback'
   115  type FeatureLocalInterface_AddResultCallback_Call struct {
   116  	*mock.Call
   117  }
   118  
   119  // AddResultCallback is a helper method to define mock.On call
   120  //   - function func(api.ResponseMessage)
   121  func (_e *FeatureLocalInterface_Expecter) AddResultCallback(function interface{}) *FeatureLocalInterface_AddResultCallback_Call {
   122  	return &FeatureLocalInterface_AddResultCallback_Call{Call: _e.mock.On("AddResultCallback", function)}
   123  }
   124  
   125  func (_c *FeatureLocalInterface_AddResultCallback_Call) Run(run func(function func(api.ResponseMessage))) *FeatureLocalInterface_AddResultCallback_Call {
   126  	_c.Call.Run(func(args mock.Arguments) {
   127  		run(args[0].(func(api.ResponseMessage)))
   128  	})
   129  	return _c
   130  }
   131  
   132  func (_c *FeatureLocalInterface_AddResultCallback_Call) Return() *FeatureLocalInterface_AddResultCallback_Call {
   133  	_c.Call.Return()
   134  	return _c
   135  }
   136  
   137  func (_c *FeatureLocalInterface_AddResultCallback_Call) RunAndReturn(run func(func(api.ResponseMessage))) *FeatureLocalInterface_AddResultCallback_Call {
   138  	_c.Call.Return(run)
   139  	return _c
   140  }
   141  
   142  // AddWriteApprovalCallback provides a mock function with given fields: function
   143  func (_m *FeatureLocalInterface) AddWriteApprovalCallback(function api.WriteApprovalCallbackFunc) error {
   144  	ret := _m.Called(function)
   145  
   146  	if len(ret) == 0 {
   147  		panic("no return value specified for AddWriteApprovalCallback")
   148  	}
   149  
   150  	var r0 error
   151  	if rf, ok := ret.Get(0).(func(api.WriteApprovalCallbackFunc) error); ok {
   152  		r0 = rf(function)
   153  	} else {
   154  		r0 = ret.Error(0)
   155  	}
   156  
   157  	return r0
   158  }
   159  
   160  // FeatureLocalInterface_AddWriteApprovalCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddWriteApprovalCallback'
   161  type FeatureLocalInterface_AddWriteApprovalCallback_Call struct {
   162  	*mock.Call
   163  }
   164  
   165  // AddWriteApprovalCallback is a helper method to define mock.On call
   166  //   - function api.WriteApprovalCallbackFunc
   167  func (_e *FeatureLocalInterface_Expecter) AddWriteApprovalCallback(function interface{}) *FeatureLocalInterface_AddWriteApprovalCallback_Call {
   168  	return &FeatureLocalInterface_AddWriteApprovalCallback_Call{Call: _e.mock.On("AddWriteApprovalCallback", function)}
   169  }
   170  
   171  func (_c *FeatureLocalInterface_AddWriteApprovalCallback_Call) Run(run func(function api.WriteApprovalCallbackFunc)) *FeatureLocalInterface_AddWriteApprovalCallback_Call {
   172  	_c.Call.Run(func(args mock.Arguments) {
   173  		run(args[0].(api.WriteApprovalCallbackFunc))
   174  	})
   175  	return _c
   176  }
   177  
   178  func (_c *FeatureLocalInterface_AddWriteApprovalCallback_Call) Return(_a0 error) *FeatureLocalInterface_AddWriteApprovalCallback_Call {
   179  	_c.Call.Return(_a0)
   180  	return _c
   181  }
   182  
   183  func (_c *FeatureLocalInterface_AddWriteApprovalCallback_Call) RunAndReturn(run func(api.WriteApprovalCallbackFunc) error) *FeatureLocalInterface_AddWriteApprovalCallback_Call {
   184  	_c.Call.Return(run)
   185  	return _c
   186  }
   187  
   188  // Address provides a mock function with given fields:
   189  func (_m *FeatureLocalInterface) Address() *model.FeatureAddressType {
   190  	ret := _m.Called()
   191  
   192  	if len(ret) == 0 {
   193  		panic("no return value specified for Address")
   194  	}
   195  
   196  	var r0 *model.FeatureAddressType
   197  	if rf, ok := ret.Get(0).(func() *model.FeatureAddressType); ok {
   198  		r0 = rf()
   199  	} else {
   200  		if ret.Get(0) != nil {
   201  			r0 = ret.Get(0).(*model.FeatureAddressType)
   202  		}
   203  	}
   204  
   205  	return r0
   206  }
   207  
   208  // FeatureLocalInterface_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address'
   209  type FeatureLocalInterface_Address_Call struct {
   210  	*mock.Call
   211  }
   212  
   213  // Address is a helper method to define mock.On call
   214  func (_e *FeatureLocalInterface_Expecter) Address() *FeatureLocalInterface_Address_Call {
   215  	return &FeatureLocalInterface_Address_Call{Call: _e.mock.On("Address")}
   216  }
   217  
   218  func (_c *FeatureLocalInterface_Address_Call) Run(run func()) *FeatureLocalInterface_Address_Call {
   219  	_c.Call.Run(func(args mock.Arguments) {
   220  		run()
   221  	})
   222  	return _c
   223  }
   224  
   225  func (_c *FeatureLocalInterface_Address_Call) Return(_a0 *model.FeatureAddressType) *FeatureLocalInterface_Address_Call {
   226  	_c.Call.Return(_a0)
   227  	return _c
   228  }
   229  
   230  func (_c *FeatureLocalInterface_Address_Call) RunAndReturn(run func() *model.FeatureAddressType) *FeatureLocalInterface_Address_Call {
   231  	_c.Call.Return(run)
   232  	return _c
   233  }
   234  
   235  // ApproveOrDenyWrite provides a mock function with given fields: msg, err
   236  func (_m *FeatureLocalInterface) ApproveOrDenyWrite(msg *api.Message, err model.ErrorType) {
   237  	_m.Called(msg, err)
   238  }
   239  
   240  // FeatureLocalInterface_ApproveOrDenyWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApproveOrDenyWrite'
   241  type FeatureLocalInterface_ApproveOrDenyWrite_Call struct {
   242  	*mock.Call
   243  }
   244  
   245  // ApproveOrDenyWrite is a helper method to define mock.On call
   246  //   - msg *api.Message
   247  //   - err model.ErrorType
   248  func (_e *FeatureLocalInterface_Expecter) ApproveOrDenyWrite(msg interface{}, err interface{}) *FeatureLocalInterface_ApproveOrDenyWrite_Call {
   249  	return &FeatureLocalInterface_ApproveOrDenyWrite_Call{Call: _e.mock.On("ApproveOrDenyWrite", msg, err)}
   250  }
   251  
   252  func (_c *FeatureLocalInterface_ApproveOrDenyWrite_Call) Run(run func(msg *api.Message, err model.ErrorType)) *FeatureLocalInterface_ApproveOrDenyWrite_Call {
   253  	_c.Call.Run(func(args mock.Arguments) {
   254  		run(args[0].(*api.Message), args[1].(model.ErrorType))
   255  	})
   256  	return _c
   257  }
   258  
   259  func (_c *FeatureLocalInterface_ApproveOrDenyWrite_Call) Return() *FeatureLocalInterface_ApproveOrDenyWrite_Call {
   260  	_c.Call.Return()
   261  	return _c
   262  }
   263  
   264  func (_c *FeatureLocalInterface_ApproveOrDenyWrite_Call) RunAndReturn(run func(*api.Message, model.ErrorType)) *FeatureLocalInterface_ApproveOrDenyWrite_Call {
   265  	_c.Call.Return(run)
   266  	return _c
   267  }
   268  
   269  // BindToRemote provides a mock function with given fields: remoteAddress
   270  func (_m *FeatureLocalInterface) BindToRemote(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) {
   271  	ret := _m.Called(remoteAddress)
   272  
   273  	if len(ret) == 0 {
   274  		panic("no return value specified for BindToRemote")
   275  	}
   276  
   277  	var r0 *model.MsgCounterType
   278  	var r1 *model.ErrorType
   279  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok {
   280  		return rf(remoteAddress)
   281  	}
   282  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok {
   283  		r0 = rf(remoteAddress)
   284  	} else {
   285  		if ret.Get(0) != nil {
   286  			r0 = ret.Get(0).(*model.MsgCounterType)
   287  		}
   288  	}
   289  
   290  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok {
   291  		r1 = rf(remoteAddress)
   292  	} else {
   293  		if ret.Get(1) != nil {
   294  			r1 = ret.Get(1).(*model.ErrorType)
   295  		}
   296  	}
   297  
   298  	return r0, r1
   299  }
   300  
   301  // FeatureLocalInterface_BindToRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BindToRemote'
   302  type FeatureLocalInterface_BindToRemote_Call struct {
   303  	*mock.Call
   304  }
   305  
   306  // BindToRemote is a helper method to define mock.On call
   307  //   - remoteAddress *model.FeatureAddressType
   308  func (_e *FeatureLocalInterface_Expecter) BindToRemote(remoteAddress interface{}) *FeatureLocalInterface_BindToRemote_Call {
   309  	return &FeatureLocalInterface_BindToRemote_Call{Call: _e.mock.On("BindToRemote", remoteAddress)}
   310  }
   311  
   312  func (_c *FeatureLocalInterface_BindToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_BindToRemote_Call {
   313  	_c.Call.Run(func(args mock.Arguments) {
   314  		run(args[0].(*model.FeatureAddressType))
   315  	})
   316  	return _c
   317  }
   318  
   319  func (_c *FeatureLocalInterface_BindToRemote_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_BindToRemote_Call {
   320  	_c.Call.Return(_a0, _a1)
   321  	return _c
   322  }
   323  
   324  func (_c *FeatureLocalInterface_BindToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_BindToRemote_Call {
   325  	_c.Call.Return(run)
   326  	return _c
   327  }
   328  
   329  // CleanRemoteDeviceCaches provides a mock function with given fields: remoteAddress
   330  func (_m *FeatureLocalInterface) CleanRemoteDeviceCaches(remoteAddress *model.DeviceAddressType) {
   331  	_m.Called(remoteAddress)
   332  }
   333  
   334  // FeatureLocalInterface_CleanRemoteDeviceCaches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanRemoteDeviceCaches'
   335  type FeatureLocalInterface_CleanRemoteDeviceCaches_Call struct {
   336  	*mock.Call
   337  }
   338  
   339  // CleanRemoteDeviceCaches is a helper method to define mock.On call
   340  //   - remoteAddress *model.DeviceAddressType
   341  func (_e *FeatureLocalInterface_Expecter) CleanRemoteDeviceCaches(remoteAddress interface{}) *FeatureLocalInterface_CleanRemoteDeviceCaches_Call {
   342  	return &FeatureLocalInterface_CleanRemoteDeviceCaches_Call{Call: _e.mock.On("CleanRemoteDeviceCaches", remoteAddress)}
   343  }
   344  
   345  func (_c *FeatureLocalInterface_CleanRemoteDeviceCaches_Call) Run(run func(remoteAddress *model.DeviceAddressType)) *FeatureLocalInterface_CleanRemoteDeviceCaches_Call {
   346  	_c.Call.Run(func(args mock.Arguments) {
   347  		run(args[0].(*model.DeviceAddressType))
   348  	})
   349  	return _c
   350  }
   351  
   352  func (_c *FeatureLocalInterface_CleanRemoteDeviceCaches_Call) Return() *FeatureLocalInterface_CleanRemoteDeviceCaches_Call {
   353  	_c.Call.Return()
   354  	return _c
   355  }
   356  
   357  func (_c *FeatureLocalInterface_CleanRemoteDeviceCaches_Call) RunAndReturn(run func(*model.DeviceAddressType)) *FeatureLocalInterface_CleanRemoteDeviceCaches_Call {
   358  	_c.Call.Return(run)
   359  	return _c
   360  }
   361  
   362  // CleanRemoteEntityCaches provides a mock function with given fields: remoteAddress
   363  func (_m *FeatureLocalInterface) CleanRemoteEntityCaches(remoteAddress *model.EntityAddressType) {
   364  	_m.Called(remoteAddress)
   365  }
   366  
   367  // FeatureLocalInterface_CleanRemoteEntityCaches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanRemoteEntityCaches'
   368  type FeatureLocalInterface_CleanRemoteEntityCaches_Call struct {
   369  	*mock.Call
   370  }
   371  
   372  // CleanRemoteEntityCaches is a helper method to define mock.On call
   373  //   - remoteAddress *model.EntityAddressType
   374  func (_e *FeatureLocalInterface_Expecter) CleanRemoteEntityCaches(remoteAddress interface{}) *FeatureLocalInterface_CleanRemoteEntityCaches_Call {
   375  	return &FeatureLocalInterface_CleanRemoteEntityCaches_Call{Call: _e.mock.On("CleanRemoteEntityCaches", remoteAddress)}
   376  }
   377  
   378  func (_c *FeatureLocalInterface_CleanRemoteEntityCaches_Call) Run(run func(remoteAddress *model.EntityAddressType)) *FeatureLocalInterface_CleanRemoteEntityCaches_Call {
   379  	_c.Call.Run(func(args mock.Arguments) {
   380  		run(args[0].(*model.EntityAddressType))
   381  	})
   382  	return _c
   383  }
   384  
   385  func (_c *FeatureLocalInterface_CleanRemoteEntityCaches_Call) Return() *FeatureLocalInterface_CleanRemoteEntityCaches_Call {
   386  	_c.Call.Return()
   387  	return _c
   388  }
   389  
   390  func (_c *FeatureLocalInterface_CleanRemoteEntityCaches_Call) RunAndReturn(run func(*model.EntityAddressType)) *FeatureLocalInterface_CleanRemoteEntityCaches_Call {
   391  	_c.Call.Return(run)
   392  	return _c
   393  }
   394  
   395  // CleanWriteApprovalCaches provides a mock function with given fields: ski
   396  func (_m *FeatureLocalInterface) CleanWriteApprovalCaches(ski string) {
   397  	_m.Called(ski)
   398  }
   399  
   400  // FeatureLocalInterface_CleanWriteApprovalCaches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanWriteApprovalCaches'
   401  type FeatureLocalInterface_CleanWriteApprovalCaches_Call struct {
   402  	*mock.Call
   403  }
   404  
   405  // CleanWriteApprovalCaches is a helper method to define mock.On call
   406  //   - ski string
   407  func (_e *FeatureLocalInterface_Expecter) CleanWriteApprovalCaches(ski interface{}) *FeatureLocalInterface_CleanWriteApprovalCaches_Call {
   408  	return &FeatureLocalInterface_CleanWriteApprovalCaches_Call{Call: _e.mock.On("CleanWriteApprovalCaches", ski)}
   409  }
   410  
   411  func (_c *FeatureLocalInterface_CleanWriteApprovalCaches_Call) Run(run func(ski string)) *FeatureLocalInterface_CleanWriteApprovalCaches_Call {
   412  	_c.Call.Run(func(args mock.Arguments) {
   413  		run(args[0].(string))
   414  	})
   415  	return _c
   416  }
   417  
   418  func (_c *FeatureLocalInterface_CleanWriteApprovalCaches_Call) Return() *FeatureLocalInterface_CleanWriteApprovalCaches_Call {
   419  	_c.Call.Return()
   420  	return _c
   421  }
   422  
   423  func (_c *FeatureLocalInterface_CleanWriteApprovalCaches_Call) RunAndReturn(run func(string)) *FeatureLocalInterface_CleanWriteApprovalCaches_Call {
   424  	_c.Call.Return(run)
   425  	return _c
   426  }
   427  
   428  // DataCopy provides a mock function with given fields: function
   429  func (_m *FeatureLocalInterface) DataCopy(function model.FunctionType) interface{} {
   430  	ret := _m.Called(function)
   431  
   432  	if len(ret) == 0 {
   433  		panic("no return value specified for DataCopy")
   434  	}
   435  
   436  	var r0 interface{}
   437  	if rf, ok := ret.Get(0).(func(model.FunctionType) interface{}); ok {
   438  		r0 = rf(function)
   439  	} else {
   440  		if ret.Get(0) != nil {
   441  			r0 = ret.Get(0).(interface{})
   442  		}
   443  	}
   444  
   445  	return r0
   446  }
   447  
   448  // FeatureLocalInterface_DataCopy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataCopy'
   449  type FeatureLocalInterface_DataCopy_Call struct {
   450  	*mock.Call
   451  }
   452  
   453  // DataCopy is a helper method to define mock.On call
   454  //   - function model.FunctionType
   455  func (_e *FeatureLocalInterface_Expecter) DataCopy(function interface{}) *FeatureLocalInterface_DataCopy_Call {
   456  	return &FeatureLocalInterface_DataCopy_Call{Call: _e.mock.On("DataCopy", function)}
   457  }
   458  
   459  func (_c *FeatureLocalInterface_DataCopy_Call) Run(run func(function model.FunctionType)) *FeatureLocalInterface_DataCopy_Call {
   460  	_c.Call.Run(func(args mock.Arguments) {
   461  		run(args[0].(model.FunctionType))
   462  	})
   463  	return _c
   464  }
   465  
   466  func (_c *FeatureLocalInterface_DataCopy_Call) Return(_a0 interface{}) *FeatureLocalInterface_DataCopy_Call {
   467  	_c.Call.Return(_a0)
   468  	return _c
   469  }
   470  
   471  func (_c *FeatureLocalInterface_DataCopy_Call) RunAndReturn(run func(model.FunctionType) interface{}) *FeatureLocalInterface_DataCopy_Call {
   472  	_c.Call.Return(run)
   473  	return _c
   474  }
   475  
   476  // Description provides a mock function with given fields:
   477  func (_m *FeatureLocalInterface) Description() *model.DescriptionType {
   478  	ret := _m.Called()
   479  
   480  	if len(ret) == 0 {
   481  		panic("no return value specified for Description")
   482  	}
   483  
   484  	var r0 *model.DescriptionType
   485  	if rf, ok := ret.Get(0).(func() *model.DescriptionType); ok {
   486  		r0 = rf()
   487  	} else {
   488  		if ret.Get(0) != nil {
   489  			r0 = ret.Get(0).(*model.DescriptionType)
   490  		}
   491  	}
   492  
   493  	return r0
   494  }
   495  
   496  // FeatureLocalInterface_Description_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Description'
   497  type FeatureLocalInterface_Description_Call struct {
   498  	*mock.Call
   499  }
   500  
   501  // Description is a helper method to define mock.On call
   502  func (_e *FeatureLocalInterface_Expecter) Description() *FeatureLocalInterface_Description_Call {
   503  	return &FeatureLocalInterface_Description_Call{Call: _e.mock.On("Description")}
   504  }
   505  
   506  func (_c *FeatureLocalInterface_Description_Call) Run(run func()) *FeatureLocalInterface_Description_Call {
   507  	_c.Call.Run(func(args mock.Arguments) {
   508  		run()
   509  	})
   510  	return _c
   511  }
   512  
   513  func (_c *FeatureLocalInterface_Description_Call) Return(_a0 *model.DescriptionType) *FeatureLocalInterface_Description_Call {
   514  	_c.Call.Return(_a0)
   515  	return _c
   516  }
   517  
   518  func (_c *FeatureLocalInterface_Description_Call) RunAndReturn(run func() *model.DescriptionType) *FeatureLocalInterface_Description_Call {
   519  	_c.Call.Return(run)
   520  	return _c
   521  }
   522  
   523  // Device provides a mock function with given fields:
   524  func (_m *FeatureLocalInterface) Device() api.DeviceLocalInterface {
   525  	ret := _m.Called()
   526  
   527  	if len(ret) == 0 {
   528  		panic("no return value specified for Device")
   529  	}
   530  
   531  	var r0 api.DeviceLocalInterface
   532  	if rf, ok := ret.Get(0).(func() api.DeviceLocalInterface); ok {
   533  		r0 = rf()
   534  	} else {
   535  		if ret.Get(0) != nil {
   536  			r0 = ret.Get(0).(api.DeviceLocalInterface)
   537  		}
   538  	}
   539  
   540  	return r0
   541  }
   542  
   543  // FeatureLocalInterface_Device_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Device'
   544  type FeatureLocalInterface_Device_Call struct {
   545  	*mock.Call
   546  }
   547  
   548  // Device is a helper method to define mock.On call
   549  func (_e *FeatureLocalInterface_Expecter) Device() *FeatureLocalInterface_Device_Call {
   550  	return &FeatureLocalInterface_Device_Call{Call: _e.mock.On("Device")}
   551  }
   552  
   553  func (_c *FeatureLocalInterface_Device_Call) Run(run func()) *FeatureLocalInterface_Device_Call {
   554  	_c.Call.Run(func(args mock.Arguments) {
   555  		run()
   556  	})
   557  	return _c
   558  }
   559  
   560  func (_c *FeatureLocalInterface_Device_Call) Return(_a0 api.DeviceLocalInterface) *FeatureLocalInterface_Device_Call {
   561  	_c.Call.Return(_a0)
   562  	return _c
   563  }
   564  
   565  func (_c *FeatureLocalInterface_Device_Call) RunAndReturn(run func() api.DeviceLocalInterface) *FeatureLocalInterface_Device_Call {
   566  	_c.Call.Return(run)
   567  	return _c
   568  }
   569  
   570  // Entity provides a mock function with given fields:
   571  func (_m *FeatureLocalInterface) Entity() api.EntityLocalInterface {
   572  	ret := _m.Called()
   573  
   574  	if len(ret) == 0 {
   575  		panic("no return value specified for Entity")
   576  	}
   577  
   578  	var r0 api.EntityLocalInterface
   579  	if rf, ok := ret.Get(0).(func() api.EntityLocalInterface); ok {
   580  		r0 = rf()
   581  	} else {
   582  		if ret.Get(0) != nil {
   583  			r0 = ret.Get(0).(api.EntityLocalInterface)
   584  		}
   585  	}
   586  
   587  	return r0
   588  }
   589  
   590  // FeatureLocalInterface_Entity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Entity'
   591  type FeatureLocalInterface_Entity_Call struct {
   592  	*mock.Call
   593  }
   594  
   595  // Entity is a helper method to define mock.On call
   596  func (_e *FeatureLocalInterface_Expecter) Entity() *FeatureLocalInterface_Entity_Call {
   597  	return &FeatureLocalInterface_Entity_Call{Call: _e.mock.On("Entity")}
   598  }
   599  
   600  func (_c *FeatureLocalInterface_Entity_Call) Run(run func()) *FeatureLocalInterface_Entity_Call {
   601  	_c.Call.Run(func(args mock.Arguments) {
   602  		run()
   603  	})
   604  	return _c
   605  }
   606  
   607  func (_c *FeatureLocalInterface_Entity_Call) Return(_a0 api.EntityLocalInterface) *FeatureLocalInterface_Entity_Call {
   608  	_c.Call.Return(_a0)
   609  	return _c
   610  }
   611  
   612  func (_c *FeatureLocalInterface_Entity_Call) RunAndReturn(run func() api.EntityLocalInterface) *FeatureLocalInterface_Entity_Call {
   613  	_c.Call.Return(run)
   614  	return _c
   615  }
   616  
   617  // Functions provides a mock function with given fields:
   618  func (_m *FeatureLocalInterface) Functions() []model.FunctionType {
   619  	ret := _m.Called()
   620  
   621  	if len(ret) == 0 {
   622  		panic("no return value specified for Functions")
   623  	}
   624  
   625  	var r0 []model.FunctionType
   626  	if rf, ok := ret.Get(0).(func() []model.FunctionType); ok {
   627  		r0 = rf()
   628  	} else {
   629  		if ret.Get(0) != nil {
   630  			r0 = ret.Get(0).([]model.FunctionType)
   631  		}
   632  	}
   633  
   634  	return r0
   635  }
   636  
   637  // FeatureLocalInterface_Functions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Functions'
   638  type FeatureLocalInterface_Functions_Call struct {
   639  	*mock.Call
   640  }
   641  
   642  // Functions is a helper method to define mock.On call
   643  func (_e *FeatureLocalInterface_Expecter) Functions() *FeatureLocalInterface_Functions_Call {
   644  	return &FeatureLocalInterface_Functions_Call{Call: _e.mock.On("Functions")}
   645  }
   646  
   647  func (_c *FeatureLocalInterface_Functions_Call) Run(run func()) *FeatureLocalInterface_Functions_Call {
   648  	_c.Call.Run(func(args mock.Arguments) {
   649  		run()
   650  	})
   651  	return _c
   652  }
   653  
   654  func (_c *FeatureLocalInterface_Functions_Call) Return(_a0 []model.FunctionType) *FeatureLocalInterface_Functions_Call {
   655  	_c.Call.Return(_a0)
   656  	return _c
   657  }
   658  
   659  func (_c *FeatureLocalInterface_Functions_Call) RunAndReturn(run func() []model.FunctionType) *FeatureLocalInterface_Functions_Call {
   660  	_c.Call.Return(run)
   661  	return _c
   662  }
   663  
   664  // HandleMessage provides a mock function with given fields: message
   665  func (_m *FeatureLocalInterface) HandleMessage(message *api.Message) *model.ErrorType {
   666  	ret := _m.Called(message)
   667  
   668  	if len(ret) == 0 {
   669  		panic("no return value specified for HandleMessage")
   670  	}
   671  
   672  	var r0 *model.ErrorType
   673  	if rf, ok := ret.Get(0).(func(*api.Message) *model.ErrorType); ok {
   674  		r0 = rf(message)
   675  	} else {
   676  		if ret.Get(0) != nil {
   677  			r0 = ret.Get(0).(*model.ErrorType)
   678  		}
   679  	}
   680  
   681  	return r0
   682  }
   683  
   684  // FeatureLocalInterface_HandleMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HandleMessage'
   685  type FeatureLocalInterface_HandleMessage_Call struct {
   686  	*mock.Call
   687  }
   688  
   689  // HandleMessage is a helper method to define mock.On call
   690  //   - message *api.Message
   691  func (_e *FeatureLocalInterface_Expecter) HandleMessage(message interface{}) *FeatureLocalInterface_HandleMessage_Call {
   692  	return &FeatureLocalInterface_HandleMessage_Call{Call: _e.mock.On("HandleMessage", message)}
   693  }
   694  
   695  func (_c *FeatureLocalInterface_HandleMessage_Call) Run(run func(message *api.Message)) *FeatureLocalInterface_HandleMessage_Call {
   696  	_c.Call.Run(func(args mock.Arguments) {
   697  		run(args[0].(*api.Message))
   698  	})
   699  	return _c
   700  }
   701  
   702  func (_c *FeatureLocalInterface_HandleMessage_Call) Return(_a0 *model.ErrorType) *FeatureLocalInterface_HandleMessage_Call {
   703  	_c.Call.Return(_a0)
   704  	return _c
   705  }
   706  
   707  func (_c *FeatureLocalInterface_HandleMessage_Call) RunAndReturn(run func(*api.Message) *model.ErrorType) *FeatureLocalInterface_HandleMessage_Call {
   708  	_c.Call.Return(run)
   709  	return _c
   710  }
   711  
   712  // HasBindingToRemote provides a mock function with given fields: remoteAddress
   713  func (_m *FeatureLocalInterface) HasBindingToRemote(remoteAddress *model.FeatureAddressType) bool {
   714  	ret := _m.Called(remoteAddress)
   715  
   716  	if len(ret) == 0 {
   717  		panic("no return value specified for HasBindingToRemote")
   718  	}
   719  
   720  	var r0 bool
   721  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) bool); ok {
   722  		r0 = rf(remoteAddress)
   723  	} else {
   724  		r0 = ret.Get(0).(bool)
   725  	}
   726  
   727  	return r0
   728  }
   729  
   730  // FeatureLocalInterface_HasBindingToRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasBindingToRemote'
   731  type FeatureLocalInterface_HasBindingToRemote_Call struct {
   732  	*mock.Call
   733  }
   734  
   735  // HasBindingToRemote is a helper method to define mock.On call
   736  //   - remoteAddress *model.FeatureAddressType
   737  func (_e *FeatureLocalInterface_Expecter) HasBindingToRemote(remoteAddress interface{}) *FeatureLocalInterface_HasBindingToRemote_Call {
   738  	return &FeatureLocalInterface_HasBindingToRemote_Call{Call: _e.mock.On("HasBindingToRemote", remoteAddress)}
   739  }
   740  
   741  func (_c *FeatureLocalInterface_HasBindingToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_HasBindingToRemote_Call {
   742  	_c.Call.Run(func(args mock.Arguments) {
   743  		run(args[0].(*model.FeatureAddressType))
   744  	})
   745  	return _c
   746  }
   747  
   748  func (_c *FeatureLocalInterface_HasBindingToRemote_Call) Return(_a0 bool) *FeatureLocalInterface_HasBindingToRemote_Call {
   749  	_c.Call.Return(_a0)
   750  	return _c
   751  }
   752  
   753  func (_c *FeatureLocalInterface_HasBindingToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) bool) *FeatureLocalInterface_HasBindingToRemote_Call {
   754  	_c.Call.Return(run)
   755  	return _c
   756  }
   757  
   758  // HasSubscriptionToRemote provides a mock function with given fields: remoteAddress
   759  func (_m *FeatureLocalInterface) HasSubscriptionToRemote(remoteAddress *model.FeatureAddressType) bool {
   760  	ret := _m.Called(remoteAddress)
   761  
   762  	if len(ret) == 0 {
   763  		panic("no return value specified for HasSubscriptionToRemote")
   764  	}
   765  
   766  	var r0 bool
   767  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) bool); ok {
   768  		r0 = rf(remoteAddress)
   769  	} else {
   770  		r0 = ret.Get(0).(bool)
   771  	}
   772  
   773  	return r0
   774  }
   775  
   776  // FeatureLocalInterface_HasSubscriptionToRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasSubscriptionToRemote'
   777  type FeatureLocalInterface_HasSubscriptionToRemote_Call struct {
   778  	*mock.Call
   779  }
   780  
   781  // HasSubscriptionToRemote is a helper method to define mock.On call
   782  //   - remoteAddress *model.FeatureAddressType
   783  func (_e *FeatureLocalInterface_Expecter) HasSubscriptionToRemote(remoteAddress interface{}) *FeatureLocalInterface_HasSubscriptionToRemote_Call {
   784  	return &FeatureLocalInterface_HasSubscriptionToRemote_Call{Call: _e.mock.On("HasSubscriptionToRemote", remoteAddress)}
   785  }
   786  
   787  func (_c *FeatureLocalInterface_HasSubscriptionToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_HasSubscriptionToRemote_Call {
   788  	_c.Call.Run(func(args mock.Arguments) {
   789  		run(args[0].(*model.FeatureAddressType))
   790  	})
   791  	return _c
   792  }
   793  
   794  func (_c *FeatureLocalInterface_HasSubscriptionToRemote_Call) Return(_a0 bool) *FeatureLocalInterface_HasSubscriptionToRemote_Call {
   795  	_c.Call.Return(_a0)
   796  	return _c
   797  }
   798  
   799  func (_c *FeatureLocalInterface_HasSubscriptionToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) bool) *FeatureLocalInterface_HasSubscriptionToRemote_Call {
   800  	_c.Call.Return(run)
   801  	return _c
   802  }
   803  
   804  // Information provides a mock function with given fields:
   805  func (_m *FeatureLocalInterface) Information() *model.NodeManagementDetailedDiscoveryFeatureInformationType {
   806  	ret := _m.Called()
   807  
   808  	if len(ret) == 0 {
   809  		panic("no return value specified for Information")
   810  	}
   811  
   812  	var r0 *model.NodeManagementDetailedDiscoveryFeatureInformationType
   813  	if rf, ok := ret.Get(0).(func() *model.NodeManagementDetailedDiscoveryFeatureInformationType); ok {
   814  		r0 = rf()
   815  	} else {
   816  		if ret.Get(0) != nil {
   817  			r0 = ret.Get(0).(*model.NodeManagementDetailedDiscoveryFeatureInformationType)
   818  		}
   819  	}
   820  
   821  	return r0
   822  }
   823  
   824  // FeatureLocalInterface_Information_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Information'
   825  type FeatureLocalInterface_Information_Call struct {
   826  	*mock.Call
   827  }
   828  
   829  // Information is a helper method to define mock.On call
   830  func (_e *FeatureLocalInterface_Expecter) Information() *FeatureLocalInterface_Information_Call {
   831  	return &FeatureLocalInterface_Information_Call{Call: _e.mock.On("Information")}
   832  }
   833  
   834  func (_c *FeatureLocalInterface_Information_Call) Run(run func()) *FeatureLocalInterface_Information_Call {
   835  	_c.Call.Run(func(args mock.Arguments) {
   836  		run()
   837  	})
   838  	return _c
   839  }
   840  
   841  func (_c *FeatureLocalInterface_Information_Call) Return(_a0 *model.NodeManagementDetailedDiscoveryFeatureInformationType) *FeatureLocalInterface_Information_Call {
   842  	_c.Call.Return(_a0)
   843  	return _c
   844  }
   845  
   846  func (_c *FeatureLocalInterface_Information_Call) RunAndReturn(run func() *model.NodeManagementDetailedDiscoveryFeatureInformationType) *FeatureLocalInterface_Information_Call {
   847  	_c.Call.Return(run)
   848  	return _c
   849  }
   850  
   851  // Operations provides a mock function with given fields:
   852  func (_m *FeatureLocalInterface) Operations() map[model.FunctionType]api.OperationsInterface {
   853  	ret := _m.Called()
   854  
   855  	if len(ret) == 0 {
   856  		panic("no return value specified for Operations")
   857  	}
   858  
   859  	var r0 map[model.FunctionType]api.OperationsInterface
   860  	if rf, ok := ret.Get(0).(func() map[model.FunctionType]api.OperationsInterface); ok {
   861  		r0 = rf()
   862  	} else {
   863  		if ret.Get(0) != nil {
   864  			r0 = ret.Get(0).(map[model.FunctionType]api.OperationsInterface)
   865  		}
   866  	}
   867  
   868  	return r0
   869  }
   870  
   871  // FeatureLocalInterface_Operations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Operations'
   872  type FeatureLocalInterface_Operations_Call struct {
   873  	*mock.Call
   874  }
   875  
   876  // Operations is a helper method to define mock.On call
   877  func (_e *FeatureLocalInterface_Expecter) Operations() *FeatureLocalInterface_Operations_Call {
   878  	return &FeatureLocalInterface_Operations_Call{Call: _e.mock.On("Operations")}
   879  }
   880  
   881  func (_c *FeatureLocalInterface_Operations_Call) Run(run func()) *FeatureLocalInterface_Operations_Call {
   882  	_c.Call.Run(func(args mock.Arguments) {
   883  		run()
   884  	})
   885  	return _c
   886  }
   887  
   888  func (_c *FeatureLocalInterface_Operations_Call) Return(_a0 map[model.FunctionType]api.OperationsInterface) *FeatureLocalInterface_Operations_Call {
   889  	_c.Call.Return(_a0)
   890  	return _c
   891  }
   892  
   893  func (_c *FeatureLocalInterface_Operations_Call) RunAndReturn(run func() map[model.FunctionType]api.OperationsInterface) *FeatureLocalInterface_Operations_Call {
   894  	_c.Call.Return(run)
   895  	return _c
   896  }
   897  
   898  // RemoveAllRemoteBindings provides a mock function with given fields:
   899  func (_m *FeatureLocalInterface) RemoveAllRemoteBindings() {
   900  	_m.Called()
   901  }
   902  
   903  // FeatureLocalInterface_RemoveAllRemoteBindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllRemoteBindings'
   904  type FeatureLocalInterface_RemoveAllRemoteBindings_Call struct {
   905  	*mock.Call
   906  }
   907  
   908  // RemoveAllRemoteBindings is a helper method to define mock.On call
   909  func (_e *FeatureLocalInterface_Expecter) RemoveAllRemoteBindings() *FeatureLocalInterface_RemoveAllRemoteBindings_Call {
   910  	return &FeatureLocalInterface_RemoveAllRemoteBindings_Call{Call: _e.mock.On("RemoveAllRemoteBindings")}
   911  }
   912  
   913  func (_c *FeatureLocalInterface_RemoveAllRemoteBindings_Call) Run(run func()) *FeatureLocalInterface_RemoveAllRemoteBindings_Call {
   914  	_c.Call.Run(func(args mock.Arguments) {
   915  		run()
   916  	})
   917  	return _c
   918  }
   919  
   920  func (_c *FeatureLocalInterface_RemoveAllRemoteBindings_Call) Return() *FeatureLocalInterface_RemoveAllRemoteBindings_Call {
   921  	_c.Call.Return()
   922  	return _c
   923  }
   924  
   925  func (_c *FeatureLocalInterface_RemoveAllRemoteBindings_Call) RunAndReturn(run func()) *FeatureLocalInterface_RemoveAllRemoteBindings_Call {
   926  	_c.Call.Return(run)
   927  	return _c
   928  }
   929  
   930  // RemoveAllRemoteSubscriptions provides a mock function with given fields:
   931  func (_m *FeatureLocalInterface) RemoveAllRemoteSubscriptions() {
   932  	_m.Called()
   933  }
   934  
   935  // FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllRemoteSubscriptions'
   936  type FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call struct {
   937  	*mock.Call
   938  }
   939  
   940  // RemoveAllRemoteSubscriptions is a helper method to define mock.On call
   941  func (_e *FeatureLocalInterface_Expecter) RemoveAllRemoteSubscriptions() *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call {
   942  	return &FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call{Call: _e.mock.On("RemoveAllRemoteSubscriptions")}
   943  }
   944  
   945  func (_c *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call) Run(run func()) *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call {
   946  	_c.Call.Run(func(args mock.Arguments) {
   947  		run()
   948  	})
   949  	return _c
   950  }
   951  
   952  func (_c *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call) Return() *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call {
   953  	_c.Call.Return()
   954  	return _c
   955  }
   956  
   957  func (_c *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call) RunAndReturn(run func()) *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call {
   958  	_c.Call.Return(run)
   959  	return _c
   960  }
   961  
   962  // RemoveRemoteBinding provides a mock function with given fields: remoteAddress
   963  func (_m *FeatureLocalInterface) RemoveRemoteBinding(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) {
   964  	ret := _m.Called(remoteAddress)
   965  
   966  	if len(ret) == 0 {
   967  		panic("no return value specified for RemoveRemoteBinding")
   968  	}
   969  
   970  	var r0 *model.MsgCounterType
   971  	var r1 *model.ErrorType
   972  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok {
   973  		return rf(remoteAddress)
   974  	}
   975  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok {
   976  		r0 = rf(remoteAddress)
   977  	} else {
   978  		if ret.Get(0) != nil {
   979  			r0 = ret.Get(0).(*model.MsgCounterType)
   980  		}
   981  	}
   982  
   983  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok {
   984  		r1 = rf(remoteAddress)
   985  	} else {
   986  		if ret.Get(1) != nil {
   987  			r1 = ret.Get(1).(*model.ErrorType)
   988  		}
   989  	}
   990  
   991  	return r0, r1
   992  }
   993  
   994  // FeatureLocalInterface_RemoveRemoteBinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRemoteBinding'
   995  type FeatureLocalInterface_RemoveRemoteBinding_Call struct {
   996  	*mock.Call
   997  }
   998  
   999  // RemoveRemoteBinding is a helper method to define mock.On call
  1000  //   - remoteAddress *model.FeatureAddressType
  1001  func (_e *FeatureLocalInterface_Expecter) RemoveRemoteBinding(remoteAddress interface{}) *FeatureLocalInterface_RemoveRemoteBinding_Call {
  1002  	return &FeatureLocalInterface_RemoveRemoteBinding_Call{Call: _e.mock.On("RemoveRemoteBinding", remoteAddress)}
  1003  }
  1004  
  1005  func (_c *FeatureLocalInterface_RemoveRemoteBinding_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_RemoveRemoteBinding_Call {
  1006  	_c.Call.Run(func(args mock.Arguments) {
  1007  		run(args[0].(*model.FeatureAddressType))
  1008  	})
  1009  	return _c
  1010  }
  1011  
  1012  func (_c *FeatureLocalInterface_RemoveRemoteBinding_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RemoveRemoteBinding_Call {
  1013  	_c.Call.Return(_a0, _a1)
  1014  	return _c
  1015  }
  1016  
  1017  func (_c *FeatureLocalInterface_RemoveRemoteBinding_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RemoveRemoteBinding_Call {
  1018  	_c.Call.Return(run)
  1019  	return _c
  1020  }
  1021  
  1022  // RemoveRemoteSubscription provides a mock function with given fields: remoteAddress
  1023  func (_m *FeatureLocalInterface) RemoveRemoteSubscription(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) {
  1024  	ret := _m.Called(remoteAddress)
  1025  
  1026  	if len(ret) == 0 {
  1027  		panic("no return value specified for RemoveRemoteSubscription")
  1028  	}
  1029  
  1030  	var r0 *model.MsgCounterType
  1031  	var r1 *model.ErrorType
  1032  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok {
  1033  		return rf(remoteAddress)
  1034  	}
  1035  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok {
  1036  		r0 = rf(remoteAddress)
  1037  	} else {
  1038  		if ret.Get(0) != nil {
  1039  			r0 = ret.Get(0).(*model.MsgCounterType)
  1040  		}
  1041  	}
  1042  
  1043  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok {
  1044  		r1 = rf(remoteAddress)
  1045  	} else {
  1046  		if ret.Get(1) != nil {
  1047  			r1 = ret.Get(1).(*model.ErrorType)
  1048  		}
  1049  	}
  1050  
  1051  	return r0, r1
  1052  }
  1053  
  1054  // FeatureLocalInterface_RemoveRemoteSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRemoteSubscription'
  1055  type FeatureLocalInterface_RemoveRemoteSubscription_Call struct {
  1056  	*mock.Call
  1057  }
  1058  
  1059  // RemoveRemoteSubscription is a helper method to define mock.On call
  1060  //   - remoteAddress *model.FeatureAddressType
  1061  func (_e *FeatureLocalInterface_Expecter) RemoveRemoteSubscription(remoteAddress interface{}) *FeatureLocalInterface_RemoveRemoteSubscription_Call {
  1062  	return &FeatureLocalInterface_RemoveRemoteSubscription_Call{Call: _e.mock.On("RemoveRemoteSubscription", remoteAddress)}
  1063  }
  1064  
  1065  func (_c *FeatureLocalInterface_RemoveRemoteSubscription_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_RemoveRemoteSubscription_Call {
  1066  	_c.Call.Run(func(args mock.Arguments) {
  1067  		run(args[0].(*model.FeatureAddressType))
  1068  	})
  1069  	return _c
  1070  }
  1071  
  1072  func (_c *FeatureLocalInterface_RemoveRemoteSubscription_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RemoveRemoteSubscription_Call {
  1073  	_c.Call.Return(_a0, _a1)
  1074  	return _c
  1075  }
  1076  
  1077  func (_c *FeatureLocalInterface_RemoveRemoteSubscription_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RemoveRemoteSubscription_Call {
  1078  	_c.Call.Return(run)
  1079  	return _c
  1080  }
  1081  
  1082  // RequestRemoteData provides a mock function with given fields: function, selector, elements, destination
  1083  func (_m *FeatureLocalInterface) RequestRemoteData(function model.FunctionType, selector interface{}, elements interface{}, destination api.FeatureRemoteInterface) (*model.MsgCounterType, *model.ErrorType) {
  1084  	ret := _m.Called(function, selector, elements, destination)
  1085  
  1086  	if len(ret) == 0 {
  1087  		panic("no return value specified for RequestRemoteData")
  1088  	}
  1089  
  1090  	var r0 *model.MsgCounterType
  1091  	var r1 *model.ErrorType
  1092  	if rf, ok := ret.Get(0).(func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) (*model.MsgCounterType, *model.ErrorType)); ok {
  1093  		return rf(function, selector, elements, destination)
  1094  	}
  1095  	if rf, ok := ret.Get(0).(func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) *model.MsgCounterType); ok {
  1096  		r0 = rf(function, selector, elements, destination)
  1097  	} else {
  1098  		if ret.Get(0) != nil {
  1099  			r0 = ret.Get(0).(*model.MsgCounterType)
  1100  		}
  1101  	}
  1102  
  1103  	if rf, ok := ret.Get(1).(func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) *model.ErrorType); ok {
  1104  		r1 = rf(function, selector, elements, destination)
  1105  	} else {
  1106  		if ret.Get(1) != nil {
  1107  			r1 = ret.Get(1).(*model.ErrorType)
  1108  		}
  1109  	}
  1110  
  1111  	return r0, r1
  1112  }
  1113  
  1114  // FeatureLocalInterface_RequestRemoteData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestRemoteData'
  1115  type FeatureLocalInterface_RequestRemoteData_Call struct {
  1116  	*mock.Call
  1117  }
  1118  
  1119  // RequestRemoteData is a helper method to define mock.On call
  1120  //   - function model.FunctionType
  1121  //   - selector interface{}
  1122  //   - elements interface{}
  1123  //   - destination api.FeatureRemoteInterface
  1124  func (_e *FeatureLocalInterface_Expecter) RequestRemoteData(function interface{}, selector interface{}, elements interface{}, destination interface{}) *FeatureLocalInterface_RequestRemoteData_Call {
  1125  	return &FeatureLocalInterface_RequestRemoteData_Call{Call: _e.mock.On("RequestRemoteData", function, selector, elements, destination)}
  1126  }
  1127  
  1128  func (_c *FeatureLocalInterface_RequestRemoteData_Call) Run(run func(function model.FunctionType, selector interface{}, elements interface{}, destination api.FeatureRemoteInterface)) *FeatureLocalInterface_RequestRemoteData_Call {
  1129  	_c.Call.Run(func(args mock.Arguments) {
  1130  		run(args[0].(model.FunctionType), args[1].(interface{}), args[2].(interface{}), args[3].(api.FeatureRemoteInterface))
  1131  	})
  1132  	return _c
  1133  }
  1134  
  1135  func (_c *FeatureLocalInterface_RequestRemoteData_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RequestRemoteData_Call {
  1136  	_c.Call.Return(_a0, _a1)
  1137  	return _c
  1138  }
  1139  
  1140  func (_c *FeatureLocalInterface_RequestRemoteData_Call) RunAndReturn(run func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RequestRemoteData_Call {
  1141  	_c.Call.Return(run)
  1142  	return _c
  1143  }
  1144  
  1145  // RequestRemoteDataBySenderAddress provides a mock function with given fields: cmd, sender, destinationSki, destinationAddress, maxDelay
  1146  func (_m *FeatureLocalInterface) RequestRemoteDataBySenderAddress(cmd model.CmdType, sender api.SenderInterface, destinationSki string, destinationAddress *model.FeatureAddressType, maxDelay time.Duration) (*model.MsgCounterType, *model.ErrorType) {
  1147  	ret := _m.Called(cmd, sender, destinationSki, destinationAddress, maxDelay)
  1148  
  1149  	if len(ret) == 0 {
  1150  		panic("no return value specified for RequestRemoteDataBySenderAddress")
  1151  	}
  1152  
  1153  	var r0 *model.MsgCounterType
  1154  	var r1 *model.ErrorType
  1155  	if rf, ok := ret.Get(0).(func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) (*model.MsgCounterType, *model.ErrorType)); ok {
  1156  		return rf(cmd, sender, destinationSki, destinationAddress, maxDelay)
  1157  	}
  1158  	if rf, ok := ret.Get(0).(func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) *model.MsgCounterType); ok {
  1159  		r0 = rf(cmd, sender, destinationSki, destinationAddress, maxDelay)
  1160  	} else {
  1161  		if ret.Get(0) != nil {
  1162  			r0 = ret.Get(0).(*model.MsgCounterType)
  1163  		}
  1164  	}
  1165  
  1166  	if rf, ok := ret.Get(1).(func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) *model.ErrorType); ok {
  1167  		r1 = rf(cmd, sender, destinationSki, destinationAddress, maxDelay)
  1168  	} else {
  1169  		if ret.Get(1) != nil {
  1170  			r1 = ret.Get(1).(*model.ErrorType)
  1171  		}
  1172  	}
  1173  
  1174  	return r0, r1
  1175  }
  1176  
  1177  // FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestRemoteDataBySenderAddress'
  1178  type FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call struct {
  1179  	*mock.Call
  1180  }
  1181  
  1182  // RequestRemoteDataBySenderAddress is a helper method to define mock.On call
  1183  //   - cmd model.CmdType
  1184  //   - sender api.SenderInterface
  1185  //   - destinationSki string
  1186  //   - destinationAddress *model.FeatureAddressType
  1187  //   - maxDelay time.Duration
  1188  func (_e *FeatureLocalInterface_Expecter) RequestRemoteDataBySenderAddress(cmd interface{}, sender interface{}, destinationSki interface{}, destinationAddress interface{}, maxDelay interface{}) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call {
  1189  	return &FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call{Call: _e.mock.On("RequestRemoteDataBySenderAddress", cmd, sender, destinationSki, destinationAddress, maxDelay)}
  1190  }
  1191  
  1192  func (_c *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call) Run(run func(cmd model.CmdType, sender api.SenderInterface, destinationSki string, destinationAddress *model.FeatureAddressType, maxDelay time.Duration)) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call {
  1193  	_c.Call.Run(func(args mock.Arguments) {
  1194  		run(args[0].(model.CmdType), args[1].(api.SenderInterface), args[2].(string), args[3].(*model.FeatureAddressType), args[4].(time.Duration))
  1195  	})
  1196  	return _c
  1197  }
  1198  
  1199  func (_c *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call {
  1200  	_c.Call.Return(_a0, _a1)
  1201  	return _c
  1202  }
  1203  
  1204  func (_c *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call) RunAndReturn(run func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call {
  1205  	_c.Call.Return(run)
  1206  	return _c
  1207  }
  1208  
  1209  // Role provides a mock function with given fields:
  1210  func (_m *FeatureLocalInterface) Role() model.RoleType {
  1211  	ret := _m.Called()
  1212  
  1213  	if len(ret) == 0 {
  1214  		panic("no return value specified for Role")
  1215  	}
  1216  
  1217  	var r0 model.RoleType
  1218  	if rf, ok := ret.Get(0).(func() model.RoleType); ok {
  1219  		r0 = rf()
  1220  	} else {
  1221  		r0 = ret.Get(0).(model.RoleType)
  1222  	}
  1223  
  1224  	return r0
  1225  }
  1226  
  1227  // FeatureLocalInterface_Role_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Role'
  1228  type FeatureLocalInterface_Role_Call struct {
  1229  	*mock.Call
  1230  }
  1231  
  1232  // Role is a helper method to define mock.On call
  1233  func (_e *FeatureLocalInterface_Expecter) Role() *FeatureLocalInterface_Role_Call {
  1234  	return &FeatureLocalInterface_Role_Call{Call: _e.mock.On("Role")}
  1235  }
  1236  
  1237  func (_c *FeatureLocalInterface_Role_Call) Run(run func()) *FeatureLocalInterface_Role_Call {
  1238  	_c.Call.Run(func(args mock.Arguments) {
  1239  		run()
  1240  	})
  1241  	return _c
  1242  }
  1243  
  1244  func (_c *FeatureLocalInterface_Role_Call) Return(_a0 model.RoleType) *FeatureLocalInterface_Role_Call {
  1245  	_c.Call.Return(_a0)
  1246  	return _c
  1247  }
  1248  
  1249  func (_c *FeatureLocalInterface_Role_Call) RunAndReturn(run func() model.RoleType) *FeatureLocalInterface_Role_Call {
  1250  	_c.Call.Return(run)
  1251  	return _c
  1252  }
  1253  
  1254  // SetData provides a mock function with given fields: function, data
  1255  func (_m *FeatureLocalInterface) SetData(function model.FunctionType, data interface{}) {
  1256  	_m.Called(function, data)
  1257  }
  1258  
  1259  // FeatureLocalInterface_SetData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetData'
  1260  type FeatureLocalInterface_SetData_Call struct {
  1261  	*mock.Call
  1262  }
  1263  
  1264  // SetData is a helper method to define mock.On call
  1265  //   - function model.FunctionType
  1266  //   - data interface{}
  1267  func (_e *FeatureLocalInterface_Expecter) SetData(function interface{}, data interface{}) *FeatureLocalInterface_SetData_Call {
  1268  	return &FeatureLocalInterface_SetData_Call{Call: _e.mock.On("SetData", function, data)}
  1269  }
  1270  
  1271  func (_c *FeatureLocalInterface_SetData_Call) Run(run func(function model.FunctionType, data interface{})) *FeatureLocalInterface_SetData_Call {
  1272  	_c.Call.Run(func(args mock.Arguments) {
  1273  		run(args[0].(model.FunctionType), args[1].(interface{}))
  1274  	})
  1275  	return _c
  1276  }
  1277  
  1278  func (_c *FeatureLocalInterface_SetData_Call) Return() *FeatureLocalInterface_SetData_Call {
  1279  	_c.Call.Return()
  1280  	return _c
  1281  }
  1282  
  1283  func (_c *FeatureLocalInterface_SetData_Call) RunAndReturn(run func(model.FunctionType, interface{})) *FeatureLocalInterface_SetData_Call {
  1284  	_c.Call.Return(run)
  1285  	return _c
  1286  }
  1287  
  1288  // SetDescription provides a mock function with given fields: desc
  1289  func (_m *FeatureLocalInterface) SetDescription(desc *model.DescriptionType) {
  1290  	_m.Called(desc)
  1291  }
  1292  
  1293  // FeatureLocalInterface_SetDescription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDescription'
  1294  type FeatureLocalInterface_SetDescription_Call struct {
  1295  	*mock.Call
  1296  }
  1297  
  1298  // SetDescription is a helper method to define mock.On call
  1299  //   - desc *model.DescriptionType
  1300  func (_e *FeatureLocalInterface_Expecter) SetDescription(desc interface{}) *FeatureLocalInterface_SetDescription_Call {
  1301  	return &FeatureLocalInterface_SetDescription_Call{Call: _e.mock.On("SetDescription", desc)}
  1302  }
  1303  
  1304  func (_c *FeatureLocalInterface_SetDescription_Call) Run(run func(desc *model.DescriptionType)) *FeatureLocalInterface_SetDescription_Call {
  1305  	_c.Call.Run(func(args mock.Arguments) {
  1306  		run(args[0].(*model.DescriptionType))
  1307  	})
  1308  	return _c
  1309  }
  1310  
  1311  func (_c *FeatureLocalInterface_SetDescription_Call) Return() *FeatureLocalInterface_SetDescription_Call {
  1312  	_c.Call.Return()
  1313  	return _c
  1314  }
  1315  
  1316  func (_c *FeatureLocalInterface_SetDescription_Call) RunAndReturn(run func(*model.DescriptionType)) *FeatureLocalInterface_SetDescription_Call {
  1317  	_c.Call.Return(run)
  1318  	return _c
  1319  }
  1320  
  1321  // SetDescriptionString provides a mock function with given fields: s
  1322  func (_m *FeatureLocalInterface) SetDescriptionString(s string) {
  1323  	_m.Called(s)
  1324  }
  1325  
  1326  // FeatureLocalInterface_SetDescriptionString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDescriptionString'
  1327  type FeatureLocalInterface_SetDescriptionString_Call struct {
  1328  	*mock.Call
  1329  }
  1330  
  1331  // SetDescriptionString is a helper method to define mock.On call
  1332  //   - s string
  1333  func (_e *FeatureLocalInterface_Expecter) SetDescriptionString(s interface{}) *FeatureLocalInterface_SetDescriptionString_Call {
  1334  	return &FeatureLocalInterface_SetDescriptionString_Call{Call: _e.mock.On("SetDescriptionString", s)}
  1335  }
  1336  
  1337  func (_c *FeatureLocalInterface_SetDescriptionString_Call) Run(run func(s string)) *FeatureLocalInterface_SetDescriptionString_Call {
  1338  	_c.Call.Run(func(args mock.Arguments) {
  1339  		run(args[0].(string))
  1340  	})
  1341  	return _c
  1342  }
  1343  
  1344  func (_c *FeatureLocalInterface_SetDescriptionString_Call) Return() *FeatureLocalInterface_SetDescriptionString_Call {
  1345  	_c.Call.Return()
  1346  	return _c
  1347  }
  1348  
  1349  func (_c *FeatureLocalInterface_SetDescriptionString_Call) RunAndReturn(run func(string)) *FeatureLocalInterface_SetDescriptionString_Call {
  1350  	_c.Call.Return(run)
  1351  	return _c
  1352  }
  1353  
  1354  // SetWriteApprovalTimeout provides a mock function with given fields: duration
  1355  func (_m *FeatureLocalInterface) SetWriteApprovalTimeout(duration time.Duration) {
  1356  	_m.Called(duration)
  1357  }
  1358  
  1359  // FeatureLocalInterface_SetWriteApprovalTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWriteApprovalTimeout'
  1360  type FeatureLocalInterface_SetWriteApprovalTimeout_Call struct {
  1361  	*mock.Call
  1362  }
  1363  
  1364  // SetWriteApprovalTimeout is a helper method to define mock.On call
  1365  //   - duration time.Duration
  1366  func (_e *FeatureLocalInterface_Expecter) SetWriteApprovalTimeout(duration interface{}) *FeatureLocalInterface_SetWriteApprovalTimeout_Call {
  1367  	return &FeatureLocalInterface_SetWriteApprovalTimeout_Call{Call: _e.mock.On("SetWriteApprovalTimeout", duration)}
  1368  }
  1369  
  1370  func (_c *FeatureLocalInterface_SetWriteApprovalTimeout_Call) Run(run func(duration time.Duration)) *FeatureLocalInterface_SetWriteApprovalTimeout_Call {
  1371  	_c.Call.Run(func(args mock.Arguments) {
  1372  		run(args[0].(time.Duration))
  1373  	})
  1374  	return _c
  1375  }
  1376  
  1377  func (_c *FeatureLocalInterface_SetWriteApprovalTimeout_Call) Return() *FeatureLocalInterface_SetWriteApprovalTimeout_Call {
  1378  	_c.Call.Return()
  1379  	return _c
  1380  }
  1381  
  1382  func (_c *FeatureLocalInterface_SetWriteApprovalTimeout_Call) RunAndReturn(run func(time.Duration)) *FeatureLocalInterface_SetWriteApprovalTimeout_Call {
  1383  	_c.Call.Return(run)
  1384  	return _c
  1385  }
  1386  
  1387  // String provides a mock function with given fields:
  1388  func (_m *FeatureLocalInterface) String() string {
  1389  	ret := _m.Called()
  1390  
  1391  	if len(ret) == 0 {
  1392  		panic("no return value specified for String")
  1393  	}
  1394  
  1395  	var r0 string
  1396  	if rf, ok := ret.Get(0).(func() string); ok {
  1397  		r0 = rf()
  1398  	} else {
  1399  		r0 = ret.Get(0).(string)
  1400  	}
  1401  
  1402  	return r0
  1403  }
  1404  
  1405  // FeatureLocalInterface_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String'
  1406  type FeatureLocalInterface_String_Call struct {
  1407  	*mock.Call
  1408  }
  1409  
  1410  // String is a helper method to define mock.On call
  1411  func (_e *FeatureLocalInterface_Expecter) String() *FeatureLocalInterface_String_Call {
  1412  	return &FeatureLocalInterface_String_Call{Call: _e.mock.On("String")}
  1413  }
  1414  
  1415  func (_c *FeatureLocalInterface_String_Call) Run(run func()) *FeatureLocalInterface_String_Call {
  1416  	_c.Call.Run(func(args mock.Arguments) {
  1417  		run()
  1418  	})
  1419  	return _c
  1420  }
  1421  
  1422  func (_c *FeatureLocalInterface_String_Call) Return(_a0 string) *FeatureLocalInterface_String_Call {
  1423  	_c.Call.Return(_a0)
  1424  	return _c
  1425  }
  1426  
  1427  func (_c *FeatureLocalInterface_String_Call) RunAndReturn(run func() string) *FeatureLocalInterface_String_Call {
  1428  	_c.Call.Return(run)
  1429  	return _c
  1430  }
  1431  
  1432  // SubscribeToRemote provides a mock function with given fields: remoteAddress
  1433  func (_m *FeatureLocalInterface) SubscribeToRemote(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) {
  1434  	ret := _m.Called(remoteAddress)
  1435  
  1436  	if len(ret) == 0 {
  1437  		panic("no return value specified for SubscribeToRemote")
  1438  	}
  1439  
  1440  	var r0 *model.MsgCounterType
  1441  	var r1 *model.ErrorType
  1442  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok {
  1443  		return rf(remoteAddress)
  1444  	}
  1445  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok {
  1446  		r0 = rf(remoteAddress)
  1447  	} else {
  1448  		if ret.Get(0) != nil {
  1449  			r0 = ret.Get(0).(*model.MsgCounterType)
  1450  		}
  1451  	}
  1452  
  1453  	if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok {
  1454  		r1 = rf(remoteAddress)
  1455  	} else {
  1456  		if ret.Get(1) != nil {
  1457  			r1 = ret.Get(1).(*model.ErrorType)
  1458  		}
  1459  	}
  1460  
  1461  	return r0, r1
  1462  }
  1463  
  1464  // FeatureLocalInterface_SubscribeToRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeToRemote'
  1465  type FeatureLocalInterface_SubscribeToRemote_Call struct {
  1466  	*mock.Call
  1467  }
  1468  
  1469  // SubscribeToRemote is a helper method to define mock.On call
  1470  //   - remoteAddress *model.FeatureAddressType
  1471  func (_e *FeatureLocalInterface_Expecter) SubscribeToRemote(remoteAddress interface{}) *FeatureLocalInterface_SubscribeToRemote_Call {
  1472  	return &FeatureLocalInterface_SubscribeToRemote_Call{Call: _e.mock.On("SubscribeToRemote", remoteAddress)}
  1473  }
  1474  
  1475  func (_c *FeatureLocalInterface_SubscribeToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_SubscribeToRemote_Call {
  1476  	_c.Call.Run(func(args mock.Arguments) {
  1477  		run(args[0].(*model.FeatureAddressType))
  1478  	})
  1479  	return _c
  1480  }
  1481  
  1482  func (_c *FeatureLocalInterface_SubscribeToRemote_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_SubscribeToRemote_Call {
  1483  	_c.Call.Return(_a0, _a1)
  1484  	return _c
  1485  }
  1486  
  1487  func (_c *FeatureLocalInterface_SubscribeToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_SubscribeToRemote_Call {
  1488  	_c.Call.Return(run)
  1489  	return _c
  1490  }
  1491  
  1492  // Type provides a mock function with given fields:
  1493  func (_m *FeatureLocalInterface) Type() model.FeatureTypeType {
  1494  	ret := _m.Called()
  1495  
  1496  	if len(ret) == 0 {
  1497  		panic("no return value specified for Type")
  1498  	}
  1499  
  1500  	var r0 model.FeatureTypeType
  1501  	if rf, ok := ret.Get(0).(func() model.FeatureTypeType); ok {
  1502  		r0 = rf()
  1503  	} else {
  1504  		r0 = ret.Get(0).(model.FeatureTypeType)
  1505  	}
  1506  
  1507  	return r0
  1508  }
  1509  
  1510  // FeatureLocalInterface_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type'
  1511  type FeatureLocalInterface_Type_Call struct {
  1512  	*mock.Call
  1513  }
  1514  
  1515  // Type is a helper method to define mock.On call
  1516  func (_e *FeatureLocalInterface_Expecter) Type() *FeatureLocalInterface_Type_Call {
  1517  	return &FeatureLocalInterface_Type_Call{Call: _e.mock.On("Type")}
  1518  }
  1519  
  1520  func (_c *FeatureLocalInterface_Type_Call) Run(run func()) *FeatureLocalInterface_Type_Call {
  1521  	_c.Call.Run(func(args mock.Arguments) {
  1522  		run()
  1523  	})
  1524  	return _c
  1525  }
  1526  
  1527  func (_c *FeatureLocalInterface_Type_Call) Return(_a0 model.FeatureTypeType) *FeatureLocalInterface_Type_Call {
  1528  	_c.Call.Return(_a0)
  1529  	return _c
  1530  }
  1531  
  1532  func (_c *FeatureLocalInterface_Type_Call) RunAndReturn(run func() model.FeatureTypeType) *FeatureLocalInterface_Type_Call {
  1533  	_c.Call.Return(run)
  1534  	return _c
  1535  }
  1536  
  1537  // UpdateData provides a mock function with given fields: function, data, filterPartial, filterDelete
  1538  func (_m *FeatureLocalInterface) UpdateData(function model.FunctionType, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType) *model.ErrorType {
  1539  	ret := _m.Called(function, data, filterPartial, filterDelete)
  1540  
  1541  	if len(ret) == 0 {
  1542  		panic("no return value specified for UpdateData")
  1543  	}
  1544  
  1545  	var r0 *model.ErrorType
  1546  	if rf, ok := ret.Get(0).(func(model.FunctionType, interface{}, *model.FilterType, *model.FilterType) *model.ErrorType); ok {
  1547  		r0 = rf(function, data, filterPartial, filterDelete)
  1548  	} else {
  1549  		if ret.Get(0) != nil {
  1550  			r0 = ret.Get(0).(*model.ErrorType)
  1551  		}
  1552  	}
  1553  
  1554  	return r0
  1555  }
  1556  
  1557  // FeatureLocalInterface_UpdateData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateData'
  1558  type FeatureLocalInterface_UpdateData_Call struct {
  1559  	*mock.Call
  1560  }
  1561  
  1562  // UpdateData is a helper method to define mock.On call
  1563  //   - function model.FunctionType
  1564  //   - data interface{}
  1565  //   - filterPartial *model.FilterType
  1566  //   - filterDelete *model.FilterType
  1567  func (_e *FeatureLocalInterface_Expecter) UpdateData(function interface{}, data interface{}, filterPartial interface{}, filterDelete interface{}) *FeatureLocalInterface_UpdateData_Call {
  1568  	return &FeatureLocalInterface_UpdateData_Call{Call: _e.mock.On("UpdateData", function, data, filterPartial, filterDelete)}
  1569  }
  1570  
  1571  func (_c *FeatureLocalInterface_UpdateData_Call) Run(run func(function model.FunctionType, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType)) *FeatureLocalInterface_UpdateData_Call {
  1572  	_c.Call.Run(func(args mock.Arguments) {
  1573  		run(args[0].(model.FunctionType), args[1].(interface{}), args[2].(*model.FilterType), args[3].(*model.FilterType))
  1574  	})
  1575  	return _c
  1576  }
  1577  
  1578  func (_c *FeatureLocalInterface_UpdateData_Call) Return(_a0 *model.ErrorType) *FeatureLocalInterface_UpdateData_Call {
  1579  	_c.Call.Return(_a0)
  1580  	return _c
  1581  }
  1582  
  1583  func (_c *FeatureLocalInterface_UpdateData_Call) RunAndReturn(run func(model.FunctionType, interface{}, *model.FilterType, *model.FilterType) *model.ErrorType) *FeatureLocalInterface_UpdateData_Call {
  1584  	_c.Call.Return(run)
  1585  	return _c
  1586  }
  1587  
  1588  // NewFeatureLocalInterface creates a new instance of FeatureLocalInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
  1589  // The first argument is typically a *testing.T value.
  1590  func NewFeatureLocalInterface(t interface {
  1591  	mock.TestingT
  1592  	Cleanup(func())
  1593  }) *FeatureLocalInterface {
  1594  	mock := &FeatureLocalInterface{}
  1595  	mock.Mock.Test(t)
  1596  
  1597  	t.Cleanup(func() { mock.AssertExpectations(t) })
  1598  
  1599  	return mock
  1600  }