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 }