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