1// Code generated by counterfeiter. DO NOT EDIT.
2package fakes
3
4import (
5	"sync"
6
7	"istio.io/istio/pilot/pkg/model"
8	"istio.io/istio/pkg/config/schema/collection"
9	"istio.io/istio/pkg/config/schema/resource"
10	"istio.io/pkg/ledger"
11)
12
13type ConfigStoreCache struct {
14	CreateStub        func(model.Config) (string, error)
15	createMutex       sync.RWMutex
16	createArgsForCall []struct {
17		arg1 model.Config
18	}
19	createReturns struct {
20		result1 string
21		result2 error
22	}
23	createReturnsOnCall map[int]struct {
24		result1 string
25		result2 error
26	}
27	DeleteStub        func(resource.GroupVersionKind, string, string) error
28	deleteMutex       sync.RWMutex
29	deleteArgsForCall []struct {
30		arg1 resource.GroupVersionKind
31		arg2 string
32		arg3 string
33	}
34	deleteReturns struct {
35		result1 error
36	}
37	deleteReturnsOnCall map[int]struct {
38		result1 error
39	}
40	GetStub        func(resource.GroupVersionKind, string, string) *model.Config
41	getMutex       sync.RWMutex
42	getArgsForCall []struct {
43		arg1 resource.GroupVersionKind
44		arg2 string
45		arg3 string
46	}
47	getReturns struct {
48		result1 *model.Config
49	}
50	getReturnsOnCall map[int]struct {
51		result1 *model.Config
52	}
53	GetLedgerStub        func() ledger.Ledger
54	getLedgerMutex       sync.RWMutex
55	getLedgerArgsForCall []struct {
56	}
57	getLedgerReturns struct {
58		result1 ledger.Ledger
59	}
60	getLedgerReturnsOnCall map[int]struct {
61		result1 ledger.Ledger
62	}
63	GetResourceAtVersionStub        func(string, string) (string, error)
64	getResourceAtVersionMutex       sync.RWMutex
65	getResourceAtVersionArgsForCall []struct {
66		arg1 string
67		arg2 string
68	}
69	getResourceAtVersionReturns struct {
70		result1 string
71		result2 error
72	}
73	getResourceAtVersionReturnsOnCall map[int]struct {
74		result1 string
75		result2 error
76	}
77	HasSyncedStub        func() bool
78	hasSyncedMutex       sync.RWMutex
79	hasSyncedArgsForCall []struct {
80	}
81	hasSyncedReturns struct {
82		result1 bool
83	}
84	hasSyncedReturnsOnCall map[int]struct {
85		result1 bool
86	}
87	ListStub        func(resource.GroupVersionKind, string) ([]model.Config, error)
88	listMutex       sync.RWMutex
89	listArgsForCall []struct {
90		arg1 resource.GroupVersionKind
91		arg2 string
92	}
93	listReturns struct {
94		result1 []model.Config
95		result2 error
96	}
97	listReturnsOnCall map[int]struct {
98		result1 []model.Config
99		result2 error
100	}
101	RegisterEventHandlerStub        func(resource.GroupVersionKind, func(model.Config, model.Config, model.Event))
102	registerEventHandlerMutex       sync.RWMutex
103	registerEventHandlerArgsForCall []struct {
104		arg1 resource.GroupVersionKind
105		arg2 func(model.Config, model.Config, model.Event)
106	}
107	RunStub        func(<-chan struct{})
108	runMutex       sync.RWMutex
109	runArgsForCall []struct {
110		arg1 <-chan struct{}
111	}
112	SchemasStub        func() collection.Schemas
113	schemasMutex       sync.RWMutex
114	schemasArgsForCall []struct {
115	}
116	schemasReturns struct {
117		result1 collection.Schemas
118	}
119	schemasReturnsOnCall map[int]struct {
120		result1 collection.Schemas
121	}
122	SetLedgerStub        func(ledger.Ledger) error
123	setLedgerMutex       sync.RWMutex
124	setLedgerArgsForCall []struct {
125		arg1 ledger.Ledger
126	}
127	setLedgerReturns struct {
128		result1 error
129	}
130	setLedgerReturnsOnCall map[int]struct {
131		result1 error
132	}
133	UpdateStub        func(model.Config) (string, error)
134	updateMutex       sync.RWMutex
135	updateArgsForCall []struct {
136		arg1 model.Config
137	}
138	updateReturns struct {
139		result1 string
140		result2 error
141	}
142	updateReturnsOnCall map[int]struct {
143		result1 string
144		result2 error
145	}
146	VersionStub        func() string
147	versionMutex       sync.RWMutex
148	versionArgsForCall []struct {
149	}
150	versionReturns struct {
151		result1 string
152	}
153	versionReturnsOnCall map[int]struct {
154		result1 string
155	}
156	invocations      map[string][][]interface{}
157	invocationsMutex sync.RWMutex
158}
159
160func (fake *ConfigStoreCache) Create(arg1 model.Config) (string, error) {
161	fake.createMutex.Lock()
162	ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)]
163	fake.createArgsForCall = append(fake.createArgsForCall, struct {
164		arg1 model.Config
165	}{arg1})
166	fake.recordInvocation("Create", []interface{}{arg1})
167	fake.createMutex.Unlock()
168	if fake.CreateStub != nil {
169		return fake.CreateStub(arg1)
170	}
171	if specificReturn {
172		return ret.result1, ret.result2
173	}
174	fakeReturns := fake.createReturns
175	return fakeReturns.result1, fakeReturns.result2
176}
177
178func (fake *ConfigStoreCache) CreateCallCount() int {
179	fake.createMutex.RLock()
180	defer fake.createMutex.RUnlock()
181	return len(fake.createArgsForCall)
182}
183
184func (fake *ConfigStoreCache) CreateCalls(stub func(model.Config) (string, error)) {
185	fake.createMutex.Lock()
186	defer fake.createMutex.Unlock()
187	fake.CreateStub = stub
188}
189
190func (fake *ConfigStoreCache) CreateArgsForCall(i int) model.Config {
191	fake.createMutex.RLock()
192	defer fake.createMutex.RUnlock()
193	argsForCall := fake.createArgsForCall[i]
194	return argsForCall.arg1
195}
196
197func (fake *ConfigStoreCache) CreateReturns(result1 string, result2 error) {
198	fake.createMutex.Lock()
199	defer fake.createMutex.Unlock()
200	fake.CreateStub = nil
201	fake.createReturns = struct {
202		result1 string
203		result2 error
204	}{result1, result2}
205}
206
207func (fake *ConfigStoreCache) CreateReturnsOnCall(i int, result1 string, result2 error) {
208	fake.createMutex.Lock()
209	defer fake.createMutex.Unlock()
210	fake.CreateStub = nil
211	if fake.createReturnsOnCall == nil {
212		fake.createReturnsOnCall = make(map[int]struct {
213			result1 string
214			result2 error
215		})
216	}
217	fake.createReturnsOnCall[i] = struct {
218		result1 string
219		result2 error
220	}{result1, result2}
221}
222
223func (fake *ConfigStoreCache) Delete(arg1 resource.GroupVersionKind, arg2 string, arg3 string) error {
224	fake.deleteMutex.Lock()
225	ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)]
226	fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct {
227		arg1 resource.GroupVersionKind
228		arg2 string
229		arg3 string
230	}{arg1, arg2, arg3})
231	fake.recordInvocation("Delete", []interface{}{arg1, arg2, arg3})
232	fake.deleteMutex.Unlock()
233	if fake.DeleteStub != nil {
234		return fake.DeleteStub(arg1, arg2, arg3)
235	}
236	if specificReturn {
237		return ret.result1
238	}
239	fakeReturns := fake.deleteReturns
240	return fakeReturns.result1
241}
242
243func (fake *ConfigStoreCache) DeleteCallCount() int {
244	fake.deleteMutex.RLock()
245	defer fake.deleteMutex.RUnlock()
246	return len(fake.deleteArgsForCall)
247}
248
249func (fake *ConfigStoreCache) DeleteCalls(stub func(resource.GroupVersionKind, string, string) error) {
250	fake.deleteMutex.Lock()
251	defer fake.deleteMutex.Unlock()
252	fake.DeleteStub = stub
253}
254
255func (fake *ConfigStoreCache) DeleteArgsForCall(i int) (resource.GroupVersionKind, string, string) {
256	fake.deleteMutex.RLock()
257	defer fake.deleteMutex.RUnlock()
258	argsForCall := fake.deleteArgsForCall[i]
259	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
260}
261
262func (fake *ConfigStoreCache) DeleteReturns(result1 error) {
263	fake.deleteMutex.Lock()
264	defer fake.deleteMutex.Unlock()
265	fake.DeleteStub = nil
266	fake.deleteReturns = struct {
267		result1 error
268	}{result1}
269}
270
271func (fake *ConfigStoreCache) DeleteReturnsOnCall(i int, result1 error) {
272	fake.deleteMutex.Lock()
273	defer fake.deleteMutex.Unlock()
274	fake.DeleteStub = nil
275	if fake.deleteReturnsOnCall == nil {
276		fake.deleteReturnsOnCall = make(map[int]struct {
277			result1 error
278		})
279	}
280	fake.deleteReturnsOnCall[i] = struct {
281		result1 error
282	}{result1}
283}
284
285func (fake *ConfigStoreCache) Get(arg1 resource.GroupVersionKind, arg2 string, arg3 string) *model.Config {
286	fake.getMutex.Lock()
287	ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)]
288	fake.getArgsForCall = append(fake.getArgsForCall, struct {
289		arg1 resource.GroupVersionKind
290		arg2 string
291		arg3 string
292	}{arg1, arg2, arg3})
293	fake.recordInvocation("Get", []interface{}{arg1, arg2, arg3})
294	fake.getMutex.Unlock()
295	if fake.GetStub != nil {
296		return fake.GetStub(arg1, arg2, arg3)
297	}
298	if specificReturn {
299		return ret.result1
300	}
301	fakeReturns := fake.getReturns
302	return fakeReturns.result1
303}
304
305func (fake *ConfigStoreCache) GetCallCount() int {
306	fake.getMutex.RLock()
307	defer fake.getMutex.RUnlock()
308	return len(fake.getArgsForCall)
309}
310
311func (fake *ConfigStoreCache) GetCalls(stub func(resource.GroupVersionKind, string, string) *model.Config) {
312	fake.getMutex.Lock()
313	defer fake.getMutex.Unlock()
314	fake.GetStub = stub
315}
316
317func (fake *ConfigStoreCache) GetArgsForCall(i int) (resource.GroupVersionKind, string, string) {
318	fake.getMutex.RLock()
319	defer fake.getMutex.RUnlock()
320	argsForCall := fake.getArgsForCall[i]
321	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
322}
323
324func (fake *ConfigStoreCache) GetReturns(result1 *model.Config) {
325	fake.getMutex.Lock()
326	defer fake.getMutex.Unlock()
327	fake.GetStub = nil
328	fake.getReturns = struct {
329		result1 *model.Config
330	}{result1}
331}
332
333func (fake *ConfigStoreCache) GetReturnsOnCall(i int, result1 *model.Config) {
334	fake.getMutex.Lock()
335	defer fake.getMutex.Unlock()
336	fake.GetStub = nil
337	if fake.getReturnsOnCall == nil {
338		fake.getReturnsOnCall = make(map[int]struct {
339			result1 *model.Config
340		})
341	}
342	fake.getReturnsOnCall[i] = struct {
343		result1 *model.Config
344	}{result1}
345}
346
347func (fake *ConfigStoreCache) GetLedger() ledger.Ledger {
348	fake.getLedgerMutex.Lock()
349	ret, specificReturn := fake.getLedgerReturnsOnCall[len(fake.getLedgerArgsForCall)]
350	fake.getLedgerArgsForCall = append(fake.getLedgerArgsForCall, struct {
351	}{})
352	fake.recordInvocation("GetLedger", []interface{}{})
353	fake.getLedgerMutex.Unlock()
354	if fake.GetLedgerStub != nil {
355		return fake.GetLedgerStub()
356	}
357	if specificReturn {
358		return ret.result1
359	}
360	fakeReturns := fake.getLedgerReturns
361	return fakeReturns.result1
362}
363
364func (fake *ConfigStoreCache) GetLedgerCallCount() int {
365	fake.getLedgerMutex.RLock()
366	defer fake.getLedgerMutex.RUnlock()
367	return len(fake.getLedgerArgsForCall)
368}
369
370func (fake *ConfigStoreCache) GetLedgerCalls(stub func() ledger.Ledger) {
371	fake.getLedgerMutex.Lock()
372	defer fake.getLedgerMutex.Unlock()
373	fake.GetLedgerStub = stub
374}
375
376func (fake *ConfigStoreCache) GetLedgerReturns(result1 ledger.Ledger) {
377	fake.getLedgerMutex.Lock()
378	defer fake.getLedgerMutex.Unlock()
379	fake.GetLedgerStub = nil
380	fake.getLedgerReturns = struct {
381		result1 ledger.Ledger
382	}{result1}
383}
384
385func (fake *ConfigStoreCache) GetLedgerReturnsOnCall(i int, result1 ledger.Ledger) {
386	fake.getLedgerMutex.Lock()
387	defer fake.getLedgerMutex.Unlock()
388	fake.GetLedgerStub = nil
389	if fake.getLedgerReturnsOnCall == nil {
390		fake.getLedgerReturnsOnCall = make(map[int]struct {
391			result1 ledger.Ledger
392		})
393	}
394	fake.getLedgerReturnsOnCall[i] = struct {
395		result1 ledger.Ledger
396	}{result1}
397}
398
399func (fake *ConfigStoreCache) GetResourceAtVersion(arg1 string, arg2 string) (string, error) {
400	fake.getResourceAtVersionMutex.Lock()
401	ret, specificReturn := fake.getResourceAtVersionReturnsOnCall[len(fake.getResourceAtVersionArgsForCall)]
402	fake.getResourceAtVersionArgsForCall = append(fake.getResourceAtVersionArgsForCall, struct {
403		arg1 string
404		arg2 string
405	}{arg1, arg2})
406	fake.recordInvocation("GetResourceAtVersion", []interface{}{arg1, arg2})
407	fake.getResourceAtVersionMutex.Unlock()
408	if fake.GetResourceAtVersionStub != nil {
409		return fake.GetResourceAtVersionStub(arg1, arg2)
410	}
411	if specificReturn {
412		return ret.result1, ret.result2
413	}
414	fakeReturns := fake.getResourceAtVersionReturns
415	return fakeReturns.result1, fakeReturns.result2
416}
417
418func (fake *ConfigStoreCache) GetResourceAtVersionCallCount() int {
419	fake.getResourceAtVersionMutex.RLock()
420	defer fake.getResourceAtVersionMutex.RUnlock()
421	return len(fake.getResourceAtVersionArgsForCall)
422}
423
424func (fake *ConfigStoreCache) GetResourceAtVersionCalls(stub func(string, string) (string, error)) {
425	fake.getResourceAtVersionMutex.Lock()
426	defer fake.getResourceAtVersionMutex.Unlock()
427	fake.GetResourceAtVersionStub = stub
428}
429
430func (fake *ConfigStoreCache) GetResourceAtVersionArgsForCall(i int) (string, string) {
431	fake.getResourceAtVersionMutex.RLock()
432	defer fake.getResourceAtVersionMutex.RUnlock()
433	argsForCall := fake.getResourceAtVersionArgsForCall[i]
434	return argsForCall.arg1, argsForCall.arg2
435}
436
437func (fake *ConfigStoreCache) GetResourceAtVersionReturns(result1 string, result2 error) {
438	fake.getResourceAtVersionMutex.Lock()
439	defer fake.getResourceAtVersionMutex.Unlock()
440	fake.GetResourceAtVersionStub = nil
441	fake.getResourceAtVersionReturns = struct {
442		result1 string
443		result2 error
444	}{result1, result2}
445}
446
447func (fake *ConfigStoreCache) GetResourceAtVersionReturnsOnCall(i int, result1 string, result2 error) {
448	fake.getResourceAtVersionMutex.Lock()
449	defer fake.getResourceAtVersionMutex.Unlock()
450	fake.GetResourceAtVersionStub = nil
451	if fake.getResourceAtVersionReturnsOnCall == nil {
452		fake.getResourceAtVersionReturnsOnCall = make(map[int]struct {
453			result1 string
454			result2 error
455		})
456	}
457	fake.getResourceAtVersionReturnsOnCall[i] = struct {
458		result1 string
459		result2 error
460	}{result1, result2}
461}
462
463func (fake *ConfigStoreCache) HasSynced() bool {
464	fake.hasSyncedMutex.Lock()
465	ret, specificReturn := fake.hasSyncedReturnsOnCall[len(fake.hasSyncedArgsForCall)]
466	fake.hasSyncedArgsForCall = append(fake.hasSyncedArgsForCall, struct {
467	}{})
468	fake.recordInvocation("HasSynced", []interface{}{})
469	fake.hasSyncedMutex.Unlock()
470	if fake.HasSyncedStub != nil {
471		return fake.HasSyncedStub()
472	}
473	if specificReturn {
474		return ret.result1
475	}
476	fakeReturns := fake.hasSyncedReturns
477	return fakeReturns.result1
478}
479
480func (fake *ConfigStoreCache) HasSyncedCallCount() int {
481	fake.hasSyncedMutex.RLock()
482	defer fake.hasSyncedMutex.RUnlock()
483	return len(fake.hasSyncedArgsForCall)
484}
485
486func (fake *ConfigStoreCache) HasSyncedCalls(stub func() bool) {
487	fake.hasSyncedMutex.Lock()
488	defer fake.hasSyncedMutex.Unlock()
489	fake.HasSyncedStub = stub
490}
491
492func (fake *ConfigStoreCache) HasSyncedReturns(result1 bool) {
493	fake.hasSyncedMutex.Lock()
494	defer fake.hasSyncedMutex.Unlock()
495	fake.HasSyncedStub = nil
496	fake.hasSyncedReturns = struct {
497		result1 bool
498	}{result1}
499}
500
501func (fake *ConfigStoreCache) HasSyncedReturnsOnCall(i int, result1 bool) {
502	fake.hasSyncedMutex.Lock()
503	defer fake.hasSyncedMutex.Unlock()
504	fake.HasSyncedStub = nil
505	if fake.hasSyncedReturnsOnCall == nil {
506		fake.hasSyncedReturnsOnCall = make(map[int]struct {
507			result1 bool
508		})
509	}
510	fake.hasSyncedReturnsOnCall[i] = struct {
511		result1 bool
512	}{result1}
513}
514
515func (fake *ConfigStoreCache) List(arg1 resource.GroupVersionKind, arg2 string) ([]model.Config, error) {
516	fake.listMutex.Lock()
517	ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)]
518	fake.listArgsForCall = append(fake.listArgsForCall, struct {
519		arg1 resource.GroupVersionKind
520		arg2 string
521	}{arg1, arg2})
522	fake.recordInvocation("List", []interface{}{arg1, arg2})
523	fake.listMutex.Unlock()
524	if fake.ListStub != nil {
525		return fake.ListStub(arg1, arg2)
526	}
527	if specificReturn {
528		return ret.result1, ret.result2
529	}
530	fakeReturns := fake.listReturns
531	return fakeReturns.result1, fakeReturns.result2
532}
533
534func (fake *ConfigStoreCache) ListCallCount() int {
535	fake.listMutex.RLock()
536	defer fake.listMutex.RUnlock()
537	return len(fake.listArgsForCall)
538}
539
540func (fake *ConfigStoreCache) ListCalls(stub func(resource.GroupVersionKind, string) ([]model.Config, error)) {
541	fake.listMutex.Lock()
542	defer fake.listMutex.Unlock()
543	fake.ListStub = stub
544}
545
546func (fake *ConfigStoreCache) ListArgsForCall(i int) (resource.GroupVersionKind, string) {
547	fake.listMutex.RLock()
548	defer fake.listMutex.RUnlock()
549	argsForCall := fake.listArgsForCall[i]
550	return argsForCall.arg1, argsForCall.arg2
551}
552
553func (fake *ConfigStoreCache) ListReturns(result1 []model.Config, result2 error) {
554	fake.listMutex.Lock()
555	defer fake.listMutex.Unlock()
556	fake.ListStub = nil
557	fake.listReturns = struct {
558		result1 []model.Config
559		result2 error
560	}{result1, result2}
561}
562
563func (fake *ConfigStoreCache) ListReturnsOnCall(i int, result1 []model.Config, result2 error) {
564	fake.listMutex.Lock()
565	defer fake.listMutex.Unlock()
566	fake.ListStub = nil
567	if fake.listReturnsOnCall == nil {
568		fake.listReturnsOnCall = make(map[int]struct {
569			result1 []model.Config
570			result2 error
571		})
572	}
573	fake.listReturnsOnCall[i] = struct {
574		result1 []model.Config
575		result2 error
576	}{result1, result2}
577}
578
579func (fake *ConfigStoreCache) RegisterEventHandler(arg1 resource.GroupVersionKind, arg2 func(model.Config, model.Config, model.Event)) {
580	fake.registerEventHandlerMutex.Lock()
581	fake.registerEventHandlerArgsForCall = append(fake.registerEventHandlerArgsForCall, struct {
582		arg1 resource.GroupVersionKind
583		arg2 func(model.Config, model.Config, model.Event)
584	}{arg1, arg2})
585	fake.recordInvocation("RegisterEventHandler", []interface{}{arg1, arg2})
586	fake.registerEventHandlerMutex.Unlock()
587	if fake.RegisterEventHandlerStub != nil {
588		fake.RegisterEventHandlerStub(arg1, arg2)
589	}
590}
591
592func (fake *ConfigStoreCache) RegisterEventHandlerCallCount() int {
593	fake.registerEventHandlerMutex.RLock()
594	defer fake.registerEventHandlerMutex.RUnlock()
595	return len(fake.registerEventHandlerArgsForCall)
596}
597
598func (fake *ConfigStoreCache) RegisterEventHandlerCalls(stub func(resource.GroupVersionKind, func(model.Config, model.Config, model.Event))) {
599	fake.registerEventHandlerMutex.Lock()
600	defer fake.registerEventHandlerMutex.Unlock()
601	fake.RegisterEventHandlerStub = stub
602}
603
604func (fake *ConfigStoreCache) RegisterEventHandlerArgsForCall(i int) (resource.GroupVersionKind, func(model.Config, model.Config, model.Event)) {
605	fake.registerEventHandlerMutex.RLock()
606	defer fake.registerEventHandlerMutex.RUnlock()
607	argsForCall := fake.registerEventHandlerArgsForCall[i]
608	return argsForCall.arg1, argsForCall.arg2
609}
610
611func (fake *ConfigStoreCache) Run(arg1 <-chan struct{}) {
612	fake.runMutex.Lock()
613	fake.runArgsForCall = append(fake.runArgsForCall, struct {
614		arg1 <-chan struct{}
615	}{arg1})
616	fake.recordInvocation("Run", []interface{}{arg1})
617	fake.runMutex.Unlock()
618	if fake.RunStub != nil {
619		fake.RunStub(arg1)
620	}
621}
622
623func (fake *ConfigStoreCache) RunCallCount() int {
624	fake.runMutex.RLock()
625	defer fake.runMutex.RUnlock()
626	return len(fake.runArgsForCall)
627}
628
629func (fake *ConfigStoreCache) RunCalls(stub func(<-chan struct{})) {
630	fake.runMutex.Lock()
631	defer fake.runMutex.Unlock()
632	fake.RunStub = stub
633}
634
635func (fake *ConfigStoreCache) RunArgsForCall(i int) <-chan struct{} {
636	fake.runMutex.RLock()
637	defer fake.runMutex.RUnlock()
638	argsForCall := fake.runArgsForCall[i]
639	return argsForCall.arg1
640}
641
642func (fake *ConfigStoreCache) Schemas() collection.Schemas {
643	fake.schemasMutex.Lock()
644	ret, specificReturn := fake.schemasReturnsOnCall[len(fake.schemasArgsForCall)]
645	fake.schemasArgsForCall = append(fake.schemasArgsForCall, struct {
646	}{})
647	fake.recordInvocation("Schemas", []interface{}{})
648	fake.schemasMutex.Unlock()
649	if fake.SchemasStub != nil {
650		return fake.SchemasStub()
651	}
652	if specificReturn {
653		return ret.result1
654	}
655	fakeReturns := fake.schemasReturns
656	return fakeReturns.result1
657}
658
659func (fake *ConfigStoreCache) SchemasCallCount() int {
660	fake.schemasMutex.RLock()
661	defer fake.schemasMutex.RUnlock()
662	return len(fake.schemasArgsForCall)
663}
664
665func (fake *ConfigStoreCache) SchemasCalls(stub func() collection.Schemas) {
666	fake.schemasMutex.Lock()
667	defer fake.schemasMutex.Unlock()
668	fake.SchemasStub = stub
669}
670
671func (fake *ConfigStoreCache) SchemasReturns(result1 collection.Schemas) {
672	fake.schemasMutex.Lock()
673	defer fake.schemasMutex.Unlock()
674	fake.SchemasStub = nil
675	fake.schemasReturns = struct {
676		result1 collection.Schemas
677	}{result1}
678}
679
680func (fake *ConfigStoreCache) SchemasReturnsOnCall(i int, result1 collection.Schemas) {
681	fake.schemasMutex.Lock()
682	defer fake.schemasMutex.Unlock()
683	fake.SchemasStub = nil
684	if fake.schemasReturnsOnCall == nil {
685		fake.schemasReturnsOnCall = make(map[int]struct {
686			result1 collection.Schemas
687		})
688	}
689	fake.schemasReturnsOnCall[i] = struct {
690		result1 collection.Schemas
691	}{result1}
692}
693
694func (fake *ConfigStoreCache) SetLedger(arg1 ledger.Ledger) error {
695	fake.setLedgerMutex.Lock()
696	ret, specificReturn := fake.setLedgerReturnsOnCall[len(fake.setLedgerArgsForCall)]
697	fake.setLedgerArgsForCall = append(fake.setLedgerArgsForCall, struct {
698		arg1 ledger.Ledger
699	}{arg1})
700	fake.recordInvocation("SetLedger", []interface{}{arg1})
701	fake.setLedgerMutex.Unlock()
702	if fake.SetLedgerStub != nil {
703		return fake.SetLedgerStub(arg1)
704	}
705	if specificReturn {
706		return ret.result1
707	}
708	fakeReturns := fake.setLedgerReturns
709	return fakeReturns.result1
710}
711
712func (fake *ConfigStoreCache) SetLedgerCallCount() int {
713	fake.setLedgerMutex.RLock()
714	defer fake.setLedgerMutex.RUnlock()
715	return len(fake.setLedgerArgsForCall)
716}
717
718func (fake *ConfigStoreCache) SetLedgerCalls(stub func(ledger.Ledger) error) {
719	fake.setLedgerMutex.Lock()
720	defer fake.setLedgerMutex.Unlock()
721	fake.SetLedgerStub = stub
722}
723
724func (fake *ConfigStoreCache) SetLedgerArgsForCall(i int) ledger.Ledger {
725	fake.setLedgerMutex.RLock()
726	defer fake.setLedgerMutex.RUnlock()
727	argsForCall := fake.setLedgerArgsForCall[i]
728	return argsForCall.arg1
729}
730
731func (fake *ConfigStoreCache) SetLedgerReturns(result1 error) {
732	fake.setLedgerMutex.Lock()
733	defer fake.setLedgerMutex.Unlock()
734	fake.SetLedgerStub = nil
735	fake.setLedgerReturns = struct {
736		result1 error
737	}{result1}
738}
739
740func (fake *ConfigStoreCache) SetLedgerReturnsOnCall(i int, result1 error) {
741	fake.setLedgerMutex.Lock()
742	defer fake.setLedgerMutex.Unlock()
743	fake.SetLedgerStub = nil
744	if fake.setLedgerReturnsOnCall == nil {
745		fake.setLedgerReturnsOnCall = make(map[int]struct {
746			result1 error
747		})
748	}
749	fake.setLedgerReturnsOnCall[i] = struct {
750		result1 error
751	}{result1}
752}
753
754func (fake *ConfigStoreCache) Update(arg1 model.Config) (string, error) {
755	fake.updateMutex.Lock()
756	ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)]
757	fake.updateArgsForCall = append(fake.updateArgsForCall, struct {
758		arg1 model.Config
759	}{arg1})
760	fake.recordInvocation("Update", []interface{}{arg1})
761	fake.updateMutex.Unlock()
762	if fake.UpdateStub != nil {
763		return fake.UpdateStub(arg1)
764	}
765	if specificReturn {
766		return ret.result1, ret.result2
767	}
768	fakeReturns := fake.updateReturns
769	return fakeReturns.result1, fakeReturns.result2
770}
771
772func (fake *ConfigStoreCache) UpdateCallCount() int {
773	fake.updateMutex.RLock()
774	defer fake.updateMutex.RUnlock()
775	return len(fake.updateArgsForCall)
776}
777
778func (fake *ConfigStoreCache) UpdateCalls(stub func(model.Config) (string, error)) {
779	fake.updateMutex.Lock()
780	defer fake.updateMutex.Unlock()
781	fake.UpdateStub = stub
782}
783
784func (fake *ConfigStoreCache) UpdateArgsForCall(i int) model.Config {
785	fake.updateMutex.RLock()
786	defer fake.updateMutex.RUnlock()
787	argsForCall := fake.updateArgsForCall[i]
788	return argsForCall.arg1
789}
790
791func (fake *ConfigStoreCache) UpdateReturns(result1 string, result2 error) {
792	fake.updateMutex.Lock()
793	defer fake.updateMutex.Unlock()
794	fake.UpdateStub = nil
795	fake.updateReturns = struct {
796		result1 string
797		result2 error
798	}{result1, result2}
799}
800
801func (fake *ConfigStoreCache) UpdateReturnsOnCall(i int, result1 string, result2 error) {
802	fake.updateMutex.Lock()
803	defer fake.updateMutex.Unlock()
804	fake.UpdateStub = nil
805	if fake.updateReturnsOnCall == nil {
806		fake.updateReturnsOnCall = make(map[int]struct {
807			result1 string
808			result2 error
809		})
810	}
811	fake.updateReturnsOnCall[i] = struct {
812		result1 string
813		result2 error
814	}{result1, result2}
815}
816
817func (fake *ConfigStoreCache) Version() string {
818	fake.versionMutex.Lock()
819	ret, specificReturn := fake.versionReturnsOnCall[len(fake.versionArgsForCall)]
820	fake.versionArgsForCall = append(fake.versionArgsForCall, struct {
821	}{})
822	fake.recordInvocation("Version", []interface{}{})
823	fake.versionMutex.Unlock()
824	if fake.VersionStub != nil {
825		return fake.VersionStub()
826	}
827	if specificReturn {
828		return ret.result1
829	}
830	fakeReturns := fake.versionReturns
831	return fakeReturns.result1
832}
833
834func (fake *ConfigStoreCache) VersionCallCount() int {
835	fake.versionMutex.RLock()
836	defer fake.versionMutex.RUnlock()
837	return len(fake.versionArgsForCall)
838}
839
840func (fake *ConfigStoreCache) VersionCalls(stub func() string) {
841	fake.versionMutex.Lock()
842	defer fake.versionMutex.Unlock()
843	fake.VersionStub = stub
844}
845
846func (fake *ConfigStoreCache) VersionReturns(result1 string) {
847	fake.versionMutex.Lock()
848	defer fake.versionMutex.Unlock()
849	fake.VersionStub = nil
850	fake.versionReturns = struct {
851		result1 string
852	}{result1}
853}
854
855func (fake *ConfigStoreCache) VersionReturnsOnCall(i int, result1 string) {
856	fake.versionMutex.Lock()
857	defer fake.versionMutex.Unlock()
858	fake.VersionStub = nil
859	if fake.versionReturnsOnCall == nil {
860		fake.versionReturnsOnCall = make(map[int]struct {
861			result1 string
862		})
863	}
864	fake.versionReturnsOnCall[i] = struct {
865		result1 string
866	}{result1}
867}
868
869func (fake *ConfigStoreCache) Invocations() map[string][][]interface{} {
870	fake.invocationsMutex.RLock()
871	defer fake.invocationsMutex.RUnlock()
872	fake.createMutex.RLock()
873	defer fake.createMutex.RUnlock()
874	fake.deleteMutex.RLock()
875	defer fake.deleteMutex.RUnlock()
876	fake.getMutex.RLock()
877	defer fake.getMutex.RUnlock()
878	fake.getLedgerMutex.RLock()
879	defer fake.getLedgerMutex.RUnlock()
880	fake.getResourceAtVersionMutex.RLock()
881	defer fake.getResourceAtVersionMutex.RUnlock()
882	fake.hasSyncedMutex.RLock()
883	defer fake.hasSyncedMutex.RUnlock()
884	fake.listMutex.RLock()
885	defer fake.listMutex.RUnlock()
886	fake.registerEventHandlerMutex.RLock()
887	defer fake.registerEventHandlerMutex.RUnlock()
888	fake.runMutex.RLock()
889	defer fake.runMutex.RUnlock()
890	fake.schemasMutex.RLock()
891	defer fake.schemasMutex.RUnlock()
892	fake.setLedgerMutex.RLock()
893	defer fake.setLedgerMutex.RUnlock()
894	fake.updateMutex.RLock()
895	defer fake.updateMutex.RUnlock()
896	fake.versionMutex.RLock()
897	defer fake.versionMutex.RUnlock()
898	copiedInvocations := map[string][][]interface{}{}
899	for key, value := range fake.invocations {
900		copiedInvocations[key] = value
901	}
902	return copiedInvocations
903}
904
905func (fake *ConfigStoreCache) recordInvocation(key string, args []interface{}) {
906	fake.invocationsMutex.Lock()
907	defer fake.invocationsMutex.Unlock()
908	if fake.invocations == nil {
909		fake.invocations = map[string][][]interface{}{}
910	}
911	if fake.invocations[key] == nil {
912		fake.invocations[key] = [][]interface{}{}
913	}
914	fake.invocations[key] = append(fake.invocations[key], args)
915}
916
917var _ model.ConfigStoreCache = new(ConfigStoreCache)
918