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 }