concourse/atc/db/dbfakes/fake_build.go

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

import (
	"encoding/json"
	"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 FakeBuild struct {
	AbortNotifierStub        func() (db.Notifier, error)
	abortNotifierMutex       sync.RWMutex
	abortNotifierArgsForCall []struct {
	}
	abortNotifierReturns struct {
		result1 db.Notifier
		result2 error
	}
	abortNotifierReturnsOnCall map[int]struct {
		result1 db.Notifier
		result2 error
	}
	AcquireTrackingLockStub        func(lager.Logger, time.Duration) (lock.Lock, bool, error)
	acquireTrackingLockMutex       sync.RWMutex
	acquireTrackingLockArgsForCall []struct {
		arg1 lager.Logger
		arg2 time.Duration
	}
	acquireTrackingLockReturns struct {
		result1 lock.Lock
		result2 bool
		result3 error
	}
	acquireTrackingLockReturnsOnCall map[int]struct {
		result1 lock.Lock
		result2 bool
		result3 error
	}
	ArtifactStub        func(int) (db.WorkerArtifact, error)
	artifactMutex       sync.RWMutex
	artifactArgsForCall []struct {
		arg1 int
	}
	artifactReturns struct {
		result1 db.WorkerArtifact
		result2 error
	}
	artifactReturnsOnCall map[int]struct {
		result1 db.WorkerArtifact
		result2 error
	}
	ArtifactsStub        func() ([]db.WorkerArtifact, error)
	artifactsMutex       sync.RWMutex
	artifactsArgsForCall []struct {
	}
	artifactsReturns struct {
		result1 []db.WorkerArtifact
		result2 error
	}
	artifactsReturnsOnCall map[int]struct {
		result1 []db.WorkerArtifact
		result2 error
	}
	CreateTimeStub        func() time.Time
	createTimeMutex       sync.RWMutex
	createTimeArgsForCall []struct {
	}
	createTimeReturns struct {
		result1 time.Time
	}
	createTimeReturnsOnCall map[int]struct {
		result1 time.Time
	}
	DeleteStub        func() (bool, error)
	deleteMutex       sync.RWMutex
	deleteArgsForCall []struct {
	}
	deleteReturns struct {
		result1 bool
		result2 error
	}
	deleteReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	EndTimeStub        func() time.Time
	endTimeMutex       sync.RWMutex
	endTimeArgsForCall []struct {
	}
	endTimeReturns struct {
		result1 time.Time
	}
	endTimeReturnsOnCall map[int]struct {
		result1 time.Time
	}
	EventsStub        func(uint) (db.EventSource, error)
	eventsMutex       sync.RWMutex
	eventsArgsForCall []struct {
		arg1 uint
	}
	eventsReturns struct {
		result1 db.EventSource
		result2 error
	}
	eventsReturnsOnCall map[int]struct {
		result1 db.EventSource
		result2 error
	}
	FinishStub        func(db.BuildStatus) error
	finishMutex       sync.RWMutex
	finishArgsForCall []struct {
		arg1 db.BuildStatus
	}
	finishReturns struct {
		result1 error
	}
	finishReturnsOnCall map[int]struct {
		result1 error
	}
	HasPlanStub        func() bool
	hasPlanMutex       sync.RWMutex
	hasPlanArgsForCall []struct {
	}
	hasPlanReturns struct {
		result1 bool
	}
	hasPlanReturnsOnCall map[int]struct {
		result1 bool
	}
	IDStub        func() int
	iDMutex       sync.RWMutex
	iDArgsForCall []struct {
	}
	iDReturns struct {
		result1 int
	}
	iDReturnsOnCall map[int]struct {
		result1 int
	}
	InterceptibleStub        func() (bool, error)
	interceptibleMutex       sync.RWMutex
	interceptibleArgsForCall []struct {
	}
	interceptibleReturns struct {
		result1 bool
		result2 error
	}
	interceptibleReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	IsAbortedStub        func() bool
	isAbortedMutex       sync.RWMutex
	isAbortedArgsForCall []struct {
	}
	isAbortedReturns struct {
		result1 bool
	}
	isAbortedReturnsOnCall map[int]struct {
		result1 bool
	}
	IsCompletedStub        func() bool
	isCompletedMutex       sync.RWMutex
	isCompletedArgsForCall []struct {
	}
	isCompletedReturns struct {
		result1 bool
	}
	isCompletedReturnsOnCall map[int]struct {
		result1 bool
	}
	IsDrainedStub        func() bool
	isDrainedMutex       sync.RWMutex
	isDrainedArgsForCall []struct {
	}
	isDrainedReturns struct {
		result1 bool
	}
	isDrainedReturnsOnCall map[int]struct {
		result1 bool
	}
	IsManuallyTriggeredStub        func() bool
	isManuallyTriggeredMutex       sync.RWMutex
	isManuallyTriggeredArgsForCall []struct {
	}
	isManuallyTriggeredReturns struct {
		result1 bool
	}
	isManuallyTriggeredReturnsOnCall map[int]struct {
		result1 bool
	}
	IsRunningStub        func() bool
	isRunningMutex       sync.RWMutex
	isRunningArgsForCall []struct {
	}
	isRunningReturns struct {
		result1 bool
	}
	isRunningReturnsOnCall map[int]struct {
		result1 bool
	}
	IsScheduledStub        func() bool
	isScheduledMutex       sync.RWMutex
	isScheduledArgsForCall []struct {
	}
	isScheduledReturns struct {
		result1 bool
	}
	isScheduledReturnsOnCall map[int]struct {
		result1 bool
	}
	JobIDStub        func() int
	jobIDMutex       sync.RWMutex
	jobIDArgsForCall []struct {
	}
	jobIDReturns struct {
		result1 int
	}
	jobIDReturnsOnCall map[int]struct {
		result1 int
	}
	JobNameStub        func() string
	jobNameMutex       sync.RWMutex
	jobNameArgsForCall []struct {
	}
	jobNameReturns struct {
		result1 string
	}
	jobNameReturnsOnCall map[int]struct {
		result1 string
	}
	MarkAsAbortedStub        func() error
	markAsAbortedMutex       sync.RWMutex
	markAsAbortedArgsForCall []struct {
	}
	markAsAbortedReturns struct {
		result1 error
	}
	markAsAbortedReturnsOnCall map[int]struct {
		result1 error
	}
	NameStub        func() string
	nameMutex       sync.RWMutex
	nameArgsForCall []struct {
	}
	nameReturns struct {
		result1 string
	}
	nameReturnsOnCall map[int]struct {
		result1 string
	}
	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
	}
	PipelineNameStub        func() string
	pipelineNameMutex       sync.RWMutex
	pipelineNameArgsForCall []struct {
	}
	pipelineNameReturns struct {
		result1 string
	}
	pipelineNameReturnsOnCall map[int]struct {
		result1 string
	}
	PreparationStub        func() (db.BuildPreparation, bool, error)
	preparationMutex       sync.RWMutex
	preparationArgsForCall []struct {
	}
	preparationReturns struct {
		result1 db.BuildPreparation
		result2 bool
		result3 error
	}
	preparationReturnsOnCall map[int]struct {
		result1 db.BuildPreparation
		result2 bool
		result3 error
	}
	PrivatePlanStub        func() atc.Plan
	privatePlanMutex       sync.RWMutex
	privatePlanArgsForCall []struct {
	}
	privatePlanReturns struct {
		result1 atc.Plan
	}
	privatePlanReturnsOnCall map[int]struct {
		result1 atc.Plan
	}
	PublicPlanStub        func() *json.RawMessage
	publicPlanMutex       sync.RWMutex
	publicPlanArgsForCall []struct {
	}
	publicPlanReturns struct {
		result1 *json.RawMessage
	}
	publicPlanReturnsOnCall map[int]struct {
		result1 *json.RawMessage
	}
	ReapTimeStub        func() time.Time
	reapTimeMutex       sync.RWMutex
	reapTimeArgsForCall []struct {
	}
	reapTimeReturns struct {
		result1 time.Time
	}
	reapTimeReturnsOnCall map[int]struct {
		result1 time.Time
	}
	ReloadStub        func() (bool, error)
	reloadMutex       sync.RWMutex
	reloadArgsForCall []struct {
	}
	reloadReturns struct {
		result1 bool
		result2 error
	}
	reloadReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	ResourcesStub        func() ([]db.BuildInput, []db.BuildOutput, error)
	resourcesMutex       sync.RWMutex
	resourcesArgsForCall []struct {
	}
	resourcesReturns struct {
		result1 []db.BuildInput
		result2 []db.BuildOutput
		result3 error
	}
	resourcesReturnsOnCall map[int]struct {
		result1 []db.BuildInput
		result2 []db.BuildOutput
		result3 error
	}
	SaveEventStub        func(atc.Event) error
	saveEventMutex       sync.RWMutex
	saveEventArgsForCall []struct {
		arg1 atc.Event
	}
	saveEventReturns struct {
		result1 error
	}
	saveEventReturnsOnCall map[int]struct {
		result1 error
	}
	SaveImageResourceVersionStub        func(db.UsedResourceCache) error
	saveImageResourceVersionMutex       sync.RWMutex
	saveImageResourceVersionArgsForCall []struct {
		arg1 db.UsedResourceCache
	}
	saveImageResourceVersionReturns struct {
		result1 error
	}
	saveImageResourceVersionReturnsOnCall map[int]struct {
		result1 error
	}
	SaveOutputStub        func(string, atc.Source, atc.VersionedResourceTypes, atc.Version, db.ResourceConfigMetadataFields, string, string) error
	saveOutputMutex       sync.RWMutex
	saveOutputArgsForCall []struct {
		arg1 string
		arg2 atc.Source
		arg3 atc.VersionedResourceTypes
		arg4 atc.Version
		arg5 db.ResourceConfigMetadataFields
		arg6 string
		arg7 string
	}
	saveOutputReturns struct {
		result1 error
	}
	saveOutputReturnsOnCall map[int]struct {
		result1 error
	}
	ScheduleStub        func() (bool, error)
	scheduleMutex       sync.RWMutex
	scheduleArgsForCall []struct {
	}
	scheduleReturns struct {
		result1 bool
		result2 error
	}
	scheduleReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	SchemaStub        func() string
	schemaMutex       sync.RWMutex
	schemaArgsForCall []struct {
	}
	schemaReturns struct {
		result1 string
	}
	schemaReturnsOnCall map[int]struct {
		result1 string
	}
	SetDrainedStub        func(bool) error
	setDrainedMutex       sync.RWMutex
	setDrainedArgsForCall []struct {
		arg1 bool
	}
	setDrainedReturns struct {
		result1 error
	}
	setDrainedReturnsOnCall map[int]struct {
		result1 error
	}
	SetInterceptibleStub        func(bool) error
	setInterceptibleMutex       sync.RWMutex
	setInterceptibleArgsForCall []struct {
		arg1 bool
	}
	setInterceptibleReturns struct {
		result1 error
	}
	setInterceptibleReturnsOnCall map[int]struct {
		result1 error
	}
	StartStub        func(atc.Plan) (bool, error)
	startMutex       sync.RWMutex
	startArgsForCall []struct {
		arg1 atc.Plan
	}
	startReturns struct {
		result1 bool
		result2 error
	}
	startReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	StartTimeStub        func() time.Time
	startTimeMutex       sync.RWMutex
	startTimeArgsForCall []struct {
	}
	startTimeReturns struct {
		result1 time.Time
	}
	startTimeReturnsOnCall map[int]struct {
		result1 time.Time
	}
	StatusStub        func() db.BuildStatus
	statusMutex       sync.RWMutex
	statusArgsForCall []struct {
	}
	statusReturns struct {
		result1 db.BuildStatus
	}
	statusReturnsOnCall map[int]struct {
		result1 db.BuildStatus
	}
	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
	}
	UseInputsStub        func([]db.BuildInput) error
	useInputsMutex       sync.RWMutex
	useInputsArgsForCall []struct {
		arg1 []db.BuildInput
	}
	useInputsReturns struct {
		result1 error
	}
	useInputsReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeBuild) AbortNotifier() (db.Notifier, error) {
	fake.abortNotifierMutex.Lock()
	ret, specificReturn := fake.abortNotifierReturnsOnCall[len(fake.abortNotifierArgsForCall)]
	fake.abortNotifierArgsForCall = append(fake.abortNotifierArgsForCall, struct {
	}{})
	fake.recordInvocation("AbortNotifier", []interface{}{})
	fake.abortNotifierMutex.Unlock()
	if fake.AbortNotifierStub != nil {
		return fake.AbortNotifierStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.abortNotifierReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeBuild) AbortNotifierCallCount() int {
	fake.abortNotifierMutex.RLock()
	defer fake.abortNotifierMutex.RUnlock()
	return len(fake.abortNotifierArgsForCall)
}

func (fake *FakeBuild) AbortNotifierCalls(stub func() (db.Notifier, error)) {
	fake.abortNotifierMutex.Lock()
	defer fake.abortNotifierMutex.Unlock()
	fake.AbortNotifierStub = stub
}

func (fake *FakeBuild) AbortNotifierReturns(result1 db.Notifier, result2 error) {
	fake.abortNotifierMutex.Lock()
	defer fake.abortNotifierMutex.Unlock()
	fake.AbortNotifierStub = nil
	fake.abortNotifierReturns = struct {
		result1 db.Notifier
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) AbortNotifierReturnsOnCall(i int, result1 db.Notifier, result2 error) {
	fake.abortNotifierMutex.Lock()
	defer fake.abortNotifierMutex.Unlock()
	fake.AbortNotifierStub = nil
	if fake.abortNotifierReturnsOnCall == nil {
		fake.abortNotifierReturnsOnCall = make(map[int]struct {
			result1 db.Notifier
			result2 error
		})
	}
	fake.abortNotifierReturnsOnCall[i] = struct {
		result1 db.Notifier
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) AcquireTrackingLock(arg1 lager.Logger, arg2 time.Duration) (lock.Lock, bool, error) {
	fake.acquireTrackingLockMutex.Lock()
	ret, specificReturn := fake.acquireTrackingLockReturnsOnCall[len(fake.acquireTrackingLockArgsForCall)]
	fake.acquireTrackingLockArgsForCall = append(fake.acquireTrackingLockArgsForCall, struct {
		arg1 lager.Logger
		arg2 time.Duration
	}{arg1, arg2})
	fake.recordInvocation("AcquireTrackingLock", []interface{}{arg1, arg2})
	fake.acquireTrackingLockMutex.Unlock()
	if fake.AcquireTrackingLockStub != nil {
		return fake.AcquireTrackingLockStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.acquireTrackingLockReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeBuild) AcquireTrackingLockCallCount() int {
	fake.acquireTrackingLockMutex.RLock()
	defer fake.acquireTrackingLockMutex.RUnlock()
	return len(fake.acquireTrackingLockArgsForCall)
}

func (fake *FakeBuild) AcquireTrackingLockCalls(stub func(lager.Logger, time.Duration) (lock.Lock, bool, error)) {
	fake.acquireTrackingLockMutex.Lock()
	defer fake.acquireTrackingLockMutex.Unlock()
	fake.AcquireTrackingLockStub = stub
}

func (fake *FakeBuild) AcquireTrackingLockArgsForCall(i int) (lager.Logger, time.Duration) {
	fake.acquireTrackingLockMutex.RLock()
	defer fake.acquireTrackingLockMutex.RUnlock()
	argsForCall := fake.acquireTrackingLockArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeBuild) AcquireTrackingLockReturns(result1 lock.Lock, result2 bool, result3 error) {
	fake.acquireTrackingLockMutex.Lock()
	defer fake.acquireTrackingLockMutex.Unlock()
	fake.AcquireTrackingLockStub = nil
	fake.acquireTrackingLockReturns = struct {
		result1 lock.Lock
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeBuild) AcquireTrackingLockReturnsOnCall(i int, result1 lock.Lock, result2 bool, result3 error) {
	fake.acquireTrackingLockMutex.Lock()
	defer fake.acquireTrackingLockMutex.Unlock()
	fake.AcquireTrackingLockStub = nil
	if fake.acquireTrackingLockReturnsOnCall == nil {
		fake.acquireTrackingLockReturnsOnCall = make(map[int]struct {
			result1 lock.Lock
			result2 bool
			result3 error
		})
	}
	fake.acquireTrackingLockReturnsOnCall[i] = struct {
		result1 lock.Lock
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeBuild) Artifact(arg1 int) (db.WorkerArtifact, error) {
	fake.artifactMutex.Lock()
	ret, specificReturn := fake.artifactReturnsOnCall[len(fake.artifactArgsForCall)]
	fake.artifactArgsForCall = append(fake.artifactArgsForCall, struct {
		arg1 int
	}{arg1})
	fake.recordInvocation("Artifact", []interface{}{arg1})
	fake.artifactMutex.Unlock()
	if fake.ArtifactStub != nil {
		return fake.ArtifactStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.artifactReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeBuild) ArtifactCallCount() int {
	fake.artifactMutex.RLock()
	defer fake.artifactMutex.RUnlock()
	return len(fake.artifactArgsForCall)
}

func (fake *FakeBuild) ArtifactCalls(stub func(int) (db.WorkerArtifact, error)) {
	fake.artifactMutex.Lock()
	defer fake.artifactMutex.Unlock()
	fake.ArtifactStub = stub
}

func (fake *FakeBuild) ArtifactArgsForCall(i int) int {
	fake.artifactMutex.RLock()
	defer fake.artifactMutex.RUnlock()
	argsForCall := fake.artifactArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeBuild) ArtifactReturns(result1 db.WorkerArtifact, result2 error) {
	fake.artifactMutex.Lock()
	defer fake.artifactMutex.Unlock()
	fake.ArtifactStub = nil
	fake.artifactReturns = struct {
		result1 db.WorkerArtifact
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) ArtifactReturnsOnCall(i int, result1 db.WorkerArtifact, result2 error) {
	fake.artifactMutex.Lock()
	defer fake.artifactMutex.Unlock()
	fake.ArtifactStub = nil
	if fake.artifactReturnsOnCall == nil {
		fake.artifactReturnsOnCall = make(map[int]struct {
			result1 db.WorkerArtifact
			result2 error
		})
	}
	fake.artifactReturnsOnCall[i] = struct {
		result1 db.WorkerArtifact
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) Artifacts() ([]db.WorkerArtifact, error) {
	fake.artifactsMutex.Lock()
	ret, specificReturn := fake.artifactsReturnsOnCall[len(fake.artifactsArgsForCall)]
	fake.artifactsArgsForCall = append(fake.artifactsArgsForCall, struct {
	}{})
	fake.recordInvocation("Artifacts", []interface{}{})
	fake.artifactsMutex.Unlock()
	if fake.ArtifactsStub != nil {
		return fake.ArtifactsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.artifactsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeBuild) ArtifactsCallCount() int {
	fake.artifactsMutex.RLock()
	defer fake.artifactsMutex.RUnlock()
	return len(fake.artifactsArgsForCall)
}

func (fake *FakeBuild) ArtifactsCalls(stub func() ([]db.WorkerArtifact, error)) {
	fake.artifactsMutex.Lock()
	defer fake.artifactsMutex.Unlock()
	fake.ArtifactsStub = stub
}

func (fake *FakeBuild) ArtifactsReturns(result1 []db.WorkerArtifact, result2 error) {
	fake.artifactsMutex.Lock()
	defer fake.artifactsMutex.Unlock()
	fake.ArtifactsStub = nil
	fake.artifactsReturns = struct {
		result1 []db.WorkerArtifact
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) ArtifactsReturnsOnCall(i int, result1 []db.WorkerArtifact, result2 error) {
	fake.artifactsMutex.Lock()
	defer fake.artifactsMutex.Unlock()
	fake.ArtifactsStub = nil
	if fake.artifactsReturnsOnCall == nil {
		fake.artifactsReturnsOnCall = make(map[int]struct {
			result1 []db.WorkerArtifact
			result2 error
		})
	}
	fake.artifactsReturnsOnCall[i] = struct {
		result1 []db.WorkerArtifact
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) CreateTime() time.Time {
	fake.createTimeMutex.Lock()
	ret, specificReturn := fake.createTimeReturnsOnCall[len(fake.createTimeArgsForCall)]
	fake.createTimeArgsForCall = append(fake.createTimeArgsForCall, struct {
	}{})
	fake.recordInvocation("CreateTime", []interface{}{})
	fake.createTimeMutex.Unlock()
	if fake.CreateTimeStub != nil {
		return fake.CreateTimeStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.createTimeReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) CreateTimeCallCount() int {
	fake.createTimeMutex.RLock()
	defer fake.createTimeMutex.RUnlock()
	return len(fake.createTimeArgsForCall)
}

func (fake *FakeBuild) CreateTimeCalls(stub func() time.Time) {
	fake.createTimeMutex.Lock()
	defer fake.createTimeMutex.Unlock()
	fake.CreateTimeStub = stub
}

func (fake *FakeBuild) CreateTimeReturns(result1 time.Time) {
	fake.createTimeMutex.Lock()
	defer fake.createTimeMutex.Unlock()
	fake.CreateTimeStub = nil
	fake.createTimeReturns = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeBuild) CreateTimeReturnsOnCall(i int, result1 time.Time) {
	fake.createTimeMutex.Lock()
	defer fake.createTimeMutex.Unlock()
	fake.CreateTimeStub = nil
	if fake.createTimeReturnsOnCall == nil {
		fake.createTimeReturnsOnCall = make(map[int]struct {
			result1 time.Time
		})
	}
	fake.createTimeReturnsOnCall[i] = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeBuild) Delete() (bool, error) {
	fake.deleteMutex.Lock()
	ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)]
	fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct {
	}{})
	fake.recordInvocation("Delete", []interface{}{})
	fake.deleteMutex.Unlock()
	if fake.DeleteStub != nil {
		return fake.DeleteStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeBuild) DeleteCallCount() int {
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	return len(fake.deleteArgsForCall)
}

func (fake *FakeBuild) DeleteCalls(stub func() (bool, error)) {
	fake.deleteMutex.Lock()
	defer fake.deleteMutex.Unlock()
	fake.DeleteStub = stub
}

func (fake *FakeBuild) DeleteReturns(result1 bool, result2 error) {
	fake.deleteMutex.Lock()
	defer fake.deleteMutex.Unlock()
	fake.DeleteStub = nil
	fake.deleteReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) DeleteReturnsOnCall(i int, result1 bool, result2 error) {
	fake.deleteMutex.Lock()
	defer fake.deleteMutex.Unlock()
	fake.DeleteStub = nil
	if fake.deleteReturnsOnCall == nil {
		fake.deleteReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.deleteReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) EndTime() time.Time {
	fake.endTimeMutex.Lock()
	ret, specificReturn := fake.endTimeReturnsOnCall[len(fake.endTimeArgsForCall)]
	fake.endTimeArgsForCall = append(fake.endTimeArgsForCall, struct {
	}{})
	fake.recordInvocation("EndTime", []interface{}{})
	fake.endTimeMutex.Unlock()
	if fake.EndTimeStub != nil {
		return fake.EndTimeStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.endTimeReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) EndTimeCallCount() int {
	fake.endTimeMutex.RLock()
	defer fake.endTimeMutex.RUnlock()
	return len(fake.endTimeArgsForCall)
}

func (fake *FakeBuild) EndTimeCalls(stub func() time.Time) {
	fake.endTimeMutex.Lock()
	defer fake.endTimeMutex.Unlock()
	fake.EndTimeStub = stub
}

func (fake *FakeBuild) EndTimeReturns(result1 time.Time) {
	fake.endTimeMutex.Lock()
	defer fake.endTimeMutex.Unlock()
	fake.EndTimeStub = nil
	fake.endTimeReturns = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeBuild) EndTimeReturnsOnCall(i int, result1 time.Time) {
	fake.endTimeMutex.Lock()
	defer fake.endTimeMutex.Unlock()
	fake.EndTimeStub = nil
	if fake.endTimeReturnsOnCall == nil {
		fake.endTimeReturnsOnCall = make(map[int]struct {
			result1 time.Time
		})
	}
	fake.endTimeReturnsOnCall[i] = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeBuild) Events(arg1 uint) (db.EventSource, error) {
	fake.eventsMutex.Lock()
	ret, specificReturn := fake.eventsReturnsOnCall[len(fake.eventsArgsForCall)]
	fake.eventsArgsForCall = append(fake.eventsArgsForCall, struct {
		arg1 uint
	}{arg1})
	fake.recordInvocation("Events", []interface{}{arg1})
	fake.eventsMutex.Unlock()
	if fake.EventsStub != nil {
		return fake.EventsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.eventsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeBuild) EventsCallCount() int {
	fake.eventsMutex.RLock()
	defer fake.eventsMutex.RUnlock()
	return len(fake.eventsArgsForCall)
}

func (fake *FakeBuild) EventsCalls(stub func(uint) (db.EventSource, error)) {
	fake.eventsMutex.Lock()
	defer fake.eventsMutex.Unlock()
	fake.EventsStub = stub
}

func (fake *FakeBuild) EventsArgsForCall(i int) uint {
	fake.eventsMutex.RLock()
	defer fake.eventsMutex.RUnlock()
	argsForCall := fake.eventsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeBuild) EventsReturns(result1 db.EventSource, result2 error) {
	fake.eventsMutex.Lock()
	defer fake.eventsMutex.Unlock()
	fake.EventsStub = nil
	fake.eventsReturns = struct {
		result1 db.EventSource
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) EventsReturnsOnCall(i int, result1 db.EventSource, result2 error) {
	fake.eventsMutex.Lock()
	defer fake.eventsMutex.Unlock()
	fake.EventsStub = nil
	if fake.eventsReturnsOnCall == nil {
		fake.eventsReturnsOnCall = make(map[int]struct {
			result1 db.EventSource
			result2 error
		})
	}
	fake.eventsReturnsOnCall[i] = struct {
		result1 db.EventSource
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) Finish(arg1 db.BuildStatus) error {
	fake.finishMutex.Lock()
	ret, specificReturn := fake.finishReturnsOnCall[len(fake.finishArgsForCall)]
	fake.finishArgsForCall = append(fake.finishArgsForCall, struct {
		arg1 db.BuildStatus
	}{arg1})
	fake.recordInvocation("Finish", []interface{}{arg1})
	fake.finishMutex.Unlock()
	if fake.FinishStub != nil {
		return fake.FinishStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.finishReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) FinishCallCount() int {
	fake.finishMutex.RLock()
	defer fake.finishMutex.RUnlock()
	return len(fake.finishArgsForCall)
}

func (fake *FakeBuild) FinishCalls(stub func(db.BuildStatus) error) {
	fake.finishMutex.Lock()
	defer fake.finishMutex.Unlock()
	fake.FinishStub = stub
}

func (fake *FakeBuild) FinishArgsForCall(i int) db.BuildStatus {
	fake.finishMutex.RLock()
	defer fake.finishMutex.RUnlock()
	argsForCall := fake.finishArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeBuild) FinishReturns(result1 error) {
	fake.finishMutex.Lock()
	defer fake.finishMutex.Unlock()
	fake.FinishStub = nil
	fake.finishReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) FinishReturnsOnCall(i int, result1 error) {
	fake.finishMutex.Lock()
	defer fake.finishMutex.Unlock()
	fake.FinishStub = nil
	if fake.finishReturnsOnCall == nil {
		fake.finishReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.finishReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) HasPlan() bool {
	fake.hasPlanMutex.Lock()
	ret, specificReturn := fake.hasPlanReturnsOnCall[len(fake.hasPlanArgsForCall)]
	fake.hasPlanArgsForCall = append(fake.hasPlanArgsForCall, struct {
	}{})
	fake.recordInvocation("HasPlan", []interface{}{})
	fake.hasPlanMutex.Unlock()
	if fake.HasPlanStub != nil {
		return fake.HasPlanStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.hasPlanReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) HasPlanCallCount() int {
	fake.hasPlanMutex.RLock()
	defer fake.hasPlanMutex.RUnlock()
	return len(fake.hasPlanArgsForCall)
}

func (fake *FakeBuild) HasPlanCalls(stub func() bool) {
	fake.hasPlanMutex.Lock()
	defer fake.hasPlanMutex.Unlock()
	fake.HasPlanStub = stub
}

func (fake *FakeBuild) HasPlanReturns(result1 bool) {
	fake.hasPlanMutex.Lock()
	defer fake.hasPlanMutex.Unlock()
	fake.HasPlanStub = nil
	fake.hasPlanReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) HasPlanReturnsOnCall(i int, result1 bool) {
	fake.hasPlanMutex.Lock()
	defer fake.hasPlanMutex.Unlock()
	fake.HasPlanStub = nil
	if fake.hasPlanReturnsOnCall == nil {
		fake.hasPlanReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasPlanReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

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

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

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

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

func (fake *FakeBuild) 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 *FakeBuild) Interceptible() (bool, error) {
	fake.interceptibleMutex.Lock()
	ret, specificReturn := fake.interceptibleReturnsOnCall[len(fake.interceptibleArgsForCall)]
	fake.interceptibleArgsForCall = append(fake.interceptibleArgsForCall, struct {
	}{})
	fake.recordInvocation("Interceptible", []interface{}{})
	fake.interceptibleMutex.Unlock()
	if fake.InterceptibleStub != nil {
		return fake.InterceptibleStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.interceptibleReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeBuild) InterceptibleCallCount() int {
	fake.interceptibleMutex.RLock()
	defer fake.interceptibleMutex.RUnlock()
	return len(fake.interceptibleArgsForCall)
}

func (fake *FakeBuild) InterceptibleCalls(stub func() (bool, error)) {
	fake.interceptibleMutex.Lock()
	defer fake.interceptibleMutex.Unlock()
	fake.InterceptibleStub = stub
}

func (fake *FakeBuild) InterceptibleReturns(result1 bool, result2 error) {
	fake.interceptibleMutex.Lock()
	defer fake.interceptibleMutex.Unlock()
	fake.InterceptibleStub = nil
	fake.interceptibleReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) InterceptibleReturnsOnCall(i int, result1 bool, result2 error) {
	fake.interceptibleMutex.Lock()
	defer fake.interceptibleMutex.Unlock()
	fake.InterceptibleStub = nil
	if fake.interceptibleReturnsOnCall == nil {
		fake.interceptibleReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.interceptibleReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) IsAborted() bool {
	fake.isAbortedMutex.Lock()
	ret, specificReturn := fake.isAbortedReturnsOnCall[len(fake.isAbortedArgsForCall)]
	fake.isAbortedArgsForCall = append(fake.isAbortedArgsForCall, struct {
	}{})
	fake.recordInvocation("IsAborted", []interface{}{})
	fake.isAbortedMutex.Unlock()
	if fake.IsAbortedStub != nil {
		return fake.IsAbortedStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isAbortedReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) IsAbortedCallCount() int {
	fake.isAbortedMutex.RLock()
	defer fake.isAbortedMutex.RUnlock()
	return len(fake.isAbortedArgsForCall)
}

func (fake *FakeBuild) IsAbortedCalls(stub func() bool) {
	fake.isAbortedMutex.Lock()
	defer fake.isAbortedMutex.Unlock()
	fake.IsAbortedStub = stub
}

func (fake *FakeBuild) IsAbortedReturns(result1 bool) {
	fake.isAbortedMutex.Lock()
	defer fake.isAbortedMutex.Unlock()
	fake.IsAbortedStub = nil
	fake.isAbortedReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsAbortedReturnsOnCall(i int, result1 bool) {
	fake.isAbortedMutex.Lock()
	defer fake.isAbortedMutex.Unlock()
	fake.IsAbortedStub = nil
	if fake.isAbortedReturnsOnCall == nil {
		fake.isAbortedReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isAbortedReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsCompleted() bool {
	fake.isCompletedMutex.Lock()
	ret, specificReturn := fake.isCompletedReturnsOnCall[len(fake.isCompletedArgsForCall)]
	fake.isCompletedArgsForCall = append(fake.isCompletedArgsForCall, struct {
	}{})
	fake.recordInvocation("IsCompleted", []interface{}{})
	fake.isCompletedMutex.Unlock()
	if fake.IsCompletedStub != nil {
		return fake.IsCompletedStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isCompletedReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) IsCompletedCallCount() int {
	fake.isCompletedMutex.RLock()
	defer fake.isCompletedMutex.RUnlock()
	return len(fake.isCompletedArgsForCall)
}

func (fake *FakeBuild) IsCompletedCalls(stub func() bool) {
	fake.isCompletedMutex.Lock()
	defer fake.isCompletedMutex.Unlock()
	fake.IsCompletedStub = stub
}

func (fake *FakeBuild) IsCompletedReturns(result1 bool) {
	fake.isCompletedMutex.Lock()
	defer fake.isCompletedMutex.Unlock()
	fake.IsCompletedStub = nil
	fake.isCompletedReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsCompletedReturnsOnCall(i int, result1 bool) {
	fake.isCompletedMutex.Lock()
	defer fake.isCompletedMutex.Unlock()
	fake.IsCompletedStub = nil
	if fake.isCompletedReturnsOnCall == nil {
		fake.isCompletedReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isCompletedReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsDrained() bool {
	fake.isDrainedMutex.Lock()
	ret, specificReturn := fake.isDrainedReturnsOnCall[len(fake.isDrainedArgsForCall)]
	fake.isDrainedArgsForCall = append(fake.isDrainedArgsForCall, struct {
	}{})
	fake.recordInvocation("IsDrained", []interface{}{})
	fake.isDrainedMutex.Unlock()
	if fake.IsDrainedStub != nil {
		return fake.IsDrainedStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isDrainedReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) IsDrainedCallCount() int {
	fake.isDrainedMutex.RLock()
	defer fake.isDrainedMutex.RUnlock()
	return len(fake.isDrainedArgsForCall)
}

func (fake *FakeBuild) IsDrainedCalls(stub func() bool) {
	fake.isDrainedMutex.Lock()
	defer fake.isDrainedMutex.Unlock()
	fake.IsDrainedStub = stub
}

func (fake *FakeBuild) IsDrainedReturns(result1 bool) {
	fake.isDrainedMutex.Lock()
	defer fake.isDrainedMutex.Unlock()
	fake.IsDrainedStub = nil
	fake.isDrainedReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsDrainedReturnsOnCall(i int, result1 bool) {
	fake.isDrainedMutex.Lock()
	defer fake.isDrainedMutex.Unlock()
	fake.IsDrainedStub = nil
	if fake.isDrainedReturnsOnCall == nil {
		fake.isDrainedReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isDrainedReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsManuallyTriggered() bool {
	fake.isManuallyTriggeredMutex.Lock()
	ret, specificReturn := fake.isManuallyTriggeredReturnsOnCall[len(fake.isManuallyTriggeredArgsForCall)]
	fake.isManuallyTriggeredArgsForCall = append(fake.isManuallyTriggeredArgsForCall, struct {
	}{})
	fake.recordInvocation("IsManuallyTriggered", []interface{}{})
	fake.isManuallyTriggeredMutex.Unlock()
	if fake.IsManuallyTriggeredStub != nil {
		return fake.IsManuallyTriggeredStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isManuallyTriggeredReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) IsManuallyTriggeredCallCount() int {
	fake.isManuallyTriggeredMutex.RLock()
	defer fake.isManuallyTriggeredMutex.RUnlock()
	return len(fake.isManuallyTriggeredArgsForCall)
}

func (fake *FakeBuild) IsManuallyTriggeredCalls(stub func() bool) {
	fake.isManuallyTriggeredMutex.Lock()
	defer fake.isManuallyTriggeredMutex.Unlock()
	fake.IsManuallyTriggeredStub = stub
}

func (fake *FakeBuild) IsManuallyTriggeredReturns(result1 bool) {
	fake.isManuallyTriggeredMutex.Lock()
	defer fake.isManuallyTriggeredMutex.Unlock()
	fake.IsManuallyTriggeredStub = nil
	fake.isManuallyTriggeredReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsManuallyTriggeredReturnsOnCall(i int, result1 bool) {
	fake.isManuallyTriggeredMutex.Lock()
	defer fake.isManuallyTriggeredMutex.Unlock()
	fake.IsManuallyTriggeredStub = nil
	if fake.isManuallyTriggeredReturnsOnCall == nil {
		fake.isManuallyTriggeredReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isManuallyTriggeredReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsRunning() bool {
	fake.isRunningMutex.Lock()
	ret, specificReturn := fake.isRunningReturnsOnCall[len(fake.isRunningArgsForCall)]
	fake.isRunningArgsForCall = append(fake.isRunningArgsForCall, struct {
	}{})
	fake.recordInvocation("IsRunning", []interface{}{})
	fake.isRunningMutex.Unlock()
	if fake.IsRunningStub != nil {
		return fake.IsRunningStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isRunningReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) IsRunningCallCount() int {
	fake.isRunningMutex.RLock()
	defer fake.isRunningMutex.RUnlock()
	return len(fake.isRunningArgsForCall)
}

func (fake *FakeBuild) IsRunningCalls(stub func() bool) {
	fake.isRunningMutex.Lock()
	defer fake.isRunningMutex.Unlock()
	fake.IsRunningStub = stub
}

func (fake *FakeBuild) IsRunningReturns(result1 bool) {
	fake.isRunningMutex.Lock()
	defer fake.isRunningMutex.Unlock()
	fake.IsRunningStub = nil
	fake.isRunningReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsRunningReturnsOnCall(i int, result1 bool) {
	fake.isRunningMutex.Lock()
	defer fake.isRunningMutex.Unlock()
	fake.IsRunningStub = nil
	if fake.isRunningReturnsOnCall == nil {
		fake.isRunningReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isRunningReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsScheduled() bool {
	fake.isScheduledMutex.Lock()
	ret, specificReturn := fake.isScheduledReturnsOnCall[len(fake.isScheduledArgsForCall)]
	fake.isScheduledArgsForCall = append(fake.isScheduledArgsForCall, struct {
	}{})
	fake.recordInvocation("IsScheduled", []interface{}{})
	fake.isScheduledMutex.Unlock()
	if fake.IsScheduledStub != nil {
		return fake.IsScheduledStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isScheduledReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) IsScheduledCallCount() int {
	fake.isScheduledMutex.RLock()
	defer fake.isScheduledMutex.RUnlock()
	return len(fake.isScheduledArgsForCall)
}

func (fake *FakeBuild) IsScheduledCalls(stub func() bool) {
	fake.isScheduledMutex.Lock()
	defer fake.isScheduledMutex.Unlock()
	fake.IsScheduledStub = stub
}

func (fake *FakeBuild) IsScheduledReturns(result1 bool) {
	fake.isScheduledMutex.Lock()
	defer fake.isScheduledMutex.Unlock()
	fake.IsScheduledStub = nil
	fake.isScheduledReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) IsScheduledReturnsOnCall(i int, result1 bool) {
	fake.isScheduledMutex.Lock()
	defer fake.isScheduledMutex.Unlock()
	fake.IsScheduledStub = nil
	if fake.isScheduledReturnsOnCall == nil {
		fake.isScheduledReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isScheduledReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeBuild) JobID() int {
	fake.jobIDMutex.Lock()
	ret, specificReturn := fake.jobIDReturnsOnCall[len(fake.jobIDArgsForCall)]
	fake.jobIDArgsForCall = append(fake.jobIDArgsForCall, struct {
	}{})
	fake.recordInvocation("JobID", []interface{}{})
	fake.jobIDMutex.Unlock()
	if fake.JobIDStub != nil {
		return fake.JobIDStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.jobIDReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) JobIDCallCount() int {
	fake.jobIDMutex.RLock()
	defer fake.jobIDMutex.RUnlock()
	return len(fake.jobIDArgsForCall)
}

func (fake *FakeBuild) JobIDCalls(stub func() int) {
	fake.jobIDMutex.Lock()
	defer fake.jobIDMutex.Unlock()
	fake.JobIDStub = stub
}

func (fake *FakeBuild) JobIDReturns(result1 int) {
	fake.jobIDMutex.Lock()
	defer fake.jobIDMutex.Unlock()
	fake.JobIDStub = nil
	fake.jobIDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeBuild) JobIDReturnsOnCall(i int, result1 int) {
	fake.jobIDMutex.Lock()
	defer fake.jobIDMutex.Unlock()
	fake.JobIDStub = nil
	if fake.jobIDReturnsOnCall == nil {
		fake.jobIDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.jobIDReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeBuild) JobName() string {
	fake.jobNameMutex.Lock()
	ret, specificReturn := fake.jobNameReturnsOnCall[len(fake.jobNameArgsForCall)]
	fake.jobNameArgsForCall = append(fake.jobNameArgsForCall, struct {
	}{})
	fake.recordInvocation("JobName", []interface{}{})
	fake.jobNameMutex.Unlock()
	if fake.JobNameStub != nil {
		return fake.JobNameStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.jobNameReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) JobNameCallCount() int {
	fake.jobNameMutex.RLock()
	defer fake.jobNameMutex.RUnlock()
	return len(fake.jobNameArgsForCall)
}

func (fake *FakeBuild) JobNameCalls(stub func() string) {
	fake.jobNameMutex.Lock()
	defer fake.jobNameMutex.Unlock()
	fake.JobNameStub = stub
}

func (fake *FakeBuild) JobNameReturns(result1 string) {
	fake.jobNameMutex.Lock()
	defer fake.jobNameMutex.Unlock()
	fake.JobNameStub = nil
	fake.jobNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeBuild) JobNameReturnsOnCall(i int, result1 string) {
	fake.jobNameMutex.Lock()
	defer fake.jobNameMutex.Unlock()
	fake.JobNameStub = nil
	if fake.jobNameReturnsOnCall == nil {
		fake.jobNameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.jobNameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeBuild) MarkAsAborted() error {
	fake.markAsAbortedMutex.Lock()
	ret, specificReturn := fake.markAsAbortedReturnsOnCall[len(fake.markAsAbortedArgsForCall)]
	fake.markAsAbortedArgsForCall = append(fake.markAsAbortedArgsForCall, struct {
	}{})
	fake.recordInvocation("MarkAsAborted", []interface{}{})
	fake.markAsAbortedMutex.Unlock()
	if fake.MarkAsAbortedStub != nil {
		return fake.MarkAsAbortedStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.markAsAbortedReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) MarkAsAbortedCallCount() int {
	fake.markAsAbortedMutex.RLock()
	defer fake.markAsAbortedMutex.RUnlock()
	return len(fake.markAsAbortedArgsForCall)
}

func (fake *FakeBuild) MarkAsAbortedCalls(stub func() error) {
	fake.markAsAbortedMutex.Lock()
	defer fake.markAsAbortedMutex.Unlock()
	fake.MarkAsAbortedStub = stub
}

func (fake *FakeBuild) MarkAsAbortedReturns(result1 error) {
	fake.markAsAbortedMutex.Lock()
	defer fake.markAsAbortedMutex.Unlock()
	fake.MarkAsAbortedStub = nil
	fake.markAsAbortedReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) MarkAsAbortedReturnsOnCall(i int, result1 error) {
	fake.markAsAbortedMutex.Lock()
	defer fake.markAsAbortedMutex.Unlock()
	fake.MarkAsAbortedStub = nil
	if fake.markAsAbortedReturnsOnCall == nil {
		fake.markAsAbortedReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.markAsAbortedReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

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

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

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

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

func (fake *FakeBuild) 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 *FakeBuild) Pipeline() (db.Pipeline, bool, error) {
	fake.pipelineMutex.Lock()
	ret, specificReturn := fake.pipelineReturnsOnCall[len(fake.pipelineArgsForCall)]
	fake.pipelineArgsForCall = append(fake.pipelineArgsForCall, struct {
	}{})
	fake.recordInvocation("Pipeline", []interface{}{})
	fake.pipelineMutex.Unlock()
	if fake.PipelineStub != nil {
		return fake.PipelineStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.pipelineReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

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

func (fake *FakeBuild) 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 *FakeBuild) 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 *FakeBuild) PipelineID() int {
	fake.pipelineIDMutex.Lock()
	ret, specificReturn := fake.pipelineIDReturnsOnCall[len(fake.pipelineIDArgsForCall)]
	fake.pipelineIDArgsForCall = append(fake.pipelineIDArgsForCall, struct {
	}{})
	fake.recordInvocation("PipelineID", []interface{}{})
	fake.pipelineIDMutex.Unlock()
	if fake.PipelineIDStub != nil {
		return fake.PipelineIDStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pipelineIDReturns
	return fakeReturns.result1
}

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

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

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

func (fake *FakeBuild) 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 *FakeBuild) PipelineName() string {
	fake.pipelineNameMutex.Lock()
	ret, specificReturn := fake.pipelineNameReturnsOnCall[len(fake.pipelineNameArgsForCall)]
	fake.pipelineNameArgsForCall = append(fake.pipelineNameArgsForCall, struct {
	}{})
	fake.recordInvocation("PipelineName", []interface{}{})
	fake.pipelineNameMutex.Unlock()
	if fake.PipelineNameStub != nil {
		return fake.PipelineNameStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pipelineNameReturns
	return fakeReturns.result1
}

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

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

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

func (fake *FakeBuild) 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 *FakeBuild) Preparation() (db.BuildPreparation, bool, error) {
	fake.preparationMutex.Lock()
	ret, specificReturn := fake.preparationReturnsOnCall[len(fake.preparationArgsForCall)]
	fake.preparationArgsForCall = append(fake.preparationArgsForCall, struct {
	}{})
	fake.recordInvocation("Preparation", []interface{}{})
	fake.preparationMutex.Unlock()
	if fake.PreparationStub != nil {
		return fake.PreparationStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.preparationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeBuild) PreparationCallCount() int {
	fake.preparationMutex.RLock()
	defer fake.preparationMutex.RUnlock()
	return len(fake.preparationArgsForCall)
}

func (fake *FakeBuild) PreparationCalls(stub func() (db.BuildPreparation, bool, error)) {
	fake.preparationMutex.Lock()
	defer fake.preparationMutex.Unlock()
	fake.PreparationStub = stub
}

func (fake *FakeBuild) PreparationReturns(result1 db.BuildPreparation, result2 bool, result3 error) {
	fake.preparationMutex.Lock()
	defer fake.preparationMutex.Unlock()
	fake.PreparationStub = nil
	fake.preparationReturns = struct {
		result1 db.BuildPreparation
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeBuild) PreparationReturnsOnCall(i int, result1 db.BuildPreparation, result2 bool, result3 error) {
	fake.preparationMutex.Lock()
	defer fake.preparationMutex.Unlock()
	fake.PreparationStub = nil
	if fake.preparationReturnsOnCall == nil {
		fake.preparationReturnsOnCall = make(map[int]struct {
			result1 db.BuildPreparation
			result2 bool
			result3 error
		})
	}
	fake.preparationReturnsOnCall[i] = struct {
		result1 db.BuildPreparation
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeBuild) PrivatePlan() atc.Plan {
	fake.privatePlanMutex.Lock()
	ret, specificReturn := fake.privatePlanReturnsOnCall[len(fake.privatePlanArgsForCall)]
	fake.privatePlanArgsForCall = append(fake.privatePlanArgsForCall, struct {
	}{})
	fake.recordInvocation("PrivatePlan", []interface{}{})
	fake.privatePlanMutex.Unlock()
	if fake.PrivatePlanStub != nil {
		return fake.PrivatePlanStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.privatePlanReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) PrivatePlanCallCount() int {
	fake.privatePlanMutex.RLock()
	defer fake.privatePlanMutex.RUnlock()
	return len(fake.privatePlanArgsForCall)
}

func (fake *FakeBuild) PrivatePlanCalls(stub func() atc.Plan) {
	fake.privatePlanMutex.Lock()
	defer fake.privatePlanMutex.Unlock()
	fake.PrivatePlanStub = stub
}

func (fake *FakeBuild) PrivatePlanReturns(result1 atc.Plan) {
	fake.privatePlanMutex.Lock()
	defer fake.privatePlanMutex.Unlock()
	fake.PrivatePlanStub = nil
	fake.privatePlanReturns = struct {
		result1 atc.Plan
	}{result1}
}

func (fake *FakeBuild) PrivatePlanReturnsOnCall(i int, result1 atc.Plan) {
	fake.privatePlanMutex.Lock()
	defer fake.privatePlanMutex.Unlock()
	fake.PrivatePlanStub = nil
	if fake.privatePlanReturnsOnCall == nil {
		fake.privatePlanReturnsOnCall = make(map[int]struct {
			result1 atc.Plan
		})
	}
	fake.privatePlanReturnsOnCall[i] = struct {
		result1 atc.Plan
	}{result1}
}

func (fake *FakeBuild) PublicPlan() *json.RawMessage {
	fake.publicPlanMutex.Lock()
	ret, specificReturn := fake.publicPlanReturnsOnCall[len(fake.publicPlanArgsForCall)]
	fake.publicPlanArgsForCall = append(fake.publicPlanArgsForCall, struct {
	}{})
	fake.recordInvocation("PublicPlan", []interface{}{})
	fake.publicPlanMutex.Unlock()
	if fake.PublicPlanStub != nil {
		return fake.PublicPlanStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.publicPlanReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) PublicPlanCallCount() int {
	fake.publicPlanMutex.RLock()
	defer fake.publicPlanMutex.RUnlock()
	return len(fake.publicPlanArgsForCall)
}

func (fake *FakeBuild) PublicPlanCalls(stub func() *json.RawMessage) {
	fake.publicPlanMutex.Lock()
	defer fake.publicPlanMutex.Unlock()
	fake.PublicPlanStub = stub
}

func (fake *FakeBuild) PublicPlanReturns(result1 *json.RawMessage) {
	fake.publicPlanMutex.Lock()
	defer fake.publicPlanMutex.Unlock()
	fake.PublicPlanStub = nil
	fake.publicPlanReturns = struct {
		result1 *json.RawMessage
	}{result1}
}

func (fake *FakeBuild) PublicPlanReturnsOnCall(i int, result1 *json.RawMessage) {
	fake.publicPlanMutex.Lock()
	defer fake.publicPlanMutex.Unlock()
	fake.PublicPlanStub = nil
	if fake.publicPlanReturnsOnCall == nil {
		fake.publicPlanReturnsOnCall = make(map[int]struct {
			result1 *json.RawMessage
		})
	}
	fake.publicPlanReturnsOnCall[i] = struct {
		result1 *json.RawMessage
	}{result1}
}

func (fake *FakeBuild) ReapTime() time.Time {
	fake.reapTimeMutex.Lock()
	ret, specificReturn := fake.reapTimeReturnsOnCall[len(fake.reapTimeArgsForCall)]
	fake.reapTimeArgsForCall = append(fake.reapTimeArgsForCall, struct {
	}{})
	fake.recordInvocation("ReapTime", []interface{}{})
	fake.reapTimeMutex.Unlock()
	if fake.ReapTimeStub != nil {
		return fake.ReapTimeStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.reapTimeReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) ReapTimeCallCount() int {
	fake.reapTimeMutex.RLock()
	defer fake.reapTimeMutex.RUnlock()
	return len(fake.reapTimeArgsForCall)
}

func (fake *FakeBuild) ReapTimeCalls(stub func() time.Time) {
	fake.reapTimeMutex.Lock()
	defer fake.reapTimeMutex.Unlock()
	fake.ReapTimeStub = stub
}

func (fake *FakeBuild) ReapTimeReturns(result1 time.Time) {
	fake.reapTimeMutex.Lock()
	defer fake.reapTimeMutex.Unlock()
	fake.ReapTimeStub = nil
	fake.reapTimeReturns = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeBuild) ReapTimeReturnsOnCall(i int, result1 time.Time) {
	fake.reapTimeMutex.Lock()
	defer fake.reapTimeMutex.Unlock()
	fake.ReapTimeStub = nil
	if fake.reapTimeReturnsOnCall == nil {
		fake.reapTimeReturnsOnCall = make(map[int]struct {
			result1 time.Time
		})
	}
	fake.reapTimeReturnsOnCall[i] = struct {
		result1 time.Time
	}{result1}
}

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

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

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

func (fake *FakeBuild) 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 *FakeBuild) 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 *FakeBuild) Resources() ([]db.BuildInput, []db.BuildOutput, error) {
	fake.resourcesMutex.Lock()
	ret, specificReturn := fake.resourcesReturnsOnCall[len(fake.resourcesArgsForCall)]
	fake.resourcesArgsForCall = append(fake.resourcesArgsForCall, struct {
	}{})
	fake.recordInvocation("Resources", []interface{}{})
	fake.resourcesMutex.Unlock()
	if fake.ResourcesStub != nil {
		return fake.ResourcesStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.resourcesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeBuild) ResourcesCallCount() int {
	fake.resourcesMutex.RLock()
	defer fake.resourcesMutex.RUnlock()
	return len(fake.resourcesArgsForCall)
}

func (fake *FakeBuild) ResourcesCalls(stub func() ([]db.BuildInput, []db.BuildOutput, error)) {
	fake.resourcesMutex.Lock()
	defer fake.resourcesMutex.Unlock()
	fake.ResourcesStub = stub
}

func (fake *FakeBuild) ResourcesReturns(result1 []db.BuildInput, result2 []db.BuildOutput, result3 error) {
	fake.resourcesMutex.Lock()
	defer fake.resourcesMutex.Unlock()
	fake.ResourcesStub = nil
	fake.resourcesReturns = struct {
		result1 []db.BuildInput
		result2 []db.BuildOutput
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeBuild) ResourcesReturnsOnCall(i int, result1 []db.BuildInput, result2 []db.BuildOutput, result3 error) {
	fake.resourcesMutex.Lock()
	defer fake.resourcesMutex.Unlock()
	fake.ResourcesStub = nil
	if fake.resourcesReturnsOnCall == nil {
		fake.resourcesReturnsOnCall = make(map[int]struct {
			result1 []db.BuildInput
			result2 []db.BuildOutput
			result3 error
		})
	}
	fake.resourcesReturnsOnCall[i] = struct {
		result1 []db.BuildInput
		result2 []db.BuildOutput
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeBuild) SaveEvent(arg1 atc.Event) error {
	fake.saveEventMutex.Lock()
	ret, specificReturn := fake.saveEventReturnsOnCall[len(fake.saveEventArgsForCall)]
	fake.saveEventArgsForCall = append(fake.saveEventArgsForCall, struct {
		arg1 atc.Event
	}{arg1})
	fake.recordInvocation("SaveEvent", []interface{}{arg1})
	fake.saveEventMutex.Unlock()
	if fake.SaveEventStub != nil {
		return fake.SaveEventStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.saveEventReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) SaveEventCallCount() int {
	fake.saveEventMutex.RLock()
	defer fake.saveEventMutex.RUnlock()
	return len(fake.saveEventArgsForCall)
}

func (fake *FakeBuild) SaveEventCalls(stub func(atc.Event) error) {
	fake.saveEventMutex.Lock()
	defer fake.saveEventMutex.Unlock()
	fake.SaveEventStub = stub
}

func (fake *FakeBuild) SaveEventArgsForCall(i int) atc.Event {
	fake.saveEventMutex.RLock()
	defer fake.saveEventMutex.RUnlock()
	argsForCall := fake.saveEventArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeBuild) SaveEventReturns(result1 error) {
	fake.saveEventMutex.Lock()
	defer fake.saveEventMutex.Unlock()
	fake.SaveEventStub = nil
	fake.saveEventReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) SaveEventReturnsOnCall(i int, result1 error) {
	fake.saveEventMutex.Lock()
	defer fake.saveEventMutex.Unlock()
	fake.SaveEventStub = nil
	if fake.saveEventReturnsOnCall == nil {
		fake.saveEventReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.saveEventReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) SaveImageResourceVersion(arg1 db.UsedResourceCache) error {
	fake.saveImageResourceVersionMutex.Lock()
	ret, specificReturn := fake.saveImageResourceVersionReturnsOnCall[len(fake.saveImageResourceVersionArgsForCall)]
	fake.saveImageResourceVersionArgsForCall = append(fake.saveImageResourceVersionArgsForCall, struct {
		arg1 db.UsedResourceCache
	}{arg1})
	fake.recordInvocation("SaveImageResourceVersion", []interface{}{arg1})
	fake.saveImageResourceVersionMutex.Unlock()
	if fake.SaveImageResourceVersionStub != nil {
		return fake.SaveImageResourceVersionStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.saveImageResourceVersionReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) SaveImageResourceVersionCallCount() int {
	fake.saveImageResourceVersionMutex.RLock()
	defer fake.saveImageResourceVersionMutex.RUnlock()
	return len(fake.saveImageResourceVersionArgsForCall)
}

func (fake *FakeBuild) SaveImageResourceVersionCalls(stub func(db.UsedResourceCache) error) {
	fake.saveImageResourceVersionMutex.Lock()
	defer fake.saveImageResourceVersionMutex.Unlock()
	fake.SaveImageResourceVersionStub = stub
}

func (fake *FakeBuild) SaveImageResourceVersionArgsForCall(i int) db.UsedResourceCache {
	fake.saveImageResourceVersionMutex.RLock()
	defer fake.saveImageResourceVersionMutex.RUnlock()
	argsForCall := fake.saveImageResourceVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeBuild) SaveImageResourceVersionReturns(result1 error) {
	fake.saveImageResourceVersionMutex.Lock()
	defer fake.saveImageResourceVersionMutex.Unlock()
	fake.SaveImageResourceVersionStub = nil
	fake.saveImageResourceVersionReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) SaveImageResourceVersionReturnsOnCall(i int, result1 error) {
	fake.saveImageResourceVersionMutex.Lock()
	defer fake.saveImageResourceVersionMutex.Unlock()
	fake.SaveImageResourceVersionStub = nil
	if fake.saveImageResourceVersionReturnsOnCall == nil {
		fake.saveImageResourceVersionReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.saveImageResourceVersionReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) SaveOutput(arg1 string, arg2 atc.Source, arg3 atc.VersionedResourceTypes, arg4 atc.Version, arg5 db.ResourceConfigMetadataFields, arg6 string, arg7 string) error {
	fake.saveOutputMutex.Lock()
	ret, specificReturn := fake.saveOutputReturnsOnCall[len(fake.saveOutputArgsForCall)]
	fake.saveOutputArgsForCall = append(fake.saveOutputArgsForCall, struct {
		arg1 string
		arg2 atc.Source
		arg3 atc.VersionedResourceTypes
		arg4 atc.Version
		arg5 db.ResourceConfigMetadataFields
		arg6 string
		arg7 string
	}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
	fake.recordInvocation("SaveOutput", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
	fake.saveOutputMutex.Unlock()
	if fake.SaveOutputStub != nil {
		return fake.SaveOutputStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.saveOutputReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) SaveOutputCallCount() int {
	fake.saveOutputMutex.RLock()
	defer fake.saveOutputMutex.RUnlock()
	return len(fake.saveOutputArgsForCall)
}

func (fake *FakeBuild) SaveOutputCalls(stub func(string, atc.Source, atc.VersionedResourceTypes, atc.Version, db.ResourceConfigMetadataFields, string, string) error) {
	fake.saveOutputMutex.Lock()
	defer fake.saveOutputMutex.Unlock()
	fake.SaveOutputStub = stub
}

func (fake *FakeBuild) SaveOutputArgsForCall(i int) (string, atc.Source, atc.VersionedResourceTypes, atc.Version, db.ResourceConfigMetadataFields, string, string) {
	fake.saveOutputMutex.RLock()
	defer fake.saveOutputMutex.RUnlock()
	argsForCall := fake.saveOutputArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7
}

func (fake *FakeBuild) SaveOutputReturns(result1 error) {
	fake.saveOutputMutex.Lock()
	defer fake.saveOutputMutex.Unlock()
	fake.SaveOutputStub = nil
	fake.saveOutputReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) SaveOutputReturnsOnCall(i int, result1 error) {
	fake.saveOutputMutex.Lock()
	defer fake.saveOutputMutex.Unlock()
	fake.SaveOutputStub = nil
	if fake.saveOutputReturnsOnCall == nil {
		fake.saveOutputReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.saveOutputReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) Schedule() (bool, error) {
	fake.scheduleMutex.Lock()
	ret, specificReturn := fake.scheduleReturnsOnCall[len(fake.scheduleArgsForCall)]
	fake.scheduleArgsForCall = append(fake.scheduleArgsForCall, struct {
	}{})
	fake.recordInvocation("Schedule", []interface{}{})
	fake.scheduleMutex.Unlock()
	if fake.ScheduleStub != nil {
		return fake.ScheduleStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.scheduleReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeBuild) ScheduleCallCount() int {
	fake.scheduleMutex.RLock()
	defer fake.scheduleMutex.RUnlock()
	return len(fake.scheduleArgsForCall)
}

func (fake *FakeBuild) ScheduleCalls(stub func() (bool, error)) {
	fake.scheduleMutex.Lock()
	defer fake.scheduleMutex.Unlock()
	fake.ScheduleStub = stub
}

func (fake *FakeBuild) ScheduleReturns(result1 bool, result2 error) {
	fake.scheduleMutex.Lock()
	defer fake.scheduleMutex.Unlock()
	fake.ScheduleStub = nil
	fake.scheduleReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) ScheduleReturnsOnCall(i int, result1 bool, result2 error) {
	fake.scheduleMutex.Lock()
	defer fake.scheduleMutex.Unlock()
	fake.ScheduleStub = nil
	if fake.scheduleReturnsOnCall == nil {
		fake.scheduleReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.scheduleReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) Schema() string {
	fake.schemaMutex.Lock()
	ret, specificReturn := fake.schemaReturnsOnCall[len(fake.schemaArgsForCall)]
	fake.schemaArgsForCall = append(fake.schemaArgsForCall, struct {
	}{})
	fake.recordInvocation("Schema", []interface{}{})
	fake.schemaMutex.Unlock()
	if fake.SchemaStub != nil {
		return fake.SchemaStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.schemaReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) SchemaCallCount() int {
	fake.schemaMutex.RLock()
	defer fake.schemaMutex.RUnlock()
	return len(fake.schemaArgsForCall)
}

func (fake *FakeBuild) SchemaCalls(stub func() string) {
	fake.schemaMutex.Lock()
	defer fake.schemaMutex.Unlock()
	fake.SchemaStub = stub
}

func (fake *FakeBuild) SchemaReturns(result1 string) {
	fake.schemaMutex.Lock()
	defer fake.schemaMutex.Unlock()
	fake.SchemaStub = nil
	fake.schemaReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeBuild) SchemaReturnsOnCall(i int, result1 string) {
	fake.schemaMutex.Lock()
	defer fake.schemaMutex.Unlock()
	fake.SchemaStub = nil
	if fake.schemaReturnsOnCall == nil {
		fake.schemaReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.schemaReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeBuild) SetDrained(arg1 bool) error {
	fake.setDrainedMutex.Lock()
	ret, specificReturn := fake.setDrainedReturnsOnCall[len(fake.setDrainedArgsForCall)]
	fake.setDrainedArgsForCall = append(fake.setDrainedArgsForCall, struct {
		arg1 bool
	}{arg1})
	fake.recordInvocation("SetDrained", []interface{}{arg1})
	fake.setDrainedMutex.Unlock()
	if fake.SetDrainedStub != nil {
		return fake.SetDrainedStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.setDrainedReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) SetDrainedCallCount() int {
	fake.setDrainedMutex.RLock()
	defer fake.setDrainedMutex.RUnlock()
	return len(fake.setDrainedArgsForCall)
}

func (fake *FakeBuild) SetDrainedCalls(stub func(bool) error) {
	fake.setDrainedMutex.Lock()
	defer fake.setDrainedMutex.Unlock()
	fake.SetDrainedStub = stub
}

func (fake *FakeBuild) SetDrainedArgsForCall(i int) bool {
	fake.setDrainedMutex.RLock()
	defer fake.setDrainedMutex.RUnlock()
	argsForCall := fake.setDrainedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeBuild) SetDrainedReturns(result1 error) {
	fake.setDrainedMutex.Lock()
	defer fake.setDrainedMutex.Unlock()
	fake.SetDrainedStub = nil
	fake.setDrainedReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) SetDrainedReturnsOnCall(i int, result1 error) {
	fake.setDrainedMutex.Lock()
	defer fake.setDrainedMutex.Unlock()
	fake.SetDrainedStub = nil
	if fake.setDrainedReturnsOnCall == nil {
		fake.setDrainedReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setDrainedReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) SetInterceptible(arg1 bool) error {
	fake.setInterceptibleMutex.Lock()
	ret, specificReturn := fake.setInterceptibleReturnsOnCall[len(fake.setInterceptibleArgsForCall)]
	fake.setInterceptibleArgsForCall = append(fake.setInterceptibleArgsForCall, struct {
		arg1 bool
	}{arg1})
	fake.recordInvocation("SetInterceptible", []interface{}{arg1})
	fake.setInterceptibleMutex.Unlock()
	if fake.SetInterceptibleStub != nil {
		return fake.SetInterceptibleStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.setInterceptibleReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) SetInterceptibleCallCount() int {
	fake.setInterceptibleMutex.RLock()
	defer fake.setInterceptibleMutex.RUnlock()
	return len(fake.setInterceptibleArgsForCall)
}

func (fake *FakeBuild) SetInterceptibleCalls(stub func(bool) error) {
	fake.setInterceptibleMutex.Lock()
	defer fake.setInterceptibleMutex.Unlock()
	fake.SetInterceptibleStub = stub
}

func (fake *FakeBuild) SetInterceptibleArgsForCall(i int) bool {
	fake.setInterceptibleMutex.RLock()
	defer fake.setInterceptibleMutex.RUnlock()
	argsForCall := fake.setInterceptibleArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeBuild) SetInterceptibleReturns(result1 error) {
	fake.setInterceptibleMutex.Lock()
	defer fake.setInterceptibleMutex.Unlock()
	fake.SetInterceptibleStub = nil
	fake.setInterceptibleReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) SetInterceptibleReturnsOnCall(i int, result1 error) {
	fake.setInterceptibleMutex.Lock()
	defer fake.setInterceptibleMutex.Unlock()
	fake.SetInterceptibleStub = nil
	if fake.setInterceptibleReturnsOnCall == nil {
		fake.setInterceptibleReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setInterceptibleReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) Start(arg1 atc.Plan) (bool, error) {
	fake.startMutex.Lock()
	ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)]
	fake.startArgsForCall = append(fake.startArgsForCall, struct {
		arg1 atc.Plan
	}{arg1})
	fake.recordInvocation("Start", []interface{}{arg1})
	fake.startMutex.Unlock()
	if fake.StartStub != nil {
		return fake.StartStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.startReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeBuild) StartCallCount() int {
	fake.startMutex.RLock()
	defer fake.startMutex.RUnlock()
	return len(fake.startArgsForCall)
}

func (fake *FakeBuild) StartCalls(stub func(atc.Plan) (bool, error)) {
	fake.startMutex.Lock()
	defer fake.startMutex.Unlock()
	fake.StartStub = stub
}

func (fake *FakeBuild) StartArgsForCall(i int) atc.Plan {
	fake.startMutex.RLock()
	defer fake.startMutex.RUnlock()
	argsForCall := fake.startArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeBuild) StartReturns(result1 bool, result2 error) {
	fake.startMutex.Lock()
	defer fake.startMutex.Unlock()
	fake.StartStub = nil
	fake.startReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) StartReturnsOnCall(i int, result1 bool, result2 error) {
	fake.startMutex.Lock()
	defer fake.startMutex.Unlock()
	fake.StartStub = nil
	if fake.startReturnsOnCall == nil {
		fake.startReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.startReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeBuild) StartTime() time.Time {
	fake.startTimeMutex.Lock()
	ret, specificReturn := fake.startTimeReturnsOnCall[len(fake.startTimeArgsForCall)]
	fake.startTimeArgsForCall = append(fake.startTimeArgsForCall, struct {
	}{})
	fake.recordInvocation("StartTime", []interface{}{})
	fake.startTimeMutex.Unlock()
	if fake.StartTimeStub != nil {
		return fake.StartTimeStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.startTimeReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) StartTimeCallCount() int {
	fake.startTimeMutex.RLock()
	defer fake.startTimeMutex.RUnlock()
	return len(fake.startTimeArgsForCall)
}

func (fake *FakeBuild) StartTimeCalls(stub func() time.Time) {
	fake.startTimeMutex.Lock()
	defer fake.startTimeMutex.Unlock()
	fake.StartTimeStub = stub
}

func (fake *FakeBuild) StartTimeReturns(result1 time.Time) {
	fake.startTimeMutex.Lock()
	defer fake.startTimeMutex.Unlock()
	fake.StartTimeStub = nil
	fake.startTimeReturns = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeBuild) StartTimeReturnsOnCall(i int, result1 time.Time) {
	fake.startTimeMutex.Lock()
	defer fake.startTimeMutex.Unlock()
	fake.StartTimeStub = nil
	if fake.startTimeReturnsOnCall == nil {
		fake.startTimeReturnsOnCall = make(map[int]struct {
			result1 time.Time
		})
	}
	fake.startTimeReturnsOnCall[i] = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeBuild) Status() db.BuildStatus {
	fake.statusMutex.Lock()
	ret, specificReturn := fake.statusReturnsOnCall[len(fake.statusArgsForCall)]
	fake.statusArgsForCall = append(fake.statusArgsForCall, struct {
	}{})
	fake.recordInvocation("Status", []interface{}{})
	fake.statusMutex.Unlock()
	if fake.StatusStub != nil {
		return fake.StatusStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.statusReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) StatusCallCount() int {
	fake.statusMutex.RLock()
	defer fake.statusMutex.RUnlock()
	return len(fake.statusArgsForCall)
}

func (fake *FakeBuild) StatusCalls(stub func() db.BuildStatus) {
	fake.statusMutex.Lock()
	defer fake.statusMutex.Unlock()
	fake.StatusStub = stub
}

func (fake *FakeBuild) StatusReturns(result1 db.BuildStatus) {
	fake.statusMutex.Lock()
	defer fake.statusMutex.Unlock()
	fake.StatusStub = nil
	fake.statusReturns = struct {
		result1 db.BuildStatus
	}{result1}
}

func (fake *FakeBuild) StatusReturnsOnCall(i int, result1 db.BuildStatus) {
	fake.statusMutex.Lock()
	defer fake.statusMutex.Unlock()
	fake.StatusStub = nil
	if fake.statusReturnsOnCall == nil {
		fake.statusReturnsOnCall = make(map[int]struct {
			result1 db.BuildStatus
		})
	}
	fake.statusReturnsOnCall[i] = struct {
		result1 db.BuildStatus
	}{result1}
}

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

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

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

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

func (fake *FakeBuild) 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 *FakeBuild) TeamName() string {
	fake.teamNameMutex.Lock()
	ret, specificReturn := fake.teamNameReturnsOnCall[len(fake.teamNameArgsForCall)]
	fake.teamNameArgsForCall = append(fake.teamNameArgsForCall, struct {
	}{})
	fake.recordInvocation("TeamName", []interface{}{})
	fake.teamNameMutex.Unlock()
	if fake.TeamNameStub != nil {
		return fake.TeamNameStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.teamNameReturns
	return fakeReturns.result1
}

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

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

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

func (fake *FakeBuild) 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 *FakeBuild) UseInputs(arg1 []db.BuildInput) error {
	var arg1Copy []db.BuildInput
	if arg1 != nil {
		arg1Copy = make([]db.BuildInput, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.useInputsMutex.Lock()
	ret, specificReturn := fake.useInputsReturnsOnCall[len(fake.useInputsArgsForCall)]
	fake.useInputsArgsForCall = append(fake.useInputsArgsForCall, struct {
		arg1 []db.BuildInput
	}{arg1Copy})
	fake.recordInvocation("UseInputs", []interface{}{arg1Copy})
	fake.useInputsMutex.Unlock()
	if fake.UseInputsStub != nil {
		return fake.UseInputsStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.useInputsReturns
	return fakeReturns.result1
}

func (fake *FakeBuild) UseInputsCallCount() int {
	fake.useInputsMutex.RLock()
	defer fake.useInputsMutex.RUnlock()
	return len(fake.useInputsArgsForCall)
}

func (fake *FakeBuild) UseInputsCalls(stub func([]db.BuildInput) error) {
	fake.useInputsMutex.Lock()
	defer fake.useInputsMutex.Unlock()
	fake.UseInputsStub = stub
}

func (fake *FakeBuild) UseInputsArgsForCall(i int) []db.BuildInput {
	fake.useInputsMutex.RLock()
	defer fake.useInputsMutex.RUnlock()
	argsForCall := fake.useInputsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeBuild) UseInputsReturns(result1 error) {
	fake.useInputsMutex.Lock()
	defer fake.useInputsMutex.Unlock()
	fake.UseInputsStub = nil
	fake.useInputsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) UseInputsReturnsOnCall(i int, result1 error) {
	fake.useInputsMutex.Lock()
	defer fake.useInputsMutex.Unlock()
	fake.UseInputsStub = nil
	if fake.useInputsReturnsOnCall == nil {
		fake.useInputsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.useInputsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeBuild) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.abortNotifierMutex.RLock()
	defer fake.abortNotifierMutex.RUnlock()
	fake.acquireTrackingLockMutex.RLock()
	defer fake.acquireTrackingLockMutex.RUnlock()
	fake.artifactMutex.RLock()
	defer fake.artifactMutex.RUnlock()
	fake.artifactsMutex.RLock()
	defer fake.artifactsMutex.RUnlock()
	fake.createTimeMutex.RLock()
	defer fake.createTimeMutex.RUnlock()
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	fake.endTimeMutex.RLock()
	defer fake.endTimeMutex.RUnlock()
	fake.eventsMutex.RLock()
	defer fake.eventsMutex.RUnlock()
	fake.finishMutex.RLock()
	defer fake.finishMutex.RUnlock()
	fake.hasPlanMutex.RLock()
	defer fake.hasPlanMutex.RUnlock()
	fake.iDMutex.RLock()
	defer fake.iDMutex.RUnlock()
	fake.interceptibleMutex.RLock()
	defer fake.interceptibleMutex.RUnlock()
	fake.isAbortedMutex.RLock()
	defer fake.isAbortedMutex.RUnlock()
	fake.isCompletedMutex.RLock()
	defer fake.isCompletedMutex.RUnlock()
	fake.isDrainedMutex.RLock()
	defer fake.isDrainedMutex.RUnlock()
	fake.isManuallyTriggeredMutex.RLock()
	defer fake.isManuallyTriggeredMutex.RUnlock()
	fake.isRunningMutex.RLock()
	defer fake.isRunningMutex.RUnlock()
	fake.isScheduledMutex.RLock()
	defer fake.isScheduledMutex.RUnlock()
	fake.jobIDMutex.RLock()
	defer fake.jobIDMutex.RUnlock()
	fake.jobNameMutex.RLock()
	defer fake.jobNameMutex.RUnlock()
	fake.markAsAbortedMutex.RLock()
	defer fake.markAsAbortedMutex.RUnlock()
	fake.nameMutex.RLock()
	defer fake.nameMutex.RUnlock()
	fake.pipelineMutex.RLock()
	defer fake.pipelineMutex.RUnlock()
	fake.pipelineIDMutex.RLock()
	defer fake.pipelineIDMutex.RUnlock()
	fake.pipelineNameMutex.RLock()
	defer fake.pipelineNameMutex.RUnlock()
	fake.preparationMutex.RLock()
	defer fake.preparationMutex.RUnlock()
	fake.privatePlanMutex.RLock()
	defer fake.privatePlanMutex.RUnlock()
	fake.publicPlanMutex.RLock()
	defer fake.publicPlanMutex.RUnlock()
	fake.reapTimeMutex.RLock()
	defer fake.reapTimeMutex.RUnlock()
	fake.reloadMutex.RLock()
	defer fake.reloadMutex.RUnlock()
	fake.resourcesMutex.RLock()
	defer fake.resourcesMutex.RUnlock()
	fake.saveEventMutex.RLock()
	defer fake.saveEventMutex.RUnlock()
	fake.saveImageResourceVersionMutex.RLock()
	defer fake.saveImageResourceVersionMutex.RUnlock()
	fake.saveOutputMutex.RLock()
	defer fake.saveOutputMutex.RUnlock()
	fake.scheduleMutex.RLock()
	defer fake.scheduleMutex.RUnlock()
	fake.schemaMutex.RLock()
	defer fake.schemaMutex.RUnlock()
	fake.setDrainedMutex.RLock()
	defer fake.setDrainedMutex.RUnlock()
	fake.setInterceptibleMutex.RLock()
	defer fake.setInterceptibleMutex.RUnlock()
	fake.startMutex.RLock()
	defer fake.startMutex.RUnlock()
	fake.startTimeMutex.RLock()
	defer fake.startTimeMutex.RUnlock()
	fake.statusMutex.RLock()
	defer fake.statusMutex.RUnlock()
	fake.teamIDMutex.RLock()
	defer fake.teamIDMutex.RUnlock()
	fake.teamNameMutex.RLock()
	defer fake.teamNameMutex.RUnlock()
	fake.useInputsMutex.RLock()
	defer fake.useInputsMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeBuild) 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.Build = new(FakeBuild)