1// Code generated by counterfeiter. DO NOT EDIT. 2package mocks 3 4import ( 5 "context" 6 "sync" 7 8 "github.com/syncthing/syncthing/lib/config" 9 "github.com/syncthing/syncthing/lib/protocol" 10) 11 12type Wrapper struct { 13 ConfigPathStub func() string 14 configPathMutex sync.RWMutex 15 configPathArgsForCall []struct { 16 } 17 configPathReturns struct { 18 result1 string 19 } 20 configPathReturnsOnCall map[int]struct { 21 result1 string 22 } 23 DefaultDeviceStub func() config.DeviceConfiguration 24 defaultDeviceMutex sync.RWMutex 25 defaultDeviceArgsForCall []struct { 26 } 27 defaultDeviceReturns struct { 28 result1 config.DeviceConfiguration 29 } 30 defaultDeviceReturnsOnCall map[int]struct { 31 result1 config.DeviceConfiguration 32 } 33 DefaultFolderStub func() config.FolderConfiguration 34 defaultFolderMutex sync.RWMutex 35 defaultFolderArgsForCall []struct { 36 } 37 defaultFolderReturns struct { 38 result1 config.FolderConfiguration 39 } 40 defaultFolderReturnsOnCall map[int]struct { 41 result1 config.FolderConfiguration 42 } 43 DeviceStub func(protocol.DeviceID) (config.DeviceConfiguration, bool) 44 deviceMutex sync.RWMutex 45 deviceArgsForCall []struct { 46 arg1 protocol.DeviceID 47 } 48 deviceReturns struct { 49 result1 config.DeviceConfiguration 50 result2 bool 51 } 52 deviceReturnsOnCall map[int]struct { 53 result1 config.DeviceConfiguration 54 result2 bool 55 } 56 DeviceListStub func() []config.DeviceConfiguration 57 deviceListMutex sync.RWMutex 58 deviceListArgsForCall []struct { 59 } 60 deviceListReturns struct { 61 result1 []config.DeviceConfiguration 62 } 63 deviceListReturnsOnCall map[int]struct { 64 result1 []config.DeviceConfiguration 65 } 66 DevicesStub func() map[protocol.DeviceID]config.DeviceConfiguration 67 devicesMutex sync.RWMutex 68 devicesArgsForCall []struct { 69 } 70 devicesReturns struct { 71 result1 map[protocol.DeviceID]config.DeviceConfiguration 72 } 73 devicesReturnsOnCall map[int]struct { 74 result1 map[protocol.DeviceID]config.DeviceConfiguration 75 } 76 FolderStub func(string) (config.FolderConfiguration, bool) 77 folderMutex sync.RWMutex 78 folderArgsForCall []struct { 79 arg1 string 80 } 81 folderReturns struct { 82 result1 config.FolderConfiguration 83 result2 bool 84 } 85 folderReturnsOnCall map[int]struct { 86 result1 config.FolderConfiguration 87 result2 bool 88 } 89 FolderListStub func() []config.FolderConfiguration 90 folderListMutex sync.RWMutex 91 folderListArgsForCall []struct { 92 } 93 folderListReturns struct { 94 result1 []config.FolderConfiguration 95 } 96 folderListReturnsOnCall map[int]struct { 97 result1 []config.FolderConfiguration 98 } 99 FolderPasswordsStub func(protocol.DeviceID) map[string]string 100 folderPasswordsMutex sync.RWMutex 101 folderPasswordsArgsForCall []struct { 102 arg1 protocol.DeviceID 103 } 104 folderPasswordsReturns struct { 105 result1 map[string]string 106 } 107 folderPasswordsReturnsOnCall map[int]struct { 108 result1 map[string]string 109 } 110 FoldersStub func() map[string]config.FolderConfiguration 111 foldersMutex sync.RWMutex 112 foldersArgsForCall []struct { 113 } 114 foldersReturns struct { 115 result1 map[string]config.FolderConfiguration 116 } 117 foldersReturnsOnCall map[int]struct { 118 result1 map[string]config.FolderConfiguration 119 } 120 GUIStub func() config.GUIConfiguration 121 gUIMutex sync.RWMutex 122 gUIArgsForCall []struct { 123 } 124 gUIReturns struct { 125 result1 config.GUIConfiguration 126 } 127 gUIReturnsOnCall map[int]struct { 128 result1 config.GUIConfiguration 129 } 130 IgnoredDeviceStub func(protocol.DeviceID) bool 131 ignoredDeviceMutex sync.RWMutex 132 ignoredDeviceArgsForCall []struct { 133 arg1 protocol.DeviceID 134 } 135 ignoredDeviceReturns struct { 136 result1 bool 137 } 138 ignoredDeviceReturnsOnCall map[int]struct { 139 result1 bool 140 } 141 IgnoredDevicesStub func() []config.ObservedDevice 142 ignoredDevicesMutex sync.RWMutex 143 ignoredDevicesArgsForCall []struct { 144 } 145 ignoredDevicesReturns struct { 146 result1 []config.ObservedDevice 147 } 148 ignoredDevicesReturnsOnCall map[int]struct { 149 result1 []config.ObservedDevice 150 } 151 IgnoredFolderStub func(protocol.DeviceID, string) bool 152 ignoredFolderMutex sync.RWMutex 153 ignoredFolderArgsForCall []struct { 154 arg1 protocol.DeviceID 155 arg2 string 156 } 157 ignoredFolderReturns struct { 158 result1 bool 159 } 160 ignoredFolderReturnsOnCall map[int]struct { 161 result1 bool 162 } 163 LDAPStub func() config.LDAPConfiguration 164 lDAPMutex sync.RWMutex 165 lDAPArgsForCall []struct { 166 } 167 lDAPReturns struct { 168 result1 config.LDAPConfiguration 169 } 170 lDAPReturnsOnCall map[int]struct { 171 result1 config.LDAPConfiguration 172 } 173 ModifyStub func(config.ModifyFunction) (config.Waiter, error) 174 modifyMutex sync.RWMutex 175 modifyArgsForCall []struct { 176 arg1 config.ModifyFunction 177 } 178 modifyReturns struct { 179 result1 config.Waiter 180 result2 error 181 } 182 modifyReturnsOnCall map[int]struct { 183 result1 config.Waiter 184 result2 error 185 } 186 MyIDStub func() protocol.DeviceID 187 myIDMutex sync.RWMutex 188 myIDArgsForCall []struct { 189 } 190 myIDReturns struct { 191 result1 protocol.DeviceID 192 } 193 myIDReturnsOnCall map[int]struct { 194 result1 protocol.DeviceID 195 } 196 OptionsStub func() config.OptionsConfiguration 197 optionsMutex sync.RWMutex 198 optionsArgsForCall []struct { 199 } 200 optionsReturns struct { 201 result1 config.OptionsConfiguration 202 } 203 optionsReturnsOnCall map[int]struct { 204 result1 config.OptionsConfiguration 205 } 206 RawCopyStub func() config.Configuration 207 rawCopyMutex sync.RWMutex 208 rawCopyArgsForCall []struct { 209 } 210 rawCopyReturns struct { 211 result1 config.Configuration 212 } 213 rawCopyReturnsOnCall map[int]struct { 214 result1 config.Configuration 215 } 216 RemoveDeviceStub func(protocol.DeviceID) (config.Waiter, error) 217 removeDeviceMutex sync.RWMutex 218 removeDeviceArgsForCall []struct { 219 arg1 protocol.DeviceID 220 } 221 removeDeviceReturns struct { 222 result1 config.Waiter 223 result2 error 224 } 225 removeDeviceReturnsOnCall map[int]struct { 226 result1 config.Waiter 227 result2 error 228 } 229 RemoveFolderStub func(string) (config.Waiter, error) 230 removeFolderMutex sync.RWMutex 231 removeFolderArgsForCall []struct { 232 arg1 string 233 } 234 removeFolderReturns struct { 235 result1 config.Waiter 236 result2 error 237 } 238 removeFolderReturnsOnCall map[int]struct { 239 result1 config.Waiter 240 result2 error 241 } 242 RequiresRestartStub func() bool 243 requiresRestartMutex sync.RWMutex 244 requiresRestartArgsForCall []struct { 245 } 246 requiresRestartReturns struct { 247 result1 bool 248 } 249 requiresRestartReturnsOnCall map[int]struct { 250 result1 bool 251 } 252 SaveStub func() error 253 saveMutex sync.RWMutex 254 saveArgsForCall []struct { 255 } 256 saveReturns struct { 257 result1 error 258 } 259 saveReturnsOnCall map[int]struct { 260 result1 error 261 } 262 ServeStub func(context.Context) error 263 serveMutex sync.RWMutex 264 serveArgsForCall []struct { 265 arg1 context.Context 266 } 267 serveReturns struct { 268 result1 error 269 } 270 serveReturnsOnCall map[int]struct { 271 result1 error 272 } 273 SubscribeStub func(config.Committer) config.Configuration 274 subscribeMutex sync.RWMutex 275 subscribeArgsForCall []struct { 276 arg1 config.Committer 277 } 278 subscribeReturns struct { 279 result1 config.Configuration 280 } 281 subscribeReturnsOnCall map[int]struct { 282 result1 config.Configuration 283 } 284 UnsubscribeStub func(config.Committer) 285 unsubscribeMutex sync.RWMutex 286 unsubscribeArgsForCall []struct { 287 arg1 config.Committer 288 } 289 invocations map[string][][]interface{} 290 invocationsMutex sync.RWMutex 291} 292 293func (fake *Wrapper) ConfigPath() string { 294 fake.configPathMutex.Lock() 295 ret, specificReturn := fake.configPathReturnsOnCall[len(fake.configPathArgsForCall)] 296 fake.configPathArgsForCall = append(fake.configPathArgsForCall, struct { 297 }{}) 298 stub := fake.ConfigPathStub 299 fakeReturns := fake.configPathReturns 300 fake.recordInvocation("ConfigPath", []interface{}{}) 301 fake.configPathMutex.Unlock() 302 if stub != nil { 303 return stub() 304 } 305 if specificReturn { 306 return ret.result1 307 } 308 return fakeReturns.result1 309} 310 311func (fake *Wrapper) ConfigPathCallCount() int { 312 fake.configPathMutex.RLock() 313 defer fake.configPathMutex.RUnlock() 314 return len(fake.configPathArgsForCall) 315} 316 317func (fake *Wrapper) ConfigPathCalls(stub func() string) { 318 fake.configPathMutex.Lock() 319 defer fake.configPathMutex.Unlock() 320 fake.ConfigPathStub = stub 321} 322 323func (fake *Wrapper) ConfigPathReturns(result1 string) { 324 fake.configPathMutex.Lock() 325 defer fake.configPathMutex.Unlock() 326 fake.ConfigPathStub = nil 327 fake.configPathReturns = struct { 328 result1 string 329 }{result1} 330} 331 332func (fake *Wrapper) ConfigPathReturnsOnCall(i int, result1 string) { 333 fake.configPathMutex.Lock() 334 defer fake.configPathMutex.Unlock() 335 fake.ConfigPathStub = nil 336 if fake.configPathReturnsOnCall == nil { 337 fake.configPathReturnsOnCall = make(map[int]struct { 338 result1 string 339 }) 340 } 341 fake.configPathReturnsOnCall[i] = struct { 342 result1 string 343 }{result1} 344} 345 346func (fake *Wrapper) DefaultDevice() config.DeviceConfiguration { 347 fake.defaultDeviceMutex.Lock() 348 ret, specificReturn := fake.defaultDeviceReturnsOnCall[len(fake.defaultDeviceArgsForCall)] 349 fake.defaultDeviceArgsForCall = append(fake.defaultDeviceArgsForCall, struct { 350 }{}) 351 stub := fake.DefaultDeviceStub 352 fakeReturns := fake.defaultDeviceReturns 353 fake.recordInvocation("DefaultDevice", []interface{}{}) 354 fake.defaultDeviceMutex.Unlock() 355 if stub != nil { 356 return stub() 357 } 358 if specificReturn { 359 return ret.result1 360 } 361 return fakeReturns.result1 362} 363 364func (fake *Wrapper) DefaultDeviceCallCount() int { 365 fake.defaultDeviceMutex.RLock() 366 defer fake.defaultDeviceMutex.RUnlock() 367 return len(fake.defaultDeviceArgsForCall) 368} 369 370func (fake *Wrapper) DefaultDeviceCalls(stub func() config.DeviceConfiguration) { 371 fake.defaultDeviceMutex.Lock() 372 defer fake.defaultDeviceMutex.Unlock() 373 fake.DefaultDeviceStub = stub 374} 375 376func (fake *Wrapper) DefaultDeviceReturns(result1 config.DeviceConfiguration) { 377 fake.defaultDeviceMutex.Lock() 378 defer fake.defaultDeviceMutex.Unlock() 379 fake.DefaultDeviceStub = nil 380 fake.defaultDeviceReturns = struct { 381 result1 config.DeviceConfiguration 382 }{result1} 383} 384 385func (fake *Wrapper) DefaultDeviceReturnsOnCall(i int, result1 config.DeviceConfiguration) { 386 fake.defaultDeviceMutex.Lock() 387 defer fake.defaultDeviceMutex.Unlock() 388 fake.DefaultDeviceStub = nil 389 if fake.defaultDeviceReturnsOnCall == nil { 390 fake.defaultDeviceReturnsOnCall = make(map[int]struct { 391 result1 config.DeviceConfiguration 392 }) 393 } 394 fake.defaultDeviceReturnsOnCall[i] = struct { 395 result1 config.DeviceConfiguration 396 }{result1} 397} 398 399func (fake *Wrapper) DefaultFolder() config.FolderConfiguration { 400 fake.defaultFolderMutex.Lock() 401 ret, specificReturn := fake.defaultFolderReturnsOnCall[len(fake.defaultFolderArgsForCall)] 402 fake.defaultFolderArgsForCall = append(fake.defaultFolderArgsForCall, struct { 403 }{}) 404 stub := fake.DefaultFolderStub 405 fakeReturns := fake.defaultFolderReturns 406 fake.recordInvocation("DefaultFolder", []interface{}{}) 407 fake.defaultFolderMutex.Unlock() 408 if stub != nil { 409 return stub() 410 } 411 if specificReturn { 412 return ret.result1 413 } 414 return fakeReturns.result1 415} 416 417func (fake *Wrapper) DefaultFolderCallCount() int { 418 fake.defaultFolderMutex.RLock() 419 defer fake.defaultFolderMutex.RUnlock() 420 return len(fake.defaultFolderArgsForCall) 421} 422 423func (fake *Wrapper) DefaultFolderCalls(stub func() config.FolderConfiguration) { 424 fake.defaultFolderMutex.Lock() 425 defer fake.defaultFolderMutex.Unlock() 426 fake.DefaultFolderStub = stub 427} 428 429func (fake *Wrapper) DefaultFolderReturns(result1 config.FolderConfiguration) { 430 fake.defaultFolderMutex.Lock() 431 defer fake.defaultFolderMutex.Unlock() 432 fake.DefaultFolderStub = nil 433 fake.defaultFolderReturns = struct { 434 result1 config.FolderConfiguration 435 }{result1} 436} 437 438func (fake *Wrapper) DefaultFolderReturnsOnCall(i int, result1 config.FolderConfiguration) { 439 fake.defaultFolderMutex.Lock() 440 defer fake.defaultFolderMutex.Unlock() 441 fake.DefaultFolderStub = nil 442 if fake.defaultFolderReturnsOnCall == nil { 443 fake.defaultFolderReturnsOnCall = make(map[int]struct { 444 result1 config.FolderConfiguration 445 }) 446 } 447 fake.defaultFolderReturnsOnCall[i] = struct { 448 result1 config.FolderConfiguration 449 }{result1} 450} 451 452func (fake *Wrapper) Device(arg1 protocol.DeviceID) (config.DeviceConfiguration, bool) { 453 fake.deviceMutex.Lock() 454 ret, specificReturn := fake.deviceReturnsOnCall[len(fake.deviceArgsForCall)] 455 fake.deviceArgsForCall = append(fake.deviceArgsForCall, struct { 456 arg1 protocol.DeviceID 457 }{arg1}) 458 stub := fake.DeviceStub 459 fakeReturns := fake.deviceReturns 460 fake.recordInvocation("Device", []interface{}{arg1}) 461 fake.deviceMutex.Unlock() 462 if stub != nil { 463 return stub(arg1) 464 } 465 if specificReturn { 466 return ret.result1, ret.result2 467 } 468 return fakeReturns.result1, fakeReturns.result2 469} 470 471func (fake *Wrapper) DeviceCallCount() int { 472 fake.deviceMutex.RLock() 473 defer fake.deviceMutex.RUnlock() 474 return len(fake.deviceArgsForCall) 475} 476 477func (fake *Wrapper) DeviceCalls(stub func(protocol.DeviceID) (config.DeviceConfiguration, bool)) { 478 fake.deviceMutex.Lock() 479 defer fake.deviceMutex.Unlock() 480 fake.DeviceStub = stub 481} 482 483func (fake *Wrapper) DeviceArgsForCall(i int) protocol.DeviceID { 484 fake.deviceMutex.RLock() 485 defer fake.deviceMutex.RUnlock() 486 argsForCall := fake.deviceArgsForCall[i] 487 return argsForCall.arg1 488} 489 490func (fake *Wrapper) DeviceReturns(result1 config.DeviceConfiguration, result2 bool) { 491 fake.deviceMutex.Lock() 492 defer fake.deviceMutex.Unlock() 493 fake.DeviceStub = nil 494 fake.deviceReturns = struct { 495 result1 config.DeviceConfiguration 496 result2 bool 497 }{result1, result2} 498} 499 500func (fake *Wrapper) DeviceReturnsOnCall(i int, result1 config.DeviceConfiguration, result2 bool) { 501 fake.deviceMutex.Lock() 502 defer fake.deviceMutex.Unlock() 503 fake.DeviceStub = nil 504 if fake.deviceReturnsOnCall == nil { 505 fake.deviceReturnsOnCall = make(map[int]struct { 506 result1 config.DeviceConfiguration 507 result2 bool 508 }) 509 } 510 fake.deviceReturnsOnCall[i] = struct { 511 result1 config.DeviceConfiguration 512 result2 bool 513 }{result1, result2} 514} 515 516func (fake *Wrapper) DeviceList() []config.DeviceConfiguration { 517 fake.deviceListMutex.Lock() 518 ret, specificReturn := fake.deviceListReturnsOnCall[len(fake.deviceListArgsForCall)] 519 fake.deviceListArgsForCall = append(fake.deviceListArgsForCall, struct { 520 }{}) 521 stub := fake.DeviceListStub 522 fakeReturns := fake.deviceListReturns 523 fake.recordInvocation("DeviceList", []interface{}{}) 524 fake.deviceListMutex.Unlock() 525 if stub != nil { 526 return stub() 527 } 528 if specificReturn { 529 return ret.result1 530 } 531 return fakeReturns.result1 532} 533 534func (fake *Wrapper) DeviceListCallCount() int { 535 fake.deviceListMutex.RLock() 536 defer fake.deviceListMutex.RUnlock() 537 return len(fake.deviceListArgsForCall) 538} 539 540func (fake *Wrapper) DeviceListCalls(stub func() []config.DeviceConfiguration) { 541 fake.deviceListMutex.Lock() 542 defer fake.deviceListMutex.Unlock() 543 fake.DeviceListStub = stub 544} 545 546func (fake *Wrapper) DeviceListReturns(result1 []config.DeviceConfiguration) { 547 fake.deviceListMutex.Lock() 548 defer fake.deviceListMutex.Unlock() 549 fake.DeviceListStub = nil 550 fake.deviceListReturns = struct { 551 result1 []config.DeviceConfiguration 552 }{result1} 553} 554 555func (fake *Wrapper) DeviceListReturnsOnCall(i int, result1 []config.DeviceConfiguration) { 556 fake.deviceListMutex.Lock() 557 defer fake.deviceListMutex.Unlock() 558 fake.DeviceListStub = nil 559 if fake.deviceListReturnsOnCall == nil { 560 fake.deviceListReturnsOnCall = make(map[int]struct { 561 result1 []config.DeviceConfiguration 562 }) 563 } 564 fake.deviceListReturnsOnCall[i] = struct { 565 result1 []config.DeviceConfiguration 566 }{result1} 567} 568 569func (fake *Wrapper) Devices() map[protocol.DeviceID]config.DeviceConfiguration { 570 fake.devicesMutex.Lock() 571 ret, specificReturn := fake.devicesReturnsOnCall[len(fake.devicesArgsForCall)] 572 fake.devicesArgsForCall = append(fake.devicesArgsForCall, struct { 573 }{}) 574 stub := fake.DevicesStub 575 fakeReturns := fake.devicesReturns 576 fake.recordInvocation("Devices", []interface{}{}) 577 fake.devicesMutex.Unlock() 578 if stub != nil { 579 return stub() 580 } 581 if specificReturn { 582 return ret.result1 583 } 584 return fakeReturns.result1 585} 586 587func (fake *Wrapper) DevicesCallCount() int { 588 fake.devicesMutex.RLock() 589 defer fake.devicesMutex.RUnlock() 590 return len(fake.devicesArgsForCall) 591} 592 593func (fake *Wrapper) DevicesCalls(stub func() map[protocol.DeviceID]config.DeviceConfiguration) { 594 fake.devicesMutex.Lock() 595 defer fake.devicesMutex.Unlock() 596 fake.DevicesStub = stub 597} 598 599func (fake *Wrapper) DevicesReturns(result1 map[protocol.DeviceID]config.DeviceConfiguration) { 600 fake.devicesMutex.Lock() 601 defer fake.devicesMutex.Unlock() 602 fake.DevicesStub = nil 603 fake.devicesReturns = struct { 604 result1 map[protocol.DeviceID]config.DeviceConfiguration 605 }{result1} 606} 607 608func (fake *Wrapper) DevicesReturnsOnCall(i int, result1 map[protocol.DeviceID]config.DeviceConfiguration) { 609 fake.devicesMutex.Lock() 610 defer fake.devicesMutex.Unlock() 611 fake.DevicesStub = nil 612 if fake.devicesReturnsOnCall == nil { 613 fake.devicesReturnsOnCall = make(map[int]struct { 614 result1 map[protocol.DeviceID]config.DeviceConfiguration 615 }) 616 } 617 fake.devicesReturnsOnCall[i] = struct { 618 result1 map[protocol.DeviceID]config.DeviceConfiguration 619 }{result1} 620} 621 622func (fake *Wrapper) Folder(arg1 string) (config.FolderConfiguration, bool) { 623 fake.folderMutex.Lock() 624 ret, specificReturn := fake.folderReturnsOnCall[len(fake.folderArgsForCall)] 625 fake.folderArgsForCall = append(fake.folderArgsForCall, struct { 626 arg1 string 627 }{arg1}) 628 stub := fake.FolderStub 629 fakeReturns := fake.folderReturns 630 fake.recordInvocation("Folder", []interface{}{arg1}) 631 fake.folderMutex.Unlock() 632 if stub != nil { 633 return stub(arg1) 634 } 635 if specificReturn { 636 return ret.result1, ret.result2 637 } 638 return fakeReturns.result1, fakeReturns.result2 639} 640 641func (fake *Wrapper) FolderCallCount() int { 642 fake.folderMutex.RLock() 643 defer fake.folderMutex.RUnlock() 644 return len(fake.folderArgsForCall) 645} 646 647func (fake *Wrapper) FolderCalls(stub func(string) (config.FolderConfiguration, bool)) { 648 fake.folderMutex.Lock() 649 defer fake.folderMutex.Unlock() 650 fake.FolderStub = stub 651} 652 653func (fake *Wrapper) FolderArgsForCall(i int) string { 654 fake.folderMutex.RLock() 655 defer fake.folderMutex.RUnlock() 656 argsForCall := fake.folderArgsForCall[i] 657 return argsForCall.arg1 658} 659 660func (fake *Wrapper) FolderReturns(result1 config.FolderConfiguration, result2 bool) { 661 fake.folderMutex.Lock() 662 defer fake.folderMutex.Unlock() 663 fake.FolderStub = nil 664 fake.folderReturns = struct { 665 result1 config.FolderConfiguration 666 result2 bool 667 }{result1, result2} 668} 669 670func (fake *Wrapper) FolderReturnsOnCall(i int, result1 config.FolderConfiguration, result2 bool) { 671 fake.folderMutex.Lock() 672 defer fake.folderMutex.Unlock() 673 fake.FolderStub = nil 674 if fake.folderReturnsOnCall == nil { 675 fake.folderReturnsOnCall = make(map[int]struct { 676 result1 config.FolderConfiguration 677 result2 bool 678 }) 679 } 680 fake.folderReturnsOnCall[i] = struct { 681 result1 config.FolderConfiguration 682 result2 bool 683 }{result1, result2} 684} 685 686func (fake *Wrapper) FolderList() []config.FolderConfiguration { 687 fake.folderListMutex.Lock() 688 ret, specificReturn := fake.folderListReturnsOnCall[len(fake.folderListArgsForCall)] 689 fake.folderListArgsForCall = append(fake.folderListArgsForCall, struct { 690 }{}) 691 stub := fake.FolderListStub 692 fakeReturns := fake.folderListReturns 693 fake.recordInvocation("FolderList", []interface{}{}) 694 fake.folderListMutex.Unlock() 695 if stub != nil { 696 return stub() 697 } 698 if specificReturn { 699 return ret.result1 700 } 701 return fakeReturns.result1 702} 703 704func (fake *Wrapper) FolderListCallCount() int { 705 fake.folderListMutex.RLock() 706 defer fake.folderListMutex.RUnlock() 707 return len(fake.folderListArgsForCall) 708} 709 710func (fake *Wrapper) FolderListCalls(stub func() []config.FolderConfiguration) { 711 fake.folderListMutex.Lock() 712 defer fake.folderListMutex.Unlock() 713 fake.FolderListStub = stub 714} 715 716func (fake *Wrapper) FolderListReturns(result1 []config.FolderConfiguration) { 717 fake.folderListMutex.Lock() 718 defer fake.folderListMutex.Unlock() 719 fake.FolderListStub = nil 720 fake.folderListReturns = struct { 721 result1 []config.FolderConfiguration 722 }{result1} 723} 724 725func (fake *Wrapper) FolderListReturnsOnCall(i int, result1 []config.FolderConfiguration) { 726 fake.folderListMutex.Lock() 727 defer fake.folderListMutex.Unlock() 728 fake.FolderListStub = nil 729 if fake.folderListReturnsOnCall == nil { 730 fake.folderListReturnsOnCall = make(map[int]struct { 731 result1 []config.FolderConfiguration 732 }) 733 } 734 fake.folderListReturnsOnCall[i] = struct { 735 result1 []config.FolderConfiguration 736 }{result1} 737} 738 739func (fake *Wrapper) FolderPasswords(arg1 protocol.DeviceID) map[string]string { 740 fake.folderPasswordsMutex.Lock() 741 ret, specificReturn := fake.folderPasswordsReturnsOnCall[len(fake.folderPasswordsArgsForCall)] 742 fake.folderPasswordsArgsForCall = append(fake.folderPasswordsArgsForCall, struct { 743 arg1 protocol.DeviceID 744 }{arg1}) 745 stub := fake.FolderPasswordsStub 746 fakeReturns := fake.folderPasswordsReturns 747 fake.recordInvocation("FolderPasswords", []interface{}{arg1}) 748 fake.folderPasswordsMutex.Unlock() 749 if stub != nil { 750 return stub(arg1) 751 } 752 if specificReturn { 753 return ret.result1 754 } 755 return fakeReturns.result1 756} 757 758func (fake *Wrapper) FolderPasswordsCallCount() int { 759 fake.folderPasswordsMutex.RLock() 760 defer fake.folderPasswordsMutex.RUnlock() 761 return len(fake.folderPasswordsArgsForCall) 762} 763 764func (fake *Wrapper) FolderPasswordsCalls(stub func(protocol.DeviceID) map[string]string) { 765 fake.folderPasswordsMutex.Lock() 766 defer fake.folderPasswordsMutex.Unlock() 767 fake.FolderPasswordsStub = stub 768} 769 770func (fake *Wrapper) FolderPasswordsArgsForCall(i int) protocol.DeviceID { 771 fake.folderPasswordsMutex.RLock() 772 defer fake.folderPasswordsMutex.RUnlock() 773 argsForCall := fake.folderPasswordsArgsForCall[i] 774 return argsForCall.arg1 775} 776 777func (fake *Wrapper) FolderPasswordsReturns(result1 map[string]string) { 778 fake.folderPasswordsMutex.Lock() 779 defer fake.folderPasswordsMutex.Unlock() 780 fake.FolderPasswordsStub = nil 781 fake.folderPasswordsReturns = struct { 782 result1 map[string]string 783 }{result1} 784} 785 786func (fake *Wrapper) FolderPasswordsReturnsOnCall(i int, result1 map[string]string) { 787 fake.folderPasswordsMutex.Lock() 788 defer fake.folderPasswordsMutex.Unlock() 789 fake.FolderPasswordsStub = nil 790 if fake.folderPasswordsReturnsOnCall == nil { 791 fake.folderPasswordsReturnsOnCall = make(map[int]struct { 792 result1 map[string]string 793 }) 794 } 795 fake.folderPasswordsReturnsOnCall[i] = struct { 796 result1 map[string]string 797 }{result1} 798} 799 800func (fake *Wrapper) Folders() map[string]config.FolderConfiguration { 801 fake.foldersMutex.Lock() 802 ret, specificReturn := fake.foldersReturnsOnCall[len(fake.foldersArgsForCall)] 803 fake.foldersArgsForCall = append(fake.foldersArgsForCall, struct { 804 }{}) 805 stub := fake.FoldersStub 806 fakeReturns := fake.foldersReturns 807 fake.recordInvocation("Folders", []interface{}{}) 808 fake.foldersMutex.Unlock() 809 if stub != nil { 810 return stub() 811 } 812 if specificReturn { 813 return ret.result1 814 } 815 return fakeReturns.result1 816} 817 818func (fake *Wrapper) FoldersCallCount() int { 819 fake.foldersMutex.RLock() 820 defer fake.foldersMutex.RUnlock() 821 return len(fake.foldersArgsForCall) 822} 823 824func (fake *Wrapper) FoldersCalls(stub func() map[string]config.FolderConfiguration) { 825 fake.foldersMutex.Lock() 826 defer fake.foldersMutex.Unlock() 827 fake.FoldersStub = stub 828} 829 830func (fake *Wrapper) FoldersReturns(result1 map[string]config.FolderConfiguration) { 831 fake.foldersMutex.Lock() 832 defer fake.foldersMutex.Unlock() 833 fake.FoldersStub = nil 834 fake.foldersReturns = struct { 835 result1 map[string]config.FolderConfiguration 836 }{result1} 837} 838 839func (fake *Wrapper) FoldersReturnsOnCall(i int, result1 map[string]config.FolderConfiguration) { 840 fake.foldersMutex.Lock() 841 defer fake.foldersMutex.Unlock() 842 fake.FoldersStub = nil 843 if fake.foldersReturnsOnCall == nil { 844 fake.foldersReturnsOnCall = make(map[int]struct { 845 result1 map[string]config.FolderConfiguration 846 }) 847 } 848 fake.foldersReturnsOnCall[i] = struct { 849 result1 map[string]config.FolderConfiguration 850 }{result1} 851} 852 853func (fake *Wrapper) GUI() config.GUIConfiguration { 854 fake.gUIMutex.Lock() 855 ret, specificReturn := fake.gUIReturnsOnCall[len(fake.gUIArgsForCall)] 856 fake.gUIArgsForCall = append(fake.gUIArgsForCall, struct { 857 }{}) 858 stub := fake.GUIStub 859 fakeReturns := fake.gUIReturns 860 fake.recordInvocation("GUI", []interface{}{}) 861 fake.gUIMutex.Unlock() 862 if stub != nil { 863 return stub() 864 } 865 if specificReturn { 866 return ret.result1 867 } 868 return fakeReturns.result1 869} 870 871func (fake *Wrapper) GUICallCount() int { 872 fake.gUIMutex.RLock() 873 defer fake.gUIMutex.RUnlock() 874 return len(fake.gUIArgsForCall) 875} 876 877func (fake *Wrapper) GUICalls(stub func() config.GUIConfiguration) { 878 fake.gUIMutex.Lock() 879 defer fake.gUIMutex.Unlock() 880 fake.GUIStub = stub 881} 882 883func (fake *Wrapper) GUIReturns(result1 config.GUIConfiguration) { 884 fake.gUIMutex.Lock() 885 defer fake.gUIMutex.Unlock() 886 fake.GUIStub = nil 887 fake.gUIReturns = struct { 888 result1 config.GUIConfiguration 889 }{result1} 890} 891 892func (fake *Wrapper) GUIReturnsOnCall(i int, result1 config.GUIConfiguration) { 893 fake.gUIMutex.Lock() 894 defer fake.gUIMutex.Unlock() 895 fake.GUIStub = nil 896 if fake.gUIReturnsOnCall == nil { 897 fake.gUIReturnsOnCall = make(map[int]struct { 898 result1 config.GUIConfiguration 899 }) 900 } 901 fake.gUIReturnsOnCall[i] = struct { 902 result1 config.GUIConfiguration 903 }{result1} 904} 905 906func (fake *Wrapper) IgnoredDevice(arg1 protocol.DeviceID) bool { 907 fake.ignoredDeviceMutex.Lock() 908 ret, specificReturn := fake.ignoredDeviceReturnsOnCall[len(fake.ignoredDeviceArgsForCall)] 909 fake.ignoredDeviceArgsForCall = append(fake.ignoredDeviceArgsForCall, struct { 910 arg1 protocol.DeviceID 911 }{arg1}) 912 stub := fake.IgnoredDeviceStub 913 fakeReturns := fake.ignoredDeviceReturns 914 fake.recordInvocation("IgnoredDevice", []interface{}{arg1}) 915 fake.ignoredDeviceMutex.Unlock() 916 if stub != nil { 917 return stub(arg1) 918 } 919 if specificReturn { 920 return ret.result1 921 } 922 return fakeReturns.result1 923} 924 925func (fake *Wrapper) IgnoredDeviceCallCount() int { 926 fake.ignoredDeviceMutex.RLock() 927 defer fake.ignoredDeviceMutex.RUnlock() 928 return len(fake.ignoredDeviceArgsForCall) 929} 930 931func (fake *Wrapper) IgnoredDeviceCalls(stub func(protocol.DeviceID) bool) { 932 fake.ignoredDeviceMutex.Lock() 933 defer fake.ignoredDeviceMutex.Unlock() 934 fake.IgnoredDeviceStub = stub 935} 936 937func (fake *Wrapper) IgnoredDeviceArgsForCall(i int) protocol.DeviceID { 938 fake.ignoredDeviceMutex.RLock() 939 defer fake.ignoredDeviceMutex.RUnlock() 940 argsForCall := fake.ignoredDeviceArgsForCall[i] 941 return argsForCall.arg1 942} 943 944func (fake *Wrapper) IgnoredDeviceReturns(result1 bool) { 945 fake.ignoredDeviceMutex.Lock() 946 defer fake.ignoredDeviceMutex.Unlock() 947 fake.IgnoredDeviceStub = nil 948 fake.ignoredDeviceReturns = struct { 949 result1 bool 950 }{result1} 951} 952 953func (fake *Wrapper) IgnoredDeviceReturnsOnCall(i int, result1 bool) { 954 fake.ignoredDeviceMutex.Lock() 955 defer fake.ignoredDeviceMutex.Unlock() 956 fake.IgnoredDeviceStub = nil 957 if fake.ignoredDeviceReturnsOnCall == nil { 958 fake.ignoredDeviceReturnsOnCall = make(map[int]struct { 959 result1 bool 960 }) 961 } 962 fake.ignoredDeviceReturnsOnCall[i] = struct { 963 result1 bool 964 }{result1} 965} 966 967func (fake *Wrapper) IgnoredDevices() []config.ObservedDevice { 968 fake.ignoredDevicesMutex.Lock() 969 ret, specificReturn := fake.ignoredDevicesReturnsOnCall[len(fake.ignoredDevicesArgsForCall)] 970 fake.ignoredDevicesArgsForCall = append(fake.ignoredDevicesArgsForCall, struct { 971 }{}) 972 stub := fake.IgnoredDevicesStub 973 fakeReturns := fake.ignoredDevicesReturns 974 fake.recordInvocation("IgnoredDevices", []interface{}{}) 975 fake.ignoredDevicesMutex.Unlock() 976 if stub != nil { 977 return stub() 978 } 979 if specificReturn { 980 return ret.result1 981 } 982 return fakeReturns.result1 983} 984 985func (fake *Wrapper) IgnoredDevicesCallCount() int { 986 fake.ignoredDevicesMutex.RLock() 987 defer fake.ignoredDevicesMutex.RUnlock() 988 return len(fake.ignoredDevicesArgsForCall) 989} 990 991func (fake *Wrapper) IgnoredDevicesCalls(stub func() []config.ObservedDevice) { 992 fake.ignoredDevicesMutex.Lock() 993 defer fake.ignoredDevicesMutex.Unlock() 994 fake.IgnoredDevicesStub = stub 995} 996 997func (fake *Wrapper) IgnoredDevicesReturns(result1 []config.ObservedDevice) { 998 fake.ignoredDevicesMutex.Lock() 999 defer fake.ignoredDevicesMutex.Unlock() 1000 fake.IgnoredDevicesStub = nil 1001 fake.ignoredDevicesReturns = struct { 1002 result1 []config.ObservedDevice 1003 }{result1} 1004} 1005 1006func (fake *Wrapper) IgnoredDevicesReturnsOnCall(i int, result1 []config.ObservedDevice) { 1007 fake.ignoredDevicesMutex.Lock() 1008 defer fake.ignoredDevicesMutex.Unlock() 1009 fake.IgnoredDevicesStub = nil 1010 if fake.ignoredDevicesReturnsOnCall == nil { 1011 fake.ignoredDevicesReturnsOnCall = make(map[int]struct { 1012 result1 []config.ObservedDevice 1013 }) 1014 } 1015 fake.ignoredDevicesReturnsOnCall[i] = struct { 1016 result1 []config.ObservedDevice 1017 }{result1} 1018} 1019 1020func (fake *Wrapper) IgnoredFolder(arg1 protocol.DeviceID, arg2 string) bool { 1021 fake.ignoredFolderMutex.Lock() 1022 ret, specificReturn := fake.ignoredFolderReturnsOnCall[len(fake.ignoredFolderArgsForCall)] 1023 fake.ignoredFolderArgsForCall = append(fake.ignoredFolderArgsForCall, struct { 1024 arg1 protocol.DeviceID 1025 arg2 string 1026 }{arg1, arg2}) 1027 stub := fake.IgnoredFolderStub 1028 fakeReturns := fake.ignoredFolderReturns 1029 fake.recordInvocation("IgnoredFolder", []interface{}{arg1, arg2}) 1030 fake.ignoredFolderMutex.Unlock() 1031 if stub != nil { 1032 return stub(arg1, arg2) 1033 } 1034 if specificReturn { 1035 return ret.result1 1036 } 1037 return fakeReturns.result1 1038} 1039 1040func (fake *Wrapper) IgnoredFolderCallCount() int { 1041 fake.ignoredFolderMutex.RLock() 1042 defer fake.ignoredFolderMutex.RUnlock() 1043 return len(fake.ignoredFolderArgsForCall) 1044} 1045 1046func (fake *Wrapper) IgnoredFolderCalls(stub func(protocol.DeviceID, string) bool) { 1047 fake.ignoredFolderMutex.Lock() 1048 defer fake.ignoredFolderMutex.Unlock() 1049 fake.IgnoredFolderStub = stub 1050} 1051 1052func (fake *Wrapper) IgnoredFolderArgsForCall(i int) (protocol.DeviceID, string) { 1053 fake.ignoredFolderMutex.RLock() 1054 defer fake.ignoredFolderMutex.RUnlock() 1055 argsForCall := fake.ignoredFolderArgsForCall[i] 1056 return argsForCall.arg1, argsForCall.arg2 1057} 1058 1059func (fake *Wrapper) IgnoredFolderReturns(result1 bool) { 1060 fake.ignoredFolderMutex.Lock() 1061 defer fake.ignoredFolderMutex.Unlock() 1062 fake.IgnoredFolderStub = nil 1063 fake.ignoredFolderReturns = struct { 1064 result1 bool 1065 }{result1} 1066} 1067 1068func (fake *Wrapper) IgnoredFolderReturnsOnCall(i int, result1 bool) { 1069 fake.ignoredFolderMutex.Lock() 1070 defer fake.ignoredFolderMutex.Unlock() 1071 fake.IgnoredFolderStub = nil 1072 if fake.ignoredFolderReturnsOnCall == nil { 1073 fake.ignoredFolderReturnsOnCall = make(map[int]struct { 1074 result1 bool 1075 }) 1076 } 1077 fake.ignoredFolderReturnsOnCall[i] = struct { 1078 result1 bool 1079 }{result1} 1080} 1081 1082func (fake *Wrapper) LDAP() config.LDAPConfiguration { 1083 fake.lDAPMutex.Lock() 1084 ret, specificReturn := fake.lDAPReturnsOnCall[len(fake.lDAPArgsForCall)] 1085 fake.lDAPArgsForCall = append(fake.lDAPArgsForCall, struct { 1086 }{}) 1087 stub := fake.LDAPStub 1088 fakeReturns := fake.lDAPReturns 1089 fake.recordInvocation("LDAP", []interface{}{}) 1090 fake.lDAPMutex.Unlock() 1091 if stub != nil { 1092 return stub() 1093 } 1094 if specificReturn { 1095 return ret.result1 1096 } 1097 return fakeReturns.result1 1098} 1099 1100func (fake *Wrapper) LDAPCallCount() int { 1101 fake.lDAPMutex.RLock() 1102 defer fake.lDAPMutex.RUnlock() 1103 return len(fake.lDAPArgsForCall) 1104} 1105 1106func (fake *Wrapper) LDAPCalls(stub func() config.LDAPConfiguration) { 1107 fake.lDAPMutex.Lock() 1108 defer fake.lDAPMutex.Unlock() 1109 fake.LDAPStub = stub 1110} 1111 1112func (fake *Wrapper) LDAPReturns(result1 config.LDAPConfiguration) { 1113 fake.lDAPMutex.Lock() 1114 defer fake.lDAPMutex.Unlock() 1115 fake.LDAPStub = nil 1116 fake.lDAPReturns = struct { 1117 result1 config.LDAPConfiguration 1118 }{result1} 1119} 1120 1121func (fake *Wrapper) LDAPReturnsOnCall(i int, result1 config.LDAPConfiguration) { 1122 fake.lDAPMutex.Lock() 1123 defer fake.lDAPMutex.Unlock() 1124 fake.LDAPStub = nil 1125 if fake.lDAPReturnsOnCall == nil { 1126 fake.lDAPReturnsOnCall = make(map[int]struct { 1127 result1 config.LDAPConfiguration 1128 }) 1129 } 1130 fake.lDAPReturnsOnCall[i] = struct { 1131 result1 config.LDAPConfiguration 1132 }{result1} 1133} 1134 1135func (fake *Wrapper) Modify(arg1 config.ModifyFunction) (config.Waiter, error) { 1136 fake.modifyMutex.Lock() 1137 ret, specificReturn := fake.modifyReturnsOnCall[len(fake.modifyArgsForCall)] 1138 fake.modifyArgsForCall = append(fake.modifyArgsForCall, struct { 1139 arg1 config.ModifyFunction 1140 }{arg1}) 1141 stub := fake.ModifyStub 1142 fakeReturns := fake.modifyReturns 1143 fake.recordInvocation("Modify", []interface{}{arg1}) 1144 fake.modifyMutex.Unlock() 1145 if stub != nil { 1146 return stub(arg1) 1147 } 1148 if specificReturn { 1149 return ret.result1, ret.result2 1150 } 1151 return fakeReturns.result1, fakeReturns.result2 1152} 1153 1154func (fake *Wrapper) ModifyCallCount() int { 1155 fake.modifyMutex.RLock() 1156 defer fake.modifyMutex.RUnlock() 1157 return len(fake.modifyArgsForCall) 1158} 1159 1160func (fake *Wrapper) ModifyCalls(stub func(config.ModifyFunction) (config.Waiter, error)) { 1161 fake.modifyMutex.Lock() 1162 defer fake.modifyMutex.Unlock() 1163 fake.ModifyStub = stub 1164} 1165 1166func (fake *Wrapper) ModifyArgsForCall(i int) config.ModifyFunction { 1167 fake.modifyMutex.RLock() 1168 defer fake.modifyMutex.RUnlock() 1169 argsForCall := fake.modifyArgsForCall[i] 1170 return argsForCall.arg1 1171} 1172 1173func (fake *Wrapper) ModifyReturns(result1 config.Waiter, result2 error) { 1174 fake.modifyMutex.Lock() 1175 defer fake.modifyMutex.Unlock() 1176 fake.ModifyStub = nil 1177 fake.modifyReturns = struct { 1178 result1 config.Waiter 1179 result2 error 1180 }{result1, result2} 1181} 1182 1183func (fake *Wrapper) ModifyReturnsOnCall(i int, result1 config.Waiter, result2 error) { 1184 fake.modifyMutex.Lock() 1185 defer fake.modifyMutex.Unlock() 1186 fake.ModifyStub = nil 1187 if fake.modifyReturnsOnCall == nil { 1188 fake.modifyReturnsOnCall = make(map[int]struct { 1189 result1 config.Waiter 1190 result2 error 1191 }) 1192 } 1193 fake.modifyReturnsOnCall[i] = struct { 1194 result1 config.Waiter 1195 result2 error 1196 }{result1, result2} 1197} 1198 1199func (fake *Wrapper) MyID() protocol.DeviceID { 1200 fake.myIDMutex.Lock() 1201 ret, specificReturn := fake.myIDReturnsOnCall[len(fake.myIDArgsForCall)] 1202 fake.myIDArgsForCall = append(fake.myIDArgsForCall, struct { 1203 }{}) 1204 stub := fake.MyIDStub 1205 fakeReturns := fake.myIDReturns 1206 fake.recordInvocation("MyID", []interface{}{}) 1207 fake.myIDMutex.Unlock() 1208 if stub != nil { 1209 return stub() 1210 } 1211 if specificReturn { 1212 return ret.result1 1213 } 1214 return fakeReturns.result1 1215} 1216 1217func (fake *Wrapper) MyIDCallCount() int { 1218 fake.myIDMutex.RLock() 1219 defer fake.myIDMutex.RUnlock() 1220 return len(fake.myIDArgsForCall) 1221} 1222 1223func (fake *Wrapper) MyIDCalls(stub func() protocol.DeviceID) { 1224 fake.myIDMutex.Lock() 1225 defer fake.myIDMutex.Unlock() 1226 fake.MyIDStub = stub 1227} 1228 1229func (fake *Wrapper) MyIDReturns(result1 protocol.DeviceID) { 1230 fake.myIDMutex.Lock() 1231 defer fake.myIDMutex.Unlock() 1232 fake.MyIDStub = nil 1233 fake.myIDReturns = struct { 1234 result1 protocol.DeviceID 1235 }{result1} 1236} 1237 1238func (fake *Wrapper) MyIDReturnsOnCall(i int, result1 protocol.DeviceID) { 1239 fake.myIDMutex.Lock() 1240 defer fake.myIDMutex.Unlock() 1241 fake.MyIDStub = nil 1242 if fake.myIDReturnsOnCall == nil { 1243 fake.myIDReturnsOnCall = make(map[int]struct { 1244 result1 protocol.DeviceID 1245 }) 1246 } 1247 fake.myIDReturnsOnCall[i] = struct { 1248 result1 protocol.DeviceID 1249 }{result1} 1250} 1251 1252func (fake *Wrapper) Options() config.OptionsConfiguration { 1253 fake.optionsMutex.Lock() 1254 ret, specificReturn := fake.optionsReturnsOnCall[len(fake.optionsArgsForCall)] 1255 fake.optionsArgsForCall = append(fake.optionsArgsForCall, struct { 1256 }{}) 1257 stub := fake.OptionsStub 1258 fakeReturns := fake.optionsReturns 1259 fake.recordInvocation("Options", []interface{}{}) 1260 fake.optionsMutex.Unlock() 1261 if stub != nil { 1262 return stub() 1263 } 1264 if specificReturn { 1265 return ret.result1 1266 } 1267 return fakeReturns.result1 1268} 1269 1270func (fake *Wrapper) OptionsCallCount() int { 1271 fake.optionsMutex.RLock() 1272 defer fake.optionsMutex.RUnlock() 1273 return len(fake.optionsArgsForCall) 1274} 1275 1276func (fake *Wrapper) OptionsCalls(stub func() config.OptionsConfiguration) { 1277 fake.optionsMutex.Lock() 1278 defer fake.optionsMutex.Unlock() 1279 fake.OptionsStub = stub 1280} 1281 1282func (fake *Wrapper) OptionsReturns(result1 config.OptionsConfiguration) { 1283 fake.optionsMutex.Lock() 1284 defer fake.optionsMutex.Unlock() 1285 fake.OptionsStub = nil 1286 fake.optionsReturns = struct { 1287 result1 config.OptionsConfiguration 1288 }{result1} 1289} 1290 1291func (fake *Wrapper) OptionsReturnsOnCall(i int, result1 config.OptionsConfiguration) { 1292 fake.optionsMutex.Lock() 1293 defer fake.optionsMutex.Unlock() 1294 fake.OptionsStub = nil 1295 if fake.optionsReturnsOnCall == nil { 1296 fake.optionsReturnsOnCall = make(map[int]struct { 1297 result1 config.OptionsConfiguration 1298 }) 1299 } 1300 fake.optionsReturnsOnCall[i] = struct { 1301 result1 config.OptionsConfiguration 1302 }{result1} 1303} 1304 1305func (fake *Wrapper) RawCopy() config.Configuration { 1306 fake.rawCopyMutex.Lock() 1307 ret, specificReturn := fake.rawCopyReturnsOnCall[len(fake.rawCopyArgsForCall)] 1308 fake.rawCopyArgsForCall = append(fake.rawCopyArgsForCall, struct { 1309 }{}) 1310 stub := fake.RawCopyStub 1311 fakeReturns := fake.rawCopyReturns 1312 fake.recordInvocation("RawCopy", []interface{}{}) 1313 fake.rawCopyMutex.Unlock() 1314 if stub != nil { 1315 return stub() 1316 } 1317 if specificReturn { 1318 return ret.result1 1319 } 1320 return fakeReturns.result1 1321} 1322 1323func (fake *Wrapper) RawCopyCallCount() int { 1324 fake.rawCopyMutex.RLock() 1325 defer fake.rawCopyMutex.RUnlock() 1326 return len(fake.rawCopyArgsForCall) 1327} 1328 1329func (fake *Wrapper) RawCopyCalls(stub func() config.Configuration) { 1330 fake.rawCopyMutex.Lock() 1331 defer fake.rawCopyMutex.Unlock() 1332 fake.RawCopyStub = stub 1333} 1334 1335func (fake *Wrapper) RawCopyReturns(result1 config.Configuration) { 1336 fake.rawCopyMutex.Lock() 1337 defer fake.rawCopyMutex.Unlock() 1338 fake.RawCopyStub = nil 1339 fake.rawCopyReturns = struct { 1340 result1 config.Configuration 1341 }{result1} 1342} 1343 1344func (fake *Wrapper) RawCopyReturnsOnCall(i int, result1 config.Configuration) { 1345 fake.rawCopyMutex.Lock() 1346 defer fake.rawCopyMutex.Unlock() 1347 fake.RawCopyStub = nil 1348 if fake.rawCopyReturnsOnCall == nil { 1349 fake.rawCopyReturnsOnCall = make(map[int]struct { 1350 result1 config.Configuration 1351 }) 1352 } 1353 fake.rawCopyReturnsOnCall[i] = struct { 1354 result1 config.Configuration 1355 }{result1} 1356} 1357 1358func (fake *Wrapper) RemoveDevice(arg1 protocol.DeviceID) (config.Waiter, error) { 1359 fake.removeDeviceMutex.Lock() 1360 ret, specificReturn := fake.removeDeviceReturnsOnCall[len(fake.removeDeviceArgsForCall)] 1361 fake.removeDeviceArgsForCall = append(fake.removeDeviceArgsForCall, struct { 1362 arg1 protocol.DeviceID 1363 }{arg1}) 1364 stub := fake.RemoveDeviceStub 1365 fakeReturns := fake.removeDeviceReturns 1366 fake.recordInvocation("RemoveDevice", []interface{}{arg1}) 1367 fake.removeDeviceMutex.Unlock() 1368 if stub != nil { 1369 return stub(arg1) 1370 } 1371 if specificReturn { 1372 return ret.result1, ret.result2 1373 } 1374 return fakeReturns.result1, fakeReturns.result2 1375} 1376 1377func (fake *Wrapper) RemoveDeviceCallCount() int { 1378 fake.removeDeviceMutex.RLock() 1379 defer fake.removeDeviceMutex.RUnlock() 1380 return len(fake.removeDeviceArgsForCall) 1381} 1382 1383func (fake *Wrapper) RemoveDeviceCalls(stub func(protocol.DeviceID) (config.Waiter, error)) { 1384 fake.removeDeviceMutex.Lock() 1385 defer fake.removeDeviceMutex.Unlock() 1386 fake.RemoveDeviceStub = stub 1387} 1388 1389func (fake *Wrapper) RemoveDeviceArgsForCall(i int) protocol.DeviceID { 1390 fake.removeDeviceMutex.RLock() 1391 defer fake.removeDeviceMutex.RUnlock() 1392 argsForCall := fake.removeDeviceArgsForCall[i] 1393 return argsForCall.arg1 1394} 1395 1396func (fake *Wrapper) RemoveDeviceReturns(result1 config.Waiter, result2 error) { 1397 fake.removeDeviceMutex.Lock() 1398 defer fake.removeDeviceMutex.Unlock() 1399 fake.RemoveDeviceStub = nil 1400 fake.removeDeviceReturns = struct { 1401 result1 config.Waiter 1402 result2 error 1403 }{result1, result2} 1404} 1405 1406func (fake *Wrapper) RemoveDeviceReturnsOnCall(i int, result1 config.Waiter, result2 error) { 1407 fake.removeDeviceMutex.Lock() 1408 defer fake.removeDeviceMutex.Unlock() 1409 fake.RemoveDeviceStub = nil 1410 if fake.removeDeviceReturnsOnCall == nil { 1411 fake.removeDeviceReturnsOnCall = make(map[int]struct { 1412 result1 config.Waiter 1413 result2 error 1414 }) 1415 } 1416 fake.removeDeviceReturnsOnCall[i] = struct { 1417 result1 config.Waiter 1418 result2 error 1419 }{result1, result2} 1420} 1421 1422func (fake *Wrapper) RemoveFolder(arg1 string) (config.Waiter, error) { 1423 fake.removeFolderMutex.Lock() 1424 ret, specificReturn := fake.removeFolderReturnsOnCall[len(fake.removeFolderArgsForCall)] 1425 fake.removeFolderArgsForCall = append(fake.removeFolderArgsForCall, struct { 1426 arg1 string 1427 }{arg1}) 1428 stub := fake.RemoveFolderStub 1429 fakeReturns := fake.removeFolderReturns 1430 fake.recordInvocation("RemoveFolder", []interface{}{arg1}) 1431 fake.removeFolderMutex.Unlock() 1432 if stub != nil { 1433 return stub(arg1) 1434 } 1435 if specificReturn { 1436 return ret.result1, ret.result2 1437 } 1438 return fakeReturns.result1, fakeReturns.result2 1439} 1440 1441func (fake *Wrapper) RemoveFolderCallCount() int { 1442 fake.removeFolderMutex.RLock() 1443 defer fake.removeFolderMutex.RUnlock() 1444 return len(fake.removeFolderArgsForCall) 1445} 1446 1447func (fake *Wrapper) RemoveFolderCalls(stub func(string) (config.Waiter, error)) { 1448 fake.removeFolderMutex.Lock() 1449 defer fake.removeFolderMutex.Unlock() 1450 fake.RemoveFolderStub = stub 1451} 1452 1453func (fake *Wrapper) RemoveFolderArgsForCall(i int) string { 1454 fake.removeFolderMutex.RLock() 1455 defer fake.removeFolderMutex.RUnlock() 1456 argsForCall := fake.removeFolderArgsForCall[i] 1457 return argsForCall.arg1 1458} 1459 1460func (fake *Wrapper) RemoveFolderReturns(result1 config.Waiter, result2 error) { 1461 fake.removeFolderMutex.Lock() 1462 defer fake.removeFolderMutex.Unlock() 1463 fake.RemoveFolderStub = nil 1464 fake.removeFolderReturns = struct { 1465 result1 config.Waiter 1466 result2 error 1467 }{result1, result2} 1468} 1469 1470func (fake *Wrapper) RemoveFolderReturnsOnCall(i int, result1 config.Waiter, result2 error) { 1471 fake.removeFolderMutex.Lock() 1472 defer fake.removeFolderMutex.Unlock() 1473 fake.RemoveFolderStub = nil 1474 if fake.removeFolderReturnsOnCall == nil { 1475 fake.removeFolderReturnsOnCall = make(map[int]struct { 1476 result1 config.Waiter 1477 result2 error 1478 }) 1479 } 1480 fake.removeFolderReturnsOnCall[i] = struct { 1481 result1 config.Waiter 1482 result2 error 1483 }{result1, result2} 1484} 1485 1486func (fake *Wrapper) RequiresRestart() bool { 1487 fake.requiresRestartMutex.Lock() 1488 ret, specificReturn := fake.requiresRestartReturnsOnCall[len(fake.requiresRestartArgsForCall)] 1489 fake.requiresRestartArgsForCall = append(fake.requiresRestartArgsForCall, struct { 1490 }{}) 1491 stub := fake.RequiresRestartStub 1492 fakeReturns := fake.requiresRestartReturns 1493 fake.recordInvocation("RequiresRestart", []interface{}{}) 1494 fake.requiresRestartMutex.Unlock() 1495 if stub != nil { 1496 return stub() 1497 } 1498 if specificReturn { 1499 return ret.result1 1500 } 1501 return fakeReturns.result1 1502} 1503 1504func (fake *Wrapper) RequiresRestartCallCount() int { 1505 fake.requiresRestartMutex.RLock() 1506 defer fake.requiresRestartMutex.RUnlock() 1507 return len(fake.requiresRestartArgsForCall) 1508} 1509 1510func (fake *Wrapper) RequiresRestartCalls(stub func() bool) { 1511 fake.requiresRestartMutex.Lock() 1512 defer fake.requiresRestartMutex.Unlock() 1513 fake.RequiresRestartStub = stub 1514} 1515 1516func (fake *Wrapper) RequiresRestartReturns(result1 bool) { 1517 fake.requiresRestartMutex.Lock() 1518 defer fake.requiresRestartMutex.Unlock() 1519 fake.RequiresRestartStub = nil 1520 fake.requiresRestartReturns = struct { 1521 result1 bool 1522 }{result1} 1523} 1524 1525func (fake *Wrapper) RequiresRestartReturnsOnCall(i int, result1 bool) { 1526 fake.requiresRestartMutex.Lock() 1527 defer fake.requiresRestartMutex.Unlock() 1528 fake.RequiresRestartStub = nil 1529 if fake.requiresRestartReturnsOnCall == nil { 1530 fake.requiresRestartReturnsOnCall = make(map[int]struct { 1531 result1 bool 1532 }) 1533 } 1534 fake.requiresRestartReturnsOnCall[i] = struct { 1535 result1 bool 1536 }{result1} 1537} 1538 1539func (fake *Wrapper) Save() error { 1540 fake.saveMutex.Lock() 1541 ret, specificReturn := fake.saveReturnsOnCall[len(fake.saveArgsForCall)] 1542 fake.saveArgsForCall = append(fake.saveArgsForCall, struct { 1543 }{}) 1544 stub := fake.SaveStub 1545 fakeReturns := fake.saveReturns 1546 fake.recordInvocation("Save", []interface{}{}) 1547 fake.saveMutex.Unlock() 1548 if stub != nil { 1549 return stub() 1550 } 1551 if specificReturn { 1552 return ret.result1 1553 } 1554 return fakeReturns.result1 1555} 1556 1557func (fake *Wrapper) SaveCallCount() int { 1558 fake.saveMutex.RLock() 1559 defer fake.saveMutex.RUnlock() 1560 return len(fake.saveArgsForCall) 1561} 1562 1563func (fake *Wrapper) SaveCalls(stub func() error) { 1564 fake.saveMutex.Lock() 1565 defer fake.saveMutex.Unlock() 1566 fake.SaveStub = stub 1567} 1568 1569func (fake *Wrapper) SaveReturns(result1 error) { 1570 fake.saveMutex.Lock() 1571 defer fake.saveMutex.Unlock() 1572 fake.SaveStub = nil 1573 fake.saveReturns = struct { 1574 result1 error 1575 }{result1} 1576} 1577 1578func (fake *Wrapper) SaveReturnsOnCall(i int, result1 error) { 1579 fake.saveMutex.Lock() 1580 defer fake.saveMutex.Unlock() 1581 fake.SaveStub = nil 1582 if fake.saveReturnsOnCall == nil { 1583 fake.saveReturnsOnCall = make(map[int]struct { 1584 result1 error 1585 }) 1586 } 1587 fake.saveReturnsOnCall[i] = struct { 1588 result1 error 1589 }{result1} 1590} 1591 1592func (fake *Wrapper) Serve(arg1 context.Context) error { 1593 fake.serveMutex.Lock() 1594 ret, specificReturn := fake.serveReturnsOnCall[len(fake.serveArgsForCall)] 1595 fake.serveArgsForCall = append(fake.serveArgsForCall, struct { 1596 arg1 context.Context 1597 }{arg1}) 1598 stub := fake.ServeStub 1599 fakeReturns := fake.serveReturns 1600 fake.recordInvocation("Serve", []interface{}{arg1}) 1601 fake.serveMutex.Unlock() 1602 if stub != nil { 1603 return stub(arg1) 1604 } 1605 if specificReturn { 1606 return ret.result1 1607 } 1608 return fakeReturns.result1 1609} 1610 1611func (fake *Wrapper) ServeCallCount() int { 1612 fake.serveMutex.RLock() 1613 defer fake.serveMutex.RUnlock() 1614 return len(fake.serveArgsForCall) 1615} 1616 1617func (fake *Wrapper) ServeCalls(stub func(context.Context) error) { 1618 fake.serveMutex.Lock() 1619 defer fake.serveMutex.Unlock() 1620 fake.ServeStub = stub 1621} 1622 1623func (fake *Wrapper) ServeArgsForCall(i int) context.Context { 1624 fake.serveMutex.RLock() 1625 defer fake.serveMutex.RUnlock() 1626 argsForCall := fake.serveArgsForCall[i] 1627 return argsForCall.arg1 1628} 1629 1630func (fake *Wrapper) ServeReturns(result1 error) { 1631 fake.serveMutex.Lock() 1632 defer fake.serveMutex.Unlock() 1633 fake.ServeStub = nil 1634 fake.serveReturns = struct { 1635 result1 error 1636 }{result1} 1637} 1638 1639func (fake *Wrapper) ServeReturnsOnCall(i int, result1 error) { 1640 fake.serveMutex.Lock() 1641 defer fake.serveMutex.Unlock() 1642 fake.ServeStub = nil 1643 if fake.serveReturnsOnCall == nil { 1644 fake.serveReturnsOnCall = make(map[int]struct { 1645 result1 error 1646 }) 1647 } 1648 fake.serveReturnsOnCall[i] = struct { 1649 result1 error 1650 }{result1} 1651} 1652 1653func (fake *Wrapper) Subscribe(arg1 config.Committer) config.Configuration { 1654 fake.subscribeMutex.Lock() 1655 ret, specificReturn := fake.subscribeReturnsOnCall[len(fake.subscribeArgsForCall)] 1656 fake.subscribeArgsForCall = append(fake.subscribeArgsForCall, struct { 1657 arg1 config.Committer 1658 }{arg1}) 1659 stub := fake.SubscribeStub 1660 fakeReturns := fake.subscribeReturns 1661 fake.recordInvocation("Subscribe", []interface{}{arg1}) 1662 fake.subscribeMutex.Unlock() 1663 if stub != nil { 1664 return stub(arg1) 1665 } 1666 if specificReturn { 1667 return ret.result1 1668 } 1669 return fakeReturns.result1 1670} 1671 1672func (fake *Wrapper) SubscribeCallCount() int { 1673 fake.subscribeMutex.RLock() 1674 defer fake.subscribeMutex.RUnlock() 1675 return len(fake.subscribeArgsForCall) 1676} 1677 1678func (fake *Wrapper) SubscribeCalls(stub func(config.Committer) config.Configuration) { 1679 fake.subscribeMutex.Lock() 1680 defer fake.subscribeMutex.Unlock() 1681 fake.SubscribeStub = stub 1682} 1683 1684func (fake *Wrapper) SubscribeArgsForCall(i int) config.Committer { 1685 fake.subscribeMutex.RLock() 1686 defer fake.subscribeMutex.RUnlock() 1687 argsForCall := fake.subscribeArgsForCall[i] 1688 return argsForCall.arg1 1689} 1690 1691func (fake *Wrapper) SubscribeReturns(result1 config.Configuration) { 1692 fake.subscribeMutex.Lock() 1693 defer fake.subscribeMutex.Unlock() 1694 fake.SubscribeStub = nil 1695 fake.subscribeReturns = struct { 1696 result1 config.Configuration 1697 }{result1} 1698} 1699 1700func (fake *Wrapper) SubscribeReturnsOnCall(i int, result1 config.Configuration) { 1701 fake.subscribeMutex.Lock() 1702 defer fake.subscribeMutex.Unlock() 1703 fake.SubscribeStub = nil 1704 if fake.subscribeReturnsOnCall == nil { 1705 fake.subscribeReturnsOnCall = make(map[int]struct { 1706 result1 config.Configuration 1707 }) 1708 } 1709 fake.subscribeReturnsOnCall[i] = struct { 1710 result1 config.Configuration 1711 }{result1} 1712} 1713 1714func (fake *Wrapper) Unsubscribe(arg1 config.Committer) { 1715 fake.unsubscribeMutex.Lock() 1716 fake.unsubscribeArgsForCall = append(fake.unsubscribeArgsForCall, struct { 1717 arg1 config.Committer 1718 }{arg1}) 1719 stub := fake.UnsubscribeStub 1720 fake.recordInvocation("Unsubscribe", []interface{}{arg1}) 1721 fake.unsubscribeMutex.Unlock() 1722 if stub != nil { 1723 fake.UnsubscribeStub(arg1) 1724 } 1725} 1726 1727func (fake *Wrapper) UnsubscribeCallCount() int { 1728 fake.unsubscribeMutex.RLock() 1729 defer fake.unsubscribeMutex.RUnlock() 1730 return len(fake.unsubscribeArgsForCall) 1731} 1732 1733func (fake *Wrapper) UnsubscribeCalls(stub func(config.Committer)) { 1734 fake.unsubscribeMutex.Lock() 1735 defer fake.unsubscribeMutex.Unlock() 1736 fake.UnsubscribeStub = stub 1737} 1738 1739func (fake *Wrapper) UnsubscribeArgsForCall(i int) config.Committer { 1740 fake.unsubscribeMutex.RLock() 1741 defer fake.unsubscribeMutex.RUnlock() 1742 argsForCall := fake.unsubscribeArgsForCall[i] 1743 return argsForCall.arg1 1744} 1745 1746func (fake *Wrapper) Invocations() map[string][][]interface{} { 1747 fake.invocationsMutex.RLock() 1748 defer fake.invocationsMutex.RUnlock() 1749 fake.configPathMutex.RLock() 1750 defer fake.configPathMutex.RUnlock() 1751 fake.defaultDeviceMutex.RLock() 1752 defer fake.defaultDeviceMutex.RUnlock() 1753 fake.defaultFolderMutex.RLock() 1754 defer fake.defaultFolderMutex.RUnlock() 1755 fake.deviceMutex.RLock() 1756 defer fake.deviceMutex.RUnlock() 1757 fake.deviceListMutex.RLock() 1758 defer fake.deviceListMutex.RUnlock() 1759 fake.devicesMutex.RLock() 1760 defer fake.devicesMutex.RUnlock() 1761 fake.folderMutex.RLock() 1762 defer fake.folderMutex.RUnlock() 1763 fake.folderListMutex.RLock() 1764 defer fake.folderListMutex.RUnlock() 1765 fake.folderPasswordsMutex.RLock() 1766 defer fake.folderPasswordsMutex.RUnlock() 1767 fake.foldersMutex.RLock() 1768 defer fake.foldersMutex.RUnlock() 1769 fake.gUIMutex.RLock() 1770 defer fake.gUIMutex.RUnlock() 1771 fake.ignoredDeviceMutex.RLock() 1772 defer fake.ignoredDeviceMutex.RUnlock() 1773 fake.ignoredDevicesMutex.RLock() 1774 defer fake.ignoredDevicesMutex.RUnlock() 1775 fake.ignoredFolderMutex.RLock() 1776 defer fake.ignoredFolderMutex.RUnlock() 1777 fake.lDAPMutex.RLock() 1778 defer fake.lDAPMutex.RUnlock() 1779 fake.modifyMutex.RLock() 1780 defer fake.modifyMutex.RUnlock() 1781 fake.myIDMutex.RLock() 1782 defer fake.myIDMutex.RUnlock() 1783 fake.optionsMutex.RLock() 1784 defer fake.optionsMutex.RUnlock() 1785 fake.rawCopyMutex.RLock() 1786 defer fake.rawCopyMutex.RUnlock() 1787 fake.removeDeviceMutex.RLock() 1788 defer fake.removeDeviceMutex.RUnlock() 1789 fake.removeFolderMutex.RLock() 1790 defer fake.removeFolderMutex.RUnlock() 1791 fake.requiresRestartMutex.RLock() 1792 defer fake.requiresRestartMutex.RUnlock() 1793 fake.saveMutex.RLock() 1794 defer fake.saveMutex.RUnlock() 1795 fake.serveMutex.RLock() 1796 defer fake.serveMutex.RUnlock() 1797 fake.subscribeMutex.RLock() 1798 defer fake.subscribeMutex.RUnlock() 1799 fake.unsubscribeMutex.RLock() 1800 defer fake.unsubscribeMutex.RUnlock() 1801 copiedInvocations := map[string][][]interface{}{} 1802 for key, value := range fake.invocations { 1803 copiedInvocations[key] = value 1804 } 1805 return copiedInvocations 1806} 1807 1808func (fake *Wrapper) recordInvocation(key string, args []interface{}) { 1809 fake.invocationsMutex.Lock() 1810 defer fake.invocationsMutex.Unlock() 1811 if fake.invocations == nil { 1812 fake.invocations = map[string][][]interface{}{} 1813 } 1814 if fake.invocations[key] == nil { 1815 fake.invocations[key] = [][]interface{}{} 1816 } 1817 fake.invocations[key] = append(fake.invocations[key], args) 1818} 1819 1820var _ config.Wrapper = new(Wrapper) 1821