github.com/enbility/spine-go@v0.7.0/mocks/FeatureRemoteInterface.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 // FeatureRemoteInterface is an autogenerated mock type for the FeatureRemoteInterface type 15 type FeatureRemoteInterface struct { 16 mock.Mock 17 } 18 19 type FeatureRemoteInterface_Expecter struct { 20 mock *mock.Mock 21 } 22 23 func (_m *FeatureRemoteInterface) EXPECT() *FeatureRemoteInterface_Expecter { 24 return &FeatureRemoteInterface_Expecter{mock: &_m.Mock} 25 } 26 27 // Address provides a mock function with given fields: 28 func (_m *FeatureRemoteInterface) Address() *model.FeatureAddressType { 29 ret := _m.Called() 30 31 if len(ret) == 0 { 32 panic("no return value specified for Address") 33 } 34 35 var r0 *model.FeatureAddressType 36 if rf, ok := ret.Get(0).(func() *model.FeatureAddressType); ok { 37 r0 = rf() 38 } else { 39 if ret.Get(0) != nil { 40 r0 = ret.Get(0).(*model.FeatureAddressType) 41 } 42 } 43 44 return r0 45 } 46 47 // FeatureRemoteInterface_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address' 48 type FeatureRemoteInterface_Address_Call struct { 49 *mock.Call 50 } 51 52 // Address is a helper method to define mock.On call 53 func (_e *FeatureRemoteInterface_Expecter) Address() *FeatureRemoteInterface_Address_Call { 54 return &FeatureRemoteInterface_Address_Call{Call: _e.mock.On("Address")} 55 } 56 57 func (_c *FeatureRemoteInterface_Address_Call) Run(run func()) *FeatureRemoteInterface_Address_Call { 58 _c.Call.Run(func(args mock.Arguments) { 59 run() 60 }) 61 return _c 62 } 63 64 func (_c *FeatureRemoteInterface_Address_Call) Return(_a0 *model.FeatureAddressType) *FeatureRemoteInterface_Address_Call { 65 _c.Call.Return(_a0) 66 return _c 67 } 68 69 func (_c *FeatureRemoteInterface_Address_Call) RunAndReturn(run func() *model.FeatureAddressType) *FeatureRemoteInterface_Address_Call { 70 _c.Call.Return(run) 71 return _c 72 } 73 74 // DataCopy provides a mock function with given fields: function 75 func (_m *FeatureRemoteInterface) DataCopy(function model.FunctionType) interface{} { 76 ret := _m.Called(function) 77 78 if len(ret) == 0 { 79 panic("no return value specified for DataCopy") 80 } 81 82 var r0 interface{} 83 if rf, ok := ret.Get(0).(func(model.FunctionType) interface{}); ok { 84 r0 = rf(function) 85 } else { 86 if ret.Get(0) != nil { 87 r0 = ret.Get(0).(interface{}) 88 } 89 } 90 91 return r0 92 } 93 94 // FeatureRemoteInterface_DataCopy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataCopy' 95 type FeatureRemoteInterface_DataCopy_Call struct { 96 *mock.Call 97 } 98 99 // DataCopy is a helper method to define mock.On call 100 // - function model.FunctionType 101 func (_e *FeatureRemoteInterface_Expecter) DataCopy(function interface{}) *FeatureRemoteInterface_DataCopy_Call { 102 return &FeatureRemoteInterface_DataCopy_Call{Call: _e.mock.On("DataCopy", function)} 103 } 104 105 func (_c *FeatureRemoteInterface_DataCopy_Call) Run(run func(function model.FunctionType)) *FeatureRemoteInterface_DataCopy_Call { 106 _c.Call.Run(func(args mock.Arguments) { 107 run(args[0].(model.FunctionType)) 108 }) 109 return _c 110 } 111 112 func (_c *FeatureRemoteInterface_DataCopy_Call) Return(_a0 interface{}) *FeatureRemoteInterface_DataCopy_Call { 113 _c.Call.Return(_a0) 114 return _c 115 } 116 117 func (_c *FeatureRemoteInterface_DataCopy_Call) RunAndReturn(run func(model.FunctionType) interface{}) *FeatureRemoteInterface_DataCopy_Call { 118 _c.Call.Return(run) 119 return _c 120 } 121 122 // Description provides a mock function with given fields: 123 func (_m *FeatureRemoteInterface) Description() *model.DescriptionType { 124 ret := _m.Called() 125 126 if len(ret) == 0 { 127 panic("no return value specified for Description") 128 } 129 130 var r0 *model.DescriptionType 131 if rf, ok := ret.Get(0).(func() *model.DescriptionType); ok { 132 r0 = rf() 133 } else { 134 if ret.Get(0) != nil { 135 r0 = ret.Get(0).(*model.DescriptionType) 136 } 137 } 138 139 return r0 140 } 141 142 // FeatureRemoteInterface_Description_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Description' 143 type FeatureRemoteInterface_Description_Call struct { 144 *mock.Call 145 } 146 147 // Description is a helper method to define mock.On call 148 func (_e *FeatureRemoteInterface_Expecter) Description() *FeatureRemoteInterface_Description_Call { 149 return &FeatureRemoteInterface_Description_Call{Call: _e.mock.On("Description")} 150 } 151 152 func (_c *FeatureRemoteInterface_Description_Call) Run(run func()) *FeatureRemoteInterface_Description_Call { 153 _c.Call.Run(func(args mock.Arguments) { 154 run() 155 }) 156 return _c 157 } 158 159 func (_c *FeatureRemoteInterface_Description_Call) Return(_a0 *model.DescriptionType) *FeatureRemoteInterface_Description_Call { 160 _c.Call.Return(_a0) 161 return _c 162 } 163 164 func (_c *FeatureRemoteInterface_Description_Call) RunAndReturn(run func() *model.DescriptionType) *FeatureRemoteInterface_Description_Call { 165 _c.Call.Return(run) 166 return _c 167 } 168 169 // Device provides a mock function with given fields: 170 func (_m *FeatureRemoteInterface) Device() api.DeviceRemoteInterface { 171 ret := _m.Called() 172 173 if len(ret) == 0 { 174 panic("no return value specified for Device") 175 } 176 177 var r0 api.DeviceRemoteInterface 178 if rf, ok := ret.Get(0).(func() api.DeviceRemoteInterface); ok { 179 r0 = rf() 180 } else { 181 if ret.Get(0) != nil { 182 r0 = ret.Get(0).(api.DeviceRemoteInterface) 183 } 184 } 185 186 return r0 187 } 188 189 // FeatureRemoteInterface_Device_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Device' 190 type FeatureRemoteInterface_Device_Call struct { 191 *mock.Call 192 } 193 194 // Device is a helper method to define mock.On call 195 func (_e *FeatureRemoteInterface_Expecter) Device() *FeatureRemoteInterface_Device_Call { 196 return &FeatureRemoteInterface_Device_Call{Call: _e.mock.On("Device")} 197 } 198 199 func (_c *FeatureRemoteInterface_Device_Call) Run(run func()) *FeatureRemoteInterface_Device_Call { 200 _c.Call.Run(func(args mock.Arguments) { 201 run() 202 }) 203 return _c 204 } 205 206 func (_c *FeatureRemoteInterface_Device_Call) Return(_a0 api.DeviceRemoteInterface) *FeatureRemoteInterface_Device_Call { 207 _c.Call.Return(_a0) 208 return _c 209 } 210 211 func (_c *FeatureRemoteInterface_Device_Call) RunAndReturn(run func() api.DeviceRemoteInterface) *FeatureRemoteInterface_Device_Call { 212 _c.Call.Return(run) 213 return _c 214 } 215 216 // Entity provides a mock function with given fields: 217 func (_m *FeatureRemoteInterface) Entity() api.EntityRemoteInterface { 218 ret := _m.Called() 219 220 if len(ret) == 0 { 221 panic("no return value specified for Entity") 222 } 223 224 var r0 api.EntityRemoteInterface 225 if rf, ok := ret.Get(0).(func() api.EntityRemoteInterface); ok { 226 r0 = rf() 227 } else { 228 if ret.Get(0) != nil { 229 r0 = ret.Get(0).(api.EntityRemoteInterface) 230 } 231 } 232 233 return r0 234 } 235 236 // FeatureRemoteInterface_Entity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Entity' 237 type FeatureRemoteInterface_Entity_Call struct { 238 *mock.Call 239 } 240 241 // Entity is a helper method to define mock.On call 242 func (_e *FeatureRemoteInterface_Expecter) Entity() *FeatureRemoteInterface_Entity_Call { 243 return &FeatureRemoteInterface_Entity_Call{Call: _e.mock.On("Entity")} 244 } 245 246 func (_c *FeatureRemoteInterface_Entity_Call) Run(run func()) *FeatureRemoteInterface_Entity_Call { 247 _c.Call.Run(func(args mock.Arguments) { 248 run() 249 }) 250 return _c 251 } 252 253 func (_c *FeatureRemoteInterface_Entity_Call) Return(_a0 api.EntityRemoteInterface) *FeatureRemoteInterface_Entity_Call { 254 _c.Call.Return(_a0) 255 return _c 256 } 257 258 func (_c *FeatureRemoteInterface_Entity_Call) RunAndReturn(run func() api.EntityRemoteInterface) *FeatureRemoteInterface_Entity_Call { 259 _c.Call.Return(run) 260 return _c 261 } 262 263 // MaxResponseDelayDuration provides a mock function with given fields: 264 func (_m *FeatureRemoteInterface) MaxResponseDelayDuration() time.Duration { 265 ret := _m.Called() 266 267 if len(ret) == 0 { 268 panic("no return value specified for MaxResponseDelayDuration") 269 } 270 271 var r0 time.Duration 272 if rf, ok := ret.Get(0).(func() time.Duration); ok { 273 r0 = rf() 274 } else { 275 r0 = ret.Get(0).(time.Duration) 276 } 277 278 return r0 279 } 280 281 // FeatureRemoteInterface_MaxResponseDelayDuration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MaxResponseDelayDuration' 282 type FeatureRemoteInterface_MaxResponseDelayDuration_Call struct { 283 *mock.Call 284 } 285 286 // MaxResponseDelayDuration is a helper method to define mock.On call 287 func (_e *FeatureRemoteInterface_Expecter) MaxResponseDelayDuration() *FeatureRemoteInterface_MaxResponseDelayDuration_Call { 288 return &FeatureRemoteInterface_MaxResponseDelayDuration_Call{Call: _e.mock.On("MaxResponseDelayDuration")} 289 } 290 291 func (_c *FeatureRemoteInterface_MaxResponseDelayDuration_Call) Run(run func()) *FeatureRemoteInterface_MaxResponseDelayDuration_Call { 292 _c.Call.Run(func(args mock.Arguments) { 293 run() 294 }) 295 return _c 296 } 297 298 func (_c *FeatureRemoteInterface_MaxResponseDelayDuration_Call) Return(_a0 time.Duration) *FeatureRemoteInterface_MaxResponseDelayDuration_Call { 299 _c.Call.Return(_a0) 300 return _c 301 } 302 303 func (_c *FeatureRemoteInterface_MaxResponseDelayDuration_Call) RunAndReturn(run func() time.Duration) *FeatureRemoteInterface_MaxResponseDelayDuration_Call { 304 _c.Call.Return(run) 305 return _c 306 } 307 308 // Operations provides a mock function with given fields: 309 func (_m *FeatureRemoteInterface) Operations() map[model.FunctionType]api.OperationsInterface { 310 ret := _m.Called() 311 312 if len(ret) == 0 { 313 panic("no return value specified for Operations") 314 } 315 316 var r0 map[model.FunctionType]api.OperationsInterface 317 if rf, ok := ret.Get(0).(func() map[model.FunctionType]api.OperationsInterface); ok { 318 r0 = rf() 319 } else { 320 if ret.Get(0) != nil { 321 r0 = ret.Get(0).(map[model.FunctionType]api.OperationsInterface) 322 } 323 } 324 325 return r0 326 } 327 328 // FeatureRemoteInterface_Operations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Operations' 329 type FeatureRemoteInterface_Operations_Call struct { 330 *mock.Call 331 } 332 333 // Operations is a helper method to define mock.On call 334 func (_e *FeatureRemoteInterface_Expecter) Operations() *FeatureRemoteInterface_Operations_Call { 335 return &FeatureRemoteInterface_Operations_Call{Call: _e.mock.On("Operations")} 336 } 337 338 func (_c *FeatureRemoteInterface_Operations_Call) Run(run func()) *FeatureRemoteInterface_Operations_Call { 339 _c.Call.Run(func(args mock.Arguments) { 340 run() 341 }) 342 return _c 343 } 344 345 func (_c *FeatureRemoteInterface_Operations_Call) Return(_a0 map[model.FunctionType]api.OperationsInterface) *FeatureRemoteInterface_Operations_Call { 346 _c.Call.Return(_a0) 347 return _c 348 } 349 350 func (_c *FeatureRemoteInterface_Operations_Call) RunAndReturn(run func() map[model.FunctionType]api.OperationsInterface) *FeatureRemoteInterface_Operations_Call { 351 _c.Call.Return(run) 352 return _c 353 } 354 355 // Role provides a mock function with given fields: 356 func (_m *FeatureRemoteInterface) Role() model.RoleType { 357 ret := _m.Called() 358 359 if len(ret) == 0 { 360 panic("no return value specified for Role") 361 } 362 363 var r0 model.RoleType 364 if rf, ok := ret.Get(0).(func() model.RoleType); ok { 365 r0 = rf() 366 } else { 367 r0 = ret.Get(0).(model.RoleType) 368 } 369 370 return r0 371 } 372 373 // FeatureRemoteInterface_Role_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Role' 374 type FeatureRemoteInterface_Role_Call struct { 375 *mock.Call 376 } 377 378 // Role is a helper method to define mock.On call 379 func (_e *FeatureRemoteInterface_Expecter) Role() *FeatureRemoteInterface_Role_Call { 380 return &FeatureRemoteInterface_Role_Call{Call: _e.mock.On("Role")} 381 } 382 383 func (_c *FeatureRemoteInterface_Role_Call) Run(run func()) *FeatureRemoteInterface_Role_Call { 384 _c.Call.Run(func(args mock.Arguments) { 385 run() 386 }) 387 return _c 388 } 389 390 func (_c *FeatureRemoteInterface_Role_Call) Return(_a0 model.RoleType) *FeatureRemoteInterface_Role_Call { 391 _c.Call.Return(_a0) 392 return _c 393 } 394 395 func (_c *FeatureRemoteInterface_Role_Call) RunAndReturn(run func() model.RoleType) *FeatureRemoteInterface_Role_Call { 396 _c.Call.Return(run) 397 return _c 398 } 399 400 // SetDescription provides a mock function with given fields: desc 401 func (_m *FeatureRemoteInterface) SetDescription(desc *model.DescriptionType) { 402 _m.Called(desc) 403 } 404 405 // FeatureRemoteInterface_SetDescription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDescription' 406 type FeatureRemoteInterface_SetDescription_Call struct { 407 *mock.Call 408 } 409 410 // SetDescription is a helper method to define mock.On call 411 // - desc *model.DescriptionType 412 func (_e *FeatureRemoteInterface_Expecter) SetDescription(desc interface{}) *FeatureRemoteInterface_SetDescription_Call { 413 return &FeatureRemoteInterface_SetDescription_Call{Call: _e.mock.On("SetDescription", desc)} 414 } 415 416 func (_c *FeatureRemoteInterface_SetDescription_Call) Run(run func(desc *model.DescriptionType)) *FeatureRemoteInterface_SetDescription_Call { 417 _c.Call.Run(func(args mock.Arguments) { 418 run(args[0].(*model.DescriptionType)) 419 }) 420 return _c 421 } 422 423 func (_c *FeatureRemoteInterface_SetDescription_Call) Return() *FeatureRemoteInterface_SetDescription_Call { 424 _c.Call.Return() 425 return _c 426 } 427 428 func (_c *FeatureRemoteInterface_SetDescription_Call) RunAndReturn(run func(*model.DescriptionType)) *FeatureRemoteInterface_SetDescription_Call { 429 _c.Call.Return(run) 430 return _c 431 } 432 433 // SetDescriptionString provides a mock function with given fields: s 434 func (_m *FeatureRemoteInterface) SetDescriptionString(s string) { 435 _m.Called(s) 436 } 437 438 // FeatureRemoteInterface_SetDescriptionString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDescriptionString' 439 type FeatureRemoteInterface_SetDescriptionString_Call struct { 440 *mock.Call 441 } 442 443 // SetDescriptionString is a helper method to define mock.On call 444 // - s string 445 func (_e *FeatureRemoteInterface_Expecter) SetDescriptionString(s interface{}) *FeatureRemoteInterface_SetDescriptionString_Call { 446 return &FeatureRemoteInterface_SetDescriptionString_Call{Call: _e.mock.On("SetDescriptionString", s)} 447 } 448 449 func (_c *FeatureRemoteInterface_SetDescriptionString_Call) Run(run func(s string)) *FeatureRemoteInterface_SetDescriptionString_Call { 450 _c.Call.Run(func(args mock.Arguments) { 451 run(args[0].(string)) 452 }) 453 return _c 454 } 455 456 func (_c *FeatureRemoteInterface_SetDescriptionString_Call) Return() *FeatureRemoteInterface_SetDescriptionString_Call { 457 _c.Call.Return() 458 return _c 459 } 460 461 func (_c *FeatureRemoteInterface_SetDescriptionString_Call) RunAndReturn(run func(string)) *FeatureRemoteInterface_SetDescriptionString_Call { 462 _c.Call.Return(run) 463 return _c 464 } 465 466 // SetMaxResponseDelay provides a mock function with given fields: delay 467 func (_m *FeatureRemoteInterface) SetMaxResponseDelay(delay *model.MaxResponseDelayType) { 468 _m.Called(delay) 469 } 470 471 // FeatureRemoteInterface_SetMaxResponseDelay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMaxResponseDelay' 472 type FeatureRemoteInterface_SetMaxResponseDelay_Call struct { 473 *mock.Call 474 } 475 476 // SetMaxResponseDelay is a helper method to define mock.On call 477 // - delay *model.MaxResponseDelayType 478 func (_e *FeatureRemoteInterface_Expecter) SetMaxResponseDelay(delay interface{}) *FeatureRemoteInterface_SetMaxResponseDelay_Call { 479 return &FeatureRemoteInterface_SetMaxResponseDelay_Call{Call: _e.mock.On("SetMaxResponseDelay", delay)} 480 } 481 482 func (_c *FeatureRemoteInterface_SetMaxResponseDelay_Call) Run(run func(delay *model.MaxResponseDelayType)) *FeatureRemoteInterface_SetMaxResponseDelay_Call { 483 _c.Call.Run(func(args mock.Arguments) { 484 run(args[0].(*model.MaxResponseDelayType)) 485 }) 486 return _c 487 } 488 489 func (_c *FeatureRemoteInterface_SetMaxResponseDelay_Call) Return() *FeatureRemoteInterface_SetMaxResponseDelay_Call { 490 _c.Call.Return() 491 return _c 492 } 493 494 func (_c *FeatureRemoteInterface_SetMaxResponseDelay_Call) RunAndReturn(run func(*model.MaxResponseDelayType)) *FeatureRemoteInterface_SetMaxResponseDelay_Call { 495 _c.Call.Return(run) 496 return _c 497 } 498 499 // SetOperations provides a mock function with given fields: functions 500 func (_m *FeatureRemoteInterface) SetOperations(functions []model.FunctionPropertyType) { 501 _m.Called(functions) 502 } 503 504 // FeatureRemoteInterface_SetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOperations' 505 type FeatureRemoteInterface_SetOperations_Call struct { 506 *mock.Call 507 } 508 509 // SetOperations is a helper method to define mock.On call 510 // - functions []model.FunctionPropertyType 511 func (_e *FeatureRemoteInterface_Expecter) SetOperations(functions interface{}) *FeatureRemoteInterface_SetOperations_Call { 512 return &FeatureRemoteInterface_SetOperations_Call{Call: _e.mock.On("SetOperations", functions)} 513 } 514 515 func (_c *FeatureRemoteInterface_SetOperations_Call) Run(run func(functions []model.FunctionPropertyType)) *FeatureRemoteInterface_SetOperations_Call { 516 _c.Call.Run(func(args mock.Arguments) { 517 run(args[0].([]model.FunctionPropertyType)) 518 }) 519 return _c 520 } 521 522 func (_c *FeatureRemoteInterface_SetOperations_Call) Return() *FeatureRemoteInterface_SetOperations_Call { 523 _c.Call.Return() 524 return _c 525 } 526 527 func (_c *FeatureRemoteInterface_SetOperations_Call) RunAndReturn(run func([]model.FunctionPropertyType)) *FeatureRemoteInterface_SetOperations_Call { 528 _c.Call.Return(run) 529 return _c 530 } 531 532 // String provides a mock function with given fields: 533 func (_m *FeatureRemoteInterface) String() string { 534 ret := _m.Called() 535 536 if len(ret) == 0 { 537 panic("no return value specified for String") 538 } 539 540 var r0 string 541 if rf, ok := ret.Get(0).(func() string); ok { 542 r0 = rf() 543 } else { 544 r0 = ret.Get(0).(string) 545 } 546 547 return r0 548 } 549 550 // FeatureRemoteInterface_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' 551 type FeatureRemoteInterface_String_Call struct { 552 *mock.Call 553 } 554 555 // String is a helper method to define mock.On call 556 func (_e *FeatureRemoteInterface_Expecter) String() *FeatureRemoteInterface_String_Call { 557 return &FeatureRemoteInterface_String_Call{Call: _e.mock.On("String")} 558 } 559 560 func (_c *FeatureRemoteInterface_String_Call) Run(run func()) *FeatureRemoteInterface_String_Call { 561 _c.Call.Run(func(args mock.Arguments) { 562 run() 563 }) 564 return _c 565 } 566 567 func (_c *FeatureRemoteInterface_String_Call) Return(_a0 string) *FeatureRemoteInterface_String_Call { 568 _c.Call.Return(_a0) 569 return _c 570 } 571 572 func (_c *FeatureRemoteInterface_String_Call) RunAndReturn(run func() string) *FeatureRemoteInterface_String_Call { 573 _c.Call.Return(run) 574 return _c 575 } 576 577 // Type provides a mock function with given fields: 578 func (_m *FeatureRemoteInterface) Type() model.FeatureTypeType { 579 ret := _m.Called() 580 581 if len(ret) == 0 { 582 panic("no return value specified for Type") 583 } 584 585 var r0 model.FeatureTypeType 586 if rf, ok := ret.Get(0).(func() model.FeatureTypeType); ok { 587 r0 = rf() 588 } else { 589 r0 = ret.Get(0).(model.FeatureTypeType) 590 } 591 592 return r0 593 } 594 595 // FeatureRemoteInterface_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type' 596 type FeatureRemoteInterface_Type_Call struct { 597 *mock.Call 598 } 599 600 // Type is a helper method to define mock.On call 601 func (_e *FeatureRemoteInterface_Expecter) Type() *FeatureRemoteInterface_Type_Call { 602 return &FeatureRemoteInterface_Type_Call{Call: _e.mock.On("Type")} 603 } 604 605 func (_c *FeatureRemoteInterface_Type_Call) Run(run func()) *FeatureRemoteInterface_Type_Call { 606 _c.Call.Run(func(args mock.Arguments) { 607 run() 608 }) 609 return _c 610 } 611 612 func (_c *FeatureRemoteInterface_Type_Call) Return(_a0 model.FeatureTypeType) *FeatureRemoteInterface_Type_Call { 613 _c.Call.Return(_a0) 614 return _c 615 } 616 617 func (_c *FeatureRemoteInterface_Type_Call) RunAndReturn(run func() model.FeatureTypeType) *FeatureRemoteInterface_Type_Call { 618 _c.Call.Return(run) 619 return _c 620 } 621 622 // UpdateData provides a mock function with given fields: persist, function, data, filterPartial, filterDelete 623 func (_m *FeatureRemoteInterface) UpdateData(persist bool, function model.FunctionType, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType) (interface{}, *model.ErrorType) { 624 ret := _m.Called(persist, function, data, filterPartial, filterDelete) 625 626 if len(ret) == 0 { 627 panic("no return value specified for UpdateData") 628 } 629 630 var r0 interface{} 631 var r1 *model.ErrorType 632 if rf, ok := ret.Get(0).(func(bool, model.FunctionType, interface{}, *model.FilterType, *model.FilterType) (interface{}, *model.ErrorType)); ok { 633 return rf(persist, function, data, filterPartial, filterDelete) 634 } 635 if rf, ok := ret.Get(0).(func(bool, model.FunctionType, interface{}, *model.FilterType, *model.FilterType) interface{}); ok { 636 r0 = rf(persist, function, data, filterPartial, filterDelete) 637 } else { 638 if ret.Get(0) != nil { 639 r0 = ret.Get(0).(interface{}) 640 } 641 } 642 643 if rf, ok := ret.Get(1).(func(bool, model.FunctionType, interface{}, *model.FilterType, *model.FilterType) *model.ErrorType); ok { 644 r1 = rf(persist, function, data, filterPartial, filterDelete) 645 } else { 646 if ret.Get(1) != nil { 647 r1 = ret.Get(1).(*model.ErrorType) 648 } 649 } 650 651 return r0, r1 652 } 653 654 // FeatureRemoteInterface_UpdateData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateData' 655 type FeatureRemoteInterface_UpdateData_Call struct { 656 *mock.Call 657 } 658 659 // UpdateData is a helper method to define mock.On call 660 // - persist bool 661 // - function model.FunctionType 662 // - data interface{} 663 // - filterPartial *model.FilterType 664 // - filterDelete *model.FilterType 665 func (_e *FeatureRemoteInterface_Expecter) UpdateData(persist interface{}, function interface{}, data interface{}, filterPartial interface{}, filterDelete interface{}) *FeatureRemoteInterface_UpdateData_Call { 666 return &FeatureRemoteInterface_UpdateData_Call{Call: _e.mock.On("UpdateData", persist, function, data, filterPartial, filterDelete)} 667 } 668 669 func (_c *FeatureRemoteInterface_UpdateData_Call) Run(run func(persist bool, function model.FunctionType, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType)) *FeatureRemoteInterface_UpdateData_Call { 670 _c.Call.Run(func(args mock.Arguments) { 671 run(args[0].(bool), args[1].(model.FunctionType), args[2].(interface{}), args[3].(*model.FilterType), args[4].(*model.FilterType)) 672 }) 673 return _c 674 } 675 676 func (_c *FeatureRemoteInterface_UpdateData_Call) Return(_a0 interface{}, _a1 *model.ErrorType) *FeatureRemoteInterface_UpdateData_Call { 677 _c.Call.Return(_a0, _a1) 678 return _c 679 } 680 681 func (_c *FeatureRemoteInterface_UpdateData_Call) RunAndReturn(run func(bool, model.FunctionType, interface{}, *model.FilterType, *model.FilterType) (interface{}, *model.ErrorType)) *FeatureRemoteInterface_UpdateData_Call { 682 _c.Call.Return(run) 683 return _c 684 } 685 686 // NewFeatureRemoteInterface creates a new instance of FeatureRemoteInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. 687 // The first argument is typically a *testing.T value. 688 func NewFeatureRemoteInterface(t interface { 689 mock.TestingT 690 Cleanup(func()) 691 }) *FeatureRemoteInterface { 692 mock := &FeatureRemoteInterface{} 693 mock.Mock.Test(t) 694 695 t.Cleanup(func() { mock.AssertExpectations(t) }) 696 697 return mock 698 }