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