1// Code generated by counterfeiter. DO NOT EDIT.
2package gclientfakes
3
4import (
5	"context"
6	"io"
7	"sync"
8	"time"
9
10	"code.cloudfoundry.org/garden"
11	"github.com/concourse/concourse/atc/worker/gclient"
12)
13
14type FakeContainer struct {
15	AttachStub        func(context.Context, string, garden.ProcessIO) (garden.Process, error)
16	attachMutex       sync.RWMutex
17	attachArgsForCall []struct {
18		arg1 context.Context
19		arg2 string
20		arg3 garden.ProcessIO
21	}
22	attachReturns struct {
23		result1 garden.Process
24		result2 error
25	}
26	attachReturnsOnCall map[int]struct {
27		result1 garden.Process
28		result2 error
29	}
30	BulkNetOutStub        func([]garden.NetOutRule) error
31	bulkNetOutMutex       sync.RWMutex
32	bulkNetOutArgsForCall []struct {
33		arg1 []garden.NetOutRule
34	}
35	bulkNetOutReturns struct {
36		result1 error
37	}
38	bulkNetOutReturnsOnCall map[int]struct {
39		result1 error
40	}
41	CurrentBandwidthLimitsStub        func() (garden.BandwidthLimits, error)
42	currentBandwidthLimitsMutex       sync.RWMutex
43	currentBandwidthLimitsArgsForCall []struct {
44	}
45	currentBandwidthLimitsReturns struct {
46		result1 garden.BandwidthLimits
47		result2 error
48	}
49	currentBandwidthLimitsReturnsOnCall map[int]struct {
50		result1 garden.BandwidthLimits
51		result2 error
52	}
53	CurrentCPULimitsStub        func() (garden.CPULimits, error)
54	currentCPULimitsMutex       sync.RWMutex
55	currentCPULimitsArgsForCall []struct {
56	}
57	currentCPULimitsReturns struct {
58		result1 garden.CPULimits
59		result2 error
60	}
61	currentCPULimitsReturnsOnCall map[int]struct {
62		result1 garden.CPULimits
63		result2 error
64	}
65	CurrentDiskLimitsStub        func() (garden.DiskLimits, error)
66	currentDiskLimitsMutex       sync.RWMutex
67	currentDiskLimitsArgsForCall []struct {
68	}
69	currentDiskLimitsReturns struct {
70		result1 garden.DiskLimits
71		result2 error
72	}
73	currentDiskLimitsReturnsOnCall map[int]struct {
74		result1 garden.DiskLimits
75		result2 error
76	}
77	CurrentMemoryLimitsStub        func() (garden.MemoryLimits, error)
78	currentMemoryLimitsMutex       sync.RWMutex
79	currentMemoryLimitsArgsForCall []struct {
80	}
81	currentMemoryLimitsReturns struct {
82		result1 garden.MemoryLimits
83		result2 error
84	}
85	currentMemoryLimitsReturnsOnCall map[int]struct {
86		result1 garden.MemoryLimits
87		result2 error
88	}
89	HandleStub        func() string
90	handleMutex       sync.RWMutex
91	handleArgsForCall []struct {
92	}
93	handleReturns struct {
94		result1 string
95	}
96	handleReturnsOnCall map[int]struct {
97		result1 string
98	}
99	InfoStub        func() (garden.ContainerInfo, error)
100	infoMutex       sync.RWMutex
101	infoArgsForCall []struct {
102	}
103	infoReturns struct {
104		result1 garden.ContainerInfo
105		result2 error
106	}
107	infoReturnsOnCall map[int]struct {
108		result1 garden.ContainerInfo
109		result2 error
110	}
111	MetricsStub        func() (garden.Metrics, error)
112	metricsMutex       sync.RWMutex
113	metricsArgsForCall []struct {
114	}
115	metricsReturns struct {
116		result1 garden.Metrics
117		result2 error
118	}
119	metricsReturnsOnCall map[int]struct {
120		result1 garden.Metrics
121		result2 error
122	}
123	NetInStub        func(uint32, uint32) (uint32, uint32, error)
124	netInMutex       sync.RWMutex
125	netInArgsForCall []struct {
126		arg1 uint32
127		arg2 uint32
128	}
129	netInReturns struct {
130		result1 uint32
131		result2 uint32
132		result3 error
133	}
134	netInReturnsOnCall map[int]struct {
135		result1 uint32
136		result2 uint32
137		result3 error
138	}
139	NetOutStub        func(garden.NetOutRule) error
140	netOutMutex       sync.RWMutex
141	netOutArgsForCall []struct {
142		arg1 garden.NetOutRule
143	}
144	netOutReturns struct {
145		result1 error
146	}
147	netOutReturnsOnCall map[int]struct {
148		result1 error
149	}
150	PropertiesStub        func() (garden.Properties, error)
151	propertiesMutex       sync.RWMutex
152	propertiesArgsForCall []struct {
153	}
154	propertiesReturns struct {
155		result1 garden.Properties
156		result2 error
157	}
158	propertiesReturnsOnCall map[int]struct {
159		result1 garden.Properties
160		result2 error
161	}
162	PropertyStub        func(string) (string, error)
163	propertyMutex       sync.RWMutex
164	propertyArgsForCall []struct {
165		arg1 string
166	}
167	propertyReturns struct {
168		result1 string
169		result2 error
170	}
171	propertyReturnsOnCall map[int]struct {
172		result1 string
173		result2 error
174	}
175	RemovePropertyStub        func(string) error
176	removePropertyMutex       sync.RWMutex
177	removePropertyArgsForCall []struct {
178		arg1 string
179	}
180	removePropertyReturns struct {
181		result1 error
182	}
183	removePropertyReturnsOnCall map[int]struct {
184		result1 error
185	}
186	RunStub        func(context.Context, garden.ProcessSpec, garden.ProcessIO) (garden.Process, error)
187	runMutex       sync.RWMutex
188	runArgsForCall []struct {
189		arg1 context.Context
190		arg2 garden.ProcessSpec
191		arg3 garden.ProcessIO
192	}
193	runReturns struct {
194		result1 garden.Process
195		result2 error
196	}
197	runReturnsOnCall map[int]struct {
198		result1 garden.Process
199		result2 error
200	}
201	SetGraceTimeStub        func(time.Duration) error
202	setGraceTimeMutex       sync.RWMutex
203	setGraceTimeArgsForCall []struct {
204		arg1 time.Duration
205	}
206	setGraceTimeReturns struct {
207		result1 error
208	}
209	setGraceTimeReturnsOnCall map[int]struct {
210		result1 error
211	}
212	SetPropertyStub        func(string, string) error
213	setPropertyMutex       sync.RWMutex
214	setPropertyArgsForCall []struct {
215		arg1 string
216		arg2 string
217	}
218	setPropertyReturns struct {
219		result1 error
220	}
221	setPropertyReturnsOnCall map[int]struct {
222		result1 error
223	}
224	StopStub        func(bool) error
225	stopMutex       sync.RWMutex
226	stopArgsForCall []struct {
227		arg1 bool
228	}
229	stopReturns struct {
230		result1 error
231	}
232	stopReturnsOnCall map[int]struct {
233		result1 error
234	}
235	StreamInStub        func(garden.StreamInSpec) error
236	streamInMutex       sync.RWMutex
237	streamInArgsForCall []struct {
238		arg1 garden.StreamInSpec
239	}
240	streamInReturns struct {
241		result1 error
242	}
243	streamInReturnsOnCall map[int]struct {
244		result1 error
245	}
246	StreamOutStub        func(garden.StreamOutSpec) (io.ReadCloser, error)
247	streamOutMutex       sync.RWMutex
248	streamOutArgsForCall []struct {
249		arg1 garden.StreamOutSpec
250	}
251	streamOutReturns struct {
252		result1 io.ReadCloser
253		result2 error
254	}
255	streamOutReturnsOnCall map[int]struct {
256		result1 io.ReadCloser
257		result2 error
258	}
259	invocations      map[string][][]interface{}
260	invocationsMutex sync.RWMutex
261}
262
263func (fake *FakeContainer) Attach(arg1 context.Context, arg2 string, arg3 garden.ProcessIO) (garden.Process, error) {
264	fake.attachMutex.Lock()
265	ret, specificReturn := fake.attachReturnsOnCall[len(fake.attachArgsForCall)]
266	fake.attachArgsForCall = append(fake.attachArgsForCall, struct {
267		arg1 context.Context
268		arg2 string
269		arg3 garden.ProcessIO
270	}{arg1, arg2, arg3})
271	fake.recordInvocation("Attach", []interface{}{arg1, arg2, arg3})
272	fake.attachMutex.Unlock()
273	if fake.AttachStub != nil {
274		return fake.AttachStub(arg1, arg2, arg3)
275	}
276	if specificReturn {
277		return ret.result1, ret.result2
278	}
279	fakeReturns := fake.attachReturns
280	return fakeReturns.result1, fakeReturns.result2
281}
282
283func (fake *FakeContainer) AttachCallCount() int {
284	fake.attachMutex.RLock()
285	defer fake.attachMutex.RUnlock()
286	return len(fake.attachArgsForCall)
287}
288
289func (fake *FakeContainer) AttachCalls(stub func(context.Context, string, garden.ProcessIO) (garden.Process, error)) {
290	fake.attachMutex.Lock()
291	defer fake.attachMutex.Unlock()
292	fake.AttachStub = stub
293}
294
295func (fake *FakeContainer) AttachArgsForCall(i int) (context.Context, string, garden.ProcessIO) {
296	fake.attachMutex.RLock()
297	defer fake.attachMutex.RUnlock()
298	argsForCall := fake.attachArgsForCall[i]
299	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
300}
301
302func (fake *FakeContainer) AttachReturns(result1 garden.Process, result2 error) {
303	fake.attachMutex.Lock()
304	defer fake.attachMutex.Unlock()
305	fake.AttachStub = nil
306	fake.attachReturns = struct {
307		result1 garden.Process
308		result2 error
309	}{result1, result2}
310}
311
312func (fake *FakeContainer) AttachReturnsOnCall(i int, result1 garden.Process, result2 error) {
313	fake.attachMutex.Lock()
314	defer fake.attachMutex.Unlock()
315	fake.AttachStub = nil
316	if fake.attachReturnsOnCall == nil {
317		fake.attachReturnsOnCall = make(map[int]struct {
318			result1 garden.Process
319			result2 error
320		})
321	}
322	fake.attachReturnsOnCall[i] = struct {
323		result1 garden.Process
324		result2 error
325	}{result1, result2}
326}
327
328func (fake *FakeContainer) BulkNetOut(arg1 []garden.NetOutRule) error {
329	var arg1Copy []garden.NetOutRule
330	if arg1 != nil {
331		arg1Copy = make([]garden.NetOutRule, len(arg1))
332		copy(arg1Copy, arg1)
333	}
334	fake.bulkNetOutMutex.Lock()
335	ret, specificReturn := fake.bulkNetOutReturnsOnCall[len(fake.bulkNetOutArgsForCall)]
336	fake.bulkNetOutArgsForCall = append(fake.bulkNetOutArgsForCall, struct {
337		arg1 []garden.NetOutRule
338	}{arg1Copy})
339	fake.recordInvocation("BulkNetOut", []interface{}{arg1Copy})
340	fake.bulkNetOutMutex.Unlock()
341	if fake.BulkNetOutStub != nil {
342		return fake.BulkNetOutStub(arg1)
343	}
344	if specificReturn {
345		return ret.result1
346	}
347	fakeReturns := fake.bulkNetOutReturns
348	return fakeReturns.result1
349}
350
351func (fake *FakeContainer) BulkNetOutCallCount() int {
352	fake.bulkNetOutMutex.RLock()
353	defer fake.bulkNetOutMutex.RUnlock()
354	return len(fake.bulkNetOutArgsForCall)
355}
356
357func (fake *FakeContainer) BulkNetOutCalls(stub func([]garden.NetOutRule) error) {
358	fake.bulkNetOutMutex.Lock()
359	defer fake.bulkNetOutMutex.Unlock()
360	fake.BulkNetOutStub = stub
361}
362
363func (fake *FakeContainer) BulkNetOutArgsForCall(i int) []garden.NetOutRule {
364	fake.bulkNetOutMutex.RLock()
365	defer fake.bulkNetOutMutex.RUnlock()
366	argsForCall := fake.bulkNetOutArgsForCall[i]
367	return argsForCall.arg1
368}
369
370func (fake *FakeContainer) BulkNetOutReturns(result1 error) {
371	fake.bulkNetOutMutex.Lock()
372	defer fake.bulkNetOutMutex.Unlock()
373	fake.BulkNetOutStub = nil
374	fake.bulkNetOutReturns = struct {
375		result1 error
376	}{result1}
377}
378
379func (fake *FakeContainer) BulkNetOutReturnsOnCall(i int, result1 error) {
380	fake.bulkNetOutMutex.Lock()
381	defer fake.bulkNetOutMutex.Unlock()
382	fake.BulkNetOutStub = nil
383	if fake.bulkNetOutReturnsOnCall == nil {
384		fake.bulkNetOutReturnsOnCall = make(map[int]struct {
385			result1 error
386		})
387	}
388	fake.bulkNetOutReturnsOnCall[i] = struct {
389		result1 error
390	}{result1}
391}
392
393func (fake *FakeContainer) CurrentBandwidthLimits() (garden.BandwidthLimits, error) {
394	fake.currentBandwidthLimitsMutex.Lock()
395	ret, specificReturn := fake.currentBandwidthLimitsReturnsOnCall[len(fake.currentBandwidthLimitsArgsForCall)]
396	fake.currentBandwidthLimitsArgsForCall = append(fake.currentBandwidthLimitsArgsForCall, struct {
397	}{})
398	fake.recordInvocation("CurrentBandwidthLimits", []interface{}{})
399	fake.currentBandwidthLimitsMutex.Unlock()
400	if fake.CurrentBandwidthLimitsStub != nil {
401		return fake.CurrentBandwidthLimitsStub()
402	}
403	if specificReturn {
404		return ret.result1, ret.result2
405	}
406	fakeReturns := fake.currentBandwidthLimitsReturns
407	return fakeReturns.result1, fakeReturns.result2
408}
409
410func (fake *FakeContainer) CurrentBandwidthLimitsCallCount() int {
411	fake.currentBandwidthLimitsMutex.RLock()
412	defer fake.currentBandwidthLimitsMutex.RUnlock()
413	return len(fake.currentBandwidthLimitsArgsForCall)
414}
415
416func (fake *FakeContainer) CurrentBandwidthLimitsCalls(stub func() (garden.BandwidthLimits, error)) {
417	fake.currentBandwidthLimitsMutex.Lock()
418	defer fake.currentBandwidthLimitsMutex.Unlock()
419	fake.CurrentBandwidthLimitsStub = stub
420}
421
422func (fake *FakeContainer) CurrentBandwidthLimitsReturns(result1 garden.BandwidthLimits, result2 error) {
423	fake.currentBandwidthLimitsMutex.Lock()
424	defer fake.currentBandwidthLimitsMutex.Unlock()
425	fake.CurrentBandwidthLimitsStub = nil
426	fake.currentBandwidthLimitsReturns = struct {
427		result1 garden.BandwidthLimits
428		result2 error
429	}{result1, result2}
430}
431
432func (fake *FakeContainer) CurrentBandwidthLimitsReturnsOnCall(i int, result1 garden.BandwidthLimits, result2 error) {
433	fake.currentBandwidthLimitsMutex.Lock()
434	defer fake.currentBandwidthLimitsMutex.Unlock()
435	fake.CurrentBandwidthLimitsStub = nil
436	if fake.currentBandwidthLimitsReturnsOnCall == nil {
437		fake.currentBandwidthLimitsReturnsOnCall = make(map[int]struct {
438			result1 garden.BandwidthLimits
439			result2 error
440		})
441	}
442	fake.currentBandwidthLimitsReturnsOnCall[i] = struct {
443		result1 garden.BandwidthLimits
444		result2 error
445	}{result1, result2}
446}
447
448func (fake *FakeContainer) CurrentCPULimits() (garden.CPULimits, error) {
449	fake.currentCPULimitsMutex.Lock()
450	ret, specificReturn := fake.currentCPULimitsReturnsOnCall[len(fake.currentCPULimitsArgsForCall)]
451	fake.currentCPULimitsArgsForCall = append(fake.currentCPULimitsArgsForCall, struct {
452	}{})
453	fake.recordInvocation("CurrentCPULimits", []interface{}{})
454	fake.currentCPULimitsMutex.Unlock()
455	if fake.CurrentCPULimitsStub != nil {
456		return fake.CurrentCPULimitsStub()
457	}
458	if specificReturn {
459		return ret.result1, ret.result2
460	}
461	fakeReturns := fake.currentCPULimitsReturns
462	return fakeReturns.result1, fakeReturns.result2
463}
464
465func (fake *FakeContainer) CurrentCPULimitsCallCount() int {
466	fake.currentCPULimitsMutex.RLock()
467	defer fake.currentCPULimitsMutex.RUnlock()
468	return len(fake.currentCPULimitsArgsForCall)
469}
470
471func (fake *FakeContainer) CurrentCPULimitsCalls(stub func() (garden.CPULimits, error)) {
472	fake.currentCPULimitsMutex.Lock()
473	defer fake.currentCPULimitsMutex.Unlock()
474	fake.CurrentCPULimitsStub = stub
475}
476
477func (fake *FakeContainer) CurrentCPULimitsReturns(result1 garden.CPULimits, result2 error) {
478	fake.currentCPULimitsMutex.Lock()
479	defer fake.currentCPULimitsMutex.Unlock()
480	fake.CurrentCPULimitsStub = nil
481	fake.currentCPULimitsReturns = struct {
482		result1 garden.CPULimits
483		result2 error
484	}{result1, result2}
485}
486
487func (fake *FakeContainer) CurrentCPULimitsReturnsOnCall(i int, result1 garden.CPULimits, result2 error) {
488	fake.currentCPULimitsMutex.Lock()
489	defer fake.currentCPULimitsMutex.Unlock()
490	fake.CurrentCPULimitsStub = nil
491	if fake.currentCPULimitsReturnsOnCall == nil {
492		fake.currentCPULimitsReturnsOnCall = make(map[int]struct {
493			result1 garden.CPULimits
494			result2 error
495		})
496	}
497	fake.currentCPULimitsReturnsOnCall[i] = struct {
498		result1 garden.CPULimits
499		result2 error
500	}{result1, result2}
501}
502
503func (fake *FakeContainer) CurrentDiskLimits() (garden.DiskLimits, error) {
504	fake.currentDiskLimitsMutex.Lock()
505	ret, specificReturn := fake.currentDiskLimitsReturnsOnCall[len(fake.currentDiskLimitsArgsForCall)]
506	fake.currentDiskLimitsArgsForCall = append(fake.currentDiskLimitsArgsForCall, struct {
507	}{})
508	fake.recordInvocation("CurrentDiskLimits", []interface{}{})
509	fake.currentDiskLimitsMutex.Unlock()
510	if fake.CurrentDiskLimitsStub != nil {
511		return fake.CurrentDiskLimitsStub()
512	}
513	if specificReturn {
514		return ret.result1, ret.result2
515	}
516	fakeReturns := fake.currentDiskLimitsReturns
517	return fakeReturns.result1, fakeReturns.result2
518}
519
520func (fake *FakeContainer) CurrentDiskLimitsCallCount() int {
521	fake.currentDiskLimitsMutex.RLock()
522	defer fake.currentDiskLimitsMutex.RUnlock()
523	return len(fake.currentDiskLimitsArgsForCall)
524}
525
526func (fake *FakeContainer) CurrentDiskLimitsCalls(stub func() (garden.DiskLimits, error)) {
527	fake.currentDiskLimitsMutex.Lock()
528	defer fake.currentDiskLimitsMutex.Unlock()
529	fake.CurrentDiskLimitsStub = stub
530}
531
532func (fake *FakeContainer) CurrentDiskLimitsReturns(result1 garden.DiskLimits, result2 error) {
533	fake.currentDiskLimitsMutex.Lock()
534	defer fake.currentDiskLimitsMutex.Unlock()
535	fake.CurrentDiskLimitsStub = nil
536	fake.currentDiskLimitsReturns = struct {
537		result1 garden.DiskLimits
538		result2 error
539	}{result1, result2}
540}
541
542func (fake *FakeContainer) CurrentDiskLimitsReturnsOnCall(i int, result1 garden.DiskLimits, result2 error) {
543	fake.currentDiskLimitsMutex.Lock()
544	defer fake.currentDiskLimitsMutex.Unlock()
545	fake.CurrentDiskLimitsStub = nil
546	if fake.currentDiskLimitsReturnsOnCall == nil {
547		fake.currentDiskLimitsReturnsOnCall = make(map[int]struct {
548			result1 garden.DiskLimits
549			result2 error
550		})
551	}
552	fake.currentDiskLimitsReturnsOnCall[i] = struct {
553		result1 garden.DiskLimits
554		result2 error
555	}{result1, result2}
556}
557
558func (fake *FakeContainer) CurrentMemoryLimits() (garden.MemoryLimits, error) {
559	fake.currentMemoryLimitsMutex.Lock()
560	ret, specificReturn := fake.currentMemoryLimitsReturnsOnCall[len(fake.currentMemoryLimitsArgsForCall)]
561	fake.currentMemoryLimitsArgsForCall = append(fake.currentMemoryLimitsArgsForCall, struct {
562	}{})
563	fake.recordInvocation("CurrentMemoryLimits", []interface{}{})
564	fake.currentMemoryLimitsMutex.Unlock()
565	if fake.CurrentMemoryLimitsStub != nil {
566		return fake.CurrentMemoryLimitsStub()
567	}
568	if specificReturn {
569		return ret.result1, ret.result2
570	}
571	fakeReturns := fake.currentMemoryLimitsReturns
572	return fakeReturns.result1, fakeReturns.result2
573}
574
575func (fake *FakeContainer) CurrentMemoryLimitsCallCount() int {
576	fake.currentMemoryLimitsMutex.RLock()
577	defer fake.currentMemoryLimitsMutex.RUnlock()
578	return len(fake.currentMemoryLimitsArgsForCall)
579}
580
581func (fake *FakeContainer) CurrentMemoryLimitsCalls(stub func() (garden.MemoryLimits, error)) {
582	fake.currentMemoryLimitsMutex.Lock()
583	defer fake.currentMemoryLimitsMutex.Unlock()
584	fake.CurrentMemoryLimitsStub = stub
585}
586
587func (fake *FakeContainer) CurrentMemoryLimitsReturns(result1 garden.MemoryLimits, result2 error) {
588	fake.currentMemoryLimitsMutex.Lock()
589	defer fake.currentMemoryLimitsMutex.Unlock()
590	fake.CurrentMemoryLimitsStub = nil
591	fake.currentMemoryLimitsReturns = struct {
592		result1 garden.MemoryLimits
593		result2 error
594	}{result1, result2}
595}
596
597func (fake *FakeContainer) CurrentMemoryLimitsReturnsOnCall(i int, result1 garden.MemoryLimits, result2 error) {
598	fake.currentMemoryLimitsMutex.Lock()
599	defer fake.currentMemoryLimitsMutex.Unlock()
600	fake.CurrentMemoryLimitsStub = nil
601	if fake.currentMemoryLimitsReturnsOnCall == nil {
602		fake.currentMemoryLimitsReturnsOnCall = make(map[int]struct {
603			result1 garden.MemoryLimits
604			result2 error
605		})
606	}
607	fake.currentMemoryLimitsReturnsOnCall[i] = struct {
608		result1 garden.MemoryLimits
609		result2 error
610	}{result1, result2}
611}
612
613func (fake *FakeContainer) Handle() string {
614	fake.handleMutex.Lock()
615	ret, specificReturn := fake.handleReturnsOnCall[len(fake.handleArgsForCall)]
616	fake.handleArgsForCall = append(fake.handleArgsForCall, struct {
617	}{})
618	fake.recordInvocation("Handle", []interface{}{})
619	fake.handleMutex.Unlock()
620	if fake.HandleStub != nil {
621		return fake.HandleStub()
622	}
623	if specificReturn {
624		return ret.result1
625	}
626	fakeReturns := fake.handleReturns
627	return fakeReturns.result1
628}
629
630func (fake *FakeContainer) HandleCallCount() int {
631	fake.handleMutex.RLock()
632	defer fake.handleMutex.RUnlock()
633	return len(fake.handleArgsForCall)
634}
635
636func (fake *FakeContainer) HandleCalls(stub func() string) {
637	fake.handleMutex.Lock()
638	defer fake.handleMutex.Unlock()
639	fake.HandleStub = stub
640}
641
642func (fake *FakeContainer) HandleReturns(result1 string) {
643	fake.handleMutex.Lock()
644	defer fake.handleMutex.Unlock()
645	fake.HandleStub = nil
646	fake.handleReturns = struct {
647		result1 string
648	}{result1}
649}
650
651func (fake *FakeContainer) HandleReturnsOnCall(i int, result1 string) {
652	fake.handleMutex.Lock()
653	defer fake.handleMutex.Unlock()
654	fake.HandleStub = nil
655	if fake.handleReturnsOnCall == nil {
656		fake.handleReturnsOnCall = make(map[int]struct {
657			result1 string
658		})
659	}
660	fake.handleReturnsOnCall[i] = struct {
661		result1 string
662	}{result1}
663}
664
665func (fake *FakeContainer) Info() (garden.ContainerInfo, error) {
666	fake.infoMutex.Lock()
667	ret, specificReturn := fake.infoReturnsOnCall[len(fake.infoArgsForCall)]
668	fake.infoArgsForCall = append(fake.infoArgsForCall, struct {
669	}{})
670	fake.recordInvocation("Info", []interface{}{})
671	fake.infoMutex.Unlock()
672	if fake.InfoStub != nil {
673		return fake.InfoStub()
674	}
675	if specificReturn {
676		return ret.result1, ret.result2
677	}
678	fakeReturns := fake.infoReturns
679	return fakeReturns.result1, fakeReturns.result2
680}
681
682func (fake *FakeContainer) InfoCallCount() int {
683	fake.infoMutex.RLock()
684	defer fake.infoMutex.RUnlock()
685	return len(fake.infoArgsForCall)
686}
687
688func (fake *FakeContainer) InfoCalls(stub func() (garden.ContainerInfo, error)) {
689	fake.infoMutex.Lock()
690	defer fake.infoMutex.Unlock()
691	fake.InfoStub = stub
692}
693
694func (fake *FakeContainer) InfoReturns(result1 garden.ContainerInfo, result2 error) {
695	fake.infoMutex.Lock()
696	defer fake.infoMutex.Unlock()
697	fake.InfoStub = nil
698	fake.infoReturns = struct {
699		result1 garden.ContainerInfo
700		result2 error
701	}{result1, result2}
702}
703
704func (fake *FakeContainer) InfoReturnsOnCall(i int, result1 garden.ContainerInfo, result2 error) {
705	fake.infoMutex.Lock()
706	defer fake.infoMutex.Unlock()
707	fake.InfoStub = nil
708	if fake.infoReturnsOnCall == nil {
709		fake.infoReturnsOnCall = make(map[int]struct {
710			result1 garden.ContainerInfo
711			result2 error
712		})
713	}
714	fake.infoReturnsOnCall[i] = struct {
715		result1 garden.ContainerInfo
716		result2 error
717	}{result1, result2}
718}
719
720func (fake *FakeContainer) Metrics() (garden.Metrics, error) {
721	fake.metricsMutex.Lock()
722	ret, specificReturn := fake.metricsReturnsOnCall[len(fake.metricsArgsForCall)]
723	fake.metricsArgsForCall = append(fake.metricsArgsForCall, struct {
724	}{})
725	fake.recordInvocation("Metrics", []interface{}{})
726	fake.metricsMutex.Unlock()
727	if fake.MetricsStub != nil {
728		return fake.MetricsStub()
729	}
730	if specificReturn {
731		return ret.result1, ret.result2
732	}
733	fakeReturns := fake.metricsReturns
734	return fakeReturns.result1, fakeReturns.result2
735}
736
737func (fake *FakeContainer) MetricsCallCount() int {
738	fake.metricsMutex.RLock()
739	defer fake.metricsMutex.RUnlock()
740	return len(fake.metricsArgsForCall)
741}
742
743func (fake *FakeContainer) MetricsCalls(stub func() (garden.Metrics, error)) {
744	fake.metricsMutex.Lock()
745	defer fake.metricsMutex.Unlock()
746	fake.MetricsStub = stub
747}
748
749func (fake *FakeContainer) MetricsReturns(result1 garden.Metrics, result2 error) {
750	fake.metricsMutex.Lock()
751	defer fake.metricsMutex.Unlock()
752	fake.MetricsStub = nil
753	fake.metricsReturns = struct {
754		result1 garden.Metrics
755		result2 error
756	}{result1, result2}
757}
758
759func (fake *FakeContainer) MetricsReturnsOnCall(i int, result1 garden.Metrics, result2 error) {
760	fake.metricsMutex.Lock()
761	defer fake.metricsMutex.Unlock()
762	fake.MetricsStub = nil
763	if fake.metricsReturnsOnCall == nil {
764		fake.metricsReturnsOnCall = make(map[int]struct {
765			result1 garden.Metrics
766			result2 error
767		})
768	}
769	fake.metricsReturnsOnCall[i] = struct {
770		result1 garden.Metrics
771		result2 error
772	}{result1, result2}
773}
774
775func (fake *FakeContainer) NetIn(arg1 uint32, arg2 uint32) (uint32, uint32, error) {
776	fake.netInMutex.Lock()
777	ret, specificReturn := fake.netInReturnsOnCall[len(fake.netInArgsForCall)]
778	fake.netInArgsForCall = append(fake.netInArgsForCall, struct {
779		arg1 uint32
780		arg2 uint32
781	}{arg1, arg2})
782	fake.recordInvocation("NetIn", []interface{}{arg1, arg2})
783	fake.netInMutex.Unlock()
784	if fake.NetInStub != nil {
785		return fake.NetInStub(arg1, arg2)
786	}
787	if specificReturn {
788		return ret.result1, ret.result2, ret.result3
789	}
790	fakeReturns := fake.netInReturns
791	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
792}
793
794func (fake *FakeContainer) NetInCallCount() int {
795	fake.netInMutex.RLock()
796	defer fake.netInMutex.RUnlock()
797	return len(fake.netInArgsForCall)
798}
799
800func (fake *FakeContainer) NetInCalls(stub func(uint32, uint32) (uint32, uint32, error)) {
801	fake.netInMutex.Lock()
802	defer fake.netInMutex.Unlock()
803	fake.NetInStub = stub
804}
805
806func (fake *FakeContainer) NetInArgsForCall(i int) (uint32, uint32) {
807	fake.netInMutex.RLock()
808	defer fake.netInMutex.RUnlock()
809	argsForCall := fake.netInArgsForCall[i]
810	return argsForCall.arg1, argsForCall.arg2
811}
812
813func (fake *FakeContainer) NetInReturns(result1 uint32, result2 uint32, result3 error) {
814	fake.netInMutex.Lock()
815	defer fake.netInMutex.Unlock()
816	fake.NetInStub = nil
817	fake.netInReturns = struct {
818		result1 uint32
819		result2 uint32
820		result3 error
821	}{result1, result2, result3}
822}
823
824func (fake *FakeContainer) NetInReturnsOnCall(i int, result1 uint32, result2 uint32, result3 error) {
825	fake.netInMutex.Lock()
826	defer fake.netInMutex.Unlock()
827	fake.NetInStub = nil
828	if fake.netInReturnsOnCall == nil {
829		fake.netInReturnsOnCall = make(map[int]struct {
830			result1 uint32
831			result2 uint32
832			result3 error
833		})
834	}
835	fake.netInReturnsOnCall[i] = struct {
836		result1 uint32
837		result2 uint32
838		result3 error
839	}{result1, result2, result3}
840}
841
842func (fake *FakeContainer) NetOut(arg1 garden.NetOutRule) error {
843	fake.netOutMutex.Lock()
844	ret, specificReturn := fake.netOutReturnsOnCall[len(fake.netOutArgsForCall)]
845	fake.netOutArgsForCall = append(fake.netOutArgsForCall, struct {
846		arg1 garden.NetOutRule
847	}{arg1})
848	fake.recordInvocation("NetOut", []interface{}{arg1})
849	fake.netOutMutex.Unlock()
850	if fake.NetOutStub != nil {
851		return fake.NetOutStub(arg1)
852	}
853	if specificReturn {
854		return ret.result1
855	}
856	fakeReturns := fake.netOutReturns
857	return fakeReturns.result1
858}
859
860func (fake *FakeContainer) NetOutCallCount() int {
861	fake.netOutMutex.RLock()
862	defer fake.netOutMutex.RUnlock()
863	return len(fake.netOutArgsForCall)
864}
865
866func (fake *FakeContainer) NetOutCalls(stub func(garden.NetOutRule) error) {
867	fake.netOutMutex.Lock()
868	defer fake.netOutMutex.Unlock()
869	fake.NetOutStub = stub
870}
871
872func (fake *FakeContainer) NetOutArgsForCall(i int) garden.NetOutRule {
873	fake.netOutMutex.RLock()
874	defer fake.netOutMutex.RUnlock()
875	argsForCall := fake.netOutArgsForCall[i]
876	return argsForCall.arg1
877}
878
879func (fake *FakeContainer) NetOutReturns(result1 error) {
880	fake.netOutMutex.Lock()
881	defer fake.netOutMutex.Unlock()
882	fake.NetOutStub = nil
883	fake.netOutReturns = struct {
884		result1 error
885	}{result1}
886}
887
888func (fake *FakeContainer) NetOutReturnsOnCall(i int, result1 error) {
889	fake.netOutMutex.Lock()
890	defer fake.netOutMutex.Unlock()
891	fake.NetOutStub = nil
892	if fake.netOutReturnsOnCall == nil {
893		fake.netOutReturnsOnCall = make(map[int]struct {
894			result1 error
895		})
896	}
897	fake.netOutReturnsOnCall[i] = struct {
898		result1 error
899	}{result1}
900}
901
902func (fake *FakeContainer) Properties() (garden.Properties, error) {
903	fake.propertiesMutex.Lock()
904	ret, specificReturn := fake.propertiesReturnsOnCall[len(fake.propertiesArgsForCall)]
905	fake.propertiesArgsForCall = append(fake.propertiesArgsForCall, struct {
906	}{})
907	fake.recordInvocation("Properties", []interface{}{})
908	fake.propertiesMutex.Unlock()
909	if fake.PropertiesStub != nil {
910		return fake.PropertiesStub()
911	}
912	if specificReturn {
913		return ret.result1, ret.result2
914	}
915	fakeReturns := fake.propertiesReturns
916	return fakeReturns.result1, fakeReturns.result2
917}
918
919func (fake *FakeContainer) PropertiesCallCount() int {
920	fake.propertiesMutex.RLock()
921	defer fake.propertiesMutex.RUnlock()
922	return len(fake.propertiesArgsForCall)
923}
924
925func (fake *FakeContainer) PropertiesCalls(stub func() (garden.Properties, error)) {
926	fake.propertiesMutex.Lock()
927	defer fake.propertiesMutex.Unlock()
928	fake.PropertiesStub = stub
929}
930
931func (fake *FakeContainer) PropertiesReturns(result1 garden.Properties, result2 error) {
932	fake.propertiesMutex.Lock()
933	defer fake.propertiesMutex.Unlock()
934	fake.PropertiesStub = nil
935	fake.propertiesReturns = struct {
936		result1 garden.Properties
937		result2 error
938	}{result1, result2}
939}
940
941func (fake *FakeContainer) PropertiesReturnsOnCall(i int, result1 garden.Properties, result2 error) {
942	fake.propertiesMutex.Lock()
943	defer fake.propertiesMutex.Unlock()
944	fake.PropertiesStub = nil
945	if fake.propertiesReturnsOnCall == nil {
946		fake.propertiesReturnsOnCall = make(map[int]struct {
947			result1 garden.Properties
948			result2 error
949		})
950	}
951	fake.propertiesReturnsOnCall[i] = struct {
952		result1 garden.Properties
953		result2 error
954	}{result1, result2}
955}
956
957func (fake *FakeContainer) Property(arg1 string) (string, error) {
958	fake.propertyMutex.Lock()
959	ret, specificReturn := fake.propertyReturnsOnCall[len(fake.propertyArgsForCall)]
960	fake.propertyArgsForCall = append(fake.propertyArgsForCall, struct {
961		arg1 string
962	}{arg1})
963	fake.recordInvocation("Property", []interface{}{arg1})
964	fake.propertyMutex.Unlock()
965	if fake.PropertyStub != nil {
966		return fake.PropertyStub(arg1)
967	}
968	if specificReturn {
969		return ret.result1, ret.result2
970	}
971	fakeReturns := fake.propertyReturns
972	return fakeReturns.result1, fakeReturns.result2
973}
974
975func (fake *FakeContainer) PropertyCallCount() int {
976	fake.propertyMutex.RLock()
977	defer fake.propertyMutex.RUnlock()
978	return len(fake.propertyArgsForCall)
979}
980
981func (fake *FakeContainer) PropertyCalls(stub func(string) (string, error)) {
982	fake.propertyMutex.Lock()
983	defer fake.propertyMutex.Unlock()
984	fake.PropertyStub = stub
985}
986
987func (fake *FakeContainer) PropertyArgsForCall(i int) string {
988	fake.propertyMutex.RLock()
989	defer fake.propertyMutex.RUnlock()
990	argsForCall := fake.propertyArgsForCall[i]
991	return argsForCall.arg1
992}
993
994func (fake *FakeContainer) PropertyReturns(result1 string, result2 error) {
995	fake.propertyMutex.Lock()
996	defer fake.propertyMutex.Unlock()
997	fake.PropertyStub = nil
998	fake.propertyReturns = struct {
999		result1 string
1000		result2 error
1001	}{result1, result2}
1002}
1003
1004func (fake *FakeContainer) PropertyReturnsOnCall(i int, result1 string, result2 error) {
1005	fake.propertyMutex.Lock()
1006	defer fake.propertyMutex.Unlock()
1007	fake.PropertyStub = nil
1008	if fake.propertyReturnsOnCall == nil {
1009		fake.propertyReturnsOnCall = make(map[int]struct {
1010			result1 string
1011			result2 error
1012		})
1013	}
1014	fake.propertyReturnsOnCall[i] = struct {
1015		result1 string
1016		result2 error
1017	}{result1, result2}
1018}
1019
1020func (fake *FakeContainer) RemoveProperty(arg1 string) error {
1021	fake.removePropertyMutex.Lock()
1022	ret, specificReturn := fake.removePropertyReturnsOnCall[len(fake.removePropertyArgsForCall)]
1023	fake.removePropertyArgsForCall = append(fake.removePropertyArgsForCall, struct {
1024		arg1 string
1025	}{arg1})
1026	fake.recordInvocation("RemoveProperty", []interface{}{arg1})
1027	fake.removePropertyMutex.Unlock()
1028	if fake.RemovePropertyStub != nil {
1029		return fake.RemovePropertyStub(arg1)
1030	}
1031	if specificReturn {
1032		return ret.result1
1033	}
1034	fakeReturns := fake.removePropertyReturns
1035	return fakeReturns.result1
1036}
1037
1038func (fake *FakeContainer) RemovePropertyCallCount() int {
1039	fake.removePropertyMutex.RLock()
1040	defer fake.removePropertyMutex.RUnlock()
1041	return len(fake.removePropertyArgsForCall)
1042}
1043
1044func (fake *FakeContainer) RemovePropertyCalls(stub func(string) error) {
1045	fake.removePropertyMutex.Lock()
1046	defer fake.removePropertyMutex.Unlock()
1047	fake.RemovePropertyStub = stub
1048}
1049
1050func (fake *FakeContainer) RemovePropertyArgsForCall(i int) string {
1051	fake.removePropertyMutex.RLock()
1052	defer fake.removePropertyMutex.RUnlock()
1053	argsForCall := fake.removePropertyArgsForCall[i]
1054	return argsForCall.arg1
1055}
1056
1057func (fake *FakeContainer) RemovePropertyReturns(result1 error) {
1058	fake.removePropertyMutex.Lock()
1059	defer fake.removePropertyMutex.Unlock()
1060	fake.RemovePropertyStub = nil
1061	fake.removePropertyReturns = struct {
1062		result1 error
1063	}{result1}
1064}
1065
1066func (fake *FakeContainer) RemovePropertyReturnsOnCall(i int, result1 error) {
1067	fake.removePropertyMutex.Lock()
1068	defer fake.removePropertyMutex.Unlock()
1069	fake.RemovePropertyStub = nil
1070	if fake.removePropertyReturnsOnCall == nil {
1071		fake.removePropertyReturnsOnCall = make(map[int]struct {
1072			result1 error
1073		})
1074	}
1075	fake.removePropertyReturnsOnCall[i] = struct {
1076		result1 error
1077	}{result1}
1078}
1079
1080func (fake *FakeContainer) Run(arg1 context.Context, arg2 garden.ProcessSpec, arg3 garden.ProcessIO) (garden.Process, error) {
1081	fake.runMutex.Lock()
1082	ret, specificReturn := fake.runReturnsOnCall[len(fake.runArgsForCall)]
1083	fake.runArgsForCall = append(fake.runArgsForCall, struct {
1084		arg1 context.Context
1085		arg2 garden.ProcessSpec
1086		arg3 garden.ProcessIO
1087	}{arg1, arg2, arg3})
1088	fake.recordInvocation("Run", []interface{}{arg1, arg2, arg3})
1089	fake.runMutex.Unlock()
1090	if fake.RunStub != nil {
1091		return fake.RunStub(arg1, arg2, arg3)
1092	}
1093	if specificReturn {
1094		return ret.result1, ret.result2
1095	}
1096	fakeReturns := fake.runReturns
1097	return fakeReturns.result1, fakeReturns.result2
1098}
1099
1100func (fake *FakeContainer) RunCallCount() int {
1101	fake.runMutex.RLock()
1102	defer fake.runMutex.RUnlock()
1103	return len(fake.runArgsForCall)
1104}
1105
1106func (fake *FakeContainer) RunCalls(stub func(context.Context, garden.ProcessSpec, garden.ProcessIO) (garden.Process, error)) {
1107	fake.runMutex.Lock()
1108	defer fake.runMutex.Unlock()
1109	fake.RunStub = stub
1110}
1111
1112func (fake *FakeContainer) RunArgsForCall(i int) (context.Context, garden.ProcessSpec, garden.ProcessIO) {
1113	fake.runMutex.RLock()
1114	defer fake.runMutex.RUnlock()
1115	argsForCall := fake.runArgsForCall[i]
1116	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
1117}
1118
1119func (fake *FakeContainer) RunReturns(result1 garden.Process, result2 error) {
1120	fake.runMutex.Lock()
1121	defer fake.runMutex.Unlock()
1122	fake.RunStub = nil
1123	fake.runReturns = struct {
1124		result1 garden.Process
1125		result2 error
1126	}{result1, result2}
1127}
1128
1129func (fake *FakeContainer) RunReturnsOnCall(i int, result1 garden.Process, result2 error) {
1130	fake.runMutex.Lock()
1131	defer fake.runMutex.Unlock()
1132	fake.RunStub = nil
1133	if fake.runReturnsOnCall == nil {
1134		fake.runReturnsOnCall = make(map[int]struct {
1135			result1 garden.Process
1136			result2 error
1137		})
1138	}
1139	fake.runReturnsOnCall[i] = struct {
1140		result1 garden.Process
1141		result2 error
1142	}{result1, result2}
1143}
1144
1145func (fake *FakeContainer) SetGraceTime(arg1 time.Duration) error {
1146	fake.setGraceTimeMutex.Lock()
1147	ret, specificReturn := fake.setGraceTimeReturnsOnCall[len(fake.setGraceTimeArgsForCall)]
1148	fake.setGraceTimeArgsForCall = append(fake.setGraceTimeArgsForCall, struct {
1149		arg1 time.Duration
1150	}{arg1})
1151	fake.recordInvocation("SetGraceTime", []interface{}{arg1})
1152	fake.setGraceTimeMutex.Unlock()
1153	if fake.SetGraceTimeStub != nil {
1154		return fake.SetGraceTimeStub(arg1)
1155	}
1156	if specificReturn {
1157		return ret.result1
1158	}
1159	fakeReturns := fake.setGraceTimeReturns
1160	return fakeReturns.result1
1161}
1162
1163func (fake *FakeContainer) SetGraceTimeCallCount() int {
1164	fake.setGraceTimeMutex.RLock()
1165	defer fake.setGraceTimeMutex.RUnlock()
1166	return len(fake.setGraceTimeArgsForCall)
1167}
1168
1169func (fake *FakeContainer) SetGraceTimeCalls(stub func(time.Duration) error) {
1170	fake.setGraceTimeMutex.Lock()
1171	defer fake.setGraceTimeMutex.Unlock()
1172	fake.SetGraceTimeStub = stub
1173}
1174
1175func (fake *FakeContainer) SetGraceTimeArgsForCall(i int) time.Duration {
1176	fake.setGraceTimeMutex.RLock()
1177	defer fake.setGraceTimeMutex.RUnlock()
1178	argsForCall := fake.setGraceTimeArgsForCall[i]
1179	return argsForCall.arg1
1180}
1181
1182func (fake *FakeContainer) SetGraceTimeReturns(result1 error) {
1183	fake.setGraceTimeMutex.Lock()
1184	defer fake.setGraceTimeMutex.Unlock()
1185	fake.SetGraceTimeStub = nil
1186	fake.setGraceTimeReturns = struct {
1187		result1 error
1188	}{result1}
1189}
1190
1191func (fake *FakeContainer) SetGraceTimeReturnsOnCall(i int, result1 error) {
1192	fake.setGraceTimeMutex.Lock()
1193	defer fake.setGraceTimeMutex.Unlock()
1194	fake.SetGraceTimeStub = nil
1195	if fake.setGraceTimeReturnsOnCall == nil {
1196		fake.setGraceTimeReturnsOnCall = make(map[int]struct {
1197			result1 error
1198		})
1199	}
1200	fake.setGraceTimeReturnsOnCall[i] = struct {
1201		result1 error
1202	}{result1}
1203}
1204
1205func (fake *FakeContainer) SetProperty(arg1 string, arg2 string) error {
1206	fake.setPropertyMutex.Lock()
1207	ret, specificReturn := fake.setPropertyReturnsOnCall[len(fake.setPropertyArgsForCall)]
1208	fake.setPropertyArgsForCall = append(fake.setPropertyArgsForCall, struct {
1209		arg1 string
1210		arg2 string
1211	}{arg1, arg2})
1212	fake.recordInvocation("SetProperty", []interface{}{arg1, arg2})
1213	fake.setPropertyMutex.Unlock()
1214	if fake.SetPropertyStub != nil {
1215		return fake.SetPropertyStub(arg1, arg2)
1216	}
1217	if specificReturn {
1218		return ret.result1
1219	}
1220	fakeReturns := fake.setPropertyReturns
1221	return fakeReturns.result1
1222}
1223
1224func (fake *FakeContainer) SetPropertyCallCount() int {
1225	fake.setPropertyMutex.RLock()
1226	defer fake.setPropertyMutex.RUnlock()
1227	return len(fake.setPropertyArgsForCall)
1228}
1229
1230func (fake *FakeContainer) SetPropertyCalls(stub func(string, string) error) {
1231	fake.setPropertyMutex.Lock()
1232	defer fake.setPropertyMutex.Unlock()
1233	fake.SetPropertyStub = stub
1234}
1235
1236func (fake *FakeContainer) SetPropertyArgsForCall(i int) (string, string) {
1237	fake.setPropertyMutex.RLock()
1238	defer fake.setPropertyMutex.RUnlock()
1239	argsForCall := fake.setPropertyArgsForCall[i]
1240	return argsForCall.arg1, argsForCall.arg2
1241}
1242
1243func (fake *FakeContainer) SetPropertyReturns(result1 error) {
1244	fake.setPropertyMutex.Lock()
1245	defer fake.setPropertyMutex.Unlock()
1246	fake.SetPropertyStub = nil
1247	fake.setPropertyReturns = struct {
1248		result1 error
1249	}{result1}
1250}
1251
1252func (fake *FakeContainer) SetPropertyReturnsOnCall(i int, result1 error) {
1253	fake.setPropertyMutex.Lock()
1254	defer fake.setPropertyMutex.Unlock()
1255	fake.SetPropertyStub = nil
1256	if fake.setPropertyReturnsOnCall == nil {
1257		fake.setPropertyReturnsOnCall = make(map[int]struct {
1258			result1 error
1259		})
1260	}
1261	fake.setPropertyReturnsOnCall[i] = struct {
1262		result1 error
1263	}{result1}
1264}
1265
1266func (fake *FakeContainer) Stop(arg1 bool) error {
1267	fake.stopMutex.Lock()
1268	ret, specificReturn := fake.stopReturnsOnCall[len(fake.stopArgsForCall)]
1269	fake.stopArgsForCall = append(fake.stopArgsForCall, struct {
1270		arg1 bool
1271	}{arg1})
1272	fake.recordInvocation("Stop", []interface{}{arg1})
1273	fake.stopMutex.Unlock()
1274	if fake.StopStub != nil {
1275		return fake.StopStub(arg1)
1276	}
1277	if specificReturn {
1278		return ret.result1
1279	}
1280	fakeReturns := fake.stopReturns
1281	return fakeReturns.result1
1282}
1283
1284func (fake *FakeContainer) StopCallCount() int {
1285	fake.stopMutex.RLock()
1286	defer fake.stopMutex.RUnlock()
1287	return len(fake.stopArgsForCall)
1288}
1289
1290func (fake *FakeContainer) StopCalls(stub func(bool) error) {
1291	fake.stopMutex.Lock()
1292	defer fake.stopMutex.Unlock()
1293	fake.StopStub = stub
1294}
1295
1296func (fake *FakeContainer) StopArgsForCall(i int) bool {
1297	fake.stopMutex.RLock()
1298	defer fake.stopMutex.RUnlock()
1299	argsForCall := fake.stopArgsForCall[i]
1300	return argsForCall.arg1
1301}
1302
1303func (fake *FakeContainer) StopReturns(result1 error) {
1304	fake.stopMutex.Lock()
1305	defer fake.stopMutex.Unlock()
1306	fake.StopStub = nil
1307	fake.stopReturns = struct {
1308		result1 error
1309	}{result1}
1310}
1311
1312func (fake *FakeContainer) StopReturnsOnCall(i int, result1 error) {
1313	fake.stopMutex.Lock()
1314	defer fake.stopMutex.Unlock()
1315	fake.StopStub = nil
1316	if fake.stopReturnsOnCall == nil {
1317		fake.stopReturnsOnCall = make(map[int]struct {
1318			result1 error
1319		})
1320	}
1321	fake.stopReturnsOnCall[i] = struct {
1322		result1 error
1323	}{result1}
1324}
1325
1326func (fake *FakeContainer) StreamIn(arg1 garden.StreamInSpec) error {
1327	fake.streamInMutex.Lock()
1328	ret, specificReturn := fake.streamInReturnsOnCall[len(fake.streamInArgsForCall)]
1329	fake.streamInArgsForCall = append(fake.streamInArgsForCall, struct {
1330		arg1 garden.StreamInSpec
1331	}{arg1})
1332	fake.recordInvocation("StreamIn", []interface{}{arg1})
1333	fake.streamInMutex.Unlock()
1334	if fake.StreamInStub != nil {
1335		return fake.StreamInStub(arg1)
1336	}
1337	if specificReturn {
1338		return ret.result1
1339	}
1340	fakeReturns := fake.streamInReturns
1341	return fakeReturns.result1
1342}
1343
1344func (fake *FakeContainer) StreamInCallCount() int {
1345	fake.streamInMutex.RLock()
1346	defer fake.streamInMutex.RUnlock()
1347	return len(fake.streamInArgsForCall)
1348}
1349
1350func (fake *FakeContainer) StreamInCalls(stub func(garden.StreamInSpec) error) {
1351	fake.streamInMutex.Lock()
1352	defer fake.streamInMutex.Unlock()
1353	fake.StreamInStub = stub
1354}
1355
1356func (fake *FakeContainer) StreamInArgsForCall(i int) garden.StreamInSpec {
1357	fake.streamInMutex.RLock()
1358	defer fake.streamInMutex.RUnlock()
1359	argsForCall := fake.streamInArgsForCall[i]
1360	return argsForCall.arg1
1361}
1362
1363func (fake *FakeContainer) StreamInReturns(result1 error) {
1364	fake.streamInMutex.Lock()
1365	defer fake.streamInMutex.Unlock()
1366	fake.StreamInStub = nil
1367	fake.streamInReturns = struct {
1368		result1 error
1369	}{result1}
1370}
1371
1372func (fake *FakeContainer) StreamInReturnsOnCall(i int, result1 error) {
1373	fake.streamInMutex.Lock()
1374	defer fake.streamInMutex.Unlock()
1375	fake.StreamInStub = nil
1376	if fake.streamInReturnsOnCall == nil {
1377		fake.streamInReturnsOnCall = make(map[int]struct {
1378			result1 error
1379		})
1380	}
1381	fake.streamInReturnsOnCall[i] = struct {
1382		result1 error
1383	}{result1}
1384}
1385
1386func (fake *FakeContainer) StreamOut(arg1 garden.StreamOutSpec) (io.ReadCloser, error) {
1387	fake.streamOutMutex.Lock()
1388	ret, specificReturn := fake.streamOutReturnsOnCall[len(fake.streamOutArgsForCall)]
1389	fake.streamOutArgsForCall = append(fake.streamOutArgsForCall, struct {
1390		arg1 garden.StreamOutSpec
1391	}{arg1})
1392	fake.recordInvocation("StreamOut", []interface{}{arg1})
1393	fake.streamOutMutex.Unlock()
1394	if fake.StreamOutStub != nil {
1395		return fake.StreamOutStub(arg1)
1396	}
1397	if specificReturn {
1398		return ret.result1, ret.result2
1399	}
1400	fakeReturns := fake.streamOutReturns
1401	return fakeReturns.result1, fakeReturns.result2
1402}
1403
1404func (fake *FakeContainer) StreamOutCallCount() int {
1405	fake.streamOutMutex.RLock()
1406	defer fake.streamOutMutex.RUnlock()
1407	return len(fake.streamOutArgsForCall)
1408}
1409
1410func (fake *FakeContainer) StreamOutCalls(stub func(garden.StreamOutSpec) (io.ReadCloser, error)) {
1411	fake.streamOutMutex.Lock()
1412	defer fake.streamOutMutex.Unlock()
1413	fake.StreamOutStub = stub
1414}
1415
1416func (fake *FakeContainer) StreamOutArgsForCall(i int) garden.StreamOutSpec {
1417	fake.streamOutMutex.RLock()
1418	defer fake.streamOutMutex.RUnlock()
1419	argsForCall := fake.streamOutArgsForCall[i]
1420	return argsForCall.arg1
1421}
1422
1423func (fake *FakeContainer) StreamOutReturns(result1 io.ReadCloser, result2 error) {
1424	fake.streamOutMutex.Lock()
1425	defer fake.streamOutMutex.Unlock()
1426	fake.StreamOutStub = nil
1427	fake.streamOutReturns = struct {
1428		result1 io.ReadCloser
1429		result2 error
1430	}{result1, result2}
1431}
1432
1433func (fake *FakeContainer) StreamOutReturnsOnCall(i int, result1 io.ReadCloser, result2 error) {
1434	fake.streamOutMutex.Lock()
1435	defer fake.streamOutMutex.Unlock()
1436	fake.StreamOutStub = nil
1437	if fake.streamOutReturnsOnCall == nil {
1438		fake.streamOutReturnsOnCall = make(map[int]struct {
1439			result1 io.ReadCloser
1440			result2 error
1441		})
1442	}
1443	fake.streamOutReturnsOnCall[i] = struct {
1444		result1 io.ReadCloser
1445		result2 error
1446	}{result1, result2}
1447}
1448
1449func (fake *FakeContainer) Invocations() map[string][][]interface{} {
1450	fake.invocationsMutex.RLock()
1451	defer fake.invocationsMutex.RUnlock()
1452	fake.attachMutex.RLock()
1453	defer fake.attachMutex.RUnlock()
1454	fake.bulkNetOutMutex.RLock()
1455	defer fake.bulkNetOutMutex.RUnlock()
1456	fake.currentBandwidthLimitsMutex.RLock()
1457	defer fake.currentBandwidthLimitsMutex.RUnlock()
1458	fake.currentCPULimitsMutex.RLock()
1459	defer fake.currentCPULimitsMutex.RUnlock()
1460	fake.currentDiskLimitsMutex.RLock()
1461	defer fake.currentDiskLimitsMutex.RUnlock()
1462	fake.currentMemoryLimitsMutex.RLock()
1463	defer fake.currentMemoryLimitsMutex.RUnlock()
1464	fake.handleMutex.RLock()
1465	defer fake.handleMutex.RUnlock()
1466	fake.infoMutex.RLock()
1467	defer fake.infoMutex.RUnlock()
1468	fake.metricsMutex.RLock()
1469	defer fake.metricsMutex.RUnlock()
1470	fake.netInMutex.RLock()
1471	defer fake.netInMutex.RUnlock()
1472	fake.netOutMutex.RLock()
1473	defer fake.netOutMutex.RUnlock()
1474	fake.propertiesMutex.RLock()
1475	defer fake.propertiesMutex.RUnlock()
1476	fake.propertyMutex.RLock()
1477	defer fake.propertyMutex.RUnlock()
1478	fake.removePropertyMutex.RLock()
1479	defer fake.removePropertyMutex.RUnlock()
1480	fake.runMutex.RLock()
1481	defer fake.runMutex.RUnlock()
1482	fake.setGraceTimeMutex.RLock()
1483	defer fake.setGraceTimeMutex.RUnlock()
1484	fake.setPropertyMutex.RLock()
1485	defer fake.setPropertyMutex.RUnlock()
1486	fake.stopMutex.RLock()
1487	defer fake.stopMutex.RUnlock()
1488	fake.streamInMutex.RLock()
1489	defer fake.streamInMutex.RUnlock()
1490	fake.streamOutMutex.RLock()
1491	defer fake.streamOutMutex.RUnlock()
1492	copiedInvocations := map[string][][]interface{}{}
1493	for key, value := range fake.invocations {
1494		copiedInvocations[key] = value
1495	}
1496	return copiedInvocations
1497}
1498
1499func (fake *FakeContainer) recordInvocation(key string, args []interface{}) {
1500	fake.invocationsMutex.Lock()
1501	defer fake.invocationsMutex.Unlock()
1502	if fake.invocations == nil {
1503		fake.invocations = map[string][][]interface{}{}
1504	}
1505	if fake.invocations[key] == nil {
1506		fake.invocations[key] = [][]interface{}{}
1507	}
1508	fake.invocations[key] = append(fake.invocations[key], args)
1509}
1510
1511var _ gclient.Container = new(FakeContainer)
1512