1// Code generated by counterfeiter. DO NOT EDIT.
2package gclientfakes
3
4import (
5	"sync"
6
7	"code.cloudfoundry.org/garden"
8	"github.com/concourse/concourse/atc/worker/gclient"
9)
10
11type FakeClient struct {
12	BulkInfoStub        func([]string) (map[string]garden.ContainerInfoEntry, error)
13	bulkInfoMutex       sync.RWMutex
14	bulkInfoArgsForCall []struct {
15		arg1 []string
16	}
17	bulkInfoReturns struct {
18		result1 map[string]garden.ContainerInfoEntry
19		result2 error
20	}
21	bulkInfoReturnsOnCall map[int]struct {
22		result1 map[string]garden.ContainerInfoEntry
23		result2 error
24	}
25	BulkMetricsStub        func([]string) (map[string]garden.ContainerMetricsEntry, error)
26	bulkMetricsMutex       sync.RWMutex
27	bulkMetricsArgsForCall []struct {
28		arg1 []string
29	}
30	bulkMetricsReturns struct {
31		result1 map[string]garden.ContainerMetricsEntry
32		result2 error
33	}
34	bulkMetricsReturnsOnCall map[int]struct {
35		result1 map[string]garden.ContainerMetricsEntry
36		result2 error
37	}
38	CapacityStub        func() (garden.Capacity, error)
39	capacityMutex       sync.RWMutex
40	capacityArgsForCall []struct {
41	}
42	capacityReturns struct {
43		result1 garden.Capacity
44		result2 error
45	}
46	capacityReturnsOnCall map[int]struct {
47		result1 garden.Capacity
48		result2 error
49	}
50	ContainersStub        func(garden.Properties) ([]gclient.Container, error)
51	containersMutex       sync.RWMutex
52	containersArgsForCall []struct {
53		arg1 garden.Properties
54	}
55	containersReturns struct {
56		result1 []gclient.Container
57		result2 error
58	}
59	containersReturnsOnCall map[int]struct {
60		result1 []gclient.Container
61		result2 error
62	}
63	CreateStub        func(garden.ContainerSpec) (gclient.Container, error)
64	createMutex       sync.RWMutex
65	createArgsForCall []struct {
66		arg1 garden.ContainerSpec
67	}
68	createReturns struct {
69		result1 gclient.Container
70		result2 error
71	}
72	createReturnsOnCall map[int]struct {
73		result1 gclient.Container
74		result2 error
75	}
76	DestroyStub        func(string) error
77	destroyMutex       sync.RWMutex
78	destroyArgsForCall []struct {
79		arg1 string
80	}
81	destroyReturns struct {
82		result1 error
83	}
84	destroyReturnsOnCall map[int]struct {
85		result1 error
86	}
87	LookupStub        func(string) (gclient.Container, error)
88	lookupMutex       sync.RWMutex
89	lookupArgsForCall []struct {
90		arg1 string
91	}
92	lookupReturns struct {
93		result1 gclient.Container
94		result2 error
95	}
96	lookupReturnsOnCall map[int]struct {
97		result1 gclient.Container
98		result2 error
99	}
100	PingStub        func() error
101	pingMutex       sync.RWMutex
102	pingArgsForCall []struct {
103	}
104	pingReturns struct {
105		result1 error
106	}
107	pingReturnsOnCall map[int]struct {
108		result1 error
109	}
110	invocations      map[string][][]interface{}
111	invocationsMutex sync.RWMutex
112}
113
114func (fake *FakeClient) BulkInfo(arg1 []string) (map[string]garden.ContainerInfoEntry, error) {
115	var arg1Copy []string
116	if arg1 != nil {
117		arg1Copy = make([]string, len(arg1))
118		copy(arg1Copy, arg1)
119	}
120	fake.bulkInfoMutex.Lock()
121	ret, specificReturn := fake.bulkInfoReturnsOnCall[len(fake.bulkInfoArgsForCall)]
122	fake.bulkInfoArgsForCall = append(fake.bulkInfoArgsForCall, struct {
123		arg1 []string
124	}{arg1Copy})
125	fake.recordInvocation("BulkInfo", []interface{}{arg1Copy})
126	fake.bulkInfoMutex.Unlock()
127	if fake.BulkInfoStub != nil {
128		return fake.BulkInfoStub(arg1)
129	}
130	if specificReturn {
131		return ret.result1, ret.result2
132	}
133	fakeReturns := fake.bulkInfoReturns
134	return fakeReturns.result1, fakeReturns.result2
135}
136
137func (fake *FakeClient) BulkInfoCallCount() int {
138	fake.bulkInfoMutex.RLock()
139	defer fake.bulkInfoMutex.RUnlock()
140	return len(fake.bulkInfoArgsForCall)
141}
142
143func (fake *FakeClient) BulkInfoCalls(stub func([]string) (map[string]garden.ContainerInfoEntry, error)) {
144	fake.bulkInfoMutex.Lock()
145	defer fake.bulkInfoMutex.Unlock()
146	fake.BulkInfoStub = stub
147}
148
149func (fake *FakeClient) BulkInfoArgsForCall(i int) []string {
150	fake.bulkInfoMutex.RLock()
151	defer fake.bulkInfoMutex.RUnlock()
152	argsForCall := fake.bulkInfoArgsForCall[i]
153	return argsForCall.arg1
154}
155
156func (fake *FakeClient) BulkInfoReturns(result1 map[string]garden.ContainerInfoEntry, result2 error) {
157	fake.bulkInfoMutex.Lock()
158	defer fake.bulkInfoMutex.Unlock()
159	fake.BulkInfoStub = nil
160	fake.bulkInfoReturns = struct {
161		result1 map[string]garden.ContainerInfoEntry
162		result2 error
163	}{result1, result2}
164}
165
166func (fake *FakeClient) BulkInfoReturnsOnCall(i int, result1 map[string]garden.ContainerInfoEntry, result2 error) {
167	fake.bulkInfoMutex.Lock()
168	defer fake.bulkInfoMutex.Unlock()
169	fake.BulkInfoStub = nil
170	if fake.bulkInfoReturnsOnCall == nil {
171		fake.bulkInfoReturnsOnCall = make(map[int]struct {
172			result1 map[string]garden.ContainerInfoEntry
173			result2 error
174		})
175	}
176	fake.bulkInfoReturnsOnCall[i] = struct {
177		result1 map[string]garden.ContainerInfoEntry
178		result2 error
179	}{result1, result2}
180}
181
182func (fake *FakeClient) BulkMetrics(arg1 []string) (map[string]garden.ContainerMetricsEntry, error) {
183	var arg1Copy []string
184	if arg1 != nil {
185		arg1Copy = make([]string, len(arg1))
186		copy(arg1Copy, arg1)
187	}
188	fake.bulkMetricsMutex.Lock()
189	ret, specificReturn := fake.bulkMetricsReturnsOnCall[len(fake.bulkMetricsArgsForCall)]
190	fake.bulkMetricsArgsForCall = append(fake.bulkMetricsArgsForCall, struct {
191		arg1 []string
192	}{arg1Copy})
193	fake.recordInvocation("BulkMetrics", []interface{}{arg1Copy})
194	fake.bulkMetricsMutex.Unlock()
195	if fake.BulkMetricsStub != nil {
196		return fake.BulkMetricsStub(arg1)
197	}
198	if specificReturn {
199		return ret.result1, ret.result2
200	}
201	fakeReturns := fake.bulkMetricsReturns
202	return fakeReturns.result1, fakeReturns.result2
203}
204
205func (fake *FakeClient) BulkMetricsCallCount() int {
206	fake.bulkMetricsMutex.RLock()
207	defer fake.bulkMetricsMutex.RUnlock()
208	return len(fake.bulkMetricsArgsForCall)
209}
210
211func (fake *FakeClient) BulkMetricsCalls(stub func([]string) (map[string]garden.ContainerMetricsEntry, error)) {
212	fake.bulkMetricsMutex.Lock()
213	defer fake.bulkMetricsMutex.Unlock()
214	fake.BulkMetricsStub = stub
215}
216
217func (fake *FakeClient) BulkMetricsArgsForCall(i int) []string {
218	fake.bulkMetricsMutex.RLock()
219	defer fake.bulkMetricsMutex.RUnlock()
220	argsForCall := fake.bulkMetricsArgsForCall[i]
221	return argsForCall.arg1
222}
223
224func (fake *FakeClient) BulkMetricsReturns(result1 map[string]garden.ContainerMetricsEntry, result2 error) {
225	fake.bulkMetricsMutex.Lock()
226	defer fake.bulkMetricsMutex.Unlock()
227	fake.BulkMetricsStub = nil
228	fake.bulkMetricsReturns = struct {
229		result1 map[string]garden.ContainerMetricsEntry
230		result2 error
231	}{result1, result2}
232}
233
234func (fake *FakeClient) BulkMetricsReturnsOnCall(i int, result1 map[string]garden.ContainerMetricsEntry, result2 error) {
235	fake.bulkMetricsMutex.Lock()
236	defer fake.bulkMetricsMutex.Unlock()
237	fake.BulkMetricsStub = nil
238	if fake.bulkMetricsReturnsOnCall == nil {
239		fake.bulkMetricsReturnsOnCall = make(map[int]struct {
240			result1 map[string]garden.ContainerMetricsEntry
241			result2 error
242		})
243	}
244	fake.bulkMetricsReturnsOnCall[i] = struct {
245		result1 map[string]garden.ContainerMetricsEntry
246		result2 error
247	}{result1, result2}
248}
249
250func (fake *FakeClient) Capacity() (garden.Capacity, error) {
251	fake.capacityMutex.Lock()
252	ret, specificReturn := fake.capacityReturnsOnCall[len(fake.capacityArgsForCall)]
253	fake.capacityArgsForCall = append(fake.capacityArgsForCall, struct {
254	}{})
255	fake.recordInvocation("Capacity", []interface{}{})
256	fake.capacityMutex.Unlock()
257	if fake.CapacityStub != nil {
258		return fake.CapacityStub()
259	}
260	if specificReturn {
261		return ret.result1, ret.result2
262	}
263	fakeReturns := fake.capacityReturns
264	return fakeReturns.result1, fakeReturns.result2
265}
266
267func (fake *FakeClient) CapacityCallCount() int {
268	fake.capacityMutex.RLock()
269	defer fake.capacityMutex.RUnlock()
270	return len(fake.capacityArgsForCall)
271}
272
273func (fake *FakeClient) CapacityCalls(stub func() (garden.Capacity, error)) {
274	fake.capacityMutex.Lock()
275	defer fake.capacityMutex.Unlock()
276	fake.CapacityStub = stub
277}
278
279func (fake *FakeClient) CapacityReturns(result1 garden.Capacity, result2 error) {
280	fake.capacityMutex.Lock()
281	defer fake.capacityMutex.Unlock()
282	fake.CapacityStub = nil
283	fake.capacityReturns = struct {
284		result1 garden.Capacity
285		result2 error
286	}{result1, result2}
287}
288
289func (fake *FakeClient) CapacityReturnsOnCall(i int, result1 garden.Capacity, result2 error) {
290	fake.capacityMutex.Lock()
291	defer fake.capacityMutex.Unlock()
292	fake.CapacityStub = nil
293	if fake.capacityReturnsOnCall == nil {
294		fake.capacityReturnsOnCall = make(map[int]struct {
295			result1 garden.Capacity
296			result2 error
297		})
298	}
299	fake.capacityReturnsOnCall[i] = struct {
300		result1 garden.Capacity
301		result2 error
302	}{result1, result2}
303}
304
305func (fake *FakeClient) Containers(arg1 garden.Properties) ([]gclient.Container, error) {
306	fake.containersMutex.Lock()
307	ret, specificReturn := fake.containersReturnsOnCall[len(fake.containersArgsForCall)]
308	fake.containersArgsForCall = append(fake.containersArgsForCall, struct {
309		arg1 garden.Properties
310	}{arg1})
311	fake.recordInvocation("Containers", []interface{}{arg1})
312	fake.containersMutex.Unlock()
313	if fake.ContainersStub != nil {
314		return fake.ContainersStub(arg1)
315	}
316	if specificReturn {
317		return ret.result1, ret.result2
318	}
319	fakeReturns := fake.containersReturns
320	return fakeReturns.result1, fakeReturns.result2
321}
322
323func (fake *FakeClient) ContainersCallCount() int {
324	fake.containersMutex.RLock()
325	defer fake.containersMutex.RUnlock()
326	return len(fake.containersArgsForCall)
327}
328
329func (fake *FakeClient) ContainersCalls(stub func(garden.Properties) ([]gclient.Container, error)) {
330	fake.containersMutex.Lock()
331	defer fake.containersMutex.Unlock()
332	fake.ContainersStub = stub
333}
334
335func (fake *FakeClient) ContainersArgsForCall(i int) garden.Properties {
336	fake.containersMutex.RLock()
337	defer fake.containersMutex.RUnlock()
338	argsForCall := fake.containersArgsForCall[i]
339	return argsForCall.arg1
340}
341
342func (fake *FakeClient) ContainersReturns(result1 []gclient.Container, result2 error) {
343	fake.containersMutex.Lock()
344	defer fake.containersMutex.Unlock()
345	fake.ContainersStub = nil
346	fake.containersReturns = struct {
347		result1 []gclient.Container
348		result2 error
349	}{result1, result2}
350}
351
352func (fake *FakeClient) ContainersReturnsOnCall(i int, result1 []gclient.Container, result2 error) {
353	fake.containersMutex.Lock()
354	defer fake.containersMutex.Unlock()
355	fake.ContainersStub = nil
356	if fake.containersReturnsOnCall == nil {
357		fake.containersReturnsOnCall = make(map[int]struct {
358			result1 []gclient.Container
359			result2 error
360		})
361	}
362	fake.containersReturnsOnCall[i] = struct {
363		result1 []gclient.Container
364		result2 error
365	}{result1, result2}
366}
367
368func (fake *FakeClient) Create(arg1 garden.ContainerSpec) (gclient.Container, error) {
369	fake.createMutex.Lock()
370	ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)]
371	fake.createArgsForCall = append(fake.createArgsForCall, struct {
372		arg1 garden.ContainerSpec
373	}{arg1})
374	fake.recordInvocation("Create", []interface{}{arg1})
375	fake.createMutex.Unlock()
376	if fake.CreateStub != nil {
377		return fake.CreateStub(arg1)
378	}
379	if specificReturn {
380		return ret.result1, ret.result2
381	}
382	fakeReturns := fake.createReturns
383	return fakeReturns.result1, fakeReturns.result2
384}
385
386func (fake *FakeClient) CreateCallCount() int {
387	fake.createMutex.RLock()
388	defer fake.createMutex.RUnlock()
389	return len(fake.createArgsForCall)
390}
391
392func (fake *FakeClient) CreateCalls(stub func(garden.ContainerSpec) (gclient.Container, error)) {
393	fake.createMutex.Lock()
394	defer fake.createMutex.Unlock()
395	fake.CreateStub = stub
396}
397
398func (fake *FakeClient) CreateArgsForCall(i int) garden.ContainerSpec {
399	fake.createMutex.RLock()
400	defer fake.createMutex.RUnlock()
401	argsForCall := fake.createArgsForCall[i]
402	return argsForCall.arg1
403}
404
405func (fake *FakeClient) CreateReturns(result1 gclient.Container, result2 error) {
406	fake.createMutex.Lock()
407	defer fake.createMutex.Unlock()
408	fake.CreateStub = nil
409	fake.createReturns = struct {
410		result1 gclient.Container
411		result2 error
412	}{result1, result2}
413}
414
415func (fake *FakeClient) CreateReturnsOnCall(i int, result1 gclient.Container, result2 error) {
416	fake.createMutex.Lock()
417	defer fake.createMutex.Unlock()
418	fake.CreateStub = nil
419	if fake.createReturnsOnCall == nil {
420		fake.createReturnsOnCall = make(map[int]struct {
421			result1 gclient.Container
422			result2 error
423		})
424	}
425	fake.createReturnsOnCall[i] = struct {
426		result1 gclient.Container
427		result2 error
428	}{result1, result2}
429}
430
431func (fake *FakeClient) Destroy(arg1 string) error {
432	fake.destroyMutex.Lock()
433	ret, specificReturn := fake.destroyReturnsOnCall[len(fake.destroyArgsForCall)]
434	fake.destroyArgsForCall = append(fake.destroyArgsForCall, struct {
435		arg1 string
436	}{arg1})
437	fake.recordInvocation("Destroy", []interface{}{arg1})
438	fake.destroyMutex.Unlock()
439	if fake.DestroyStub != nil {
440		return fake.DestroyStub(arg1)
441	}
442	if specificReturn {
443		return ret.result1
444	}
445	fakeReturns := fake.destroyReturns
446	return fakeReturns.result1
447}
448
449func (fake *FakeClient) DestroyCallCount() int {
450	fake.destroyMutex.RLock()
451	defer fake.destroyMutex.RUnlock()
452	return len(fake.destroyArgsForCall)
453}
454
455func (fake *FakeClient) DestroyCalls(stub func(string) error) {
456	fake.destroyMutex.Lock()
457	defer fake.destroyMutex.Unlock()
458	fake.DestroyStub = stub
459}
460
461func (fake *FakeClient) DestroyArgsForCall(i int) string {
462	fake.destroyMutex.RLock()
463	defer fake.destroyMutex.RUnlock()
464	argsForCall := fake.destroyArgsForCall[i]
465	return argsForCall.arg1
466}
467
468func (fake *FakeClient) DestroyReturns(result1 error) {
469	fake.destroyMutex.Lock()
470	defer fake.destroyMutex.Unlock()
471	fake.DestroyStub = nil
472	fake.destroyReturns = struct {
473		result1 error
474	}{result1}
475}
476
477func (fake *FakeClient) DestroyReturnsOnCall(i int, result1 error) {
478	fake.destroyMutex.Lock()
479	defer fake.destroyMutex.Unlock()
480	fake.DestroyStub = nil
481	if fake.destroyReturnsOnCall == nil {
482		fake.destroyReturnsOnCall = make(map[int]struct {
483			result1 error
484		})
485	}
486	fake.destroyReturnsOnCall[i] = struct {
487		result1 error
488	}{result1}
489}
490
491func (fake *FakeClient) Lookup(arg1 string) (gclient.Container, error) {
492	fake.lookupMutex.Lock()
493	ret, specificReturn := fake.lookupReturnsOnCall[len(fake.lookupArgsForCall)]
494	fake.lookupArgsForCall = append(fake.lookupArgsForCall, struct {
495		arg1 string
496	}{arg1})
497	fake.recordInvocation("Lookup", []interface{}{arg1})
498	fake.lookupMutex.Unlock()
499	if fake.LookupStub != nil {
500		return fake.LookupStub(arg1)
501	}
502	if specificReturn {
503		return ret.result1, ret.result2
504	}
505	fakeReturns := fake.lookupReturns
506	return fakeReturns.result1, fakeReturns.result2
507}
508
509func (fake *FakeClient) LookupCallCount() int {
510	fake.lookupMutex.RLock()
511	defer fake.lookupMutex.RUnlock()
512	return len(fake.lookupArgsForCall)
513}
514
515func (fake *FakeClient) LookupCalls(stub func(string) (gclient.Container, error)) {
516	fake.lookupMutex.Lock()
517	defer fake.lookupMutex.Unlock()
518	fake.LookupStub = stub
519}
520
521func (fake *FakeClient) LookupArgsForCall(i int) string {
522	fake.lookupMutex.RLock()
523	defer fake.lookupMutex.RUnlock()
524	argsForCall := fake.lookupArgsForCall[i]
525	return argsForCall.arg1
526}
527
528func (fake *FakeClient) LookupReturns(result1 gclient.Container, result2 error) {
529	fake.lookupMutex.Lock()
530	defer fake.lookupMutex.Unlock()
531	fake.LookupStub = nil
532	fake.lookupReturns = struct {
533		result1 gclient.Container
534		result2 error
535	}{result1, result2}
536}
537
538func (fake *FakeClient) LookupReturnsOnCall(i int, result1 gclient.Container, result2 error) {
539	fake.lookupMutex.Lock()
540	defer fake.lookupMutex.Unlock()
541	fake.LookupStub = nil
542	if fake.lookupReturnsOnCall == nil {
543		fake.lookupReturnsOnCall = make(map[int]struct {
544			result1 gclient.Container
545			result2 error
546		})
547	}
548	fake.lookupReturnsOnCall[i] = struct {
549		result1 gclient.Container
550		result2 error
551	}{result1, result2}
552}
553
554func (fake *FakeClient) Ping() error {
555	fake.pingMutex.Lock()
556	ret, specificReturn := fake.pingReturnsOnCall[len(fake.pingArgsForCall)]
557	fake.pingArgsForCall = append(fake.pingArgsForCall, struct {
558	}{})
559	fake.recordInvocation("Ping", []interface{}{})
560	fake.pingMutex.Unlock()
561	if fake.PingStub != nil {
562		return fake.PingStub()
563	}
564	if specificReturn {
565		return ret.result1
566	}
567	fakeReturns := fake.pingReturns
568	return fakeReturns.result1
569}
570
571func (fake *FakeClient) PingCallCount() int {
572	fake.pingMutex.RLock()
573	defer fake.pingMutex.RUnlock()
574	return len(fake.pingArgsForCall)
575}
576
577func (fake *FakeClient) PingCalls(stub func() error) {
578	fake.pingMutex.Lock()
579	defer fake.pingMutex.Unlock()
580	fake.PingStub = stub
581}
582
583func (fake *FakeClient) PingReturns(result1 error) {
584	fake.pingMutex.Lock()
585	defer fake.pingMutex.Unlock()
586	fake.PingStub = nil
587	fake.pingReturns = struct {
588		result1 error
589	}{result1}
590}
591
592func (fake *FakeClient) PingReturnsOnCall(i int, result1 error) {
593	fake.pingMutex.Lock()
594	defer fake.pingMutex.Unlock()
595	fake.PingStub = nil
596	if fake.pingReturnsOnCall == nil {
597		fake.pingReturnsOnCall = make(map[int]struct {
598			result1 error
599		})
600	}
601	fake.pingReturnsOnCall[i] = struct {
602		result1 error
603	}{result1}
604}
605
606func (fake *FakeClient) Invocations() map[string][][]interface{} {
607	fake.invocationsMutex.RLock()
608	defer fake.invocationsMutex.RUnlock()
609	fake.bulkInfoMutex.RLock()
610	defer fake.bulkInfoMutex.RUnlock()
611	fake.bulkMetricsMutex.RLock()
612	defer fake.bulkMetricsMutex.RUnlock()
613	fake.capacityMutex.RLock()
614	defer fake.capacityMutex.RUnlock()
615	fake.containersMutex.RLock()
616	defer fake.containersMutex.RUnlock()
617	fake.createMutex.RLock()
618	defer fake.createMutex.RUnlock()
619	fake.destroyMutex.RLock()
620	defer fake.destroyMutex.RUnlock()
621	fake.lookupMutex.RLock()
622	defer fake.lookupMutex.RUnlock()
623	fake.pingMutex.RLock()
624	defer fake.pingMutex.RUnlock()
625	copiedInvocations := map[string][][]interface{}{}
626	for key, value := range fake.invocations {
627		copiedInvocations[key] = value
628	}
629	return copiedInvocations
630}
631
632func (fake *FakeClient) recordInvocation(key string, args []interface{}) {
633	fake.invocationsMutex.Lock()
634	defer fake.invocationsMutex.Unlock()
635	if fake.invocations == nil {
636		fake.invocations = map[string][][]interface{}{}
637	}
638	if fake.invocations[key] == nil {
639		fake.invocations[key] = [][]interface{}{}
640	}
641	fake.invocations[key] = append(fake.invocations[key], args)
642}
643
644var _ gclient.Client = new(FakeClient)
645