concourse/atc/db/dbfakes/fake_job.go

// Code generated by counterfeiter. DO NOT EDIT.
package dbfakes

import (
	"context"
	"sync"
	"time"

	"code.cloudfoundry.org/lager"
	"github.com/concourse/concourse/atc"
	"github.com/concourse/concourse/atc/db"
	"github.com/concourse/concourse/atc/db/lock"
)

type FakeJob struct {
	AcquireSchedulingLockStub        func(lager.Logger) (lock.Lock, bool, error)
	acquireSchedulingLockMutex       sync.RWMutex
	acquireSchedulingLockArgsForCall []struct {
		arg1 lager.Logger
	}
	acquireSchedulingLockReturns struct {
		result1 lock.Lock
		result2 bool
		result3 error
	}
	acquireSchedulingLockReturnsOnCall map[int]struct {
		result1 lock.Lock
		result2 bool
		result3 error
	}
	AlgorithmInputsStub        func() (db.InputConfigs, error)
	algorithmInputsMutex       sync.RWMutex
	algorithmInputsArgsForCall []struct {
	}
	algorithmInputsReturns struct {
		result1 db.InputConfigs
		result2 error
	}
	algorithmInputsReturnsOnCall map[int]struct {
		result1 db.InputConfigs
		result2 error
	}
	BuildStub        func(string) (db.Build, bool, error)
	buildMutex       sync.RWMutex
	buildArgsForCall []struct {
		arg1 string
	}
	buildReturns struct {
		result1 db.Build
		result2 bool
		result3 error
	}
	buildReturnsOnCall map[int]struct {
		result1 db.Build
		result2 bool
		result3 error
	}
	BuildsStub        func(db.Page) ([]db.Build, db.Pagination, error)
	buildsMutex       sync.RWMutex
	buildsArgsForCall []struct {
		arg1 db.Page
	}
	buildsReturns struct {
		result1 []db.Build
		result2 db.Pagination
		result3 error
	}
	buildsReturnsOnCall map[int]struct {
		result1 []db.Build
		result2 db.Pagination
		result3 error
	}
	BuildsWithTimeStub        func(db.Page) ([]db.Build, db.Pagination, error)
	buildsWithTimeMutex       sync.RWMutex
	buildsWithTimeArgsForCall []struct {
		arg1 db.Page
	}
	buildsWithTimeReturns struct {
		result1 []db.Build
		result2 db.Pagination
		result3 error
	}
	buildsWithTimeReturnsOnCall map[int]struct {
		result1 []db.Build
		result2 db.Pagination
		result3 error
	}
	ClearTaskCacheStub        func(string, string) (int64, error)
	clearTaskCacheMutex       sync.RWMutex
	clearTaskCacheArgsForCall []struct {
		arg1 string
		arg2 string
	}
	clearTaskCacheReturns struct {
		result1 int64
		result2 error
	}
	clearTaskCacheReturnsOnCall map[int]struct {
		result1 int64
		result2 error
	}
	ConfigStub        func() (atc.JobConfig, error)
	configMutex       sync.RWMutex
	configArgsForCall []struct {
	}
	configReturns struct {
		result1 atc.JobConfig
		result2 error
	}
	configReturnsOnCall map[int]struct {
		result1 atc.JobConfig
		result2 error
	}
	CreateBuildStub        func(string) (db.Build, error)
	createBuildMutex       sync.RWMutex
	createBuildArgsForCall []struct {
		arg1 string
	}
	createBuildReturns struct {
		result1 db.Build
		result2 error
	}
	createBuildReturnsOnCall map[int]struct {
		result1 db.Build
		result2 error
	}
	DisableManualTriggerStub        func() bool
	disableManualTriggerMutex       sync.RWMutex
	disableManualTriggerArgsForCall []struct {
	}
	disableManualTriggerReturns struct {
		result1 bool
	}
	disableManualTriggerReturnsOnCall map[int]struct {
		result1 bool
	}
	EnsurePendingBuildExistsStub        func(context.Context) error
	ensurePendingBuildExistsMutex       sync.RWMutex
	ensurePendingBuildExistsArgsForCall []struct {
		arg1 context.Context
	}
	ensurePendingBuildExistsReturns struct {
		result1 error
	}
	ensurePendingBuildExistsReturnsOnCall map[int]struct {
		result1 error
	}
	FinishedAndNextBuildStub        func() (db.Build, db.Build, error)
	finishedAndNextBuildMutex       sync.RWMutex
	finishedAndNextBuildArgsForCall []struct {
	}
	finishedAndNextBuildReturns struct {
		result1 db.Build
		result2 db.Build
		result3 error
	}
	finishedAndNextBuildReturnsOnCall map[int]struct {
		result1 db.Build
		result2 db.Build
		result3 error
	}
	FirstLoggedBuildIDStub        func() int
	firstLoggedBuildIDMutex       sync.RWMutex
	firstLoggedBuildIDArgsForCall []struct {
	}
	firstLoggedBuildIDReturns struct {
		result1 int
	}
	firstLoggedBuildIDReturnsOnCall map[int]struct {
		result1 int
	}
	GetFullNextBuildInputsStub        func() ([]db.BuildInput, bool, error)
	getFullNextBuildInputsMutex       sync.RWMutex
	getFullNextBuildInputsArgsForCall []struct {
	}
	getFullNextBuildInputsReturns struct {
		result1 []db.BuildInput
		result2 bool
		result3 error
	}
	getFullNextBuildInputsReturnsOnCall map[int]struct {
		result1 []db.BuildInput
		result2 bool
		result3 error
	}
	GetNextBuildInputsStub        func() ([]db.BuildInput, error)
	getNextBuildInputsMutex       sync.RWMutex
	getNextBuildInputsArgsForCall []struct {
	}
	getNextBuildInputsReturns struct {
		result1 []db.BuildInput
		result2 error
	}
	getNextBuildInputsReturnsOnCall map[int]struct {
		result1 []db.BuildInput
		result2 error
	}
	GetPendingBuildsStub        func() ([]db.Build, error)
	getPendingBuildsMutex       sync.RWMutex
	getPendingBuildsArgsForCall []struct {
	}
	getPendingBuildsReturns struct {
		result1 []db.Build
		result2 error
	}
	getPendingBuildsReturnsOnCall map[int]struct {
		result1 []db.Build
		result2 error
	}
	HasNewInputsStub        func() bool
	hasNewInputsMutex       sync.RWMutex
	hasNewInputsArgsForCall []struct {
	}
	hasNewInputsReturns struct {
		result1 bool
	}
	hasNewInputsReturnsOnCall map[int]struct {
		result1 bool
	}
	IDStub        func() int
	iDMutex       sync.RWMutex
	iDArgsForCall []struct {
	}
	iDReturns struct {
		result1 int
	}
	iDReturnsOnCall map[int]struct {
		result1 int
	}
	InputsStub        func() ([]atc.JobInput, error)
	inputsMutex       sync.RWMutex
	inputsArgsForCall []struct {
	}
	inputsReturns struct {
		result1 []atc.JobInput
		result2 error
	}
	inputsReturnsOnCall map[int]struct {
		result1 []atc.JobInput
		result2 error
	}
	MaxInFlightStub        func() int
	maxInFlightMutex       sync.RWMutex
	maxInFlightArgsForCall []struct {
	}
	maxInFlightReturns struct {
		result1 int
	}
	maxInFlightReturnsOnCall map[int]struct {
		result1 int
	}
	NameStub        func() string
	nameMutex       sync.RWMutex
	nameArgsForCall []struct {
	}
	nameReturns struct {
		result1 string
	}
	nameReturnsOnCall map[int]struct {
		result1 string
	}
	OutputsStub        func() ([]atc.JobOutput, error)
	outputsMutex       sync.RWMutex
	outputsArgsForCall []struct {
	}
	outputsReturns struct {
		result1 []atc.JobOutput
		result2 error
	}
	outputsReturnsOnCall map[int]struct {
		result1 []atc.JobOutput
		result2 error
	}
	PauseStub        func() error
	pauseMutex       sync.RWMutex
	pauseArgsForCall []struct {
	}
	pauseReturns struct {
		result1 error
	}
	pauseReturnsOnCall map[int]struct {
		result1 error
	}
	PausedStub        func() bool
	pausedMutex       sync.RWMutex
	pausedArgsForCall []struct {
	}
	pausedReturns struct {
		result1 bool
	}
	pausedReturnsOnCall map[int]struct {
		result1 bool
	}
	PipelineStub        func() (db.Pipeline, bool, error)
	pipelineMutex       sync.RWMutex
	pipelineArgsForCall []struct {
	}
	pipelineReturns struct {
		result1 db.Pipeline
		result2 bool
		result3 error
	}
	pipelineReturnsOnCall map[int]struct {
		result1 db.Pipeline
		result2 bool
		result3 error
	}
	PipelineIDStub        func() int
	pipelineIDMutex       sync.RWMutex
	pipelineIDArgsForCall []struct {
	}
	pipelineIDReturns struct {
		result1 int
	}
	pipelineIDReturnsOnCall map[int]struct {
		result1 int
	}
	PipelineInstanceVarsStub        func() atc.InstanceVars
	pipelineInstanceVarsMutex       sync.RWMutex
	pipelineInstanceVarsArgsForCall []struct {
	}
	pipelineInstanceVarsReturns struct {
		result1 atc.InstanceVars
	}
	pipelineInstanceVarsReturnsOnCall map[int]struct {
		result1 atc.InstanceVars
	}
	PipelineNameStub        func() string
	pipelineNameMutex       sync.RWMutex
	pipelineNameArgsForCall []struct {
	}
	pipelineNameReturns struct {
		result1 string
	}
	pipelineNameReturnsOnCall map[int]struct {
		result1 string
	}
	PipelineRefStub        func() atc.PipelineRef
	pipelineRefMutex       sync.RWMutex
	pipelineRefArgsForCall []struct {
	}
	pipelineRefReturns struct {
		result1 atc.PipelineRef
	}
	pipelineRefReturnsOnCall map[int]struct {
		result1 atc.PipelineRef
	}
	PublicStub        func() bool
	publicMutex       sync.RWMutex
	publicArgsForCall []struct {
	}
	publicReturns struct {
		result1 bool
	}
	publicReturnsOnCall map[int]struct {
		result1 bool
	}
	ReloadStub        func() (bool, error)
	reloadMutex       sync.RWMutex
	reloadArgsForCall []struct {
	}
	reloadReturns struct {
		result1 bool
		result2 error
	}
	reloadReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	RequestScheduleStub        func() error
	requestScheduleMutex       sync.RWMutex
	requestScheduleArgsForCall []struct {
	}
	requestScheduleReturns struct {
		result1 error
	}
	requestScheduleReturnsOnCall map[int]struct {
		result1 error
	}
	RerunBuildStub        func(db.Build, string) (db.Build, error)
	rerunBuildMutex       sync.RWMutex
	rerunBuildArgsForCall []struct {
		arg1 db.Build
		arg2 string
	}
	rerunBuildReturns struct {
		result1 db.Build
		result2 error
	}
	rerunBuildReturnsOnCall map[int]struct {
		result1 db.Build
		result2 error
	}
	SaveNextInputMappingStub        func(db.InputMapping, bool) error
	saveNextInputMappingMutex       sync.RWMutex
	saveNextInputMappingArgsForCall []struct {
		arg1 db.InputMapping
		arg2 bool
	}
	saveNextInputMappingReturns struct {
		result1 error
	}
	saveNextInputMappingReturnsOnCall map[int]struct {
		result1 error
	}
	ScheduleBuildStub        func(db.Build) (bool, error)
	scheduleBuildMutex       sync.RWMutex
	scheduleBuildArgsForCall []struct {
		arg1 db.Build
	}
	scheduleBuildReturns struct {
		result1 bool
		result2 error
	}
	scheduleBuildReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	ScheduleRequestedTimeStub        func() time.Time
	scheduleRequestedTimeMutex       sync.RWMutex
	scheduleRequestedTimeArgsForCall []struct {
	}
	scheduleRequestedTimeReturns struct {
		result1 time.Time
	}
	scheduleRequestedTimeReturnsOnCall map[int]struct {
		result1 time.Time
	}
	SetHasNewInputsStub        func(bool) error
	setHasNewInputsMutex       sync.RWMutex
	setHasNewInputsArgsForCall []struct {
		arg1 bool
	}
	setHasNewInputsReturns struct {
		result1 error
	}
	setHasNewInputsReturnsOnCall map[int]struct {
		result1 error
	}
	TagsStub        func() []string
	tagsMutex       sync.RWMutex
	tagsArgsForCall []struct {
	}
	tagsReturns struct {
		result1 []string
	}
	tagsReturnsOnCall map[int]struct {
		result1 []string
	}
	TeamIDStub        func() int
	teamIDMutex       sync.RWMutex
	teamIDArgsForCall []struct {
	}
	teamIDReturns struct {
		result1 int
	}
	teamIDReturnsOnCall map[int]struct {
		result1 int
	}
	TeamNameStub        func() string
	teamNameMutex       sync.RWMutex
	teamNameArgsForCall []struct {
	}
	teamNameReturns struct {
		result1 string
	}
	teamNameReturnsOnCall map[int]struct {
		result1 string
	}
	UnpauseStub        func() error
	unpauseMutex       sync.RWMutex
	unpauseArgsForCall []struct {
	}
	unpauseReturns struct {
		result1 error
	}
	unpauseReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateFirstLoggedBuildIDStub        func(int) error
	updateFirstLoggedBuildIDMutex       sync.RWMutex
	updateFirstLoggedBuildIDArgsForCall []struct {
		arg1 int
	}
	updateFirstLoggedBuildIDReturns struct {
		result1 error
	}
	updateFirstLoggedBuildIDReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateLastScheduledStub        func(time.Time) error
	updateLastScheduledMutex       sync.RWMutex
	updateLastScheduledArgsForCall []struct {
		arg1 time.Time
	}
	updateLastScheduledReturns struct {
		result1 error
	}
	updateLastScheduledReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeJob) AcquireSchedulingLock(arg1 lager.Logger) (lock.Lock, bool, error) {
	fake.acquireSchedulingLockMutex.Lock()
	ret, specificReturn := fake.acquireSchedulingLockReturnsOnCall[len(fake.acquireSchedulingLockArgsForCall)]
	fake.acquireSchedulingLockArgsForCall = append(fake.acquireSchedulingLockArgsForCall, struct {
		arg1 lager.Logger
	}{arg1})
	stub := fake.AcquireSchedulingLockStub
	fakeReturns := fake.acquireSchedulingLockReturns
	fake.recordInvocation("AcquireSchedulingLock", []interface{}{arg1})
	fake.acquireSchedulingLockMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeJob) AcquireSchedulingLockCallCount() int {
	fake.acquireSchedulingLockMutex.RLock()
	defer fake.acquireSchedulingLockMutex.RUnlock()
	return len(fake.acquireSchedulingLockArgsForCall)
}

