1// Code generated by counterfeiter. DO NOT EDIT.
2package dbfakes
3
4import (
5	"context"
6	"sync"
7	"time"
8
9	"code.cloudfoundry.org/lager"
10	"github.com/concourse/concourse/atc"
11	"github.com/concourse/concourse/atc/db"
12	"github.com/concourse/concourse/atc/db/lock"
13)
14
15type FakeJob struct {
16	AcquireSchedulingLockStub        func(lager.Logger) (lock.Lock, bool, error)
17	acquireSchedulingLockMutex       sync.RWMutex
18	acquireSchedulingLockArgsForCall []struct {
19		arg1 lager.Logger
20	}
21	acquireSchedulingLockReturns struct {
22		result1 lock.Lock
23		result2 bool
24		result3 error
25	}
26	acquireSchedulingLockReturnsOnCall map[int]struct {
27		result1 lock.Lock
28		result2 bool
29		result3 error
30	}
31	AlgorithmInputsStub        func() (db.InputConfigs, error)
32	algorithmInputsMutex       sync.RWMutex
33	algorithmInputsArgsForCall []struct {
34	}
35	algorithmInputsReturns struct {
36		result1 db.InputConfigs
37		result2 error
38	}
39	algorithmInputsReturnsOnCall map[int]struct {
40		result1 db.InputConfigs
41		result2 error
42	}
43	BuildStub        func(string) (db.Build, bool, error)
44	buildMutex       sync.RWMutex
45	buildArgsForCall []struct {
46		arg1 string
47	}
48	buildReturns struct {
49		result1 db.Build
50		result2 bool
51		result3 error
52	}
53	buildReturnsOnCall map[int]struct {
54		result1 db.Build
55		result2 bool
56		result3 error
57	}
58	BuildsStub        func(db.Page) ([]db.Build, db.Pagination, error)
59	buildsMutex       sync.RWMutex
60	buildsArgsForCall []struct {
61		arg1 db.Page
62	}
63	buildsReturns struct {
64		result1 []db.Build
65		result2 db.Pagination
66		result3 error
67	}
68	buildsReturnsOnCall map[int]struct {
69		result1 []db.Build
70		result2 db.Pagination
71		result3 error
72	}
73	BuildsWithTimeStub        func(db.Page) ([]db.Build, db.Pagination, error)
74	buildsWithTimeMutex       sync.RWMutex
75	buildsWithTimeArgsForCall []struct {
76		arg1 db.Page
77	}
78	buildsWithTimeReturns struct {
79		result1 []db.Build
80		result2 db.Pagination
81		result3 error
82	}
83	buildsWithTimeReturnsOnCall map[int]struct {
84		result1 []db.Build
85		result2 db.Pagination
86		result3 error
87	}
88	ClearTaskCacheStub        func(string, string) (int64, error)
89	clearTaskCacheMutex       sync.RWMutex
90	clearTaskCacheArgsForCall []struct {
91		arg1 string
92		arg2 string
93	}
94	clearTaskCacheReturns struct {
95		result1 int64
96		result2 error
97	}
98	clearTaskCacheReturnsOnCall map[int]struct {
99		result1 int64
100		result2 error
101	}
102	ConfigStub        func() (atc.JobConfig, error)
103	configMutex       sync.RWMutex
104	configArgsForCall []struct {
105	}
106	configReturns struct {
107		result1 atc.JobConfig
108		result2 error
109	}
110	configReturnsOnCall map[int]struct {
111		result1 atc.JobConfig
112		result2 error
113	}
114	CreateBuildStub        func() (db.Build, error)
115	createBuildMutex       sync.RWMutex
116	createBuildArgsForCall []struct {
117	}
118	createBuildReturns struct {
119		result1 db.Build
120		result2 error
121	}
122	createBuildReturnsOnCall map[int]struct {
123		result1 db.Build
124		result2 error
125	}
126	DisableManualTriggerStub        func() bool
127	disableManualTriggerMutex       sync.RWMutex
128	disableManualTriggerArgsForCall []struct {
129	}
130	disableManualTriggerReturns struct {
131		result1 bool
132	}
133	disableManualTriggerReturnsOnCall map[int]struct {
134		result1 bool
135	}
136	EnsurePendingBuildExistsStub        func(context.Context) error
137	ensurePendingBuildExistsMutex       sync.RWMutex
138	ensurePendingBuildExistsArgsForCall []struct {
139		arg1 context.Context
140	}
141	ensurePendingBuildExistsReturns struct {
142		result1 error
143	}
144	ensurePendingBuildExistsReturnsOnCall map[int]struct {
145		result1 error
146	}
147	FinishedAndNextBuildStub        func() (db.Build, db.Build, error)
148	finishedAndNextBuildMutex       sync.RWMutex
149	finishedAndNextBuildArgsForCall []struct {
150	}
151	finishedAndNextBuildReturns struct {
152		result1 db.Build
153		result2 db.Build
154		result3 error
155	}
156	finishedAndNextBuildReturnsOnCall map[int]struct {
157		result1 db.Build
158		result2 db.Build
159		result3 error
160	}
161	FirstLoggedBuildIDStub        func() int
162	firstLoggedBuildIDMutex       sync.RWMutex
163	firstLoggedBuildIDArgsForCall []struct {
164	}
165	firstLoggedBuildIDReturns struct {
166		result1 int
167	}
168	firstLoggedBuildIDReturnsOnCall map[int]struct {
169		result1 int
170	}
171	GetFullNextBuildInputsStub        func() ([]db.BuildInput, bool, error)
172	getFullNextBuildInputsMutex       sync.RWMutex
173	getFullNextBuildInputsArgsForCall []struct {
174	}
175	getFullNextBuildInputsReturns struct {
176		result1 []db.BuildInput
177		result2 bool
178		result3 error
179	}
180	getFullNextBuildInputsReturnsOnCall map[int]struct {
181		result1 []db.BuildInput
182		result2 bool
183		result3 error
184	}
185	GetNextBuildInputsStub        func() ([]db.BuildInput, error)
186	getNextBuildInputsMutex       sync.RWMutex
187	getNextBuildInputsArgsForCall []struct {
188	}
189	getNextBuildInputsReturns struct {
190		result1 []db.BuildInput
191		result2 error
192	}
193	getNextBuildInputsReturnsOnCall map[int]struct {
194		result1 []db.BuildInput
195		result2 error
196	}
197	GetPendingBuildsStub        func() ([]db.Build, error)
198	getPendingBuildsMutex       sync.RWMutex
199	getPendingBuildsArgsForCall []struct {
200	}
201	getPendingBuildsReturns struct {
202		result1 []db.Build
203		result2 error
204	}
205	getPendingBuildsReturnsOnCall map[int]struct {
206		result1 []db.Build
207		result2 error
208	}
209	HasNewInputsStub        func() bool
210	hasNewInputsMutex       sync.RWMutex
211	hasNewInputsArgsForCall []struct {
212	}
213	hasNewInputsReturns struct {
214		result1 bool
215	}
216	hasNewInputsReturnsOnCall map[int]struct {
217		result1 bool
218	}
219	IDStub        func() int
220	iDMutex       sync.RWMutex
221	iDArgsForCall []struct {
222	}
223	iDReturns struct {
224		result1 int
225	}
226	iDReturnsOnCall map[int]struct {
227		result1 int
228	}
229	InputsStub        func() ([]atc.JobInput, error)
230	inputsMutex       sync.RWMutex
231	inputsArgsForCall []struct {
232	}
233	inputsReturns struct {
234		result1 []atc.JobInput
235		result2 error
236	}
237	inputsReturnsOnCall map[int]struct {
238		result1 []atc.JobInput
239		result2 error
240	}
241	MaxInFlightStub        func() int
242	maxInFlightMutex       sync.RWMutex
243	maxInFlightArgsForCall []struct {
244	}
245	maxInFlightReturns struct {
246		result1 int
247	}
248	maxInFlightReturnsOnCall map[int]struct {
249		result1 int
250	}
251	NameStub        func() string
252	nameMutex       sync.RWMutex
253	nameArgsForCall []struct {
254	}
255	nameReturns struct {
256		result1 string
257	}
258	nameReturnsOnCall map[int]struct {
259		result1 string
260	}
261	OutputsStub        func() ([]atc.JobOutput, error)
262	outputsMutex       sync.RWMutex
263	outputsArgsForCall []struct {
264	}
265	outputsReturns struct {
266		result1 []atc.JobOutput
267		result2 error
268	}
269	outputsReturnsOnCall map[int]struct {
270		result1 []atc.JobOutput
271		result2 error
272	}
273	PauseStub        func() error
274	pauseMutex       sync.RWMutex
275	pauseArgsForCall []struct {
276	}
277	pauseReturns struct {
278		result1 error
279	}
280	pauseReturnsOnCall map[int]struct {
281		result1 error
282	}
283	PausedStub        func() bool
284	pausedMutex       sync.RWMutex
285	pausedArgsForCall []struct {
286	}
287	pausedReturns struct {
288		result1 bool
289	}
290	pausedReturnsOnCall map[int]struct {
291		result1 bool
292	}
293	PipelineStub        func() (db.Pipeline, bool, error)
294	pipelineMutex       sync.RWMutex
295	pipelineArgsForCall []struct {
296	}
297	pipelineReturns struct {
298		result1 db.Pipeline
299		result2 bool
300		result3 error
301	}
302	pipelineReturnsOnCall map[int]struct {
303		result1 db.Pipeline
304		result2 bool
305		result3 error
306	}
307	PipelineIDStub        func() int
308	pipelineIDMutex       sync.RWMutex
309	pipelineIDArgsForCall []struct {
310	}
311	pipelineIDReturns struct {
312		result1 int
313	}
314	pipelineIDReturnsOnCall map[int]struct {
315		result1 int
316	}
317	PipelineNameStub        func() string
318	pipelineNameMutex       sync.RWMutex
319	pipelineNameArgsForCall []struct {
320	}
321	pipelineNameReturns struct {
322		result1 string
323	}
324	pipelineNameReturnsOnCall map[int]struct {
325		result1 string
326	}
327	PublicStub        func() bool
328	publicMutex       sync.RWMutex
329	publicArgsForCall []struct {
330	}
331	publicReturns struct {
332		result1 bool
333	}
334	publicReturnsOnCall map[int]struct {
335		result1 bool
336	}
337	ReloadStub        func() (bool, error)
338	reloadMutex       sync.RWMutex
339	reloadArgsForCall []struct {
340	}
341	reloadReturns struct {
342		result1 bool
343		result2 error
344	}
345	reloadReturnsOnCall map[int]struct {
346		result1 bool
347		result2 error
348	}
349	RequestScheduleStub        func() error
350	requestScheduleMutex       sync.RWMutex
351	requestScheduleArgsForCall []struct {
352	}
353	requestScheduleReturns struct {
354		result1 error
355	}
356	requestScheduleReturnsOnCall map[int]struct {
357		result1 error
358	}
359	RerunBuildStub        func(db.Build) (db.Build, error)
360	rerunBuildMutex       sync.RWMutex
361	rerunBuildArgsForCall []struct {
362		arg1 db.Build
363	}
364	rerunBuildReturns struct {
365		result1 db.Build
366		result2 error
367	}
368	rerunBuildReturnsOnCall map[int]struct {
369		result1 db.Build
370		result2 error
371	}
372	SaveNextInputMappingStub        func(db.InputMapping, bool) error
373	saveNextInputMappingMutex       sync.RWMutex
374	saveNextInputMappingArgsForCall []struct {
375		arg1 db.InputMapping
376		arg2 bool
377	}
378	saveNextInputMappingReturns struct {
379		result1 error
380	}
381	saveNextInputMappingReturnsOnCall map[int]struct {
382		result1 error
383	}
384	ScheduleBuildStub        func(db.Build) (bool, error)
385	scheduleBuildMutex       sync.RWMutex
386	scheduleBuildArgsForCall []struct {
387		arg1 db.Build
388	}
389	scheduleBuildReturns struct {
390		result1 bool
391		result2 error
392	}
393	scheduleBuildReturnsOnCall map[int]struct {
394		result1 bool
395		result2 error
396	}
397	ScheduleRequestedTimeStub        func() time.Time
398	scheduleRequestedTimeMutex       sync.RWMutex
399	scheduleRequestedTimeArgsForCall []struct {
400	}
401	scheduleRequestedTimeReturns struct {
402		result1 time.Time
403	}
404	scheduleRequestedTimeReturnsOnCall map[int]struct {
405		result1 time.Time
406	}
407	SetHasNewInputsStub        func(bool) error
408	setHasNewInputsMutex       sync.RWMutex
409	setHasNewInputsArgsForCall []struct {
410		arg1 bool
411	}
412	setHasNewInputsReturns struct {
413		result1 error
414	}
415	setHasNewInputsReturnsOnCall map[int]struct {
416		result1 error
417	}
418	TagsStub        func() []string
419	tagsMutex       sync.RWMutex
420	tagsArgsForCall []struct {
421	}
422	tagsReturns struct {
423		result1 []string
424	}
425	tagsReturnsOnCall map[int]struct {
426		result1 []string
427	}
428	TeamIDStub        func() int
429	teamIDMutex       sync.RWMutex
430	teamIDArgsForCall []struct {
431	}
432	teamIDReturns struct {
433		result1 int
434	}
435	teamIDReturnsOnCall map[int]struct {
436		result1 int
437	}
438	TeamNameStub        func() string
439	teamNameMutex       sync.RWMutex
440	teamNameArgsForCall []struct {
441	}
442	teamNameReturns struct {
443		result1 string
444	}
445	teamNameReturnsOnCall map[int]struct {
446		result1 string
447	}
448	UnpauseStub        func() error
449	unpauseMutex       sync.RWMutex
450	unpauseArgsForCall []struct {
451	}
452	unpauseReturns struct {
453		result1 error
454	}
455	unpauseReturnsOnCall map[int]struct {
456		result1 error
457	}
458	UpdateFirstLoggedBuildIDStub        func(int) error
459	updateFirstLoggedBuildIDMutex       sync.RWMutex
460	updateFirstLoggedBuildIDArgsForCall []struct {
461		arg1 int
462	}
463	updateFirstLoggedBuildIDReturns struct {
464		result1 error
465	}
466	updateFirstLoggedBuildIDReturnsOnCall map[int]struct {
467		result1 error
468	}
469	UpdateLastScheduledStub        func(time.Time) error
470	updateLastScheduledMutex       sync.RWMutex
471	updateLastScheduledArgsForCall []struct {
472		arg1 time.Time
473	}
474	updateLastScheduledReturns struct {
475		result1 error
476	}
477	updateLastScheduledReturnsOnCall map[int]struct {
478		result1 error
479	}
480	invocations      map[string][][]interface{}
481	invocationsMutex sync.RWMutex
482}
483
484func (fake *FakeJob) AcquireSchedulingLock(arg1 lager.Logger) (lock.Lock, bool, error) {
485	fake.acquireSchedulingLockMutex.Lock()
486	ret, specificReturn := fake.acquireSchedulingLockReturnsOnCall[len(fake.acquireSchedulingLockArgsForCall)]
487	fake.acquireSchedulingLockArgsForCall = append(fake.acquireSchedulingLockArgsForCall, struct {
488		arg1 lager.Logger
489	}{arg1})
490	fake.recordInvocation("AcquireSchedulingLock", []interface{}{arg1})
491	fake.acquireSchedulingLockMutex.Unlock()
492	if fake.AcquireSchedulingLockStub != nil {
493		return fake.AcquireSchedulingLockStub(arg1)
494	}
495	if specificReturn {
496		return ret.result1, ret.result2, ret.result3
497	}
498	fakeReturns := fake.acquireSchedulingLockReturns
499	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
500}
501
502func (fake *FakeJob) AcquireSchedulingLockCallCount() int {
503	fake.acquireSchedulingLockMutex.RLock()
504	defer fake.acquireSchedulingLockMutex.RUnlock()
505	return len(fake.acquireSchedulingLockArgsForCall)
506}
507
508func (fake *FakeJob) AcquireSchedulingLockCalls(stub func(lager.Logger) (lock.Lock, bool, error)) {
509	fake.acquireSchedulingLockMutex.Lock()
510	defer fake.acquireSchedulingLockMutex.Unlock()
511	fake.AcquireSchedulingLockStub = stub
512}
513
514func (fake *FakeJob) AcquireSchedulingLockArgsForCall(i int) lager.Logger {
515	fake.acquireSchedulingLockMutex.RLock()
516	defer fake.acquireSchedulingLockMutex.RUnlock()
517	argsForCall := fake.acquireSchedulingLockArgsForCall[i]
518	return argsForCall.arg1
519}
520
521func (fake *FakeJob) AcquireSchedulingLockReturns(result1 lock.Lock, result2 bool, result3 error) {
522	fake.acquireSchedulingLockMutex.Lock()
523	defer fake.acquireSchedulingLockMutex.Unlock()
524	fake.AcquireSchedulingLockStub = nil
525	fake.acquireSchedulingLockReturns = struct {
526		result1 lock.Lock
527		result2 bool
528		result3 error
529	}{result1, result2, result3}
530}
531
532func (fake *FakeJob) AcquireSchedulingLockReturnsOnCall(i int, result1 lock.Lock, result2 bool, result3 error) {
533	fake.acquireSchedulingLockMutex.Lock()
534	defer fake.acquireSchedulingLockMutex.Unlock()
535	fake.AcquireSchedulingLockStub = nil
536	if fake.acquireSchedulingLockReturnsOnCall == nil {
537		fake.acquireSchedulingLockReturnsOnCall = make(map[int]struct {
538			result1 lock.Lock
539			result2 bool
540			result3 error
541		})
542	}
543	fake.acquireSchedulingLockReturnsOnCall[i] = struct {
544		result1 lock.Lock
545		result2 bool
546		result3 error
547	}{result1, result2, result3}
548}
549
550func (fake *FakeJob) AlgorithmInputs() (db.InputConfigs, error) {
551	fake.algorithmInputsMutex.Lock()
552	ret, specificReturn := fake.algorithmInputsReturnsOnCall[len(fake.algorithmInputsArgsForCall)]
553	fake.algorithmInputsArgsForCall = append(fake.algorithmInputsArgsForCall, struct {
554	}{})
555	fake.recordInvocation("AlgorithmInputs", []interface{}{})
556	fake.algorithmInputsMutex.Unlock()
557	if fake.AlgorithmInputsStub != nil {
558		return fake.AlgorithmInputsStub()
559	}
560	if specificReturn {
561		return ret.result1, ret.result2
562	}
563	fakeReturns := fake.algorithmInputsReturns
564	return fakeReturns.result1, fakeReturns.result2
565}
566
567func (fake *FakeJob) AlgorithmInputsCallCount() int {
568	fake.algorithmInputsMutex.RLock()
569	defer fake.algorithmInputsMutex.RUnlock()
570	return len(fake.algorithmInputsArgsForCall)
571}
572
573func (fake *FakeJob) AlgorithmInputsCalls(stub func() (db.InputConfigs, error)) {
574	fake.algorithmInputsMutex.Lock()
575	defer fake.algorithmInputsMutex.Unlock()
576	fake.AlgorithmInputsStub = stub
577}
578
579func (fake *FakeJob) AlgorithmInputsReturns(result1 db.InputConfigs, result2 error) {
580	fake.algorithmInputsMutex.Lock()
581	defer fake.algorithmInputsMutex.Unlock()
582	fake.AlgorithmInputsStub = nil
583	fake.algorithmInputsReturns = struct {
584		result1 db.InputConfigs
585		result2 error
586	}{result1, result2}
587}
588
589func (fake *FakeJob) AlgorithmInputsReturnsOnCall(i int, result1 db.InputConfigs, result2 error) {
590	fake.algorithmInputsMutex.Lock()
591	defer fake.algorithmInputsMutex.Unlock()
592	fake.AlgorithmInputsStub = nil
593	if fake.algorithmInputsReturnsOnCall == nil {
594		fake.algorithmInputsReturnsOnCall = make(map[int]struct {
595			result1 db.InputConfigs
596			result2 error
597		})
598	}
599	fake.algorithmInputsReturnsOnCall[i] = struct {
600		result1 db.InputConfigs
601		result2 error
602	}{result1, result2}
603}
604
605func (fake *FakeJob) Build(arg1 string) (db.Build, bool, error) {
606	fake.buildMutex.Lock()
607	ret, specificReturn := fake.buildReturnsOnCall[len(fake.buildArgsForCall)]
608	fake.buildArgsForCall = append(fake.buildArgsForCall, struct {
609		arg1 string
610	}{arg1})
611	fake.recordInvocation("Build", []interface{}{arg1})
612	fake.buildMutex.Unlock()
613	if fake.BuildStub != nil {
614		return fake.BuildStub(arg1)
615	}
616	if specificReturn {
617		return ret.result1, ret.result2, ret.result3
618	}
619	fakeReturns := fake.buildReturns
620	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
621}
622
623func (fake *FakeJob) BuildCallCount() int {
624	fake.buildMutex.RLock()
625	defer fake.buildMutex.RUnlock()
626	return len(fake.buildArgsForCall)
627}
628
629func (fake *FakeJob) BuildCalls(stub func(string) (db.Build, bool, error)) {
630	fake.buildMutex.Lock()
631	defer fake.buildMutex.Unlock()
632	fake.BuildStub = stub
633}
634
635func (fake *FakeJob) BuildArgsForCall(i int) string {
636	fake.buildMutex.RLock()
637	defer fake.buildMutex.RUnlock()
638	argsForCall := fake.buildArgsForCall[i]
639	return argsForCall.arg1
640}
641
642func (fake *FakeJob) BuildReturns(result1 db.Build, result2 bool, result3 error) {
643	fake.buildMutex.Lock()
644	defer fake.buildMutex.Unlock()
645	fake.BuildStub = nil
646	fake.buildReturns = struct {
647		result1 db.Build
648		result2 bool
649		result3 error
650	}{result1, result2, result3}
651}
652
653func (fake *FakeJob) BuildReturnsOnCall(i int, result1 db.Build, result2 bool, result3 error) {
654	fake.buildMutex.Lock()
655	defer fake.buildMutex.Unlock()
656	fake.BuildStub = nil
657	if fake.buildReturnsOnCall == nil {
658		fake.buildReturnsOnCall = make(map[int]struct {
659			result1 db.Build
660			result2 bool
661			result3 error
662		})
663	}
664	fake.buildReturnsOnCall[i] = struct {
665		result1 db.Build
666		result2 bool
667		result3 error
668	}{result1, result2, result3}
669}
670
671func (fake *FakeJob) Builds(arg1 db.Page) ([]db.Build, db.Pagination, error) {
672	fake.buildsMutex.Lock()
673	ret, specificReturn := fake.buildsReturnsOnCall[len(fake.buildsArgsForCall)]
674	fake.buildsArgsForCall = append(fake.buildsArgsForCall, struct {
675		arg1 db.Page
676	}{arg1})
677	fake.recordInvocation("Builds", []interface{}{arg1})
678	fake.buildsMutex.Unlock()
679	if fake.BuildsStub != nil {
680		return fake.BuildsStub(arg1)
681	}
682	if specificReturn {
683		return ret.result1, ret.result2, ret.result3
684	}
685	fakeReturns := fake.buildsReturns
686	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
687}
688
689func (fake *FakeJob) BuildsCallCount() int {
690	fake.buildsMutex.RLock()
691	defer fake.buildsMutex.RUnlock()
692	return len(fake.buildsArgsForCall)
693}
694
695func (fake *FakeJob) BuildsCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) {
696	fake.buildsMutex.Lock()
697	defer fake.buildsMutex.Unlock()
698	fake.BuildsStub = stub
699}
700
701func (fake *FakeJob) BuildsArgsForCall(i int) db.Page {
702	fake.buildsMutex.RLock()
703	defer fake.buildsMutex.RUnlock()
704	argsForCall := fake.buildsArgsForCall[i]
705	return argsForCall.arg1
706}
707
708func (fake *FakeJob) BuildsReturns(result1 []db.Build, result2 db.Pagination, result3 error) {
709	fake.buildsMutex.Lock()
710	defer fake.buildsMutex.Unlock()
711	fake.BuildsStub = nil
712	fake.buildsReturns = struct {
713		result1 []db.Build
714		result2 db.Pagination
715		result3 error
716	}{result1, result2, result3}
717}
718
719func (fake *FakeJob) BuildsReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) {
720	fake.buildsMutex.Lock()
721	defer fake.buildsMutex.Unlock()
722	fake.BuildsStub = nil
723	if fake.buildsReturnsOnCall == nil {
724		fake.buildsReturnsOnCall = make(map[int]struct {
725			result1 []db.Build
726			result2 db.Pagination
727			result3 error
728		})
729	}
730	fake.buildsReturnsOnCall[i] = struct {
731		result1 []db.Build
732		result2 db.Pagination
733		result3 error
734	}{result1, result2, result3}
735}
736
737func (fake *FakeJob) BuildsWithTime(arg1 db.Page) ([]db.Build, db.Pagination, error) {
738	fake.buildsWithTimeMutex.Lock()
739	ret, specificReturn := fake.buildsWithTimeReturnsOnCall[len(fake.buildsWithTimeArgsForCall)]
740	fake.buildsWithTimeArgsForCall = append(fake.buildsWithTimeArgsForCall, struct {
741		arg1 db.Page
742	}{arg1})
743	fake.recordInvocation("BuildsWithTime", []interface{}{arg1})
744	fake.buildsWithTimeMutex.Unlock()
745	if fake.BuildsWithTimeStub != nil {
746		return fake.BuildsWithTimeStub(arg1)
747	}
748	if specificReturn {
749		return ret.result1, ret.result2, ret.result3
750	}
751	fakeReturns := fake.buildsWithTimeReturns
752	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
753}
754
755func (fake *FakeJob) BuildsWithTimeCallCount() int {
756	fake.buildsWithTimeMutex.RLock()
757	defer fake.buildsWithTimeMutex.RUnlock()
758	return len(fake.buildsWithTimeArgsForCall)
759}
760
761func (fake *FakeJob) BuildsWithTimeCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) {
762	fake.buildsWithTimeMutex.Lock()
763	defer fake.buildsWithTimeMutex.Unlock()
764	fake.BuildsWithTimeStub = stub
765}
766
767func (fake *FakeJob) BuildsWithTimeArgsForCall(i int) db.Page {
768	fake.buildsWithTimeMutex.RLock()
769	defer fake.buildsWithTimeMutex.RUnlock()
770	argsForCall := fake.buildsWithTimeArgsForCall[i]
771	return argsForCall.arg1
772}
773
774func (fake *FakeJob) BuildsWithTimeReturns(result1 []db.Build, result2 db.Pagination, result3 error) {
775	fake.buildsWithTimeMutex.Lock()
776	defer fake.buildsWithTimeMutex.Unlock()
777	fake.BuildsWithTimeStub = nil
778	fake.buildsWithTimeReturns = struct {
779		result1 []db.Build
780		result2 db.Pagination
781		result3 error
782	}{result1, result2, result3}
783}
784
785func (fake *FakeJob) BuildsWithTimeReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) {
786	fake.buildsWithTimeMutex.Lock()
787	defer fake.buildsWithTimeMutex.Unlock()
788	fake.BuildsWithTimeStub = nil
789	if fake.buildsWithTimeReturnsOnCall == nil {
790		fake.buildsWithTimeReturnsOnCall = make(map[int]struct {
791			result1 []db.Build
792			result2 db.Pagination
793			result3 error
794		})
795	}
796	fake.buildsWithTimeReturnsOnCall[i] = struct {
797		result1 []db.Build
798		result2 db.Pagination
799		result3 error
800	}{result1, result2, result3}
801}
802
803func (fake *FakeJob) ClearTaskCache(arg1 string, arg2 string) (int64, error) {
804	fake.clearTaskCacheMutex.Lock()
805	ret, specificReturn := fake.clearTaskCacheReturnsOnCall[len(fake.clearTaskCacheArgsForCall)]
806	fake.clearTaskCacheArgsForCall = append(fake.clearTaskCacheArgsForCall, struct {
807		arg1 string
808		arg2 string
809	}{arg1, arg2})
810	fake.recordInvocation("ClearTaskCache", []interface{}{arg1, arg2})
811	fake.clearTaskCacheMutex.Unlock()
812	if fake.ClearTaskCacheStub != nil {
813		return fake.ClearTaskCacheStub(arg1, arg2)
814	}
815	if specificReturn {
816		return ret.result1, ret.result2
817	}
818	fakeReturns := fake.clearTaskCacheReturns
819	return fakeReturns.result1, fakeReturns.result2
820}
821
822func (fake *FakeJob) ClearTaskCacheCallCount() int {
823	fake.clearTaskCacheMutex.RLock()
824	defer fake.clearTaskCacheMutex.RUnlock()
825	return len(fake.clearTaskCacheArgsForCall)
826}
827
828func (fake *FakeJob) ClearTaskCacheCalls(stub func(string, string) (int64, error)) {
829	fake.clearTaskCacheMutex.Lock()
830	defer fake.clearTaskCacheMutex.Unlock()
831	fake.ClearTaskCacheStub = stub
832}
833
834func (fake *FakeJob) ClearTaskCacheArgsForCall(i int) (string, string) {
835	fake.clearTaskCacheMutex.RLock()
836	defer fake.clearTaskCacheMutex.RUnlock()
837	argsForCall := fake.clearTaskCacheArgsForCall[i]
838	return argsForCall.arg1, argsForCall.arg2
839}
840
841func (fake *FakeJob) ClearTaskCacheReturns(result1 int64, result2 error) {
842	fake.clearTaskCacheMutex.Lock()
843	defer fake.clearTaskCacheMutex.Unlock()
844	fake.ClearTaskCacheStub = nil
845	fake.clearTaskCacheReturns = struct {
846		result1 int64
847		result2 error
848	}{result1, result2}
849}
850
851func (fake *FakeJob) ClearTaskCacheReturnsOnCall(i int, result1 int64, result2 error) {
852	fake.clearTaskCacheMutex.Lock()
853	defer fake.clearTaskCacheMutex.Unlock()
854	fake.ClearTaskCacheStub = nil
855	if fake.clearTaskCacheReturnsOnCall == nil {
856		fake.clearTaskCacheReturnsOnCall = make(map[int]struct {
857			result1 int64
858			result2 error
859		})
860	}
861	fake.clearTaskCacheReturnsOnCall[i] = struct {
862		result1 int64
863		result2 error
864	}{result1, result2}
865}
866
867func (fake *FakeJob) Config() (atc.JobConfig, error) {
868	fake.configMutex.Lock()
869	ret, specificReturn := fake.configReturnsOnCall[len(fake.configArgsForCall)]
870	fake.configArgsForCall = append(fake.configArgsForCall, struct {
871	}{})
872	fake.recordInvocation("Config", []interface{}{})
873	fake.configMutex.Unlock()
874	if fake.ConfigStub != nil {
875		return fake.ConfigStub()
876	}
877	if specificReturn {
878		return ret.result1, ret.result2
879	}
880	fakeReturns := fake.configReturns
881	return fakeReturns.result1, fakeReturns.result2
882}
883
884func (fake *FakeJob) ConfigCallCount() int {
885	fake.configMutex.RLock()
886	defer fake.configMutex.RUnlock()
887	return len(fake.configArgsForCall)
888}
889
890func (fake *FakeJob) ConfigCalls(stub func() (atc.JobConfig, error)) {
891	fake.configMutex.Lock()
892	defer fake.configMutex.Unlock()
893	fake.ConfigStub = stub
894}
895
896func (fake *FakeJob) ConfigReturns(result1 atc.JobConfig, result2 error) {
897	fake.configMutex.Lock()
898	defer fake.configMutex.Unlock()
899	fake.ConfigStub = nil
900	fake.configReturns = struct {
901		result1 atc.JobConfig
902		result2 error
903	}{result1, result2}
904}
905
906func (fake *FakeJob) ConfigReturnsOnCall(i int, result1 atc.JobConfig, result2 error) {
907	fake.configMutex.Lock()
908	defer fake.configMutex.Unlock()
909	fake.ConfigStub = nil
910	if fake.configReturnsOnCall == nil {
911		fake.configReturnsOnCall = make(map[int]struct {
912			result1 atc.JobConfig
913			result2 error
914		})
915	}
916	fake.configReturnsOnCall[i] = struct {
917		result1 atc.JobConfig
918		result2 error
919	}{result1, result2}
920}
921
922func (fake *FakeJob) CreateBuild() (db.Build, error) {
923	fake.createBuildMutex.Lock()
924	ret, specificReturn := fake.createBuildReturnsOnCall[len(fake.createBuildArgsForCall)]
925	fake.createBuildArgsForCall = append(fake.createBuildArgsForCall, struct {
926	}{})
927	fake.recordInvocation("CreateBuild", []interface{}{})
928	fake.createBuildMutex.Unlock()
929	if fake.CreateBuildStub != nil {
930		return fake.CreateBuildStub()
931	}
932	if specificReturn {
933		return ret.result1, ret.result2
934	}
935	fakeReturns := fake.createBuildReturns
936	return fakeReturns.result1, fakeReturns.result2
937}
938
939func (fake *FakeJob) CreateBuildCallCount() int {
940	fake.createBuildMutex.RLock()
941	defer fake.createBuildMutex.RUnlock()
942	return len(fake.createBuildArgsForCall)
943}
944
945func (fake *FakeJob) CreateBuildCalls(stub func() (db.Build, error)) {
946	fake.createBuildMutex.Lock()
947	defer fake.createBuildMutex.Unlock()
948	fake.CreateBuildStub = stub
949}
950
951func (fake *FakeJob) CreateBuildReturns(result1 db.Build, result2 error) {
952	fake.createBuildMutex.Lock()
953	defer fake.createBuildMutex.Unlock()
954	fake.CreateBuildStub = nil
955	fake.createBuildReturns = struct {
956		result1 db.Build
957		result2 error
958	}{result1, result2}
959}
960
961func (fake *FakeJob) CreateBuildReturnsOnCall(i int, result1 db.Build, result2 error) {
962	fake.createBuildMutex.Lock()
963	defer fake.createBuildMutex.Unlock()
964	fake.CreateBuildStub = nil
965	if fake.createBuildReturnsOnCall == nil {
966		fake.createBuildReturnsOnCall = make(map[int]struct {
967			result1 db.Build
968			result2 error
969		})
970	}
971	fake.createBuildReturnsOnCall[i] = struct {
972		result1 db.Build
973		result2 error
974	}{result1, result2}
975}
976
977func (fake *FakeJob) DisableManualTrigger() bool {
978	fake.disableManualTriggerMutex.Lock()
979	ret, specificReturn := fake.disableManualTriggerReturnsOnCall[len(fake.disableManualTriggerArgsForCall)]
980	fake.disableManualTriggerArgsForCall = append(fake.disableManualTriggerArgsForCall, struct {
981	}{})
982	fake.recordInvocation("DisableManualTrigger", []interface{}{})
983	fake.disableManualTriggerMutex.Unlock()
984	if fake.DisableManualTriggerStub != nil {
985		return fake.DisableManualTriggerStub()
986	}
987	if specificReturn {
988		return ret.result1
989	}
990	fakeReturns := fake.disableManualTriggerReturns
991	return fakeReturns.result1
992}
993
994func (fake *FakeJob) DisableManualTriggerCallCount() int {
995	fake.disableManualTriggerMutex.RLock()
996	defer fake.disableManualTriggerMutex.RUnlock()
997	return len(fake.disableManualTriggerArgsForCall)
998}
999
1000func (fake *FakeJob) DisableManualTriggerCalls(stub func() bool) {
1001	fake.disableManualTriggerMutex.Lock()
1002	defer fake.disableManualTriggerMutex.Unlock()
1003	fake.DisableManualTriggerStub = stub
1004}
1005
1006func (fake *FakeJob) DisableManualTriggerReturns(result1 bool) {
1007	fake.disableManualTriggerMutex.Lock()
1008	defer fake.disableManualTriggerMutex.Unlock()
1009	fake.DisableManualTriggerStub = nil
1010	fake.disableManualTriggerReturns = struct {
1011		result1 bool
1012	}{result1}
1013}
1014
1015func (fake *FakeJob) DisableManualTriggerReturnsOnCall(i int, result1 bool) {
1016	fake.disableManualTriggerMutex.Lock()
1017	defer fake.disableManualTriggerMutex.Unlock()
1018	fake.DisableManualTriggerStub = nil
1019	if fake.disableManualTriggerReturnsOnCall == nil {
1020		fake.disableManualTriggerReturnsOnCall = make(map[int]struct {
1021			result1 bool
1022		})
1023	}
1024	fake.disableManualTriggerReturnsOnCall[i] = struct {
1025		result1 bool
1026	}{result1}
1027}
1028
1029func (fake *FakeJob) EnsurePendingBuildExists(arg1 context.Context) error {
1030	fake.ensurePendingBuildExistsMutex.Lock()
1031	ret, specificReturn := fake.ensurePendingBuildExistsReturnsOnCall[len(fake.ensurePendingBuildExistsArgsForCall)]
1032	fake.ensurePendingBuildExistsArgsForCall = append(fake.ensurePendingBuildExistsArgsForCall, struct {
1033		arg1 context.Context
1034	}{arg1})
1035	fake.recordInvocation("EnsurePendingBuildExists", []interface{}{arg1})
1036	fake.ensurePendingBuildExistsMutex.Unlock()
1037	if fake.EnsurePendingBuildExistsStub != nil {
1038		return fake.EnsurePendingBuildExistsStub(arg1)
1039	}
1040	if specificReturn {
1041		return ret.result1
1042	}
1043	fakeReturns := fake.ensurePendingBuildExistsReturns
1044	return fakeReturns.result1
1045}
1046
1047func (fake *FakeJob) EnsurePendingBuildExistsCallCount() int {
1048	fake.ensurePendingBuildExistsMutex.RLock()
1049	defer fake.ensurePendingBuildExistsMutex.RUnlock()
1050	return len(fake.ensurePendingBuildExistsArgsForCall)
1051}
1052
1053func (fake *FakeJob) EnsurePendingBuildExistsCalls(stub func(context.Context) error) {
1054	fake.ensurePendingBuildExistsMutex.Lock()
1055	defer fake.ensurePendingBuildExistsMutex.Unlock()
1056	fake.EnsurePendingBuildExistsStub = stub
1057}
1058
1059func (fake *FakeJob) EnsurePendingBuildExistsArgsForCall(i int) context.Context {
1060	fake.ensurePendingBuildExistsMutex.RLock()
1061	defer fake.ensurePendingBuildExistsMutex.RUnlock()
1062	argsForCall := fake.ensurePendingBuildExistsArgsForCall[i]
1063	return argsForCall.arg1
1064}
1065
1066func (fake *FakeJob) EnsurePendingBuildExistsReturns(result1 error) {
1067	fake.ensurePendingBuildExistsMutex.Lock()
1068	defer fake.ensurePendingBuildExistsMutex.Unlock()
1069	fake.EnsurePendingBuildExistsStub = nil
1070	fake.ensurePendingBuildExistsReturns = struct {
1071		result1 error
1072	}{result1}
1073}
1074
1075func (fake *FakeJob) EnsurePendingBuildExistsReturnsOnCall(i int, result1 error) {
1076	fake.ensurePendingBuildExistsMutex.Lock()
1077	defer fake.ensurePendingBuildExistsMutex.Unlock()
1078	fake.EnsurePendingBuildExistsStub = nil
1079	if fake.ensurePendingBuildExistsReturnsOnCall == nil {
1080		fake.ensurePendingBuildExistsReturnsOnCall = make(map[int]struct {
1081			result1 error
1082		})
1083	}
1084	fake.ensurePendingBuildExistsReturnsOnCall[i] = struct {
1085		result1 error
1086	}{result1}
1087}
1088
1089func (fake *FakeJob) FinishedAndNextBuild() (db.Build, db.Build, error) {
1090	fake.finishedAndNextBuildMutex.Lock()
1091	ret, specificReturn := fake.finishedAndNextBuildReturnsOnCall[len(fake.finishedAndNextBuildArgsForCall)]
1092	fake.finishedAndNextBuildArgsForCall = append(fake.finishedAndNextBuildArgsForCall, struct {
1093	}{})
1094	fake.recordInvocation("FinishedAndNextBuild", []interface{}{})
1095	fake.finishedAndNextBuildMutex.Unlock()
1096	if fake.FinishedAndNextBuildStub != nil {
1097		return fake.FinishedAndNextBuildStub()
1098	}
1099	if specificReturn {
1100		return ret.result1, ret.result2, ret.result3
1101	}
1102	fakeReturns := fake.finishedAndNextBuildReturns
1103	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
1104}
1105
1106func (fake *FakeJob) FinishedAndNextBuildCallCount() int {
1107	fake.finishedAndNextBuildMutex.RLock()
1108	defer fake.finishedAndNextBuildMutex.RUnlock()
1109	return len(fake.finishedAndNextBuildArgsForCall)
1110}
1111
1112func (fake *FakeJob) FinishedAndNextBuildCalls(stub func() (db.Build, db.Build, error)) {
1113	fake.finishedAndNextBuildMutex.Lock()
1114	defer fake.finishedAndNextBuildMutex.Unlock()
1115	fake.FinishedAndNextBuildStub = stub
1116}
1117
1118func (fake *FakeJob) FinishedAndNextBuildReturns(result1 db.Build, result2 db.Build, result3 error) {
1119	fake.finishedAndNextBuildMutex.Lock()
1120	defer fake.finishedAndNextBuildMutex.Unlock()
1121	fake.FinishedAndNextBuildStub = nil
1122	fake.finishedAndNextBuildReturns = struct {
1123		result1 db.Build
1124		result2 db.Build
1125		result3 error
1126	}{result1, result2, result3}
1127}
1128
1129func (fake *FakeJob) FinishedAndNextBuildReturnsOnCall(i int, result1 db.Build, result2 db.Build, result3 error) {
1130	fake.finishedAndNextBuildMutex.Lock()
1131	defer fake.finishedAndNextBuildMutex.Unlock()
1132	fake.FinishedAndNextBuildStub = nil
1133	if fake.finishedAndNextBuildReturnsOnCall == nil {
1134		fake.finishedAndNextBuildReturnsOnCall = make(map[int]struct {
1135			result1 db.Build
1136			result2 db.Build
1137			result3 error
1138		})
1139	}
1140	fake.finishedAndNextBuildReturnsOnCall[i] = struct {
1141		result1 db.Build
1142		result2 db.Build
1143		result3 error
1144	}{result1, result2, result3}
1145}
1146
1147func (fake *FakeJob) FirstLoggedBuildID() int {
1148	fake.firstLoggedBuildIDMutex.Lock()
1149	ret, specificReturn := fake.firstLoggedBuildIDReturnsOnCall[len(fake.firstLoggedBuildIDArgsForCall)]
1150	fake.firstLoggedBuildIDArgsForCall = append(fake.firstLoggedBuildIDArgsForCall, struct {
1151	}{})
1152	fake.recordInvocation("FirstLoggedBuildID", []interface{}{})
1153	fake.firstLoggedBuildIDMutex.Unlock()
1154	if fake.FirstLoggedBuildIDStub != nil {
1155		return fake.FirstLoggedBuildIDStub()
1156	}
1157	if specificReturn {
1158		return ret.result1
1159	}
1160	fakeReturns := fake.firstLoggedBuildIDReturns
1161	return fakeReturns.result1
1162}
1163
1164func (fake *FakeJob) FirstLoggedBuildIDCallCount() int {
1165	fake.firstLoggedBuildIDMutex.RLock()
1166	defer fake.firstLoggedBuildIDMutex.RUnlock()
1167	return len(fake.firstLoggedBuildIDArgsForCall)
1168}
1169
1170func (fake *FakeJob) FirstLoggedBuildIDCalls(stub func() int) {
1171	fake.firstLoggedBuildIDMutex.Lock()
1172	defer fake.firstLoggedBuildIDMutex.Unlock()
1173	fake.FirstLoggedBuildIDStub = stub
1174}
1175
1176func (fake *FakeJob) FirstLoggedBuildIDReturns(result1 int) {
1177	fake.firstLoggedBuildIDMutex.Lock()
1178	defer fake.firstLoggedBuildIDMutex.Unlock()
1179	fake.FirstLoggedBuildIDStub = nil
1180	fake.firstLoggedBuildIDReturns = struct {
1181		result1 int
1182	}{result1}
1183}
1184
1185func (fake *FakeJob) FirstLoggedBuildIDReturnsOnCall(i int, result1 int) {
1186	fake.firstLoggedBuildIDMutex.Lock()
1187	defer fake.firstLoggedBuildIDMutex.Unlock()
1188	fake.FirstLoggedBuildIDStub = nil
1189	if fake.firstLoggedBuildIDReturnsOnCall == nil {
1190		fake.firstLoggedBuildIDReturnsOnCall = make(map[int]struct {
1191			result1 int
1192		})
1193	}
1194	fake.firstLoggedBuildIDReturnsOnCall[i] = struct {
1195		result1 int
1196	}{result1}
1197}
1198
1199func (fake *FakeJob) GetFullNextBuildInputs() ([]db.BuildInput, bool, error) {
1200	fake.getFullNextBuildInputsMutex.Lock()
1201	ret, specificReturn := fake.getFullNextBuildInputsReturnsOnCall[len(fake.getFullNextBuildInputsArgsForCall)]
1202	fake.getFullNextBuildInputsArgsForCall = append(fake.getFullNextBuildInputsArgsForCall, struct {
1203	}{})
1204	fake.recordInvocation("GetFullNextBuildInputs", []interface{}{})
1205	fake.getFullNextBuildInputsMutex.Unlock()
1206	if fake.GetFullNextBuildInputsStub != nil {
1207		return fake.GetFullNextBuildInputsStub()
1208	}
1209	if specificReturn {
1210		return ret.result1, ret.result2, ret.result3
1211	}
1212	fakeReturns := fake.getFullNextBuildInputsReturns
1213	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
1214}
1215
1216func (fake *FakeJob) GetFullNextBuildInputsCallCount() int {
1217	fake.getFullNextBuildInputsMutex.RLock()
1218	defer fake.getFullNextBuildInputsMutex.RUnlock()
1219	return len(fake.getFullNextBuildInputsArgsForCall)
1220}
1221
1222func (fake *FakeJob) GetFullNextBuildInputsCalls(stub func() ([]db.BuildInput, bool, error)) {
1223	fake.getFullNextBuildInputsMutex.Lock()
1224	defer fake.getFullNextBuildInputsMutex.Unlock()
1225	fake.GetFullNextBuildInputsStub = stub
1226}
1227
1228func (fake *FakeJob) GetFullNextBuildInputsReturns(result1 []db.BuildInput, result2 bool, result3 error) {
1229	fake.getFullNextBuildInputsMutex.Lock()
1230	defer fake.getFullNextBuildInputsMutex.Unlock()
1231	fake.GetFullNextBuildInputsStub = nil
1232	fake.getFullNextBuildInputsReturns = struct {
1233		result1 []db.BuildInput
1234		result2 bool
1235		result3 error
1236	}{result1, result2, result3}
1237}
1238
1239func (fake *FakeJob) GetFullNextBuildInputsReturnsOnCall(i int, result1 []db.BuildInput, result2 bool, result3 error) {
1240	fake.getFullNextBuildInputsMutex.Lock()
1241	defer fake.getFullNextBuildInputsMutex.Unlock()
1242	fake.GetFullNextBuildInputsStub = nil
1243	if fake.getFullNextBuildInputsReturnsOnCall == nil {
1244		fake.getFullNextBuildInputsReturnsOnCall = make(map[int]struct {
1245			result1 []db.BuildInput
1246			result2 bool
1247			result3 error
1248		})
1249	}
1250	fake.getFullNextBuildInputsReturnsOnCall[i] = struct {
1251		result1 []db.BuildInput
1252		result2 bool
1253		result3 error
1254	}{result1, result2, result3}
1255}
1256
1257func (fake *FakeJob) GetNextBuildInputs() ([]db.BuildInput, error) {
1258	fake.getNextBuildInputsMutex.Lock()
1259	ret, specificReturn := fake.getNextBuildInputsReturnsOnCall[len(fake.getNextBuildInputsArgsForCall)]
1260	fake.getNextBuildInputsArgsForCall = append(fake.getNextBuildInputsArgsForCall, struct {
1261	}{})
1262	fake.recordInvocation("GetNextBuildInputs", []interface{}{})
1263	fake.getNextBuildInputsMutex.Unlock()
1264	if fake.GetNextBuildInputsStub != nil {
1265		return fake.GetNextBuildInputsStub()
1266	}
1267	if specificReturn {
1268		return ret.result1, ret.result2
1269	}
1270	fakeReturns := fake.getNextBuildInputsReturns
1271	return fakeReturns.result1, fakeReturns.result2
1272}
1273
1274func (fake *FakeJob) GetNextBuildInputsCallCount() int {
1275	fake.getNextBuildInputsMutex.RLock()
1276	defer fake.getNextBuildInputsMutex.RUnlock()
1277	return len(fake.getNextBuildInputsArgsForCall)
1278}
1279
1280func (fake *FakeJob) GetNextBuildInputsCalls(stub func() ([]db.BuildInput, error)) {
1281	fake.getNextBuildInputsMutex.Lock()
1282	defer fake.getNextBuildInputsMutex.Unlock()
1283	fake.GetNextBuildInputsStub = stub
1284}
1285
1286func (fake *FakeJob) GetNextBuildInputsReturns(result1 []db.BuildInput, result2 error) {
1287	fake.getNextBuildInputsMutex.Lock()
1288	defer fake.getNextBuildInputsMutex.Unlock()
1289	fake.GetNextBuildInputsStub = nil
1290	fake.getNextBuildInputsReturns = struct {
1291		result1 []db.BuildInput
1292		result2 error
1293	}{result1, result2}
1294}
1295
1296func (fake *FakeJob) GetNextBuildInputsReturnsOnCall(i int, result1 []db.BuildInput, result2 error) {
1297	fake.getNextBuildInputsMutex.Lock()
1298	defer fake.getNextBuildInputsMutex.Unlock()
1299	fake.GetNextBuildInputsStub = nil
1300	if fake.getNextBuildInputsReturnsOnCall == nil {
1301		fake.getNextBuildInputsReturnsOnCall = make(map[int]struct {
1302			result1 []db.BuildInput
1303			result2 error
1304		})
1305	}
1306	fake.getNextBuildInputsReturnsOnCall[i] = struct {
1307		result1 []db.BuildInput
1308		result2 error
1309	}{result1, result2}
1310}
1311
1312func (fake *FakeJob) GetPendingBuilds() ([]db.Build, error) {
1313	fake.getPendingBuildsMutex.Lock()
1314	ret, specificReturn := fake.getPendingBuildsReturnsOnCall[len(fake.getPendingBuildsArgsForCall)]
1315	fake.getPendingBuildsArgsForCall = append(fake.getPendingBuildsArgsForCall, struct {
1316	}{})
1317	fake.recordInvocation("GetPendingBuilds", []interface{}{})
1318	fake.getPendingBuildsMutex.Unlock()
1319	if fake.GetPendingBuildsStub != nil {
1320		return fake.GetPendingBuildsStub()
1321	}
1322	if specificReturn {
1323		return ret.result1, ret.result2
1324	}
1325	fakeReturns := fake.getPendingBuildsReturns
1326	return fakeReturns.result1, fakeReturns.result2
1327}
1328
1329func (fake *FakeJob) GetPendingBuildsCallCount() int {
1330	fake.getPendingBuildsMutex.RLock()
1331	defer fake.getPendingBuildsMutex.RUnlock()
1332	return len(fake.getPendingBuildsArgsForCall)
1333}
1334
1335func (fake *FakeJob) GetPendingBuildsCalls(stub func() ([]db.Build, error)) {
1336	fake.getPendingBuildsMutex.Lock()
1337	defer fake.getPendingBuildsMutex.Unlock()
1338	fake.GetPendingBuildsStub = stub
1339}
1340
1341func (fake *FakeJob) GetPendingBuildsReturns(result1 []db.Build, result2 error) {
1342	fake.getPendingBuildsMutex.Lock()
1343	defer fake.getPendingBuildsMutex.Unlock()
1344	fake.GetPendingBuildsStub = nil
1345	fake.getPendingBuildsReturns = struct {
1346		result1 []db.Build
1347		result2 error
1348	}{result1, result2}
1349}
1350
1351func (fake *FakeJob) GetPendingBuildsReturnsOnCall(i int, result1 []db.Build, result2 error) {
1352	fake.getPendingBuildsMutex.Lock()
1353	defer fake.getPendingBuildsMutex.Unlock()
1354	fake.GetPendingBuildsStub = nil
1355	if fake.getPendingBuildsReturnsOnCall == nil {
1356		fake.getPendingBuildsReturnsOnCall = make(map[int]struct {
1357			result1 []db.Build
1358			result2 error
1359		})
1360	}
1361	fake.getPendingBuildsReturnsOnCall[i] = struct {
1362		result1 []db.Build
1363		result2 error
1364	}{result1, result2}
1365}
1366
1367func (fake *FakeJob) HasNewInputs() bool {
1368	fake.hasNewInputsMutex.Lock()
1369	ret, specificReturn := fake.hasNewInputsReturnsOnCall[len(fake.hasNewInputsArgsForCall)]
1370	fake.hasNewInputsArgsForCall = append(fake.hasNewInputsArgsForCall, struct {
1371	}{})
1372	fake.recordInvocation("HasNewInputs", []interface{}{})
1373	fake.hasNewInputsMutex.Unlock()
1374	if fake.HasNewInputsStub != nil {
1375		return fake.HasNewInputsStub()
1376	}
1377	if specificReturn {
1378		return ret.result1
1379	}
1380	fakeReturns := fake.hasNewInputsReturns
1381	return fakeReturns.result1
1382}
1383
1384func (fake *FakeJob) HasNewInputsCallCount() int {
1385	fake.hasNewInputsMutex.RLock()
1386	defer fake.hasNewInputsMutex.RUnlock()
1387	return len(fake.hasNewInputsArgsForCall)
1388}
1389
1390func (fake *FakeJob) HasNewInputsCalls(stub func() bool) {
1391	fake.hasNewInputsMutex.Lock()
1392	defer fake.hasNewInputsMutex.Unlock()
1393	fake.HasNewInputsStub = stub
1394}
1395
1396func (fake *FakeJob) HasNewInputsReturns(result1 bool) {
1397	fake.hasNewInputsMutex.Lock()
1398	defer fake.hasNewInputsMutex.Unlock()
1399	fake.HasNewInputsStub = nil
1400	fake.hasNewInputsReturns = struct {
1401		result1 bool
1402	}{result1}
1403}
1404
1405func (fake *FakeJob) HasNewInputsReturnsOnCall(i int, result1 bool) {
1406	fake.hasNewInputsMutex.Lock()
1407	defer fake.hasNewInputsMutex.Unlock()
1408	fake.HasNewInputsStub = nil
1409	if fake.hasNewInputsReturnsOnCall == nil {
1410		fake.hasNewInputsReturnsOnCall = make(map[int]struct {
1411			result1 bool
1412		})
1413	}
1414	fake.hasNewInputsReturnsOnCall[i] = struct {
1415		result1 bool
1416	}{result1}
1417}
1418
1419func (fake *FakeJob) ID() int {
1420	fake.iDMutex.Lock()
1421	ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
1422	fake.iDArgsForCall = append(fake.iDArgsForCall, struct {
1423	}{})
1424	fake.recordInvocation("ID", []interface{}{})
1425	fake.iDMutex.Unlock()
1426	if fake.IDStub != nil {
1427		return fake.IDStub()
1428	}
1429	if specificReturn {
1430		return ret.result1
1431	}
1432	fakeReturns := fake.iDReturns
1433	return fakeReturns.result1
1434}
1435
1436func (fake *FakeJob) IDCallCount() int {
1437	fake.iDMutex.RLock()
1438	defer fake.iDMutex.RUnlock()
1439	return len(fake.iDArgsForCall)
1440}
1441
1442func (fake *FakeJob) IDCalls(stub func() int) {
1443	fake.iDMutex.Lock()
1444	defer fake.iDMutex.Unlock()
1445	fake.IDStub = stub
1446}
1447
1448func (fake *FakeJob) IDReturns(result1 int) {
1449	fake.iDMutex.Lock()
1450	defer fake.iDMutex.Unlock()
1451	fake.IDStub = nil
1452	fake.iDReturns = struct {
1453		result1 int
1454	}{result1}
1455}
1456
1457func (fake *FakeJob) IDReturnsOnCall(i int, result1 int) {
1458	fake.iDMutex.Lock()
1459	defer fake.iDMutex.Unlock()
1460	fake.IDStub = nil
1461	if fake.iDReturnsOnCall == nil {
1462		fake.iDReturnsOnCall = make(map[int]struct {
1463			result1 int
1464		})
1465	}
1466	fake.iDReturnsOnCall[i] = struct {
1467		result1 int
1468	}{result1}
1469}
1470
1471func (fake *FakeJob) Inputs() ([]atc.JobInput, error) {
1472	fake.inputsMutex.Lock()
1473	ret, specificReturn := fake.inputsReturnsOnCall[len(fake.inputsArgsForCall)]
1474	fake.inputsArgsForCall = append(fake.inputsArgsForCall, struct {
1475	}{})
1476	fake.recordInvocation("Inputs", []interface{}{})
1477	fake.inputsMutex.Unlock()
1478	if fake.InputsStub != nil {
1479		return fake.InputsStub()
1480	}
1481	if specificReturn {
1482		return ret.result1, ret.result2
1483	}
1484	fakeReturns := fake.inputsReturns
1485	return fakeReturns.result1, fakeReturns.result2
1486}
1487
1488func (fake *FakeJob) InputsCallCount() int {
1489	fake.inputsMutex.RLock()
1490	defer fake.inputsMutex.RUnlock()
1491	return len(fake.inputsArgsForCall)
1492}
1493
1494func (fake *FakeJob) InputsCalls(stub func() ([]atc.JobInput, error)) {
1495	fake.inputsMutex.Lock()
1496	defer fake.inputsMutex.Unlock()
1497	fake.InputsStub = stub
1498}
1499
1500func (fake *FakeJob) InputsReturns(result1 []atc.JobInput, result2 error) {
1501	fake.inputsMutex.Lock()
1502	defer fake.inputsMutex.Unlock()
1503	fake.InputsStub = nil
1504	fake.inputsReturns = struct {
1505		result1 []atc.JobInput
1506		result2 error
1507	}{result1, result2}
1508}
1509
1510func (fake *FakeJob) InputsReturnsOnCall(i int, result1 []atc.JobInput, result2 error) {
1511	fake.inputsMutex.Lock()
1512	defer fake.inputsMutex.Unlock()
1513	fake.InputsStub = nil
1514	if fake.inputsReturnsOnCall == nil {
1515		fake.inputsReturnsOnCall = make(map[int]struct {
1516			result1 []atc.JobInput
1517			result2 error
1518		})
1519	}
1520	fake.inputsReturnsOnCall[i] = struct {
1521		result1 []atc.JobInput
1522		result2 error
1523	}{result1, result2}
1524}
1525
1526func (fake *FakeJob) MaxInFlight() int {
1527	fake.maxInFlightMutex.Lock()
1528	ret, specificReturn := fake.maxInFlightReturnsOnCall[len(fake.maxInFlightArgsForCall)]
1529	fake.maxInFlightArgsForCall = append(fake.maxInFlightArgsForCall, struct {
1530	}{})
1531	fake.recordInvocation("MaxInFlight", []interface{}{})
1532	fake.maxInFlightMutex.Unlock()
1533	if fake.MaxInFlightStub != nil {
1534		return fake.MaxInFlightStub()
1535	}
1536	if specificReturn {
1537		return ret.result1
1538	}
1539	fakeReturns := fake.maxInFlightReturns
1540	return fakeReturns.result1
1541}
1542
1543func (fake *FakeJob) MaxInFlightCallCount() int {
1544	fake.maxInFlightMutex.RLock()
1545	defer fake.maxInFlightMutex.RUnlock()
1546	return len(fake.maxInFlightArgsForCall)
1547}
1548
1549func (fake *FakeJob) MaxInFlightCalls(stub func() int) {
1550	fake.maxInFlightMutex.Lock()
1551	defer fake.maxInFlightMutex.Unlock()
1552	fake.MaxInFlightStub = stub
1553}
1554
1555func (fake *FakeJob) MaxInFlightReturns(result1 int) {
1556	fake.maxInFlightMutex.Lock()
1557	defer fake.maxInFlightMutex.Unlock()
1558	fake.MaxInFlightStub = nil
1559	fake.maxInFlightReturns = struct {
1560		result1 int
1561	}{result1}
1562}
1563
1564func (fake *FakeJob) MaxInFlightReturnsOnCall(i int, result1 int) {
1565	fake.maxInFlightMutex.Lock()
1566	defer fake.maxInFlightMutex.Unlock()
1567	fake.MaxInFlightStub = nil
1568	if fake.maxInFlightReturnsOnCall == nil {
1569		fake.maxInFlightReturnsOnCall = make(map[int]struct {
1570			result1 int
1571		})
1572	}
1573	fake.maxInFlightReturnsOnCall[i] = struct {
1574		result1 int
1575	}{result1}
1576}
1577
1578func (fake *FakeJob) Name() string {
1579	fake.nameMutex.Lock()
1580	ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)]
1581	fake.nameArgsForCall = append(fake.nameArgsForCall, struct {
1582	}{})
1583	fake.recordInvocation("Name", []interface{}{})
1584	fake.nameMutex.Unlock()
1585	if fake.NameStub != nil {
1586		return fake.NameStub()
1587	}
1588	if specificReturn {
1589		return ret.result1
1590	}
1591	fakeReturns := fake.nameReturns
1592	return fakeReturns.result1
1593}
1594
1595func (fake *FakeJob) NameCallCount() int {
1596	fake.nameMutex.RLock()
1597	defer fake.nameMutex.RUnlock()
1598	return len(fake.nameArgsForCall)
1599}
1600
1601func (fake *FakeJob) NameCalls(stub func() string) {
1602	fake.nameMutex.Lock()
1603	defer fake.nameMutex.Unlock()
1604	fake.NameStub = stub
1605}
1606
1607func (fake *FakeJob) NameReturns(result1 string) {
1608	fake.nameMutex.Lock()
1609	defer fake.nameMutex.Unlock()
1610	fake.NameStub = nil
1611	fake.nameReturns = struct {
1612		result1 string
1613	}{result1}
1614}
1615
1616func (fake *FakeJob) NameReturnsOnCall(i int, result1 string) {
1617	fake.nameMutex.Lock()
1618	defer fake.nameMutex.Unlock()
1619	fake.NameStub = nil
1620	if fake.nameReturnsOnCall == nil {
1621		fake.nameReturnsOnCall = make(map[int]struct {
1622			result1 string
1623		})
1624	}
1625	fake.nameReturnsOnCall[i] = struct {
1626		result1 string
1627	}{result1}
1628}
1629
1630func (fake *FakeJob) Outputs() ([]atc.JobOutput, error) {
1631	fake.outputsMutex.Lock()
1632	ret, specificReturn := fake.outputsReturnsOnCall[len(fake.outputsArgsForCall)]
1633	fake.outputsArgsForCall = append(fake.outputsArgsForCall, struct {
1634	}{})
1635	fake.recordInvocation("Outputs", []interface{}{})
1636	fake.outputsMutex.Unlock()
1637	if fake.OutputsStub != nil {
1638		return fake.OutputsStub()
1639	}
1640	if specificReturn {
1641		return ret.result1, ret.result2
1642	}
1643	fakeReturns := fake.outputsReturns
1644	return fakeReturns.result1, fakeReturns.result2
1645}
1646
1647func (fake *FakeJob) OutputsCallCount() int {
1648	fake.outputsMutex.RLock()
1649	defer fake.outputsMutex.RUnlock()
1650	return len(fake.outputsArgsForCall)
1651}
1652
1653func (fake *FakeJob) OutputsCalls(stub func() ([]atc.JobOutput, error)) {
1654	fake.outputsMutex.Lock()
1655	defer fake.outputsMutex.Unlock()
1656	fake.OutputsStub = stub
1657}
1658
1659func (fake *FakeJob) OutputsReturns(result1 []atc.JobOutput, result2 error) {
1660	fake.outputsMutex.Lock()
1661	defer fake.outputsMutex.Unlock()
1662	fake.OutputsStub = nil
1663	fake.outputsReturns = struct {
1664		result1 []atc.JobOutput
1665		result2 error
1666	}{result1, result2}
1667}
1668
1669func (fake *FakeJob) OutputsReturnsOnCall(i int, result1 []atc.JobOutput, result2 error) {
1670	fake.outputsMutex.Lock()
1671	defer fake.outputsMutex.Unlock()
1672	fake.OutputsStub = nil
1673	if fake.outputsReturnsOnCall == nil {
1674		fake.outputsReturnsOnCall = make(map[int]struct {
1675			result1 []atc.JobOutput
1676			result2 error
1677		})
1678	}
1679	fake.outputsReturnsOnCall[i] = struct {
1680		result1 []atc.JobOutput
1681		result2 error
1682	}{result1, result2}
1683}
1684
1685func (fake *FakeJob) Pause() error {
1686	fake.pauseMutex.Lock()
1687	ret, specificReturn := fake.pauseReturnsOnCall[len(fake.pauseArgsForCall)]
1688	fake.pauseArgsForCall = append(fake.pauseArgsForCall, struct {
1689	}{})
1690	fake.recordInvocation("Pause", []interface{}{})
1691	fake.pauseMutex.Unlock()
1692	if fake.PauseStub != nil {
1693		return fake.PauseStub()
1694	}
1695	if specificReturn {
1696		return ret.result1
1697	}
1698	fakeReturns := fake.pauseReturns
1699	return fakeReturns.result1
1700}
1701
1702func (fake *FakeJob) PauseCallCount() int {
1703	fake.pauseMutex.RLock()
1704	defer fake.pauseMutex.RUnlock()
1705	return len(fake.pauseArgsForCall)
1706}
1707
1708func (fake *FakeJob) PauseCalls(stub func() error) {
1709	fake.pauseMutex.Lock()
1710	defer fake.pauseMutex.Unlock()
1711	fake.PauseStub = stub
1712}
1713
1714func (fake *FakeJob) PauseReturns(result1 error) {
1715	fake.pauseMutex.Lock()
1716	defer fake.pauseMutex.Unlock()
1717	fake.PauseStub = nil
1718	fake.pauseReturns = struct {
1719		result1 error
1720	}{result1}
1721}
1722
1723func (fake *FakeJob) PauseReturnsOnCall(i int, result1 error) {
1724	fake.pauseMutex.Lock()
1725	defer fake.pauseMutex.Unlock()
1726	fake.PauseStub = nil
1727	if fake.pauseReturnsOnCall == nil {
1728		fake.pauseReturnsOnCall = make(map[int]struct {
1729			result1 error
1730		})
1731	}
1732	fake.pauseReturnsOnCall[i] = struct {
1733		result1 error
1734	}{result1}
1735}
1736
1737func (fake *FakeJob) Paused() bool {
1738	fake.pausedMutex.Lock()
1739	ret, specificReturn := fake.pausedReturnsOnCall[len(fake.pausedArgsForCall)]
1740	fake.pausedArgsForCall = append(fake.pausedArgsForCall, struct {
1741	}{})
1742	fake.recordInvocation("Paused", []interface{}{})
1743	fake.pausedMutex.Unlock()
1744	if fake.PausedStub != nil {
1745		return fake.PausedStub()
1746	}
1747	if specificReturn {
1748		return ret.result1
1749	}
1750	fakeReturns := fake.pausedReturns
1751	return fakeReturns.result1
1752}
1753
1754func (fake *FakeJob) PausedCallCount() int {
1755	fake.pausedMutex.RLock()
1756	defer fake.pausedMutex.RUnlock()
1757	return len(fake.pausedArgsForCall)
1758}
1759
1760func (fake *FakeJob) PausedCalls(stub func() bool) {
1761	fake.pausedMutex.Lock()
1762	defer fake.pausedMutex.Unlock()
1763	fake.PausedStub = stub
1764}
1765
1766func (fake *FakeJob) PausedReturns(result1 bool) {
1767	fake.pausedMutex.Lock()
1768	defer fake.pausedMutex.Unlock()
1769	fake.PausedStub = nil
1770	fake.pausedReturns = struct {
1771		result1 bool
1772	}{result1}
1773}
1774
1775func (fake *FakeJob) PausedReturnsOnCall(i int, result1 bool) {
1776	fake.pausedMutex.Lock()
1777	defer fake.pausedMutex.Unlock()
1778	fake.PausedStub = nil
1779	if fake.pausedReturnsOnCall == nil {
1780		fake.pausedReturnsOnCall = make(map[int]struct {
1781			result1 bool
1782		})
1783	}
1784	fake.pausedReturnsOnCall[i] = struct {
1785		result1 bool
1786	}{result1}
1787}
1788
1789func (fake *FakeJob) Pipeline() (db.Pipeline, bool, error) {
1790	fake.pipelineMutex.Lock()
1791	ret, specificReturn := fake.pipelineReturnsOnCall[len(fake.pipelineArgsForCall)]
1792	fake.pipelineArgsForCall = append(fake.pipelineArgsForCall, struct {
1793	}{})
1794	fake.recordInvocation("Pipeline", []interface{}{})
1795	fake.pipelineMutex.Unlock()
1796	if fake.PipelineStub != nil {
1797		return fake.PipelineStub()
1798	}
1799	if specificReturn {
1800		return ret.result1, ret.result2, ret.result3
1801	}
1802	fakeReturns := fake.pipelineReturns
1803	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
1804}
1805
1806func (fake *FakeJob) PipelineCallCount() int {
1807	fake.pipelineMutex.RLock()
1808	defer fake.pipelineMutex.RUnlock()
1809	return len(fake.pipelineArgsForCall)
1810}
1811
1812func (fake *FakeJob) PipelineCalls(stub func() (db.Pipeline, bool, error)) {
1813	fake.pipelineMutex.Lock()
1814	defer fake.pipelineMutex.Unlock()
1815	fake.PipelineStub = stub
1816}
1817
1818func (fake *FakeJob) PipelineReturns(result1 db.Pipeline, result2 bool, result3 error) {
1819	fake.pipelineMutex.Lock()
1820	defer fake.pipelineMutex.Unlock()
1821	fake.PipelineStub = nil
1822	fake.pipelineReturns = struct {
1823		result1 db.Pipeline
1824		result2 bool
1825		result3 error
1826	}{result1, result2, result3}
1827}
1828
1829func (fake *FakeJob) PipelineReturnsOnCall(i int, result1 db.Pipeline, result2 bool, result3 error) {
1830	fake.pipelineMutex.Lock()
1831	defer fake.pipelineMutex.Unlock()
1832	fake.PipelineStub = nil
1833	if fake.pipelineReturnsOnCall == nil {
1834		fake.pipelineReturnsOnCall = make(map[int]struct {
1835			result1 db.Pipeline
1836			result2 bool
1837			result3 error
1838		})
1839	}
1840	fake.pipelineReturnsOnCall[i] = struct {
1841		result1 db.Pipeline
1842		result2 bool
1843		result3 error
1844	}{result1, result2, result3}
1845}
1846
1847func (fake *FakeJob) PipelineID() int {
1848	fake.pipelineIDMutex.Lock()
1849	ret, specificReturn := fake.pipelineIDReturnsOnCall[len(fake.pipelineIDArgsForCall)]
1850	fake.pipelineIDArgsForCall = append(fake.pipelineIDArgsForCall, struct {
1851	}{})
1852	fake.recordInvocation("PipelineID", []interface{}{})
1853	fake.pipelineIDMutex.Unlock()
1854	if fake.PipelineIDStub != nil {
1855		return fake.PipelineIDStub()
1856	}
1857	if specificReturn {
1858		return ret.result1
1859	}
1860	fakeReturns := fake.pipelineIDReturns
1861	return fakeReturns.result1
1862}
1863
1864func (fake *FakeJob) PipelineIDCallCount() int {
1865	fake.pipelineIDMutex.RLock()
1866	defer fake.pipelineIDMutex.RUnlock()
1867	return len(fake.pipelineIDArgsForCall)
1868}
1869
1870func (fake *FakeJob) PipelineIDCalls(stub func() int) {
1871	fake.pipelineIDMutex.Lock()
1872	defer fake.pipelineIDMutex.Unlock()
1873	fake.PipelineIDStub = stub
1874}
1875
1876func (fake *FakeJob) PipelineIDReturns(result1 int) {
1877	fake.pipelineIDMutex.Lock()
1878	defer fake.pipelineIDMutex.Unlock()
1879	fake.PipelineIDStub = nil
1880	fake.pipelineIDReturns = struct {
1881		result1 int
1882	}{result1}
1883}
1884
1885func (fake *FakeJob) PipelineIDReturnsOnCall(i int, result1 int) {
1886	fake.pipelineIDMutex.Lock()
1887	defer fake.pipelineIDMutex.Unlock()
1888	fake.PipelineIDStub = nil
1889	if fake.pipelineIDReturnsOnCall == nil {
1890		fake.pipelineIDReturnsOnCall = make(map[int]struct {
1891			result1 int
1892		})
1893	}
1894	fake.pipelineIDReturnsOnCall[i] = struct {
1895		result1 int
1896	}{result1}
1897}
1898
1899func (fake *FakeJob) PipelineName() string {
1900	fake.pipelineNameMutex.Lock()
1901	ret, specificReturn := fake.pipelineNameReturnsOnCall[len(fake.pipelineNameArgsForCall)]
1902	fake.pipelineNameArgsForCall = append(fake.pipelineNameArgsForCall, struct {
1903	}{})
1904	fake.recordInvocation("PipelineName", []interface{}{})
1905	fake.pipelineNameMutex.Unlock()
1906	if fake.PipelineNameStub != nil {
1907		return fake.PipelineNameStub()
1908	}
1909	if specificReturn {
1910		return ret.result1
1911	}
1912	fakeReturns := fake.pipelineNameReturns
1913	return fakeReturns.result1
1914}
1915
1916func (fake *FakeJob) PipelineNameCallCount() int {
1917	fake.pipelineNameMutex.RLock()
1918	defer fake.pipelineNameMutex.RUnlock()
1919	return len(fake.pipelineNameArgsForCall)
1920}
1921
1922func (fake *FakeJob) PipelineNameCalls(stub func() string) {
1923	fake.pipelineNameMutex.Lock()
1924	defer fake.pipelineNameMutex.Unlock()
1925	fake.PipelineNameStub = stub
1926}
1927
1928func (fake *FakeJob) PipelineNameReturns(result1 string) {
1929	fake.pipelineNameMutex.Lock()
1930	defer fake.pipelineNameMutex.Unlock()
1931	fake.PipelineNameStub = nil
1932	fake.pipelineNameReturns = struct {
1933		result1 string
1934	}{result1}
1935}
1936
1937func (fake *FakeJob) PipelineNameReturnsOnCall(i int, result1 string) {
1938	fake.pipelineNameMutex.Lock()
1939	defer fake.pipelineNameMutex.Unlock()
1940	fake.PipelineNameStub = nil
1941	if fake.pipelineNameReturnsOnCall == nil {
1942		fake.pipelineNameReturnsOnCall = make(map[int]struct {
1943			result1 string
1944		})
1945	}
1946	fake.pipelineNameReturnsOnCall[i] = struct {
1947		result1 string
1948	}{result1}
1949}
1950
1951func (fake *FakeJob) Public() bool {
1952	fake.publicMutex.Lock()
1953	ret, specificReturn := fake.publicReturnsOnCall[len(fake.publicArgsForCall)]
1954	fake.publicArgsForCall = append(fake.publicArgsForCall, struct {
1955	}{})
1956	fake.recordInvocation("Public", []interface{}{})
1957	fake.publicMutex.Unlock()
1958	if fake.PublicStub != nil {
1959		return fake.PublicStub()
1960	}
1961	if specificReturn {
1962		return ret.result1
1963	}
1964	fakeReturns := fake.publicReturns
1965	return fakeReturns.result1
1966}
1967
1968func (fake *FakeJob) PublicCallCount() int {
1969	fake.publicMutex.RLock()
1970	defer fake.publicMutex.RUnlock()
1971	return len(fake.publicArgsForCall)
1972}
1973
1974func (fake *FakeJob) PublicCalls(stub func() bool) {
1975	fake.publicMutex.Lock()
1976	defer fake.publicMutex.Unlock()
1977	fake.PublicStub = stub
1978}
1979
1980func (fake *FakeJob) PublicReturns(result1 bool) {
1981	fake.publicMutex.Lock()
1982	defer fake.publicMutex.Unlock()
1983	fake.PublicStub = nil
1984	fake.publicReturns = struct {
1985		result1 bool
1986	}{result1}
1987}
1988
1989func (fake *FakeJob) PublicReturnsOnCall(i int, result1 bool) {
1990	fake.publicMutex.Lock()
1991	defer fake.publicMutex.Unlock()
1992	fake.PublicStub = nil
1993	if fake.publicReturnsOnCall == nil {
1994		fake.publicReturnsOnCall = make(map[int]struct {
1995			result1 bool
1996		})
1997	}
1998	fake.publicReturnsOnCall[i] = struct {
1999		result1 bool
2000	}{result1}
2001}
2002
2003func (fake *FakeJob) Reload() (bool, error) {
2004	fake.reloadMutex.Lock()
2005	ret, specificReturn := fake.reloadReturnsOnCall[len(fake.reloadArgsForCall)]
2006	fake.reloadArgsForCall = append(fake.reloadArgsForCall, struct {
2007	}{})
2008	fake.recordInvocation("Reload", []interface{}{})
2009	fake.reloadMutex.Unlock()
2010	if fake.ReloadStub != nil {
2011		return fake.ReloadStub()
2012	}
2013	if specificReturn {
2014		return ret.result1, ret.result2
2015	}
2016	fakeReturns := fake.reloadReturns
2017	return fakeReturns.result1, fakeReturns.result2
2018}
2019
2020func (fake *FakeJob) ReloadCallCount() int {
2021	fake.reloadMutex.RLock()
2022	defer fake.reloadMutex.RUnlock()
2023	return len(fake.reloadArgsForCall)
2024}
2025
2026func (fake *FakeJob) ReloadCalls(stub func() (bool, error)) {
2027	fake.reloadMutex.Lock()
2028	defer fake.reloadMutex.Unlock()
2029	fake.ReloadStub = stub
2030}
2031
2032func (fake *FakeJob) ReloadReturns(result1 bool, result2 error) {
2033	fake.reloadMutex.Lock()
2034	defer fake.reloadMutex.Unlock()
2035	fake.ReloadStub = nil
2036	fake.reloadReturns = struct {
2037		result1 bool
2038		result2 error
2039	}{result1, result2}
2040}
2041
2042func (fake *FakeJob) ReloadReturnsOnCall(i int, result1 bool, result2 error) {
2043	fake.reloadMutex.Lock()
2044	defer fake.reloadMutex.Unlock()
2045	fake.ReloadStub = nil
2046	if fake.reloadReturnsOnCall == nil {
2047		fake.reloadReturnsOnCall = make(map[int]struct {
2048			result1 bool
2049			result2 error
2050		})
2051	}
2052	fake.reloadReturnsOnCall[i] = struct {
2053		result1 bool
2054		result2 error
2055	}{result1, result2}
2056}
2057
2058func (fake *FakeJob) RequestSchedule() error {
2059	fake.requestScheduleMutex.Lock()
2060	ret, specificReturn := fake.requestScheduleReturnsOnCall[len(fake.requestScheduleArgsForCall)]
2061	fake.requestScheduleArgsForCall = append(fake.requestScheduleArgsForCall, struct {
2062	}{})
2063	fake.recordInvocation("RequestSchedule", []interface{}{})
2064	fake.requestScheduleMutex.Unlock()
2065	if fake.RequestScheduleStub != nil {
2066		return fake.RequestScheduleStub()
2067	}
2068	if specificReturn {
2069		return ret.result1
2070	}
2071	fakeReturns := fake.requestScheduleReturns
2072	return fakeReturns.result1
2073}
2074
2075func (fake *FakeJob) RequestScheduleCallCount() int {
2076	fake.requestScheduleMutex.RLock()
2077	defer fake.requestScheduleMutex.RUnlock()
2078	return len(fake.requestScheduleArgsForCall)
2079}
2080
2081func (fake *FakeJob) RequestScheduleCalls(stub func() error) {
2082	fake.requestScheduleMutex.Lock()
2083	defer fake.requestScheduleMutex.Unlock()
2084	fake.RequestScheduleStub = stub
2085}
2086
2087func (fake *FakeJob) RequestScheduleReturns(result1 error) {
2088	fake.requestScheduleMutex.Lock()
2089	defer fake.requestScheduleMutex.Unlock()
2090	fake.RequestScheduleStub = nil
2091	fake.requestScheduleReturns = struct {
2092		result1 error
2093	}{result1}
2094}
2095
2096func (fake *FakeJob) RequestScheduleReturnsOnCall(i int, result1 error) {
2097	fake.requestScheduleMutex.Lock()
2098	defer fake.requestScheduleMutex.Unlock()
2099	fake.RequestScheduleStub = nil
2100	if fake.requestScheduleReturnsOnCall == nil {
2101		fake.requestScheduleReturnsOnCall = make(map[int]struct {
2102			result1 error
2103		})
2104	}
2105	fake.requestScheduleReturnsOnCall[i] = struct {
2106		result1 error
2107	}{result1}
2108}
2109
2110func (fake *FakeJob) RerunBuild(arg1 db.Build) (db.Build, error) {
2111	fake.rerunBuildMutex.Lock()
2112	ret, specificReturn := fake.rerunBuildReturnsOnCall[len(fake.rerunBuildArgsForCall)]
2113	fake.rerunBuildArgsForCall = append(fake.rerunBuildArgsForCall, struct {
2114		arg1 db.Build
2115	}{arg1})
2116	fake.recordInvocation("RerunBuild", []interface{}{arg1})
2117	fake.rerunBuildMutex.Unlock()
2118	if fake.RerunBuildStub != nil {
2119		return fake.RerunBuildStub(arg1)
2120	}
2121	if specificReturn {
2122		return ret.result1, ret.result2
2123	}
2124	fakeReturns := fake.rerunBuildReturns
2125	return fakeReturns.result1, fakeReturns.result2
2126}
2127
2128func (fake *FakeJob) RerunBuildCallCount() int {
2129	fake.rerunBuildMutex.RLock()
2130	defer fake.rerunBuildMutex.RUnlock()
2131	return len(fake.rerunBuildArgsForCall)
2132}
2133
2134func (fake *FakeJob) RerunBuildCalls(stub func(db.Build) (db.Build, error)) {
2135	fake.rerunBuildMutex.Lock()
2136	defer fake.rerunBuildMutex.Unlock()
2137	fake.RerunBuildStub = stub
2138}
2139
2140func (fake *FakeJob) RerunBuildArgsForCall(i int) db.Build {
2141	fake.rerunBuildMutex.RLock()
2142	defer fake.rerunBuildMutex.RUnlock()
2143	argsForCall := fake.rerunBuildArgsForCall[i]
2144	return argsForCall.arg1
2145}
2146
2147func (fake *FakeJob) RerunBuildReturns(result1 db.Build, result2 error) {
2148	fake.rerunBuildMutex.Lock()
2149	defer fake.rerunBuildMutex.Unlock()
2150	fake.RerunBuildStub = nil
2151	fake.rerunBuildReturns = struct {
2152		result1 db.Build
2153		result2 error
2154	}{result1, result2}
2155}
2156
2157func (fake *FakeJob) RerunBuildReturnsOnCall(i int, result1 db.Build, result2 error) {
2158	fake.rerunBuildMutex.Lock()
2159	defer fake.rerunBuildMutex.Unlock()
2160	fake.RerunBuildStub = nil
2161	if fake.rerunBuildReturnsOnCall == nil {
2162		fake.rerunBuildReturnsOnCall = make(map[int]struct {
2163			result1 db.Build
2164			result2 error
2165		})
2166	}
2167	fake.rerunBuildReturnsOnCall[i] = struct {
2168		result1 db.Build
2169		result2 error
2170	}{result1, result2}
2171}
2172
2173func (fake *FakeJob) SaveNextInputMapping(arg1 db.InputMapping, arg2 bool) error {
2174	fake.saveNextInputMappingMutex.Lock()
2175	ret, specificReturn := fake.saveNextInputMappingReturnsOnCall[len(fake.saveNextInputMappingArgsForCall)]
2176	fake.saveNextInputMappingArgsForCall = append(fake.saveNextInputMappingArgsForCall, struct {
2177		arg1 db.InputMapping
2178		arg2 bool
2179	}{arg1, arg2})
2180	fake.recordInvocation("SaveNextInputMapping", []interface{}{arg1, arg2})
2181	fake.saveNextInputMappingMutex.Unlock()
2182	if fake.SaveNextInputMappingStub != nil {
2183		return fake.SaveNextInputMappingStub(arg1, arg2)
2184	}
2185	if specificReturn {
2186		return ret.result1
2187	}
2188	fakeReturns := fake.saveNextInputMappingReturns
2189	return fakeReturns.result1
2190}
2191
2192func (fake *FakeJob) SaveNextInputMappingCallCount() int {
2193	fake.saveNextInputMappingMutex.RLock()
2194	defer fake.saveNextInputMappingMutex.RUnlock()
2195	return len(fake.saveNextInputMappingArgsForCall)
2196}
2197
2198func (fake *FakeJob) SaveNextInputMappingCalls(stub func(db.InputMapping, bool) error) {
2199	fake.saveNextInputMappingMutex.Lock()
2200	defer fake.saveNextInputMappingMutex.Unlock()
2201	fake.SaveNextInputMappingStub = stub
2202}
2203
2204func (fake *FakeJob) SaveNextInputMappingArgsForCall(i int) (db.InputMapping, bool) {
2205	fake.saveNextInputMappingMutex.RLock()
2206	defer fake.saveNextInputMappingMutex.RUnlock()
2207	argsForCall := fake.saveNextInputMappingArgsForCall[i]
2208	return argsForCall.arg1, argsForCall.arg2
2209}
2210
2211func (fake *FakeJob) SaveNextInputMappingReturns(result1 error) {
2212	fake.saveNextInputMappingMutex.Lock()
2213	defer fake.saveNextInputMappingMutex.Unlock()
2214	fake.SaveNextInputMappingStub = nil
2215	fake.saveNextInputMappingReturns = struct {
2216		result1 error
2217	}{result1}
2218}
2219
2220func (fake *FakeJob) SaveNextInputMappingReturnsOnCall(i int, result1 error) {
2221	fake.saveNextInputMappingMutex.Lock()
2222	defer fake.saveNextInputMappingMutex.Unlock()
2223	fake.SaveNextInputMappingStub = nil
2224	if fake.saveNextInputMappingReturnsOnCall == nil {
2225		fake.saveNextInputMappingReturnsOnCall = make(map[int]struct {
2226			result1 error
2227		})
2228	}
2229	fake.saveNextInputMappingReturnsOnCall[i] = struct {
2230		result1 error
2231	}{result1}
2232}
2233
2234func (fake *FakeJob) ScheduleBuild(arg1 db.Build) (bool, error) {
2235	fake.scheduleBuildMutex.Lock()
2236	ret, specificReturn := fake.scheduleBuildReturnsOnCall[len(fake.scheduleBuildArgsForCall)]
2237	fake.scheduleBuildArgsForCall = append(fake.scheduleBuildArgsForCall, struct {
2238		arg1 db.Build
2239	}{arg1})
2240	fake.recordInvocation("ScheduleBuild", []interface{}{arg1})
2241	fake.scheduleBuildMutex.Unlock()
2242	if fake.ScheduleBuildStub != nil {
2243		return fake.ScheduleBuildStub(arg1)
2244	}
2245	if specificReturn {
2246		return ret.result1, ret.result2
2247	}
2248	fakeReturns := fake.scheduleBuildReturns
2249	return fakeReturns.result1, fakeReturns.result2
2250}
2251
2252func (fake *FakeJob) ScheduleBuildCallCount() int {
2253	fake.scheduleBuildMutex.RLock()
2254	defer fake.scheduleBuildMutex.RUnlock()
2255	return len(fake.scheduleBuildArgsForCall)
2256}
2257
2258func (fake *FakeJob) ScheduleBuildCalls(stub func(db.Build) (bool, error)) {
2259	fake.scheduleBuildMutex.Lock()
2260	defer fake.scheduleBuildMutex.Unlock()
2261	fake.ScheduleBuildStub = stub
2262}
2263
2264func (fake *FakeJob) ScheduleBuildArgsForCall(i int) db.Build {
2265	fake.scheduleBuildMutex.RLock()
2266	defer fake.scheduleBuildMutex.RUnlock()
2267	argsForCall := fake.scheduleBuildArgsForCall[i]
2268	return argsForCall.arg1
2269}
2270
2271func (fake *FakeJob) ScheduleBuildReturns(result1 bool, result2 error) {
2272	fake.scheduleBuildMutex.Lock()
2273	defer fake.scheduleBuildMutex.Unlock()
2274	fake.ScheduleBuildStub = nil
2275	fake.scheduleBuildReturns = struct {
2276		result1 bool
2277		result2 error
2278	}{result1, result2}
2279}
2280
2281func (fake *FakeJob) ScheduleBuildReturnsOnCall(i int, result1 bool, result2 error) {
2282	fake.scheduleBuildMutex.Lock()
2283	defer fake.scheduleBuildMutex.Unlock()
2284	fake.ScheduleBuildStub = nil
2285	if fake.scheduleBuildReturnsOnCall == nil {
2286		fake.scheduleBuildReturnsOnCall = make(map[int]struct {
2287			result1 bool
2288			result2 error
2289		})
2290	}
2291	fake.scheduleBuildReturnsOnCall[i] = struct {
2292		result1 bool
2293		result2 error
2294	}{result1, result2}
2295}
2296
2297func (fake *FakeJob) ScheduleRequestedTime() time.Time {
2298	fake.scheduleRequestedTimeMutex.Lock()
2299	ret, specificReturn := fake.scheduleRequestedTimeReturnsOnCall[len(fake.scheduleRequestedTimeArgsForCall)]
2300	fake.scheduleRequestedTimeArgsForCall = append(fake.scheduleRequestedTimeArgsForCall, struct {
2301	}{})
2302	fake.recordInvocation("ScheduleRequestedTime", []interface{}{})
2303	fake.scheduleRequestedTimeMutex.Unlock()
2304	if fake.ScheduleRequestedTimeStub != nil {
2305		return fake.ScheduleRequestedTimeStub()
2306	}
2307	if specificReturn {
2308		return ret.result1
2309	}
2310	fakeReturns := fake.scheduleRequestedTimeReturns
2311	return fakeReturns.result1
2312}
2313
2314func (fake *FakeJob) ScheduleRequestedTimeCallCount() int {
2315	fake.scheduleRequestedTimeMutex.RLock()
2316	defer fake.scheduleRequestedTimeMutex.RUnlock()
2317	return len(fake.scheduleRequestedTimeArgsForCall)
2318}
2319
2320func (fake *FakeJob) ScheduleRequestedTimeCalls(stub func() time.Time) {
2321	fake.scheduleRequestedTimeMutex.Lock()
2322	defer fake.scheduleRequestedTimeMutex.Unlock()
2323	fake.ScheduleRequestedTimeStub = stub
2324}
2325
2326func (fake *FakeJob) ScheduleRequestedTimeReturns(result1 time.Time) {
2327	fake.scheduleRequestedTimeMutex.Lock()
2328	defer fake.scheduleRequestedTimeMutex.Unlock()
2329	fake.ScheduleRequestedTimeStub = nil
2330	fake.scheduleRequestedTimeReturns = struct {
2331		result1 time.Time
2332	}{result1}
2333}
2334
2335func (fake *FakeJob) ScheduleRequestedTimeReturnsOnCall(i int, result1 time.Time) {
2336	fake.scheduleRequestedTimeMutex.Lock()
2337	defer fake.scheduleRequestedTimeMutex.Unlock()
2338	fake.ScheduleRequestedTimeStub = nil
2339	if fake.scheduleRequestedTimeReturnsOnCall == nil {
2340		fake.scheduleRequestedTimeReturnsOnCall = make(map[int]struct {
2341			result1 time.Time
2342		})
2343	}
2344	fake.scheduleRequestedTimeReturnsOnCall[i] = struct {
2345		result1 time.Time
2346	}{result1}
2347}
2348
2349func (fake *FakeJob) SetHasNewInputs(arg1 bool) error {
2350	fake.setHasNewInputsMutex.Lock()
2351	ret, specificReturn := fake.setHasNewInputsReturnsOnCall[len(fake.setHasNewInputsArgsForCall)]
2352	fake.setHasNewInputsArgsForCall = append(fake.setHasNewInputsArgsForCall, struct {
2353		arg1 bool
2354	}{arg1})
2355	fake.recordInvocation("SetHasNewInputs", []interface{}{arg1})
2356	fake.setHasNewInputsMutex.Unlock()
2357	if fake.SetHasNewInputsStub != nil {
2358		return fake.SetHasNewInputsStub(arg1)
2359	}
2360	if specificReturn {
2361		return ret.result1
2362	}
2363	fakeReturns := fake.setHasNewInputsReturns
2364	return fakeReturns.result1
2365}
2366
2367func (fake *FakeJob) SetHasNewInputsCallCount() int {
2368	fake.setHasNewInputsMutex.RLock()
2369	defer fake.setHasNewInputsMutex.RUnlock()
2370	return len(fake.setHasNewInputsArgsForCall)
2371}
2372
2373func (fake *FakeJob) SetHasNewInputsCalls(stub func(bool) error) {
2374	fake.setHasNewInputsMutex.Lock()
2375	defer fake.setHasNewInputsMutex.Unlock()
2376	fake.SetHasNewInputsStub = stub
2377}
2378
2379func (fake *FakeJob) SetHasNewInputsArgsForCall(i int) bool {
2380	fake.setHasNewInputsMutex.RLock()
2381	defer fake.setHasNewInputsMutex.RUnlock()
2382	argsForCall := fake.setHasNewInputsArgsForCall[i]
2383	return argsForCall.arg1
2384}
2385
2386func (fake *FakeJob) SetHasNewInputsReturns(result1 error) {
2387	fake.setHasNewInputsMutex.Lock()
2388	defer fake.setHasNewInputsMutex.Unlock()
2389	fake.SetHasNewInputsStub = nil
2390	fake.setHasNewInputsReturns = struct {
2391		result1 error
2392	}{result1}
2393}
2394
2395func (fake *FakeJob) SetHasNewInputsReturnsOnCall(i int, result1 error) {
2396	fake.setHasNewInputsMutex.Lock()
2397	defer fake.setHasNewInputsMutex.Unlock()
2398	fake.SetHasNewInputsStub = nil
2399	if fake.setHasNewInputsReturnsOnCall == nil {
2400		fake.setHasNewInputsReturnsOnCall = make(map[int]struct {
2401			result1 error
2402		})
2403	}
2404	fake.setHasNewInputsReturnsOnCall[i] = struct {
2405		result1 error
2406	}{result1}
2407}
2408
2409func (fake *FakeJob) Tags() []string {
2410	fake.tagsMutex.Lock()
2411	ret, specificReturn := fake.tagsReturnsOnCall[len(fake.tagsArgsForCall)]
2412	fake.tagsArgsForCall = append(fake.tagsArgsForCall, struct {
2413	}{})
2414	fake.recordInvocation("Tags", []interface{}{})
2415	fake.tagsMutex.Unlock()
2416	if fake.TagsStub != nil {
2417		return fake.TagsStub()
2418	}
2419	if specificReturn {
2420		return ret.result1
2421	}
2422	fakeReturns := fake.tagsReturns
2423	return fakeReturns.result1
2424}
2425
2426func (fake *FakeJob) TagsCallCount() int {
2427	fake.tagsMutex.RLock()
2428	defer fake.tagsMutex.RUnlock()
2429	return len(fake.tagsArgsForCall)
2430}
2431
2432func (fake *FakeJob) TagsCalls(stub func() []string) {
2433	fake.tagsMutex.Lock()
2434	defer fake.tagsMutex.Unlock()
2435	fake.TagsStub = stub
2436}
2437
2438func (fake *FakeJob) TagsReturns(result1 []string) {
2439	fake.tagsMutex.Lock()
2440	defer fake.tagsMutex.Unlock()
2441	fake.TagsStub = nil
2442	fake.tagsReturns = struct {
2443		result1 []string
2444	}{result1}
2445}
2446
2447func (fake *FakeJob) TagsReturnsOnCall(i int, result1 []string) {
2448	fake.tagsMutex.Lock()
2449	defer fake.tagsMutex.Unlock()
2450	fake.TagsStub = nil
2451	if fake.tagsReturnsOnCall == nil {
2452		fake.tagsReturnsOnCall = make(map[int]struct {
2453			result1 []string
2454		})
2455	}
2456	fake.tagsReturnsOnCall[i] = struct {
2457		result1 []string
2458	}{result1}
2459}
2460
2461func (fake *FakeJob) TeamID() int {
2462	fake.teamIDMutex.Lock()
2463	ret, specificReturn := fake.teamIDReturnsOnCall[len(fake.teamIDArgsForCall)]
2464	fake.teamIDArgsForCall = append(fake.teamIDArgsForCall, struct {
2465	}{})
2466	fake.recordInvocation("TeamID", []interface{}{})
2467	fake.teamIDMutex.Unlock()
2468	if fake.TeamIDStub != nil {
2469		return fake.TeamIDStub()
2470	}
2471	if specificReturn {
2472		return ret.result1
2473	}
2474	fakeReturns := fake.teamIDReturns
2475	return fakeReturns.result1
2476}
2477
2478func (fake *FakeJob) TeamIDCallCount() int {
2479	fake.teamIDMutex.RLock()
2480	defer fake.teamIDMutex.RUnlock()
2481	return len(fake.teamIDArgsForCall)
2482}
2483
2484func (fake *FakeJob) TeamIDCalls(stub func() int) {
2485	fake.teamIDMutex.Lock()
2486	defer fake.teamIDMutex.Unlock()
2487	fake.TeamIDStub = stub
2488}
2489
2490func (fake *FakeJob) TeamIDReturns(result1 int) {
2491	fake.teamIDMutex.Lock()
2492	defer fake.teamIDMutex.Unlock()
2493	fake.TeamIDStub = nil
2494	fake.teamIDReturns = struct {
2495		result1 int
2496	}{result1}
2497}
2498
2499func (fake *FakeJob) TeamIDReturnsOnCall(i int, result1 int) {
2500	fake.teamIDMutex.Lock()
2501	defer fake.teamIDMutex.Unlock()
2502	fake.TeamIDStub = nil
2503	if fake.teamIDReturnsOnCall == nil {
2504		fake.teamIDReturnsOnCall = make(map[int]struct {
2505			result1 int
2506		})
2507	}
2508	fake.teamIDReturnsOnCall[i] = struct {
2509		result1 int
2510	}{result1}
2511}
2512
2513func (fake *FakeJob) TeamName() string {
2514	fake.teamNameMutex.Lock()
2515	ret, specificReturn := fake.teamNameReturnsOnCall[len(fake.teamNameArgsForCall)]
2516	fake.teamNameArgsForCall = append(fake.teamNameArgsForCall, struct {
2517	}{})
2518	fake.recordInvocation("TeamName", []interface{}{})
2519	fake.teamNameMutex.Unlock()
2520	if fake.TeamNameStub != nil {
2521		return fake.TeamNameStub()
2522	}
2523	if specificReturn {
2524		return ret.result1
2525	}
2526	fakeReturns := fake.teamNameReturns
2527	return fakeReturns.result1
2528}
2529
2530func (fake *FakeJob) TeamNameCallCount() int {
2531	fake.teamNameMutex.RLock()
2532	defer fake.teamNameMutex.RUnlock()
2533	return len(fake.teamNameArgsForCall)
2534}
2535
2536func (fake *FakeJob) TeamNameCalls(stub func() string) {
2537	fake.teamNameMutex.Lock()
2538	defer fake.teamNameMutex.Unlock()
2539	fake.TeamNameStub = stub
2540}
2541
2542func (fake *FakeJob) TeamNameReturns(result1 string) {
2543	fake.teamNameMutex.Lock()
2544	defer fake.teamNameMutex.Unlock()
2545	fake.TeamNameStub = nil
2546	fake.teamNameReturns = struct {
2547		result1 string
2548	}{result1}
2549}
2550
2551func (fake *FakeJob) TeamNameReturnsOnCall(i int, result1 string) {
2552	fake.teamNameMutex.Lock()
2553	defer fake.teamNameMutex.Unlock()
2554	fake.TeamNameStub = nil
2555	if fake.teamNameReturnsOnCall == nil {
2556		fake.teamNameReturnsOnCall = make(map[int]struct {
2557			result1 string
2558		})
2559	}
2560	fake.teamNameReturnsOnCall[i] = struct {
2561		result1 string
2562	}{result1}
2563}
2564
2565func (fake *FakeJob) Unpause() error {
2566	fake.unpauseMutex.Lock()
2567	ret, specificReturn := fake.unpauseReturnsOnCall[len(fake.unpauseArgsForCall)]
2568	fake.unpauseArgsForCall = append(fake.unpauseArgsForCall, struct {
2569	}{})
2570	fake.recordInvocation("Unpause", []interface{}{})
2571	fake.unpauseMutex.Unlock()
2572	if fake.UnpauseStub != nil {
2573		return fake.UnpauseStub()
2574	}
2575	if specificReturn {
2576		return ret.result1
2577	}
2578	fakeReturns := fake.unpauseReturns
2579	return fakeReturns.result1
2580}
2581
2582func (fake *FakeJob) UnpauseCallCount() int {
2583	fake.unpauseMutex.RLock()
2584	defer fake.unpauseMutex.RUnlock()
2585	return len(fake.unpauseArgsForCall)
2586}
2587
2588func (fake *FakeJob) UnpauseCalls(stub func() error) {
2589	fake.unpauseMutex.Lock()
2590	defer fake.unpauseMutex.Unlock()
2591	fake.UnpauseStub = stub
2592}
2593
2594func (fake *FakeJob) UnpauseReturns(result1 error) {
2595	fake.unpauseMutex.Lock()
2596	defer fake.unpauseMutex.Unlock()
2597	fake.UnpauseStub = nil
2598	fake.unpauseReturns = struct {
2599		result1 error
2600	}{result1}
2601}
2602
2603func (fake *FakeJob) UnpauseReturnsOnCall(i int, result1 error) {
2604	fake.unpauseMutex.Lock()
2605	defer fake.unpauseMutex.Unlock()
2606	fake.UnpauseStub = nil
2607	if fake.unpauseReturnsOnCall == nil {
2608		fake.unpauseReturnsOnCall = make(map[int]struct {
2609			result1 error
2610		})
2611	}
2612	fake.unpauseReturnsOnCall[i] = struct {
2613		result1 error
2614	}{result1}
2615}
2616
2617func (fake *FakeJob) UpdateFirstLoggedBuildID(arg1 int) error {
2618	fake.updateFirstLoggedBuildIDMutex.Lock()
2619	ret, specificReturn := fake.updateFirstLoggedBuildIDReturnsOnCall[len(fake.updateFirstLoggedBuildIDArgsForCall)]
2620	fake.updateFirstLoggedBuildIDArgsForCall = append(fake.updateFirstLoggedBuildIDArgsForCall, struct {
2621		arg1 int
2622	}{arg1})
2623	fake.recordInvocation("UpdateFirstLoggedBuildID", []interface{}{arg1})
2624	fake.updateFirstLoggedBuildIDMutex.Unlock()
2625	if fake.UpdateFirstLoggedBuildIDStub != nil {
2626		return fake.UpdateFirstLoggedBuildIDStub(arg1)
2627	}
2628	if specificReturn {
2629		return ret.result1
2630	}
2631	fakeReturns := fake.updateFirstLoggedBuildIDReturns
2632	return fakeReturns.result1
2633}
2634
2635func (fake *FakeJob) UpdateFirstLoggedBuildIDCallCount() int {
2636	fake.updateFirstLoggedBuildIDMutex.RLock()
2637	defer fake.updateFirstLoggedBuildIDMutex.RUnlock()
2638	return len(fake.updateFirstLoggedBuildIDArgsForCall)
2639}
2640
2641func (fake *FakeJob) UpdateFirstLoggedBuildIDCalls(stub func(int) error) {
2642	fake.updateFirstLoggedBuildIDMutex.Lock()
2643	defer fake.updateFirstLoggedBuildIDMutex.Unlock()
2644	fake.UpdateFirstLoggedBuildIDStub = stub
2645}
2646
2647func (fake *FakeJob) UpdateFirstLoggedBuildIDArgsForCall(i int) int {
2648	fake.updateFirstLoggedBuildIDMutex.RLock()
2649	defer fake.updateFirstLoggedBuildIDMutex.RUnlock()
2650	argsForCall := fake.updateFirstLoggedBuildIDArgsForCall[i]
2651	return argsForCall.arg1
2652}
2653
2654func (fake *FakeJob) UpdateFirstLoggedBuildIDReturns(result1 error) {
2655	fake.updateFirstLoggedBuildIDMutex.Lock()
2656	defer fake.updateFirstLoggedBuildIDMutex.Unlock()
2657	fake.UpdateFirstLoggedBuildIDStub = nil
2658	fake.updateFirstLoggedBuildIDReturns = struct {
2659		result1 error
2660	}{result1}
2661}
2662
2663func (fake *FakeJob) UpdateFirstLoggedBuildIDReturnsOnCall(i int, result1 error) {
2664	fake.updateFirstLoggedBuildIDMutex.Lock()
2665	defer fake.updateFirstLoggedBuildIDMutex.Unlock()
2666	fake.UpdateFirstLoggedBuildIDStub = nil
2667	if fake.updateFirstLoggedBuildIDReturnsOnCall == nil {
2668		fake.updateFirstLoggedBuildIDReturnsOnCall = make(map[int]struct {
2669			result1 error
2670		})
2671	}
2672	fake.updateFirstLoggedBuildIDReturnsOnCall[i] = struct {
2673		result1 error
2674	}{result1}
2675}
2676
2677func (fake *FakeJob) UpdateLastScheduled(arg1 time.Time) error {
2678	fake.updateLastScheduledMutex.Lock()
2679	ret, specificReturn := fake.updateLastScheduledReturnsOnCall[len(fake.updateLastScheduledArgsForCall)]
2680	fake.updateLastScheduledArgsForCall = append(fake.updateLastScheduledArgsForCall, struct {
2681		arg1 time.Time
2682	}{arg1})
2683	fake.recordInvocation("UpdateLastScheduled", []interface{}{arg1})
2684	fake.updateLastScheduledMutex.Unlock()
2685	if fake.UpdateLastScheduledStub != nil {
2686		return fake.UpdateLastScheduledStub(arg1)
2687	}
2688	if specificReturn {
2689		return ret.result1
2690	}
2691	fakeReturns := fake.updateLastScheduledReturns
2692	return fakeReturns.result1
2693}
2694
2695func (fake *FakeJob) UpdateLastScheduledCallCount() int {
2696	fake.updateLastScheduledMutex.RLock()
2697	defer fake.updateLastScheduledMutex.RUnlock()
2698	return len(fake.updateLastScheduledArgsForCall)
2699}
2700
2701func (fake *FakeJob) UpdateLastScheduledCalls(stub func(time.Time) error) {
2702	fake.updateLastScheduledMutex.Lock()
2703	defer fake.updateLastScheduledMutex.Unlock()
2704	fake.UpdateLastScheduledStub = stub
2705}
2706
2707func (fake *FakeJob) UpdateLastScheduledArgsForCall(i int) time.Time {
2708	fake.updateLastScheduledMutex.RLock()
2709	defer fake.updateLastScheduledMutex.RUnlock()
2710	argsForCall := fake.updateLastScheduledArgsForCall[i]
2711	return argsForCall.arg1
2712}
2713
2714func (fake *FakeJob) UpdateLastScheduledReturns(result1 error) {
2715	fake.updateLastScheduledMutex.Lock()
2716	defer fake.updateLastScheduledMutex.Unlock()
2717	fake.UpdateLastScheduledStub = nil
2718	fake.updateLastScheduledReturns = struct {
2719		result1 error
2720	}{result1}
2721}
2722
2723func (fake *FakeJob) UpdateLastScheduledReturnsOnCall(i int, result1 error) {
2724	fake.updateLastScheduledMutex.Lock()
2725	defer fake.updateLastScheduledMutex.Unlock()
2726	fake.UpdateLastScheduledStub = nil
2727	if fake.updateLastScheduledReturnsOnCall == nil {
2728		fake.updateLastScheduledReturnsOnCall = make(map[int]struct {
2729			result1 error
2730		})
2731	}
2732	fake.updateLastScheduledReturnsOnCall[i] = struct {
2733		result1 error
2734	}{result1}
2735}
2736
2737func (fake *FakeJob) Invocations() map[string][][]interface{} {
2738	fake.invocationsMutex.RLock()
2739	defer fake.invocationsMutex.RUnlock()
2740	fake.acquireSchedulingLockMutex.RLock()
2741	defer fake.acquireSchedulingLockMutex.RUnlock()
2742	fake.algorithmInputsMutex.RLock()
2743	defer fake.algorithmInputsMutex.RUnlock()
2744	fake.buildMutex.RLock()
2745	defer fake.buildMutex.RUnlock()
2746	fake.buildsMutex.RLock()
2747	defer fake.buildsMutex.RUnlock()
2748	fake.buildsWithTimeMutex.RLock()
2749	defer fake.buildsWithTimeMutex.RUnlock()
2750	fake.clearTaskCacheMutex.RLock()
2751	defer fake.clearTaskCacheMutex.RUnlock()
2752	fake.configMutex.RLock()
2753	defer fake.configMutex.RUnlock()
2754	fake.createBuildMutex.RLock()
2755	defer fake.createBuildMutex.RUnlock()
2756	fake.disableManualTriggerMutex.RLock()
2757	defer fake.disableManualTriggerMutex.RUnlock()
2758	fake.ensurePendingBuildExistsMutex.RLock()
2759	defer fake.ensurePendingBuildExistsMutex.RUnlock()
2760	fake.finishedAndNextBuildMutex.RLock()
2761	defer fake.finishedAndNextBuildMutex.RUnlock()
2762	fake.firstLoggedBuildIDMutex.RLock()
2763	defer fake.firstLoggedBuildIDMutex.RUnlock()
2764	fake.getFullNextBuildInputsMutex.RLock()
2765	defer fake.getFullNextBuildInputsMutex.RUnlock()
2766	fake.getNextBuildInputsMutex.RLock()
2767	defer fake.getNextBuildInputsMutex.RUnlock()
2768	fake.getPendingBuildsMutex.RLock()
2769	defer fake.getPendingBuildsMutex.RUnlock()
2770	fake.hasNewInputsMutex.RLock()
2771	defer fake.hasNewInputsMutex.RUnlock()
2772	fake.iDMutex.RLock()
2773	defer fake.iDMutex.RUnlock()
2774	fake.inputsMutex.RLock()
2775	defer fake.inputsMutex.RUnlock()
2776	fake.maxInFlightMutex.RLock()
2777	defer fake.maxInFlightMutex.RUnlock()
2778	fake.nameMutex.RLock()
2779	defer fake.nameMutex.RUnlock()
2780	fake.outputsMutex.RLock()
2781	defer fake.outputsMutex.RUnlock()
2782	fake.pauseMutex.RLock()
2783	defer fake.pauseMutex.RUnlock()
2784	fake.pausedMutex.RLock()
2785	defer fake.pausedMutex.RUnlock()
2786	fake.pipelineMutex.RLock()
2787	defer fake.pipelineMutex.RUnlock()
2788	fake.pipelineIDMutex.RLock()
2789	defer fake.pipelineIDMutex.RUnlock()
2790	fake.pipelineNameMutex.RLock()
2791	defer fake.pipelineNameMutex.RUnlock()
2792	fake.publicMutex.RLock()
2793	defer fake.publicMutex.RUnlock()
2794	fake.reloadMutex.RLock()
2795	defer fake.reloadMutex.RUnlock()
2796	fake.requestScheduleMutex.RLock()
2797	defer fake.requestScheduleMutex.RUnlock()
2798	fake.rerunBuildMutex.RLock()
2799	defer fake.rerunBuildMutex.RUnlock()
2800	fake.saveNextInputMappingMutex.RLock()
2801	defer fake.saveNextInputMappingMutex.RUnlock()
2802	fake.scheduleBuildMutex.RLock()
2803	defer fake.scheduleBuildMutex.RUnlock()
2804	fake.scheduleRequestedTimeMutex.RLock()
2805	defer fake.scheduleRequestedTimeMutex.RUnlock()
2806	fake.setHasNewInputsMutex.RLock()
2807	defer fake.setHasNewInputsMutex.RUnlock()
2808	fake.tagsMutex.RLock()
2809	defer fake.tagsMutex.RUnlock()
2810	fake.teamIDMutex.RLock()
2811	defer fake.teamIDMutex.RUnlock()
2812	fake.teamNameMutex.RLock()
2813	defer fake.teamNameMutex.RUnlock()
2814	fake.unpauseMutex.RLock()
2815	defer fake.unpauseMutex.RUnlock()
2816	fake.updateFirstLoggedBuildIDMutex.RLock()
2817	defer fake.updateFirstLoggedBuildIDMutex.RUnlock()
2818	fake.updateLastScheduledMutex.RLock()
2819	defer fake.updateLastScheduledMutex.RUnlock()
2820	copiedInvocations := map[string][][]interface{}{}
2821	for key, value := range fake.invocations {
2822		copiedInvocations[key] = value
2823	}
2824	return copiedInvocations
2825}
2826
2827func (fake *FakeJob) recordInvocation(key string, args []interface{}) {
2828	fake.invocationsMutex.Lock()
2829	defer fake.invocationsMutex.Unlock()
2830	if fake.invocations == nil {
2831		fake.invocations = map[string][][]interface{}{}
2832	}
2833	if fake.invocations[key] == nil {
2834		fake.invocations[key] = [][]interface{}{}
2835	}
2836	fake.invocations[key] = append(fake.invocations[key], args)
2837}
2838
2839var _ db.Job = new(FakeJob)
2840