github.com/enbility/spine-go@v0.7.0/mocks/DeviceLocalInterface.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  	ship_goapi "github.com/enbility/ship-go/api"
    12  )
    13  
    14  // DeviceLocalInterface is an autogenerated mock type for the DeviceLocalInterface type
    15  type DeviceLocalInterface struct {
    16  	mock.Mock
    17  }
    18  
    19  type DeviceLocalInterface_Expecter struct {
    20  	mock *mock.Mock
    21  }
    22  
    23  func (_m *DeviceLocalInterface) EXPECT() *DeviceLocalInterface_Expecter {
    24  	return &DeviceLocalInterface_Expecter{mock: &_m.Mock}
    25  }
    26  
    27  // AddEntity provides a mock function with given fields: entity
    28  func (_m *DeviceLocalInterface) AddEntity(entity api.EntityLocalInterface) {
    29  	_m.Called(entity)
    30  }
    31  
    32  // DeviceLocalInterface_AddEntity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddEntity'
    33  type DeviceLocalInterface_AddEntity_Call struct {
    34  	*mock.Call
    35  }
    36  
    37  // AddEntity is a helper method to define mock.On call
    38  //   - entity api.EntityLocalInterface
    39  func (_e *DeviceLocalInterface_Expecter) AddEntity(entity interface{}) *DeviceLocalInterface_AddEntity_Call {
    40  	return &DeviceLocalInterface_AddEntity_Call{Call: _e.mock.On("AddEntity", entity)}
    41  }
    42  
    43  func (_c *DeviceLocalInterface_AddEntity_Call) Run(run func(entity api.EntityLocalInterface)) *DeviceLocalInterface_AddEntity_Call {
    44  	_c.Call.Run(func(args mock.Arguments) {
    45  		run(args[0].(api.EntityLocalInterface))
    46  	})
    47  	return _c
    48  }
    49  
    50  func (_c *DeviceLocalInterface_AddEntity_Call) Return() *DeviceLocalInterface_AddEntity_Call {
    51  	_c.Call.Return()
    52  	return _c
    53  }
    54  
    55  func (_c *DeviceLocalInterface_AddEntity_Call) RunAndReturn(run func(api.EntityLocalInterface)) *DeviceLocalInterface_AddEntity_Call {
    56  	_c.Call.Return(run)
    57  	return _c
    58  }
    59  
    60  // AddRemoteDeviceForSki provides a mock function with given fields: ski, rDevice
    61  func (_m *DeviceLocalInterface) AddRemoteDeviceForSki(ski string, rDevice api.DeviceRemoteInterface) {
    62  	_m.Called(ski, rDevice)
    63  }
    64  
    65  // DeviceLocalInterface_AddRemoteDeviceForSki_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRemoteDeviceForSki'
    66  type DeviceLocalInterface_AddRemoteDeviceForSki_Call struct {
    67  	*mock.Call
    68  }
    69  
    70  // AddRemoteDeviceForSki is a helper method to define mock.On call
    71  //   - ski string
    72  //   - rDevice api.DeviceRemoteInterface
    73  func (_e *DeviceLocalInterface_Expecter) AddRemoteDeviceForSki(ski interface{}, rDevice interface{}) *DeviceLocalInterface_AddRemoteDeviceForSki_Call {
    74  	return &DeviceLocalInterface_AddRemoteDeviceForSki_Call{Call: _e.mock.On("AddRemoteDeviceForSki", ski, rDevice)}
    75  }
    76  
    77  func (_c *DeviceLocalInterface_AddRemoteDeviceForSki_Call) Run(run func(ski string, rDevice api.DeviceRemoteInterface)) *DeviceLocalInterface_AddRemoteDeviceForSki_Call {
    78  	_c.Call.Run(func(args mock.Arguments) {
    79  		run(args[0].(string), args[1].(api.DeviceRemoteInterface))
    80  	})
    81  	return _c
    82  }
    83  
    84  func (_c *DeviceLocalInterface_AddRemoteDeviceForSki_Call) Return() *DeviceLocalInterface_AddRemoteDeviceForSki_Call {
    85  	_c.Call.Return()
    86  	return _c
    87  }
    88  
    89  func (_c *DeviceLocalInterface_AddRemoteDeviceForSki_Call) RunAndReturn(run func(string, api.DeviceRemoteInterface)) *DeviceLocalInterface_AddRemoteDeviceForSki_Call {
    90  	_c.Call.Return(run)
    91  	return _c
    92  }
    93  
    94  // Address provides a mock function with given fields:
    95  func (_m *DeviceLocalInterface) Address() *model.AddressDeviceType {
    96  	ret := _m.Called()
    97  
    98  	if len(ret) == 0 {
    99  		panic("no return value specified for Address")
   100  	}
   101  
   102  	var r0 *model.AddressDeviceType
   103  	if rf, ok := ret.Get(0).(func() *model.AddressDeviceType); ok {
   104  		r0 = rf()
   105  	} else {
   106  		if ret.Get(0) != nil {
   107  			r0 = ret.Get(0).(*model.AddressDeviceType)
   108  		}
   109  	}
   110  
   111  	return r0
   112  }
   113  
   114  // DeviceLocalInterface_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address'
   115  type DeviceLocalInterface_Address_Call struct {
   116  	*mock.Call
   117  }
   118  
   119  // Address is a helper method to define mock.On call
   120  func (_e *DeviceLocalInterface_Expecter) Address() *DeviceLocalInterface_Address_Call {
   121  	return &DeviceLocalInterface_Address_Call{Call: _e.mock.On("Address")}
   122  }
   123  
   124  func (_c *DeviceLocalInterface_Address_Call) Run(run func()) *DeviceLocalInterface_Address_Call {
   125  	_c.Call.Run(func(args mock.Arguments) {
   126  		run()
   127  	})
   128  	return _c
   129  }
   130  
   131  func (_c *DeviceLocalInterface_Address_Call) Return(_a0 *model.AddressDeviceType) *DeviceLocalInterface_Address_Call {
   132  	_c.Call.Return(_a0)
   133  	return _c
   134  }
   135  
   136  func (_c *DeviceLocalInterface_Address_Call) RunAndReturn(run func() *model.AddressDeviceType) *DeviceLocalInterface_Address_Call {
   137  	_c.Call.Return(run)
   138  	return _c
   139  }
   140  
   141  // BindingManager provides a mock function with given fields:
   142  func (_m *DeviceLocalInterface) BindingManager() api.BindingManagerInterface {
   143  	ret := _m.Called()
   144  
   145  	if len(ret) == 0 {
   146  		panic("no return value specified for BindingManager")
   147  	}
   148  
   149  	var r0 api.BindingManagerInterface
   150  	if rf, ok := ret.Get(0).(func() api.BindingManagerInterface); ok {
   151  		r0 = rf()
   152  	} else {
   153  		if ret.Get(0) != nil {
   154  			r0 = ret.Get(0).(api.BindingManagerInterface)
   155  		}
   156  	}
   157  
   158  	return r0
   159  }
   160  
   161  // DeviceLocalInterface_BindingManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BindingManager'
   162  type DeviceLocalInterface_BindingManager_Call struct {
   163  	*mock.Call
   164  }
   165  
   166  // BindingManager is a helper method to define mock.On call
   167  func (_e *DeviceLocalInterface_Expecter) BindingManager() *DeviceLocalInterface_BindingManager_Call {
   168  	return &DeviceLocalInterface_BindingManager_Call{Call: _e.mock.On("BindingManager")}
   169  }
   170  
   171  func (_c *DeviceLocalInterface_BindingManager_Call) Run(run func()) *DeviceLocalInterface_BindingManager_Call {
   172  	_c.Call.Run(func(args mock.Arguments) {
   173  		run()
   174  	})
   175  	return _c
   176  }
   177  
   178  func (_c *DeviceLocalInterface_BindingManager_Call) Return(_a0 api.BindingManagerInterface) *DeviceLocalInterface_BindingManager_Call {
   179  	_c.Call.Return(_a0)
   180  	return _c
   181  }
   182  
   183  func (_c *DeviceLocalInterface_BindingManager_Call) RunAndReturn(run func() api.BindingManagerInterface) *DeviceLocalInterface_BindingManager_Call {
   184  	_c.Call.Return(run)
   185  	return _c
   186  }
   187  
   188  // CleanRemoteEntityCaches provides a mock function with given fields: remoteAddress
   189  func (_m *DeviceLocalInterface) CleanRemoteEntityCaches(remoteAddress *model.EntityAddressType) {
   190  	_m.Called(remoteAddress)
   191  }
   192  
   193  // DeviceLocalInterface_CleanRemoteEntityCaches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanRemoteEntityCaches'
   194  type DeviceLocalInterface_CleanRemoteEntityCaches_Call struct {
   195  	*mock.Call
   196  }
   197  
   198  // CleanRemoteEntityCaches is a helper method to define mock.On call
   199  //   - remoteAddress *model.EntityAddressType
   200  func (_e *DeviceLocalInterface_Expecter) CleanRemoteEntityCaches(remoteAddress interface{}) *DeviceLocalInterface_CleanRemoteEntityCaches_Call {
   201  	return &DeviceLocalInterface_CleanRemoteEntityCaches_Call{Call: _e.mock.On("CleanRemoteEntityCaches", remoteAddress)}
   202  }
   203  
   204  func (_c *DeviceLocalInterface_CleanRemoteEntityCaches_Call) Run(run func(remoteAddress *model.EntityAddressType)) *DeviceLocalInterface_CleanRemoteEntityCaches_Call {
   205  	_c.Call.Run(func(args mock.Arguments) {
   206  		run(args[0].(*model.EntityAddressType))
   207  	})
   208  	return _c
   209  }
   210  
   211  func (_c *DeviceLocalInterface_CleanRemoteEntityCaches_Call) Return() *DeviceLocalInterface_CleanRemoteEntityCaches_Call {
   212  	_c.Call.Return()
   213  	return _c
   214  }
   215  
   216  func (_c *DeviceLocalInterface_CleanRemoteEntityCaches_Call) RunAndReturn(run func(*model.EntityAddressType)) *DeviceLocalInterface_CleanRemoteEntityCaches_Call {
   217  	_c.Call.Return(run)
   218  	return _c
   219  }
   220  
   221  // DestinationData provides a mock function with given fields:
   222  func (_m *DeviceLocalInterface) DestinationData() model.NodeManagementDestinationDataType {
   223  	ret := _m.Called()
   224  
   225  	if len(ret) == 0 {
   226  		panic("no return value specified for DestinationData")
   227  	}
   228  
   229  	var r0 model.NodeManagementDestinationDataType
   230  	if rf, ok := ret.Get(0).(func() model.NodeManagementDestinationDataType); ok {
   231  		r0 = rf()
   232  	} else {
   233  		r0 = ret.Get(0).(model.NodeManagementDestinationDataType)
   234  	}
   235  
   236  	return r0
   237  }
   238  
   239  // DeviceLocalInterface_DestinationData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DestinationData'
   240  type DeviceLocalInterface_DestinationData_Call struct {
   241  	*mock.Call
   242  }
   243  
   244  // DestinationData is a helper method to define mock.On call
   245  func (_e *DeviceLocalInterface_Expecter) DestinationData() *DeviceLocalInterface_DestinationData_Call {
   246  	return &DeviceLocalInterface_DestinationData_Call{Call: _e.mock.On("DestinationData")}
   247  }
   248  
   249  func (_c *DeviceLocalInterface_DestinationData_Call) Run(run func()) *DeviceLocalInterface_DestinationData_Call {
   250  	_c.Call.Run(func(args mock.Arguments) {
   251  		run()
   252  	})
   253  	return _c
   254  }
   255  
   256  func (_c *DeviceLocalInterface_DestinationData_Call) Return(_a0 model.NodeManagementDestinationDataType) *DeviceLocalInterface_DestinationData_Call {
   257  	_c.Call.Return(_a0)
   258  	return _c
   259  }
   260  
   261  func (_c *DeviceLocalInterface_DestinationData_Call) RunAndReturn(run func() model.NodeManagementDestinationDataType) *DeviceLocalInterface_DestinationData_Call {
   262  	_c.Call.Return(run)
   263  	return _c
   264  }
   265  
   266  // DeviceType provides a mock function with given fields:
   267  func (_m *DeviceLocalInterface) DeviceType() *model.DeviceTypeType {
   268  	ret := _m.Called()
   269  
   270  	if len(ret) == 0 {
   271  		panic("no return value specified for DeviceType")
   272  	}
   273  
   274  	var r0 *model.DeviceTypeType
   275  	if rf, ok := ret.Get(0).(func() *model.DeviceTypeType); ok {
   276  		r0 = rf()
   277  	} else {
   278  		if ret.Get(0) != nil {
   279  			r0 = ret.Get(0).(*model.DeviceTypeType)
   280  		}
   281  	}
   282  
   283  	return r0
   284  }
   285  
   286  // DeviceLocalInterface_DeviceType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeviceType'
   287  type DeviceLocalInterface_DeviceType_Call struct {
   288  	*mock.Call
   289  }
   290  
   291  // DeviceType is a helper method to define mock.On call
   292  func (_e *DeviceLocalInterface_Expecter) DeviceType() *DeviceLocalInterface_DeviceType_Call {
   293  	return &DeviceLocalInterface_DeviceType_Call{Call: _e.mock.On("DeviceType")}
   294  }
   295  
   296  func (_c *DeviceLocalInterface_DeviceType_Call) Run(run func()) *DeviceLocalInterface_DeviceType_Call {
   297  	_c.Call.Run(func(args mock.Arguments) {
   298  		run()
   299  	})
   300  	return _c
   301  }
   302  
   303  func (_c *DeviceLocalInterface_DeviceType_Call) Return(_a0 *model.DeviceTypeType) *DeviceLocalInterface_DeviceType_Call {
   304  	_c.Call.Return(_a0)
   305  	return _c
   306  }
   307  
   308  func (_c *DeviceLocalInterface_DeviceType_Call) RunAndReturn(run func() *model.DeviceTypeType) *DeviceLocalInterface_DeviceType_Call {
   309  	_c.Call.Return(run)
   310  	return _c
   311  }
   312  
   313  // Entities provides a mock function with given fields:
   314  func (_m *DeviceLocalInterface) Entities() []api.EntityLocalInterface {
   315  	ret := _m.Called()
   316  
   317  	if len(ret) == 0 {
   318  		panic("no return value specified for Entities")
   319  	}
   320  
   321  	var r0 []api.EntityLocalInterface
   322  	if rf, ok := ret.Get(0).(func() []api.EntityLocalInterface); ok {
   323  		r0 = rf()
   324  	} else {
   325  		if ret.Get(0) != nil {
   326  			r0 = ret.Get(0).([]api.EntityLocalInterface)
   327  		}
   328  	}
   329  
   330  	return r0
   331  }
   332  
   333  // DeviceLocalInterface_Entities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Entities'
   334  type DeviceLocalInterface_Entities_Call struct {
   335  	*mock.Call
   336  }
   337  
   338  // Entities is a helper method to define mock.On call
   339  func (_e *DeviceLocalInterface_Expecter) Entities() *DeviceLocalInterface_Entities_Call {
   340  	return &DeviceLocalInterface_Entities_Call{Call: _e.mock.On("Entities")}
   341  }
   342  
   343  func (_c *DeviceLocalInterface_Entities_Call) Run(run func()) *DeviceLocalInterface_Entities_Call {
   344  	_c.Call.Run(func(args mock.Arguments) {
   345  		run()
   346  	})
   347  	return _c
   348  }
   349  
   350  func (_c *DeviceLocalInterface_Entities_Call) Return(_a0 []api.EntityLocalInterface) *DeviceLocalInterface_Entities_Call {
   351  	_c.Call.Return(_a0)
   352  	return _c
   353  }
   354  
   355  func (_c *DeviceLocalInterface_Entities_Call) RunAndReturn(run func() []api.EntityLocalInterface) *DeviceLocalInterface_Entities_Call {
   356  	_c.Call.Return(run)
   357  	return _c
   358  }
   359  
   360  // Entity provides a mock function with given fields: id
   361  func (_m *DeviceLocalInterface) Entity(id []model.AddressEntityType) api.EntityLocalInterface {
   362  	ret := _m.Called(id)
   363  
   364  	if len(ret) == 0 {
   365  		panic("no return value specified for Entity")
   366  	}
   367  
   368  	var r0 api.EntityLocalInterface
   369  	if rf, ok := ret.Get(0).(func([]model.AddressEntityType) api.EntityLocalInterface); ok {
   370  		r0 = rf(id)
   371  	} else {
   372  		if ret.Get(0) != nil {
   373  			r0 = ret.Get(0).(api.EntityLocalInterface)
   374  		}
   375  	}
   376  
   377  	return r0
   378  }
   379  
   380  // DeviceLocalInterface_Entity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Entity'
   381  type DeviceLocalInterface_Entity_Call struct {
   382  	*mock.Call
   383  }
   384  
   385  // Entity is a helper method to define mock.On call
   386  //   - id []model.AddressEntityType
   387  func (_e *DeviceLocalInterface_Expecter) Entity(id interface{}) *DeviceLocalInterface_Entity_Call {
   388  	return &DeviceLocalInterface_Entity_Call{Call: _e.mock.On("Entity", id)}
   389  }
   390  
   391  func (_c *DeviceLocalInterface_Entity_Call) Run(run func(id []model.AddressEntityType)) *DeviceLocalInterface_Entity_Call {
   392  	_c.Call.Run(func(args mock.Arguments) {
   393  		run(args[0].([]model.AddressEntityType))
   394  	})
   395  	return _c
   396  }
   397  
   398  func (_c *DeviceLocalInterface_Entity_Call) Return(_a0 api.EntityLocalInterface) *DeviceLocalInterface_Entity_Call {
   399  	_c.Call.Return(_a0)
   400  	return _c
   401  }
   402  
   403  func (_c *DeviceLocalInterface_Entity_Call) RunAndReturn(run func([]model.AddressEntityType) api.EntityLocalInterface) *DeviceLocalInterface_Entity_Call {
   404  	_c.Call.Return(run)
   405  	return _c
   406  }
   407  
   408  // EntityForType provides a mock function with given fields: entityType
   409  func (_m *DeviceLocalInterface) EntityForType(entityType model.EntityTypeType) api.EntityLocalInterface {
   410  	ret := _m.Called(entityType)
   411  
   412  	if len(ret) == 0 {
   413  		panic("no return value specified for EntityForType")
   414  	}
   415  
   416  	var r0 api.EntityLocalInterface
   417  	if rf, ok := ret.Get(0).(func(model.EntityTypeType) api.EntityLocalInterface); ok {
   418  		r0 = rf(entityType)
   419  	} else {
   420  		if ret.Get(0) != nil {
   421  			r0 = ret.Get(0).(api.EntityLocalInterface)
   422  		}
   423  	}
   424  
   425  	return r0
   426  }
   427  
   428  // DeviceLocalInterface_EntityForType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EntityForType'
   429  type DeviceLocalInterface_EntityForType_Call struct {
   430  	*mock.Call
   431  }
   432  
   433  // EntityForType is a helper method to define mock.On call
   434  //   - entityType model.EntityTypeType
   435  func (_e *DeviceLocalInterface_Expecter) EntityForType(entityType interface{}) *DeviceLocalInterface_EntityForType_Call {
   436  	return &DeviceLocalInterface_EntityForType_Call{Call: _e.mock.On("EntityForType", entityType)}
   437  }
   438  
   439  func (_c *DeviceLocalInterface_EntityForType_Call) Run(run func(entityType model.EntityTypeType)) *DeviceLocalInterface_EntityForType_Call {
   440  	_c.Call.Run(func(args mock.Arguments) {
   441  		run(args[0].(model.EntityTypeType))
   442  	})
   443  	return _c
   444  }
   445  
   446  func (_c *DeviceLocalInterface_EntityForType_Call) Return(_a0 api.EntityLocalInterface) *DeviceLocalInterface_EntityForType_Call {
   447  	_c.Call.Return(_a0)
   448  	return _c
   449  }
   450  
   451  func (_c *DeviceLocalInterface_EntityForType_Call) RunAndReturn(run func(model.EntityTypeType) api.EntityLocalInterface) *DeviceLocalInterface_EntityForType_Call {
   452  	_c.Call.Return(run)
   453  	return _c
   454  }
   455  
   456  // FeatureByAddress provides a mock function with given fields: address
   457  func (_m *DeviceLocalInterface) FeatureByAddress(address *model.FeatureAddressType) api.FeatureLocalInterface {
   458  	ret := _m.Called(address)
   459  
   460  	if len(ret) == 0 {
   461  		panic("no return value specified for FeatureByAddress")
   462  	}
   463  
   464  	var r0 api.FeatureLocalInterface
   465  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) api.FeatureLocalInterface); ok {
   466  		r0 = rf(address)
   467  	} else {
   468  		if ret.Get(0) != nil {
   469  			r0 = ret.Get(0).(api.FeatureLocalInterface)
   470  		}
   471  	}
   472  
   473  	return r0
   474  }
   475  
   476  // DeviceLocalInterface_FeatureByAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureByAddress'
   477  type DeviceLocalInterface_FeatureByAddress_Call struct {
   478  	*mock.Call
   479  }
   480  
   481  // FeatureByAddress is a helper method to define mock.On call
   482  //   - address *model.FeatureAddressType
   483  func (_e *DeviceLocalInterface_Expecter) FeatureByAddress(address interface{}) *DeviceLocalInterface_FeatureByAddress_Call {
   484  	return &DeviceLocalInterface_FeatureByAddress_Call{Call: _e.mock.On("FeatureByAddress", address)}
   485  }
   486  
   487  func (_c *DeviceLocalInterface_FeatureByAddress_Call) Run(run func(address *model.FeatureAddressType)) *DeviceLocalInterface_FeatureByAddress_Call {
   488  	_c.Call.Run(func(args mock.Arguments) {
   489  		run(args[0].(*model.FeatureAddressType))
   490  	})
   491  	return _c
   492  }
   493  
   494  func (_c *DeviceLocalInterface_FeatureByAddress_Call) Return(_a0 api.FeatureLocalInterface) *DeviceLocalInterface_FeatureByAddress_Call {
   495  	_c.Call.Return(_a0)
   496  	return _c
   497  }
   498  
   499  func (_c *DeviceLocalInterface_FeatureByAddress_Call) RunAndReturn(run func(*model.FeatureAddressType) api.FeatureLocalInterface) *DeviceLocalInterface_FeatureByAddress_Call {
   500  	_c.Call.Return(run)
   501  	return _c
   502  }
   503  
   504  // FeatureSet provides a mock function with given fields:
   505  func (_m *DeviceLocalInterface) FeatureSet() *model.NetworkManagementFeatureSetType {
   506  	ret := _m.Called()
   507  
   508  	if len(ret) == 0 {
   509  		panic("no return value specified for FeatureSet")
   510  	}
   511  
   512  	var r0 *model.NetworkManagementFeatureSetType
   513  	if rf, ok := ret.Get(0).(func() *model.NetworkManagementFeatureSetType); ok {
   514  		r0 = rf()
   515  	} else {
   516  		if ret.Get(0) != nil {
   517  			r0 = ret.Get(0).(*model.NetworkManagementFeatureSetType)
   518  		}
   519  	}
   520  
   521  	return r0
   522  }
   523  
   524  // DeviceLocalInterface_FeatureSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureSet'
   525  type DeviceLocalInterface_FeatureSet_Call struct {
   526  	*mock.Call
   527  }
   528  
   529  // FeatureSet is a helper method to define mock.On call
   530  func (_e *DeviceLocalInterface_Expecter) FeatureSet() *DeviceLocalInterface_FeatureSet_Call {
   531  	return &DeviceLocalInterface_FeatureSet_Call{Call: _e.mock.On("FeatureSet")}
   532  }
   533  
   534  func (_c *DeviceLocalInterface_FeatureSet_Call) Run(run func()) *DeviceLocalInterface_FeatureSet_Call {
   535  	_c.Call.Run(func(args mock.Arguments) {
   536  		run()
   537  	})
   538  	return _c
   539  }
   540  
   541  func (_c *DeviceLocalInterface_FeatureSet_Call) Return(_a0 *model.NetworkManagementFeatureSetType) *DeviceLocalInterface_FeatureSet_Call {
   542  	_c.Call.Return(_a0)
   543  	return _c
   544  }
   545  
   546  func (_c *DeviceLocalInterface_FeatureSet_Call) RunAndReturn(run func() *model.NetworkManagementFeatureSetType) *DeviceLocalInterface_FeatureSet_Call {
   547  	_c.Call.Return(run)
   548  	return _c
   549  }
   550  
   551  // HeartbeatManager provides a mock function with given fields:
   552  func (_m *DeviceLocalInterface) HeartbeatManager() api.HeartbeatManagerInterface {
   553  	ret := _m.Called()
   554  
   555  	if len(ret) == 0 {
   556  		panic("no return value specified for HeartbeatManager")
   557  	}
   558  
   559  	var r0 api.HeartbeatManagerInterface
   560  	if rf, ok := ret.Get(0).(func() api.HeartbeatManagerInterface); ok {
   561  		r0 = rf()
   562  	} else {
   563  		if ret.Get(0) != nil {
   564  			r0 = ret.Get(0).(api.HeartbeatManagerInterface)
   565  		}
   566  	}
   567  
   568  	return r0
   569  }
   570  
   571  // DeviceLocalInterface_HeartbeatManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeartbeatManager'
   572  type DeviceLocalInterface_HeartbeatManager_Call struct {
   573  	*mock.Call
   574  }
   575  
   576  // HeartbeatManager is a helper method to define mock.On call
   577  func (_e *DeviceLocalInterface_Expecter) HeartbeatManager() *DeviceLocalInterface_HeartbeatManager_Call {
   578  	return &DeviceLocalInterface_HeartbeatManager_Call{Call: _e.mock.On("HeartbeatManager")}
   579  }
   580  
   581  func (_c *DeviceLocalInterface_HeartbeatManager_Call) Run(run func()) *DeviceLocalInterface_HeartbeatManager_Call {
   582  	_c.Call.Run(func(args mock.Arguments) {
   583  		run()
   584  	})
   585  	return _c
   586  }
   587  
   588  func (_c *DeviceLocalInterface_HeartbeatManager_Call) Return(_a0 api.HeartbeatManagerInterface) *DeviceLocalInterface_HeartbeatManager_Call {
   589  	_c.Call.Return(_a0)
   590  	return _c
   591  }
   592  
   593  func (_c *DeviceLocalInterface_HeartbeatManager_Call) RunAndReturn(run func() api.HeartbeatManagerInterface) *DeviceLocalInterface_HeartbeatManager_Call {
   594  	_c.Call.Return(run)
   595  	return _c
   596  }
   597  
   598  // Information provides a mock function with given fields:
   599  func (_m *DeviceLocalInterface) Information() *model.NodeManagementDetailedDiscoveryDeviceInformationType {
   600  	ret := _m.Called()
   601  
   602  	if len(ret) == 0 {
   603  		panic("no return value specified for Information")
   604  	}
   605  
   606  	var r0 *model.NodeManagementDetailedDiscoveryDeviceInformationType
   607  	if rf, ok := ret.Get(0).(func() *model.NodeManagementDetailedDiscoveryDeviceInformationType); ok {
   608  		r0 = rf()
   609  	} else {
   610  		if ret.Get(0) != nil {
   611  			r0 = ret.Get(0).(*model.NodeManagementDetailedDiscoveryDeviceInformationType)
   612  		}
   613  	}
   614  
   615  	return r0
   616  }
   617  
   618  // DeviceLocalInterface_Information_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Information'
   619  type DeviceLocalInterface_Information_Call struct {
   620  	*mock.Call
   621  }
   622  
   623  // Information is a helper method to define mock.On call
   624  func (_e *DeviceLocalInterface_Expecter) Information() *DeviceLocalInterface_Information_Call {
   625  	return &DeviceLocalInterface_Information_Call{Call: _e.mock.On("Information")}
   626  }
   627  
   628  func (_c *DeviceLocalInterface_Information_Call) Run(run func()) *DeviceLocalInterface_Information_Call {
   629  	_c.Call.Run(func(args mock.Arguments) {
   630  		run()
   631  	})
   632  	return _c
   633  }
   634  
   635  func (_c *DeviceLocalInterface_Information_Call) Return(_a0 *model.NodeManagementDetailedDiscoveryDeviceInformationType) *DeviceLocalInterface_Information_Call {
   636  	_c.Call.Return(_a0)
   637  	return _c
   638  }
   639  
   640  func (_c *DeviceLocalInterface_Information_Call) RunAndReturn(run func() *model.NodeManagementDetailedDiscoveryDeviceInformationType) *DeviceLocalInterface_Information_Call {
   641  	_c.Call.Return(run)
   642  	return _c
   643  }
   644  
   645  // NodeManagement provides a mock function with given fields:
   646  func (_m *DeviceLocalInterface) NodeManagement() api.NodeManagementInterface {
   647  	ret := _m.Called()
   648  
   649  	if len(ret) == 0 {
   650  		panic("no return value specified for NodeManagement")
   651  	}
   652  
   653  	var r0 api.NodeManagementInterface
   654  	if rf, ok := ret.Get(0).(func() api.NodeManagementInterface); ok {
   655  		r0 = rf()
   656  	} else {
   657  		if ret.Get(0) != nil {
   658  			r0 = ret.Get(0).(api.NodeManagementInterface)
   659  		}
   660  	}
   661  
   662  	return r0
   663  }
   664  
   665  // DeviceLocalInterface_NodeManagement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeManagement'
   666  type DeviceLocalInterface_NodeManagement_Call struct {
   667  	*mock.Call
   668  }
   669  
   670  // NodeManagement is a helper method to define mock.On call
   671  func (_e *DeviceLocalInterface_Expecter) NodeManagement() *DeviceLocalInterface_NodeManagement_Call {
   672  	return &DeviceLocalInterface_NodeManagement_Call{Call: _e.mock.On("NodeManagement")}
   673  }
   674  
   675  func (_c *DeviceLocalInterface_NodeManagement_Call) Run(run func()) *DeviceLocalInterface_NodeManagement_Call {
   676  	_c.Call.Run(func(args mock.Arguments) {
   677  		run()
   678  	})
   679  	return _c
   680  }
   681  
   682  func (_c *DeviceLocalInterface_NodeManagement_Call) Return(_a0 api.NodeManagementInterface) *DeviceLocalInterface_NodeManagement_Call {
   683  	_c.Call.Return(_a0)
   684  	return _c
   685  }
   686  
   687  func (_c *DeviceLocalInterface_NodeManagement_Call) RunAndReturn(run func() api.NodeManagementInterface) *DeviceLocalInterface_NodeManagement_Call {
   688  	_c.Call.Return(run)
   689  	return _c
   690  }
   691  
   692  // NotifySubscribers provides a mock function with given fields: featureAddress, cmd
   693  func (_m *DeviceLocalInterface) NotifySubscribers(featureAddress *model.FeatureAddressType, cmd model.CmdType) {
   694  	_m.Called(featureAddress, cmd)
   695  }
   696  
   697  // DeviceLocalInterface_NotifySubscribers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotifySubscribers'
   698  type DeviceLocalInterface_NotifySubscribers_Call struct {
   699  	*mock.Call
   700  }
   701  
   702  // NotifySubscribers is a helper method to define mock.On call
   703  //   - featureAddress *model.FeatureAddressType
   704  //   - cmd model.CmdType
   705  func (_e *DeviceLocalInterface_Expecter) NotifySubscribers(featureAddress interface{}, cmd interface{}) *DeviceLocalInterface_NotifySubscribers_Call {
   706  	return &DeviceLocalInterface_NotifySubscribers_Call{Call: _e.mock.On("NotifySubscribers", featureAddress, cmd)}
   707  }
   708  
   709  func (_c *DeviceLocalInterface_NotifySubscribers_Call) Run(run func(featureAddress *model.FeatureAddressType, cmd model.CmdType)) *DeviceLocalInterface_NotifySubscribers_Call {
   710  	_c.Call.Run(func(args mock.Arguments) {
   711  		run(args[0].(*model.FeatureAddressType), args[1].(model.CmdType))
   712  	})
   713  	return _c
   714  }
   715  
   716  func (_c *DeviceLocalInterface_NotifySubscribers_Call) Return() *DeviceLocalInterface_NotifySubscribers_Call {
   717  	_c.Call.Return()
   718  	return _c
   719  }
   720  
   721  func (_c *DeviceLocalInterface_NotifySubscribers_Call) RunAndReturn(run func(*model.FeatureAddressType, model.CmdType)) *DeviceLocalInterface_NotifySubscribers_Call {
   722  	_c.Call.Return(run)
   723  	return _c
   724  }
   725  
   726  // ProcessCmd provides a mock function with given fields: datagram, remoteDevice
   727  func (_m *DeviceLocalInterface) ProcessCmd(datagram model.DatagramType, remoteDevice api.DeviceRemoteInterface) error {
   728  	ret := _m.Called(datagram, remoteDevice)
   729  
   730  	if len(ret) == 0 {
   731  		panic("no return value specified for ProcessCmd")
   732  	}
   733  
   734  	var r0 error
   735  	if rf, ok := ret.Get(0).(func(model.DatagramType, api.DeviceRemoteInterface) error); ok {
   736  		r0 = rf(datagram, remoteDevice)
   737  	} else {
   738  		r0 = ret.Error(0)
   739  	}
   740  
   741  	return r0
   742  }
   743  
   744  // DeviceLocalInterface_ProcessCmd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProcessCmd'
   745  type DeviceLocalInterface_ProcessCmd_Call struct {
   746  	*mock.Call
   747  }
   748  
   749  // ProcessCmd is a helper method to define mock.On call
   750  //   - datagram model.DatagramType
   751  //   - remoteDevice api.DeviceRemoteInterface
   752  func (_e *DeviceLocalInterface_Expecter) ProcessCmd(datagram interface{}, remoteDevice interface{}) *DeviceLocalInterface_ProcessCmd_Call {
   753  	return &DeviceLocalInterface_ProcessCmd_Call{Call: _e.mock.On("ProcessCmd", datagram, remoteDevice)}
   754  }
   755  
   756  func (_c *DeviceLocalInterface_ProcessCmd_Call) Run(run func(datagram model.DatagramType, remoteDevice api.DeviceRemoteInterface)) *DeviceLocalInterface_ProcessCmd_Call {
   757  	_c.Call.Run(func(args mock.Arguments) {
   758  		run(args[0].(model.DatagramType), args[1].(api.DeviceRemoteInterface))
   759  	})
   760  	return _c
   761  }
   762  
   763  func (_c *DeviceLocalInterface_ProcessCmd_Call) Return(_a0 error) *DeviceLocalInterface_ProcessCmd_Call {
   764  	_c.Call.Return(_a0)
   765  	return _c
   766  }
   767  
   768  func (_c *DeviceLocalInterface_ProcessCmd_Call) RunAndReturn(run func(model.DatagramType, api.DeviceRemoteInterface) error) *DeviceLocalInterface_ProcessCmd_Call {
   769  	_c.Call.Return(run)
   770  	return _c
   771  }
   772  
   773  // RemoteDeviceForAddress provides a mock function with given fields: address
   774  func (_m *DeviceLocalInterface) RemoteDeviceForAddress(address model.AddressDeviceType) api.DeviceRemoteInterface {
   775  	ret := _m.Called(address)
   776  
   777  	if len(ret) == 0 {
   778  		panic("no return value specified for RemoteDeviceForAddress")
   779  	}
   780  
   781  	var r0 api.DeviceRemoteInterface
   782  	if rf, ok := ret.Get(0).(func(model.AddressDeviceType) api.DeviceRemoteInterface); ok {
   783  		r0 = rf(address)
   784  	} else {
   785  		if ret.Get(0) != nil {
   786  			r0 = ret.Get(0).(api.DeviceRemoteInterface)
   787  		}
   788  	}
   789  
   790  	return r0
   791  }
   792  
   793  // DeviceLocalInterface_RemoteDeviceForAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoteDeviceForAddress'
   794  type DeviceLocalInterface_RemoteDeviceForAddress_Call struct {
   795  	*mock.Call
   796  }
   797  
   798  // RemoteDeviceForAddress is a helper method to define mock.On call
   799  //   - address model.AddressDeviceType
   800  func (_e *DeviceLocalInterface_Expecter) RemoteDeviceForAddress(address interface{}) *DeviceLocalInterface_RemoteDeviceForAddress_Call {
   801  	return &DeviceLocalInterface_RemoteDeviceForAddress_Call{Call: _e.mock.On("RemoteDeviceForAddress", address)}
   802  }
   803  
   804  func (_c *DeviceLocalInterface_RemoteDeviceForAddress_Call) Run(run func(address model.AddressDeviceType)) *DeviceLocalInterface_RemoteDeviceForAddress_Call {
   805  	_c.Call.Run(func(args mock.Arguments) {
   806  		run(args[0].(model.AddressDeviceType))
   807  	})
   808  	return _c
   809  }
   810  
   811  func (_c *DeviceLocalInterface_RemoteDeviceForAddress_Call) Return(_a0 api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDeviceForAddress_Call {
   812  	_c.Call.Return(_a0)
   813  	return _c
   814  }
   815  
   816  func (_c *DeviceLocalInterface_RemoteDeviceForAddress_Call) RunAndReturn(run func(model.AddressDeviceType) api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDeviceForAddress_Call {
   817  	_c.Call.Return(run)
   818  	return _c
   819  }
   820  
   821  // RemoteDeviceForSki provides a mock function with given fields: ski
   822  func (_m *DeviceLocalInterface) RemoteDeviceForSki(ski string) api.DeviceRemoteInterface {
   823  	ret := _m.Called(ski)
   824  
   825  	if len(ret) == 0 {
   826  		panic("no return value specified for RemoteDeviceForSki")
   827  	}
   828  
   829  	var r0 api.DeviceRemoteInterface
   830  	if rf, ok := ret.Get(0).(func(string) api.DeviceRemoteInterface); ok {
   831  		r0 = rf(ski)
   832  	} else {
   833  		if ret.Get(0) != nil {
   834  			r0 = ret.Get(0).(api.DeviceRemoteInterface)
   835  		}
   836  	}
   837  
   838  	return r0
   839  }
   840  
   841  // DeviceLocalInterface_RemoteDeviceForSki_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoteDeviceForSki'
   842  type DeviceLocalInterface_RemoteDeviceForSki_Call struct {
   843  	*mock.Call
   844  }
   845  
   846  // RemoteDeviceForSki is a helper method to define mock.On call
   847  //   - ski string
   848  func (_e *DeviceLocalInterface_Expecter) RemoteDeviceForSki(ski interface{}) *DeviceLocalInterface_RemoteDeviceForSki_Call {
   849  	return &DeviceLocalInterface_RemoteDeviceForSki_Call{Call: _e.mock.On("RemoteDeviceForSki", ski)}
   850  }
   851  
   852  func (_c *DeviceLocalInterface_RemoteDeviceForSki_Call) Run(run func(ski string)) *DeviceLocalInterface_RemoteDeviceForSki_Call {
   853  	_c.Call.Run(func(args mock.Arguments) {
   854  		run(args[0].(string))
   855  	})
   856  	return _c
   857  }
   858  
   859  func (_c *DeviceLocalInterface_RemoteDeviceForSki_Call) Return(_a0 api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDeviceForSki_Call {
   860  	_c.Call.Return(_a0)
   861  	return _c
   862  }
   863  
   864  func (_c *DeviceLocalInterface_RemoteDeviceForSki_Call) RunAndReturn(run func(string) api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDeviceForSki_Call {
   865  	_c.Call.Return(run)
   866  	return _c
   867  }
   868  
   869  // RemoteDevices provides a mock function with given fields:
   870  func (_m *DeviceLocalInterface) RemoteDevices() []api.DeviceRemoteInterface {
   871  	ret := _m.Called()
   872  
   873  	if len(ret) == 0 {
   874  		panic("no return value specified for RemoteDevices")
   875  	}
   876  
   877  	var r0 []api.DeviceRemoteInterface
   878  	if rf, ok := ret.Get(0).(func() []api.DeviceRemoteInterface); ok {
   879  		r0 = rf()
   880  	} else {
   881  		if ret.Get(0) != nil {
   882  			r0 = ret.Get(0).([]api.DeviceRemoteInterface)
   883  		}
   884  	}
   885  
   886  	return r0
   887  }
   888  
   889  // DeviceLocalInterface_RemoteDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoteDevices'
   890  type DeviceLocalInterface_RemoteDevices_Call struct {
   891  	*mock.Call
   892  }
   893  
   894  // RemoteDevices is a helper method to define mock.On call
   895  func (_e *DeviceLocalInterface_Expecter) RemoteDevices() *DeviceLocalInterface_RemoteDevices_Call {
   896  	return &DeviceLocalInterface_RemoteDevices_Call{Call: _e.mock.On("RemoteDevices")}
   897  }
   898  
   899  func (_c *DeviceLocalInterface_RemoteDevices_Call) Run(run func()) *DeviceLocalInterface_RemoteDevices_Call {
   900  	_c.Call.Run(func(args mock.Arguments) {
   901  		run()
   902  	})
   903  	return _c
   904  }
   905  
   906  func (_c *DeviceLocalInterface_RemoteDevices_Call) Return(_a0 []api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDevices_Call {
   907  	_c.Call.Return(_a0)
   908  	return _c
   909  }
   910  
   911  func (_c *DeviceLocalInterface_RemoteDevices_Call) RunAndReturn(run func() []api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDevices_Call {
   912  	_c.Call.Return(run)
   913  	return _c
   914  }
   915  
   916  // RemoveEntity provides a mock function with given fields: entity
   917  func (_m *DeviceLocalInterface) RemoveEntity(entity api.EntityLocalInterface) {
   918  	_m.Called(entity)
   919  }
   920  
   921  // DeviceLocalInterface_RemoveEntity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveEntity'
   922  type DeviceLocalInterface_RemoveEntity_Call struct {
   923  	*mock.Call
   924  }
   925  
   926  // RemoveEntity is a helper method to define mock.On call
   927  //   - entity api.EntityLocalInterface
   928  func (_e *DeviceLocalInterface_Expecter) RemoveEntity(entity interface{}) *DeviceLocalInterface_RemoveEntity_Call {
   929  	return &DeviceLocalInterface_RemoveEntity_Call{Call: _e.mock.On("RemoveEntity", entity)}
   930  }
   931  
   932  func (_c *DeviceLocalInterface_RemoveEntity_Call) Run(run func(entity api.EntityLocalInterface)) *DeviceLocalInterface_RemoveEntity_Call {
   933  	_c.Call.Run(func(args mock.Arguments) {
   934  		run(args[0].(api.EntityLocalInterface))
   935  	})
   936  	return _c
   937  }
   938  
   939  func (_c *DeviceLocalInterface_RemoveEntity_Call) Return() *DeviceLocalInterface_RemoveEntity_Call {
   940  	_c.Call.Return()
   941  	return _c
   942  }
   943  
   944  func (_c *DeviceLocalInterface_RemoveEntity_Call) RunAndReturn(run func(api.EntityLocalInterface)) *DeviceLocalInterface_RemoveEntity_Call {
   945  	_c.Call.Return(run)
   946  	return _c
   947  }
   948  
   949  // RemoveRemoteDevice provides a mock function with given fields: ski
   950  func (_m *DeviceLocalInterface) RemoveRemoteDevice(ski string) {
   951  	_m.Called(ski)
   952  }
   953  
   954  // DeviceLocalInterface_RemoveRemoteDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRemoteDevice'
   955  type DeviceLocalInterface_RemoveRemoteDevice_Call struct {
   956  	*mock.Call
   957  }
   958  
   959  // RemoveRemoteDevice is a helper method to define mock.On call
   960  //   - ski string
   961  func (_e *DeviceLocalInterface_Expecter) RemoveRemoteDevice(ski interface{}) *DeviceLocalInterface_RemoveRemoteDevice_Call {
   962  	return &DeviceLocalInterface_RemoveRemoteDevice_Call{Call: _e.mock.On("RemoveRemoteDevice", ski)}
   963  }
   964  
   965  func (_c *DeviceLocalInterface_RemoveRemoteDevice_Call) Run(run func(ski string)) *DeviceLocalInterface_RemoveRemoteDevice_Call {
   966  	_c.Call.Run(func(args mock.Arguments) {
   967  		run(args[0].(string))
   968  	})
   969  	return _c
   970  }
   971  
   972  func (_c *DeviceLocalInterface_RemoveRemoteDevice_Call) Return() *DeviceLocalInterface_RemoveRemoteDevice_Call {
   973  	_c.Call.Return()
   974  	return _c
   975  }
   976  
   977  func (_c *DeviceLocalInterface_RemoveRemoteDevice_Call) RunAndReturn(run func(string)) *DeviceLocalInterface_RemoveRemoteDevice_Call {
   978  	_c.Call.Return(run)
   979  	return _c
   980  }
   981  
   982  // RemoveRemoteDeviceConnection provides a mock function with given fields: ski
   983  func (_m *DeviceLocalInterface) RemoveRemoteDeviceConnection(ski string) {
   984  	_m.Called(ski)
   985  }
   986  
   987  // DeviceLocalInterface_RemoveRemoteDeviceConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRemoteDeviceConnection'
   988  type DeviceLocalInterface_RemoveRemoteDeviceConnection_Call struct {
   989  	*mock.Call
   990  }
   991  
   992  // RemoveRemoteDeviceConnection is a helper method to define mock.On call
   993  //   - ski string
   994  func (_e *DeviceLocalInterface_Expecter) RemoveRemoteDeviceConnection(ski interface{}) *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call {
   995  	return &DeviceLocalInterface_RemoveRemoteDeviceConnection_Call{Call: _e.mock.On("RemoveRemoteDeviceConnection", ski)}
   996  }
   997  
   998  func (_c *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call) Run(run func(ski string)) *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call {
   999  	_c.Call.Run(func(args mock.Arguments) {
  1000  		run(args[0].(string))
  1001  	})
  1002  	return _c
  1003  }
  1004  
  1005  func (_c *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call) Return() *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call {
  1006  	_c.Call.Return()
  1007  	return _c
  1008  }
  1009  
  1010  func (_c *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call) RunAndReturn(run func(string)) *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call {
  1011  	_c.Call.Return(run)
  1012  	return _c
  1013  }
  1014  
  1015  // RequestRemoteDetailedDiscoveryData provides a mock function with given fields: rDevice
  1016  func (_m *DeviceLocalInterface) RequestRemoteDetailedDiscoveryData(rDevice api.DeviceRemoteInterface) (*model.MsgCounterType, *model.ErrorType) {
  1017  	ret := _m.Called(rDevice)
  1018  
  1019  	if len(ret) == 0 {
  1020  		panic("no return value specified for RequestRemoteDetailedDiscoveryData")
  1021  	}
  1022  
  1023  	var r0 *model.MsgCounterType
  1024  	var r1 *model.ErrorType
  1025  	if rf, ok := ret.Get(0).(func(api.DeviceRemoteInterface) (*model.MsgCounterType, *model.ErrorType)); ok {
  1026  		return rf(rDevice)
  1027  	}
  1028  	if rf, ok := ret.Get(0).(func(api.DeviceRemoteInterface) *model.MsgCounterType); ok {
  1029  		r0 = rf(rDevice)
  1030  	} else {
  1031  		if ret.Get(0) != nil {
  1032  			r0 = ret.Get(0).(*model.MsgCounterType)
  1033  		}
  1034  	}
  1035  
  1036  	if rf, ok := ret.Get(1).(func(api.DeviceRemoteInterface) *model.ErrorType); ok {
  1037  		r1 = rf(rDevice)
  1038  	} else {
  1039  		if ret.Get(1) != nil {
  1040  			r1 = ret.Get(1).(*model.ErrorType)
  1041  		}
  1042  	}
  1043  
  1044  	return r0, r1
  1045  }
  1046  
  1047  // DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestRemoteDetailedDiscoveryData'
  1048  type DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call struct {
  1049  	*mock.Call
  1050  }
  1051  
  1052  // RequestRemoteDetailedDiscoveryData is a helper method to define mock.On call
  1053  //   - rDevice api.DeviceRemoteInterface
  1054  func (_e *DeviceLocalInterface_Expecter) RequestRemoteDetailedDiscoveryData(rDevice interface{}) *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call {
  1055  	return &DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call{Call: _e.mock.On("RequestRemoteDetailedDiscoveryData", rDevice)}
  1056  }
  1057  
  1058  func (_c *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call) Run(run func(rDevice api.DeviceRemoteInterface)) *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call {
  1059  	_c.Call.Run(func(args mock.Arguments) {
  1060  		run(args[0].(api.DeviceRemoteInterface))
  1061  	})
  1062  	return _c
  1063  }
  1064  
  1065  func (_c *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call {
  1066  	_c.Call.Return(_a0, _a1)
  1067  	return _c
  1068  }
  1069  
  1070  func (_c *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call) RunAndReturn(run func(api.DeviceRemoteInterface) (*model.MsgCounterType, *model.ErrorType)) *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call {
  1071  	_c.Call.Return(run)
  1072  	return _c
  1073  }
  1074  
  1075  // SetupRemoteDevice provides a mock function with given fields: ski, writeI
  1076  func (_m *DeviceLocalInterface) SetupRemoteDevice(ski string, writeI ship_goapi.ShipConnectionDataWriterInterface) ship_goapi.ShipConnectionDataReaderInterface {
  1077  	ret := _m.Called(ski, writeI)
  1078  
  1079  	if len(ret) == 0 {
  1080  		panic("no return value specified for SetupRemoteDevice")
  1081  	}
  1082  
  1083  	var r0 ship_goapi.ShipConnectionDataReaderInterface
  1084  	if rf, ok := ret.Get(0).(func(string, ship_goapi.ShipConnectionDataWriterInterface) ship_goapi.ShipConnectionDataReaderInterface); ok {
  1085  		r0 = rf(ski, writeI)
  1086  	} else {
  1087  		if ret.Get(0) != nil {
  1088  			r0 = ret.Get(0).(ship_goapi.ShipConnectionDataReaderInterface)
  1089  		}
  1090  	}
  1091  
  1092  	return r0
  1093  }
  1094  
  1095  // DeviceLocalInterface_SetupRemoteDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetupRemoteDevice'
  1096  type DeviceLocalInterface_SetupRemoteDevice_Call struct {
  1097  	*mock.Call
  1098  }
  1099  
  1100  // SetupRemoteDevice is a helper method to define mock.On call
  1101  //   - ski string
  1102  //   - writeI ship_goapi.ShipConnectionDataWriterInterface
  1103  func (_e *DeviceLocalInterface_Expecter) SetupRemoteDevice(ski interface{}, writeI interface{}) *DeviceLocalInterface_SetupRemoteDevice_Call {
  1104  	return &DeviceLocalInterface_SetupRemoteDevice_Call{Call: _e.mock.On("SetupRemoteDevice", ski, writeI)}
  1105  }
  1106  
  1107  func (_c *DeviceLocalInterface_SetupRemoteDevice_Call) Run(run func(ski string, writeI ship_goapi.ShipConnectionDataWriterInterface)) *DeviceLocalInterface_SetupRemoteDevice_Call {
  1108  	_c.Call.Run(func(args mock.Arguments) {
  1109  		run(args[0].(string), args[1].(ship_goapi.ShipConnectionDataWriterInterface))
  1110  	})
  1111  	return _c
  1112  }
  1113  
  1114  func (_c *DeviceLocalInterface_SetupRemoteDevice_Call) Return(_a0 ship_goapi.ShipConnectionDataReaderInterface) *DeviceLocalInterface_SetupRemoteDevice_Call {
  1115  	_c.Call.Return(_a0)
  1116  	return _c
  1117  }
  1118  
  1119  func (_c *DeviceLocalInterface_SetupRemoteDevice_Call) RunAndReturn(run func(string, ship_goapi.ShipConnectionDataWriterInterface) ship_goapi.ShipConnectionDataReaderInterface) *DeviceLocalInterface_SetupRemoteDevice_Call {
  1120  	_c.Call.Return(run)
  1121  	return _c
  1122  }
  1123  
  1124  // SubscriptionManager provides a mock function with given fields:
  1125  func (_m *DeviceLocalInterface) SubscriptionManager() api.SubscriptionManagerInterface {
  1126  	ret := _m.Called()
  1127  
  1128  	if len(ret) == 0 {
  1129  		panic("no return value specified for SubscriptionManager")
  1130  	}
  1131  
  1132  	var r0 api.SubscriptionManagerInterface
  1133  	if rf, ok := ret.Get(0).(func() api.SubscriptionManagerInterface); ok {
  1134  		r0 = rf()
  1135  	} else {
  1136  		if ret.Get(0) != nil {
  1137  			r0 = ret.Get(0).(api.SubscriptionManagerInterface)
  1138  		}
  1139  	}
  1140  
  1141  	return r0
  1142  }
  1143  
  1144  // DeviceLocalInterface_SubscriptionManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscriptionManager'
  1145  type DeviceLocalInterface_SubscriptionManager_Call struct {
  1146  	*mock.Call
  1147  }
  1148  
  1149  // SubscriptionManager is a helper method to define mock.On call
  1150  func (_e *DeviceLocalInterface_Expecter) SubscriptionManager() *DeviceLocalInterface_SubscriptionManager_Call {
  1151  	return &DeviceLocalInterface_SubscriptionManager_Call{Call: _e.mock.On("SubscriptionManager")}
  1152  }
  1153  
  1154  func (_c *DeviceLocalInterface_SubscriptionManager_Call) Run(run func()) *DeviceLocalInterface_SubscriptionManager_Call {
  1155  	_c.Call.Run(func(args mock.Arguments) {
  1156  		run()
  1157  	})
  1158  	return _c
  1159  }
  1160  
  1161  func (_c *DeviceLocalInterface_SubscriptionManager_Call) Return(_a0 api.SubscriptionManagerInterface) *DeviceLocalInterface_SubscriptionManager_Call {
  1162  	_c.Call.Return(_a0)
  1163  	return _c
  1164  }
  1165  
  1166  func (_c *DeviceLocalInterface_SubscriptionManager_Call) RunAndReturn(run func() api.SubscriptionManagerInterface) *DeviceLocalInterface_SubscriptionManager_Call {
  1167  	_c.Call.Return(run)
  1168  	return _c
  1169  }
  1170  
  1171  // NewDeviceLocalInterface creates a new instance of DeviceLocalInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
  1172  // The first argument is typically a *testing.T value.
  1173  func NewDeviceLocalInterface(t interface {
  1174  	mock.TestingT
  1175  	Cleanup(func())
  1176  }) *DeviceLocalInterface {
  1177  	mock := &DeviceLocalInterface{}
  1178  	mock.Mock.Test(t)
  1179  
  1180  	t.Cleanup(func() { mock.AssertExpectations(t) })
  1181  
  1182  	return mock
  1183  }