func (fake *FakeJob) AcquireSchedulingLockCalls(stub func(lager.Logger) (lock.Lock, bool, error)) {
	fake.acquireSchedulingLockMutex.Lock()
	defer fake.acquireSchedulingLockMutex.Unlock()
	fake.AcquireSchedulingLockStub = stub
}

func (fake *FakeJob) AcquireSchedulingLockArgsForCall(i int) lager.Logger {
	fake.acquireSchedulingLockMutex.RLock()
	defer fake.acquireSchedulingLockMutex.RUnlock()
	argsForCall := fake.acquireSchedulingLockArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) AcquireSchedulingLockReturns(result1 lock.Lock, result2 bool, result3 error) {
	fake.acquireSchedulingLockMutex.Lock()
	defer fake.acquireSchedulingLockMutex.Unlock()
	fake.AcquireSchedulingLockStub = nil
	fake.acquireSchedulingLockReturns = struct {
		result1 lock.Lock
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) AcquireSchedulingLockReturnsOnCall(i int, result1 lock.Lock, result2 bool, result3 error) {
	fake.acquireSchedulingLockMutex.Lock()
	defer fake.acquireSchedulingLockMutex.Unlock()
	fake.AcquireSchedulingLockStub = nil
	if fake.acquireSchedulingLockReturnsOnCall == nil {
		fake.acquireSchedulingLockReturnsOnCall = make(map[int]struct {
			result1 lock.Lock
			result2 bool
			result3 error
		})
	}
	fake.acquireSchedulingLockReturnsOnCall[i] = struct {
		result1 lock.Lock
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) AlgorithmInputs() (db.InputConfigs, error) {
	fake.algorithmInputsMutex.Lock()
	ret, specificReturn := fake.algorithmInputsReturnsOnCall[len(fake.algorithmInputsArgsForCall)]
	fake.algorithmInputsArgsForCall = append(fake.algorithmInputsArgsForCall, struct {
	}{})
	stub := fake.AlgorithmInputsStub
	fakeReturns := fake.algorithmInputsReturns
	fake.recordInvocation("AlgorithmInputs", []interface{}{})
	fake.algorithmInputsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) AlgorithmInputsCallCount() int {
	fake.algorithmInputsMutex.RLock()
	defer fake.algorithmInputsMutex.RUnlock()
	return len(fake.algorithmInputsArgsForCall)
}

func (fake *FakeJob) AlgorithmInputsCalls(stub func() (db.InputConfigs, error)) {
	fake.algorithmInputsMutex.Lock()
	defer fake.algorithmInputsMutex.Unlock()
	fake.AlgorithmInputsStub = stub
}

func (fake *FakeJob) AlgorithmInputsReturns(result1 db.InputConfigs, result2 error) {
	fake.algorithmInputsMutex.Lock()
	defer fake.algorithmInputsMutex.Unlock()
	fake.AlgorithmInputsStub = nil
	fake.algorithmInputsReturns = struct {
		result1 db.InputConfigs
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) AlgorithmInputsReturnsOnCall(i int, result1 db.InputConfigs, result2 error) {
	fake.algorithmInputsMutex.Lock()
	defer fake.algorithmInputsMutex.Unlock()
	fake.AlgorithmInputsStub = nil
	if fake.algorithmInputsReturnsOnCall == nil {
		fake.algorithmInputsReturnsOnCall = make(map[int]struct {
			result1 db.InputConfigs
			result2 error
		})
	}
	fake.algorithmInputsReturnsOnCall[i] = struct {
		result1 db.InputConfigs
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) Build(arg1 string) (db.Build, bool, error) {
	fake.buildMutex.Lock()
	ret, specificReturn := fake.buildReturnsOnCall[len(fake.buildArgsForCall)]
	fake.buildArgsForCall = append(fake.buildArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.BuildStub
	fakeReturns := fake.buildReturns
	fake.recordInvocation("Build", []interface{}{arg1})
	fake.buildMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeJob) BuildCallCount() int {
	fake.buildMutex.RLock()
	defer fake.buildMutex.RUnlock()
	return len(fake.buildArgsForCall)
}

func (fake *FakeJob) BuildCalls(stub func(string) (db.Build, bool, error)) {
	fake.buildMutex.Lock()
	defer fake.buildMutex.Unlock()
	fake.BuildStub = stub
}

func (fake *FakeJob) BuildArgsForCall(i int) string {
	fake.buildMutex.RLock()
	defer fake.buildMutex.RUnlock()
	argsForCall := fake.buildArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) BuildReturns(result1 db.Build, result2 bool, result3 error) {
	fake.buildMutex.Lock()
	defer fake.buildMutex.Unlock()
	fake.BuildStub = nil
	fake.buildReturns = struct {
		result1 db.Build
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) BuildReturnsOnCall(i int, result1 db.Build, result2 bool, result3 error) {
	fake.buildMutex.Lock()
	defer fake.buildMutex.Unlock()
	fake.BuildStub = nil
	if fake.buildReturnsOnCall == nil {
		fake.buildReturnsOnCall = make(map[int]struct {
			result1 db.Build
			result2 bool
			result3 error
		})
	}
	fake.buildReturnsOnCall[i] = struct {
		result1 db.Build
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) Builds(arg1 db.Page) ([]db.Build, db.Pagination, error) {
	fake.buildsMutex.Lock()
	ret, specificReturn := fake.buildsReturnsOnCall[len(fake.buildsArgsForCall)]
	fake.buildsArgsForCall = append(fake.buildsArgsForCall, struct {
		arg1 db.Page
	}{arg1})
	stub := fake.BuildsStub
	fakeReturns := fake.buildsReturns
	fake.recordInvocation("Builds", []interface{}{arg1})
	fake.buildsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeJob) BuildsCallCount() int {
	fake.buildsMutex.RLock()
	defer fake.buildsMutex.RUnlock()
	return len(fake.buildsArgsForCall)
}

func (fake *FakeJob) BuildsCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) {
	fake.buildsMutex.Lock()
	defer fake.buildsMutex.Unlock()
	fake.BuildsStub = stub
}

func (fake *FakeJob) BuildsArgsForCall(i int) db.Page {
	fake.buildsMutex.RLock()
	defer fake.buildsMutex.RUnlock()
	argsForCall := fake.buildsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) BuildsReturns(result1 []db.Build, result2 db.Pagination, result3 error) {
	fake.buildsMutex.Lock()
	defer fake.buildsMutex.Unlock()
	fake.BuildsStub = nil
	fake.buildsReturns = struct {
		result1 []db.Build
		result2 db.Pagination
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) BuildsReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) {
	fake.buildsMutex.Lock()
	defer fake.buildsMutex.Unlock()
	fake.BuildsStub = nil
	if fake.buildsReturnsOnCall == nil {
		fake.buildsReturnsOnCall = make(map[int]struct {
			result1 []db.Build
			result2 db.Pagination
			result3 error
		})
	}
	fake.buildsReturnsOnCall[i] = struct {
		result1 []db.Build
		result2 db.Pagination
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) BuildsWithTime(arg1 db.Page) ([]db.Build, db.Pagination, error) {
	fake.buildsWithTimeMutex.Lock()
	ret, specificReturn := fake.buildsWithTimeReturnsOnCall[len(fake.buildsWithTimeArgsForCall)]
	fake.buildsWithTimeArgsForCall = append(fake.buildsWithTimeArgsForCall, struct {
		arg1 db.Page
	}{arg1})
	stub := fake.BuildsWithTimeStub
	fakeReturns := fake.buildsWithTimeReturns
	fake.recordInvocation("BuildsWithTime", []interface{}{arg1})
	fake.buildsWithTimeMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeJob) BuildsWithTimeCallCount() int {
	fake.buildsWithTimeMutex.RLock()
	defer fake.buildsWithTimeMutex.RUnlock()
	return len(fake.buildsWithTimeArgsForCall)
}

func (fake *FakeJob) BuildsWithTimeCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) {
	fake.buildsWithTimeMutex.Lock()
	defer fake.buildsWithTimeMutex.Unlock()
	fake.BuildsWithTimeStub = stub
}

func (fake *FakeJob) BuildsWithTimeArgsForCall(i int) db.Page {
	fake.buildsWithTimeMutex.RLock()
	defer fake.buildsWithTimeMutex.RUnlock()
	argsForCall := fake.buildsWithTimeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) BuildsWithTimeReturns(result1 []db.Build, result2 db.Pagination, result3 error) {
	fake.buildsWithTimeMutex.Lock()
	defer fake.buildsWithTimeMutex.Unlock()
	fake.BuildsWithTimeStub = nil
	fake.buildsWithTimeReturns = struct {
		result1 []db.Build
		result2 db.Pagination
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) BuildsWithTimeReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) {
	fake.buildsWithTimeMutex.Lock()
	defer fake.buildsWithTimeMutex.Unlock()
	fake.BuildsWithTimeStub = nil
	if fake.buildsWithTimeReturnsOnCall == nil {
		fake.buildsWithTimeReturnsOnCall = make(map[int]struct {
			result1 []db.Build
			result2 db.Pagination
			result3 error
		})
	}
	fake.buildsWithTimeReturnsOnCall[i] = struct {
		result1 []db.Build
		result2 db.Pagination
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) ClearTaskCache(arg1 string, arg2 string) (int64, error) {
	fake.clearTaskCacheMutex.Lock()
	ret, specificReturn := fake.clearTaskCacheReturnsOnCall[len(fake.clearTaskCacheArgsForCall)]
	fake.clearTaskCacheArgsForCall = append(fake.clearTaskCacheArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.ClearTaskCacheStub
	fakeReturns := fake.clearTaskCacheReturns
	fake.recordInvocation("ClearTaskCache", []interface{}{arg1, arg2})
	fake.clearTaskCacheMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) ClearTaskCacheCallCount() int {
	fake.clearTaskCacheMutex.RLock()
	defer fake.clearTaskCacheMutex.RUnlock()
	return len(fake.clearTaskCacheArgsForCall)
}

func (fake *FakeJob) ClearTaskCacheCalls(stub func(string, string) (int64, error)) {
	fake.clearTaskCacheMutex.Lock()
	defer fake.clearTaskCacheMutex.Unlock()
	fake.ClearTaskCacheStub = stub
}

func (fake *FakeJob) ClearTaskCacheArgsForCall(i int) (string, string) {
	fake.clearTaskCacheMutex.RLock()
	defer fake.clearTaskCacheMutex.RUnlock()
	argsForCall := fake.clearTaskCacheArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeJob) ClearTaskCacheReturns(result1 int64, result2 error) {
	fake.clearTaskCacheMutex.Lock()
	defer fake.clearTaskCacheMutex.Unlock()
	fake.ClearTaskCacheStub = nil
	fake.clearTaskCacheReturns = struct {
		result1 int64
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) ClearTaskCacheReturnsOnCall(i int, result1 int64, result2 error) {
	fake.clearTaskCacheMutex.Lock()
	defer fake.clearTaskCacheMutex.Unlock()
	fake.ClearTaskCacheStub = nil
	if fake.clearTaskCacheReturnsOnCall == nil {
		fake.clearTaskCacheReturnsOnCall = make(map[int]struct {
			result1 int64
			result2 error
		})
	}
	fake.clearTaskCacheReturnsOnCall[i] = struct {
		result1 int64
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) Config() (atc.JobConfig, error) {
	fake.configMutex.Lock()
	ret, specificReturn := fake.configReturnsOnCall[len(fake.configArgsForCall)]
	fake.configArgsForCall = append(fake.configArgsForCall, struct {
	}{})
	stub := fake.ConfigStub
	fakeReturns := fake.configReturns
	fake.recordInvocation("Config", []interface{}{})
	fake.configMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) ConfigCallCount() int {
	fake.configMutex.RLock()
	defer fake.configMutex.RUnlock()
	return len(fake.configArgsForCall)
}

func (fake *FakeJob) ConfigCalls(stub func() (atc.JobConfig, error)) {
	fake.configMutex.Lock()
	defer fake.configMutex.Unlock()
	fake.ConfigStub = stub
}

func (fake *FakeJob) ConfigReturns(result1 atc.JobConfig, result2 error) {
	fake.configMutex.Lock()
	defer fake.configMutex.Unlock()
	fake.ConfigStub = nil
	fake.configReturns = struct {
		result1 atc.JobConfig
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) ConfigReturnsOnCall(i int, result1 atc.JobConfig, result2 error) {
	fake.configMutex.Lock()
	defer fake.configMutex.Unlock()
	fake.ConfigStub = nil
	if fake.configReturnsOnCall == nil {
		fake.configReturnsOnCall = make(map[int]struct {
			result1 atc.JobConfig
			result2 error
		})
	}
	fake.configReturnsOnCall[i] = struct {
		result1 atc.JobConfig
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) CreateBuild(arg1 string) (db.Build, error) {
	fake.createBuildMutex.Lock()
	ret, specificReturn := fake.createBuildReturnsOnCall[len(fake.createBuildArgsForCall)]
	fake.createBuildArgsForCall = append(fake.createBuildArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.CreateBuildStub
	fakeReturns := fake.createBuildReturns
	fake.recordInvocation("CreateBuild", []interface{}{arg1})
	fake.createBuildMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) CreateBuildCallCount() int {
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	return len(fake.createBuildArgsForCall)
}

func (fake *FakeJob) CreateBuildCalls(stub func(string) (db.Build, error)) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = stub
}

func (fake *FakeJob) CreateBuildArgsForCall(i int) string {
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	argsForCall := fake.createBuildArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) CreateBuildReturns(result1 db.Build, result2 error) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = nil
	fake.createBuildReturns = struct {
		result1 db.Build
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) CreateBuildReturnsOnCall(i int, result1 db.Build, result2 error) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = nil
	if fake.createBuildReturnsOnCall == nil {
		fake.createBuildReturnsOnCall = make(map[int]struct {
			result1 db.Build
			result2 error
		})
	}
	fake.createBuildReturnsOnCall[i] = struct {
		result1 db.Build
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) DisableManualTrigger() bool {
	fake.disableManualTriggerMutex.Lock()
	ret, specificReturn := fake.disableManualTriggerReturnsOnCall[len(fake.disableManualTriggerArgsForCall)]
	fake.disableManualTriggerArgsForCall = append(fake.disableManualTriggerArgsForCall, struct {
	}{})
	stub := fake.DisableManualTriggerStub
	fakeReturns := fake.disableManualTriggerReturns
	fake.recordInvocation("DisableManualTrigger", []interface{}{})
	fake.disableManualTriggerMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) DisableManualTriggerCallCount() int {
	fake.disableManualTriggerMutex.RLock()
	defer fake.disableManualTriggerMutex.RUnlock()
	return len(fake.disableManualTriggerArgsForCall)
}

func (fake *FakeJob) DisableManualTriggerCalls(stub func() bool) {
	fake.disableManualTriggerMutex.Lock()
	defer fake.disableManualTriggerMutex.Unlock()
	fake.DisableManualTriggerStub = stub
}

func (fake *FakeJob) DisableManualTriggerReturns(result1 bool) {
	fake.disableManualTriggerMutex.Lock()
	defer fake.disableManualTriggerMutex.Unlock()
	fake.DisableManualTriggerStub = nil
	fake.disableManualTriggerReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeJob) DisableManualTriggerReturnsOnCall(i int, result1 bool) {
	fake.disableManualTriggerMutex.Lock()
	defer fake.disableManualTriggerMutex.Unlock()
	fake.DisableManualTriggerStub = nil
	if fake.disableManualTriggerReturnsOnCall == nil {
		fake.disableManualTriggerReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.disableManualTriggerReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeJob) EnsurePendingBuildExists(arg1 context.Context) error {
	fake.ensurePendingBuildExistsMutex.Lock()
	ret, specificReturn := fake.ensurePendingBuildExistsReturnsOnCall[len(fake.ensurePendingBuildExistsArgsForCall)]
	fake.ensurePendingBuildExistsArgsForCall = append(fake.ensurePendingBuildExistsArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	stub := fake.EnsurePendingBuildExistsStub
	fakeReturns := fake.ensurePendingBuildExistsReturns
	fake.recordInvocation("EnsurePendingBuildExists", []interface{}{arg1})
	fake.ensurePendingBuildExistsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) EnsurePendingBuildExistsCallCount() int {
	fake.ensurePendingBuildExistsMutex.RLock()
	defer fake.ensurePendingBuildExistsMutex.RUnlock()
	return len(fake.ensurePendingBuildExistsArgsForCall)
}

func (fake *FakeJob) EnsurePendingBuildExistsCalls(stub func(context.Context) error) {
	fake.ensurePendingBuildExistsMutex.Lock()
	defer fake.ensurePendingBuildExistsMutex.Unlock()
	fake.EnsurePendingBuildExistsStub = stub
}

func (fake *FakeJob) EnsurePendingBuildExistsArgsForCall(i int) context.Context {
	fake.ensurePendingBuildExistsMutex.RLock()
	defer fake.ensurePendingBuildExistsMutex.RUnlock()
	argsForCall := fake.ensurePendingBuildExistsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) EnsurePendingBuildExistsReturns(result1 error) {
	fake.ensurePendingBuildExistsMutex.Lock()
	defer fake.ensurePendingBuildExistsMutex.Unlock()
	fake.EnsurePendingBuildExistsStub = nil
	fake.ensurePendingBuildExistsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) EnsurePendingBuildExistsReturnsOnCall(i int, result1 error) {
	fake.ensurePendingBuildExistsMutex.Lock()
	defer fake.ensurePendingBuildExistsMutex.Unlock()
	fake.EnsurePendingBuildExistsStub = nil
	if fake.ensurePendingBuildExistsReturnsOnCall == nil {
		fake.ensurePendingBuildExistsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.ensurePendingBuildExistsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) FinishedAndNextBuild() (db.Build, db.Build, error) {
	fake.finishedAndNextBuildMutex.Lock()
	ret, specificReturn := fake.finishedAndNextBuildReturnsOnCall[len(fake.finishedAndNextBuildArgsForCall)]
	fake.finishedAndNextBuildArgsForCall = append(fake.finishedAndNextBuildArgsForCall, struct {
	}{})
	stub := fake.FinishedAndNextBuildStub
	fakeReturns := fake.finishedAndNextBuildReturns
	fake.recordInvocation("FinishedAndNextBuild", []interface{}{})
	fake.finishedAndNextBuildMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeJob) FinishedAndNextBuildCallCount() int {
	fake.finishedAndNextBuildMutex.RLock()
	defer fake.finishedAndNextBuildMutex.RUnlock()
	return len(fake.finishedAndNextBuildArgsForCall)
}

func (fake *FakeJob) FinishedAndNextBuildCalls(stub func() (db.Build, db.Build, error)) {
	fake.finishedAndNextBuildMutex.Lock()
	defer fake.finishedAndNextBuildMutex.Unlock()
	fake.FinishedAndNextBuildStub = stub
}

func (fake *FakeJob) FinishedAndNextBuildReturns(result1 db.Build, result2 db.Build, result3 error) {
	fake.finishedAndNextBuildMutex.Lock()
	defer fake.finishedAndNextBuildMutex.Unlock()
	fake.FinishedAndNextBuildStub = nil
	fake.finishedAndNextBuildReturns = struct {
		result1 db.Build
		result2 db.Build
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) FinishedAndNextBuildReturnsOnCall(i int, result1 db.Build, result2 db.Build, result3 error) {
	fake.finishedAndNextBuildMutex.Lock()
	defer fake.finishedAndNextBuildMutex.Unlock()
	fake.FinishedAndNextBuildStub = nil
	if fake.finishedAndNextBuildReturnsOnCall == nil {
		fake.finishedAndNextBuildReturnsOnCall = make(map[int]struct {
			result1 db.Build
			result2 db.Build
			result3 error
		})
	}
	fake.finishedAndNextBuildReturnsOnCall[i] = struct {
		result1 db.Build
		result2 db.Build
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) FirstLoggedBuildID() int {
	fake.firstLoggedBuildIDMutex.Lock()
	ret, specificReturn := fake.firstLoggedBuildIDReturnsOnCall[len(fake.firstLoggedBuildIDArgsForCall)]
	fake.firstLoggedBuildIDArgsForCall = append(fake.firstLoggedBuildIDArgsForCall, struct {
	}{})
	stub := fake.FirstLoggedBuildIDStub
	fakeReturns := fake.firstLoggedBuildIDReturns
	fake.recordInvocation("FirstLoggedBuildID", []interface{}{})
	fake.firstLoggedBuildIDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) FirstLoggedBuildIDCallCount() int {
	fake.firstLoggedBuildIDMutex.RLock()
	defer fake.firstLoggedBuildIDMutex.RUnlock()
	return len(fake.firstLoggedBuildIDArgsForCall)
}

func (fake *FakeJob) FirstLoggedBuildIDCalls(stub func() int) {
	fake.firstLoggedBuildIDMutex.Lock()
	defer fake.firstLoggedBuildIDMutex.Unlock()
	fake.FirstLoggedBuildIDStub = stub
}

func (fake *FakeJob) FirstLoggedBuildIDReturns(result1 int) {
	fake.firstLoggedBuildIDMutex.Lock()
	defer fake.firstLoggedBuildIDMutex.Unlock()
	fake.FirstLoggedBuildIDStub = nil
	fake.firstLoggedBuildIDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) FirstLoggedBuildIDReturnsOnCall(i int, result1 int) {
	fake.firstLoggedBuildIDMutex.Lock()
	defer fake.firstLoggedBuildIDMutex.Unlock()
	fake.FirstLoggedBuildIDStub = nil
	if fake.firstLoggedBuildIDReturnsOnCall == nil {
		fake.firstLoggedBuildIDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.firstLoggedBuildIDReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) GetFullNextBuildInputs() ([]db.BuildInput, bool, error) {
	fake.getFullNextBuildInputsMutex.Lock()
	ret, specificReturn := fake.getFullNextBuildInputsReturnsOnCall[len(fake.getFullNextBuildInputsArgsForCall)]
	fake.getFullNextBuildInputsArgsForCall = append(fake.getFullNextBuildInputsArgsForCall, struct {
	}{})
	stub := fake.GetFullNextBuildInputsStub
	fakeReturns := fake.getFullNextBuildInputsReturns
	fake.recordInvocation("GetFullNextBuildInputs", []interface{}{})
	fake.getFullNextBuildInputsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeJob) GetFullNextBuildInputsCallCount() int {
	fake.getFullNextBuildInputsMutex.RLock()
	defer fake.getFullNextBuildInputsMutex.RUnlock()
	return len(fake.getFullNextBuildInputsArgsForCall)
}

func (fake *FakeJob) GetFullNextBuildInputsCalls(stub func() ([]db.BuildInput, bool, error)) {
	fake.getFullNextBuildInputsMutex.Lock()
	defer fake.getFullNextBuildInputsMutex.Unlock()
	fake.GetFullNextBuildInputsStub = stub
}

func (fake *FakeJob) GetFullNextBuildInputsReturns(result1 []db.BuildInput, result2 bool, result3 error) {
	fake.getFullNextBuildInputsMutex.Lock()
	defer fake.getFullNextBuildInputsMutex.Unlock()
	fake.GetFullNextBuildInputsStub = nil
	fake.getFullNextBuildInputsReturns = struct {
		result1 []db.BuildInput
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) GetFullNextBuildInputsReturnsOnCall(i int, result1 []db.BuildInput, result2 bool, result3 error) {
	fake.getFullNextBuildInputsMutex.Lock()
	defer fake.getFullNextBuildInputsMutex.Unlock()
	fake.GetFullNextBuildInputsStub = nil
	if fake.getFullNextBuildInputsReturnsOnCall == nil {
		fake.getFullNextBuildInputsReturnsOnCall = make(map[int]struct {
			result1 []db.BuildInput
			result2 bool
			result3 error
		})
	}
	fake.getFullNextBuildInputsReturnsOnCall[i] = struct {
		result1 []db.BuildInput
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) GetNextBuildInputs() ([]db.BuildInput, error) {
	fake.getNextBuildInputsMutex.Lock()
	ret, specificReturn := fake.getNextBuildInputsReturnsOnCall[len(fake.getNextBuildInputsArgsForCall)]
	fake.getNextBuildInputsArgsForCall = append(fake.getNextBuildInputsArgsForCall, struct {
	}{})
	stub := fake.GetNextBuildInputsStub
	fakeReturns := fake.getNextBuildInputsReturns
	fake.recordInvocation("GetNextBuildInputs", []interface{}{})
	fake.getNextBuildInputsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) GetNextBuildInputsCallCount() int {
	fake.getNextBuildInputsMutex.RLock()
	defer fake.getNextBuildInputsMutex.RUnlock()
	return len(fake.getNextBuildInputsArgsForCall)
}

func (fake *FakeJob) GetNextBuildInputsCalls(stub func() ([]db.BuildInput, error)) {
	fake.getNextBuildInputsMutex.Lock()
	defer fake.getNextBuildInputsMutex.Unlock()
	fake.GetNextBuildInputsStub = stub
}

func (fake *FakeJob) GetNextBuildInputsReturns(result1 []db.BuildInput, result2 error) {
	fake.getNextBuildInputsMutex.Lock()
	defer fake.getNextBuildInputsMutex.Unlock()
	fake.GetNextBuildInputsStub = nil
	fake.getNextBuildInputsReturns = struct {
		result1 []db.BuildInput
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) GetNextBuildInputsReturnsOnCall(i int, result1 []db.BuildInput, result2 error) {
	fake.getNextBuildInputsMutex.Lock()
	defer fake.getNextBuildInputsMutex.Unlock()
	fake.GetNextBuildInputsStub = nil
	if fake.getNextBuildInputsReturnsOnCall == nil {
		fake.getNextBuildInputsReturnsOnCall = make(map[int]struct {
			result1 []db.BuildInput
			result2 error
		})
	}
	fake.getNextBuildInputsReturnsOnCall[i] = struct {
		result1 []db.BuildInput
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) GetPendingBuilds() ([]db.Build, error) {
	fake.getPendingBuildsMutex.Lock()
	ret, specificReturn := fake.getPendingBuildsReturnsOnCall[len(fake.getPendingBuildsArgsForCall)]
	fake.getPendingBuildsArgsForCall = append(fake.getPendingBuildsArgsForCall, struct {
	}{})
	stub := fake.GetPendingBuildsStub
	fakeReturns := fake.getPendingBuildsReturns
	fake.recordInvocation("GetPendingBuilds", []interface{}{})
	fake.getPendingBuildsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) GetPendingBuildsCallCount() int {
	fake.getPendingBuildsMutex.RLock()
	defer fake.getPendingBuildsMutex.RUnlock()
	return len(fake.getPendingBuildsArgsForCall)
}

func (fake *FakeJob) GetPendingBuildsCalls(stub func() ([]db.Build, error)) {
	fake.getPendingBuildsMutex.Lock()
	defer fake.getPendingBuildsMutex.Unlock()
	fake.GetPendingBuildsStub = stub
}

func (fake *FakeJob) GetPendingBuildsReturns(result1 []db.Build, result2 error) {
	fake.getPendingBuildsMutex.Lock()
	defer fake.getPendingBuildsMutex.Unlock()
	fake.GetPendingBuildsStub = nil
	fake.getPendingBuildsReturns = struct {
		result1 []db.Build
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) GetPendingBuildsReturnsOnCall(i int, result1 []db.Build, result2 error) {
	fake.getPendingBuildsMutex.Lock()
	defer fake.getPendingBuildsMutex.Unlock()
	fake.GetPendingBuildsStub = nil
	if fake.getPendingBuildsReturnsOnCall == nil {
		fake.getPendingBuildsReturnsOnCall = make(map[int]struct {
			result1 []db.Build
			result2 error
		})
	}
	fake.getPendingBuildsReturnsOnCall[i] = struct {
		result1 []db.Build
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) HasNewInputs() bool {
	fake.hasNewInputsMutex.Lock()
	ret, specificReturn := fake.hasNewInputsReturnsOnCall[len(fake.hasNewInputsArgsForCall)]
	fake.hasNewInputsArgsForCall = append(fake.hasNewInputsArgsForCall, struct {
	}{})
	stub := fake.HasNewInputsStub
	fakeReturns := fake.hasNewInputsReturns
	fake.recordInvocation("HasNewInputs", []interface{}{})
	fake.hasNewInputsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) HasNewInputsCallCount() int {
	fake.hasNewInputsMutex.RLock()
	defer fake.hasNewInputsMutex.RUnlock()
	return len(fake.hasNewInputsArgsForCall)
}

func (fake *FakeJob) HasNewInputsCalls(stub func() bool) {
	fake.hasNewInputsMutex.Lock()
	defer fake.hasNewInputsMutex.Unlock()
	fake.HasNewInputsStub = stub
}

func (fake *FakeJob) HasNewInputsReturns(result1 bool) {
	fake.hasNewInputsMutex.Lock()
	defer fake.hasNewInputsMutex.Unlock()
	fake.HasNewInputsStub = nil
	fake.hasNewInputsReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeJob) HasNewInputsReturnsOnCall(i int, result1 bool) {
	fake.hasNewInputsMutex.Lock()
	defer fake.hasNewInputsMutex.Unlock()
	fake.HasNewInputsStub = nil
	if fake.hasNewInputsReturnsOnCall == nil {
		fake.hasNewInputsReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasNewInputsReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeJob) ID() int {
	fake.iDMutex.Lock()
	ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
	fake.iDArgsForCall = append(fake.iDArgsForCall, struct {
	}{})
	stub := fake.IDStub
	fakeReturns := fake.iDReturns
	fake.recordInvocation("ID", []interface{}{})
	fake.iDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) IDCallCount() int {
	fake.iDMutex.RLock()
	defer fake.iDMutex.RUnlock()
	return len(fake.iDArgsForCall)
}

func (fake *FakeJob) IDCalls(stub func() int) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = stub
}

func (fake *FakeJob) IDReturns(result1 int) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = nil
	fake.iDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) IDReturnsOnCall(i int, result1 int) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = nil
	if fake.iDReturnsOnCall == nil {
		fake.iDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.iDReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) Inputs() ([]atc.JobInput, error) {
	fake.inputsMutex.Lock()
	ret, specificReturn := fake.inputsReturnsOnCall[len(fake.inputsArgsForCall)]
	fake.inputsArgsForCall = append(fake.inputsArgsForCall, struct {
	}{})
	stub := fake.InputsStub
	fakeReturns := fake.inputsReturns
	fake.recordInvocation("Inputs", []interface{}{})
	fake.inputsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) InputsCallCount() int {
	fake.inputsMutex.RLock()
	defer fake.inputsMutex.RUnlock()
	return len(fake.inputsArgsForCall)
}

func (fake *FakeJob) InputsCalls(stub func() ([]atc.JobInput, error)) {
	fake.inputsMutex.Lock()
	defer fake.inputsMutex.Unlock()
	fake.InputsStub = stub
}

func (fake *FakeJob) InputsReturns(result1 []atc.JobInput, result2 error) {
	fake.inputsMutex.Lock()
	defer fake.inputsMutex.Unlock()
	fake.InputsStub = nil
	fake.inputsReturns = struct {
		result1 []atc.JobInput
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) InputsReturnsOnCall(i int, result1 []atc.JobInput, result2 error) {
	fake.inputsMutex.Lock()
	defer fake.inputsMutex.Unlock()
	fake.InputsStub = nil
	if fake.inputsReturnsOnCall == nil {
		fake.inputsReturnsOnCall = make(map[int]struct {
			result1 []atc.JobInput
			result2 error
		})
	}
	fake.inputsReturnsOnCall[i] = struct {
		result1 []atc.JobInput
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) MaxInFlight() int {
	fake.maxInFlightMutex.Lock()
	ret, specificReturn := fake.maxInFlightReturnsOnCall[len(fake.maxInFlightArgsForCall)]
	fake.maxInFlightArgsForCall = append(fake.maxInFlightArgsForCall, struct {
	}{})
	stub := fake.MaxInFlightStub
	fakeReturns := fake.maxInFlightReturns
	fake.recordInvocation("MaxInFlight", []interface{}{})
	fake.maxInFlightMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) MaxInFlightCallCount() int {
	fake.maxInFlightMutex.RLock()
	defer fake.maxInFlightMutex.RUnlock()
	return len(fake.maxInFlightArgsForCall)
}

func (fake *FakeJob) MaxInFlightCalls(stub func() int) {
	fake.maxInFlightMutex.Lock()
	defer fake.maxInFlightMutex.Unlock()
	fake.MaxInFlightStub = stub
}

func (fake *FakeJob) MaxInFlightReturns(result1 int) {
	fake.maxInFlightMutex.Lock()
	defer fake.maxInFlightMutex.Unlock()
	fake.MaxInFlightStub = nil
	fake.maxInFlightReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) MaxInFlightReturnsOnCall(i int, result1 int) {
	fake.maxInFlightMutex.Lock()
	defer fake.maxInFlightMutex.Unlock()
	fake.MaxInFlightStub = nil
	if fake.maxInFlightReturnsOnCall == nil {
		fake.maxInFlightReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.maxInFlightReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) Name() string {
	fake.nameMutex.Lock()
	ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)]
	fake.nameArgsForCall = append(fake.nameArgsForCall, struct {
	}{})
	stub := fake.NameStub
	fakeReturns := fake.nameReturns
	fake.recordInvocation("Name", []interface{}{})
	fake.nameMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) NameCallCount() int {
	fake.nameMutex.RLock()
	defer fake.nameMutex.RUnlock()
	return len(fake.nameArgsForCall)
}

func (fake *FakeJob) NameCalls(stub func() string) {
	fake.nameMutex.Lock()
	defer fake.nameMutex.Unlock()
	fake.NameStub = stub
}

func (fake *FakeJob) NameReturns(result1 string) {
	fake.nameMutex.Lock()
	defer fake.nameMutex.Unlock()
	fake.NameStub = nil
	fake.nameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeJob) NameReturnsOnCall(i int, result1 string) {
	fake.nameMutex.Lock()
	defer fake.nameMutex.Unlock()
	fake.NameStub = nil
	if fake.nameReturnsOnCall == nil {
		fake.nameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.nameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeJob) Outputs() ([]atc.JobOutput, error) {
	fake.outputsMutex.Lock()
	ret, specificReturn := fake.outputsReturnsOnCall[len(fake.outputsArgsForCall)]
	fake.outputsArgsForCall = append(fake.outputsArgsForCall, struct {
	}{})
	stub := fake.OutputsStub
	fakeReturns := fake.outputsReturns
	fake.recordInvocation("Outputs", []interface{}{})
	fake.outputsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) OutputsCallCount() int {
	fake.outputsMutex.RLock()
	defer fake.outputsMutex.RUnlock()
	return len(fake.outputsArgsForCall)
}

func (fake *FakeJob) OutputsCalls(stub func() ([]atc.JobOutput, error)) {
	fake.outputsMutex.Lock()
	defer fake.outputsMutex.Unlock()
	fake.OutputsStub = stub
}

func (fake *FakeJob) OutputsReturns(result1 []atc.JobOutput, result2 error) {
	fake.outputsMutex.Lock()
	defer fake.outputsMutex.Unlock()
	fake.OutputsStub = nil
	fake.outputsReturns = struct {
		result1 []atc.JobOutput
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) OutputsReturnsOnCall(i int, result1 []atc.JobOutput, result2 error) {
	fake.outputsMutex.Lock()
	defer fake.outputsMutex.Unlock()
	fake.OutputsStub = nil
	if fake.outputsReturnsOnCall == nil {
		fake.outputsReturnsOnCall = make(map[int]struct {
			result1 []atc.JobOutput
			result2 error
		})
	}
	fake.outputsReturnsOnCall[i] = struct {
		result1 []atc.JobOutput
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) Pause() error {
	fake.pauseMutex.Lock()
	ret, specificReturn := fake.pauseReturnsOnCall[len(fake.pauseArgsForCall)]
	fake.pauseArgsForCall = append(fake.pauseArgsForCall, struct {
	}{})
	stub := fake.PauseStub
	fakeReturns := fake.pauseReturns
	fake.recordInvocation("Pause", []interface{}{})
	fake.pauseMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) PauseCallCount() int {
	fake.pauseMutex.RLock()
	defer fake.pauseMutex.RUnlock()
	return len(fake.pauseArgsForCall)
}

func (fake *FakeJob) PauseCalls(stub func() error) {
	fake.pauseMutex.Lock()
	defer fake.pauseMutex.Unlock()
	fake.PauseStub = stub
}

func (fake *FakeJob) PauseReturns(result1 error) {
	fake.pauseMutex.Lock()
	defer fake.pauseMutex.Unlock()
	fake.PauseStub = nil
	fake.pauseReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) PauseReturnsOnCall(i int, result1 error) {
	fake.pauseMutex.Lock()
	defer fake.pauseMutex.Unlock()
	fake.PauseStub = nil
	if fake.pauseReturnsOnCall == nil {
		fake.pauseReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.pauseReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) Paused() bool {
	fake.pausedMutex.Lock()
	ret, specificReturn := fake.pausedReturnsOnCall[len(fake.pausedArgsForCall)]
	fake.pausedArgsForCall = append(fake.pausedArgsForCall, struct {
	}{})
	stub := fake.PausedStub
	fakeReturns := fake.pausedReturns
	fake.recordInvocation("Paused", []interface{}{})
	fake.pausedMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) PausedCallCount() int {
	fake.pausedMutex.RLock()
	defer fake.pausedMutex.RUnlock()
	return len(fake.pausedArgsForCall)
}

func (fake *FakeJob) PausedCalls(stub func() bool) {
	fake.pausedMutex.Lock()
	defer fake.pausedMutex.Unlock()
	fake.PausedStub = stub
}

func (fake *FakeJob) PausedReturns(result1 bool) {
	fake.pausedMutex.Lock()
	defer fake.pausedMutex.Unlock()
	fake.PausedStub = nil
	fake.pausedReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeJob) PausedReturnsOnCall(i int, result1 bool) {
	fake.pausedMutex.Lock()
	defer fake.pausedMutex.Unlock()
	fake.PausedStub = nil
	if fake.pausedReturnsOnCall == nil {
		fake.pausedReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.pausedReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeJob) Pipeline() (db.Pipeline, bool, error) {
	fake.pipelineMutex.Lock()
	ret, specificReturn := fake.pipelineReturnsOnCall[len(fake.pipelineArgsForCall)]
	fake.pipelineArgsForCall = append(fake.pipelineArgsForCall, struct {
	}{})
	stub := fake.PipelineStub
	fakeReturns := fake.pipelineReturns
	fake.recordInvocation("Pipeline", []interface{}{})
	fake.pipelineMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeJob) PipelineCallCount() int {
	fake.pipelineMutex.RLock()
	defer fake.pipelineMutex.RUnlock()
	return len(fake.pipelineArgsForCall)
}

func (fake *FakeJob) PipelineCalls(stub func() (db.Pipeline, bool, error)) {
	fake.pipelineMutex.Lock()
	defer fake.pipelineMutex.Unlock()
	fake.PipelineStub = stub
}

func (fake *FakeJob) PipelineReturns(result1 db.Pipeline, result2 bool, result3 error) {
	fake.pipelineMutex.Lock()
	defer fake.pipelineMutex.Unlock()
	fake.PipelineStub = nil
	fake.pipelineReturns = struct {
		result1 db.Pipeline
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) PipelineReturnsOnCall(i int, result1 db.Pipeline, result2 bool, result3 error) {
	fake.pipelineMutex.Lock()
	defer fake.pipelineMutex.Unlock()
	fake.PipelineStub = nil
	if fake.pipelineReturnsOnCall == nil {
		fake.pipelineReturnsOnCall = make(map[int]struct {
			result1 db.Pipeline
			result2 bool
			result3 error
		})
	}
	fake.pipelineReturnsOnCall[i] = struct {
		result1 db.Pipeline
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeJob) PipelineID() int {
	fake.pipelineIDMutex.Lock()
	ret, specificReturn := fake.pipelineIDReturnsOnCall[len(fake.pipelineIDArgsForCall)]
	fake.pipelineIDArgsForCall = append(fake.pipelineIDArgsForCall, struct {
	}{})
	stub := fake.PipelineIDStub
	fakeReturns := fake.pipelineIDReturns
	fake.recordInvocation("PipelineID", []interface{}{})
	fake.pipelineIDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) PipelineIDCallCount() int {
	fake.pipelineIDMutex.RLock()
	defer fake.pipelineIDMutex.RUnlock()
	return len(fake.pipelineIDArgsForCall)
}

func (fake *FakeJob) PipelineIDCalls(stub func() int) {
	fake.pipelineIDMutex.Lock()
	defer fake.pipelineIDMutex.Unlock()
	fake.PipelineIDStub = stub
}

func (fake *FakeJob) PipelineIDReturns(result1 int) {
	fake.pipelineIDMutex.Lock()
	defer fake.pipelineIDMutex.Unlock()
	fake.PipelineIDStub = nil
	fake.pipelineIDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) PipelineIDReturnsOnCall(i int, result1 int) {
	fake.pipelineIDMutex.Lock()
	defer fake.pipelineIDMutex.Unlock()
	fake.PipelineIDStub = nil
	if fake.pipelineIDReturnsOnCall == nil {
		fake.pipelineIDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.pipelineIDReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) PipelineInstanceVars() atc.InstanceVars {
	fake.pipelineInstanceVarsMutex.Lock()
	ret, specificReturn := fake.pipelineInstanceVarsReturnsOnCall[len(fake.pipelineInstanceVarsArgsForCall)]
	fake.pipelineInstanceVarsArgsForCall = append(fake.pipelineInstanceVarsArgsForCall, struct {
	}{})
	stub := fake.PipelineInstanceVarsStub
	fakeReturns := fake.pipelineInstanceVarsReturns
	fake.recordInvocation("PipelineInstanceVars", []interface{}{})
	fake.pipelineInstanceVarsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) PipelineInstanceVarsCallCount() int {
	fake.pipelineInstanceVarsMutex.RLock()
	defer fake.pipelineInstanceVarsMutex.RUnlock()
	return len(fake.pipelineInstanceVarsArgsForCall)
}

func (fake *FakeJob) PipelineInstanceVarsCalls(stub func() atc.InstanceVars) {
	fake.pipelineInstanceVarsMutex.Lock()
	defer fake.pipelineInstanceVarsMutex.Unlock()
	fake.PipelineInstanceVarsStub = stub
}

func (fake *FakeJob) PipelineInstanceVarsReturns(result1 atc.InstanceVars) {
	fake.pipelineInstanceVarsMutex.Lock()
	defer fake.pipelineInstanceVarsMutex.Unlock()
	fake.PipelineInstanceVarsStub = nil
	fake.pipelineInstanceVarsReturns = struct {
		result1 atc.InstanceVars
	}{result1}
}

func (fake *FakeJob) PipelineInstanceVarsReturnsOnCall(i int, result1 atc.InstanceVars) {
	fake.pipelineInstanceVarsMutex.Lock()
	defer fake.pipelineInstanceVarsMutex.Unlock()
	fake.PipelineInstanceVarsStub = nil
	if fake.pipelineInstanceVarsReturnsOnCall == nil {
		fake.pipelineInstanceVarsReturnsOnCall = make(map[int]struct {
			result1 atc.InstanceVars
		})
	}
	fake.pipelineInstanceVarsReturnsOnCall[i] = struct {
		result1 atc.InstanceVars
	}{result1}
}

func (fake *FakeJob) PipelineName() string {
	fake.pipelineNameMutex.Lock()
	ret, specificReturn := fake.pipelineNameReturnsOnCall[len(fake.pipelineNameArgsForCall)]
	fake.pipelineNameArgsForCall = append(fake.pipelineNameArgsForCall, struct {
	}{})
	stub := fake.PipelineNameStub
	fakeReturns := fake.pipelineNameReturns
	fake.recordInvocation("PipelineName", []interface{}{})
	fake.pipelineNameMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) PipelineNameCallCount() int {
	fake.pipelineNameMutex.RLock()
	defer fake.pipelineNameMutex.RUnlock()
	return len(fake.pipelineNameArgsForCall)
}

func (fake *FakeJob) PipelineNameCalls(stub func() string) {
	fake.pipelineNameMutex.Lock()
	defer fake.pipelineNameMutex.Unlock()
	fake.PipelineNameStub = stub
}

func (fake *FakeJob) PipelineNameReturns(result1 string) {
	fake.pipelineNameMutex.Lock()
	defer fake.pipelineNameMutex.Unlock()
	fake.PipelineNameStub = nil
	fake.pipelineNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeJob) PipelineNameReturnsOnCall(i int, result1 string) {
	fake.pipelineNameMutex.Lock()
	defer fake.pipelineNameMutex.Unlock()
	fake.PipelineNameStub = nil
	if fake.pipelineNameReturnsOnCall == nil {
		fake.pipelineNameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.pipelineNameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeJob) PipelineRef() atc.PipelineRef {
	fake.pipelineRefMutex.Lock()
	ret, specificReturn := fake.pipelineRefReturnsOnCall[len(fake.pipelineRefArgsForCall)]
	fake.pipelineRefArgsForCall = append(fake.pipelineRefArgsForCall, struct {
	}{})
	stub := fake.PipelineRefStub
	fakeReturns := fake.pipelineRefReturns
	fake.recordInvocation("PipelineRef", []interface{}{})
	fake.pipelineRefMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) PipelineRefCallCount() int {
	fake.pipelineRefMutex.RLock()
	defer fake.pipelineRefMutex.RUnlock()
	return len(fake.pipelineRefArgsForCall)
}

func (fake *FakeJob) PipelineRefCalls(stub func() atc.PipelineRef) {
	fake.pipelineRefMutex.Lock()
	defer fake.pipelineRefMutex.Unlock()
	fake.PipelineRefStub = stub
}

func (fake *FakeJob) PipelineRefReturns(result1 atc.PipelineRef) {
	fake.pipelineRefMutex.Lock()
	defer fake.pipelineRefMutex.Unlock()
	fake.PipelineRefStub = nil
	fake.pipelineRefReturns = struct {
		result1 atc.PipelineRef
	}{result1}
}

func (fake *FakeJob) PipelineRefReturnsOnCall(i int, result1 atc.PipelineRef) {
	fake.pipelineRefMutex.Lock()
	defer fake.pipelineRefMutex.Unlock()
	fake.PipelineRefStub = nil
	if fake.pipelineRefReturnsOnCall == nil {
		fake.pipelineRefReturnsOnCall = make(map[int]struct {
			result1 atc.PipelineRef
		})
	}
	fake.pipelineRefReturnsOnCall[i] = struct {
		result1 atc.PipelineRef
	}{result1}
}

func (fake *FakeJob) Public() bool {
	fake.publicMutex.Lock()
	ret, specificReturn := fake.publicReturnsOnCall[len(fake.publicArgsForCall)]
	fake.publicArgsForCall = append(fake.publicArgsForCall, struct {
	}{})
	stub := fake.PublicStub
	fakeReturns := fake.publicReturns
	fake.recordInvocation("Public", []interface{}{})
	fake.publicMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) PublicCallCount() int {
	fake.publicMutex.RLock()
	defer fake.publicMutex.RUnlock()
	return len(fake.publicArgsForCall)
}

func (fake *FakeJob) PublicCalls(stub func() bool) {
	fake.publicMutex.Lock()
	defer fake.publicMutex.Unlock()
	fake.PublicStub = stub
}

func (fake *FakeJob) PublicReturns(result1 bool) {
	fake.publicMutex.Lock()
	defer fake.publicMutex.Unlock()
	fake.PublicStub = nil
	fake.publicReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeJob) PublicReturnsOnCall(i int, result1 bool) {
	fake.publicMutex.Lock()
	defer fake.publicMutex.Unlock()
	fake.PublicStub = nil
	if fake.publicReturnsOnCall == nil {
		fake.publicReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.publicReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeJob) Reload() (bool, error) {
	fake.reloadMutex.Lock()
	ret, specificReturn := fake.reloadReturnsOnCall[len(fake.reloadArgsForCall)]
	fake.reloadArgsForCall = append(fake.reloadArgsForCall, struct {
	}{})
	stub := fake.ReloadStub
	fakeReturns := fake.reloadReturns
	fake.recordInvocation("Reload", []interface{}{})
	fake.reloadMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) ReloadCallCount() int {
	fake.reloadMutex.RLock()
	defer fake.reloadMutex.RUnlock()
	return len(fake.reloadArgsForCall)
}

func (fake *FakeJob) ReloadCalls(stub func() (bool, error)) {
	fake.reloadMutex.Lock()
	defer fake.reloadMutex.Unlock()
	fake.ReloadStub = stub
}

func (fake *FakeJob) ReloadReturns(result1 bool, result2 error) {
	fake.reloadMutex.Lock()
	defer fake.reloadMutex.Unlock()
	fake.ReloadStub = nil
	fake.reloadReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) ReloadReturnsOnCall(i int, result1 bool, result2 error) {
	fake.reloadMutex.Lock()
	defer fake.reloadMutex.Unlock()
	fake.ReloadStub = nil
	if fake.reloadReturnsOnCall == nil {
		fake.reloadReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.reloadReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) RequestSchedule() error {
	fake.requestScheduleMutex.Lock()
	ret, specificReturn := fake.requestScheduleReturnsOnCall[len(fake.requestScheduleArgsForCall)]
	fake.requestScheduleArgsForCall = append(fake.requestScheduleArgsForCall, struct {
	}{})
	stub := fake.RequestScheduleStub
	fakeReturns := fake.requestScheduleReturns
	fake.recordInvocation("RequestSchedule", []interface{}{})
	fake.requestScheduleMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) RequestScheduleCallCount() int {
	fake.requestScheduleMutex.RLock()
	defer fake.requestScheduleMutex.RUnlock()
	return len(fake.requestScheduleArgsForCall)
}

func (fake *FakeJob) RequestScheduleCalls(stub func() error) {
	fake.requestScheduleMutex.Lock()
	defer fake.requestScheduleMutex.Unlock()
	fake.RequestScheduleStub = stub
}

func (fake *FakeJob) RequestScheduleReturns(result1 error) {
	fake.requestScheduleMutex.Lock()
	defer fake.requestScheduleMutex.Unlock()
	fake.RequestScheduleStub = nil
	fake.requestScheduleReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) RequestScheduleReturnsOnCall(i int, result1 error) {
	fake.requestScheduleMutex.Lock()
	defer fake.requestScheduleMutex.Unlock()
	fake.RequestScheduleStub = nil
	if fake.requestScheduleReturnsOnCall == nil {
		fake.requestScheduleReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.requestScheduleReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) RerunBuild(arg1 db.Build, arg2 string) (db.Build, error) {
	fake.rerunBuildMutex.Lock()
	ret, specificReturn := fake.rerunBuildReturnsOnCall[len(fake.rerunBuildArgsForCall)]
	fake.rerunBuildArgsForCall = append(fake.rerunBuildArgsForCall, struct {
		arg1 db.Build
		arg2 string
	}{arg1, arg2})
	stub := fake.RerunBuildStub
	fakeReturns := fake.rerunBuildReturns
	fake.recordInvocation("RerunBuild", []interface{}{arg1, arg2})
	fake.rerunBuildMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) RerunBuildCallCount() int {
	fake.rerunBuildMutex.RLock()
	defer fake.rerunBuildMutex.RUnlock()
	return len(fake.rerunBuildArgsForCall)
}

func (fake *FakeJob) RerunBuildCalls(stub func(db.Build, string) (db.Build, error)) {
	fake.rerunBuildMutex.Lock()
	defer fake.rerunBuildMutex.Unlock()
	fake.RerunBuildStub = stub
}

func (fake *FakeJob) RerunBuildArgsForCall(i int) (db.Build, string) {
	fake.rerunBuildMutex.RLock()
	defer fake.rerunBuildMutex.RUnlock()
	argsForCall := fake.rerunBuildArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeJob) RerunBuildReturns(result1 db.Build, result2 error) {
	fake.rerunBuildMutex.Lock()
	defer fake.rerunBuildMutex.Unlock()
	fake.RerunBuildStub = nil
	fake.rerunBuildReturns = struct {
		result1 db.Build
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) RerunBuildReturnsOnCall(i int, result1 db.Build, result2 error) {
	fake.rerunBuildMutex.Lock()
	defer fake.rerunBuildMutex.Unlock()
	fake.RerunBuildStub = nil
	if fake.rerunBuildReturnsOnCall == nil {
		fake.rerunBuildReturnsOnCall = make(map[int]struct {
			result1 db.Build
			result2 error
		})
	}
	fake.rerunBuildReturnsOnCall[i] = struct {
		result1 db.Build
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) SaveNextInputMapping(arg1 db.InputMapping, arg2 bool) error {
	fake.saveNextInputMappingMutex.Lock()
	ret, specificReturn := fake.saveNextInputMappingReturnsOnCall[len(fake.saveNextInputMappingArgsForCall)]
	fake.saveNextInputMappingArgsForCall = append(fake.saveNextInputMappingArgsForCall, struct {
		arg1 db.InputMapping
		arg2 bool
	}{arg1, arg2})
	stub := fake.SaveNextInputMappingStub
	fakeReturns := fake.saveNextInputMappingReturns
	fake.recordInvocation("SaveNextInputMapping", []interface{}{arg1, arg2})
	fake.saveNextInputMappingMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) SaveNextInputMappingCallCount() int {
	fake.saveNextInputMappingMutex.RLock()
	defer fake.saveNextInputMappingMutex.RUnlock()
	return len(fake.saveNextInputMappingArgsForCall)
}

func (fake *FakeJob) SaveNextInputMappingCalls(stub func(db.InputMapping, bool) error) {
	fake.saveNextInputMappingMutex.Lock()
	defer fake.saveNextInputMappingMutex.Unlock()
	fake.SaveNextInputMappingStub = stub
}

func (fake *FakeJob) SaveNextInputMappingArgsForCall(i int) (db.InputMapping, bool) {
	fake.saveNextInputMappingMutex.RLock()
	defer fake.saveNextInputMappingMutex.RUnlock()
	argsForCall := fake.saveNextInputMappingArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeJob) SaveNextInputMappingReturns(result1 error) {
	fake.saveNextInputMappingMutex.Lock()
	defer fake.saveNextInputMappingMutex.Unlock()
	fake.SaveNextInputMappingStub = nil
	fake.saveNextInputMappingReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) SaveNextInputMappingReturnsOnCall(i int, result1 error) {
	fake.saveNextInputMappingMutex.Lock()
	defer fake.saveNextInputMappingMutex.Unlock()
	fake.SaveNextInputMappingStub = nil
	if fake.saveNextInputMappingReturnsOnCall == nil {
		fake.saveNextInputMappingReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.saveNextInputMappingReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) ScheduleBuild(arg1 db.Build) (bool, error) {
	fake.scheduleBuildMutex.Lock()
	ret, specificReturn := fake.scheduleBuildReturnsOnCall[len(fake.scheduleBuildArgsForCall)]
	fake.scheduleBuildArgsForCall = append(fake.scheduleBuildArgsForCall, struct {
		arg1 db.Build
	}{arg1})
	stub := fake.ScheduleBuildStub
	fakeReturns := fake.scheduleBuildReturns
	fake.recordInvocation("ScheduleBuild", []interface{}{arg1})
	fake.scheduleBuildMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeJob) ScheduleBuildCallCount() int {
	fake.scheduleBuildMutex.RLock()
	defer fake.scheduleBuildMutex.RUnlock()
	return len(fake.scheduleBuildArgsForCall)
}

func (fake *FakeJob) ScheduleBuildCalls(stub func(db.Build) (bool, error)) {
	fake.scheduleBuildMutex.Lock()
	defer fake.scheduleBuildMutex.Unlock()
	fake.ScheduleBuildStub = stub
}

func (fake *FakeJob) ScheduleBuildArgsForCall(i int) db.Build {
	fake.scheduleBuildMutex.RLock()
	defer fake.scheduleBuildMutex.RUnlock()
	argsForCall := fake.scheduleBuildArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) ScheduleBuildReturns(result1 bool, result2 error) {
	fake.scheduleBuildMutex.Lock()
	defer fake.scheduleBuildMutex.Unlock()
	fake.ScheduleBuildStub = nil
	fake.scheduleBuildReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) ScheduleBuildReturnsOnCall(i int, result1 bool, result2 error) {
	fake.scheduleBuildMutex.Lock()
	defer fake.scheduleBuildMutex.Unlock()
	fake.ScheduleBuildStub = nil
	if fake.scheduleBuildReturnsOnCall == nil {
		fake.scheduleBuildReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.scheduleBuildReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeJob) ScheduleRequestedTime() time.Time {
	fake.scheduleRequestedTimeMutex.Lock()
	ret, specificReturn := fake.scheduleRequestedTimeReturnsOnCall[len(fake.scheduleRequestedTimeArgsForCall)]
	fake.scheduleRequestedTimeArgsForCall = append(fake.scheduleRequestedTimeArgsForCall, struct {
	}{})
	stub := fake.ScheduleRequestedTimeStub
	fakeReturns := fake.scheduleRequestedTimeReturns
	fake.recordInvocation("ScheduleRequestedTime", []interface{}{})
	fake.scheduleRequestedTimeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) ScheduleRequestedTimeCallCount() int {
	fake.scheduleRequestedTimeMutex.RLock()
	defer fake.scheduleRequestedTimeMutex.RUnlock()
	return len(fake.scheduleRequestedTimeArgsForCall)
}

func (fake *FakeJob) ScheduleRequestedTimeCalls(stub func() time.Time) {
	fake.scheduleRequestedTimeMutex.Lock()
	defer fake.scheduleRequestedTimeMutex.Unlock()
	fake.ScheduleRequestedTimeStub = stub
}

func (fake *FakeJob) ScheduleRequestedTimeReturns(result1 time.Time) {
	fake.scheduleRequestedTimeMutex.Lock()
	defer fake.scheduleRequestedTimeMutex.Unlock()
	fake.ScheduleRequestedTimeStub = nil
	fake.scheduleRequestedTimeReturns = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeJob) ScheduleRequestedTimeReturnsOnCall(i int, result1 time.Time) {
	fake.scheduleRequestedTimeMutex.Lock()
	defer fake.scheduleRequestedTimeMutex.Unlock()
	fake.ScheduleRequestedTimeStub = nil
	if fake.scheduleRequestedTimeReturnsOnCall == nil {
		fake.scheduleRequestedTimeReturnsOnCall = make(map[int]struct {
			result1 time.Time
		})
	}
	fake.scheduleRequestedTimeReturnsOnCall[i] = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeJob) SetHasNewInputs(arg1 bool) error {
	fake.setHasNewInputsMutex.Lock()
	ret, specificReturn := fake.setHasNewInputsReturnsOnCall[len(fake.setHasNewInputsArgsForCall)]
	fake.setHasNewInputsArgsForCall = append(fake.setHasNewInputsArgsForCall, struct {
		arg1 bool
	}{arg1})
	stub := fake.SetHasNewInputsStub
	fakeReturns := fake.setHasNewInputsReturns
	fake.recordInvocation("SetHasNewInputs", []interface{}{arg1})
	fake.setHasNewInputsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) SetHasNewInputsCallCount() int {
	fake.setHasNewInputsMutex.RLock()
	defer fake.setHasNewInputsMutex.RUnlock()
	return len(fake.setHasNewInputsArgsForCall)
}

func (fake *FakeJob) SetHasNewInputsCalls(stub func(bool) error) {
	fake.setHasNewInputsMutex.Lock()
	defer fake.setHasNewInputsMutex.Unlock()
	fake.SetHasNewInputsStub = stub
}

func (fake *FakeJob) SetHasNewInputsArgsForCall(i int) bool {
	fake.setHasNewInputsMutex.RLock()
	defer fake.setHasNewInputsMutex.RUnlock()
	argsForCall := fake.setHasNewInputsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) SetHasNewInputsReturns(result1 error) {
	fake.setHasNewInputsMutex.Lock()
	defer fake.setHasNewInputsMutex.Unlock()
	fake.SetHasNewInputsStub = nil
	fake.setHasNewInputsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) SetHasNewInputsReturnsOnCall(i int, result1 error) {
	fake.setHasNewInputsMutex.Lock()
	defer fake.setHasNewInputsMutex.Unlock()
	fake.SetHasNewInputsStub = nil
	if fake.setHasNewInputsReturnsOnCall == nil {
		fake.setHasNewInputsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setHasNewInputsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) Tags() []string {
	fake.tagsMutex.Lock()
	ret, specificReturn := fake.tagsReturnsOnCall[len(fake.tagsArgsForCall)]
	fake.tagsArgsForCall = append(fake.tagsArgsForCall, struct {
	}{})
	stub := fake.TagsStub
	fakeReturns := fake.tagsReturns
	fake.recordInvocation("Tags", []interface{}{})
	fake.tagsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) TagsCallCount() int {
	fake.tagsMutex.RLock()
	defer fake.tagsMutex.RUnlock()
	return len(fake.tagsArgsForCall)
}

func (fake *FakeJob) TagsCalls(stub func() []string) {
	fake.tagsMutex.Lock()
	defer fake.tagsMutex.Unlock()
	fake.TagsStub = stub
}

func (fake *FakeJob) TagsReturns(result1 []string) {
	fake.tagsMutex.Lock()
	defer fake.tagsMutex.Unlock()
	fake.TagsStub = nil
	fake.tagsReturns = struct {
		result1 []string
	}{result1}
}

func (fake *FakeJob) TagsReturnsOnCall(i int, result1 []string) {
	fake.tagsMutex.Lock()
	defer fake.tagsMutex.Unlock()
	fake.TagsStub = nil
	if fake.tagsReturnsOnCall == nil {
		fake.tagsReturnsOnCall = make(map[int]struct {
			result1 []string
		})
	}
	fake.tagsReturnsOnCall[i] = struct {
		result1 []string
	}{result1}
}

func (fake *FakeJob) TeamID() int {
	fake.teamIDMutex.Lock()
	ret, specificReturn := fake.teamIDReturnsOnCall[len(fake.teamIDArgsForCall)]
	fake.teamIDArgsForCall = append(fake.teamIDArgsForCall, struct {
	}{})
	stub := fake.TeamIDStub
	fakeReturns := fake.teamIDReturns
	fake.recordInvocation("TeamID", []interface{}{})
	fake.teamIDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) TeamIDCallCount() int {
	fake.teamIDMutex.RLock()
	defer fake.teamIDMutex.RUnlock()
	return len(fake.teamIDArgsForCall)
}

func (fake *FakeJob) TeamIDCalls(stub func() int) {
	fake.teamIDMutex.Lock()
	defer fake.teamIDMutex.Unlock()
	fake.TeamIDStub = stub
}

func (fake *FakeJob) TeamIDReturns(result1 int) {
	fake.teamIDMutex.Lock()
	defer fake.teamIDMutex.Unlock()
	fake.TeamIDStub = nil
	fake.teamIDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) TeamIDReturnsOnCall(i int, result1 int) {
	fake.teamIDMutex.Lock()
	defer fake.teamIDMutex.Unlock()
	fake.TeamIDStub = nil
	if fake.teamIDReturnsOnCall == nil {
		fake.teamIDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.teamIDReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeJob) TeamName() string {
	fake.teamNameMutex.Lock()
	ret, specificReturn := fake.teamNameReturnsOnCall[len(fake.teamNameArgsForCall)]
	fake.teamNameArgsForCall = append(fake.teamNameArgsForCall, struct {
	}{})
	stub := fake.TeamNameStub
	fakeReturns := fake.teamNameReturns
	fake.recordInvocation("TeamName", []interface{}{})
	fake.teamNameMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) TeamNameCallCount() int {
	fake.teamNameMutex.RLock()
	defer fake.teamNameMutex.RUnlock()
	return len(fake.teamNameArgsForCall)
}

func (fake *FakeJob) TeamNameCalls(stub func() string) {
	fake.teamNameMutex.Lock()
	defer fake.teamNameMutex.Unlock()
	fake.TeamNameStub = stub
}

func (fake *FakeJob) TeamNameReturns(result1 string) {
	fake.teamNameMutex.Lock()
	defer fake.teamNameMutex.Unlock()
	fake.TeamNameStub = nil
	fake.teamNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeJob) TeamNameReturnsOnCall(i int, result1 string) {
	fake.teamNameMutex.Lock()
	defer fake.teamNameMutex.Unlock()
	fake.TeamNameStub = nil
	if fake.teamNameReturnsOnCall == nil {
		fake.teamNameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.teamNameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeJob) Unpause() error {
	fake.unpauseMutex.Lock()
	ret, specificReturn := fake.unpauseReturnsOnCall[len(fake.unpauseArgsForCall)]
	fake.unpauseArgsForCall = append(fake.unpauseArgsForCall, struct {
	}{})
	stub := fake.UnpauseStub
	fakeReturns := fake.unpauseReturns
	fake.recordInvocation("Unpause", []interface{}{})
	fake.unpauseMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) UnpauseCallCount() int {
	fake.unpauseMutex.RLock()
	defer fake.unpauseMutex.RUnlock()
	return len(fake.unpauseArgsForCall)
}

func (fake *FakeJob) UnpauseCalls(stub func() error) {
	fake.unpauseMutex.Lock()
	defer fake.unpauseMutex.Unlock()
	fake.UnpauseStub = stub
}

func (fake *FakeJob) UnpauseReturns(result1 error) {
	fake.unpauseMutex.Lock()
	defer fake.unpauseMutex.Unlock()
	fake.UnpauseStub = nil
	fake.unpauseReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) UnpauseReturnsOnCall(i int, result1 error) {
	fake.unpauseMutex.Lock()
	defer fake.unpauseMutex.Unlock()
	fake.UnpauseStub = nil
	if fake.unpauseReturnsOnCall == nil {
		fake.unpauseReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.unpauseReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) UpdateFirstLoggedBuildID(arg1 int) error {
	fake.updateFirstLoggedBuildIDMutex.Lock()
	ret, specificReturn := fake.updateFirstLoggedBuildIDReturnsOnCall[len(fake.updateFirstLoggedBuildIDArgsForCall)]
	fake.updateFirstLoggedBuildIDArgsForCall = append(fake.updateFirstLoggedBuildIDArgsForCall, struct {
		arg1 int
	}{arg1})
	stub := fake.UpdateFirstLoggedBuildIDStub
	fakeReturns := fake.updateFirstLoggedBuildIDReturns
	fake.recordInvocation("UpdateFirstLoggedBuildID", []interface{}{arg1})
	fake.updateFirstLoggedBuildIDMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) UpdateFirstLoggedBuildIDCallCount() int {
	fake.updateFirstLoggedBuildIDMutex.RLock()
	defer fake.updateFirstLoggedBuildIDMutex.RUnlock()
	return len(fake.updateFirstLoggedBuildIDArgsForCall)
}

func (fake *FakeJob) UpdateFirstLoggedBuildIDCalls(stub func(int) error) {
	fake.updateFirstLoggedBuildIDMutex.Lock()
	defer fake.updateFirstLoggedBuildIDMutex.Unlock()
	fake.UpdateFirstLoggedBuildIDStub = stub
}

func (fake *FakeJob) UpdateFirstLoggedBuildIDArgsForCall(i int) int {
	fake.updateFirstLoggedBuildIDMutex.RLock()
	defer fake.updateFirstLoggedBuildIDMutex.RUnlock()
	argsForCall := fake.updateFirstLoggedBuildIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) UpdateFirstLoggedBuildIDReturns(result1 error) {
	fake.updateFirstLoggedBuildIDMutex.Lock()
	defer fake.updateFirstLoggedBuildIDMutex.Unlock()
	fake.UpdateFirstLoggedBuildIDStub = nil
	fake.updateFirstLoggedBuildIDReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) UpdateFirstLoggedBuildIDReturnsOnCall(i int, result1 error) {
	fake.updateFirstLoggedBuildIDMutex.Lock()
	defer fake.updateFirstLoggedBuildIDMutex.Unlock()
	fake.UpdateFirstLoggedBuildIDStub = nil
	if fake.updateFirstLoggedBuildIDReturnsOnCall == nil {
		fake.updateFirstLoggedBuildIDReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateFirstLoggedBuildIDReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) UpdateLastScheduled(arg1 time.Time) error {
	fake.updateLastScheduledMutex.Lock()
	ret, specificReturn := fake.updateLastScheduledReturnsOnCall[len(fake.updateLastScheduledArgsForCall)]
	fake.updateLastScheduledArgsForCall = append(fake.updateLastScheduledArgsForCall, struct {
		arg1 time.Time
	}{arg1})
	stub := fake.UpdateLastScheduledStub
	fakeReturns := fake.updateLastScheduledReturns
	fake.recordInvocation("UpdateLastScheduled", []interface{}{arg1})
	fake.updateLastScheduledMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeJob) UpdateLastScheduledCallCount() int {
	fake.updateLastScheduledMutex.RLock()
	defer fake.updateLastScheduledMutex.RUnlock()
	return len(fake.updateLastScheduledArgsForCall)
}

func (fake *FakeJob) UpdateLastScheduledCalls(stub func(time.Time) error) {
	fake.updateLastScheduledMutex.Lock()
	defer fake.updateLastScheduledMutex.Unlock()
	fake.UpdateLastScheduledStub = stub
}

func (fake *FakeJob) UpdateLastScheduledArgsForCall(i int) time.Time {
	fake.updateLastScheduledMutex.RLock()
	defer fake.updateLastScheduledMutex.RUnlock()
	argsForCall := fake.updateLastScheduledArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeJob) UpdateLastScheduledReturns(result1 error) {
	fake.updateLastScheduledMutex.Lock()
	defer fake.updateLastScheduledMutex.Unlock()
	fake.UpdateLastScheduledStub = nil
	fake.updateLastScheduledReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) UpdateLastScheduledReturnsOnCall(i int, result1 error) {
	fake.updateLastScheduledMutex.Lock()
	defer fake.updateLastScheduledMutex.Unlock()
	fake.UpdateLastScheduledStub = nil
	if fake.updateLastScheduledReturnsOnCall == nil {
		fake.updateLastScheduledReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateLastScheduledReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeJob) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.acquireSchedulingLockMutex.RLock()
	defer fake.acquireSchedulingLockMutex.RUnlock()
	fake.algorithmInputsMutex.RLock()
	defer fake.algorithmInputsMutex.RUnlock()
	fake.buildMutex.RLock()
	defer fake.buildMutex.RUnlock()
	fake.buildsMutex.RLock()
	defer fake.buildsMutex.RUnlock()
	fake.buildsWithTimeMutex.RLock()
	defer fake.buildsWithTimeMutex.RUnlock()
	fake.clearTaskCacheMutex.RLock()
	defer fake.clearTaskCacheMutex.RUnlock()
	fake.configMutex.RLock()
	defer fake.configMutex.RUnlock()
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	fake.disableManualTriggerMutex.RLock()
	defer fake.disableManualTriggerMutex.RUnlock()
	fake.ensurePendingBuildExistsMutex.RLock()
	defer fake.ensurePendingBuildExistsMutex.RUnlock()
	fake.finishedAndNextBuildMutex.RLock()
	defer fake.finishedAndNextBuildMutex.RUnlock()
	fake.firstLoggedBuildIDMutex.RLock()
	defer fake.firstLoggedBuildIDMutex.RUnlock()
	fake.getFullNextBuildInputsMutex.RLock()
	defer fake.getFullNextBuildInputsMutex.RUnlock()
	fake.getNextBuildInputsMutex.RLock()
	defer fake.getNextBuildInputsMutex.RUnlock()
	fake.getPendingBuildsMutex.RLock()
	defer fake.getPendingBuildsMutex.RUnlock()
	fake.hasNewInputsMutex.RLock()
	defer fake.hasNewInputsMutex.RUnlock()
	fake.iDMutex.RLock()
	defer fake.iDMutex.RUnlock()
	fake.inputsMutex.RLock()
	defer fake.inputsMutex.RUnlock()
	fake.maxInFlightMutex.RLock()
	defer fake.maxInFlightMutex.RUnlock()
	fake.nameMutex.RLock()
	defer fake.nameMutex.RUnlock()
	fake.outputsMutex.RLock()
	defer fake.outputsMutex.RUnlock()
	fake.pauseMutex.RLock()
	defer fake.pauseMutex.RUnlock()
	fake.pausedMutex.RLock()
	defer fake.pausedMutex.RUnlock()
	fake.pipelineMutex.RLock()
	defer fake.pipelineMutex.RUnlock()
	fake.pipelineIDMutex.RLock()
	defer fake.pipelineIDMutex.RUnlock()
	fake.pipelineInstanceVarsMutex.RLock()
	defer fake.pipelineInstanceVarsMutex.RUnlock()
	fake.pipelineNameMutex.RLock()
	defer fake.pipelineNameMutex.RUnlock()
	fake.pipelineRefMutex.RLock()
	defer fake.pipelineRefMutex.RUnlock()
	fake.publicMutex.RLock()
	defer fake.publicMutex.RUnlock()
	fake.reloadMutex.RLock()
	defer fake.reloadMutex.RUnlock()
	fake.requestScheduleMutex.RLock()
	defer fake.requestScheduleMutex.RUnlock()
	fake.rerunBuildMutex.RLock()
	defer fake.rerunBuildMutex.RUnlock()
	fake.saveNextInputMappingMutex.RLock()
	defer fake.saveNextInputMappingMutex.RUnlock()
	fake.scheduleBuildMutex.RLock()
	defer fake.scheduleBuildMutex.RUnlock()
	fake.scheduleRequestedTimeMutex.RLock()
	defer fake.scheduleRequestedTimeMutex.RUnlock()
	fake.setHasNewInputsMutex.RLock()
	defer fake.setHasNewInputsMutex.RUnlock()
	fake.tagsMutex.RLock()
	defer fake.tagsMutex.RUnlock()
	fake.teamIDMutex.RLock()
	defer fake.teamIDMutex.RUnlock()
	fake.teamNameMutex.RLock()
	defer fake.teamNameMutex.RUnlock()
	fake.unpauseMutex.RLock()
	defer fake.unpauseMutex.RUnlock()
	fake.updateFirstLoggedBuildIDMutex.RLock()
	defer fake.updateFirstLoggedBuildIDMutex.RUnlock()
	fake.updateLastScheduledMutex.RLock()
	defer fake.updateLastScheduledMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeJob) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ db.Job = new(FakeJob)