github.com/enbility/spine-go@v0.7.0/mocks/FeatureLocalInterface.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 time "time" 12 ) 13 14 // FeatureLocalInterface is an autogenerated mock type for the FeatureLocalInterface type 15 type FeatureLocalInterface struct { 16 mock.Mock 17 } 18 19 type FeatureLocalInterface_Expecter struct { 20 mock *mock.Mock 21 } 22 23 func (_m *FeatureLocalInterface) EXPECT() *FeatureLocalInterface_Expecter { 24 return &FeatureLocalInterface_Expecter{mock: &_m.Mock} 25 } 26 27 // AddFunctionType provides a mock function with given fields: function, read, write 28 func (_m *FeatureLocalInterface) AddFunctionType(function model.FunctionType, read bool, write bool) { 29 _m.Called(function, read, write) 30 } 31 32 // FeatureLocalInterface_AddFunctionType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFunctionType' 33 type FeatureLocalInterface_AddFunctionType_Call struct { 34 *mock.Call 35 } 36 37 // AddFunctionType is a helper method to define mock.On call 38 // - function model.FunctionType 39 // - read bool 40 // - write bool 41 func (_e *FeatureLocalInterface_Expecter) AddFunctionType(function interface{}, read interface{}, write interface{}) *FeatureLocalInterface_AddFunctionType_Call { 42 return &FeatureLocalInterface_AddFunctionType_Call{Call: _e.mock.On("AddFunctionType", function, read, write)} 43 } 44 45 func (_c *FeatureLocalInterface_AddFunctionType_Call) Run(run func(function model.FunctionType, read bool, write bool)) *FeatureLocalInterface_AddFunctionType_Call { 46 _c.Call.Run(func(args mock.Arguments) { 47 run(args[0].(model.FunctionType), args[1].(bool), args[2].(bool)) 48 }) 49 return _c 50 } 51 52 func (_c *FeatureLocalInterface_AddFunctionType_Call) Return() *FeatureLocalInterface_AddFunctionType_Call { 53 _c.Call.Return() 54 return _c 55 } 56 57 func (_c *FeatureLocalInterface_AddFunctionType_Call) RunAndReturn(run func(model.FunctionType, bool, bool)) *FeatureLocalInterface_AddFunctionType_Call { 58 _c.Call.Return(run) 59 return _c 60 } 61 62 // AddResponseCallback provides a mock function with given fields: msgCounterReference, function 63 func (_m *FeatureLocalInterface) AddResponseCallback(msgCounterReference model.MsgCounterType, function func(api.ResponseMessage)) error { 64 ret := _m.Called(msgCounterReference, function) 65 66 if len(ret) == 0 { 67 panic("no return value specified for AddResponseCallback") 68 } 69 70 var r0 error 71 if rf, ok := ret.Get(0).(func(model.MsgCounterType, func(api.ResponseMessage)) error); ok { 72 r0 = rf(msgCounterReference, function) 73 } else { 74 r0 = ret.Error(0) 75 } 76 77 return r0 78 } 79 80 // FeatureLocalInterface_AddResponseCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddResponseCallback' 81 type FeatureLocalInterface_AddResponseCallback_Call struct { 82 *mock.Call 83 } 84 85 // AddResponseCallback is a helper method to define mock.On call 86 // - msgCounterReference model.MsgCounterType 87 // - function func(api.ResponseMessage) 88 func (_e *FeatureLocalInterface_Expecter) AddResponseCallback(msgCounterReference interface{}, function interface{}) *FeatureLocalInterface_AddResponseCallback_Call { 89 return &FeatureLocalInterface_AddResponseCallback_Call{Call: _e.mock.On("AddResponseCallback", msgCounterReference, function)} 90 } 91 92 func (_c *FeatureLocalInterface_AddResponseCallback_Call) Run(run func(msgCounterReference model.MsgCounterType, function func(api.ResponseMessage))) *FeatureLocalInterface_AddResponseCallback_Call { 93 _c.Call.Run(func(args mock.Arguments) { 94 run(args[0].(model.MsgCounterType), args[1].(func(api.ResponseMessage))) 95 }) 96 return _c 97 } 98 99 func (_c *FeatureLocalInterface_AddResponseCallback_Call) Return(_a0 error) *FeatureLocalInterface_AddResponseCallback_Call { 100 _c.Call.Return(_a0) 101 return _c 102 } 103 104 func (_c *FeatureLocalInterface_AddResponseCallback_Call) RunAndReturn(run func(model.MsgCounterType, func(api.ResponseMessage)) error) *FeatureLocalInterface_AddResponseCallback_Call { 105 _c.Call.Return(run) 106 return _c 107 } 108 109 // AddResultCallback provides a mock function with given fields: function 110 func (_m *FeatureLocalInterface) AddResultCallback(function func(api.ResponseMessage)) { 111 _m.Called(function) 112 } 113 114 // FeatureLocalInterface_AddResultCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddResultCallback' 115 type FeatureLocalInterface_AddResultCallback_Call struct { 116 *mock.Call 117 } 118 119 // AddResultCallback is a helper method to define mock.On call 120 // - function func(api.ResponseMessage) 121 func (_e *FeatureLocalInterface_Expecter) AddResultCallback(function interface{}) *FeatureLocalInterface_AddResultCallback_Call { 122 return &FeatureLocalInterface_AddResultCallback_Call{Call: _e.mock.On("AddResultCallback", function)} 123 } 124 125 func (_c *FeatureLocalInterface_AddResultCallback_Call) Run(run func(function func(api.ResponseMessage))) *FeatureLocalInterface_AddResultCallback_Call { 126 _c.Call.Run(func(args mock.Arguments) { 127 run(args[0].(func(api.ResponseMessage))) 128 }) 129 return _c 130 } 131 132 func (_c *FeatureLocalInterface_AddResultCallback_Call) Return() *FeatureLocalInterface_AddResultCallback_Call { 133 _c.Call.Return() 134 return _c 135 } 136 137 func (_c *FeatureLocalInterface_AddResultCallback_Call) RunAndReturn(run func(func(api.ResponseMessage))) *FeatureLocalInterface_AddResultCallback_Call { 138 _c.Call.Return(run) 139 return _c 140 } 141 142 // AddWriteApprovalCallback provides a mock function with given fields: function 143 func (_m *FeatureLocalInterface) AddWriteApprovalCallback(function api.WriteApprovalCallbackFunc) error { 144 ret := _m.Called(function) 145 146 if len(ret) == 0 { 147 panic("no return value specified for AddWriteApprovalCallback") 148 } 149 150 var r0 error 151 if rf, ok := ret.Get(0).(func(api.WriteApprovalCallbackFunc) error); ok { 152 r0 = rf(function) 153 } else { 154 r0 = ret.Error(0) 155 } 156 157 return r0 158 } 159 160 // FeatureLocalInterface_AddWriteApprovalCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddWriteApprovalCallback' 161 type FeatureLocalInterface_AddWriteApprovalCallback_Call struct { 162 *mock.Call 163 } 164 165 // AddWriteApprovalCallback is a helper method to define mock.On call 166 // - function api.WriteApprovalCallbackFunc 167 func (_e *FeatureLocalInterface_Expecter) AddWriteApprovalCallback(function interface{}) *FeatureLocalInterface_AddWriteApprovalCallback_Call { 168 return &FeatureLocalInterface_AddWriteApprovalCallback_Call{Call: _e.mock.On("AddWriteApprovalCallback", function)} 169 } 170 171 func (_c *FeatureLocalInterface_AddWriteApprovalCallback_Call) Run(run func(function api.WriteApprovalCallbackFunc)) *FeatureLocalInterface_AddWriteApprovalCallback_Call { 172 _c.Call.Run(func(args mock.Arguments) { 173 run(args[0].(api.WriteApprovalCallbackFunc)) 174 }) 175 return _c 176 } 177 178 func (_c *FeatureLocalInterface_AddWriteApprovalCallback_Call) Return(_a0 error) *FeatureLocalInterface_AddWriteApprovalCallback_Call { 179 _c.Call.Return(_a0) 180 return _c 181 } 182 183 func (_c *FeatureLocalInterface_AddWriteApprovalCallback_Call) RunAndReturn(run func(api.WriteApprovalCallbackFunc) error) *FeatureLocalInterface_AddWriteApprovalCallback_Call { 184 _c.Call.Return(run) 185 return _c 186 } 187 188 // Address provides a mock function with given fields: 189 func (_m *FeatureLocalInterface) Address() *model.FeatureAddressType { 190 ret := _m.Called() 191 192 if len(ret) == 0 { 193 panic("no return value specified for Address") 194 } 195 196 var r0 *model.FeatureAddressType 197 if rf, ok := ret.Get(0).(func() *model.FeatureAddressType); ok { 198 r0 = rf() 199 } else { 200 if ret.Get(0) != nil { 201 r0 = ret.Get(0).(*model.FeatureAddressType) 202 } 203 } 204 205 return r0 206 } 207 208 // FeatureLocalInterface_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address' 209 type FeatureLocalInterface_Address_Call struct { 210 *mock.Call 211 } 212 213 // Address is a helper method to define mock.On call 214 func (_e *FeatureLocalInterface_Expecter) Address() *FeatureLocalInterface_Address_Call { 215 return &FeatureLocalInterface_Address_Call{Call: _e.mock.On("Address")} 216 } 217 218 func (_c *FeatureLocalInterface_Address_Call) Run(run func()) *FeatureLocalInterface_Address_Call { 219 _c.Call.Run(func(args mock.Arguments) { 220 run() 221 }) 222 return _c 223 } 224 225 func (_c *FeatureLocalInterface_Address_Call) Return(_a0 *model.FeatureAddressType) *FeatureLocalInterface_Address_Call { 226 _c.Call.Return(_a0) 227 return _c 228 } 229 230 func (_c *FeatureLocalInterface_Address_Call) RunAndReturn(run func() *model.FeatureAddressType) *FeatureLocalInterface_Address_Call { 231 _c.Call.Return(run) 232 return _c 233 } 234 235 // ApproveOrDenyWrite provides a mock function with given fields: msg, err 236 func (_m *FeatureLocalInterface) ApproveOrDenyWrite(msg *api.Message, err model.ErrorType) { 237 _m.Called(msg, err) 238 } 239 240 // FeatureLocalInterface_ApproveOrDenyWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApproveOrDenyWrite' 241 type FeatureLocalInterface_ApproveOrDenyWrite_Call struct { 242 *mock.Call 243 } 244 245 // ApproveOrDenyWrite is a helper method to define mock.On call 246 // - msg *api.Message 247 // - err model.ErrorType 248 func (_e *FeatureLocalInterface_Expecter) ApproveOrDenyWrite(msg interface{}, err interface{}) *FeatureLocalInterface_ApproveOrDenyWrite_Call { 249 return &FeatureLocalInterface_ApproveOrDenyWrite_Call{Call: _e.mock.On("ApproveOrDenyWrite", msg, err)} 250 } 251 252 func (_c *FeatureLocalInterface_ApproveOrDenyWrite_Call) Run(run func(msg *api.Message, err model.ErrorType)) *FeatureLocalInterface_ApproveOrDenyWrite_Call { 253 _c.Call.Run(func(args mock.Arguments) { 254 run(args[0].(*api.Message), args[1].(model.ErrorType)) 255 }) 256 return _c 257 } 258 259 func (_c *FeatureLocalInterface_ApproveOrDenyWrite_Call) Return() *FeatureLocalInterface_ApproveOrDenyWrite_Call { 260 _c.Call.Return() 261 return _c 262 } 263 264 func (_c *FeatureLocalInterface_ApproveOrDenyWrite_Call) RunAndReturn(run func(*api.Message, model.ErrorType)) *FeatureLocalInterface_ApproveOrDenyWrite_Call { 265 _c.Call.Return(run) 266 return _c 267 } 268 269 // BindToRemote provides a mock function with given fields: remoteAddress 270 func (_m *FeatureLocalInterface) BindToRemote(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) { 271 ret := _m.Called(remoteAddress) 272 273 if len(ret) == 0 { 274 panic("no return value specified for BindToRemote") 275 } 276 277 var r0 *model.MsgCounterType 278 var r1 *model.ErrorType 279 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok { 280 return rf(remoteAddress) 281 } 282 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok { 283 r0 = rf(remoteAddress) 284 } else { 285 if ret.Get(0) != nil { 286 r0 = ret.Get(0).(*model.MsgCounterType) 287 } 288 } 289 290 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok { 291 r1 = rf(remoteAddress) 292 } else { 293 if ret.Get(1) != nil { 294 r1 = ret.Get(1).(*model.ErrorType) 295 } 296 } 297 298 return r0, r1 299 } 300 301 // FeatureLocalInterface_BindToRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BindToRemote' 302 type FeatureLocalInterface_BindToRemote_Call struct { 303 *mock.Call 304 } 305 306 // BindToRemote is a helper method to define mock.On call 307 // - remoteAddress *model.FeatureAddressType 308 func (_e *FeatureLocalInterface_Expecter) BindToRemote(remoteAddress interface{}) *FeatureLocalInterface_BindToRemote_Call { 309 return &FeatureLocalInterface_BindToRemote_Call{Call: _e.mock.On("BindToRemote", remoteAddress)} 310 } 311 312 func (_c *FeatureLocalInterface_BindToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_BindToRemote_Call { 313 _c.Call.Run(func(args mock.Arguments) { 314 run(args[0].(*model.FeatureAddressType)) 315 }) 316 return _c 317 } 318 319 func (_c *FeatureLocalInterface_BindToRemote_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_BindToRemote_Call { 320 _c.Call.Return(_a0, _a1) 321 return _c 322 } 323 324 func (_c *FeatureLocalInterface_BindToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_BindToRemote_Call { 325 _c.Call.Return(run) 326 return _c 327 } 328 329 // CleanRemoteDeviceCaches provides a mock function with given fields: remoteAddress 330 func (_m *FeatureLocalInterface) CleanRemoteDeviceCaches(remoteAddress *model.DeviceAddressType) { 331 _m.Called(remoteAddress) 332 } 333 334 // FeatureLocalInterface_CleanRemoteDeviceCaches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanRemoteDeviceCaches' 335 type FeatureLocalInterface_CleanRemoteDeviceCaches_Call struct { 336 *mock.Call 337 } 338 339 // CleanRemoteDeviceCaches is a helper method to define mock.On call 340 // - remoteAddress *model.DeviceAddressType 341 func (_e *FeatureLocalInterface_Expecter) CleanRemoteDeviceCaches(remoteAddress interface{}) *FeatureLocalInterface_CleanRemoteDeviceCaches_Call { 342 return &FeatureLocalInterface_CleanRemoteDeviceCaches_Call{Call: _e.mock.On("CleanRemoteDeviceCaches", remoteAddress)} 343 } 344 345 func (_c *FeatureLocalInterface_CleanRemoteDeviceCaches_Call) Run(run func(remoteAddress *model.DeviceAddressType)) *FeatureLocalInterface_CleanRemoteDeviceCaches_Call { 346 _c.Call.Run(func(args mock.Arguments) { 347 run(args[0].(*model.DeviceAddressType)) 348 }) 349 return _c 350 } 351 352 func (_c *FeatureLocalInterface_CleanRemoteDeviceCaches_Call) Return() *FeatureLocalInterface_CleanRemoteDeviceCaches_Call { 353 _c.Call.Return() 354 return _c 355 } 356 357 func (_c *FeatureLocalInterface_CleanRemoteDeviceCaches_Call) RunAndReturn(run func(*model.DeviceAddressType)) *FeatureLocalInterface_CleanRemoteDeviceCaches_Call { 358 _c.Call.Return(run) 359 return _c 360 } 361 362 // CleanRemoteEntityCaches provides a mock function with given fields: remoteAddress 363 func (_m *FeatureLocalInterface) CleanRemoteEntityCaches(remoteAddress *model.EntityAddressType) { 364 _m.Called(remoteAddress) 365 } 366 367 // FeatureLocalInterface_CleanRemoteEntityCaches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanRemoteEntityCaches' 368 type FeatureLocalInterface_CleanRemoteEntityCaches_Call struct { 369 *mock.Call 370 } 371 372 // CleanRemoteEntityCaches is a helper method to define mock.On call 373 // - remoteAddress *model.EntityAddressType 374 func (_e *FeatureLocalInterface_Expecter) CleanRemoteEntityCaches(remoteAddress interface{}) *FeatureLocalInterface_CleanRemoteEntityCaches_Call { 375 return &FeatureLocalInterface_CleanRemoteEntityCaches_Call{Call: _e.mock.On("CleanRemoteEntityCaches", remoteAddress)} 376 } 377 378 func (_c *FeatureLocalInterface_CleanRemoteEntityCaches_Call) Run(run func(remoteAddress *model.EntityAddressType)) *FeatureLocalInterface_CleanRemoteEntityCaches_Call { 379 _c.Call.Run(func(args mock.Arguments) { 380 run(args[0].(*model.EntityAddressType)) 381 }) 382 return _c 383 } 384 385 func (_c *FeatureLocalInterface_CleanRemoteEntityCaches_Call) Return() *FeatureLocalInterface_CleanRemoteEntityCaches_Call { 386 _c.Call.Return() 387 return _c 388 } 389 390 func (_c *FeatureLocalInterface_CleanRemoteEntityCaches_Call) RunAndReturn(run func(*model.EntityAddressType)) *FeatureLocalInterface_CleanRemoteEntityCaches_Call { 391 _c.Call.Return(run) 392 return _c 393 } 394 395 // CleanWriteApprovalCaches provides a mock function with given fields: ski 396 func (_m *FeatureLocalInterface) CleanWriteApprovalCaches(ski string) { 397 _m.Called(ski) 398 } 399 400 // FeatureLocalInterface_CleanWriteApprovalCaches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanWriteApprovalCaches' 401 type FeatureLocalInterface_CleanWriteApprovalCaches_Call struct { 402 *mock.Call 403 } 404 405 // CleanWriteApprovalCaches is a helper method to define mock.On call 406 // - ski string 407 func (_e *FeatureLocalInterface_Expecter) CleanWriteApprovalCaches(ski interface{}) *FeatureLocalInterface_CleanWriteApprovalCaches_Call { 408 return &FeatureLocalInterface_CleanWriteApprovalCaches_Call{Call: _e.mock.On("CleanWriteApprovalCaches", ski)} 409 } 410 411 func (_c *FeatureLocalInterface_CleanWriteApprovalCaches_Call) Run(run func(ski string)) *FeatureLocalInterface_CleanWriteApprovalCaches_Call { 412 _c.Call.Run(func(args mock.Arguments) { 413 run(args[0].(string)) 414 }) 415 return _c 416 } 417 418 func (_c *FeatureLocalInterface_CleanWriteApprovalCaches_Call) Return() *FeatureLocalInterface_CleanWriteApprovalCaches_Call { 419 _c.Call.Return() 420 return _c 421 } 422 423 func (_c *FeatureLocalInterface_CleanWriteApprovalCaches_Call) RunAndReturn(run func(string)) *FeatureLocalInterface_CleanWriteApprovalCaches_Call { 424 _c.Call.Return(run) 425 return _c 426 } 427 428 // DataCopy provides a mock function with given fields: function 429 func (_m *FeatureLocalInterface) DataCopy(function model.FunctionType) interface{} { 430 ret := _m.Called(function) 431 432 if len(ret) == 0 { 433 panic("no return value specified for DataCopy") 434 } 435 436 var r0 interface{} 437 if rf, ok := ret.Get(0).(func(model.FunctionType) interface{}); ok { 438 r0 = rf(function) 439 } else { 440 if ret.Get(0) != nil { 441 r0 = ret.Get(0).(interface{}) 442 } 443 } 444 445 return r0 446 } 447 448 // FeatureLocalInterface_DataCopy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataCopy' 449 type FeatureLocalInterface_DataCopy_Call struct { 450 *mock.Call 451 } 452 453 // DataCopy is a helper method to define mock.On call 454 // - function model.FunctionType 455 func (_e *FeatureLocalInterface_Expecter) DataCopy(function interface{}) *FeatureLocalInterface_DataCopy_Call { 456 return &FeatureLocalInterface_DataCopy_Call{Call: _e.mock.On("DataCopy", function)} 457 } 458 459 func (_c *FeatureLocalInterface_DataCopy_Call) Run(run func(function model.FunctionType)) *FeatureLocalInterface_DataCopy_Call { 460 _c.Call.Run(func(args mock.Arguments) { 461 run(args[0].(model.FunctionType)) 462 }) 463 return _c 464 } 465 466 func (_c *FeatureLocalInterface_DataCopy_Call) Return(_a0 interface{}) *FeatureLocalInterface_DataCopy_Call { 467 _c.Call.Return(_a0) 468 return _c 469 } 470 471 func (_c *FeatureLocalInterface_DataCopy_Call) RunAndReturn(run func(model.FunctionType) interface{}) *FeatureLocalInterface_DataCopy_Call { 472 _c.Call.Return(run) 473 return _c 474 } 475 476 // Description provides a mock function with given fields: 477 func (_m *FeatureLocalInterface) Description() *model.DescriptionType { 478 ret := _m.Called() 479 480 if len(ret) == 0 { 481 panic("no return value specified for Description") 482 } 483 484 var r0 *model.DescriptionType 485 if rf, ok := ret.Get(0).(func() *model.DescriptionType); ok { 486 r0 = rf() 487 } else { 488 if ret.Get(0) != nil { 489 r0 = ret.Get(0).(*model.DescriptionType) 490 } 491 } 492 493 return r0 494 } 495 496 // FeatureLocalInterface_Description_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Description' 497 type FeatureLocalInterface_Description_Call struct { 498 *mock.Call 499 } 500 501 // Description is a helper method to define mock.On call 502 func (_e *FeatureLocalInterface_Expecter) Description() *FeatureLocalInterface_Description_Call { 503 return &FeatureLocalInterface_Description_Call{Call: _e.mock.On("Description")} 504 } 505 506 func (_c *FeatureLocalInterface_Description_Call) Run(run func()) *FeatureLocalInterface_Description_Call { 507 _c.Call.Run(func(args mock.Arguments) { 508 run() 509 }) 510 return _c 511 } 512 513 func (_c *FeatureLocalInterface_Description_Call) Return(_a0 *model.DescriptionType) *FeatureLocalInterface_Description_Call { 514 _c.Call.Return(_a0) 515 return _c 516 } 517 518 func (_c *FeatureLocalInterface_Description_Call) RunAndReturn(run func() *model.DescriptionType) *FeatureLocalInterface_Description_Call { 519 _c.Call.Return(run) 520 return _c 521 } 522 523 // Device provides a mock function with given fields: 524 func (_m *FeatureLocalInterface) Device() api.DeviceLocalInterface { 525 ret := _m.Called() 526 527 if len(ret) == 0 { 528 panic("no return value specified for Device") 529 } 530 531 var r0 api.DeviceLocalInterface 532 if rf, ok := ret.Get(0).(func() api.DeviceLocalInterface); ok { 533 r0 = rf() 534 } else { 535 if ret.Get(0) != nil { 536 r0 = ret.Get(0).(api.DeviceLocalInterface) 537 } 538 } 539 540 return r0 541 } 542 543 // FeatureLocalInterface_Device_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Device' 544 type FeatureLocalInterface_Device_Call struct { 545 *mock.Call 546 } 547 548 // Device is a helper method to define mock.On call 549 func (_e *FeatureLocalInterface_Expecter) Device() *FeatureLocalInterface_Device_Call { 550 return &FeatureLocalInterface_Device_Call{Call: _e.mock.On("Device")} 551 } 552 553 func (_c *FeatureLocalInterface_Device_Call) Run(run func()) *FeatureLocalInterface_Device_Call { 554 _c.Call.Run(func(args mock.Arguments) { 555 run() 556 }) 557 return _c 558 } 559 560 func (_c *FeatureLocalInterface_Device_Call) Return(_a0 api.DeviceLocalInterface) *FeatureLocalInterface_Device_Call { 561 _c.Call.Return(_a0) 562 return _c 563 } 564 565 func (_c *FeatureLocalInterface_Device_Call) RunAndReturn(run func() api.DeviceLocalInterface) *FeatureLocalInterface_Device_Call { 566 _c.Call.Return(run) 567 return _c 568 } 569 570 // Entity provides a mock function with given fields: 571 func (_m *FeatureLocalInterface) Entity() api.EntityLocalInterface { 572 ret := _m.Called() 573 574 if len(ret) == 0 { 575 panic("no return value specified for Entity") 576 } 577 578 var r0 api.EntityLocalInterface 579 if rf, ok := ret.Get(0).(func() api.EntityLocalInterface); ok { 580 r0 = rf() 581 } else { 582 if ret.Get(0) != nil { 583 r0 = ret.Get(0).(api.EntityLocalInterface) 584 } 585 } 586 587 return r0 588 } 589 590 // FeatureLocalInterface_Entity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Entity' 591 type FeatureLocalInterface_Entity_Call struct { 592 *mock.Call 593 } 594 595 // Entity is a helper method to define mock.On call 596 func (_e *FeatureLocalInterface_Expecter) Entity() *FeatureLocalInterface_Entity_Call { 597 return &FeatureLocalInterface_Entity_Call{Call: _e.mock.On("Entity")} 598 } 599 600 func (_c *FeatureLocalInterface_Entity_Call) Run(run func()) *FeatureLocalInterface_Entity_Call { 601 _c.Call.Run(func(args mock.Arguments) { 602 run() 603 }) 604 return _c 605 } 606 607 func (_c *FeatureLocalInterface_Entity_Call) Return(_a0 api.EntityLocalInterface) *FeatureLocalInterface_Entity_Call { 608 _c.Call.Return(_a0) 609 return _c 610 } 611 612 func (_c *FeatureLocalInterface_Entity_Call) RunAndReturn(run func() api.EntityLocalInterface) *FeatureLocalInterface_Entity_Call { 613 _c.Call.Return(run) 614 return _c 615 } 616 617 // Functions provides a mock function with given fields: 618 func (_m *FeatureLocalInterface) Functions() []model.FunctionType { 619 ret := _m.Called() 620 621 if len(ret) == 0 { 622 panic("no return value specified for Functions") 623 } 624 625 var r0 []model.FunctionType 626 if rf, ok := ret.Get(0).(func() []model.FunctionType); ok { 627 r0 = rf() 628 } else { 629 if ret.Get(0) != nil { 630 r0 = ret.Get(0).([]model.FunctionType) 631 } 632 } 633 634 return r0 635 } 636 637 // FeatureLocalInterface_Functions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Functions' 638 type FeatureLocalInterface_Functions_Call struct { 639 *mock.Call 640 } 641 642 // Functions is a helper method to define mock.On call 643 func (_e *FeatureLocalInterface_Expecter) Functions() *FeatureLocalInterface_Functions_Call { 644 return &FeatureLocalInterface_Functions_Call{Call: _e.mock.On("Functions")} 645 } 646 647 func (_c *FeatureLocalInterface_Functions_Call) Run(run func()) *FeatureLocalInterface_Functions_Call { 648 _c.Call.Run(func(args mock.Arguments) { 649 run() 650 }) 651 return _c 652 } 653 654 func (_c *FeatureLocalInterface_Functions_Call) Return(_a0 []model.FunctionType) *FeatureLocalInterface_Functions_Call { 655 _c.Call.Return(_a0) 656 return _c 657 } 658 659 func (_c *FeatureLocalInterface_Functions_Call) RunAndReturn(run func() []model.FunctionType) *FeatureLocalInterface_Functions_Call { 660 _c.Call.Return(run) 661 return _c 662 } 663 664 // HandleMessage provides a mock function with given fields: message 665 func (_m *FeatureLocalInterface) HandleMessage(message *api.Message) *model.ErrorType { 666 ret := _m.Called(message) 667 668 if len(ret) == 0 { 669 panic("no return value specified for HandleMessage") 670 } 671 672 var r0 *model.ErrorType 673 if rf, ok := ret.Get(0).(func(*api.Message) *model.ErrorType); ok { 674 r0 = rf(message) 675 } else { 676 if ret.Get(0) != nil { 677 r0 = ret.Get(0).(*model.ErrorType) 678 } 679 } 680 681 return r0 682 } 683 684 // FeatureLocalInterface_HandleMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HandleMessage' 685 type FeatureLocalInterface_HandleMessage_Call struct { 686 *mock.Call 687 } 688 689 // HandleMessage is a helper method to define mock.On call 690 // - message *api.Message 691 func (_e *FeatureLocalInterface_Expecter) HandleMessage(message interface{}) *FeatureLocalInterface_HandleMessage_Call { 692 return &FeatureLocalInterface_HandleMessage_Call{Call: _e.mock.On("HandleMessage", message)} 693 } 694 695 func (_c *FeatureLocalInterface_HandleMessage_Call) Run(run func(message *api.Message)) *FeatureLocalInterface_HandleMessage_Call { 696 _c.Call.Run(func(args mock.Arguments) { 697 run(args[0].(*api.Message)) 698 }) 699 return _c 700 } 701 702 func (_c *FeatureLocalInterface_HandleMessage_Call) Return(_a0 *model.ErrorType) *FeatureLocalInterface_HandleMessage_Call { 703 _c.Call.Return(_a0) 704 return _c 705 } 706 707 func (_c *FeatureLocalInterface_HandleMessage_Call) RunAndReturn(run func(*api.Message) *model.ErrorType) *FeatureLocalInterface_HandleMessage_Call { 708 _c.Call.Return(run) 709 return _c 710 } 711 712 // HasBindingToRemote provides a mock function with given fields: remoteAddress 713 func (_m *FeatureLocalInterface) HasBindingToRemote(remoteAddress *model.FeatureAddressType) bool { 714 ret := _m.Called(remoteAddress) 715 716 if len(ret) == 0 { 717 panic("no return value specified for HasBindingToRemote") 718 } 719 720 var r0 bool 721 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) bool); ok { 722 r0 = rf(remoteAddress) 723 } else { 724 r0 = ret.Get(0).(bool) 725 } 726 727 return r0 728 } 729 730 // FeatureLocalInterface_HasBindingToRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasBindingToRemote' 731 type FeatureLocalInterface_HasBindingToRemote_Call struct { 732 *mock.Call 733 } 734 735 // HasBindingToRemote is a helper method to define mock.On call 736 // - remoteAddress *model.FeatureAddressType 737 func (_e *FeatureLocalInterface_Expecter) HasBindingToRemote(remoteAddress interface{}) *FeatureLocalInterface_HasBindingToRemote_Call { 738 return &FeatureLocalInterface_HasBindingToRemote_Call{Call: _e.mock.On("HasBindingToRemote", remoteAddress)} 739 } 740 741 func (_c *FeatureLocalInterface_HasBindingToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_HasBindingToRemote_Call { 742 _c.Call.Run(func(args mock.Arguments) { 743 run(args[0].(*model.FeatureAddressType)) 744 }) 745 return _c 746 } 747 748 func (_c *FeatureLocalInterface_HasBindingToRemote_Call) Return(_a0 bool) *FeatureLocalInterface_HasBindingToRemote_Call { 749 _c.Call.Return(_a0) 750 return _c 751 } 752 753 func (_c *FeatureLocalInterface_HasBindingToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) bool) *FeatureLocalInterface_HasBindingToRemote_Call { 754 _c.Call.Return(run) 755 return _c 756 } 757 758 // HasSubscriptionToRemote provides a mock function with given fields: remoteAddress 759 func (_m *FeatureLocalInterface) HasSubscriptionToRemote(remoteAddress *model.FeatureAddressType) bool { 760 ret := _m.Called(remoteAddress) 761 762 if len(ret) == 0 { 763 panic("no return value specified for HasSubscriptionToRemote") 764 } 765 766 var r0 bool 767 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) bool); ok { 768 r0 = rf(remoteAddress) 769 } else { 770 r0 = ret.Get(0).(bool) 771 } 772 773 return r0 774 } 775 776 // FeatureLocalInterface_HasSubscriptionToRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasSubscriptionToRemote' 777 type FeatureLocalInterface_HasSubscriptionToRemote_Call struct { 778 *mock.Call 779 } 780 781 // HasSubscriptionToRemote is a helper method to define mock.On call 782 // - remoteAddress *model.FeatureAddressType 783 func (_e *FeatureLocalInterface_Expecter) HasSubscriptionToRemote(remoteAddress interface{}) *FeatureLocalInterface_HasSubscriptionToRemote_Call { 784 return &FeatureLocalInterface_HasSubscriptionToRemote_Call{Call: _e.mock.On("HasSubscriptionToRemote", remoteAddress)} 785 } 786 787 func (_c *FeatureLocalInterface_HasSubscriptionToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_HasSubscriptionToRemote_Call { 788 _c.Call.Run(func(args mock.Arguments) { 789 run(args[0].(*model.FeatureAddressType)) 790 }) 791 return _c 792 } 793 794 func (_c *FeatureLocalInterface_HasSubscriptionToRemote_Call) Return(_a0 bool) *FeatureLocalInterface_HasSubscriptionToRemote_Call { 795 _c.Call.Return(_a0) 796 return _c 797 } 798 799 func (_c *FeatureLocalInterface_HasSubscriptionToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) bool) *FeatureLocalInterface_HasSubscriptionToRemote_Call { 800 _c.Call.Return(run) 801 return _c 802 } 803 804 // Information provides a mock function with given fields: 805 func (_m *FeatureLocalInterface) Information() *model.NodeManagementDetailedDiscoveryFeatureInformationType { 806 ret := _m.Called() 807 808 if len(ret) == 0 { 809 panic("no return value specified for Information") 810 } 811 812 var r0 *model.NodeManagementDetailedDiscoveryFeatureInformationType 813 if rf, ok := ret.Get(0).(func() *model.NodeManagementDetailedDiscoveryFeatureInformationType); ok { 814 r0 = rf() 815 } else { 816 if ret.Get(0) != nil { 817 r0 = ret.Get(0).(*model.NodeManagementDetailedDiscoveryFeatureInformationType) 818 } 819 } 820 821 return r0 822 } 823 824 // FeatureLocalInterface_Information_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Information' 825 type FeatureLocalInterface_Information_Call struct { 826 *mock.Call 827 } 828 829 // Information is a helper method to define mock.On call 830 func (_e *FeatureLocalInterface_Expecter) Information() *FeatureLocalInterface_Information_Call { 831 return &FeatureLocalInterface_Information_Call{Call: _e.mock.On("Information")} 832 } 833 834 func (_c *FeatureLocalInterface_Information_Call) Run(run func()) *FeatureLocalInterface_Information_Call { 835 _c.Call.Run(func(args mock.Arguments) { 836 run() 837 }) 838 return _c 839 } 840 841 func (_c *FeatureLocalInterface_Information_Call) Return(_a0 *model.NodeManagementDetailedDiscoveryFeatureInformationType) *FeatureLocalInterface_Information_Call { 842 _c.Call.Return(_a0) 843 return _c 844 } 845 846 func (_c *FeatureLocalInterface_Information_Call) RunAndReturn(run func() *model.NodeManagementDetailedDiscoveryFeatureInformationType) *FeatureLocalInterface_Information_Call { 847 _c.Call.Return(run) 848 return _c 849 } 850 851 // Operations provides a mock function with given fields: 852 func (_m *FeatureLocalInterface) Operations() map[model.FunctionType]api.OperationsInterface { 853 ret := _m.Called() 854 855 if len(ret) == 0 { 856 panic("no return value specified for Operations") 857 } 858 859 var r0 map[model.FunctionType]api.OperationsInterface 860 if rf, ok := ret.Get(0).(func() map[model.FunctionType]api.OperationsInterface); ok { 861 r0 = rf() 862 } else { 863 if ret.Get(0) != nil { 864 r0 = ret.Get(0).(map[model.FunctionType]api.OperationsInterface) 865 } 866 } 867 868 return r0 869 } 870 871 // FeatureLocalInterface_Operations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Operations' 872 type FeatureLocalInterface_Operations_Call struct { 873 *mock.Call 874 } 875 876 // Operations is a helper method to define mock.On call 877 func (_e *FeatureLocalInterface_Expecter) Operations() *FeatureLocalInterface_Operations_Call { 878 return &FeatureLocalInterface_Operations_Call{Call: _e.mock.On("Operations")} 879 } 880 881 func (_c *FeatureLocalInterface_Operations_Call) Run(run func()) *FeatureLocalInterface_Operations_Call { 882 _c.Call.Run(func(args mock.Arguments) { 883 run() 884 }) 885 return _c 886 } 887 888 func (_c *FeatureLocalInterface_Operations_Call) Return(_a0 map[model.FunctionType]api.OperationsInterface) *FeatureLocalInterface_Operations_Call { 889 _c.Call.Return(_a0) 890 return _c 891 } 892 893 func (_c *FeatureLocalInterface_Operations_Call) RunAndReturn(run func() map[model.FunctionType]api.OperationsInterface) *FeatureLocalInterface_Operations_Call { 894 _c.Call.Return(run) 895 return _c 896 } 897 898 // RemoveAllRemoteBindings provides a mock function with given fields: 899 func (_m *FeatureLocalInterface) RemoveAllRemoteBindings() { 900 _m.Called() 901 } 902 903 // FeatureLocalInterface_RemoveAllRemoteBindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllRemoteBindings' 904 type FeatureLocalInterface_RemoveAllRemoteBindings_Call struct { 905 *mock.Call 906 } 907 908 // RemoveAllRemoteBindings is a helper method to define mock.On call 909 func (_e *FeatureLocalInterface_Expecter) RemoveAllRemoteBindings() *FeatureLocalInterface_RemoveAllRemoteBindings_Call { 910 return &FeatureLocalInterface_RemoveAllRemoteBindings_Call{Call: _e.mock.On("RemoveAllRemoteBindings")} 911 } 912 913 func (_c *FeatureLocalInterface_RemoveAllRemoteBindings_Call) Run(run func()) *FeatureLocalInterface_RemoveAllRemoteBindings_Call { 914 _c.Call.Run(func(args mock.Arguments) { 915 run() 916 }) 917 return _c 918 } 919 920 func (_c *FeatureLocalInterface_RemoveAllRemoteBindings_Call) Return() *FeatureLocalInterface_RemoveAllRemoteBindings_Call { 921 _c.Call.Return() 922 return _c 923 } 924 925 func (_c *FeatureLocalInterface_RemoveAllRemoteBindings_Call) RunAndReturn(run func()) *FeatureLocalInterface_RemoveAllRemoteBindings_Call { 926 _c.Call.Return(run) 927 return _c 928 } 929 930 // RemoveAllRemoteSubscriptions provides a mock function with given fields: 931 func (_m *FeatureLocalInterface) RemoveAllRemoteSubscriptions() { 932 _m.Called() 933 } 934 935 // FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllRemoteSubscriptions' 936 type FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call struct { 937 *mock.Call 938 } 939 940 // RemoveAllRemoteSubscriptions is a helper method to define mock.On call 941 func (_e *FeatureLocalInterface_Expecter) RemoveAllRemoteSubscriptions() *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call { 942 return &FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call{Call: _e.mock.On("RemoveAllRemoteSubscriptions")} 943 } 944 945 func (_c *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call) Run(run func()) *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call { 946 _c.Call.Run(func(args mock.Arguments) { 947 run() 948 }) 949 return _c 950 } 951 952 func (_c *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call) Return() *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call { 953 _c.Call.Return() 954 return _c 955 } 956 957 func (_c *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call) RunAndReturn(run func()) *FeatureLocalInterface_RemoveAllRemoteSubscriptions_Call { 958 _c.Call.Return(run) 959 return _c 960 } 961 962 // RemoveRemoteBinding provides a mock function with given fields: remoteAddress 963 func (_m *FeatureLocalInterface) RemoveRemoteBinding(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) { 964 ret := _m.Called(remoteAddress) 965 966 if len(ret) == 0 { 967 panic("no return value specified for RemoveRemoteBinding") 968 } 969 970 var r0 *model.MsgCounterType 971 var r1 *model.ErrorType 972 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok { 973 return rf(remoteAddress) 974 } 975 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok { 976 r0 = rf(remoteAddress) 977 } else { 978 if ret.Get(0) != nil { 979 r0 = ret.Get(0).(*model.MsgCounterType) 980 } 981 } 982 983 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok { 984 r1 = rf(remoteAddress) 985 } else { 986 if ret.Get(1) != nil { 987 r1 = ret.Get(1).(*model.ErrorType) 988 } 989 } 990 991 return r0, r1 992 } 993 994 // FeatureLocalInterface_RemoveRemoteBinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRemoteBinding' 995 type FeatureLocalInterface_RemoveRemoteBinding_Call struct { 996 *mock.Call 997 } 998 999 // RemoveRemoteBinding is a helper method to define mock.On call 1000 // - remoteAddress *model.FeatureAddressType 1001 func (_e *FeatureLocalInterface_Expecter) RemoveRemoteBinding(remoteAddress interface{}) *FeatureLocalInterface_RemoveRemoteBinding_Call { 1002 return &FeatureLocalInterface_RemoveRemoteBinding_Call{Call: _e.mock.On("RemoveRemoteBinding", remoteAddress)} 1003 } 1004 1005 func (_c *FeatureLocalInterface_RemoveRemoteBinding_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_RemoveRemoteBinding_Call { 1006 _c.Call.Run(func(args mock.Arguments) { 1007 run(args[0].(*model.FeatureAddressType)) 1008 }) 1009 return _c 1010 } 1011 1012 func (_c *FeatureLocalInterface_RemoveRemoteBinding_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RemoveRemoteBinding_Call { 1013 _c.Call.Return(_a0, _a1) 1014 return _c 1015 } 1016 1017 func (_c *FeatureLocalInterface_RemoveRemoteBinding_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RemoveRemoteBinding_Call { 1018 _c.Call.Return(run) 1019 return _c 1020 } 1021 1022 // RemoveRemoteSubscription provides a mock function with given fields: remoteAddress 1023 func (_m *FeatureLocalInterface) RemoveRemoteSubscription(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) { 1024 ret := _m.Called(remoteAddress) 1025 1026 if len(ret) == 0 { 1027 panic("no return value specified for RemoveRemoteSubscription") 1028 } 1029 1030 var r0 *model.MsgCounterType 1031 var r1 *model.ErrorType 1032 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok { 1033 return rf(remoteAddress) 1034 } 1035 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok { 1036 r0 = rf(remoteAddress) 1037 } else { 1038 if ret.Get(0) != nil { 1039 r0 = ret.Get(0).(*model.MsgCounterType) 1040 } 1041 } 1042 1043 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok { 1044 r1 = rf(remoteAddress) 1045 } else { 1046 if ret.Get(1) != nil { 1047 r1 = ret.Get(1).(*model.ErrorType) 1048 } 1049 } 1050 1051 return r0, r1 1052 } 1053 1054 // FeatureLocalInterface_RemoveRemoteSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRemoteSubscription' 1055 type FeatureLocalInterface_RemoveRemoteSubscription_Call struct { 1056 *mock.Call 1057 } 1058 1059 // RemoveRemoteSubscription is a helper method to define mock.On call 1060 // - remoteAddress *model.FeatureAddressType 1061 func (_e *FeatureLocalInterface_Expecter) RemoveRemoteSubscription(remoteAddress interface{}) *FeatureLocalInterface_RemoveRemoteSubscription_Call { 1062 return &FeatureLocalInterface_RemoveRemoteSubscription_Call{Call: _e.mock.On("RemoveRemoteSubscription", remoteAddress)} 1063 } 1064 1065 func (_c *FeatureLocalInterface_RemoveRemoteSubscription_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_RemoveRemoteSubscription_Call { 1066 _c.Call.Run(func(args mock.Arguments) { 1067 run(args[0].(*model.FeatureAddressType)) 1068 }) 1069 return _c 1070 } 1071 1072 func (_c *FeatureLocalInterface_RemoveRemoteSubscription_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RemoveRemoteSubscription_Call { 1073 _c.Call.Return(_a0, _a1) 1074 return _c 1075 } 1076 1077 func (_c *FeatureLocalInterface_RemoveRemoteSubscription_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RemoveRemoteSubscription_Call { 1078 _c.Call.Return(run) 1079 return _c 1080 } 1081 1082 // RequestRemoteData provides a mock function with given fields: function, selector, elements, destination 1083 func (_m *FeatureLocalInterface) RequestRemoteData(function model.FunctionType, selector interface{}, elements interface{}, destination api.FeatureRemoteInterface) (*model.MsgCounterType, *model.ErrorType) { 1084 ret := _m.Called(function, selector, elements, destination) 1085 1086 if len(ret) == 0 { 1087 panic("no return value specified for RequestRemoteData") 1088 } 1089 1090 var r0 *model.MsgCounterType 1091 var r1 *model.ErrorType 1092 if rf, ok := ret.Get(0).(func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) (*model.MsgCounterType, *model.ErrorType)); ok { 1093 return rf(function, selector, elements, destination) 1094 } 1095 if rf, ok := ret.Get(0).(func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) *model.MsgCounterType); ok { 1096 r0 = rf(function, selector, elements, destination) 1097 } else { 1098 if ret.Get(0) != nil { 1099 r0 = ret.Get(0).(*model.MsgCounterType) 1100 } 1101 } 1102 1103 if rf, ok := ret.Get(1).(func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) *model.ErrorType); ok { 1104 r1 = rf(function, selector, elements, destination) 1105 } else { 1106 if ret.Get(1) != nil { 1107 r1 = ret.Get(1).(*model.ErrorType) 1108 } 1109 } 1110 1111 return r0, r1 1112 } 1113 1114 // FeatureLocalInterface_RequestRemoteData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestRemoteData' 1115 type FeatureLocalInterface_RequestRemoteData_Call struct { 1116 *mock.Call 1117 } 1118 1119 // RequestRemoteData is a helper method to define mock.On call 1120 // - function model.FunctionType 1121 // - selector interface{} 1122 // - elements interface{} 1123 // - destination api.FeatureRemoteInterface 1124 func (_e *FeatureLocalInterface_Expecter) RequestRemoteData(function interface{}, selector interface{}, elements interface{}, destination interface{}) *FeatureLocalInterface_RequestRemoteData_Call { 1125 return &FeatureLocalInterface_RequestRemoteData_Call{Call: _e.mock.On("RequestRemoteData", function, selector, elements, destination)} 1126 } 1127 1128 func (_c *FeatureLocalInterface_RequestRemoteData_Call) Run(run func(function model.FunctionType, selector interface{}, elements interface{}, destination api.FeatureRemoteInterface)) *FeatureLocalInterface_RequestRemoteData_Call { 1129 _c.Call.Run(func(args mock.Arguments) { 1130 run(args[0].(model.FunctionType), args[1].(interface{}), args[2].(interface{}), args[3].(api.FeatureRemoteInterface)) 1131 }) 1132 return _c 1133 } 1134 1135 func (_c *FeatureLocalInterface_RequestRemoteData_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RequestRemoteData_Call { 1136 _c.Call.Return(_a0, _a1) 1137 return _c 1138 } 1139 1140 func (_c *FeatureLocalInterface_RequestRemoteData_Call) RunAndReturn(run func(model.FunctionType, interface{}, interface{}, api.FeatureRemoteInterface) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RequestRemoteData_Call { 1141 _c.Call.Return(run) 1142 return _c 1143 } 1144 1145 // RequestRemoteDataBySenderAddress provides a mock function with given fields: cmd, sender, destinationSki, destinationAddress, maxDelay 1146 func (_m *FeatureLocalInterface) RequestRemoteDataBySenderAddress(cmd model.CmdType, sender api.SenderInterface, destinationSki string, destinationAddress *model.FeatureAddressType, maxDelay time.Duration) (*model.MsgCounterType, *model.ErrorType) { 1147 ret := _m.Called(cmd, sender, destinationSki, destinationAddress, maxDelay) 1148 1149 if len(ret) == 0 { 1150 panic("no return value specified for RequestRemoteDataBySenderAddress") 1151 } 1152 1153 var r0 *model.MsgCounterType 1154 var r1 *model.ErrorType 1155 if rf, ok := ret.Get(0).(func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) (*model.MsgCounterType, *model.ErrorType)); ok { 1156 return rf(cmd, sender, destinationSki, destinationAddress, maxDelay) 1157 } 1158 if rf, ok := ret.Get(0).(func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) *model.MsgCounterType); ok { 1159 r0 = rf(cmd, sender, destinationSki, destinationAddress, maxDelay) 1160 } else { 1161 if ret.Get(0) != nil { 1162 r0 = ret.Get(0).(*model.MsgCounterType) 1163 } 1164 } 1165 1166 if rf, ok := ret.Get(1).(func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) *model.ErrorType); ok { 1167 r1 = rf(cmd, sender, destinationSki, destinationAddress, maxDelay) 1168 } else { 1169 if ret.Get(1) != nil { 1170 r1 = ret.Get(1).(*model.ErrorType) 1171 } 1172 } 1173 1174 return r0, r1 1175 } 1176 1177 // FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestRemoteDataBySenderAddress' 1178 type FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call struct { 1179 *mock.Call 1180 } 1181 1182 // RequestRemoteDataBySenderAddress is a helper method to define mock.On call 1183 // - cmd model.CmdType 1184 // - sender api.SenderInterface 1185 // - destinationSki string 1186 // - destinationAddress *model.FeatureAddressType 1187 // - maxDelay time.Duration 1188 func (_e *FeatureLocalInterface_Expecter) RequestRemoteDataBySenderAddress(cmd interface{}, sender interface{}, destinationSki interface{}, destinationAddress interface{}, maxDelay interface{}) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call { 1189 return &FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call{Call: _e.mock.On("RequestRemoteDataBySenderAddress", cmd, sender, destinationSki, destinationAddress, maxDelay)} 1190 } 1191 1192 func (_c *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call) Run(run func(cmd model.CmdType, sender api.SenderInterface, destinationSki string, destinationAddress *model.FeatureAddressType, maxDelay time.Duration)) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call { 1193 _c.Call.Run(func(args mock.Arguments) { 1194 run(args[0].(model.CmdType), args[1].(api.SenderInterface), args[2].(string), args[3].(*model.FeatureAddressType), args[4].(time.Duration)) 1195 }) 1196 return _c 1197 } 1198 1199 func (_c *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call { 1200 _c.Call.Return(_a0, _a1) 1201 return _c 1202 } 1203 1204 func (_c *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call) RunAndReturn(run func(model.CmdType, api.SenderInterface, string, *model.FeatureAddressType, time.Duration) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_RequestRemoteDataBySenderAddress_Call { 1205 _c.Call.Return(run) 1206 return _c 1207 } 1208 1209 // Role provides a mock function with given fields: 1210 func (_m *FeatureLocalInterface) Role() model.RoleType { 1211 ret := _m.Called() 1212 1213 if len(ret) == 0 { 1214 panic("no return value specified for Role") 1215 } 1216 1217 var r0 model.RoleType 1218 if rf, ok := ret.Get(0).(func() model.RoleType); ok { 1219 r0 = rf() 1220 } else { 1221 r0 = ret.Get(0).(model.RoleType) 1222 } 1223 1224 return r0 1225 } 1226 1227 // FeatureLocalInterface_Role_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Role' 1228 type FeatureLocalInterface_Role_Call struct { 1229 *mock.Call 1230 } 1231 1232 // Role is a helper method to define mock.On call 1233 func (_e *FeatureLocalInterface_Expecter) Role() *FeatureLocalInterface_Role_Call { 1234 return &FeatureLocalInterface_Role_Call{Call: _e.mock.On("Role")} 1235 } 1236 1237 func (_c *FeatureLocalInterface_Role_Call) Run(run func()) *FeatureLocalInterface_Role_Call { 1238 _c.Call.Run(func(args mock.Arguments) { 1239 run() 1240 }) 1241 return _c 1242 } 1243 1244 func (_c *FeatureLocalInterface_Role_Call) Return(_a0 model.RoleType) *FeatureLocalInterface_Role_Call { 1245 _c.Call.Return(_a0) 1246 return _c 1247 } 1248 1249 func (_c *FeatureLocalInterface_Role_Call) RunAndReturn(run func() model.RoleType) *FeatureLocalInterface_Role_Call { 1250 _c.Call.Return(run) 1251 return _c 1252 } 1253 1254 // SetData provides a mock function with given fields: function, data 1255 func (_m *FeatureLocalInterface) SetData(function model.FunctionType, data interface{}) { 1256 _m.Called(function, data) 1257 } 1258 1259 // FeatureLocalInterface_SetData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetData' 1260 type FeatureLocalInterface_SetData_Call struct { 1261 *mock.Call 1262 } 1263 1264 // SetData is a helper method to define mock.On call 1265 // - function model.FunctionType 1266 // - data interface{} 1267 func (_e *FeatureLocalInterface_Expecter) SetData(function interface{}, data interface{}) *FeatureLocalInterface_SetData_Call { 1268 return &FeatureLocalInterface_SetData_Call{Call: _e.mock.On("SetData", function, data)} 1269 } 1270 1271 func (_c *FeatureLocalInterface_SetData_Call) Run(run func(function model.FunctionType, data interface{})) *FeatureLocalInterface_SetData_Call { 1272 _c.Call.Run(func(args mock.Arguments) { 1273 run(args[0].(model.FunctionType), args[1].(interface{})) 1274 }) 1275 return _c 1276 } 1277 1278 func (_c *FeatureLocalInterface_SetData_Call) Return() *FeatureLocalInterface_SetData_Call { 1279 _c.Call.Return() 1280 return _c 1281 } 1282 1283 func (_c *FeatureLocalInterface_SetData_Call) RunAndReturn(run func(model.FunctionType, interface{})) *FeatureLocalInterface_SetData_Call { 1284 _c.Call.Return(run) 1285 return _c 1286 } 1287 1288 // SetDescription provides a mock function with given fields: desc 1289 func (_m *FeatureLocalInterface) SetDescription(desc *model.DescriptionType) { 1290 _m.Called(desc) 1291 } 1292 1293 // FeatureLocalInterface_SetDescription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDescription' 1294 type FeatureLocalInterface_SetDescription_Call struct { 1295 *mock.Call 1296 } 1297 1298 // SetDescription is a helper method to define mock.On call 1299 // - desc *model.DescriptionType 1300 func (_e *FeatureLocalInterface_Expecter) SetDescription(desc interface{}) *FeatureLocalInterface_SetDescription_Call { 1301 return &FeatureLocalInterface_SetDescription_Call{Call: _e.mock.On("SetDescription", desc)} 1302 } 1303 1304 func (_c *FeatureLocalInterface_SetDescription_Call) Run(run func(desc *model.DescriptionType)) *FeatureLocalInterface_SetDescription_Call { 1305 _c.Call.Run(func(args mock.Arguments) { 1306 run(args[0].(*model.DescriptionType)) 1307 }) 1308 return _c 1309 } 1310 1311 func (_c *FeatureLocalInterface_SetDescription_Call) Return() *FeatureLocalInterface_SetDescription_Call { 1312 _c.Call.Return() 1313 return _c 1314 } 1315 1316 func (_c *FeatureLocalInterface_SetDescription_Call) RunAndReturn(run func(*model.DescriptionType)) *FeatureLocalInterface_SetDescription_Call { 1317 _c.Call.Return(run) 1318 return _c 1319 } 1320 1321 // SetDescriptionString provides a mock function with given fields: s 1322 func (_m *FeatureLocalInterface) SetDescriptionString(s string) { 1323 _m.Called(s) 1324 } 1325 1326 // FeatureLocalInterface_SetDescriptionString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDescriptionString' 1327 type FeatureLocalInterface_SetDescriptionString_Call struct { 1328 *mock.Call 1329 } 1330 1331 // SetDescriptionString is a helper method to define mock.On call 1332 // - s string 1333 func (_e *FeatureLocalInterface_Expecter) SetDescriptionString(s interface{}) *FeatureLocalInterface_SetDescriptionString_Call { 1334 return &FeatureLocalInterface_SetDescriptionString_Call{Call: _e.mock.On("SetDescriptionString", s)} 1335 } 1336 1337 func (_c *FeatureLocalInterface_SetDescriptionString_Call) Run(run func(s string)) *FeatureLocalInterface_SetDescriptionString_Call { 1338 _c.Call.Run(func(args mock.Arguments) { 1339 run(args[0].(string)) 1340 }) 1341 return _c 1342 } 1343 1344 func (_c *FeatureLocalInterface_SetDescriptionString_Call) Return() *FeatureLocalInterface_SetDescriptionString_Call { 1345 _c.Call.Return() 1346 return _c 1347 } 1348 1349 func (_c *FeatureLocalInterface_SetDescriptionString_Call) RunAndReturn(run func(string)) *FeatureLocalInterface_SetDescriptionString_Call { 1350 _c.Call.Return(run) 1351 return _c 1352 } 1353 1354 // SetWriteApprovalTimeout provides a mock function with given fields: duration 1355 func (_m *FeatureLocalInterface) SetWriteApprovalTimeout(duration time.Duration) { 1356 _m.Called(duration) 1357 } 1358 1359 // FeatureLocalInterface_SetWriteApprovalTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWriteApprovalTimeout' 1360 type FeatureLocalInterface_SetWriteApprovalTimeout_Call struct { 1361 *mock.Call 1362 } 1363 1364 // SetWriteApprovalTimeout is a helper method to define mock.On call 1365 // - duration time.Duration 1366 func (_e *FeatureLocalInterface_Expecter) SetWriteApprovalTimeout(duration interface{}) *FeatureLocalInterface_SetWriteApprovalTimeout_Call { 1367 return &FeatureLocalInterface_SetWriteApprovalTimeout_Call{Call: _e.mock.On("SetWriteApprovalTimeout", duration)} 1368 } 1369 1370 func (_c *FeatureLocalInterface_SetWriteApprovalTimeout_Call) Run(run func(duration time.Duration)) *FeatureLocalInterface_SetWriteApprovalTimeout_Call { 1371 _c.Call.Run(func(args mock.Arguments) { 1372 run(args[0].(time.Duration)) 1373 }) 1374 return _c 1375 } 1376 1377 func (_c *FeatureLocalInterface_SetWriteApprovalTimeout_Call) Return() *FeatureLocalInterface_SetWriteApprovalTimeout_Call { 1378 _c.Call.Return() 1379 return _c 1380 } 1381 1382 func (_c *FeatureLocalInterface_SetWriteApprovalTimeout_Call) RunAndReturn(run func(time.Duration)) *FeatureLocalInterface_SetWriteApprovalTimeout_Call { 1383 _c.Call.Return(run) 1384 return _c 1385 } 1386 1387 // String provides a mock function with given fields: 1388 func (_m *FeatureLocalInterface) String() string { 1389 ret := _m.Called() 1390 1391 if len(ret) == 0 { 1392 panic("no return value specified for String") 1393 } 1394 1395 var r0 string 1396 if rf, ok := ret.Get(0).(func() string); ok { 1397 r0 = rf() 1398 } else { 1399 r0 = ret.Get(0).(string) 1400 } 1401 1402 return r0 1403 } 1404 1405 // FeatureLocalInterface_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' 1406 type FeatureLocalInterface_String_Call struct { 1407 *mock.Call 1408 } 1409 1410 // String is a helper method to define mock.On call 1411 func (_e *FeatureLocalInterface_Expecter) String() *FeatureLocalInterface_String_Call { 1412 return &FeatureLocalInterface_String_Call{Call: _e.mock.On("String")} 1413 } 1414 1415 func (_c *FeatureLocalInterface_String_Call) Run(run func()) *FeatureLocalInterface_String_Call { 1416 _c.Call.Run(func(args mock.Arguments) { 1417 run() 1418 }) 1419 return _c 1420 } 1421 1422 func (_c *FeatureLocalInterface_String_Call) Return(_a0 string) *FeatureLocalInterface_String_Call { 1423 _c.Call.Return(_a0) 1424 return _c 1425 } 1426 1427 func (_c *FeatureLocalInterface_String_Call) RunAndReturn(run func() string) *FeatureLocalInterface_String_Call { 1428 _c.Call.Return(run) 1429 return _c 1430 } 1431 1432 // SubscribeToRemote provides a mock function with given fields: remoteAddress 1433 func (_m *FeatureLocalInterface) SubscribeToRemote(remoteAddress *model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType) { 1434 ret := _m.Called(remoteAddress) 1435 1436 if len(ret) == 0 { 1437 panic("no return value specified for SubscribeToRemote") 1438 } 1439 1440 var r0 *model.MsgCounterType 1441 var r1 *model.ErrorType 1442 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)); ok { 1443 return rf(remoteAddress) 1444 } 1445 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) *model.MsgCounterType); ok { 1446 r0 = rf(remoteAddress) 1447 } else { 1448 if ret.Get(0) != nil { 1449 r0 = ret.Get(0).(*model.MsgCounterType) 1450 } 1451 } 1452 1453 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType) *model.ErrorType); ok { 1454 r1 = rf(remoteAddress) 1455 } else { 1456 if ret.Get(1) != nil { 1457 r1 = ret.Get(1).(*model.ErrorType) 1458 } 1459 } 1460 1461 return r0, r1 1462 } 1463 1464 // FeatureLocalInterface_SubscribeToRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribeToRemote' 1465 type FeatureLocalInterface_SubscribeToRemote_Call struct { 1466 *mock.Call 1467 } 1468 1469 // SubscribeToRemote is a helper method to define mock.On call 1470 // - remoteAddress *model.FeatureAddressType 1471 func (_e *FeatureLocalInterface_Expecter) SubscribeToRemote(remoteAddress interface{}) *FeatureLocalInterface_SubscribeToRemote_Call { 1472 return &FeatureLocalInterface_SubscribeToRemote_Call{Call: _e.mock.On("SubscribeToRemote", remoteAddress)} 1473 } 1474 1475 func (_c *FeatureLocalInterface_SubscribeToRemote_Call) Run(run func(remoteAddress *model.FeatureAddressType)) *FeatureLocalInterface_SubscribeToRemote_Call { 1476 _c.Call.Run(func(args mock.Arguments) { 1477 run(args[0].(*model.FeatureAddressType)) 1478 }) 1479 return _c 1480 } 1481 1482 func (_c *FeatureLocalInterface_SubscribeToRemote_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *FeatureLocalInterface_SubscribeToRemote_Call { 1483 _c.Call.Return(_a0, _a1) 1484 return _c 1485 } 1486 1487 func (_c *FeatureLocalInterface_SubscribeToRemote_Call) RunAndReturn(run func(*model.FeatureAddressType) (*model.MsgCounterType, *model.ErrorType)) *FeatureLocalInterface_SubscribeToRemote_Call { 1488 _c.Call.Return(run) 1489 return _c 1490 } 1491 1492 // Type provides a mock function with given fields: 1493 func (_m *FeatureLocalInterface) Type() model.FeatureTypeType { 1494 ret := _m.Called() 1495 1496 if len(ret) == 0 { 1497 panic("no return value specified for Type") 1498 } 1499 1500 var r0 model.FeatureTypeType 1501 if rf, ok := ret.Get(0).(func() model.FeatureTypeType); ok { 1502 r0 = rf() 1503 } else { 1504 r0 = ret.Get(0).(model.FeatureTypeType) 1505 } 1506 1507 return r0 1508 } 1509 1510 // FeatureLocalInterface_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type' 1511 type FeatureLocalInterface_Type_Call struct { 1512 *mock.Call 1513 } 1514 1515 // Type is a helper method to define mock.On call 1516 func (_e *FeatureLocalInterface_Expecter) Type() *FeatureLocalInterface_Type_Call { 1517 return &FeatureLocalInterface_Type_Call{Call: _e.mock.On("Type")} 1518 } 1519 1520 func (_c *FeatureLocalInterface_Type_Call) Run(run func()) *FeatureLocalInterface_Type_Call { 1521 _c.Call.Run(func(args mock.Arguments) { 1522 run() 1523 }) 1524 return _c 1525 } 1526 1527 func (_c *FeatureLocalInterface_Type_Call) Return(_a0 model.FeatureTypeType) *FeatureLocalInterface_Type_Call { 1528 _c.Call.Return(_a0) 1529 return _c 1530 } 1531 1532 func (_c *FeatureLocalInterface_Type_Call) RunAndReturn(run func() model.FeatureTypeType) *FeatureLocalInterface_Type_Call { 1533 _c.Call.Return(run) 1534 return _c 1535 } 1536 1537 // UpdateData provides a mock function with given fields: function, data, filterPartial, filterDelete 1538 func (_m *FeatureLocalInterface) UpdateData(function model.FunctionType, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType) *model.ErrorType { 1539 ret := _m.Called(function, data, filterPartial, filterDelete) 1540 1541 if len(ret) == 0 { 1542 panic("no return value specified for UpdateData") 1543 } 1544 1545 var r0 *model.ErrorType 1546 if rf, ok := ret.Get(0).(func(model.FunctionType, interface{}, *model.FilterType, *model.FilterType) *model.ErrorType); ok { 1547 r0 = rf(function, data, filterPartial, filterDelete) 1548 } else { 1549 if ret.Get(0) != nil { 1550 r0 = ret.Get(0).(*model.ErrorType) 1551 } 1552 } 1553 1554 return r0 1555 } 1556 1557 // FeatureLocalInterface_UpdateData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateData' 1558 type FeatureLocalInterface_UpdateData_Call struct { 1559 *mock.Call 1560 } 1561 1562 // UpdateData is a helper method to define mock.On call 1563 // - function model.FunctionType 1564 // - data interface{} 1565 // - filterPartial *model.FilterType 1566 // - filterDelete *model.FilterType 1567 func (_e *FeatureLocalInterface_Expecter) UpdateData(function interface{}, data interface{}, filterPartial interface{}, filterDelete interface{}) *FeatureLocalInterface_UpdateData_Call { 1568 return &FeatureLocalInterface_UpdateData_Call{Call: _e.mock.On("UpdateData", function, data, filterPartial, filterDelete)} 1569 } 1570 1571 func (_c *FeatureLocalInterface_UpdateData_Call) Run(run func(function model.FunctionType, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType)) *FeatureLocalInterface_UpdateData_Call { 1572 _c.Call.Run(func(args mock.Arguments) { 1573 run(args[0].(model.FunctionType), args[1].(interface{}), args[2].(*model.FilterType), args[3].(*model.FilterType)) 1574 }) 1575 return _c 1576 } 1577 1578 func (_c *FeatureLocalInterface_UpdateData_Call) Return(_a0 *model.ErrorType) *FeatureLocalInterface_UpdateData_Call { 1579 _c.Call.Return(_a0) 1580 return _c 1581 } 1582 1583 func (_c *FeatureLocalInterface_UpdateData_Call) RunAndReturn(run func(model.FunctionType, interface{}, *model.FilterType, *model.FilterType) *model.ErrorType) *FeatureLocalInterface_UpdateData_Call { 1584 _c.Call.Return(run) 1585 return _c 1586 } 1587 1588 // NewFeatureLocalInterface creates a new instance of FeatureLocalInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. 1589 // The first argument is typically a *testing.T value. 1590 func NewFeatureLocalInterface(t interface { 1591 mock.TestingT 1592 Cleanup(func()) 1593 }) *FeatureLocalInterface { 1594 mock := &FeatureLocalInterface{} 1595 mock.Mock.Test(t) 1596 1597 t.Cleanup(func() { mock.AssertExpectations(t) }) 1598 1599 return mock 1600 }