1// Code generated by counterfeiter. DO NOT EDIT.
2package releasedirfakes
3
4import (
5	"sync"
6
7	boshrel "github.com/cloudfoundry/bosh-cli/release"
8	boshpkg "github.com/cloudfoundry/bosh-cli/release/pkg"
9	"github.com/cloudfoundry/bosh-cli/releasedir"
10	semver "github.com/cppforlife/go-semi-semantic/version"
11)
12
13type FakeReleaseDir struct {
14	InitStub        func(bool) error
15	initMutex       sync.RWMutex
16	initArgsForCall []struct {
17		arg1 bool
18	}
19	initReturns struct {
20		result1 error
21	}
22	initReturnsOnCall map[int]struct {
23		result1 error
24	}
25	ResetStub        func() error
26	resetMutex       sync.RWMutex
27	resetArgsForCall []struct{}
28	resetReturns     struct {
29		result1 error
30	}
31	resetReturnsOnCall map[int]struct {
32		result1 error
33	}
34	GenerateJobStub        func(string) error
35	generateJobMutex       sync.RWMutex
36	generateJobArgsForCall []struct {
37		arg1 string
38	}
39	generateJobReturns struct {
40		result1 error
41	}
42	generateJobReturnsOnCall map[int]struct {
43		result1 error
44	}
45	GeneratePackageStub        func(string) error
46	generatePackageMutex       sync.RWMutex
47	generatePackageArgsForCall []struct {
48		arg1 string
49	}
50	generatePackageReturns struct {
51		result1 error
52	}
53	generatePackageReturnsOnCall map[int]struct {
54		result1 error
55	}
56	DefaultNameStub        func() (string, error)
57	defaultNameMutex       sync.RWMutex
58	defaultNameArgsForCall []struct{}
59	defaultNameReturns     struct {
60		result1 string
61		result2 error
62	}
63	defaultNameReturnsOnCall map[int]struct {
64		result1 string
65		result2 error
66	}
67	NextDevVersionStub        func(name string, timestamp bool) (semver.Version, error)
68	nextDevVersionMutex       sync.RWMutex
69	nextDevVersionArgsForCall []struct {
70		name      string
71		timestamp bool
72	}
73	nextDevVersionReturns struct {
74		result1 semver.Version
75		result2 error
76	}
77	nextDevVersionReturnsOnCall map[int]struct {
78		result1 semver.Version
79		result2 error
80	}
81	NextFinalVersionStub        func(name string) (semver.Version, error)
82	nextFinalVersionMutex       sync.RWMutex
83	nextFinalVersionArgsForCall []struct {
84		name string
85	}
86	nextFinalVersionReturns struct {
87		result1 semver.Version
88		result2 error
89	}
90	nextFinalVersionReturnsOnCall map[int]struct {
91		result1 semver.Version
92		result2 error
93	}
94	FindReleaseStub        func(name string, version semver.Version) (boshrel.Release, error)
95	findReleaseMutex       sync.RWMutex
96	findReleaseArgsForCall []struct {
97		name    string
98		version semver.Version
99	}
100	findReleaseReturns struct {
101		result1 boshrel.Release
102		result2 error
103	}
104	findReleaseReturnsOnCall map[int]struct {
105		result1 boshrel.Release
106		result2 error
107	}
108	BuildReleaseStub        func(name string, version semver.Version, force bool) (boshrel.Release, error)
109	buildReleaseMutex       sync.RWMutex
110	buildReleaseArgsForCall []struct {
111		name    string
112		version semver.Version
113		force   bool
114	}
115	buildReleaseReturns struct {
116		result1 boshrel.Release
117		result2 error
118	}
119	buildReleaseReturnsOnCall map[int]struct {
120		result1 boshrel.Release
121		result2 error
122	}
123	VendorPackageStub        func(*boshpkg.Package) error
124	vendorPackageMutex       sync.RWMutex
125	vendorPackageArgsForCall []struct {
126		arg1 *boshpkg.Package
127	}
128	vendorPackageReturns struct {
129		result1 error
130	}
131	vendorPackageReturnsOnCall map[int]struct {
132		result1 error
133	}
134	FinalizeReleaseStub        func(release boshrel.Release, force bool) error
135	finalizeReleaseMutex       sync.RWMutex
136	finalizeReleaseArgsForCall []struct {
137		release boshrel.Release
138		force   bool
139	}
140	finalizeReleaseReturns struct {
141		result1 error
142	}
143	finalizeReleaseReturnsOnCall map[int]struct {
144		result1 error
145	}
146	invocations      map[string][][]interface{}
147	invocationsMutex sync.RWMutex
148}
149
150func (fake *FakeReleaseDir) Init(arg1 bool) error {
151	fake.initMutex.Lock()
152	ret, specificReturn := fake.initReturnsOnCall[len(fake.initArgsForCall)]
153	fake.initArgsForCall = append(fake.initArgsForCall, struct {
154		arg1 bool
155	}{arg1})
156	fake.recordInvocation("Init", []interface{}{arg1})
157	fake.initMutex.Unlock()
158	if fake.InitStub != nil {
159		return fake.InitStub(arg1)
160	}
161	if specificReturn {
162		return ret.result1
163	}
164	return fake.initReturns.result1
165}
166
167func (fake *FakeReleaseDir) InitCallCount() int {
168	fake.initMutex.RLock()
169	defer fake.initMutex.RUnlock()
170	return len(fake.initArgsForCall)
171}
172
173func (fake *FakeReleaseDir) InitArgsForCall(i int) bool {
174	fake.initMutex.RLock()
175	defer fake.initMutex.RUnlock()
176	return fake.initArgsForCall[i].arg1
177}
178
179func (fake *FakeReleaseDir) InitReturns(result1 error) {
180	fake.InitStub = nil
181	fake.initReturns = struct {
182		result1 error
183	}{result1}
184}
185
186func (fake *FakeReleaseDir) InitReturnsOnCall(i int, result1 error) {
187	fake.InitStub = nil
188	if fake.initReturnsOnCall == nil {
189		fake.initReturnsOnCall = make(map[int]struct {
190			result1 error
191		})
192	}
193	fake.initReturnsOnCall[i] = struct {
194		result1 error
195	}{result1}
196}
197
198func (fake *FakeReleaseDir) Reset() error {
199	fake.resetMutex.Lock()
200	ret, specificReturn := fake.resetReturnsOnCall[len(fake.resetArgsForCall)]
201	fake.resetArgsForCall = append(fake.resetArgsForCall, struct{}{})
202	fake.recordInvocation("Reset", []interface{}{})
203	fake.resetMutex.Unlock()
204	if fake.ResetStub != nil {
205		return fake.ResetStub()
206	}
207	if specificReturn {
208		return ret.result1
209	}
210	return fake.resetReturns.result1
211}
212
213func (fake *FakeReleaseDir) ResetCallCount() int {
214	fake.resetMutex.RLock()
215	defer fake.resetMutex.RUnlock()
216	return len(fake.resetArgsForCall)
217}
218
219func (fake *FakeReleaseDir) ResetReturns(result1 error) {
220	fake.ResetStub = nil
221	fake.resetReturns = struct {
222		result1 error
223	}{result1}
224}
225
226func (fake *FakeReleaseDir) ResetReturnsOnCall(i int, result1 error) {
227	fake.ResetStub = nil
228	if fake.resetReturnsOnCall == nil {
229		fake.resetReturnsOnCall = make(map[int]struct {
230			result1 error
231		})
232	}
233	fake.resetReturnsOnCall[i] = struct {
234		result1 error
235	}{result1}
236}
237
238func (fake *FakeReleaseDir) GenerateJob(arg1 string) error {
239	fake.generateJobMutex.Lock()
240	ret, specificReturn := fake.generateJobReturnsOnCall[len(fake.generateJobArgsForCall)]
241	fake.generateJobArgsForCall = append(fake.generateJobArgsForCall, struct {
242		arg1 string
243	}{arg1})
244	fake.recordInvocation("GenerateJob", []interface{}{arg1})
245	fake.generateJobMutex.Unlock()
246	if fake.GenerateJobStub != nil {
247		return fake.GenerateJobStub(arg1)
248	}
249	if specificReturn {
250		return ret.result1
251	}
252	return fake.generateJobReturns.result1
253}
254
255func (fake *FakeReleaseDir) GenerateJobCallCount() int {
256	fake.generateJobMutex.RLock()
257	defer fake.generateJobMutex.RUnlock()
258	return len(fake.generateJobArgsForCall)
259}
260
261func (fake *FakeReleaseDir) GenerateJobArgsForCall(i int) string {
262	fake.generateJobMutex.RLock()
263	defer fake.generateJobMutex.RUnlock()
264	return fake.generateJobArgsForCall[i].arg1
265}
266
267func (fake *FakeReleaseDir) GenerateJobReturns(result1 error) {
268	fake.GenerateJobStub = nil
269	fake.generateJobReturns = struct {
270		result1 error
271	}{result1}
272}
273
274func (fake *FakeReleaseDir) GenerateJobReturnsOnCall(i int, result1 error) {
275	fake.GenerateJobStub = nil
276	if fake.generateJobReturnsOnCall == nil {
277		fake.generateJobReturnsOnCall = make(map[int]struct {
278			result1 error
279		})
280	}
281	fake.generateJobReturnsOnCall[i] = struct {
282		result1 error
283	}{result1}
284}
285
286func (fake *FakeReleaseDir) GeneratePackage(arg1 string) error {
287	fake.generatePackageMutex.Lock()
288	ret, specificReturn := fake.generatePackageReturnsOnCall[len(fake.generatePackageArgsForCall)]
289	fake.generatePackageArgsForCall = append(fake.generatePackageArgsForCall, struct {
290		arg1 string
291	}{arg1})
292	fake.recordInvocation("GeneratePackage", []interface{}{arg1})
293	fake.generatePackageMutex.Unlock()
294	if fake.GeneratePackageStub != nil {
295		return fake.GeneratePackageStub(arg1)
296	}
297	if specificReturn {
298		return ret.result1
299	}
300	return fake.generatePackageReturns.result1
301}
302
303func (fake *FakeReleaseDir) GeneratePackageCallCount() int {
304	fake.generatePackageMutex.RLock()
305	defer fake.generatePackageMutex.RUnlock()
306	return len(fake.generatePackageArgsForCall)
307}
308
309func (fake *FakeReleaseDir) GeneratePackageArgsForCall(i int) string {
310	fake.generatePackageMutex.RLock()
311	defer fake.generatePackageMutex.RUnlock()
312	return fake.generatePackageArgsForCall[i].arg1
313}
314
315func (fake *FakeReleaseDir) GeneratePackageReturns(result1 error) {
316	fake.GeneratePackageStub = nil
317	fake.generatePackageReturns = struct {
318		result1 error
319	}{result1}
320}
321
322func (fake *FakeReleaseDir) GeneratePackageReturnsOnCall(i int, result1 error) {
323	fake.GeneratePackageStub = nil
324	if fake.generatePackageReturnsOnCall == nil {
325		fake.generatePackageReturnsOnCall = make(map[int]struct {
326			result1 error
327		})
328	}
329	fake.generatePackageReturnsOnCall[i] = struct {
330		result1 error
331	}{result1}
332}
333
334func (fake *FakeReleaseDir) DefaultName() (string, error) {
335	fake.defaultNameMutex.Lock()
336	ret, specificReturn := fake.defaultNameReturnsOnCall[len(fake.defaultNameArgsForCall)]
337	fake.defaultNameArgsForCall = append(fake.defaultNameArgsForCall, struct{}{})
338	fake.recordInvocation("DefaultName", []interface{}{})
339	fake.defaultNameMutex.Unlock()
340	if fake.DefaultNameStub != nil {
341		return fake.DefaultNameStub()
342	}
343	if specificReturn {
344		return ret.result1, ret.result2
345	}
346	return fake.defaultNameReturns.result1, fake.defaultNameReturns.result2
347}
348
349func (fake *FakeReleaseDir) DefaultNameCallCount() int {
350	fake.defaultNameMutex.RLock()
351	defer fake.defaultNameMutex.RUnlock()
352	return len(fake.defaultNameArgsForCall)
353}
354
355func (fake *FakeReleaseDir) DefaultNameReturns(result1 string, result2 error) {
356	fake.DefaultNameStub = nil
357	fake.defaultNameReturns = struct {
358		result1 string
359		result2 error
360	}{result1, result2}
361}
362
363func (fake *FakeReleaseDir) DefaultNameReturnsOnCall(i int, result1 string, result2 error) {
364	fake.DefaultNameStub = nil
365	if fake.defaultNameReturnsOnCall == nil {
366		fake.defaultNameReturnsOnCall = make(map[int]struct {
367			result1 string
368			result2 error
369		})
370	}
371	fake.defaultNameReturnsOnCall[i] = struct {
372		result1 string
373		result2 error
374	}{result1, result2}
375}
376
377func (fake *FakeReleaseDir) NextDevVersion(name string, timestamp bool) (semver.Version, error) {
378	fake.nextDevVersionMutex.Lock()
379	ret, specificReturn := fake.nextDevVersionReturnsOnCall[len(fake.nextDevVersionArgsForCall)]
380	fake.nextDevVersionArgsForCall = append(fake.nextDevVersionArgsForCall, struct {
381		name      string
382		timestamp bool
383	}{name, timestamp})
384	fake.recordInvocation("NextDevVersion", []interface{}{name, timestamp})
385	fake.nextDevVersionMutex.Unlock()
386	if fake.NextDevVersionStub != nil {
387		return fake.NextDevVersionStub(name, timestamp)
388	}
389	if specificReturn {
390		return ret.result1, ret.result2
391	}
392	return fake.nextDevVersionReturns.result1, fake.nextDevVersionReturns.result2
393}
394
395func (fake *FakeReleaseDir) NextDevVersionCallCount() int {
396	fake.nextDevVersionMutex.RLock()
397	defer fake.nextDevVersionMutex.RUnlock()
398	return len(fake.nextDevVersionArgsForCall)
399}
400
401func (fake *FakeReleaseDir) NextDevVersionArgsForCall(i int) (string, bool) {
402	fake.nextDevVersionMutex.RLock()
403	defer fake.nextDevVersionMutex.RUnlock()
404	return fake.nextDevVersionArgsForCall[i].name, fake.nextDevVersionArgsForCall[i].timestamp
405}
406
407func (fake *FakeReleaseDir) NextDevVersionReturns(result1 semver.Version, result2 error) {
408	fake.NextDevVersionStub = nil
409	fake.nextDevVersionReturns = struct {
410		result1 semver.Version
411		result2 error
412	}{result1, result2}
413}
414
415func (fake *FakeReleaseDir) NextDevVersionReturnsOnCall(i int, result1 semver.Version, result2 error) {
416	fake.NextDevVersionStub = nil
417	if fake.nextDevVersionReturnsOnCall == nil {
418		fake.nextDevVersionReturnsOnCall = make(map[int]struct {
419			result1 semver.Version
420			result2 error
421		})
422	}
423	fake.nextDevVersionReturnsOnCall[i] = struct {
424		result1 semver.Version
425		result2 error
426	}{result1, result2}
427}
428
429func (fake *FakeReleaseDir) NextFinalVersion(name string) (semver.Version, error) {
430	fake.nextFinalVersionMutex.Lock()
431	ret, specificReturn := fake.nextFinalVersionReturnsOnCall[len(fake.nextFinalVersionArgsForCall)]
432	fake.nextFinalVersionArgsForCall = append(fake.nextFinalVersionArgsForCall, struct {
433		name string
434	}{name})
435	fake.recordInvocation("NextFinalVersion", []interface{}{name})
436	fake.nextFinalVersionMutex.Unlock()
437	if fake.NextFinalVersionStub != nil {
438		return fake.NextFinalVersionStub(name)
439	}
440	if specificReturn {
441		return ret.result1, ret.result2
442	}
443	return fake.nextFinalVersionReturns.result1, fake.nextFinalVersionReturns.result2
444}
445
446func (fake *FakeReleaseDir) NextFinalVersionCallCount() int {
447	fake.nextFinalVersionMutex.RLock()
448	defer fake.nextFinalVersionMutex.RUnlock()
449	return len(fake.nextFinalVersionArgsForCall)
450}
451
452func (fake *FakeReleaseDir) NextFinalVersionArgsForCall(i int) string {
453	fake.nextFinalVersionMutex.RLock()
454	defer fake.nextFinalVersionMutex.RUnlock()
455	return fake.nextFinalVersionArgsForCall[i].name
456}
457
458func (fake *FakeReleaseDir) NextFinalVersionReturns(result1 semver.Version, result2 error) {
459	fake.NextFinalVersionStub = nil
460	fake.nextFinalVersionReturns = struct {
461		result1 semver.Version
462		result2 error
463	}{result1, result2}
464}
465
466func (fake *FakeReleaseDir) NextFinalVersionReturnsOnCall(i int, result1 semver.Version, result2 error) {
467	fake.NextFinalVersionStub = nil
468	if fake.nextFinalVersionReturnsOnCall == nil {
469		fake.nextFinalVersionReturnsOnCall = make(map[int]struct {
470			result1 semver.Version
471			result2 error
472		})
473	}
474	fake.nextFinalVersionReturnsOnCall[i] = struct {
475		result1 semver.Version
476		result2 error
477	}{result1, result2}
478}
479
480func (fake *FakeReleaseDir) FindRelease(name string, version semver.Version) (boshrel.Release, error) {
481	fake.findReleaseMutex.Lock()
482	ret, specificReturn := fake.findReleaseReturnsOnCall[len(fake.findReleaseArgsForCall)]
483	fake.findReleaseArgsForCall = append(fake.findReleaseArgsForCall, struct {
484		name    string
485		version semver.Version
486	}{name, version})
487	fake.recordInvocation("FindRelease", []interface{}{name, version})
488	fake.findReleaseMutex.Unlock()
489	if fake.FindReleaseStub != nil {
490		return fake.FindReleaseStub(name, version)
491	}
492	if specificReturn {
493		return ret.result1, ret.result2
494	}
495	return fake.findReleaseReturns.result1, fake.findReleaseReturns.result2
496}
497
498func (fake *FakeReleaseDir) FindReleaseCallCount() int {
499	fake.findReleaseMutex.RLock()
500	defer fake.findReleaseMutex.RUnlock()
501	return len(fake.findReleaseArgsForCall)
502}
503
504func (fake *FakeReleaseDir) FindReleaseArgsForCall(i int) (string, semver.Version) {
505	fake.findReleaseMutex.RLock()
506	defer fake.findReleaseMutex.RUnlock()
507	return fake.findReleaseArgsForCall[i].name, fake.findReleaseArgsForCall[i].version
508}
509
510func (fake *FakeReleaseDir) FindReleaseReturns(result1 boshrel.Release, result2 error) {
511	fake.FindReleaseStub = nil
512	fake.findReleaseReturns = struct {
513		result1 boshrel.Release
514		result2 error
515	}{result1, result2}
516}
517
518func (fake *FakeReleaseDir) FindReleaseReturnsOnCall(i int, result1 boshrel.Release, result2 error) {
519	fake.FindReleaseStub = nil
520	if fake.findReleaseReturnsOnCall == nil {
521		fake.findReleaseReturnsOnCall = make(map[int]struct {
522			result1 boshrel.Release
523			result2 error
524		})
525	}
526	fake.findReleaseReturnsOnCall[i] = struct {
527		result1 boshrel.Release
528		result2 error
529	}{result1, result2}
530}
531
532func (fake *FakeReleaseDir) BuildRelease(name string, version semver.Version, force bool) (boshrel.Release, error) {
533	fake.buildReleaseMutex.Lock()
534	ret, specificReturn := fake.buildReleaseReturnsOnCall[len(fake.buildReleaseArgsForCall)]
535	fake.buildReleaseArgsForCall = append(fake.buildReleaseArgsForCall, struct {
536		name    string
537		version semver.Version
538		force   bool
539	}{name, version, force})
540	fake.recordInvocation("BuildRelease", []interface{}{name, version, force})
541	fake.buildReleaseMutex.Unlock()
542	if fake.BuildReleaseStub != nil {
543		return fake.BuildReleaseStub(name, version, force)
544	}
545	if specificReturn {
546		return ret.result1, ret.result2
547	}
548	return fake.buildReleaseReturns.result1, fake.buildReleaseReturns.result2
549}
550
551func (fake *FakeReleaseDir) BuildReleaseCallCount() int {
552	fake.buildReleaseMutex.RLock()
553	defer fake.buildReleaseMutex.RUnlock()
554	return len(fake.buildReleaseArgsForCall)
555}
556
557func (fake *FakeReleaseDir) BuildReleaseArgsForCall(i int) (string, semver.Version, bool) {
558	fake.buildReleaseMutex.RLock()
559	defer fake.buildReleaseMutex.RUnlock()
560	return fake.buildReleaseArgsForCall[i].name, fake.buildReleaseArgsForCall[i].version, fake.buildReleaseArgsForCall[i].force
561}
562
563func (fake *FakeReleaseDir) BuildReleaseReturns(result1 boshrel.Release, result2 error) {
564	fake.BuildReleaseStub = nil
565	fake.buildReleaseReturns = struct {
566		result1 boshrel.Release
567		result2 error
568	}{result1, result2}
569}
570
571func (fake *FakeReleaseDir) BuildReleaseReturnsOnCall(i int, result1 boshrel.Release, result2 error) {
572	fake.BuildReleaseStub = nil
573	if fake.buildReleaseReturnsOnCall == nil {
574		fake.buildReleaseReturnsOnCall = make(map[int]struct {
575			result1 boshrel.Release
576			result2 error
577		})
578	}
579	fake.buildReleaseReturnsOnCall[i] = struct {
580		result1 boshrel.Release
581		result2 error
582	}{result1, result2}
583}
584
585func (fake *FakeReleaseDir) VendorPackage(arg1 *boshpkg.Package) error {
586	fake.vendorPackageMutex.Lock()
587	ret, specificReturn := fake.vendorPackageReturnsOnCall[len(fake.vendorPackageArgsForCall)]
588	fake.vendorPackageArgsForCall = append(fake.vendorPackageArgsForCall, struct {
589		arg1 *boshpkg.Package
590	}{arg1})
591	fake.recordInvocation("VendorPackage", []interface{}{arg1})
592	fake.vendorPackageMutex.Unlock()
593	if fake.VendorPackageStub != nil {
594		return fake.VendorPackageStub(arg1)
595	}
596	if specificReturn {
597		return ret.result1
598	}
599	return fake.vendorPackageReturns.result1
600}
601
602func (fake *FakeReleaseDir) VendorPackageCallCount() int {
603	fake.vendorPackageMutex.RLock()
604	defer fake.vendorPackageMutex.RUnlock()
605	return len(fake.vendorPackageArgsForCall)
606}
607
608func (fake *FakeReleaseDir) VendorPackageArgsForCall(i int) *boshpkg.Package {
609	fake.vendorPackageMutex.RLock()
610	defer fake.vendorPackageMutex.RUnlock()
611	return fake.vendorPackageArgsForCall[i].arg1
612}
613
614func (fake *FakeReleaseDir) VendorPackageReturns(result1 error) {
615	fake.VendorPackageStub = nil
616	fake.vendorPackageReturns = struct {
617		result1 error
618	}{result1}
619}
620
621func (fake *FakeReleaseDir) VendorPackageReturnsOnCall(i int, result1 error) {
622	fake.VendorPackageStub = nil
623	if fake.vendorPackageReturnsOnCall == nil {
624		fake.vendorPackageReturnsOnCall = make(map[int]struct {
625			result1 error
626		})
627	}
628	fake.vendorPackageReturnsOnCall[i] = struct {
629		result1 error
630	}{result1}
631}
632
633func (fake *FakeReleaseDir) FinalizeRelease(release boshrel.Release, force bool) error {
634	fake.finalizeReleaseMutex.Lock()
635	ret, specificReturn := fake.finalizeReleaseReturnsOnCall[len(fake.finalizeReleaseArgsForCall)]
636	fake.finalizeReleaseArgsForCall = append(fake.finalizeReleaseArgsForCall, struct {
637		release boshrel.Release
638		force   bool
639	}{release, force})
640	fake.recordInvocation("FinalizeRelease", []interface{}{release, force})
641	fake.finalizeReleaseMutex.Unlock()
642	if fake.FinalizeReleaseStub != nil {
643		return fake.FinalizeReleaseStub(release, force)
644	}
645	if specificReturn {
646		return ret.result1
647	}
648	return fake.finalizeReleaseReturns.result1
649}
650
651func (fake *FakeReleaseDir) FinalizeReleaseCallCount() int {
652	fake.finalizeReleaseMutex.RLock()
653	defer fake.finalizeReleaseMutex.RUnlock()
654	return len(fake.finalizeReleaseArgsForCall)
655}
656
657func (fake *FakeReleaseDir) FinalizeReleaseArgsForCall(i int) (boshrel.Release, bool) {
658	fake.finalizeReleaseMutex.RLock()
659	defer fake.finalizeReleaseMutex.RUnlock()
660	return fake.finalizeReleaseArgsForCall[i].release, fake.finalizeReleaseArgsForCall[i].force
661}
662
663func (fake *FakeReleaseDir) FinalizeReleaseReturns(result1 error) {
664	fake.FinalizeReleaseStub = nil
665	fake.finalizeReleaseReturns = struct {
666		result1 error
667	}{result1}
668}
669
670func (fake *FakeReleaseDir) FinalizeReleaseReturnsOnCall(i int, result1 error) {
671	fake.FinalizeReleaseStub = nil
672	if fake.finalizeReleaseReturnsOnCall == nil {
673		fake.finalizeReleaseReturnsOnCall = make(map[int]struct {
674			result1 error
675		})
676	}
677	fake.finalizeReleaseReturnsOnCall[i] = struct {
678		result1 error
679	}{result1}
680}
681
682func (fake *FakeReleaseDir) Invocations() map[string][][]interface{} {
683	fake.invocationsMutex.RLock()
684	defer fake.invocationsMutex.RUnlock()
685	fake.initMutex.RLock()
686	defer fake.initMutex.RUnlock()
687	fake.resetMutex.RLock()
688	defer fake.resetMutex.RUnlock()
689	fake.generateJobMutex.RLock()
690	defer fake.generateJobMutex.RUnlock()
691	fake.generatePackageMutex.RLock()
692	defer fake.generatePackageMutex.RUnlock()
693	fake.defaultNameMutex.RLock()
694	defer fake.defaultNameMutex.RUnlock()
695	fake.nextDevVersionMutex.RLock()
696	defer fake.nextDevVersionMutex.RUnlock()
697	fake.nextFinalVersionMutex.RLock()
698	defer fake.nextFinalVersionMutex.RUnlock()
699	fake.findReleaseMutex.RLock()
700	defer fake.findReleaseMutex.RUnlock()
701	fake.buildReleaseMutex.RLock()
702	defer fake.buildReleaseMutex.RUnlock()
703	fake.vendorPackageMutex.RLock()
704	defer fake.vendorPackageMutex.RUnlock()
705	fake.finalizeReleaseMutex.RLock()
706	defer fake.finalizeReleaseMutex.RUnlock()
707	copiedInvocations := map[string][][]interface{}{}
708	for key, value := range fake.invocations {
709		copiedInvocations[key] = value
710	}
711	return copiedInvocations
712}
713
714func (fake *FakeReleaseDir) recordInvocation(key string, args []interface{}) {
715	fake.invocationsMutex.Lock()
716	defer fake.invocationsMutex.Unlock()
717	if fake.invocations == nil {
718		fake.invocations = map[string][][]interface{}{}
719	}
720	if fake.invocations[key] == nil {
721		fake.invocations[key] = [][]interface{}{}
722	}
723	fake.invocations[key] = append(fake.invocations[key], args)
724}
725
726var _ releasedir.ReleaseDir = new(FakeReleaseDir)
727