github.com/enbility/spine-go@v0.7.0/mocks/DeviceRemoteInterface.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  
    12  // DeviceRemoteInterface is an autogenerated mock type for the DeviceRemoteInterface type
    13  type DeviceRemoteInterface struct {
    14  	mock.Mock
    15  }
    16  
    17  type DeviceRemoteInterface_Expecter struct {
    18  	mock *mock.Mock
    19  }
    20  
    21  func (_m *DeviceRemoteInterface) EXPECT() *DeviceRemoteInterface_Expecter {
    22  	return &DeviceRemoteInterface_Expecter{mock: &_m.Mock}
    23  }
    24  
    25  // AddEntity provides a mock function with given fields: entity
    26  func (_m *DeviceRemoteInterface) AddEntity(entity api.EntityRemoteInterface) {
    27  	_m.Called(entity)
    28  }
    29  
    30  // DeviceRemoteInterface_AddEntity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddEntity'
    31  type DeviceRemoteInterface_AddEntity_Call struct {
    32  	*mock.Call
    33  }
    34  
    35  // AddEntity is a helper method to define mock.On call
    36  //   - entity api.EntityRemoteInterface
    37  func (_e *DeviceRemoteInterface_Expecter) AddEntity(entity interface{}) *DeviceRemoteInterface_AddEntity_Call {
    38  	return &DeviceRemoteInterface_AddEntity_Call{Call: _e.mock.On("AddEntity", entity)}
    39  }
    40  
    41  func (_c *DeviceRemoteInterface_AddEntity_Call) Run(run func(entity api.EntityRemoteInterface)) *DeviceRemoteInterface_AddEntity_Call {
    42  	_c.Call.Run(func(args mock.Arguments) {
    43  		run(args[0].(api.EntityRemoteInterface))
    44  	})
    45  	return _c
    46  }
    47  
    48  func (_c *DeviceRemoteInterface_AddEntity_Call) Return() *DeviceRemoteInterface_AddEntity_Call {
    49  	_c.Call.Return()
    50  	return _c
    51  }
    52  
    53  func (_c *DeviceRemoteInterface_AddEntity_Call) RunAndReturn(run func(api.EntityRemoteInterface)) *DeviceRemoteInterface_AddEntity_Call {
    54  	_c.Call.Return(run)
    55  	return _c
    56  }
    57  
    58  // AddEntityAndFeatures provides a mock function with given fields: initialData, data
    59  func (_m *DeviceRemoteInterface) AddEntityAndFeatures(initialData bool, data *model.NodeManagementDetailedDiscoveryDataType) ([]api.EntityRemoteInterface, error) {
    60  	ret := _m.Called(initialData, data)
    61  
    62  	if len(ret) == 0 {
    63  		panic("no return value specified for AddEntityAndFeatures")
    64  	}
    65  
    66  	var r0 []api.EntityRemoteInterface
    67  	var r1 error
    68  	if rf, ok := ret.Get(0).(func(bool, *model.NodeManagementDetailedDiscoveryDataType) ([]api.EntityRemoteInterface, error)); ok {
    69  		return rf(initialData, data)
    70  	}
    71  	if rf, ok := ret.Get(0).(func(bool, *model.NodeManagementDetailedDiscoveryDataType) []api.EntityRemoteInterface); ok {
    72  		r0 = rf(initialData, data)
    73  	} else {
    74  		if ret.Get(0) != nil {
    75  			r0 = ret.Get(0).([]api.EntityRemoteInterface)
    76  		}
    77  	}
    78  
    79  	if rf, ok := ret.Get(1).(func(bool, *model.NodeManagementDetailedDiscoveryDataType) error); ok {
    80  		r1 = rf(initialData, data)
    81  	} else {
    82  		r1 = ret.Error(1)
    83  	}
    84  
    85  	return r0, r1
    86  }
    87  
    88  // DeviceRemoteInterface_AddEntityAndFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddEntityAndFeatures'
    89  type DeviceRemoteInterface_AddEntityAndFeatures_Call struct {
    90  	*mock.Call
    91  }
    92  
    93  // AddEntityAndFeatures is a helper method to define mock.On call
    94  //   - initialData bool
    95  //   - data *model.NodeManagementDetailedDiscoveryDataType
    96  func (_e *DeviceRemoteInterface_Expecter) AddEntityAndFeatures(initialData interface{}, data interface{}) *DeviceRemoteInterface_AddEntityAndFeatures_Call {
    97  	return &DeviceRemoteInterface_AddEntityAndFeatures_Call{Call: _e.mock.On("AddEntityAndFeatures", initialData, data)}
    98  }
    99  
   100  func (_c *DeviceRemoteInterface_AddEntityAndFeatures_Call) Run(run func(initialData bool, data *model.NodeManagementDetailedDiscoveryDataType)) *DeviceRemoteInterface_AddEntityAndFeatures_Call {
   101  	_c.Call.Run(func(args mock.Arguments) {
   102  		run(args[0].(bool), args[1].(*model.NodeManagementDetailedDiscoveryDataType))
   103  	})
   104  	return _c
   105  }
   106  
   107  func (_c *DeviceRemoteInterface_AddEntityAndFeatures_Call) Return(_a0 []api.EntityRemoteInterface, _a1 error) *DeviceRemoteInterface_AddEntityAndFeatures_Call {
   108  	_c.Call.Return(_a0, _a1)
   109  	return _c
   110  }
   111  
   112  func (_c *DeviceRemoteInterface_AddEntityAndFeatures_Call) RunAndReturn(run func(bool, *model.NodeManagementDetailedDiscoveryDataType) ([]api.EntityRemoteInterface, error)) *DeviceRemoteInterface_AddEntityAndFeatures_Call {
   113  	_c.Call.Return(run)
   114  	return _c
   115  }
   116  
   117  // Address provides a mock function with given fields:
   118  func (_m *DeviceRemoteInterface) Address() *model.AddressDeviceType {
   119  	ret := _m.Called()
   120  
   121  	if len(ret) == 0 {
   122  		panic("no return value specified for Address")
   123  	}
   124  
   125  	var r0 *model.AddressDeviceType
   126  	if rf, ok := ret.Get(0).(func() *model.AddressDeviceType); ok {
   127  		r0 = rf()
   128  	} else {
   129  		if ret.Get(0) != nil {
   130  			r0 = ret.Get(0).(*model.AddressDeviceType)
   131  		}
   132  	}
   133  
   134  	return r0
   135  }
   136  
   137  // DeviceRemoteInterface_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address'
   138  type DeviceRemoteInterface_Address_Call struct {
   139  	*mock.Call
   140  }
   141  
   142  // Address is a helper method to define mock.On call
   143  func (_e *DeviceRemoteInterface_Expecter) Address() *DeviceRemoteInterface_Address_Call {
   144  	return &DeviceRemoteInterface_Address_Call{Call: _e.mock.On("Address")}
   145  }
   146  
   147  func (_c *DeviceRemoteInterface_Address_Call) Run(run func()) *DeviceRemoteInterface_Address_Call {
   148  	_c.Call.Run(func(args mock.Arguments) {
   149  		run()
   150  	})
   151  	return _c
   152  }
   153  
   154  func (_c *DeviceRemoteInterface_Address_Call) Return(_a0 *model.AddressDeviceType) *DeviceRemoteInterface_Address_Call {
   155  	_c.Call.Return(_a0)
   156  	return _c
   157  }
   158  
   159  func (_c *DeviceRemoteInterface_Address_Call) RunAndReturn(run func() *model.AddressDeviceType) *DeviceRemoteInterface_Address_Call {
   160  	_c.Call.Return(run)
   161  	return _c
   162  }
   163  
   164  // CheckEntityInformation provides a mock function with given fields: initialData, entity
   165  func (_m *DeviceRemoteInterface) CheckEntityInformation(initialData bool, entity model.NodeManagementDetailedDiscoveryEntityInformationType) error {
   166  	ret := _m.Called(initialData, entity)
   167  
   168  	if len(ret) == 0 {
   169  		panic("no return value specified for CheckEntityInformation")
   170  	}
   171  
   172  	var r0 error
   173  	if rf, ok := ret.Get(0).(func(bool, model.NodeManagementDetailedDiscoveryEntityInformationType) error); ok {
   174  		r0 = rf(initialData, entity)
   175  	} else {
   176  		r0 = ret.Error(0)
   177  	}
   178  
   179  	return r0
   180  }
   181  
   182  // DeviceRemoteInterface_CheckEntityInformation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckEntityInformation'
   183  type DeviceRemoteInterface_CheckEntityInformation_Call struct {
   184  	*mock.Call
   185  }
   186  
   187  // CheckEntityInformation is a helper method to define mock.On call
   188  //   - initialData bool
   189  //   - entity model.NodeManagementDetailedDiscoveryEntityInformationType
   190  func (_e *DeviceRemoteInterface_Expecter) CheckEntityInformation(initialData interface{}, entity interface{}) *DeviceRemoteInterface_CheckEntityInformation_Call {
   191  	return &DeviceRemoteInterface_CheckEntityInformation_Call{Call: _e.mock.On("CheckEntityInformation", initialData, entity)}
   192  }
   193  
   194  func (_c *DeviceRemoteInterface_CheckEntityInformation_Call) Run(run func(initialData bool, entity model.NodeManagementDetailedDiscoveryEntityInformationType)) *DeviceRemoteInterface_CheckEntityInformation_Call {
   195  	_c.Call.Run(func(args mock.Arguments) {
   196  		run(args[0].(bool), args[1].(model.NodeManagementDetailedDiscoveryEntityInformationType))
   197  	})
   198  	return _c
   199  }
   200  
   201  func (_c *DeviceRemoteInterface_CheckEntityInformation_Call) Return(_a0 error) *DeviceRemoteInterface_CheckEntityInformation_Call {
   202  	_c.Call.Return(_a0)
   203  	return _c
   204  }
   205  
   206  func (_c *DeviceRemoteInterface_CheckEntityInformation_Call) RunAndReturn(run func(bool, model.NodeManagementDetailedDiscoveryEntityInformationType) error) *DeviceRemoteInterface_CheckEntityInformation_Call {
   207  	_c.Call.Return(run)
   208  	return _c
   209  }
   210  
   211  // DestinationData provides a mock function with given fields:
   212  func (_m *DeviceRemoteInterface) DestinationData() model.NodeManagementDestinationDataType {
   213  	ret := _m.Called()
   214  
   215  	if len(ret) == 0 {
   216  		panic("no return value specified for DestinationData")
   217  	}
   218  
   219  	var r0 model.NodeManagementDestinationDataType
   220  	if rf, ok := ret.Get(0).(func() model.NodeManagementDestinationDataType); ok {
   221  		r0 = rf()
   222  	} else {
   223  		r0 = ret.Get(0).(model.NodeManagementDestinationDataType)
   224  	}
   225  
   226  	return r0
   227  }
   228  
   229  // DeviceRemoteInterface_DestinationData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DestinationData'
   230  type DeviceRemoteInterface_DestinationData_Call struct {
   231  	*mock.Call
   232  }
   233  
   234  // DestinationData is a helper method to define mock.On call
   235  func (_e *DeviceRemoteInterface_Expecter) DestinationData() *DeviceRemoteInterface_DestinationData_Call {
   236  	return &DeviceRemoteInterface_DestinationData_Call{Call: _e.mock.On("DestinationData")}
   237  }
   238  
   239  func (_c *DeviceRemoteInterface_DestinationData_Call) Run(run func()) *DeviceRemoteInterface_DestinationData_Call {
   240  	_c.Call.Run(func(args mock.Arguments) {
   241  		run()
   242  	})
   243  	return _c
   244  }
   245  
   246  func (_c *DeviceRemoteInterface_DestinationData_Call) Return(_a0 model.NodeManagementDestinationDataType) *DeviceRemoteInterface_DestinationData_Call {
   247  	_c.Call.Return(_a0)
   248  	return _c
   249  }
   250  
   251  func (_c *DeviceRemoteInterface_DestinationData_Call) RunAndReturn(run func() model.NodeManagementDestinationDataType) *DeviceRemoteInterface_DestinationData_Call {
   252  	_c.Call.Return(run)
   253  	return _c
   254  }
   255  
   256  // DeviceType provides a mock function with given fields:
   257  func (_m *DeviceRemoteInterface) DeviceType() *model.DeviceTypeType {
   258  	ret := _m.Called()
   259  
   260  	if len(ret) == 0 {
   261  		panic("no return value specified for DeviceType")
   262  	}
   263  
   264  	var r0 *model.DeviceTypeType
   265  	if rf, ok := ret.Get(0).(func() *model.DeviceTypeType); ok {
   266  		r0 = rf()
   267  	} else {
   268  		if ret.Get(0) != nil {
   269  			r0 = ret.Get(0).(*model.DeviceTypeType)
   270  		}
   271  	}
   272  
   273  	return r0
   274  }
   275  
   276  // DeviceRemoteInterface_DeviceType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeviceType'
   277  type DeviceRemoteInterface_DeviceType_Call struct {
   278  	*mock.Call
   279  }
   280  
   281  // DeviceType is a helper method to define mock.On call
   282  func (_e *DeviceRemoteInterface_Expecter) DeviceType() *DeviceRemoteInterface_DeviceType_Call {
   283  	return &DeviceRemoteInterface_DeviceType_Call{Call: _e.mock.On("DeviceType")}
   284  }
   285  
   286  func (_c *DeviceRemoteInterface_DeviceType_Call) Run(run func()) *DeviceRemoteInterface_DeviceType_Call {
   287  	_c.Call.Run(func(args mock.Arguments) {
   288  		run()
   289  	})
   290  	return _c
   291  }
   292  
   293  func (_c *DeviceRemoteInterface_DeviceType_Call) Return(_a0 *model.DeviceTypeType) *DeviceRemoteInterface_DeviceType_Call {
   294  	_c.Call.Return(_a0)
   295  	return _c
   296  }
   297  
   298  func (_c *DeviceRemoteInterface_DeviceType_Call) RunAndReturn(run func() *model.DeviceTypeType) *DeviceRemoteInterface_DeviceType_Call {
   299  	_c.Call.Return(run)
   300  	return _c
   301  }
   302  
   303  // Entities provides a mock function with given fields:
   304  func (_m *DeviceRemoteInterface) Entities() []api.EntityRemoteInterface {
   305  	ret := _m.Called()
   306  
   307  	if len(ret) == 0 {
   308  		panic("no return value specified for Entities")
   309  	}
   310  
   311  	var r0 []api.EntityRemoteInterface
   312  	if rf, ok := ret.Get(0).(func() []api.EntityRemoteInterface); ok {
   313  		r0 = rf()
   314  	} else {
   315  		if ret.Get(0) != nil {
   316  			r0 = ret.Get(0).([]api.EntityRemoteInterface)
   317  		}
   318  	}
   319  
   320  	return r0
   321  }
   322  
   323  // DeviceRemoteInterface_Entities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Entities'
   324  type DeviceRemoteInterface_Entities_Call struct {
   325  	*mock.Call
   326  }
   327  
   328  // Entities is a helper method to define mock.On call
   329  func (_e *DeviceRemoteInterface_Expecter) Entities() *DeviceRemoteInterface_Entities_Call {
   330  	return &DeviceRemoteInterface_Entities_Call{Call: _e.mock.On("Entities")}
   331  }
   332  
   333  func (_c *DeviceRemoteInterface_Entities_Call) Run(run func()) *DeviceRemoteInterface_Entities_Call {
   334  	_c.Call.Run(func(args mock.Arguments) {
   335  		run()
   336  	})
   337  	return _c
   338  }
   339  
   340  func (_c *DeviceRemoteInterface_Entities_Call) Return(_a0 []api.EntityRemoteInterface) *DeviceRemoteInterface_Entities_Call {
   341  	_c.Call.Return(_a0)
   342  	return _c
   343  }
   344  
   345  func (_c *DeviceRemoteInterface_Entities_Call) RunAndReturn(run func() []api.EntityRemoteInterface) *DeviceRemoteInterface_Entities_Call {
   346  	_c.Call.Return(run)
   347  	return _c
   348  }
   349  
   350  // Entity provides a mock function with given fields: id
   351  func (_m *DeviceRemoteInterface) Entity(id []model.AddressEntityType) api.EntityRemoteInterface {
   352  	ret := _m.Called(id)
   353  
   354  	if len(ret) == 0 {
   355  		panic("no return value specified for Entity")
   356  	}
   357  
   358  	var r0 api.EntityRemoteInterface
   359  	if rf, ok := ret.Get(0).(func([]model.AddressEntityType) api.EntityRemoteInterface); ok {
   360  		r0 = rf(id)
   361  	} else {
   362  		if ret.Get(0) != nil {
   363  			r0 = ret.Get(0).(api.EntityRemoteInterface)
   364  		}
   365  	}
   366  
   367  	return r0
   368  }
   369  
   370  // DeviceRemoteInterface_Entity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Entity'
   371  type DeviceRemoteInterface_Entity_Call struct {
   372  	*mock.Call
   373  }
   374  
   375  // Entity is a helper method to define mock.On call
   376  //   - id []model.AddressEntityType
   377  func (_e *DeviceRemoteInterface_Expecter) Entity(id interface{}) *DeviceRemoteInterface_Entity_Call {
   378  	return &DeviceRemoteInterface_Entity_Call{Call: _e.mock.On("Entity", id)}
   379  }
   380  
   381  func (_c *DeviceRemoteInterface_Entity_Call) Run(run func(id []model.AddressEntityType)) *DeviceRemoteInterface_Entity_Call {
   382  	_c.Call.Run(func(args mock.Arguments) {
   383  		run(args[0].([]model.AddressEntityType))
   384  	})
   385  	return _c
   386  }
   387  
   388  func (_c *DeviceRemoteInterface_Entity_Call) Return(_a0 api.EntityRemoteInterface) *DeviceRemoteInterface_Entity_Call {
   389  	_c.Call.Return(_a0)
   390  	return _c
   391  }
   392  
   393  func (_c *DeviceRemoteInterface_Entity_Call) RunAndReturn(run func([]model.AddressEntityType) api.EntityRemoteInterface) *DeviceRemoteInterface_Entity_Call {
   394  	_c.Call.Return(run)
   395  	return _c
   396  }
   397  
   398  // FeatureByAddress provides a mock function with given fields: address
   399  func (_m *DeviceRemoteInterface) FeatureByAddress(address *model.FeatureAddressType) api.FeatureRemoteInterface {
   400  	ret := _m.Called(address)
   401  
   402  	if len(ret) == 0 {
   403  		panic("no return value specified for FeatureByAddress")
   404  	}
   405  
   406  	var r0 api.FeatureRemoteInterface
   407  	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) api.FeatureRemoteInterface); ok {
   408  		r0 = rf(address)
   409  	} else {
   410  		if ret.Get(0) != nil {
   411  			r0 = ret.Get(0).(api.FeatureRemoteInterface)
   412  		}
   413  	}
   414  
   415  	return r0
   416  }
   417  
   418  // DeviceRemoteInterface_FeatureByAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureByAddress'
   419  type DeviceRemoteInterface_FeatureByAddress_Call struct {
   420  	*mock.Call
   421  }
   422  
   423  // FeatureByAddress is a helper method to define mock.On call
   424  //   - address *model.FeatureAddressType
   425  func (_e *DeviceRemoteInterface_Expecter) FeatureByAddress(address interface{}) *DeviceRemoteInterface_FeatureByAddress_Call {
   426  	return &DeviceRemoteInterface_FeatureByAddress_Call{Call: _e.mock.On("FeatureByAddress", address)}
   427  }
   428  
   429  func (_c *DeviceRemoteInterface_FeatureByAddress_Call) Run(run func(address *model.FeatureAddressType)) *DeviceRemoteInterface_FeatureByAddress_Call {
   430  	_c.Call.Run(func(args mock.Arguments) {
   431  		run(args[0].(*model.FeatureAddressType))
   432  	})
   433  	return _c
   434  }
   435  
   436  func (_c *DeviceRemoteInterface_FeatureByAddress_Call) Return(_a0 api.FeatureRemoteInterface) *DeviceRemoteInterface_FeatureByAddress_Call {
   437  	_c.Call.Return(_a0)
   438  	return _c
   439  }
   440  
   441  func (_c *DeviceRemoteInterface_FeatureByAddress_Call) RunAndReturn(run func(*model.FeatureAddressType) api.FeatureRemoteInterface) *DeviceRemoteInterface_FeatureByAddress_Call {
   442  	_c.Call.Return(run)
   443  	return _c
   444  }
   445  
   446  // FeatureByEntityTypeAndRole provides a mock function with given fields: entity, featureType, role
   447  func (_m *DeviceRemoteInterface) FeatureByEntityTypeAndRole(entity api.EntityRemoteInterface, featureType model.FeatureTypeType, role model.RoleType) api.FeatureRemoteInterface {
   448  	ret := _m.Called(entity, featureType, role)
   449  
   450  	if len(ret) == 0 {
   451  		panic("no return value specified for FeatureByEntityTypeAndRole")
   452  	}
   453  
   454  	var r0 api.FeatureRemoteInterface
   455  	if rf, ok := ret.Get(0).(func(api.EntityRemoteInterface, model.FeatureTypeType, model.RoleType) api.FeatureRemoteInterface); ok {
   456  		r0 = rf(entity, featureType, role)
   457  	} else {
   458  		if ret.Get(0) != nil {
   459  			r0 = ret.Get(0).(api.FeatureRemoteInterface)
   460  		}
   461  	}
   462  
   463  	return r0
   464  }
   465  
   466  // DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureByEntityTypeAndRole'
   467  type DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call struct {
   468  	*mock.Call
   469  }
   470  
   471  // FeatureByEntityTypeAndRole is a helper method to define mock.On call
   472  //   - entity api.EntityRemoteInterface
   473  //   - featureType model.FeatureTypeType
   474  //   - role model.RoleType
   475  func (_e *DeviceRemoteInterface_Expecter) FeatureByEntityTypeAndRole(entity interface{}, featureType interface{}, role interface{}) *DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call {
   476  	return &DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call{Call: _e.mock.On("FeatureByEntityTypeAndRole", entity, featureType, role)}
   477  }
   478  
   479  func (_c *DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call) Run(run func(entity api.EntityRemoteInterface, featureType model.FeatureTypeType, role model.RoleType)) *DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call {
   480  	_c.Call.Run(func(args mock.Arguments) {
   481  		run(args[0].(api.EntityRemoteInterface), args[1].(model.FeatureTypeType), args[2].(model.RoleType))
   482  	})
   483  	return _c
   484  }
   485  
   486  func (_c *DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call) Return(_a0 api.FeatureRemoteInterface) *DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call {
   487  	_c.Call.Return(_a0)
   488  	return _c
   489  }
   490  
   491  func (_c *DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call) RunAndReturn(run func(api.EntityRemoteInterface, model.FeatureTypeType, model.RoleType) api.FeatureRemoteInterface) *DeviceRemoteInterface_FeatureByEntityTypeAndRole_Call {
   492  	_c.Call.Return(run)
   493  	return _c
   494  }
   495  
   496  // FeatureSet provides a mock function with given fields:
   497  func (_m *DeviceRemoteInterface) FeatureSet() *model.NetworkManagementFeatureSetType {
   498  	ret := _m.Called()
   499  
   500  	if len(ret) == 0 {
   501  		panic("no return value specified for FeatureSet")
   502  	}
   503  
   504  	var r0 *model.NetworkManagementFeatureSetType
   505  	if rf, ok := ret.Get(0).(func() *model.NetworkManagementFeatureSetType); ok {
   506  		r0 = rf()
   507  	} else {
   508  		if ret.Get(0) != nil {
   509  			r0 = ret.Get(0).(*model.NetworkManagementFeatureSetType)
   510  		}
   511  	}
   512  
   513  	return r0
   514  }
   515  
   516  // DeviceRemoteInterface_FeatureSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureSet'
   517  type DeviceRemoteInterface_FeatureSet_Call struct {
   518  	*mock.Call
   519  }
   520  
   521  // FeatureSet is a helper method to define mock.On call
   522  func (_e *DeviceRemoteInterface_Expecter) FeatureSet() *DeviceRemoteInterface_FeatureSet_Call {
   523  	return &DeviceRemoteInterface_FeatureSet_Call{Call: _e.mock.On("FeatureSet")}
   524  }
   525  
   526  func (_c *DeviceRemoteInterface_FeatureSet_Call) Run(run func()) *DeviceRemoteInterface_FeatureSet_Call {
   527  	_c.Call.Run(func(args mock.Arguments) {
   528  		run()
   529  	})
   530  	return _c
   531  }
   532  
   533  func (_c *DeviceRemoteInterface_FeatureSet_Call) Return(_a0 *model.NetworkManagementFeatureSetType) *DeviceRemoteInterface_FeatureSet_Call {
   534  	_c.Call.Return(_a0)
   535  	return _c
   536  }
   537  
   538  func (_c *DeviceRemoteInterface_FeatureSet_Call) RunAndReturn(run func() *model.NetworkManagementFeatureSetType) *DeviceRemoteInterface_FeatureSet_Call {
   539  	_c.Call.Return(run)
   540  	return _c
   541  }
   542  
   543  // HandleSpineMesssage provides a mock function with given fields: message
   544  func (_m *DeviceRemoteInterface) HandleSpineMesssage(message []byte) (*model.MsgCounterType, error) {
   545  	ret := _m.Called(message)
   546  
   547  	if len(ret) == 0 {
   548  		panic("no return value specified for HandleSpineMesssage")
   549  	}
   550  
   551  	var r0 *model.MsgCounterType
   552  	var r1 error
   553  	if rf, ok := ret.Get(0).(func([]byte) (*model.MsgCounterType, error)); ok {
   554  		return rf(message)
   555  	}
   556  	if rf, ok := ret.Get(0).(func([]byte) *model.MsgCounterType); ok {
   557  		r0 = rf(message)
   558  	} else {
   559  		if ret.Get(0) != nil {
   560  			r0 = ret.Get(0).(*model.MsgCounterType)
   561  		}
   562  	}
   563  
   564  	if rf, ok := ret.Get(1).(func([]byte) error); ok {
   565  		r1 = rf(message)
   566  	} else {
   567  		r1 = ret.Error(1)
   568  	}
   569  
   570  	return r0, r1
   571  }
   572  
   573  // DeviceRemoteInterface_HandleSpineMesssage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HandleSpineMesssage'
   574  type DeviceRemoteInterface_HandleSpineMesssage_Call struct {
   575  	*mock.Call
   576  }
   577  
   578  // HandleSpineMesssage is a helper method to define mock.On call
   579  //   - message []byte
   580  func (_e *DeviceRemoteInterface_Expecter) HandleSpineMesssage(message interface{}) *DeviceRemoteInterface_HandleSpineMesssage_Call {
   581  	return &DeviceRemoteInterface_HandleSpineMesssage_Call{Call: _e.mock.On("HandleSpineMesssage", message)}
   582  }
   583  
   584  func (_c *DeviceRemoteInterface_HandleSpineMesssage_Call) Run(run func(message []byte)) *DeviceRemoteInterface_HandleSpineMesssage_Call {
   585  	_c.Call.Run(func(args mock.Arguments) {
   586  		run(args[0].([]byte))
   587  	})
   588  	return _c
   589  }
   590  
   591  func (_c *DeviceRemoteInterface_HandleSpineMesssage_Call) Return(_a0 *model.MsgCounterType, _a1 error) *DeviceRemoteInterface_HandleSpineMesssage_Call {
   592  	_c.Call.Return(_a0, _a1)
   593  	return _c
   594  }
   595  
   596  func (_c *DeviceRemoteInterface_HandleSpineMesssage_Call) RunAndReturn(run func([]byte) (*model.MsgCounterType, error)) *DeviceRemoteInterface_HandleSpineMesssage_Call {
   597  	_c.Call.Return(run)
   598  	return _c
   599  }
   600  
   601  // RemoveEntityByAddress provides a mock function with given fields: addr
   602  func (_m *DeviceRemoteInterface) RemoveEntityByAddress(addr []model.AddressEntityType) api.EntityRemoteInterface {
   603  	ret := _m.Called(addr)
   604  
   605  	if len(ret) == 0 {
   606  		panic("no return value specified for RemoveEntityByAddress")
   607  	}
   608  
   609  	var r0 api.EntityRemoteInterface
   610  	if rf, ok := ret.Get(0).(func([]model.AddressEntityType) api.EntityRemoteInterface); ok {
   611  		r0 = rf(addr)
   612  	} else {
   613  		if ret.Get(0) != nil {
   614  			r0 = ret.Get(0).(api.EntityRemoteInterface)
   615  		}
   616  	}
   617  
   618  	return r0
   619  }
   620  
   621  // DeviceRemoteInterface_RemoveEntityByAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveEntityByAddress'
   622  type DeviceRemoteInterface_RemoveEntityByAddress_Call struct {
   623  	*mock.Call
   624  }
   625  
   626  // RemoveEntityByAddress is a helper method to define mock.On call
   627  //   - addr []model.AddressEntityType
   628  func (_e *DeviceRemoteInterface_Expecter) RemoveEntityByAddress(addr interface{}) *DeviceRemoteInterface_RemoveEntityByAddress_Call {
   629  	return &DeviceRemoteInterface_RemoveEntityByAddress_Call{Call: _e.mock.On("RemoveEntityByAddress", addr)}
   630  }
   631  
   632  func (_c *DeviceRemoteInterface_RemoveEntityByAddress_Call) Run(run func(addr []model.AddressEntityType)) *DeviceRemoteInterface_RemoveEntityByAddress_Call {
   633  	_c.Call.Run(func(args mock.Arguments) {
   634  		run(args[0].([]model.AddressEntityType))
   635  	})
   636  	return _c
   637  }
   638  
   639  func (_c *DeviceRemoteInterface_RemoveEntityByAddress_Call) Return(_a0 api.EntityRemoteInterface) *DeviceRemoteInterface_RemoveEntityByAddress_Call {
   640  	_c.Call.Return(_a0)
   641  	return _c
   642  }
   643  
   644  func (_c *DeviceRemoteInterface_RemoveEntityByAddress_Call) RunAndReturn(run func([]model.AddressEntityType) api.EntityRemoteInterface) *DeviceRemoteInterface_RemoveEntityByAddress_Call {
   645  	_c.Call.Return(run)
   646  	return _c
   647  }
   648  
   649  // Sender provides a mock function with given fields:
   650  func (_m *DeviceRemoteInterface) Sender() api.SenderInterface {
   651  	ret := _m.Called()
   652  
   653  	if len(ret) == 0 {
   654  		panic("no return value specified for Sender")
   655  	}
   656  
   657  	var r0 api.SenderInterface
   658  	if rf, ok := ret.Get(0).(func() api.SenderInterface); ok {
   659  		r0 = rf()
   660  	} else {
   661  		if ret.Get(0) != nil {
   662  			r0 = ret.Get(0).(api.SenderInterface)
   663  		}
   664  	}
   665  
   666  	return r0
   667  }
   668  
   669  // DeviceRemoteInterface_Sender_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sender'
   670  type DeviceRemoteInterface_Sender_Call struct {
   671  	*mock.Call
   672  }
   673  
   674  // Sender is a helper method to define mock.On call
   675  func (_e *DeviceRemoteInterface_Expecter) Sender() *DeviceRemoteInterface_Sender_Call {
   676  	return &DeviceRemoteInterface_Sender_Call{Call: _e.mock.On("Sender")}
   677  }
   678  
   679  func (_c *DeviceRemoteInterface_Sender_Call) Run(run func()) *DeviceRemoteInterface_Sender_Call {
   680  	_c.Call.Run(func(args mock.Arguments) {
   681  		run()
   682  	})
   683  	return _c
   684  }
   685  
   686  func (_c *DeviceRemoteInterface_Sender_Call) Return(_a0 api.SenderInterface) *DeviceRemoteInterface_Sender_Call {
   687  	_c.Call.Return(_a0)
   688  	return _c
   689  }
   690  
   691  func (_c *DeviceRemoteInterface_Sender_Call) RunAndReturn(run func() api.SenderInterface) *DeviceRemoteInterface_Sender_Call {
   692  	_c.Call.Return(run)
   693  	return _c
   694  }
   695  
   696  // Ski provides a mock function with given fields:
   697  func (_m *DeviceRemoteInterface) Ski() string {
   698  	ret := _m.Called()
   699  
   700  	if len(ret) == 0 {
   701  		panic("no return value specified for Ski")
   702  	}
   703  
   704  	var r0 string
   705  	if rf, ok := ret.Get(0).(func() string); ok {
   706  		r0 = rf()
   707  	} else {
   708  		r0 = ret.Get(0).(string)
   709  	}
   710  
   711  	return r0
   712  }
   713  
   714  // DeviceRemoteInterface_Ski_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ski'
   715  type DeviceRemoteInterface_Ski_Call struct {
   716  	*mock.Call
   717  }
   718  
   719  // Ski is a helper method to define mock.On call
   720  func (_e *DeviceRemoteInterface_Expecter) Ski() *DeviceRemoteInterface_Ski_Call {
   721  	return &DeviceRemoteInterface_Ski_Call{Call: _e.mock.On("Ski")}
   722  }
   723  
   724  func (_c *DeviceRemoteInterface_Ski_Call) Run(run func()) *DeviceRemoteInterface_Ski_Call {
   725  	_c.Call.Run(func(args mock.Arguments) {
   726  		run()
   727  	})
   728  	return _c
   729  }
   730  
   731  func (_c *DeviceRemoteInterface_Ski_Call) Return(_a0 string) *DeviceRemoteInterface_Ski_Call {
   732  	_c.Call.Return(_a0)
   733  	return _c
   734  }
   735  
   736  func (_c *DeviceRemoteInterface_Ski_Call) RunAndReturn(run func() string) *DeviceRemoteInterface_Ski_Call {
   737  	_c.Call.Return(run)
   738  	return _c
   739  }
   740  
   741  // UpdateDevice provides a mock function with given fields: description
   742  func (_m *DeviceRemoteInterface) UpdateDevice(description *model.NetworkManagementDeviceDescriptionDataType) {
   743  	_m.Called(description)
   744  }
   745  
   746  // DeviceRemoteInterface_UpdateDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDevice'
   747  type DeviceRemoteInterface_UpdateDevice_Call struct {
   748  	*mock.Call
   749  }
   750  
   751  // UpdateDevice is a helper method to define mock.On call
   752  //   - description *model.NetworkManagementDeviceDescriptionDataType
   753  func (_e *DeviceRemoteInterface_Expecter) UpdateDevice(description interface{}) *DeviceRemoteInterface_UpdateDevice_Call {
   754  	return &DeviceRemoteInterface_UpdateDevice_Call{Call: _e.mock.On("UpdateDevice", description)}
   755  }
   756  
   757  func (_c *DeviceRemoteInterface_UpdateDevice_Call) Run(run func(description *model.NetworkManagementDeviceDescriptionDataType)) *DeviceRemoteInterface_UpdateDevice_Call {
   758  	_c.Call.Run(func(args mock.Arguments) {
   759  		run(args[0].(*model.NetworkManagementDeviceDescriptionDataType))
   760  	})
   761  	return _c
   762  }
   763  
   764  func (_c *DeviceRemoteInterface_UpdateDevice_Call) Return() *DeviceRemoteInterface_UpdateDevice_Call {
   765  	_c.Call.Return()
   766  	return _c
   767  }
   768  
   769  func (_c *DeviceRemoteInterface_UpdateDevice_Call) RunAndReturn(run func(*model.NetworkManagementDeviceDescriptionDataType)) *DeviceRemoteInterface_UpdateDevice_Call {
   770  	_c.Call.Return(run)
   771  	return _c
   772  }
   773  
   774  // UseCases provides a mock function with given fields:
   775  func (_m *DeviceRemoteInterface) UseCases() []model.UseCaseInformationDataType {
   776  	ret := _m.Called()
   777  
   778  	if len(ret) == 0 {
   779  		panic("no return value specified for UseCases")
   780  	}
   781  
   782  	var r0 []model.UseCaseInformationDataType
   783  	if rf, ok := ret.Get(0).(func() []model.UseCaseInformationDataType); ok {
   784  		r0 = rf()
   785  	} else {
   786  		if ret.Get(0) != nil {
   787  			r0 = ret.Get(0).([]model.UseCaseInformationDataType)
   788  		}
   789  	}
   790  
   791  	return r0
   792  }
   793  
   794  // DeviceRemoteInterface_UseCases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCases'
   795  type DeviceRemoteInterface_UseCases_Call struct {
   796  	*mock.Call
   797  }
   798  
   799  // UseCases is a helper method to define mock.On call
   800  func (_e *DeviceRemoteInterface_Expecter) UseCases() *DeviceRemoteInterface_UseCases_Call {
   801  	return &DeviceRemoteInterface_UseCases_Call{Call: _e.mock.On("UseCases")}
   802  }
   803  
   804  func (_c *DeviceRemoteInterface_UseCases_Call) Run(run func()) *DeviceRemoteInterface_UseCases_Call {
   805  	_c.Call.Run(func(args mock.Arguments) {
   806  		run()
   807  	})
   808  	return _c
   809  }
   810  
   811  func (_c *DeviceRemoteInterface_UseCases_Call) Return(_a0 []model.UseCaseInformationDataType) *DeviceRemoteInterface_UseCases_Call {
   812  	_c.Call.Return(_a0)
   813  	return _c
   814  }
   815  
   816  func (_c *DeviceRemoteInterface_UseCases_Call) RunAndReturn(run func() []model.UseCaseInformationDataType) *DeviceRemoteInterface_UseCases_Call {
   817  	_c.Call.Return(run)
   818  	return _c
   819  }
   820  
   821  // NewDeviceRemoteInterface creates a new instance of DeviceRemoteInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
   822  // The first argument is typically a *testing.T value.
   823  func NewDeviceRemoteInterface(t interface {
   824  	mock.TestingT
   825  	Cleanup(func())
   826  }) *DeviceRemoteInterface {
   827  	mock := &DeviceRemoteInterface{}
   828  	mock.Mock.Test(t)
   829  
   830  	t.Cleanup(func() { mock.AssertExpectations(t) })
   831  
   832  	return mock
   833  }