1// Code generated by counterfeiter. DO NOT EDIT.
2package mocks
3
4import (
5	"context"
6	"sync"
7
8	"github.com/syncthing/syncthing/lib/discover"
9	"github.com/syncthing/syncthing/lib/protocol"
10)
11
12type Manager struct {
13	CacheStub        func() map[protocol.DeviceID]discover.CacheEntry
14	cacheMutex       sync.RWMutex
15	cacheArgsForCall []struct {
16	}
17	cacheReturns struct {
18		result1 map[protocol.DeviceID]discover.CacheEntry
19	}
20	cacheReturnsOnCall map[int]struct {
21		result1 map[protocol.DeviceID]discover.CacheEntry
22	}
23	ChildErrorsStub        func() map[string]error
24	childErrorsMutex       sync.RWMutex
25	childErrorsArgsForCall []struct {
26	}
27	childErrorsReturns struct {
28		result1 map[string]error
29	}
30	childErrorsReturnsOnCall map[int]struct {
31		result1 map[string]error
32	}
33	ErrorStub        func() error
34	errorMutex       sync.RWMutex
35	errorArgsForCall []struct {
36	}
37	errorReturns struct {
38		result1 error
39	}
40	errorReturnsOnCall map[int]struct {
41		result1 error
42	}
43	LookupStub        func(context.Context, protocol.DeviceID) ([]string, error)
44	lookupMutex       sync.RWMutex
45	lookupArgsForCall []struct {
46		arg1 context.Context
47		arg2 protocol.DeviceID
48	}
49	lookupReturns struct {
50		result1 []string
51		result2 error
52	}
53	lookupReturnsOnCall map[int]struct {
54		result1 []string
55		result2 error
56	}
57	ServeStub        func(context.Context) error
58	serveMutex       sync.RWMutex
59	serveArgsForCall []struct {
60		arg1 context.Context
61	}
62	serveReturns struct {
63		result1 error
64	}
65	serveReturnsOnCall map[int]struct {
66		result1 error
67	}
68	StringStub        func() string
69	stringMutex       sync.RWMutex
70	stringArgsForCall []struct {
71	}
72	stringReturns struct {
73		result1 string
74	}
75	stringReturnsOnCall map[int]struct {
76		result1 string
77	}
78	invocations      map[string][][]interface{}
79	invocationsMutex sync.RWMutex
80}
81
82func (fake *Manager) Cache() map[protocol.DeviceID]discover.CacheEntry {
83	fake.cacheMutex.Lock()
84	ret, specificReturn := fake.cacheReturnsOnCall[len(fake.cacheArgsForCall)]
85	fake.cacheArgsForCall = append(fake.cacheArgsForCall, struct {
86	}{})
87	stub := fake.CacheStub
88	fakeReturns := fake.cacheReturns
89	fake.recordInvocation("Cache", []interface{}{})
90	fake.cacheMutex.Unlock()
91	if stub != nil {
92		return stub()
93	}
94	if specificReturn {
95		return ret.result1
96	}
97	return fakeReturns.result1
98}
99
100func (fake *Manager) CacheCallCount() int {
101	fake.cacheMutex.RLock()
102	defer fake.cacheMutex.RUnlock()
103	return len(fake.cacheArgsForCall)
104}
105
106func (fake *Manager) CacheCalls(stub func() map[protocol.DeviceID]discover.CacheEntry) {
107	fake.cacheMutex.Lock()
108	defer fake.cacheMutex.Unlock()
109	fake.CacheStub = stub
110}
111
112func (fake *Manager) CacheReturns(result1 map[protocol.DeviceID]discover.CacheEntry) {
113	fake.cacheMutex.Lock()
114	defer fake.cacheMutex.Unlock()
115	fake.CacheStub = nil
116	fake.cacheReturns = struct {
117		result1 map[protocol.DeviceID]discover.CacheEntry
118	}{result1}
119}
120
121func (fake *Manager) CacheReturnsOnCall(i int, result1 map[protocol.DeviceID]discover.CacheEntry) {
122	fake.cacheMutex.Lock()
123	defer fake.cacheMutex.Unlock()
124	fake.CacheStub = nil
125	if fake.cacheReturnsOnCall == nil {
126		fake.cacheReturnsOnCall = make(map[int]struct {
127			result1 map[protocol.DeviceID]discover.CacheEntry
128		})
129	}
130	fake.cacheReturnsOnCall[i] = struct {
131		result1 map[protocol.DeviceID]discover.CacheEntry
132	}{result1}
133}
134
135func (fake *Manager) ChildErrors() map[string]error {
136	fake.childErrorsMutex.Lock()
137	ret, specificReturn := fake.childErrorsReturnsOnCall[len(fake.childErrorsArgsForCall)]
138	fake.childErrorsArgsForCall = append(fake.childErrorsArgsForCall, struct {
139	}{})
140	stub := fake.ChildErrorsStub
141	fakeReturns := fake.childErrorsReturns
142	fake.recordInvocation("ChildErrors", []interface{}{})
143	fake.childErrorsMutex.Unlock()
144	if stub != nil {
145		return stub()
146	}
147	if specificReturn {
148		return ret.result1
149	}
150	return fakeReturns.result1
151}
152
153func (fake *Manager) ChildErrorsCallCount() int {
154	fake.childErrorsMutex.RLock()
155	defer fake.childErrorsMutex.RUnlock()
156	return len(fake.childErrorsArgsForCall)
157}
158
159func (fake *Manager) ChildErrorsCalls(stub func() map[string]error) {
160	fake.childErrorsMutex.Lock()
161	defer fake.childErrorsMutex.Unlock()
162	fake.ChildErrorsStub = stub
163}
164
165func (fake *Manager) ChildErrorsReturns(result1 map[string]error) {
166	fake.childErrorsMutex.Lock()
167	defer fake.childErrorsMutex.Unlock()
168	fake.ChildErrorsStub = nil
169	fake.childErrorsReturns = struct {
170		result1 map[string]error
171	}{result1}
172}
173
174func (fake *Manager) ChildErrorsReturnsOnCall(i int, result1 map[string]error) {
175	fake.childErrorsMutex.Lock()
176	defer fake.childErrorsMutex.Unlock()
177	fake.ChildErrorsStub = nil
178	if fake.childErrorsReturnsOnCall == nil {
179		fake.childErrorsReturnsOnCall = make(map[int]struct {
180			result1 map[string]error
181		})
182	}
183	fake.childErrorsReturnsOnCall[i] = struct {
184		result1 map[string]error
185	}{result1}
186}
187
188func (fake *Manager) Error() error {
189	fake.errorMutex.Lock()
190	ret, specificReturn := fake.errorReturnsOnCall[len(fake.errorArgsForCall)]
191	fake.errorArgsForCall = append(fake.errorArgsForCall, struct {
192	}{})
193	stub := fake.ErrorStub
194	fakeReturns := fake.errorReturns
195	fake.recordInvocation("Error", []interface{}{})
196	fake.errorMutex.Unlock()
197	if stub != nil {
198		return stub()
199	}
200	if specificReturn {
201		return ret.result1
202	}
203	return fakeReturns.result1
204}
205
206func (fake *Manager) ErrorCallCount() int {
207	fake.errorMutex.RLock()
208	defer fake.errorMutex.RUnlock()
209	return len(fake.errorArgsForCall)
210}
211
212func (fake *Manager) ErrorCalls(stub func() error) {
213	fake.errorMutex.Lock()
214	defer fake.errorMutex.Unlock()
215	fake.ErrorStub = stub
216}
217
218func (fake *Manager) ErrorReturns(result1 error) {
219	fake.errorMutex.Lock()
220	defer fake.errorMutex.Unlock()
221	fake.ErrorStub = nil
222	fake.errorReturns = struct {
223		result1 error
224	}{result1}
225}
226
227func (fake *Manager) ErrorReturnsOnCall(i int, result1 error) {
228	fake.errorMutex.Lock()
229	defer fake.errorMutex.Unlock()
230	fake.ErrorStub = nil
231	if fake.errorReturnsOnCall == nil {
232		fake.errorReturnsOnCall = make(map[int]struct {
233			result1 error
234		})
235	}
236	fake.errorReturnsOnCall[i] = struct {
237		result1 error
238	}{result1}
239}
240
241func (fake *Manager) Lookup(arg1 context.Context, arg2 protocol.DeviceID) ([]string, error) {
242	fake.lookupMutex.Lock()
243	ret, specificReturn := fake.lookupReturnsOnCall[len(fake.lookupArgsForCall)]
244	fake.lookupArgsForCall = append(fake.lookupArgsForCall, struct {
245		arg1 context.Context
246		arg2 protocol.DeviceID
247	}{arg1, arg2})
248	stub := fake.LookupStub
249	fakeReturns := fake.lookupReturns
250	fake.recordInvocation("Lookup", []interface{}{arg1, arg2})
251	fake.lookupMutex.Unlock()
252	if stub != nil {
253		return stub(arg1, arg2)
254	}
255	if specificReturn {
256		return ret.result1, ret.result2
257	}
258	return fakeReturns.result1, fakeReturns.result2
259}
260
261func (fake *Manager) LookupCallCount() int {
262	fake.lookupMutex.RLock()
263	defer fake.lookupMutex.RUnlock()
264	return len(fake.lookupArgsForCall)
265}
266
267func (fake *Manager) LookupCalls(stub func(context.Context, protocol.DeviceID) ([]string, error)) {
268	fake.lookupMutex.Lock()
269	defer fake.lookupMutex.Unlock()
270	fake.LookupStub = stub
271}
272
273func (fake *Manager) LookupArgsForCall(i int) (context.Context, protocol.DeviceID) {
274	fake.lookupMutex.RLock()
275	defer fake.lookupMutex.RUnlock()
276	argsForCall := fake.lookupArgsForCall[i]
277	return argsForCall.arg1, argsForCall.arg2
278}
279
280func (fake *Manager) LookupReturns(result1 []string, result2 error) {
281	fake.lookupMutex.Lock()
282	defer fake.lookupMutex.Unlock()
283	fake.LookupStub = nil
284	fake.lookupReturns = struct {
285		result1 []string
286		result2 error
287	}{result1, result2}
288}
289
290func (fake *Manager) LookupReturnsOnCall(i int, result1 []string, result2 error) {
291	fake.lookupMutex.Lock()
292	defer fake.lookupMutex.Unlock()
293	fake.LookupStub = nil
294	if fake.lookupReturnsOnCall == nil {
295		fake.lookupReturnsOnCall = make(map[int]struct {
296			result1 []string
297			result2 error
298		})
299	}
300	fake.lookupReturnsOnCall[i] = struct {
301		result1 []string
302		result2 error
303	}{result1, result2}
304}
305
306func (fake *Manager) Serve(arg1 context.Context) error {
307	fake.serveMutex.Lock()
308	ret, specificReturn := fake.serveReturnsOnCall[len(fake.serveArgsForCall)]
309	fake.serveArgsForCall = append(fake.serveArgsForCall, struct {
310		arg1 context.Context
311	}{arg1})
312	stub := fake.ServeStub
313	fakeReturns := fake.serveReturns
314	fake.recordInvocation("Serve", []interface{}{arg1})
315	fake.serveMutex.Unlock()
316	if stub != nil {
317		return stub(arg1)
318	}
319	if specificReturn {
320		return ret.result1
321	}
322	return fakeReturns.result1
323}
324
325func (fake *Manager) ServeCallCount() int {
326	fake.serveMutex.RLock()
327	defer fake.serveMutex.RUnlock()
328	return len(fake.serveArgsForCall)
329}
330
331func (fake *Manager) ServeCalls(stub func(context.Context) error) {
332	fake.serveMutex.Lock()
333	defer fake.serveMutex.Unlock()
334	fake.ServeStub = stub
335}
336
337func (fake *Manager) ServeArgsForCall(i int) context.Context {
338	fake.serveMutex.RLock()
339	defer fake.serveMutex.RUnlock()
340	argsForCall := fake.serveArgsForCall[i]
341	return argsForCall.arg1
342}
343
344func (fake *Manager) ServeReturns(result1 error) {
345	fake.serveMutex.Lock()
346	defer fake.serveMutex.Unlock()
347	fake.ServeStub = nil
348	fake.serveReturns = struct {
349		result1 error
350	}{result1}
351}
352
353func (fake *Manager) ServeReturnsOnCall(i int, result1 error) {
354	fake.serveMutex.Lock()
355	defer fake.serveMutex.Unlock()
356	fake.ServeStub = nil
357	if fake.serveReturnsOnCall == nil {
358		fake.serveReturnsOnCall = make(map[int]struct {
359			result1 error
360		})
361	}
362	fake.serveReturnsOnCall[i] = struct {
363		result1 error
364	}{result1}
365}
366
367func (fake *Manager) String() string {
368	fake.stringMutex.Lock()
369	ret, specificReturn := fake.stringReturnsOnCall[len(fake.stringArgsForCall)]
370	fake.stringArgsForCall = append(fake.stringArgsForCall, struct {
371	}{})
372	stub := fake.StringStub
373	fakeReturns := fake.stringReturns
374	fake.recordInvocation("String", []interface{}{})
375	fake.stringMutex.Unlock()
376	if stub != nil {
377		return stub()
378	}
379	if specificReturn {
380		return ret.result1
381	}
382	return fakeReturns.result1
383}
384
385func (fake *Manager) StringCallCount() int {
386	fake.stringMutex.RLock()
387	defer fake.stringMutex.RUnlock()
388	return len(fake.stringArgsForCall)
389}
390
391func (fake *Manager) StringCalls(stub func() string) {
392	fake.stringMutex.Lock()
393	defer fake.stringMutex.Unlock()
394	fake.StringStub = stub
395}
396
397func (fake *Manager) StringReturns(result1 string) {
398	fake.stringMutex.Lock()
399	defer fake.stringMutex.Unlock()
400	fake.StringStub = nil
401	fake.stringReturns = struct {
402		result1 string
403	}{result1}
404}
405
406func (fake *Manager) StringReturnsOnCall(i int, result1 string) {
407	fake.stringMutex.Lock()
408	defer fake.stringMutex.Unlock()
409	fake.StringStub = nil
410	if fake.stringReturnsOnCall == nil {
411		fake.stringReturnsOnCall = make(map[int]struct {
412			result1 string
413		})
414	}
415	fake.stringReturnsOnCall[i] = struct {
416		result1 string
417	}{result1}
418}
419
420func (fake *Manager) Invocations() map[string][][]interface{} {
421	fake.invocationsMutex.RLock()
422	defer fake.invocationsMutex.RUnlock()
423	fake.cacheMutex.RLock()
424	defer fake.cacheMutex.RUnlock()
425	fake.childErrorsMutex.RLock()
426	defer fake.childErrorsMutex.RUnlock()
427	fake.errorMutex.RLock()
428	defer fake.errorMutex.RUnlock()
429	fake.lookupMutex.RLock()
430	defer fake.lookupMutex.RUnlock()
431	fake.serveMutex.RLock()
432	defer fake.serveMutex.RUnlock()
433	fake.stringMutex.RLock()
434	defer fake.stringMutex.RUnlock()
435	copiedInvocations := map[string][][]interface{}{}
436	for key, value := range fake.invocations {
437		copiedInvocations[key] = value
438	}
439	return copiedInvocations
440}
441
442func (fake *Manager) recordInvocation(key string, args []interface{}) {
443	fake.invocationsMutex.Lock()
444	defer fake.invocationsMutex.Unlock()
445	if fake.invocations == nil {
446		fake.invocations = map[string][][]interface{}{}
447	}
448	if fake.invocations[key] == nil {
449		fake.invocations[key] = [][]interface{}{}
450	}
451	fake.invocations[key] = append(fake.invocations[key], args)
452}
453
454var _ discover.Manager = new(Manager)
455