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