1// Code generated by counterfeiter. DO NOT EDIT.
2package execfakes
3
4import (
5	"io"
6	"sync"
7
8	"code.cloudfoundry.org/lager"
9	"github.com/concourse/concourse/atc"
10	"github.com/concourse/concourse/atc/db"
11	"github.com/concourse/concourse/atc/exec"
12	"github.com/concourse/concourse/vars"
13)
14
15type FakeTaskDelegate struct {
16	ErroredStub        func(lager.Logger, string)
17	erroredMutex       sync.RWMutex
18	erroredArgsForCall []struct {
19		arg1 lager.Logger
20		arg2 string
21	}
22	FinishedStub        func(lager.Logger, exec.ExitStatus)
23	finishedMutex       sync.RWMutex
24	finishedArgsForCall []struct {
25		arg1 lager.Logger
26		arg2 exec.ExitStatus
27	}
28	ImageVersionDeterminedStub        func(db.UsedResourceCache) error
29	imageVersionDeterminedMutex       sync.RWMutex
30	imageVersionDeterminedArgsForCall []struct {
31		arg1 db.UsedResourceCache
32	}
33	imageVersionDeterminedReturns struct {
34		result1 error
35	}
36	imageVersionDeterminedReturnsOnCall map[int]struct {
37		result1 error
38	}
39	InitializingStub        func(lager.Logger)
40	initializingMutex       sync.RWMutex
41	initializingArgsForCall []struct {
42		arg1 lager.Logger
43	}
44	RedactImageSourceStub        func(atc.Source) (atc.Source, error)
45	redactImageSourceMutex       sync.RWMutex
46	redactImageSourceArgsForCall []struct {
47		arg1 atc.Source
48	}
49	redactImageSourceReturns struct {
50		result1 atc.Source
51		result2 error
52	}
53	redactImageSourceReturnsOnCall map[int]struct {
54		result1 atc.Source
55		result2 error
56	}
57	SelectedWorkerStub        func(lager.Logger, string)
58	selectedWorkerMutex       sync.RWMutex
59	selectedWorkerArgsForCall []struct {
60		arg1 lager.Logger
61		arg2 string
62	}
63	SetTaskConfigStub        func(atc.TaskConfig)
64	setTaskConfigMutex       sync.RWMutex
65	setTaskConfigArgsForCall []struct {
66		arg1 atc.TaskConfig
67	}
68	StartingStub        func(lager.Logger)
69	startingMutex       sync.RWMutex
70	startingArgsForCall []struct {
71		arg1 lager.Logger
72	}
73	StderrStub        func() io.Writer
74	stderrMutex       sync.RWMutex
75	stderrArgsForCall []struct {
76	}
77	stderrReturns struct {
78		result1 io.Writer
79	}
80	stderrReturnsOnCall map[int]struct {
81		result1 io.Writer
82	}
83	StdoutStub        func() io.Writer
84	stdoutMutex       sync.RWMutex
85	stdoutArgsForCall []struct {
86	}
87	stdoutReturns struct {
88		result1 io.Writer
89	}
90	stdoutReturnsOnCall map[int]struct {
91		result1 io.Writer
92	}
93	VariablesStub        func() *vars.BuildVariables
94	variablesMutex       sync.RWMutex
95	variablesArgsForCall []struct {
96	}
97	variablesReturns struct {
98		result1 *vars.BuildVariables
99	}
100	variablesReturnsOnCall map[int]struct {
101		result1 *vars.BuildVariables
102	}
103	invocations      map[string][][]interface{}
104	invocationsMutex sync.RWMutex
105}
106
107func (fake *FakeTaskDelegate) Errored(arg1 lager.Logger, arg2 string) {
108	fake.erroredMutex.Lock()
109	fake.erroredArgsForCall = append(fake.erroredArgsForCall, struct {
110		arg1 lager.Logger
111		arg2 string
112	}{arg1, arg2})
113	fake.recordInvocation("Errored", []interface{}{arg1, arg2})
114	fake.erroredMutex.Unlock()
115	if fake.ErroredStub != nil {
116		fake.ErroredStub(arg1, arg2)
117	}
118}
119
120func (fake *FakeTaskDelegate) ErroredCallCount() int {
121	fake.erroredMutex.RLock()
122	defer fake.erroredMutex.RUnlock()
123	return len(fake.erroredArgsForCall)
124}
125
126func (fake *FakeTaskDelegate) ErroredCalls(stub func(lager.Logger, string)) {
127	fake.erroredMutex.Lock()
128	defer fake.erroredMutex.Unlock()
129	fake.ErroredStub = stub
130}
131
132func (fake *FakeTaskDelegate) ErroredArgsForCall(i int) (lager.Logger, string) {
133	fake.erroredMutex.RLock()
134	defer fake.erroredMutex.RUnlock()
135	argsForCall := fake.erroredArgsForCall[i]
136	return argsForCall.arg1, argsForCall.arg2
137}
138
139func (fake *FakeTaskDelegate) Finished(arg1 lager.Logger, arg2 exec.ExitStatus) {
140	fake.finishedMutex.Lock()
141	fake.finishedArgsForCall = append(fake.finishedArgsForCall, struct {
142		arg1 lager.Logger
143		arg2 exec.ExitStatus
144	}{arg1, arg2})
145	fake.recordInvocation("Finished", []interface{}{arg1, arg2})
146	fake.finishedMutex.Unlock()
147	if fake.FinishedStub != nil {
148		fake.FinishedStub(arg1, arg2)
149	}
150}
151
152func (fake *FakeTaskDelegate) FinishedCallCount() int {
153	fake.finishedMutex.RLock()
154	defer fake.finishedMutex.RUnlock()
155	return len(fake.finishedArgsForCall)
156}
157
158func (fake *FakeTaskDelegate) FinishedCalls(stub func(lager.Logger, exec.ExitStatus)) {
159	fake.finishedMutex.Lock()
160	defer fake.finishedMutex.Unlock()
161	fake.FinishedStub = stub
162}
163
164func (fake *FakeTaskDelegate) FinishedArgsForCall(i int) (lager.Logger, exec.ExitStatus) {
165	fake.finishedMutex.RLock()
166	defer fake.finishedMutex.RUnlock()
167	argsForCall := fake.finishedArgsForCall[i]
168	return argsForCall.arg1, argsForCall.arg2
169}
170
171func (fake *FakeTaskDelegate) ImageVersionDetermined(arg1 db.UsedResourceCache) error {
172	fake.imageVersionDeterminedMutex.Lock()
173	ret, specificReturn := fake.imageVersionDeterminedReturnsOnCall[len(fake.imageVersionDeterminedArgsForCall)]
174	fake.imageVersionDeterminedArgsForCall = append(fake.imageVersionDeterminedArgsForCall, struct {
175		arg1 db.UsedResourceCache
176	}{arg1})
177	fake.recordInvocation("ImageVersionDetermined", []interface{}{arg1})
178	fake.imageVersionDeterminedMutex.Unlock()
179	if fake.ImageVersionDeterminedStub != nil {
180		return fake.ImageVersionDeterminedStub(arg1)
181	}
182	if specificReturn {
183		return ret.result1
184	}
185	fakeReturns := fake.imageVersionDeterminedReturns
186	return fakeReturns.result1
187}
188
189func (fake *FakeTaskDelegate) ImageVersionDeterminedCallCount() int {
190	fake.imageVersionDeterminedMutex.RLock()
191	defer fake.imageVersionDeterminedMutex.RUnlock()
192	return len(fake.imageVersionDeterminedArgsForCall)
193}
194
195func (fake *FakeTaskDelegate) ImageVersionDeterminedCalls(stub func(db.UsedResourceCache) error) {
196	fake.imageVersionDeterminedMutex.Lock()
197	defer fake.imageVersionDeterminedMutex.Unlock()
198	fake.ImageVersionDeterminedStub = stub
199}
200
201func (fake *FakeTaskDelegate) ImageVersionDeterminedArgsForCall(i int) db.UsedResourceCache {
202	fake.imageVersionDeterminedMutex.RLock()
203	defer fake.imageVersionDeterminedMutex.RUnlock()
204	argsForCall := fake.imageVersionDeterminedArgsForCall[i]
205	return argsForCall.arg1
206}
207
208func (fake *FakeTaskDelegate) ImageVersionDeterminedReturns(result1 error) {
209	fake.imageVersionDeterminedMutex.Lock()
210	defer fake.imageVersionDeterminedMutex.Unlock()
211	fake.ImageVersionDeterminedStub = nil
212	fake.imageVersionDeterminedReturns = struct {
213		result1 error
214	}{result1}
215}
216
217func (fake *FakeTaskDelegate) ImageVersionDeterminedReturnsOnCall(i int, result1 error) {
218	fake.imageVersionDeterminedMutex.Lock()
219	defer fake.imageVersionDeterminedMutex.Unlock()
220	fake.ImageVersionDeterminedStub = nil
221	if fake.imageVersionDeterminedReturnsOnCall == nil {
222		fake.imageVersionDeterminedReturnsOnCall = make(map[int]struct {
223			result1 error
224		})
225	}
226	fake.imageVersionDeterminedReturnsOnCall[i] = struct {
227		result1 error
228	}{result1}
229}
230
231func (fake *FakeTaskDelegate) Initializing(arg1 lager.Logger) {
232	fake.initializingMutex.Lock()
233	fake.initializingArgsForCall = append(fake.initializingArgsForCall, struct {
234		arg1 lager.Logger
235	}{arg1})
236	fake.recordInvocation("Initializing", []interface{}{arg1})
237	fake.initializingMutex.Unlock()
238	if fake.InitializingStub != nil {
239		fake.InitializingStub(arg1)
240	}
241}
242
243func (fake *FakeTaskDelegate) InitializingCallCount() int {
244	fake.initializingMutex.RLock()
245	defer fake.initializingMutex.RUnlock()
246	return len(fake.initializingArgsForCall)
247}
248
249func (fake *FakeTaskDelegate) InitializingCalls(stub func(lager.Logger)) {
250	fake.initializingMutex.Lock()
251	defer fake.initializingMutex.Unlock()
252	fake.InitializingStub = stub
253}
254
255func (fake *FakeTaskDelegate) InitializingArgsForCall(i int) lager.Logger {
256	fake.initializingMutex.RLock()
257	defer fake.initializingMutex.RUnlock()
258	argsForCall := fake.initializingArgsForCall[i]
259	return argsForCall.arg1
260}
261
262func (fake *FakeTaskDelegate) RedactImageSource(arg1 atc.Source) (atc.Source, error) {
263	fake.redactImageSourceMutex.Lock()
264	ret, specificReturn := fake.redactImageSourceReturnsOnCall[len(fake.redactImageSourceArgsForCall)]
265	fake.redactImageSourceArgsForCall = append(fake.redactImageSourceArgsForCall, struct {
266		arg1 atc.Source
267	}{arg1})
268	fake.recordInvocation("RedactImageSource", []interface{}{arg1})
269	fake.redactImageSourceMutex.Unlock()
270	if fake.RedactImageSourceStub != nil {
271		return fake.RedactImageSourceStub(arg1)
272	}
273	if specificReturn {
274		return ret.result1, ret.result2
275	}
276	fakeReturns := fake.redactImageSourceReturns
277	return fakeReturns.result1, fakeReturns.result2
278}
279
280func (fake *FakeTaskDelegate) RedactImageSourceCallCount() int {
281	fake.redactImageSourceMutex.RLock()
282	defer fake.redactImageSourceMutex.RUnlock()
283	return len(fake.redactImageSourceArgsForCall)
284}
285
286func (fake *FakeTaskDelegate) RedactImageSourceCalls(stub func(atc.Source) (atc.Source, error)) {
287	fake.redactImageSourceMutex.Lock()
288	defer fake.redactImageSourceMutex.Unlock()
289	fake.RedactImageSourceStub = stub
290}
291
292func (fake *FakeTaskDelegate) RedactImageSourceArgsForCall(i int) atc.Source {
293	fake.redactImageSourceMutex.RLock()
294	defer fake.redactImageSourceMutex.RUnlock()
295	argsForCall := fake.redactImageSourceArgsForCall[i]
296	return argsForCall.arg1
297}
298
299func (fake *FakeTaskDelegate) RedactImageSourceReturns(result1 atc.Source, result2 error) {
300	fake.redactImageSourceMutex.Lock()
301	defer fake.redactImageSourceMutex.Unlock()
302	fake.RedactImageSourceStub = nil
303	fake.redactImageSourceReturns = struct {
304		result1 atc.Source
305		result2 error
306	}{result1, result2}
307}
308
309func (fake *FakeTaskDelegate) RedactImageSourceReturnsOnCall(i int, result1 atc.Source, result2 error) {
310	fake.redactImageSourceMutex.Lock()
311	defer fake.redactImageSourceMutex.Unlock()
312	fake.RedactImageSourceStub = nil
313	if fake.redactImageSourceReturnsOnCall == nil {
314		fake.redactImageSourceReturnsOnCall = make(map[int]struct {
315			result1 atc.Source
316			result2 error
317		})
318	}
319	fake.redactImageSourceReturnsOnCall[i] = struct {
320		result1 atc.Source
321		result2 error
322	}{result1, result2}
323}
324
325func (fake *FakeTaskDelegate) SelectedWorker(arg1 lager.Logger, arg2 string) {
326	fake.selectedWorkerMutex.Lock()
327	fake.selectedWorkerArgsForCall = append(fake.selectedWorkerArgsForCall, struct {
328		arg1 lager.Logger
329		arg2 string
330	}{arg1, arg2})
331	fake.recordInvocation("SelectedWorker", []interface{}{arg1, arg2})
332	fake.selectedWorkerMutex.Unlock()
333	if fake.SelectedWorkerStub != nil {
334		fake.SelectedWorkerStub(arg1, arg2)
335	}
336}
337
338func (fake *FakeTaskDelegate) SelectedWorkerCallCount() int {
339	fake.selectedWorkerMutex.RLock()
340	defer fake.selectedWorkerMutex.RUnlock()
341	return len(fake.selectedWorkerArgsForCall)
342}
343
344func (fake *FakeTaskDelegate) SelectedWorkerCalls(stub func(lager.Logger, string)) {
345	fake.selectedWorkerMutex.Lock()
346	defer fake.selectedWorkerMutex.Unlock()
347	fake.SelectedWorkerStub = stub
348}
349
350func (fake *FakeTaskDelegate) SelectedWorkerArgsForCall(i int) (lager.Logger, string) {
351	fake.selectedWorkerMutex.RLock()
352	defer fake.selectedWorkerMutex.RUnlock()
353	argsForCall := fake.selectedWorkerArgsForCall[i]
354	return argsForCall.arg1, argsForCall.arg2
355}
356
357func (fake *FakeTaskDelegate) SetTaskConfig(arg1 atc.TaskConfig) {
358	fake.setTaskConfigMutex.Lock()
359	fake.setTaskConfigArgsForCall = append(fake.setTaskConfigArgsForCall, struct {
360		arg1 atc.TaskConfig
361	}{arg1})
362	fake.recordInvocation("SetTaskConfig", []interface{}{arg1})
363	fake.setTaskConfigMutex.Unlock()
364	if fake.SetTaskConfigStub != nil {
365		fake.SetTaskConfigStub(arg1)
366	}
367}
368
369func (fake *FakeTaskDelegate) SetTaskConfigCallCount() int {
370	fake.setTaskConfigMutex.RLock()
371	defer fake.setTaskConfigMutex.RUnlock()
372	return len(fake.setTaskConfigArgsForCall)
373}
374
375func (fake *FakeTaskDelegate) SetTaskConfigCalls(stub func(atc.TaskConfig)) {
376	fake.setTaskConfigMutex.Lock()
377	defer fake.setTaskConfigMutex.Unlock()
378	fake.SetTaskConfigStub = stub
379}
380
381func (fake *FakeTaskDelegate) SetTaskConfigArgsForCall(i int) atc.TaskConfig {
382	fake.setTaskConfigMutex.RLock()
383	defer fake.setTaskConfigMutex.RUnlock()
384	argsForCall := fake.setTaskConfigArgsForCall[i]
385	return argsForCall.arg1
386}
387
388func (fake *FakeTaskDelegate) Starting(arg1 lager.Logger) {
389	fake.startingMutex.Lock()
390	fake.startingArgsForCall = append(fake.startingArgsForCall, struct {
391		arg1 lager.Logger
392	}{arg1})
393	fake.recordInvocation("Starting", []interface{}{arg1})
394	fake.startingMutex.Unlock()
395	if fake.StartingStub != nil {
396		fake.StartingStub(arg1)
397	}
398}
399
400func (fake *FakeTaskDelegate) StartingCallCount() int {
401	fake.startingMutex.RLock()
402	defer fake.startingMutex.RUnlock()
403	return len(fake.startingArgsForCall)
404}
405
406func (fake *FakeTaskDelegate) StartingCalls(stub func(lager.Logger)) {
407	fake.startingMutex.Lock()
408	defer fake.startingMutex.Unlock()
409	fake.StartingStub = stub
410}
411
412func (fake *FakeTaskDelegate) StartingArgsForCall(i int) lager.Logger {
413	fake.startingMutex.RLock()
414	defer fake.startingMutex.RUnlock()
415	argsForCall := fake.startingArgsForCall[i]
416	return argsForCall.arg1
417}
418
419func (fake *FakeTaskDelegate) Stderr() io.Writer {
420	fake.stderrMutex.Lock()
421	ret, specificReturn := fake.stderrReturnsOnCall[len(fake.stderrArgsForCall)]
422	fake.stderrArgsForCall = append(fake.stderrArgsForCall, struct {
423	}{})
424	fake.recordInvocation("Stderr", []interface{}{})
425	fake.stderrMutex.Unlock()
426	if fake.StderrStub != nil {
427		return fake.StderrStub()
428	}
429	if specificReturn {
430		return ret.result1
431	}
432	fakeReturns := fake.stderrReturns
433	return fakeReturns.result1
434}
435
436func (fake *FakeTaskDelegate) StderrCallCount() int {
437	fake.stderrMutex.RLock()
438	defer fake.stderrMutex.RUnlock()
439	return len(fake.stderrArgsForCall)
440}
441
442func (fake *FakeTaskDelegate) StderrCalls(stub func() io.Writer) {
443	fake.stderrMutex.Lock()
444	defer fake.stderrMutex.Unlock()
445	fake.StderrStub = stub
446}
447
448func (fake *FakeTaskDelegate) StderrReturns(result1 io.Writer) {
449	fake.stderrMutex.Lock()
450	defer fake.stderrMutex.Unlock()
451	fake.StderrStub = nil
452	fake.stderrReturns = struct {
453		result1 io.Writer
454	}{result1}
455}
456
457func (fake *FakeTaskDelegate) StderrReturnsOnCall(i int, result1 io.Writer) {
458	fake.stderrMutex.Lock()
459	defer fake.stderrMutex.Unlock()
460	fake.StderrStub = nil
461	if fake.stderrReturnsOnCall == nil {
462		fake.stderrReturnsOnCall = make(map[int]struct {
463			result1 io.Writer
464		})
465	}
466	fake.stderrReturnsOnCall[i] = struct {
467		result1 io.Writer
468	}{result1}
469}
470
471func (fake *FakeTaskDelegate) Stdout() io.Writer {
472	fake.stdoutMutex.Lock()
473	ret, specificReturn := fake.stdoutReturnsOnCall[len(fake.stdoutArgsForCall)]
474	fake.stdoutArgsForCall = append(fake.stdoutArgsForCall, struct {
475	}{})
476	fake.recordInvocation("Stdout", []interface{}{})
477	fake.stdoutMutex.Unlock()
478	if fake.StdoutStub != nil {
479		return fake.StdoutStub()
480	}
481	if specificReturn {
482		return ret.result1
483	}
484	fakeReturns := fake.stdoutReturns
485	return fakeReturns.result1
486}
487
488func (fake *FakeTaskDelegate) StdoutCallCount() int {
489	fake.stdoutMutex.RLock()
490	defer fake.stdoutMutex.RUnlock()
491	return len(fake.stdoutArgsForCall)
492}
493
494func (fake *FakeTaskDelegate) StdoutCalls(stub func() io.Writer) {
495	fake.stdoutMutex.Lock()
496	defer fake.stdoutMutex.Unlock()
497	fake.StdoutStub = stub
498}
499
500func (fake *FakeTaskDelegate) StdoutReturns(result1 io.Writer) {
501	fake.stdoutMutex.Lock()
502	defer fake.stdoutMutex.Unlock()
503	fake.StdoutStub = nil
504	fake.stdoutReturns = struct {
505		result1 io.Writer
506	}{result1}
507}
508
509func (fake *FakeTaskDelegate) StdoutReturnsOnCall(i int, result1 io.Writer) {
510	fake.stdoutMutex.Lock()
511	defer fake.stdoutMutex.Unlock()
512	fake.StdoutStub = nil
513	if fake.stdoutReturnsOnCall == nil {
514		fake.stdoutReturnsOnCall = make(map[int]struct {
515			result1 io.Writer
516		})
517	}
518	fake.stdoutReturnsOnCall[i] = struct {
519		result1 io.Writer
520	}{result1}
521}
522
523func (fake *FakeTaskDelegate) Variables() *vars.BuildVariables {
524	fake.variablesMutex.Lock()
525	ret, specificReturn := fake.variablesReturnsOnCall[len(fake.variablesArgsForCall)]
526	fake.variablesArgsForCall = append(fake.variablesArgsForCall, struct {
527	}{})
528	fake.recordInvocation("Variables", []interface{}{})
529	fake.variablesMutex.Unlock()
530	if fake.VariablesStub != nil {
531		return fake.VariablesStub()
532	}
533	if specificReturn {
534		return ret.result1
535	}
536	fakeReturns := fake.variablesReturns
537	return fakeReturns.result1
538}
539
540func (fake *FakeTaskDelegate) VariablesCallCount() int {
541	fake.variablesMutex.RLock()
542	defer fake.variablesMutex.RUnlock()
543	return len(fake.variablesArgsForCall)
544}
545
546func (fake *FakeTaskDelegate) VariablesCalls(stub func() *vars.BuildVariables) {
547	fake.variablesMutex.Lock()
548	defer fake.variablesMutex.Unlock()
549	fake.VariablesStub = stub
550}
551
552func (fake *FakeTaskDelegate) VariablesReturns(result1 *vars.BuildVariables) {
553	fake.variablesMutex.Lock()
554	defer fake.variablesMutex.Unlock()
555	fake.VariablesStub = nil
556	fake.variablesReturns = struct {
557		result1 *vars.BuildVariables
558	}{result1}
559}
560
561func (fake *FakeTaskDelegate) VariablesReturnsOnCall(i int, result1 *vars.BuildVariables) {
562	fake.variablesMutex.Lock()
563	defer fake.variablesMutex.Unlock()
564	fake.VariablesStub = nil
565	if fake.variablesReturnsOnCall == nil {
566		fake.variablesReturnsOnCall = make(map[int]struct {
567			result1 *vars.BuildVariables
568		})
569	}
570	fake.variablesReturnsOnCall[i] = struct {
571		result1 *vars.BuildVariables
572	}{result1}
573}
574
575func (fake *FakeTaskDelegate) Invocations() map[string][][]interface{} {
576	fake.invocationsMutex.RLock()
577	defer fake.invocationsMutex.RUnlock()
578	fake.erroredMutex.RLock()
579	defer fake.erroredMutex.RUnlock()
580	fake.finishedMutex.RLock()
581	defer fake.finishedMutex.RUnlock()
582	fake.imageVersionDeterminedMutex.RLock()
583	defer fake.imageVersionDeterminedMutex.RUnlock()
584	fake.initializingMutex.RLock()
585	defer fake.initializingMutex.RUnlock()
586	fake.redactImageSourceMutex.RLock()
587	defer fake.redactImageSourceMutex.RUnlock()
588	fake.selectedWorkerMutex.RLock()
589	defer fake.selectedWorkerMutex.RUnlock()
590	fake.setTaskConfigMutex.RLock()
591	defer fake.setTaskConfigMutex.RUnlock()
592	fake.startingMutex.RLock()
593	defer fake.startingMutex.RUnlock()
594	fake.stderrMutex.RLock()
595	defer fake.stderrMutex.RUnlock()
596	fake.stdoutMutex.RLock()
597	defer fake.stdoutMutex.RUnlock()
598	fake.variablesMutex.RLock()
599	defer fake.variablesMutex.RUnlock()
600	copiedInvocations := map[string][][]interface{}{}
601	for key, value := range fake.invocations {
602		copiedInvocations[key] = value
603	}
604	return copiedInvocations
605}
606
607func (fake *FakeTaskDelegate) recordInvocation(key string, args []interface{}) {
608	fake.invocationsMutex.Lock()
609	defer fake.invocationsMutex.Unlock()
610	if fake.invocations == nil {
611		fake.invocations = map[string][][]interface{}{}
612	}
613	if fake.invocations[key] == nil {
614		fake.invocations[key] = [][]interface{}{}
615	}
616	fake.invocations[key] = append(fake.invocations[key], args)
617}
618
619var _ exec.TaskDelegate = new(FakeTaskDelegate)
620