syncthing/lib/config/mocks/mocked_wrapper.go

1821 lines
50 KiB
Go

// Code generated by counterfeiter. DO NOT EDIT.
package mocks
import (
"context"
"sync"
"github.com/syncthing/syncthing/lib/config"
"github.com/syncthing/syncthing/lib/protocol"
)
type Wrapper struct {
ConfigPathStub func() string
configPathMutex sync.RWMutex
configPathArgsForCall []struct {
}
configPathReturns struct {
result1 string
}
configPathReturnsOnCall map[int]struct {
result1 string
}
DefaultDeviceStub func() config.DeviceConfiguration
defaultDeviceMutex sync.RWMutex
defaultDeviceArgsForCall []struct {
}
defaultDeviceReturns struct {
result1 config.DeviceConfiguration
}
defaultDeviceReturnsOnCall map[int]struct {
result1 config.DeviceConfiguration
}
DefaultFolderStub func() config.FolderConfiguration
defaultFolderMutex sync.RWMutex
defaultFolderArgsForCall []struct {
}
defaultFolderReturns struct {
result1 config.FolderConfiguration
}
defaultFolderReturnsOnCall map[int]struct {
result1 config.FolderConfiguration
}
DeviceStub func(protocol.DeviceID) (config.DeviceConfiguration, bool)
deviceMutex sync.RWMutex
deviceArgsForCall []struct {
arg1 protocol.DeviceID
}
deviceReturns struct {
result1 config.DeviceConfiguration
result2 bool
}
deviceReturnsOnCall map[int]struct {
result1 config.DeviceConfiguration
result2 bool
}
DeviceListStub func() []config.DeviceConfiguration
deviceListMutex sync.RWMutex
deviceListArgsForCall []struct {
}
deviceListReturns struct {
result1 []config.DeviceConfiguration
}
deviceListReturnsOnCall map[int]struct {
result1 []config.DeviceConfiguration
}
DevicesStub func() map[protocol.DeviceID]config.DeviceConfiguration
devicesMutex sync.RWMutex
devicesArgsForCall []struct {
}
devicesReturns struct {
result1 map[protocol.DeviceID]config.DeviceConfiguration
}
devicesReturnsOnCall map[int]struct {
result1 map[protocol.DeviceID]config.DeviceConfiguration
}
FolderStub func(string) (config.FolderConfiguration, bool)
folderMutex sync.RWMutex
folderArgsForCall []struct {
arg1 string
}
folderReturns struct {
result1 config.FolderConfiguration
result2 bool
}
folderReturnsOnCall map[int]struct {
result1 config.FolderConfiguration
result2 bool
}
FolderListStub func() []config.FolderConfiguration
folderListMutex sync.RWMutex
folderListArgsForCall []struct {
}
folderListReturns struct {
result1 []config.FolderConfiguration
}
folderListReturnsOnCall map[int]struct {
result1 []config.FolderConfiguration
}
FolderPasswordsStub func(protocol.DeviceID) map[string]string
folderPasswordsMutex sync.RWMutex
folderPasswordsArgsForCall []struct {
arg1 protocol.DeviceID
}
folderPasswordsReturns struct {
result1 map[string]string
}
folderPasswordsReturnsOnCall map[int]struct {
result1 map[string]string
}
FoldersStub func() map[string]config.FolderConfiguration
foldersMutex sync.RWMutex
foldersArgsForCall []struct {
}
foldersReturns struct {
result1 map[string]config.FolderConfiguration
}
foldersReturnsOnCall map[int]struct {
result1 map[string]config.FolderConfiguration
}
GUIStub func() config.GUIConfiguration
gUIMutex sync.RWMutex
gUIArgsForCall []struct {
}
gUIReturns struct {
result1 config.GUIConfiguration
}
gUIReturnsOnCall map[int]struct {
result1 config.GUIConfiguration
}
IgnoredDeviceStub func(protocol.DeviceID) bool
ignoredDeviceMutex sync.RWMutex
ignoredDeviceArgsForCall []struct {
arg1 protocol.DeviceID
}
ignoredDeviceReturns struct {
result1 bool
}
ignoredDeviceReturnsOnCall map[int]struct {
result1 bool
}
IgnoredDevicesStub func() []config.ObservedDevice
ignoredDevicesMutex sync.RWMutex
ignoredDevicesArgsForCall []struct {
}
ignoredDevicesReturns struct {
result1 []config.ObservedDevice
}
ignoredDevicesReturnsOnCall map[int]struct {
result1 []config.ObservedDevice
}
IgnoredFolderStub func(protocol.DeviceID, string) bool
ignoredFolderMutex sync.RWMutex
ignoredFolderArgsForCall []struct {
arg1 protocol.DeviceID
arg2 string
}
ignoredFolderReturns struct {
result1 bool
}
ignoredFolderReturnsOnCall map[int]struct {
result1 bool
}
LDAPStub func() config.LDAPConfiguration
lDAPMutex sync.RWMutex
lDAPArgsForCall []struct {
}
lDAPReturns struct {
result1 config.LDAPConfiguration
}
lDAPReturnsOnCall map[int]struct {
result1 config.LDAPConfiguration
}
ModifyStub func(config.ModifyFunction) (config.Waiter, error)
modifyMutex sync.RWMutex
modifyArgsForCall []struct {
arg1 config.ModifyFunction
}
modifyReturns struct {
result1 config.Waiter
result2 error
}
modifyReturnsOnCall map[int]struct {
result1 config.Waiter
result2 error
}
MyIDStub func() protocol.DeviceID
myIDMutex sync.RWMutex
myIDArgsForCall []struct {
}
myIDReturns struct {
result1 protocol.DeviceID
}
myIDReturnsOnCall map[int]struct {
result1 protocol.DeviceID
}
OptionsStub func() config.OptionsConfiguration
optionsMutex sync.RWMutex
optionsArgsForCall []struct {
}
optionsReturns struct {
result1 config.OptionsConfiguration
}
optionsReturnsOnCall map[int]struct {
result1 config.OptionsConfiguration
}
RawCopyStub func() config.Configuration
rawCopyMutex sync.RWMutex
rawCopyArgsForCall []struct {
}
rawCopyReturns struct {
result1 config.Configuration
}
rawCopyReturnsOnCall map[int]struct {
result1 config.Configuration
}
RemoveDeviceStub func(protocol.DeviceID) (config.Waiter, error)
removeDeviceMutex sync.RWMutex
removeDeviceArgsForCall []struct {
arg1 protocol.DeviceID
}
removeDeviceReturns struct {
result1 config.Waiter
result2 error
}
removeDeviceReturnsOnCall map[int]struct {
result1 config.Waiter
result2 error
}
RemoveFolderStub func(string) (config.Waiter, error)
removeFolderMutex sync.RWMutex
removeFolderArgsForCall []struct {
arg1 string
}
removeFolderReturns struct {
result1 config.Waiter
result2 error
}
removeFolderReturnsOnCall map[int]struct {
result1 config.Waiter
result2 error
}
RequiresRestartStub func() bool
requiresRestartMutex sync.RWMutex
requiresRestartArgsForCall []struct {
}
requiresRestartReturns struct {
result1 bool
}
requiresRestartReturnsOnCall map[int]struct {
result1 bool
}
SaveStub func() error
saveMutex sync.RWMutex
saveArgsForCall []struct {
}
saveReturns struct {
result1 error
}
saveReturnsOnCall map[int]struct {
result1 error
}
ServeStub func(context.Context) error
serveMutex sync.RWMutex
serveArgsForCall []struct {
arg1 context.Context
}
serveReturns struct {
result1 error
}
serveReturnsOnCall map[int]struct {
result1 error
}
SubscribeStub func(config.Committer) config.Configuration
subscribeMutex sync.RWMutex
subscribeArgsForCall []struct {
arg1 config.Committer
}
subscribeReturns struct {
result1 config.Configuration
}
subscribeReturnsOnCall map[int]struct {
result1 config.Configuration
}
UnsubscribeStub func(config.Committer)
unsubscribeMutex sync.RWMutex
unsubscribeArgsForCall []struct {
arg1 config.Committer
}
invocations map[string][][]interface{}
invocationsMutex sync.RWMutex
}
func (fake *Wrapper) ConfigPath() string {
fake.configPathMutex.Lock()
ret, specificReturn := fake.configPathReturnsOnCall[len(fake.configPathArgsForCall)]
fake.configPathArgsForCall = append(fake.configPathArgsForCall, struct {
}{})
stub := fake.ConfigPathStub
fakeReturns := fake.configPathReturns
fake.recordInvocation("ConfigPath", []interface{}{})
fake.configPathMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) ConfigPathCallCount() int {
fake.configPathMutex.RLock()
defer fake.configPathMutex.RUnlock()
return len(fake.configPathArgsForCall)
}
func (fake *Wrapper) ConfigPathCalls(stub func() string) {
fake.configPathMutex.Lock()
defer fake.configPathMutex.Unlock()
fake.ConfigPathStub = stub
}
func (fake *Wrapper) ConfigPathReturns(result1 string) {
fake.configPathMutex.Lock()
defer fake.configPathMutex.Unlock()
fake.ConfigPathStub = nil
fake.configPathReturns = struct {
result1 string
}{result1}
}
func (fake *Wrapper) ConfigPathReturnsOnCall(i int, result1 string) {
fake.configPathMutex.Lock()
defer fake.configPathMutex.Unlock()
fake.ConfigPathStub = nil
if fake.configPathReturnsOnCall == nil {
fake.configPathReturnsOnCall = make(map[int]struct {
result1 string
})
}
fake.configPathReturnsOnCall[i] = struct {
result1 string
}{result1}
}
func (fake *Wrapper) DefaultDevice() config.DeviceConfiguration {
fake.defaultDeviceMutex.Lock()
ret, specificReturn := fake.defaultDeviceReturnsOnCall[len(fake.defaultDeviceArgsForCall)]
fake.defaultDeviceArgsForCall = append(fake.defaultDeviceArgsForCall, struct {
}{})
stub := fake.DefaultDeviceStub
fakeReturns := fake.defaultDeviceReturns
fake.recordInvocation("DefaultDevice", []interface{}{})
fake.defaultDeviceMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) DefaultDeviceCallCount() int {
fake.defaultDeviceMutex.RLock()
defer fake.defaultDeviceMutex.RUnlock()
return len(fake.defaultDeviceArgsForCall)
}
func (fake *Wrapper) DefaultDeviceCalls(stub func() config.DeviceConfiguration) {
fake.defaultDeviceMutex.Lock()
defer fake.defaultDeviceMutex.Unlock()
fake.DefaultDeviceStub = stub
}
func (fake *Wrapper) DefaultDeviceReturns(result1 config.DeviceConfiguration) {
fake.defaultDeviceMutex.Lock()
defer fake.defaultDeviceMutex.Unlock()
fake.DefaultDeviceStub = nil
fake.defaultDeviceReturns = struct {
result1 config.DeviceConfiguration
}{result1}
}
func (fake *Wrapper) DefaultDeviceReturnsOnCall(i int, result1 config.DeviceConfiguration) {
fake.defaultDeviceMutex.Lock()
defer fake.defaultDeviceMutex.Unlock()
fake.DefaultDeviceStub = nil
if fake.defaultDeviceReturnsOnCall == nil {
fake.defaultDeviceReturnsOnCall = make(map[int]struct {
result1 config.DeviceConfiguration
})
}
fake.defaultDeviceReturnsOnCall[i] = struct {
result1 config.DeviceConfiguration
}{result1}
}
func (fake *Wrapper) DefaultFolder() config.FolderConfiguration {
fake.defaultFolderMutex.Lock()
ret, specificReturn := fake.defaultFolderReturnsOnCall[len(fake.defaultFolderArgsForCall)]
fake.defaultFolderArgsForCall = append(fake.defaultFolderArgsForCall, struct {
}{})
stub := fake.DefaultFolderStub
fakeReturns := fake.defaultFolderReturns
fake.recordInvocation("DefaultFolder", []interface{}{})
fake.defaultFolderMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) DefaultFolderCallCount() int {
fake.defaultFolderMutex.RLock()
defer fake.defaultFolderMutex.RUnlock()
return len(fake.defaultFolderArgsForCall)
}
func (fake *Wrapper) DefaultFolderCalls(stub func() config.FolderConfiguration) {
fake.defaultFolderMutex.Lock()
defer fake.defaultFolderMutex.Unlock()
fake.DefaultFolderStub = stub
}
func (fake *Wrapper) DefaultFolderReturns(result1 config.FolderConfiguration) {
fake.defaultFolderMutex.Lock()
defer fake.defaultFolderMutex.Unlock()
fake.DefaultFolderStub = nil
fake.defaultFolderReturns = struct {
result1 config.FolderConfiguration
}{result1}
}
func (fake *Wrapper) DefaultFolderReturnsOnCall(i int, result1 config.FolderConfiguration) {
fake.defaultFolderMutex.Lock()
defer fake.defaultFolderMutex.Unlock()
fake.DefaultFolderStub = nil
if fake.defaultFolderReturnsOnCall == nil {
fake.defaultFolderReturnsOnCall = make(map[int]struct {
result1 config.FolderConfiguration
})
}
fake.defaultFolderReturnsOnCall[i] = struct {
result1 config.FolderConfiguration
}{result1}
}
func (fake *Wrapper) Device(arg1 protocol.DeviceID) (config.DeviceConfiguration, bool) {
fake.deviceMutex.Lock()
ret, specificReturn := fake.deviceReturnsOnCall[len(fake.deviceArgsForCall)]
fake.deviceArgsForCall = append(fake.deviceArgsForCall, struct {
arg1 protocol.DeviceID
}{arg1})
stub := fake.DeviceStub
fakeReturns := fake.deviceReturns
fake.recordInvocation("Device", []interface{}{arg1})
fake.deviceMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1, ret.result2
}
return fakeReturns.result1, fakeReturns.result2
}
func (fake *Wrapper) DeviceCallCount() int {
fake.deviceMutex.RLock()
defer fake.deviceMutex.RUnlock()
return len(fake.deviceArgsForCall)
}
func (fake *Wrapper) DeviceCalls(stub func(protocol.DeviceID) (config.DeviceConfiguration, bool)) {
fake.deviceMutex.Lock()
defer fake.deviceMutex.Unlock()
fake.DeviceStub = stub
}
func (fake *Wrapper) DeviceArgsForCall(i int) protocol.DeviceID {
fake.deviceMutex.RLock()
defer fake.deviceMutex.RUnlock()
argsForCall := fake.deviceArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) DeviceReturns(result1 config.DeviceConfiguration, result2 bool) {
fake.deviceMutex.Lock()
defer fake.deviceMutex.Unlock()
fake.DeviceStub = nil
fake.deviceReturns = struct {
result1 config.DeviceConfiguration
result2 bool
}{result1, result2}
}
func (fake *Wrapper) DeviceReturnsOnCall(i int, result1 config.DeviceConfiguration, result2 bool) {
fake.deviceMutex.Lock()
defer fake.deviceMutex.Unlock()
fake.DeviceStub = nil
if fake.deviceReturnsOnCall == nil {
fake.deviceReturnsOnCall = make(map[int]struct {
result1 config.DeviceConfiguration
result2 bool
})
}
fake.deviceReturnsOnCall[i] = struct {
result1 config.DeviceConfiguration
result2 bool
}{result1, result2}
}
func (fake *Wrapper) DeviceList() []config.DeviceConfiguration {
fake.deviceListMutex.Lock()
ret, specificReturn := fake.deviceListReturnsOnCall[len(fake.deviceListArgsForCall)]
fake.deviceListArgsForCall = append(fake.deviceListArgsForCall, struct {
}{})
stub := fake.DeviceListStub
fakeReturns := fake.deviceListReturns
fake.recordInvocation("DeviceList", []interface{}{})
fake.deviceListMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) DeviceListCallCount() int {
fake.deviceListMutex.RLock()
defer fake.deviceListMutex.RUnlock()
return len(fake.deviceListArgsForCall)
}
func (fake *Wrapper) DeviceListCalls(stub func() []config.DeviceConfiguration) {
fake.deviceListMutex.Lock()
defer fake.deviceListMutex.Unlock()
fake.DeviceListStub = stub
}
func (fake *Wrapper) DeviceListReturns(result1 []config.DeviceConfiguration) {
fake.deviceListMutex.Lock()
defer fake.deviceListMutex.Unlock()
fake.DeviceListStub = nil
fake.deviceListReturns = struct {
result1 []config.DeviceConfiguration
}{result1}
}
func (fake *Wrapper) DeviceListReturnsOnCall(i int, result1 []config.DeviceConfiguration) {
fake.deviceListMutex.Lock()
defer fake.deviceListMutex.Unlock()
fake.DeviceListStub = nil
if fake.deviceListReturnsOnCall == nil {
fake.deviceListReturnsOnCall = make(map[int]struct {
result1 []config.DeviceConfiguration
})
}
fake.deviceListReturnsOnCall[i] = struct {
result1 []config.DeviceConfiguration
}{result1}
}
func (fake *Wrapper) Devices() map[protocol.DeviceID]config.DeviceConfiguration {
fake.devicesMutex.Lock()
ret, specificReturn := fake.devicesReturnsOnCall[len(fake.devicesArgsForCall)]
fake.devicesArgsForCall = append(fake.devicesArgsForCall, struct {
}{})
stub := fake.DevicesStub
fakeReturns := fake.devicesReturns
fake.recordInvocation("Devices", []interface{}{})
fake.devicesMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) DevicesCallCount() int {
fake.devicesMutex.RLock()
defer fake.devicesMutex.RUnlock()
return len(fake.devicesArgsForCall)
}
func (fake *Wrapper) DevicesCalls(stub func() map[protocol.DeviceID]config.DeviceConfiguration) {
fake.devicesMutex.Lock()
defer fake.devicesMutex.Unlock()
fake.DevicesStub = stub
}
func (fake *Wrapper) DevicesReturns(result1 map[protocol.DeviceID]config.DeviceConfiguration) {
fake.devicesMutex.Lock()
defer fake.devicesMutex.Unlock()
fake.DevicesStub = nil
fake.devicesReturns = struct {
result1 map[protocol.DeviceID]config.DeviceConfiguration
}{result1}
}
func (fake *Wrapper) DevicesReturnsOnCall(i int, result1 map[protocol.DeviceID]config.DeviceConfiguration) {
fake.devicesMutex.Lock()
defer fake.devicesMutex.Unlock()
fake.DevicesStub = nil
if fake.devicesReturnsOnCall == nil {
fake.devicesReturnsOnCall = make(map[int]struct {
result1 map[protocol.DeviceID]config.DeviceConfiguration
})
}
fake.devicesReturnsOnCall[i] = struct {
result1 map[protocol.DeviceID]config.DeviceConfiguration
}{result1}
}
func (fake *Wrapper) Folder(arg1 string) (config.FolderConfiguration, bool) {
fake.folderMutex.Lock()
ret, specificReturn := fake.folderReturnsOnCall[len(fake.folderArgsForCall)]
fake.folderArgsForCall = append(fake.folderArgsForCall, struct {
arg1 string
}{arg1})
stub := fake.FolderStub
fakeReturns := fake.folderReturns
fake.recordInvocation("Folder", []interface{}{arg1})
fake.folderMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1, ret.result2
}
return fakeReturns.result1, fakeReturns.result2
}
func (fake *Wrapper) FolderCallCount() int {
fake.folderMutex.RLock()
defer fake.folderMutex.RUnlock()
return len(fake.folderArgsForCall)
}
func (fake *Wrapper) FolderCalls(stub func(string) (config.FolderConfiguration, bool)) {
fake.folderMutex.Lock()
defer fake.folderMutex.Unlock()
fake.FolderStub = stub
}
func (fake *Wrapper) FolderArgsForCall(i int) string {
fake.folderMutex.RLock()
defer fake.folderMutex.RUnlock()
argsForCall := fake.folderArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) FolderReturns(result1 config.FolderConfiguration, result2 bool) {
fake.folderMutex.Lock()
defer fake.folderMutex.Unlock()
fake.FolderStub = nil
fake.folderReturns = struct {
result1 config.FolderConfiguration
result2 bool
}{result1, result2}
}
func (fake *Wrapper) FolderReturnsOnCall(i int, result1 config.FolderConfiguration, result2 bool) {
fake.folderMutex.Lock()
defer fake.folderMutex.Unlock()
fake.FolderStub = nil
if fake.folderReturnsOnCall == nil {
fake.folderReturnsOnCall = make(map[int]struct {
result1 config.FolderConfiguration
result2 bool
})
}
fake.folderReturnsOnCall[i] = struct {
result1 config.FolderConfiguration
result2 bool
}{result1, result2}
}
func (fake *Wrapper) FolderList() []config.FolderConfiguration {
fake.folderListMutex.Lock()
ret, specificReturn := fake.folderListReturnsOnCall[len(fake.folderListArgsForCall)]
fake.folderListArgsForCall = append(fake.folderListArgsForCall, struct {
}{})
stub := fake.FolderListStub
fakeReturns := fake.folderListReturns
fake.recordInvocation("FolderList", []interface{}{})
fake.folderListMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) FolderListCallCount() int {
fake.folderListMutex.RLock()
defer fake.folderListMutex.RUnlock()
return len(fake.folderListArgsForCall)
}
func (fake *Wrapper) FolderListCalls(stub func() []config.FolderConfiguration) {
fake.folderListMutex.Lock()
defer fake.folderListMutex.Unlock()
fake.FolderListStub = stub
}
func (fake *Wrapper) FolderListReturns(result1 []config.FolderConfiguration) {
fake.folderListMutex.Lock()
defer fake.folderListMutex.Unlock()
fake.FolderListStub = nil
fake.folderListReturns = struct {
result1 []config.FolderConfiguration
}{result1}
}
func (fake *Wrapper) FolderListReturnsOnCall(i int, result1 []config.FolderConfiguration) {
fake.folderListMutex.Lock()
defer fake.folderListMutex.Unlock()
fake.FolderListStub = nil
if fake.folderListReturnsOnCall == nil {
fake.folderListReturnsOnCall = make(map[int]struct {
result1 []config.FolderConfiguration
})
}
fake.folderListReturnsOnCall[i] = struct {
result1 []config.FolderConfiguration
}{result1}
}
func (fake *Wrapper) FolderPasswords(arg1 protocol.DeviceID) map[string]string {
fake.folderPasswordsMutex.Lock()
ret, specificReturn := fake.folderPasswordsReturnsOnCall[len(fake.folderPasswordsArgsForCall)]
fake.folderPasswordsArgsForCall = append(fake.folderPasswordsArgsForCall, struct {
arg1 protocol.DeviceID
}{arg1})
stub := fake.FolderPasswordsStub
fakeReturns := fake.folderPasswordsReturns
fake.recordInvocation("FolderPasswords", []interface{}{arg1})
fake.folderPasswordsMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) FolderPasswordsCallCount() int {
fake.folderPasswordsMutex.RLock()
defer fake.folderPasswordsMutex.RUnlock()
return len(fake.folderPasswordsArgsForCall)
}
func (fake *Wrapper) FolderPasswordsCalls(stub func(protocol.DeviceID) map[string]string) {
fake.folderPasswordsMutex.Lock()
defer fake.folderPasswordsMutex.Unlock()
fake.FolderPasswordsStub = stub
}
func (fake *Wrapper) FolderPasswordsArgsForCall(i int) protocol.DeviceID {
fake.folderPasswordsMutex.RLock()
defer fake.folderPasswordsMutex.RUnlock()
argsForCall := fake.folderPasswordsArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) FolderPasswordsReturns(result1 map[string]string) {
fake.folderPasswordsMutex.Lock()
defer fake.folderPasswordsMutex.Unlock()
fake.FolderPasswordsStub = nil
fake.folderPasswordsReturns = struct {
result1 map[string]string
}{result1}
}
func (fake *Wrapper) FolderPasswordsReturnsOnCall(i int, result1 map[string]string) {
fake.folderPasswordsMutex.Lock()
defer fake.folderPasswordsMutex.Unlock()
fake.FolderPasswordsStub = nil
if fake.folderPasswordsReturnsOnCall == nil {
fake.folderPasswordsReturnsOnCall = make(map[int]struct {
result1 map[string]string
})
}
fake.folderPasswordsReturnsOnCall[i] = struct {
result1 map[string]string
}{result1}
}
func (fake *Wrapper) Folders() map[string]config.FolderConfiguration {
fake.foldersMutex.Lock()
ret, specificReturn := fake.foldersReturnsOnCall[len(fake.foldersArgsForCall)]
fake.foldersArgsForCall = append(fake.foldersArgsForCall, struct {
}{})
stub := fake.FoldersStub
fakeReturns := fake.foldersReturns
fake.recordInvocation("Folders", []interface{}{})
fake.foldersMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) FoldersCallCount() int {
fake.foldersMutex.RLock()
defer fake.foldersMutex.RUnlock()
return len(fake.foldersArgsForCall)
}
func (fake *Wrapper) FoldersCalls(stub func() map[string]config.FolderConfiguration) {
fake.foldersMutex.Lock()
defer fake.foldersMutex.Unlock()
fake.FoldersStub = stub
}
func (fake *Wrapper) FoldersReturns(result1 map[string]config.FolderConfiguration) {
fake.foldersMutex.Lock()
defer fake.foldersMutex.Unlock()
fake.FoldersStub = nil
fake.foldersReturns = struct {
result1 map[string]config.FolderConfiguration
}{result1}
}
func (fake *Wrapper) FoldersReturnsOnCall(i int, result1 map[string]config.FolderConfiguration) {
fake.foldersMutex.Lock()
defer fake.foldersMutex.Unlock()
fake.FoldersStub = nil
if fake.foldersReturnsOnCall == nil {
fake.foldersReturnsOnCall = make(map[int]struct {
result1 map[string]config.FolderConfiguration
})
}
fake.foldersReturnsOnCall[i] = struct {
result1 map[string]config.FolderConfiguration
}{result1}
}
func (fake *Wrapper) GUI() config.GUIConfiguration {
fake.gUIMutex.Lock()
ret, specificReturn := fake.gUIReturnsOnCall[len(fake.gUIArgsForCall)]
fake.gUIArgsForCall = append(fake.gUIArgsForCall, struct {
}{})
stub := fake.GUIStub
fakeReturns := fake.gUIReturns
fake.recordInvocation("GUI", []interface{}{})
fake.gUIMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) GUICallCount() int {
fake.gUIMutex.RLock()
defer fake.gUIMutex.RUnlock()
return len(fake.gUIArgsForCall)
}
func (fake *Wrapper) GUICalls(stub func() config.GUIConfiguration) {
fake.gUIMutex.Lock()
defer fake.gUIMutex.Unlock()
fake.GUIStub = stub
}
func (fake *Wrapper) GUIReturns(result1 config.GUIConfiguration) {
fake.gUIMutex.Lock()
defer fake.gUIMutex.Unlock()
fake.GUIStub = nil
fake.gUIReturns = struct {
result1 config.GUIConfiguration
}{result1}
}
func (fake *Wrapper) GUIReturnsOnCall(i int, result1 config.GUIConfiguration) {
fake.gUIMutex.Lock()
defer fake.gUIMutex.Unlock()
fake.GUIStub = nil
if fake.gUIReturnsOnCall == nil {
fake.gUIReturnsOnCall = make(map[int]struct {
result1 config.GUIConfiguration
})
}
fake.gUIReturnsOnCall[i] = struct {
result1 config.GUIConfiguration
}{result1}
}
func (fake *Wrapper) IgnoredDevice(arg1 protocol.DeviceID) bool {
fake.ignoredDeviceMutex.Lock()
ret, specificReturn := fake.ignoredDeviceReturnsOnCall[len(fake.ignoredDeviceArgsForCall)]
fake.ignoredDeviceArgsForCall = append(fake.ignoredDeviceArgsForCall, struct {
arg1 protocol.DeviceID
}{arg1})
stub := fake.IgnoredDeviceStub
fakeReturns := fake.ignoredDeviceReturns
fake.recordInvocation("IgnoredDevice", []interface{}{arg1})
fake.ignoredDeviceMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) IgnoredDeviceCallCount() int {
fake.ignoredDeviceMutex.RLock()
defer fake.ignoredDeviceMutex.RUnlock()
return len(fake.ignoredDeviceArgsForCall)
}
func (fake *Wrapper) IgnoredDeviceCalls(stub func(protocol.DeviceID) bool) {
fake.ignoredDeviceMutex.Lock()
defer fake.ignoredDeviceMutex.Unlock()
fake.IgnoredDeviceStub = stub
}
func (fake *Wrapper) IgnoredDeviceArgsForCall(i int) protocol.DeviceID {
fake.ignoredDeviceMutex.RLock()
defer fake.ignoredDeviceMutex.RUnlock()
argsForCall := fake.ignoredDeviceArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) IgnoredDeviceReturns(result1 bool) {
fake.ignoredDeviceMutex.Lock()
defer fake.ignoredDeviceMutex.Unlock()
fake.IgnoredDeviceStub = nil
fake.ignoredDeviceReturns = struct {
result1 bool
}{result1}
}
func (fake *Wrapper) IgnoredDeviceReturnsOnCall(i int, result1 bool) {
fake.ignoredDeviceMutex.Lock()
defer fake.ignoredDeviceMutex.Unlock()
fake.IgnoredDeviceStub = nil
if fake.ignoredDeviceReturnsOnCall == nil {
fake.ignoredDeviceReturnsOnCall = make(map[int]struct {
result1 bool
})
}
fake.ignoredDeviceReturnsOnCall[i] = struct {
result1 bool
}{result1}
}
func (fake *Wrapper) IgnoredDevices() []config.ObservedDevice {
fake.ignoredDevicesMutex.Lock()
ret, specificReturn := fake.ignoredDevicesReturnsOnCall[len(fake.ignoredDevicesArgsForCall)]
fake.ignoredDevicesArgsForCall = append(fake.ignoredDevicesArgsForCall, struct {
}{})
stub := fake.IgnoredDevicesStub
fakeReturns := fake.ignoredDevicesReturns
fake.recordInvocation("IgnoredDevices", []interface{}{})
fake.ignoredDevicesMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) IgnoredDevicesCallCount() int {
fake.ignoredDevicesMutex.RLock()
defer fake.ignoredDevicesMutex.RUnlock()
return len(fake.ignoredDevicesArgsForCall)
}
func (fake *Wrapper) IgnoredDevicesCalls(stub func() []config.ObservedDevice) {
fake.ignoredDevicesMutex.Lock()
defer fake.ignoredDevicesMutex.Unlock()
fake.IgnoredDevicesStub = stub
}
func (fake *Wrapper) IgnoredDevicesReturns(result1 []config.ObservedDevice) {
fake.ignoredDevicesMutex.Lock()
defer fake.ignoredDevicesMutex.Unlock()
fake.IgnoredDevicesStub = nil
fake.ignoredDevicesReturns = struct {
result1 []config.ObservedDevice
}{result1}
}
func (fake *Wrapper) IgnoredDevicesReturnsOnCall(i int, result1 []config.ObservedDevice) {
fake.ignoredDevicesMutex.Lock()
defer fake.ignoredDevicesMutex.Unlock()
fake.IgnoredDevicesStub = nil
if fake.ignoredDevicesReturnsOnCall == nil {
fake.ignoredDevicesReturnsOnCall = make(map[int]struct {
result1 []config.ObservedDevice
})
}
fake.ignoredDevicesReturnsOnCall[i] = struct {
result1 []config.ObservedDevice
}{result1}
}
func (fake *Wrapper) IgnoredFolder(arg1 protocol.DeviceID, arg2 string) bool {
fake.ignoredFolderMutex.Lock()
ret, specificReturn := fake.ignoredFolderReturnsOnCall[len(fake.ignoredFolderArgsForCall)]
fake.ignoredFolderArgsForCall = append(fake.ignoredFolderArgsForCall, struct {
arg1 protocol.DeviceID
arg2 string
}{arg1, arg2})
stub := fake.IgnoredFolderStub
fakeReturns := fake.ignoredFolderReturns
fake.recordInvocation("IgnoredFolder", []interface{}{arg1, arg2})
fake.ignoredFolderMutex.Unlock()
if stub != nil {
return stub(arg1, arg2)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) IgnoredFolderCallCount() int {
fake.ignoredFolderMutex.RLock()
defer fake.ignoredFolderMutex.RUnlock()
return len(fake.ignoredFolderArgsForCall)
}
func (fake *Wrapper) IgnoredFolderCalls(stub func(protocol.DeviceID, string) bool) {
fake.ignoredFolderMutex.Lock()
defer fake.ignoredFolderMutex.Unlock()
fake.IgnoredFolderStub = stub
}
func (fake *Wrapper) IgnoredFolderArgsForCall(i int) (protocol.DeviceID, string) {
fake.ignoredFolderMutex.RLock()
defer fake.ignoredFolderMutex.RUnlock()
argsForCall := fake.ignoredFolderArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2
}
func (fake *Wrapper) IgnoredFolderReturns(result1 bool) {
fake.ignoredFolderMutex.Lock()
defer fake.ignoredFolderMutex.Unlock()
fake.IgnoredFolderStub = nil
fake.ignoredFolderReturns = struct {
result1 bool
}{result1}
}
func (fake *Wrapper) IgnoredFolderReturnsOnCall(i int, result1 bool) {
fake.ignoredFolderMutex.Lock()
defer fake.ignoredFolderMutex.Unlock()
fake.IgnoredFolderStub = nil
if fake.ignoredFolderReturnsOnCall == nil {
fake.ignoredFolderReturnsOnCall = make(map[int]struct {
result1 bool
})
}
fake.ignoredFolderReturnsOnCall[i] = struct {
result1 bool
}{result1}
}
func (fake *Wrapper) LDAP() config.LDAPConfiguration {
fake.lDAPMutex.Lock()
ret, specificReturn := fake.lDAPReturnsOnCall[len(fake.lDAPArgsForCall)]
fake.lDAPArgsForCall = append(fake.lDAPArgsForCall, struct {
}{})
stub := fake.LDAPStub
fakeReturns := fake.lDAPReturns
fake.recordInvocation("LDAP", []interface{}{})
fake.lDAPMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) LDAPCallCount() int {
fake.lDAPMutex.RLock()
defer fake.lDAPMutex.RUnlock()
return len(fake.lDAPArgsForCall)
}
func (fake *Wrapper) LDAPCalls(stub func() config.LDAPConfiguration) {
fake.lDAPMutex.Lock()
defer fake.lDAPMutex.Unlock()
fake.LDAPStub = stub
}
func (fake *Wrapper) LDAPReturns(result1 config.LDAPConfiguration) {
fake.lDAPMutex.Lock()
defer fake.lDAPMutex.Unlock()
fake.LDAPStub = nil
fake.lDAPReturns = struct {
result1 config.LDAPConfiguration
}{result1}
}
func (fake *Wrapper) LDAPReturnsOnCall(i int, result1 config.LDAPConfiguration) {
fake.lDAPMutex.Lock()
defer fake.lDAPMutex.Unlock()
fake.LDAPStub = nil
if fake.lDAPReturnsOnCall == nil {
fake.lDAPReturnsOnCall = make(map[int]struct {
result1 config.LDAPConfiguration
})
}
fake.lDAPReturnsOnCall[i] = struct {
result1 config.LDAPConfiguration
}{result1}
}
func (fake *Wrapper) Modify(arg1 config.ModifyFunction) (config.Waiter, error) {
fake.modifyMutex.Lock()
ret, specificReturn := fake.modifyReturnsOnCall[len(fake.modifyArgsForCall)]
fake.modifyArgsForCall = append(fake.modifyArgsForCall, struct {
arg1 config.ModifyFunction
}{arg1})
stub := fake.ModifyStub
fakeReturns := fake.modifyReturns
fake.recordInvocation("Modify", []interface{}{arg1})
fake.modifyMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1, ret.result2
}
return fakeReturns.result1, fakeReturns.result2
}
func (fake *Wrapper) ModifyCallCount() int {
fake.modifyMutex.RLock()
defer fake.modifyMutex.RUnlock()
return len(fake.modifyArgsForCall)
}
func (fake *Wrapper) ModifyCalls(stub func(config.ModifyFunction) (config.Waiter, error)) {
fake.modifyMutex.Lock()
defer fake.modifyMutex.Unlock()
fake.ModifyStub = stub
}
func (fake *Wrapper) ModifyArgsForCall(i int) config.ModifyFunction {
fake.modifyMutex.RLock()
defer fake.modifyMutex.RUnlock()
argsForCall := fake.modifyArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) ModifyReturns(result1 config.Waiter, result2 error) {
fake.modifyMutex.Lock()
defer fake.modifyMutex.Unlock()
fake.ModifyStub = nil
fake.modifyReturns = struct {
result1 config.Waiter
result2 error
}{result1, result2}
}
func (fake *Wrapper) ModifyReturnsOnCall(i int, result1 config.Waiter, result2 error) {
fake.modifyMutex.Lock()
defer fake.modifyMutex.Unlock()
fake.ModifyStub = nil
if fake.modifyReturnsOnCall == nil {
fake.modifyReturnsOnCall = make(map[int]struct {
result1 config.Waiter
result2 error
})
}
fake.modifyReturnsOnCall[i] = struct {
result1 config.Waiter
result2 error
}{result1, result2}
}
func (fake *Wrapper) MyID() protocol.DeviceID {
fake.myIDMutex.Lock()
ret, specificReturn := fake.myIDReturnsOnCall[len(fake.myIDArgsForCall)]
fake.myIDArgsForCall = append(fake.myIDArgsForCall, struct {
}{})
stub := fake.MyIDStub
fakeReturns := fake.myIDReturns
fake.recordInvocation("MyID", []interface{}{})
fake.myIDMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) MyIDCallCount() int {
fake.myIDMutex.RLock()
defer fake.myIDMutex.RUnlock()
return len(fake.myIDArgsForCall)
}
func (fake *Wrapper) MyIDCalls(stub func() protocol.DeviceID) {
fake.myIDMutex.Lock()
defer fake.myIDMutex.Unlock()
fake.MyIDStub = stub
}
func (fake *Wrapper) MyIDReturns(result1 protocol.DeviceID) {
fake.myIDMutex.Lock()
defer fake.myIDMutex.Unlock()
fake.MyIDStub = nil
fake.myIDReturns = struct {
result1 protocol.DeviceID
}{result1}
}
func (fake *Wrapper) MyIDReturnsOnCall(i int, result1 protocol.DeviceID) {
fake.myIDMutex.Lock()
defer fake.myIDMutex.Unlock()
fake.MyIDStub = nil
if fake.myIDReturnsOnCall == nil {
fake.myIDReturnsOnCall = make(map[int]struct {
result1 protocol.DeviceID
})
}
fake.myIDReturnsOnCall[i] = struct {
result1 protocol.DeviceID
}{result1}
}
func (fake *Wrapper) Options() config.OptionsConfiguration {
fake.optionsMutex.Lock()
ret, specificReturn := fake.optionsReturnsOnCall[len(fake.optionsArgsForCall)]
fake.optionsArgsForCall = append(fake.optionsArgsForCall, struct {
}{})
stub := fake.OptionsStub
fakeReturns := fake.optionsReturns
fake.recordInvocation("Options", []interface{}{})
fake.optionsMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) OptionsCallCount() int {
fake.optionsMutex.RLock()
defer fake.optionsMutex.RUnlock()
return len(fake.optionsArgsForCall)
}
func (fake *Wrapper) OptionsCalls(stub func() config.OptionsConfiguration) {
fake.optionsMutex.Lock()
defer fake.optionsMutex.Unlock()
fake.OptionsStub = stub
}
func (fake *Wrapper) OptionsReturns(result1 config.OptionsConfiguration) {
fake.optionsMutex.Lock()
defer fake.optionsMutex.Unlock()
fake.OptionsStub = nil
fake.optionsReturns = struct {
result1 config.OptionsConfiguration
}{result1}
}
func (fake *Wrapper) OptionsReturnsOnCall(i int, result1 config.OptionsConfiguration) {
fake.optionsMutex.Lock()
defer fake.optionsMutex.Unlock()
fake.OptionsStub = nil
if fake.optionsReturnsOnCall == nil {
fake.optionsReturnsOnCall = make(map[int]struct {
result1 config.OptionsConfiguration
})
}
fake.optionsReturnsOnCall[i] = struct {
result1 config.OptionsConfiguration
}{result1}
}
func (fake *Wrapper) RawCopy() config.Configuration {
fake.rawCopyMutex.Lock()
ret, specificReturn := fake.rawCopyReturnsOnCall[len(fake.rawCopyArgsForCall)]
fake.rawCopyArgsForCall = append(fake.rawCopyArgsForCall, struct {
}{})
stub := fake.RawCopyStub
fakeReturns := fake.rawCopyReturns
fake.recordInvocation("RawCopy", []interface{}{})
fake.rawCopyMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) RawCopyCallCount() int {
fake.rawCopyMutex.RLock()
defer fake.rawCopyMutex.RUnlock()
return len(fake.rawCopyArgsForCall)
}
func (fake *Wrapper) RawCopyCalls(stub func() config.Configuration) {
fake.rawCopyMutex.Lock()
defer fake.rawCopyMutex.Unlock()
fake.RawCopyStub = stub
}
func (fake *Wrapper) RawCopyReturns(result1 config.Configuration) {
fake.rawCopyMutex.Lock()
defer fake.rawCopyMutex.Unlock()
fake.RawCopyStub = nil
fake.rawCopyReturns = struct {
result1 config.Configuration
}{result1}
}
func (fake *Wrapper) RawCopyReturnsOnCall(i int, result1 config.Configuration) {
fake.rawCopyMutex.Lock()
defer fake.rawCopyMutex.Unlock()
fake.RawCopyStub = nil
if fake.rawCopyReturnsOnCall == nil {
fake.rawCopyReturnsOnCall = make(map[int]struct {
result1 config.Configuration
})
}
fake.rawCopyReturnsOnCall[i] = struct {
result1 config.Configuration
}{result1}
}
func (fake *Wrapper) RemoveDevice(arg1 protocol.DeviceID) (config.Waiter, error) {
fake.removeDeviceMutex.Lock()
ret, specificReturn := fake.removeDeviceReturnsOnCall[len(fake.removeDeviceArgsForCall)]
fake.removeDeviceArgsForCall = append(fake.removeDeviceArgsForCall, struct {
arg1 protocol.DeviceID
}{arg1})
stub := fake.RemoveDeviceStub
fakeReturns := fake.removeDeviceReturns
fake.recordInvocation("RemoveDevice", []interface{}{arg1})
fake.removeDeviceMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1, ret.result2
}
return fakeReturns.result1, fakeReturns.result2
}
func (fake *Wrapper) RemoveDeviceCallCount() int {
fake.removeDeviceMutex.RLock()
defer fake.removeDeviceMutex.RUnlock()
return len(fake.removeDeviceArgsForCall)
}
func (fake *Wrapper) RemoveDeviceCalls(stub func(protocol.DeviceID) (config.Waiter, error)) {
fake.removeDeviceMutex.Lock()
defer fake.removeDeviceMutex.Unlock()
fake.RemoveDeviceStub = stub
}
func (fake *Wrapper) RemoveDeviceArgsForCall(i int) protocol.DeviceID {
fake.removeDeviceMutex.RLock()
defer fake.removeDeviceMutex.RUnlock()
argsForCall := fake.removeDeviceArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) RemoveDeviceReturns(result1 config.Waiter, result2 error) {
fake.removeDeviceMutex.Lock()
defer fake.removeDeviceMutex.Unlock()
fake.RemoveDeviceStub = nil
fake.removeDeviceReturns = struct {
result1 config.Waiter
result2 error
}{result1, result2}
}
func (fake *Wrapper) RemoveDeviceReturnsOnCall(i int, result1 config.Waiter, result2 error) {
fake.removeDeviceMutex.Lock()
defer fake.removeDeviceMutex.Unlock()
fake.RemoveDeviceStub = nil
if fake.removeDeviceReturnsOnCall == nil {
fake.removeDeviceReturnsOnCall = make(map[int]struct {
result1 config.Waiter
result2 error
})
}
fake.removeDeviceReturnsOnCall[i] = struct {
result1 config.Waiter
result2 error
}{result1, result2}
}
func (fake *Wrapper) RemoveFolder(arg1 string) (config.Waiter, error) {
fake.removeFolderMutex.Lock()
ret, specificReturn := fake.removeFolderReturnsOnCall[len(fake.removeFolderArgsForCall)]
fake.removeFolderArgsForCall = append(fake.removeFolderArgsForCall, struct {
arg1 string
}{arg1})
stub := fake.RemoveFolderStub
fakeReturns := fake.removeFolderReturns
fake.recordInvocation("RemoveFolder", []interface{}{arg1})
fake.removeFolderMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1, ret.result2
}
return fakeReturns.result1, fakeReturns.result2
}
func (fake *Wrapper) RemoveFolderCallCount() int {
fake.removeFolderMutex.RLock()
defer fake.removeFolderMutex.RUnlock()
return len(fake.removeFolderArgsForCall)
}
func (fake *Wrapper) RemoveFolderCalls(stub func(string) (config.Waiter, error)) {
fake.removeFolderMutex.Lock()
defer fake.removeFolderMutex.Unlock()
fake.RemoveFolderStub = stub
}
func (fake *Wrapper) RemoveFolderArgsForCall(i int) string {
fake.removeFolderMutex.RLock()
defer fake.removeFolderMutex.RUnlock()
argsForCall := fake.removeFolderArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) RemoveFolderReturns(result1 config.Waiter, result2 error) {
fake.removeFolderMutex.Lock()
defer fake.removeFolderMutex.Unlock()
fake.RemoveFolderStub = nil
fake.removeFolderReturns = struct {
result1 config.Waiter
result2 error
}{result1, result2}
}
func (fake *Wrapper) RemoveFolderReturnsOnCall(i int, result1 config.Waiter, result2 error) {
fake.removeFolderMutex.Lock()
defer fake.removeFolderMutex.Unlock()
fake.RemoveFolderStub = nil
if fake.removeFolderReturnsOnCall == nil {
fake.removeFolderReturnsOnCall = make(map[int]struct {
result1 config.Waiter
result2 error
})
}
fake.removeFolderReturnsOnCall[i] = struct {
result1 config.Waiter
result2 error
}{result1, result2}
}
func (fake *Wrapper) RequiresRestart() bool {
fake.requiresRestartMutex.Lock()
ret, specificReturn := fake.requiresRestartReturnsOnCall[len(fake.requiresRestartArgsForCall)]
fake.requiresRestartArgsForCall = append(fake.requiresRestartArgsForCall, struct {
}{})
stub := fake.RequiresRestartStub
fakeReturns := fake.requiresRestartReturns
fake.recordInvocation("RequiresRestart", []interface{}{})
fake.requiresRestartMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) RequiresRestartCallCount() int {
fake.requiresRestartMutex.RLock()
defer fake.requiresRestartMutex.RUnlock()
return len(fake.requiresRestartArgsForCall)
}
func (fake *Wrapper) RequiresRestartCalls(stub func() bool) {
fake.requiresRestartMutex.Lock()
defer fake.requiresRestartMutex.Unlock()
fake.RequiresRestartStub = stub
}
func (fake *Wrapper) RequiresRestartReturns(result1 bool) {
fake.requiresRestartMutex.Lock()
defer fake.requiresRestartMutex.Unlock()
fake.RequiresRestartStub = nil
fake.requiresRestartReturns = struct {
result1 bool
}{result1}
}
func (fake *Wrapper) RequiresRestartReturnsOnCall(i int, result1 bool) {
fake.requiresRestartMutex.Lock()
defer fake.requiresRestartMutex.Unlock()
fake.RequiresRestartStub = nil
if fake.requiresRestartReturnsOnCall == nil {
fake.requiresRestartReturnsOnCall = make(map[int]struct {
result1 bool
})
}
fake.requiresRestartReturnsOnCall[i] = struct {
result1 bool
}{result1}
}
func (fake *Wrapper) Save() error {
fake.saveMutex.Lock()
ret, specificReturn := fake.saveReturnsOnCall[len(fake.saveArgsForCall)]
fake.saveArgsForCall = append(fake.saveArgsForCall, struct {
}{})
stub := fake.SaveStub
fakeReturns := fake.saveReturns
fake.recordInvocation("Save", []interface{}{})
fake.saveMutex.Unlock()
if stub != nil {
return stub()
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) SaveCallCount() int {
fake.saveMutex.RLock()
defer fake.saveMutex.RUnlock()
return len(fake.saveArgsForCall)
}
func (fake *Wrapper) SaveCalls(stub func() error) {
fake.saveMutex.Lock()
defer fake.saveMutex.Unlock()
fake.SaveStub = stub
}
func (fake *Wrapper) SaveReturns(result1 error) {
fake.saveMutex.Lock()
defer fake.saveMutex.Unlock()
fake.SaveStub = nil
fake.saveReturns = struct {
result1 error
}{result1}
}
func (fake *Wrapper) SaveReturnsOnCall(i int, result1 error) {
fake.saveMutex.Lock()
defer fake.saveMutex.Unlock()
fake.SaveStub = nil
if fake.saveReturnsOnCall == nil {
fake.saveReturnsOnCall = make(map[int]struct {
result1 error
})
}
fake.saveReturnsOnCall[i] = struct {
result1 error
}{result1}
}
func (fake *Wrapper) Serve(arg1 context.Context) error {
fake.serveMutex.Lock()
ret, specificReturn := fake.serveReturnsOnCall[len(fake.serveArgsForCall)]
fake.serveArgsForCall = append(fake.serveArgsForCall, struct {
arg1 context.Context
}{arg1})
stub := fake.ServeStub
fakeReturns := fake.serveReturns
fake.recordInvocation("Serve", []interface{}{arg1})
fake.serveMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) ServeCallCount() int {
fake.serveMutex.RLock()
defer fake.serveMutex.RUnlock()
return len(fake.serveArgsForCall)
}
func (fake *Wrapper) ServeCalls(stub func(context.Context) error) {
fake.serveMutex.Lock()
defer fake.serveMutex.Unlock()
fake.ServeStub = stub
}
func (fake *Wrapper) ServeArgsForCall(i int) context.Context {
fake.serveMutex.RLock()
defer fake.serveMutex.RUnlock()
argsForCall := fake.serveArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) ServeReturns(result1 error) {
fake.serveMutex.Lock()
defer fake.serveMutex.Unlock()
fake.ServeStub = nil
fake.serveReturns = struct {
result1 error
}{result1}
}
func (fake *Wrapper) ServeReturnsOnCall(i int, result1 error) {
fake.serveMutex.Lock()
defer fake.serveMutex.Unlock()
fake.ServeStub = nil
if fake.serveReturnsOnCall == nil {
fake.serveReturnsOnCall = make(map[int]struct {
result1 error
})
}
fake.serveReturnsOnCall[i] = struct {
result1 error
}{result1}
}
func (fake *Wrapper) Subscribe(arg1 config.Committer) config.Configuration {
fake.subscribeMutex.Lock()
ret, specificReturn := fake.subscribeReturnsOnCall[len(fake.subscribeArgsForCall)]
fake.subscribeArgsForCall = append(fake.subscribeArgsForCall, struct {
arg1 config.Committer
}{arg1})
stub := fake.SubscribeStub
fakeReturns := fake.subscribeReturns
fake.recordInvocation("Subscribe", []interface{}{arg1})
fake.subscribeMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *Wrapper) SubscribeCallCount() int {
fake.subscribeMutex.RLock()
defer fake.subscribeMutex.RUnlock()
return len(fake.subscribeArgsForCall)
}
func (fake *Wrapper) SubscribeCalls(stub func(config.Committer) config.Configuration) {
fake.subscribeMutex.Lock()
defer fake.subscribeMutex.Unlock()
fake.SubscribeStub = stub
}
func (fake *Wrapper) SubscribeArgsForCall(i int) config.Committer {
fake.subscribeMutex.RLock()
defer fake.subscribeMutex.RUnlock()
argsForCall := fake.subscribeArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) SubscribeReturns(result1 config.Configuration) {
fake.subscribeMutex.Lock()
defer fake.subscribeMutex.Unlock()
fake.SubscribeStub = nil
fake.subscribeReturns = struct {
result1 config.Configuration
}{result1}
}
func (fake *Wrapper) SubscribeReturnsOnCall(i int, result1 config.Configuration) {
fake.subscribeMutex.Lock()
defer fake.subscribeMutex.Unlock()
fake.SubscribeStub = nil
if fake.subscribeReturnsOnCall == nil {
fake.subscribeReturnsOnCall = make(map[int]struct {
result1 config.Configuration
})
}
fake.subscribeReturnsOnCall[i] = struct {
result1 config.Configuration
}{result1}
}
func (fake *Wrapper) Unsubscribe(arg1 config.Committer) {
fake.unsubscribeMutex.Lock()
fake.unsubscribeArgsForCall = append(fake.unsubscribeArgsForCall, struct {
arg1 config.Committer
}{arg1})
stub := fake.UnsubscribeStub
fake.recordInvocation("Unsubscribe", []interface{}{arg1})
fake.unsubscribeMutex.Unlock()
if stub != nil {
fake.UnsubscribeStub(arg1)
}
}
func (fake *Wrapper) UnsubscribeCallCount() int {
fake.unsubscribeMutex.RLock()
defer fake.unsubscribeMutex.RUnlock()
return len(fake.unsubscribeArgsForCall)
}
func (fake *Wrapper) UnsubscribeCalls(stub func(config.Committer)) {
fake.unsubscribeMutex.Lock()
defer fake.unsubscribeMutex.Unlock()
fake.UnsubscribeStub = stub
}
func (fake *Wrapper) UnsubscribeArgsForCall(i int) config.Committer {
fake.unsubscribeMutex.RLock()
defer fake.unsubscribeMutex.RUnlock()
argsForCall := fake.unsubscribeArgsForCall[i]
return argsForCall.arg1
}
func (fake *Wrapper) Invocations() map[string][][]interface{} {
fake.invocationsMutex.RLock()
defer fake.invocationsMutex.RUnlock()
fake.configPathMutex.RLock()
defer fake.configPathMutex.RUnlock()
fake.defaultDeviceMutex.RLock()
defer fake.defaultDeviceMutex.RUnlock()
fake.defaultFolderMutex.RLock()
defer fake.defaultFolderMutex.RUnlock()
fake.deviceMutex.RLock()
defer fake.deviceMutex.RUnlock()
fake.deviceListMutex.RLock()
defer fake.deviceListMutex.RUnlock()
fake.devicesMutex.RLock()
defer fake.devicesMutex.RUnlock()
fake.folderMutex.RLock()
defer fake.folderMutex.RUnlock()
fake.folderListMutex.RLock()
defer fake.folderListMutex.RUnlock()
fake.folderPasswordsMutex.RLock()
defer fake.folderPasswordsMutex.RUnlock()
fake.foldersMutex.RLock()
defer fake.foldersMutex.RUnlock()
fake.gUIMutex.RLock()
defer fake.gUIMutex.RUnlock()
fake.ignoredDeviceMutex.RLock()
defer fake.ignoredDeviceMutex.RUnlock()
fake.ignoredDevicesMutex.RLock()
defer fake.ignoredDevicesMutex.RUnlock()
fake.ignoredFolderMutex.RLock()
defer fake.ignoredFolderMutex.RUnlock()
fake.lDAPMutex.RLock()
defer fake.lDAPMutex.RUnlock()
fake.modifyMutex.RLock()
defer fake.modifyMutex.RUnlock()
fake.myIDMutex.RLock()
defer fake.myIDMutex.RUnlock()
fake.optionsMutex.RLock()
defer fake.optionsMutex.RUnlock()
fake.rawCopyMutex.RLock()
defer fake.rawCopyMutex.RUnlock()
fake.removeDeviceMutex.RLock()
defer fake.removeDeviceMutex.RUnlock()
fake.removeFolderMutex.RLock()
defer fake.removeFolderMutex.RUnlock()
fake.requiresRestartMutex.RLock()
defer fake.requiresRestartMutex.RUnlock()
fake.saveMutex.RLock()
defer fake.saveMutex.RUnlock()
fake.serveMutex.RLock()
defer fake.serveMutex.RUnlock()
fake.subscribeMutex.RLock()
defer fake.subscribeMutex.RUnlock()
fake.unsubscribeMutex.RLock()
defer fake.unsubscribeMutex.RUnlock()
copiedInvocations := map[string][][]interface{}{}
for key, value := range fake.invocations {
copiedInvocations[key] = value
}
return copiedInvocations
}
func (fake *Wrapper) recordInvocation(key string, args []interface{}) {
fake.invocationsMutex.Lock()
defer fake.invocationsMutex.Unlock()
if fake.invocations == nil {
fake.invocations = map[string][][]interface{}{}
}
if fake.invocations[key] == nil {
fake.invocations[key] = [][]interface{}{}
}
fake.invocations[key] = append(fake.invocations[key], args)
}
var _ config.Wrapper = new(Wrapper)