fake_lrpdb.go

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

import (
	"context"
	"sync"

	"code.cloudfoundry.org/bbs/db"
	"code.cloudfoundry.org/bbs/models"
	"code.cloudfoundry.org/lager"
)

type FakeLRPDB struct {
	ActualLRPsStub        func(context.Context, lager.Logger, models.ActualLRPFilter) ([]*models.ActualLRP, error)
	actualLRPsMutex       sync.RWMutex
	actualLRPsArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 models.ActualLRPFilter
	}
	actualLRPsReturns struct {
		result1 []*models.ActualLRP
		result2 error
	}
	actualLRPsReturnsOnCall map[int]struct {
		result1 []*models.ActualLRP
		result2 error
	}
	ChangeActualLRPPresenceStub        func(context.Context, lager.Logger, *models.ActualLRPKey, models.ActualLRP_Presence, models.ActualLRP_Presence) (*models.ActualLRP, *models.ActualLRP, error)
	changeActualLRPPresenceMutex       sync.RWMutex
	changeActualLRPPresenceArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
		arg4 models.ActualLRP_Presence
		arg5 models.ActualLRP_Presence
	}
	changeActualLRPPresenceReturns struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	changeActualLRPPresenceReturnsOnCall map[int]struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	ClaimActualLRPStub        func(context.Context, lager.Logger, string, int32, *models.ActualLRPInstanceKey) (*models.ActualLRP, *models.ActualLRP, error)
	claimActualLRPMutex       sync.RWMutex
	claimActualLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
		arg4 int32
		arg5 *models.ActualLRPInstanceKey
	}
	claimActualLRPReturns struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	claimActualLRPReturnsOnCall map[int]struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	ConvergeLRPsStub        func(context.Context, lager.Logger, models.CellSet) db.ConvergenceResult
	convergeLRPsMutex       sync.RWMutex
	convergeLRPsArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 models.CellSet
	}
	convergeLRPsReturns struct {
		result1 db.ConvergenceResult
	}
	convergeLRPsReturnsOnCall map[int]struct {
		result1 db.ConvergenceResult
	}
	CountActualLRPsByStateStub        func(context.Context, lager.Logger) (int, int, int, int, int)
	countActualLRPsByStateMutex       sync.RWMutex
	countActualLRPsByStateArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
	}
	countActualLRPsByStateReturns struct {
		result1 int
		result2 int
		result3 int
		result4 int
		result5 int
	}
	countActualLRPsByStateReturnsOnCall map[int]struct {
		result1 int
		result2 int
		result3 int
		result4 int
		result5 int
	}
	CountDesiredInstancesStub        func(context.Context, lager.Logger) int
	countDesiredInstancesMutex       sync.RWMutex
	countDesiredInstancesArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
	}
	countDesiredInstancesReturns struct {
		result1 int
	}
	countDesiredInstancesReturnsOnCall map[int]struct {
		result1 int
	}
	CrashActualLRPStub        func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, string) (*models.ActualLRP, *models.ActualLRP, bool, error)
	crashActualLRPMutex       sync.RWMutex
	crashActualLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
		arg4 *models.ActualLRPInstanceKey
		arg5 string
	}
	crashActualLRPReturns struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 bool
		result4 error
	}
	crashActualLRPReturnsOnCall map[int]struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 bool
		result4 error
	}
	CreateUnclaimedActualLRPStub        func(context.Context, lager.Logger, *models.ActualLRPKey) (*models.ActualLRP, error)
	createUnclaimedActualLRPMutex       sync.RWMutex
	createUnclaimedActualLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
	}
	createUnclaimedActualLRPReturns struct {
		result1 *models.ActualLRP
		result2 error
	}
	createUnclaimedActualLRPReturnsOnCall map[int]struct {
		result1 *models.ActualLRP
		result2 error
	}
	DesireLRPStub        func(context.Context, lager.Logger, *models.DesiredLRP) error
	desireLRPMutex       sync.RWMutex
	desireLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.DesiredLRP
	}
	desireLRPReturns struct {
		result1 error
	}
	desireLRPReturnsOnCall map[int]struct {
		result1 error
	}
	DesiredLRPByProcessGuidStub        func(context.Context, lager.Logger, string) (*models.DesiredLRP, error)
	desiredLRPByProcessGuidMutex       sync.RWMutex
	desiredLRPByProcessGuidArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
	}
	desiredLRPByProcessGuidReturns struct {
		result1 *models.DesiredLRP
		result2 error
	}
	desiredLRPByProcessGuidReturnsOnCall map[int]struct {
		result1 *models.DesiredLRP
		result2 error
	}
	DesiredLRPSchedulingInfosStub        func(context.Context, lager.Logger, models.DesiredLRPFilter) ([]*models.DesiredLRPSchedulingInfo, error)
	desiredLRPSchedulingInfosMutex       sync.RWMutex
	desiredLRPSchedulingInfosArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 models.DesiredLRPFilter
	}
	desiredLRPSchedulingInfosReturns struct {
		result1 []*models.DesiredLRPSchedulingInfo
		result2 error
	}
	desiredLRPSchedulingInfosReturnsOnCall map[int]struct {
		result1 []*models.DesiredLRPSchedulingInfo
		result2 error
	}
	DesiredLRPsStub        func(context.Context, lager.Logger, models.DesiredLRPFilter) ([]*models.DesiredLRP, error)
	desiredLRPsMutex       sync.RWMutex
	desiredLRPsArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 models.DesiredLRPFilter
	}
	desiredLRPsReturns struct {
		result1 []*models.DesiredLRP
		result2 error
	}
	desiredLRPsReturnsOnCall map[int]struct {
		result1 []*models.DesiredLRP
		result2 error
	}
	FailActualLRPStub        func(context.Context, lager.Logger, *models.ActualLRPKey, string) (*models.ActualLRP, *models.ActualLRP, error)
	failActualLRPMutex       sync.RWMutex
	failActualLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
		arg4 string
	}
	failActualLRPReturns struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	failActualLRPReturnsOnCall map[int]struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	RemoveActualLRPStub        func(context.Context, lager.Logger, string, int32, *models.ActualLRPInstanceKey) error
	removeActualLRPMutex       sync.RWMutex
	removeActualLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
		arg4 int32
		arg5 *models.ActualLRPInstanceKey
	}
	removeActualLRPReturns struct {
		result1 error
	}
	removeActualLRPReturnsOnCall map[int]struct {
		result1 error
	}
	RemoveDesiredLRPStub        func(context.Context, lager.Logger, string) error
	removeDesiredLRPMutex       sync.RWMutex
	removeDesiredLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
	}
	removeDesiredLRPReturns struct {
		result1 error
	}
	removeDesiredLRPReturnsOnCall map[int]struct {
		result1 error
	}
	StartActualLRPStub        func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute) (*models.ActualLRP, *models.ActualLRP, error)
	startActualLRPMutex       sync.RWMutex
	startActualLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
		arg4 *models.ActualLRPInstanceKey
		arg5 *models.ActualLRPNetInfo
		arg6 []*models.ActualLRPInternalRoute
	}
	startActualLRPReturns struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	startActualLRPReturnsOnCall map[int]struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	UnclaimActualLRPStub        func(context.Context, lager.Logger, *models.ActualLRPKey) (*models.ActualLRP, *models.ActualLRP, error)
	unclaimActualLRPMutex       sync.RWMutex
	unclaimActualLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
	}
	unclaimActualLRPReturns struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	unclaimActualLRPReturnsOnCall map[int]struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}
	UpdateDesiredLRPStub        func(context.Context, lager.Logger, string, *models.DesiredLRPUpdate) (*models.DesiredLRP, error)
	updateDesiredLRPMutex       sync.RWMutex
	updateDesiredLRPArgsForCall []struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
		arg4 *models.DesiredLRPUpdate
	}
	updateDesiredLRPReturns struct {
		result1 *models.DesiredLRP
		result2 error
	}
	updateDesiredLRPReturnsOnCall map[int]struct {
		result1 *models.DesiredLRP
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeLRPDB) ActualLRPs(arg1 context.Context, arg2 lager.Logger, arg3 models.ActualLRPFilter) ([]*models.ActualLRP, error) {
	fake.actualLRPsMutex.Lock()
	ret, specificReturn := fake.actualLRPsReturnsOnCall[len(fake.actualLRPsArgsForCall)]
	fake.actualLRPsArgsForCall = append(fake.actualLRPsArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 models.ActualLRPFilter
	}{arg1, arg2, arg3})
	stub := fake.ActualLRPsStub
	fakeReturns := fake.actualLRPsReturns
	fake.recordInvocation("ActualLRPs", []interface{}{arg1, arg2, arg3})
	fake.actualLRPsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeLRPDB) ActualLRPsCallCount() int {
	fake.actualLRPsMutex.RLock()
	defer fake.actualLRPsMutex.RUnlock()
	return len(fake.actualLRPsArgsForCall)
}

func (fake *FakeLRPDB) ActualLRPsCalls(stub func(context.Context, lager.Logger, models.ActualLRPFilter) ([]*models.ActualLRP, error)) {
	fake.actualLRPsMutex.Lock()
	defer fake.actualLRPsMutex.Unlock()
	fake.ActualLRPsStub = stub
}

func (fake *FakeLRPDB) ActualLRPsArgsForCall(i int) (context.Context, lager.Logger, models.ActualLRPFilter) {
	fake.actualLRPsMutex.RLock()
	defer fake.actualLRPsMutex.RUnlock()
	argsForCall := fake.actualLRPsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeLRPDB) ActualLRPsReturns(result1 []*models.ActualLRP, result2 error) {
	fake.actualLRPsMutex.Lock()
	defer fake.actualLRPsMutex.Unlock()
	fake.ActualLRPsStub = nil
	fake.actualLRPsReturns = struct {
		result1 []*models.ActualLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) ActualLRPsReturnsOnCall(i int, result1 []*models.ActualLRP, result2 error) {
	fake.actualLRPsMutex.Lock()
	defer fake.actualLRPsMutex.Unlock()
	fake.ActualLRPsStub = nil
	if fake.actualLRPsReturnsOnCall == nil {
		fake.actualLRPsReturnsOnCall = make(map[int]struct {
			result1 []*models.ActualLRP
			result2 error
		})
	}
	fake.actualLRPsReturnsOnCall[i] = struct {
		result1 []*models.ActualLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) ChangeActualLRPPresence(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 models.ActualLRP_Presence, arg5 models.ActualLRP_Presence) (*models.ActualLRP, *models.ActualLRP, error) {
	fake.changeActualLRPPresenceMutex.Lock()
	ret, specificReturn := fake.changeActualLRPPresenceReturnsOnCall[len(fake.changeActualLRPPresenceArgsForCall)]
	fake.changeActualLRPPresenceArgsForCall = append(fake.changeActualLRPPresenceArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
		arg4 models.ActualLRP_Presence
		arg5 models.ActualLRP_Presence
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.ChangeActualLRPPresenceStub
	fakeReturns := fake.changeActualLRPPresenceReturns
	fake.recordInvocation("ChangeActualLRPPresence", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.changeActualLRPPresenceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeLRPDB) ChangeActualLRPPresenceCallCount() int {
	fake.changeActualLRPPresenceMutex.RLock()
	defer fake.changeActualLRPPresenceMutex.RUnlock()
	return len(fake.changeActualLRPPresenceArgsForCall)
}

func (fake *FakeLRPDB) ChangeActualLRPPresenceCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, models.ActualLRP_Presence, models.ActualLRP_Presence) (*models.ActualLRP, *models.ActualLRP, error)) {
	fake.changeActualLRPPresenceMutex.Lock()
	defer fake.changeActualLRPPresenceMutex.Unlock()
	fake.ChangeActualLRPPresenceStub = stub
}

func (fake *FakeLRPDB) ChangeActualLRPPresenceArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, models.ActualLRP_Presence, models.ActualLRP_Presence) {
	fake.changeActualLRPPresenceMutex.RLock()
	defer fake.changeActualLRPPresenceMutex.RUnlock()
	argsForCall := fake.changeActualLRPPresenceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeLRPDB) ChangeActualLRPPresenceReturns(result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.changeActualLRPPresenceMutex.Lock()
	defer fake.changeActualLRPPresenceMutex.Unlock()
	fake.ChangeActualLRPPresenceStub = nil
	fake.changeActualLRPPresenceReturns = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) ChangeActualLRPPresenceReturnsOnCall(i int, result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.changeActualLRPPresenceMutex.Lock()
	defer fake.changeActualLRPPresenceMutex.Unlock()
	fake.ChangeActualLRPPresenceStub = nil
	if fake.changeActualLRPPresenceReturnsOnCall == nil {
		fake.changeActualLRPPresenceReturnsOnCall = make(map[int]struct {
			result1 *models.ActualLRP
			result2 *models.ActualLRP
			result3 error
		})
	}
	fake.changeActualLRPPresenceReturnsOnCall[i] = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) ClaimActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 string, arg4 int32, arg5 *models.ActualLRPInstanceKey) (*models.ActualLRP, *models.ActualLRP, error) {
	fake.claimActualLRPMutex.Lock()
	ret, specificReturn := fake.claimActualLRPReturnsOnCall[len(fake.claimActualLRPArgsForCall)]
	fake.claimActualLRPArgsForCall = append(fake.claimActualLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
		arg4 int32
		arg5 *models.ActualLRPInstanceKey
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.ClaimActualLRPStub
	fakeReturns := fake.claimActualLRPReturns
	fake.recordInvocation("ClaimActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.claimActualLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeLRPDB) ClaimActualLRPCallCount() int {
	fake.claimActualLRPMutex.RLock()
	defer fake.claimActualLRPMutex.RUnlock()
	return len(fake.claimActualLRPArgsForCall)
}

func (fake *FakeLRPDB) ClaimActualLRPCalls(stub func(context.Context, lager.Logger, string, int32, *models.ActualLRPInstanceKey) (*models.ActualLRP, *models.ActualLRP, error)) {
	fake.claimActualLRPMutex.Lock()
	defer fake.claimActualLRPMutex.Unlock()
	fake.ClaimActualLRPStub = stub
}

func (fake *FakeLRPDB) ClaimActualLRPArgsForCall(i int) (context.Context, lager.Logger, string, int32, *models.ActualLRPInstanceKey) {
	fake.claimActualLRPMutex.RLock()
	defer fake.claimActualLRPMutex.RUnlock()
	argsForCall := fake.claimActualLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeLRPDB) ClaimActualLRPReturns(result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.claimActualLRPMutex.Lock()
	defer fake.claimActualLRPMutex.Unlock()
	fake.ClaimActualLRPStub = nil
	fake.claimActualLRPReturns = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) ClaimActualLRPReturnsOnCall(i int, result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.claimActualLRPMutex.Lock()
	defer fake.claimActualLRPMutex.Unlock()
	fake.ClaimActualLRPStub = nil
	if fake.claimActualLRPReturnsOnCall == nil {
		fake.claimActualLRPReturnsOnCall = make(map[int]struct {
			result1 *models.ActualLRP
			result2 *models.ActualLRP
			result3 error
		})
	}
	fake.claimActualLRPReturnsOnCall[i] = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) ConvergeLRPs(arg1 context.Context, arg2 lager.Logger, arg3 models.CellSet) db.ConvergenceResult {
	fake.convergeLRPsMutex.Lock()
	ret, specificReturn := fake.convergeLRPsReturnsOnCall[len(fake.convergeLRPsArgsForCall)]
	fake.convergeLRPsArgsForCall = append(fake.convergeLRPsArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 models.CellSet
	}{arg1, arg2, arg3})
	stub := fake.ConvergeLRPsStub
	fakeReturns := fake.convergeLRPsReturns
	fake.recordInvocation("ConvergeLRPs", []interface{}{arg1, arg2, arg3})
	fake.convergeLRPsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeLRPDB) ConvergeLRPsCallCount() int {
	fake.convergeLRPsMutex.RLock()
	defer fake.convergeLRPsMutex.RUnlock()
	return len(fake.convergeLRPsArgsForCall)
}

func (fake *FakeLRPDB) ConvergeLRPsCalls(stub func(context.Context, lager.Logger, models.CellSet) db.ConvergenceResult) {
	fake.convergeLRPsMutex.Lock()
	defer fake.convergeLRPsMutex.Unlock()
	fake.ConvergeLRPsStub = stub
}

func (fake *FakeLRPDB) ConvergeLRPsArgsForCall(i int) (context.Context, lager.Logger, models.CellSet) {
	fake.convergeLRPsMutex.RLock()
	defer fake.convergeLRPsMutex.RUnlock()
	argsForCall := fake.convergeLRPsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeLRPDB) ConvergeLRPsReturns(result1 db.ConvergenceResult) {
	fake.convergeLRPsMutex.Lock()
	defer fake.convergeLRPsMutex.Unlock()
	fake.ConvergeLRPsStub = nil
	fake.convergeLRPsReturns = struct {
		result1 db.ConvergenceResult
	}{result1}
}

func (fake *FakeLRPDB) ConvergeLRPsReturnsOnCall(i int, result1 db.ConvergenceResult) {
	fake.convergeLRPsMutex.Lock()
	defer fake.convergeLRPsMutex.Unlock()
	fake.ConvergeLRPsStub = nil
	if fake.convergeLRPsReturnsOnCall == nil {
		fake.convergeLRPsReturnsOnCall = make(map[int]struct {
			result1 db.ConvergenceResult
		})
	}
	fake.convergeLRPsReturnsOnCall[i] = struct {
		result1 db.ConvergenceResult
	}{result1}
}

func (fake *FakeLRPDB) CountActualLRPsByState(arg1 context.Context, arg2 lager.Logger) (int, int, int, int, int) {
	fake.countActualLRPsByStateMutex.Lock()
	ret, specificReturn := fake.countActualLRPsByStateReturnsOnCall[len(fake.countActualLRPsByStateArgsForCall)]
	fake.countActualLRPsByStateArgsForCall = append(fake.countActualLRPsByStateArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
	}{arg1, arg2})
	stub := fake.CountActualLRPsByStateStub
	fakeReturns := fake.countActualLRPsByStateReturns
	fake.recordInvocation("CountActualLRPsByState", []interface{}{arg1, arg2})
	fake.countActualLRPsByStateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4, ret.result5
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4, fakeReturns.result5
}

func (fake *FakeLRPDB) CountActualLRPsByStateCallCount() int {
	fake.countActualLRPsByStateMutex.RLock()
	defer fake.countActualLRPsByStateMutex.RUnlock()
	return len(fake.countActualLRPsByStateArgsForCall)
}

func (fake *FakeLRPDB) CountActualLRPsByStateCalls(stub func(context.Context, lager.Logger) (int, int, int, int, int)) {
	fake.countActualLRPsByStateMutex.Lock()
	defer fake.countActualLRPsByStateMutex.Unlock()
	fake.CountActualLRPsByStateStub = stub
}

func (fake *FakeLRPDB) CountActualLRPsByStateArgsForCall(i int) (context.Context, lager.Logger) {
	fake.countActualLRPsByStateMutex.RLock()
	defer fake.countActualLRPsByStateMutex.RUnlock()
	argsForCall := fake.countActualLRPsByStateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeLRPDB) CountActualLRPsByStateReturns(result1 int, result2 int, result3 int, result4 int, result5 int) {
	fake.countActualLRPsByStateMutex.Lock()
	defer fake.countActualLRPsByStateMutex.Unlock()
	fake.CountActualLRPsByStateStub = nil
	fake.countActualLRPsByStateReturns = struct {
		result1 int
		result2 int
		result3 int
		result4 int
		result5 int
	}{result1, result2, result3, result4, result5}
}

func (fake *FakeLRPDB) CountActualLRPsByStateReturnsOnCall(i int, result1 int, result2 int, result3 int, result4 int, result5 int) {
	fake.countActualLRPsByStateMutex.Lock()
	defer fake.countActualLRPsByStateMutex.Unlock()
	fake.CountActualLRPsByStateStub = nil
	if fake.countActualLRPsByStateReturnsOnCall == nil {
		fake.countActualLRPsByStateReturnsOnCall = make(map[int]struct {
			result1 int
			result2 int
			result3 int
			result4 int
			result5 int
		})
	}
	fake.countActualLRPsByStateReturnsOnCall[i] = struct {
		result1 int
		result2 int
		result3 int
		result4 int
		result5 int
	}{result1, result2, result3, result4, result5}
}

func (fake *FakeLRPDB) CountDesiredInstances(arg1 context.Context, arg2 lager.Logger) int {
	fake.countDesiredInstancesMutex.Lock()
	ret, specificReturn := fake.countDesiredInstancesReturnsOnCall[len(fake.countDesiredInstancesArgsForCall)]
	fake.countDesiredInstancesArgsForCall = append(fake.countDesiredInstancesArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
	}{arg1, arg2})
	stub := fake.CountDesiredInstancesStub
	fakeReturns := fake.countDesiredInstancesReturns
	fake.recordInvocation("CountDesiredInstances", []interface{}{arg1, arg2})
	fake.countDesiredInstancesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeLRPDB) CountDesiredInstancesCallCount() int {
	fake.countDesiredInstancesMutex.RLock()
	defer fake.countDesiredInstancesMutex.RUnlock()
	return len(fake.countDesiredInstancesArgsForCall)
}

func (fake *FakeLRPDB) CountDesiredInstancesCalls(stub func(context.Context, lager.Logger) int) {
	fake.countDesiredInstancesMutex.Lock()
	defer fake.countDesiredInstancesMutex.Unlock()
	fake.CountDesiredInstancesStub = stub
}

func (fake *FakeLRPDB) CountDesiredInstancesArgsForCall(i int) (context.Context, lager.Logger) {
	fake.countDesiredInstancesMutex.RLock()
	defer fake.countDesiredInstancesMutex.RUnlock()
	argsForCall := fake.countDesiredInstancesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeLRPDB) CountDesiredInstancesReturns(result1 int) {
	fake.countDesiredInstancesMutex.Lock()
	defer fake.countDesiredInstancesMutex.Unlock()
	fake.CountDesiredInstancesStub = nil
	fake.countDesiredInstancesReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeLRPDB) CountDesiredInstancesReturnsOnCall(i int, result1 int) {
	fake.countDesiredInstancesMutex.Lock()
	defer fake.countDesiredInstancesMutex.Unlock()
	fake.CountDesiredInstancesStub = nil
	if fake.countDesiredInstancesReturnsOnCall == nil {
		fake.countDesiredInstancesReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.countDesiredInstancesReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeLRPDB) CrashActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 *models.ActualLRPInstanceKey, arg5 string) (*models.ActualLRP, *models.ActualLRP, bool, error) {
	fake.crashActualLRPMutex.Lock()
	ret, specificReturn := fake.crashActualLRPReturnsOnCall[len(fake.crashActualLRPArgsForCall)]
	fake.crashActualLRPArgsForCall = append(fake.crashActualLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
		arg4 *models.ActualLRPInstanceKey
		arg5 string
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.CrashActualLRPStub
	fakeReturns := fake.crashActualLRPReturns
	fake.recordInvocation("CrashActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.crashActualLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

func (fake *FakeLRPDB) CrashActualLRPCallCount() int {
	fake.crashActualLRPMutex.RLock()
	defer fake.crashActualLRPMutex.RUnlock()
	return len(fake.crashActualLRPArgsForCall)
}

func (fake *FakeLRPDB) CrashActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, string) (*models.ActualLRP, *models.ActualLRP, bool, error)) {
	fake.crashActualLRPMutex.Lock()
	defer fake.crashActualLRPMutex.Unlock()
	fake.CrashActualLRPStub = stub
}

func (fake *FakeLRPDB) CrashActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, string) {
	fake.crashActualLRPMutex.RLock()
	defer fake.crashActualLRPMutex.RUnlock()
	argsForCall := fake.crashActualLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeLRPDB) CrashActualLRPReturns(result1 *models.ActualLRP, result2 *models.ActualLRP, result3 bool, result4 error) {
	fake.crashActualLRPMutex.Lock()
	defer fake.crashActualLRPMutex.Unlock()
	fake.CrashActualLRPStub = nil
	fake.crashActualLRPReturns = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 bool
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeLRPDB) CrashActualLRPReturnsOnCall(i int, result1 *models.ActualLRP, result2 *models.ActualLRP, result3 bool, result4 error) {
	fake.crashActualLRPMutex.Lock()
	defer fake.crashActualLRPMutex.Unlock()
	fake.CrashActualLRPStub = nil
	if fake.crashActualLRPReturnsOnCall == nil {
		fake.crashActualLRPReturnsOnCall = make(map[int]struct {
			result1 *models.ActualLRP
			result2 *models.ActualLRP
			result3 bool
			result4 error
		})
	}
	fake.crashActualLRPReturnsOnCall[i] = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 bool
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeLRPDB) CreateUnclaimedActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey) (*models.ActualLRP, error) {
	fake.createUnclaimedActualLRPMutex.Lock()
	ret, specificReturn := fake.createUnclaimedActualLRPReturnsOnCall[len(fake.createUnclaimedActualLRPArgsForCall)]
	fake.createUnclaimedActualLRPArgsForCall = append(fake.createUnclaimedActualLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
	}{arg1, arg2, arg3})
	stub := fake.CreateUnclaimedActualLRPStub
	fakeReturns := fake.createUnclaimedActualLRPReturns
	fake.recordInvocation("CreateUnclaimedActualLRP", []interface{}{arg1, arg2, arg3})
	fake.createUnclaimedActualLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeLRPDB) CreateUnclaimedActualLRPCallCount() int {
	fake.createUnclaimedActualLRPMutex.RLock()
	defer fake.createUnclaimedActualLRPMutex.RUnlock()
	return len(fake.createUnclaimedActualLRPArgsForCall)
}

func (fake *FakeLRPDB) CreateUnclaimedActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey) (*models.ActualLRP, error)) {
	fake.createUnclaimedActualLRPMutex.Lock()
	defer fake.createUnclaimedActualLRPMutex.Unlock()
	fake.CreateUnclaimedActualLRPStub = stub
}

func (fake *FakeLRPDB) CreateUnclaimedActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey) {
	fake.createUnclaimedActualLRPMutex.RLock()
	defer fake.createUnclaimedActualLRPMutex.RUnlock()
	argsForCall := fake.createUnclaimedActualLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeLRPDB) CreateUnclaimedActualLRPReturns(result1 *models.ActualLRP, result2 error) {
	fake.createUnclaimedActualLRPMutex.Lock()
	defer fake.createUnclaimedActualLRPMutex.Unlock()
	fake.CreateUnclaimedActualLRPStub = nil
	fake.createUnclaimedActualLRPReturns = struct {
		result1 *models.ActualLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) CreateUnclaimedActualLRPReturnsOnCall(i int, result1 *models.ActualLRP, result2 error) {
	fake.createUnclaimedActualLRPMutex.Lock()
	defer fake.createUnclaimedActualLRPMutex.Unlock()
	fake.CreateUnclaimedActualLRPStub = nil
	if fake.createUnclaimedActualLRPReturnsOnCall == nil {
		fake.createUnclaimedActualLRPReturnsOnCall = make(map[int]struct {
			result1 *models.ActualLRP
			result2 error
		})
	}
	fake.createUnclaimedActualLRPReturnsOnCall[i] = struct {
		result1 *models.ActualLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) DesireLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.DesiredLRP) error {
	fake.desireLRPMutex.Lock()
	ret, specificReturn := fake.desireLRPReturnsOnCall[len(fake.desireLRPArgsForCall)]
	fake.desireLRPArgsForCall = append(fake.desireLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.DesiredLRP
	}{arg1, arg2, arg3})
	stub := fake.DesireLRPStub
	fakeReturns := fake.desireLRPReturns
	fake.recordInvocation("DesireLRP", []interface{}{arg1, arg2, arg3})
	fake.desireLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeLRPDB) DesireLRPCallCount() int {
	fake.desireLRPMutex.RLock()
	defer fake.desireLRPMutex.RUnlock()
	return len(fake.desireLRPArgsForCall)
}

func (fake *FakeLRPDB) DesireLRPCalls(stub func(context.Context, lager.Logger, *models.DesiredLRP) error) {
	fake.desireLRPMutex.Lock()
	defer fake.desireLRPMutex.Unlock()
	fake.DesireLRPStub = stub
}

func (fake *FakeLRPDB) DesireLRPArgsForCall(i int) (context.Context, lager.Logger, *models.DesiredLRP) {
	fake.desireLRPMutex.RLock()
	defer fake.desireLRPMutex.RUnlock()
	argsForCall := fake.desireLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeLRPDB) DesireLRPReturns(result1 error) {
	fake.desireLRPMutex.Lock()
	defer fake.desireLRPMutex.Unlock()
	fake.DesireLRPStub = nil
	fake.desireLRPReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeLRPDB) DesireLRPReturnsOnCall(i int, result1 error) {
	fake.desireLRPMutex.Lock()
	defer fake.desireLRPMutex.Unlock()
	fake.DesireLRPStub = nil
	if fake.desireLRPReturnsOnCall == nil {
		fake.desireLRPReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.desireLRPReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeLRPDB) DesiredLRPByProcessGuid(arg1 context.Context, arg2 lager.Logger, arg3 string) (*models.DesiredLRP, error) {
	fake.desiredLRPByProcessGuidMutex.Lock()
	ret, specificReturn := fake.desiredLRPByProcessGuidReturnsOnCall[len(fake.desiredLRPByProcessGuidArgsForCall)]
	fake.desiredLRPByProcessGuidArgsForCall = append(fake.desiredLRPByProcessGuidArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.DesiredLRPByProcessGuidStub
	fakeReturns := fake.desiredLRPByProcessGuidReturns
	fake.recordInvocation("DesiredLRPByProcessGuid", []interface{}{arg1, arg2, arg3})
	fake.desiredLRPByProcessGuidMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeLRPDB) DesiredLRPByProcessGuidCallCount() int {
	fake.desiredLRPByProcessGuidMutex.RLock()
	defer fake.desiredLRPByProcessGuidMutex.RUnlock()
	return len(fake.desiredLRPByProcessGuidArgsForCall)
}

func (fake *FakeLRPDB) DesiredLRPByProcessGuidCalls(stub func(context.Context, lager.Logger, string) (*models.DesiredLRP, error)) {
	fake.desiredLRPByProcessGuidMutex.Lock()
	defer fake.desiredLRPByProcessGuidMutex.Unlock()
	fake.DesiredLRPByProcessGuidStub = stub
}

func (fake *FakeLRPDB) DesiredLRPByProcessGuidArgsForCall(i int) (context.Context, lager.Logger, string) {
	fake.desiredLRPByProcessGuidMutex.RLock()
	defer fake.desiredLRPByProcessGuidMutex.RUnlock()
	argsForCall := fake.desiredLRPByProcessGuidArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeLRPDB) DesiredLRPByProcessGuidReturns(result1 *models.DesiredLRP, result2 error) {
	fake.desiredLRPByProcessGuidMutex.Lock()
	defer fake.desiredLRPByProcessGuidMutex.Unlock()
	fake.DesiredLRPByProcessGuidStub = nil
	fake.desiredLRPByProcessGuidReturns = struct {
		result1 *models.DesiredLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) DesiredLRPByProcessGuidReturnsOnCall(i int, result1 *models.DesiredLRP, result2 error) {
	fake.desiredLRPByProcessGuidMutex.Lock()
	defer fake.desiredLRPByProcessGuidMutex.Unlock()
	fake.DesiredLRPByProcessGuidStub = nil
	if fake.desiredLRPByProcessGuidReturnsOnCall == nil {
		fake.desiredLRPByProcessGuidReturnsOnCall = make(map[int]struct {
			result1 *models.DesiredLRP
			result2 error
		})
	}
	fake.desiredLRPByProcessGuidReturnsOnCall[i] = struct {
		result1 *models.DesiredLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) DesiredLRPSchedulingInfos(arg1 context.Context, arg2 lager.Logger, arg3 models.DesiredLRPFilter) ([]*models.DesiredLRPSchedulingInfo, error) {
	fake.desiredLRPSchedulingInfosMutex.Lock()
	ret, specificReturn := fake.desiredLRPSchedulingInfosReturnsOnCall[len(fake.desiredLRPSchedulingInfosArgsForCall)]
	fake.desiredLRPSchedulingInfosArgsForCall = append(fake.desiredLRPSchedulingInfosArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 models.DesiredLRPFilter
	}{arg1, arg2, arg3})
	stub := fake.DesiredLRPSchedulingInfosStub
	fakeReturns := fake.desiredLRPSchedulingInfosReturns
	fake.recordInvocation("DesiredLRPSchedulingInfos", []interface{}{arg1, arg2, arg3})
	fake.desiredLRPSchedulingInfosMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeLRPDB) DesiredLRPSchedulingInfosCallCount() int {
	fake.desiredLRPSchedulingInfosMutex.RLock()
	defer fake.desiredLRPSchedulingInfosMutex.RUnlock()
	return len(fake.desiredLRPSchedulingInfosArgsForCall)
}

func (fake *FakeLRPDB) DesiredLRPSchedulingInfosCalls(stub func(context.Context, lager.Logger, models.DesiredLRPFilter) ([]*models.DesiredLRPSchedulingInfo, error)) {
	fake.desiredLRPSchedulingInfosMutex.Lock()
	defer fake.desiredLRPSchedulingInfosMutex.Unlock()
	fake.DesiredLRPSchedulingInfosStub = stub
}

func (fake *FakeLRPDB) DesiredLRPSchedulingInfosArgsForCall(i int) (context.Context, lager.Logger, models.DesiredLRPFilter) {
	fake.desiredLRPSchedulingInfosMutex.RLock()
	defer fake.desiredLRPSchedulingInfosMutex.RUnlock()
	argsForCall := fake.desiredLRPSchedulingInfosArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeLRPDB) DesiredLRPSchedulingInfosReturns(result1 []*models.DesiredLRPSchedulingInfo, result2 error) {
	fake.desiredLRPSchedulingInfosMutex.Lock()
	defer fake.desiredLRPSchedulingInfosMutex.Unlock()
	fake.DesiredLRPSchedulingInfosStub = nil
	fake.desiredLRPSchedulingInfosReturns = struct {
		result1 []*models.DesiredLRPSchedulingInfo
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) DesiredLRPSchedulingInfosReturnsOnCall(i int, result1 []*models.DesiredLRPSchedulingInfo, result2 error) {
	fake.desiredLRPSchedulingInfosMutex.Lock()
	defer fake.desiredLRPSchedulingInfosMutex.Unlock()
	fake.DesiredLRPSchedulingInfosStub = nil
	if fake.desiredLRPSchedulingInfosReturnsOnCall == nil {
		fake.desiredLRPSchedulingInfosReturnsOnCall = make(map[int]struct {
			result1 []*models.DesiredLRPSchedulingInfo
			result2 error
		})
	}
	fake.desiredLRPSchedulingInfosReturnsOnCall[i] = struct {
		result1 []*models.DesiredLRPSchedulingInfo
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) DesiredLRPs(arg1 context.Context, arg2 lager.Logger, arg3 models.DesiredLRPFilter) ([]*models.DesiredLRP, error) {
	fake.desiredLRPsMutex.Lock()
	ret, specificReturn := fake.desiredLRPsReturnsOnCall[len(fake.desiredLRPsArgsForCall)]
	fake.desiredLRPsArgsForCall = append(fake.desiredLRPsArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 models.DesiredLRPFilter
	}{arg1, arg2, arg3})
	stub := fake.DesiredLRPsStub
	fakeReturns := fake.desiredLRPsReturns
	fake.recordInvocation("DesiredLRPs", []interface{}{arg1, arg2, arg3})
	fake.desiredLRPsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeLRPDB) DesiredLRPsCallCount() int {
	fake.desiredLRPsMutex.RLock()
	defer fake.desiredLRPsMutex.RUnlock()
	return len(fake.desiredLRPsArgsForCall)
}

func (fake *FakeLRPDB) DesiredLRPsCalls(stub func(context.Context, lager.Logger, models.DesiredLRPFilter) ([]*models.DesiredLRP, error)) {
	fake.desiredLRPsMutex.Lock()
	defer fake.desiredLRPsMutex.Unlock()
	fake.DesiredLRPsStub = stub
}

func (fake *FakeLRPDB) DesiredLRPsArgsForCall(i int) (context.Context, lager.Logger, models.DesiredLRPFilter) {
	fake.desiredLRPsMutex.RLock()
	defer fake.desiredLRPsMutex.RUnlock()
	argsForCall := fake.desiredLRPsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeLRPDB) DesiredLRPsReturns(result1 []*models.DesiredLRP, result2 error) {
	fake.desiredLRPsMutex.Lock()
	defer fake.desiredLRPsMutex.Unlock()
	fake.DesiredLRPsStub = nil
	fake.desiredLRPsReturns = struct {
		result1 []*models.DesiredLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) DesiredLRPsReturnsOnCall(i int, result1 []*models.DesiredLRP, result2 error) {
	fake.desiredLRPsMutex.Lock()
	defer fake.desiredLRPsMutex.Unlock()
	fake.DesiredLRPsStub = nil
	if fake.desiredLRPsReturnsOnCall == nil {
		fake.desiredLRPsReturnsOnCall = make(map[int]struct {
			result1 []*models.DesiredLRP
			result2 error
		})
	}
	fake.desiredLRPsReturnsOnCall[i] = struct {
		result1 []*models.DesiredLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) FailActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 string) (*models.ActualLRP, *models.ActualLRP, error) {
	fake.failActualLRPMutex.Lock()
	ret, specificReturn := fake.failActualLRPReturnsOnCall[len(fake.failActualLRPArgsForCall)]
	fake.failActualLRPArgsForCall = append(fake.failActualLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.FailActualLRPStub
	fakeReturns := fake.failActualLRPReturns
	fake.recordInvocation("FailActualLRP", []interface{}{arg1, arg2, arg3, arg4})
	fake.failActualLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeLRPDB) FailActualLRPCallCount() int {
	fake.failActualLRPMutex.RLock()
	defer fake.failActualLRPMutex.RUnlock()
	return len(fake.failActualLRPArgsForCall)
}

func (fake *FakeLRPDB) FailActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, string) (*models.ActualLRP, *models.ActualLRP, error)) {
	fake.failActualLRPMutex.Lock()
	defer fake.failActualLRPMutex.Unlock()
	fake.FailActualLRPStub = stub
}

func (fake *FakeLRPDB) FailActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, string) {
	fake.failActualLRPMutex.RLock()
	defer fake.failActualLRPMutex.RUnlock()
	argsForCall := fake.failActualLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeLRPDB) FailActualLRPReturns(result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.failActualLRPMutex.Lock()
	defer fake.failActualLRPMutex.Unlock()
	fake.FailActualLRPStub = nil
	fake.failActualLRPReturns = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) FailActualLRPReturnsOnCall(i int, result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.failActualLRPMutex.Lock()
	defer fake.failActualLRPMutex.Unlock()
	fake.FailActualLRPStub = nil
	if fake.failActualLRPReturnsOnCall == nil {
		fake.failActualLRPReturnsOnCall = make(map[int]struct {
			result1 *models.ActualLRP
			result2 *models.ActualLRP
			result3 error
		})
	}
	fake.failActualLRPReturnsOnCall[i] = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) RemoveActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 string, arg4 int32, arg5 *models.ActualLRPInstanceKey) error {
	fake.removeActualLRPMutex.Lock()
	ret, specificReturn := fake.removeActualLRPReturnsOnCall[len(fake.removeActualLRPArgsForCall)]
	fake.removeActualLRPArgsForCall = append(fake.removeActualLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
		arg4 int32
		arg5 *models.ActualLRPInstanceKey
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.RemoveActualLRPStub
	fakeReturns := fake.removeActualLRPReturns
	fake.recordInvocation("RemoveActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.removeActualLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeLRPDB) RemoveActualLRPCallCount() int {
	fake.removeActualLRPMutex.RLock()
	defer fake.removeActualLRPMutex.RUnlock()
	return len(fake.removeActualLRPArgsForCall)
}

func (fake *FakeLRPDB) RemoveActualLRPCalls(stub func(context.Context, lager.Logger, string, int32, *models.ActualLRPInstanceKey) error) {
	fake.removeActualLRPMutex.Lock()
	defer fake.removeActualLRPMutex.Unlock()
	fake.RemoveActualLRPStub = stub
}

func (fake *FakeLRPDB) RemoveActualLRPArgsForCall(i int) (context.Context, lager.Logger, string, int32, *models.ActualLRPInstanceKey) {
	fake.removeActualLRPMutex.RLock()
	defer fake.removeActualLRPMutex.RUnlock()
	argsForCall := fake.removeActualLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeLRPDB) RemoveActualLRPReturns(result1 error) {
	fake.removeActualLRPMutex.Lock()
	defer fake.removeActualLRPMutex.Unlock()
	fake.RemoveActualLRPStub = nil
	fake.removeActualLRPReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeLRPDB) RemoveActualLRPReturnsOnCall(i int, result1 error) {
	fake.removeActualLRPMutex.Lock()
	defer fake.removeActualLRPMutex.Unlock()
	fake.RemoveActualLRPStub = nil
	if fake.removeActualLRPReturnsOnCall == nil {
		fake.removeActualLRPReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.removeActualLRPReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeLRPDB) RemoveDesiredLRP(arg1 context.Context, arg2 lager.Logger, arg3 string) error {
	fake.removeDesiredLRPMutex.Lock()
	ret, specificReturn := fake.removeDesiredLRPReturnsOnCall[len(fake.removeDesiredLRPArgsForCall)]
	fake.removeDesiredLRPArgsForCall = append(fake.removeDesiredLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.RemoveDesiredLRPStub
	fakeReturns := fake.removeDesiredLRPReturns
	fake.recordInvocation("RemoveDesiredLRP", []interface{}{arg1, arg2, arg3})
	fake.removeDesiredLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeLRPDB) RemoveDesiredLRPCallCount() int {
	fake.removeDesiredLRPMutex.RLock()
	defer fake.removeDesiredLRPMutex.RUnlock()
	return len(fake.removeDesiredLRPArgsForCall)
}

func (fake *FakeLRPDB) RemoveDesiredLRPCalls(stub func(context.Context, lager.Logger, string) error) {
	fake.removeDesiredLRPMutex.Lock()
	defer fake.removeDesiredLRPMutex.Unlock()
	fake.RemoveDesiredLRPStub = stub
}

func (fake *FakeLRPDB) RemoveDesiredLRPArgsForCall(i int) (context.Context, lager.Logger, string) {
	fake.removeDesiredLRPMutex.RLock()
	defer fake.removeDesiredLRPMutex.RUnlock()
	argsForCall := fake.removeDesiredLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeLRPDB) RemoveDesiredLRPReturns(result1 error) {
	fake.removeDesiredLRPMutex.Lock()
	defer fake.removeDesiredLRPMutex.Unlock()
	fake.RemoveDesiredLRPStub = nil
	fake.removeDesiredLRPReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeLRPDB) RemoveDesiredLRPReturnsOnCall(i int, result1 error) {
	fake.removeDesiredLRPMutex.Lock()
	defer fake.removeDesiredLRPMutex.Unlock()
	fake.RemoveDesiredLRPStub = nil
	if fake.removeDesiredLRPReturnsOnCall == nil {
		fake.removeDesiredLRPReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.removeDesiredLRPReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeLRPDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 *models.ActualLRPInstanceKey, arg5 *models.ActualLRPNetInfo, arg6 []*models.ActualLRPInternalRoute) (*models.ActualLRP, *models.ActualLRP, error) {
	var arg6Copy []*models.ActualLRPInternalRoute
	if arg6 != nil {
		arg6Copy = make([]*models.ActualLRPInternalRoute, len(arg6))
		copy(arg6Copy, arg6)
	}
	fake.startActualLRPMutex.Lock()
	ret, specificReturn := fake.startActualLRPReturnsOnCall[len(fake.startActualLRPArgsForCall)]
	fake.startActualLRPArgsForCall = append(fake.startActualLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
		arg4 *models.ActualLRPInstanceKey
		arg5 *models.ActualLRPNetInfo
		arg6 []*models.ActualLRPInternalRoute
	}{arg1, arg2, arg3, arg4, arg5, arg6Copy})
	stub := fake.StartActualLRPStub
	fakeReturns := fake.startActualLRPReturns
	fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6Copy})
	fake.startActualLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeLRPDB) StartActualLRPCallCount() int {
	fake.startActualLRPMutex.RLock()
	defer fake.startActualLRPMutex.RUnlock()
	return len(fake.startActualLRPArgsForCall)
}

func (fake *FakeLRPDB) StartActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute) (*models.ActualLRP, *models.ActualLRP, error)) {
	fake.startActualLRPMutex.Lock()
	defer fake.startActualLRPMutex.Unlock()
	fake.StartActualLRPStub = stub
}

func (fake *FakeLRPDB) StartActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute) {
	fake.startActualLRPMutex.RLock()
	defer fake.startActualLRPMutex.RUnlock()
	argsForCall := fake.startActualLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
}

func (fake *FakeLRPDB) StartActualLRPReturns(result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.startActualLRPMutex.Lock()
	defer fake.startActualLRPMutex.Unlock()
	fake.StartActualLRPStub = nil
	fake.startActualLRPReturns = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) StartActualLRPReturnsOnCall(i int, result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.startActualLRPMutex.Lock()
	defer fake.startActualLRPMutex.Unlock()
	fake.StartActualLRPStub = nil
	if fake.startActualLRPReturnsOnCall == nil {
		fake.startActualLRPReturnsOnCall = make(map[int]struct {
			result1 *models.ActualLRP
			result2 *models.ActualLRP
			result3 error
		})
	}
	fake.startActualLRPReturnsOnCall[i] = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) UnclaimActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey) (*models.ActualLRP, *models.ActualLRP, error) {
	fake.unclaimActualLRPMutex.Lock()
	ret, specificReturn := fake.unclaimActualLRPReturnsOnCall[len(fake.unclaimActualLRPArgsForCall)]
	fake.unclaimActualLRPArgsForCall = append(fake.unclaimActualLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 *models.ActualLRPKey
	}{arg1, arg2, arg3})
	stub := fake.UnclaimActualLRPStub
	fakeReturns := fake.unclaimActualLRPReturns
	fake.recordInvocation("UnclaimActualLRP", []interface{}{arg1, arg2, arg3})
	fake.unclaimActualLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeLRPDB) UnclaimActualLRPCallCount() int {
	fake.unclaimActualLRPMutex.RLock()
	defer fake.unclaimActualLRPMutex.RUnlock()
	return len(fake.unclaimActualLRPArgsForCall)
}

func (fake *FakeLRPDB) UnclaimActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey) (*models.ActualLRP, *models.ActualLRP, error)) {
	fake.unclaimActualLRPMutex.Lock()
	defer fake.unclaimActualLRPMutex.Unlock()
	fake.UnclaimActualLRPStub = stub
}

func (fake *FakeLRPDB) UnclaimActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey) {
	fake.unclaimActualLRPMutex.RLock()
	defer fake.unclaimActualLRPMutex.RUnlock()
	argsForCall := fake.unclaimActualLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeLRPDB) UnclaimActualLRPReturns(result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.unclaimActualLRPMutex.Lock()
	defer fake.unclaimActualLRPMutex.Unlock()
	fake.UnclaimActualLRPStub = nil
	fake.unclaimActualLRPReturns = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) UnclaimActualLRPReturnsOnCall(i int, result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) {
	fake.unclaimActualLRPMutex.Lock()
	defer fake.unclaimActualLRPMutex.Unlock()
	fake.UnclaimActualLRPStub = nil
	if fake.unclaimActualLRPReturnsOnCall == nil {
		fake.unclaimActualLRPReturnsOnCall = make(map[int]struct {
			result1 *models.ActualLRP
			result2 *models.ActualLRP
			result3 error
		})
	}
	fake.unclaimActualLRPReturnsOnCall[i] = struct {
		result1 *models.ActualLRP
		result2 *models.ActualLRP
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeLRPDB) UpdateDesiredLRP(arg1 context.Context, arg2 lager.Logger, arg3 string, arg4 *models.DesiredLRPUpdate) (*models.DesiredLRP, error) {
	fake.updateDesiredLRPMutex.Lock()
	ret, specificReturn := fake.updateDesiredLRPReturnsOnCall[len(fake.updateDesiredLRPArgsForCall)]
	fake.updateDesiredLRPArgsForCall = append(fake.updateDesiredLRPArgsForCall, struct {
		arg1 context.Context
		arg2 lager.Logger
		arg3 string
		arg4 *models.DesiredLRPUpdate
	}{arg1, arg2, arg3, arg4})
	stub := fake.UpdateDesiredLRPStub
	fakeReturns := fake.updateDesiredLRPReturns
	fake.recordInvocation("UpdateDesiredLRP", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateDesiredLRPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeLRPDB) UpdateDesiredLRPCallCount() int {
	fake.updateDesiredLRPMutex.RLock()
	defer fake.updateDesiredLRPMutex.RUnlock()
	return len(fake.updateDesiredLRPArgsForCall)
}

func (fake *FakeLRPDB) UpdateDesiredLRPCalls(stub func(context.Context, lager.Logger, string, *models.DesiredLRPUpdate) (*models.DesiredLRP, error)) {
	fake.updateDesiredLRPMutex.Lock()
	defer fake.updateDesiredLRPMutex.Unlock()
	fake.UpdateDesiredLRPStub = stub
}

func (fake *FakeLRPDB) UpdateDesiredLRPArgsForCall(i int) (context.Context, lager.Logger, string, *models.DesiredLRPUpdate) {
	fake.updateDesiredLRPMutex.RLock()
	defer fake.updateDesiredLRPMutex.RUnlock()
	argsForCall := fake.updateDesiredLRPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeLRPDB) UpdateDesiredLRPReturns(result1 *models.DesiredLRP, result2 error) {
	fake.updateDesiredLRPMutex.Lock()
	defer fake.updateDesiredLRPMutex.Unlock()
	fake.UpdateDesiredLRPStub = nil
	fake.updateDesiredLRPReturns = struct {
		result1 *models.DesiredLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) UpdateDesiredLRPReturnsOnCall(i int, result1 *models.DesiredLRP, result2 error) {
	fake.updateDesiredLRPMutex.Lock()
	defer fake.updateDesiredLRPMutex.Unlock()
	fake.UpdateDesiredLRPStub = nil
	if fake.updateDesiredLRPReturnsOnCall == nil {
		fake.updateDesiredLRPReturnsOnCall = make(map[int]struct {
			result1 *models.DesiredLRP
			result2 error
		})
	}
	fake.updateDesiredLRPReturnsOnCall[i] = struct {
		result1 *models.DesiredLRP
		result2 error
	}{result1, result2}
}

func (fake *FakeLRPDB) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.actualLRPsMutex.RLock()
	defer fake.actualLRPsMutex.RUnlock()
	fake.changeActualLRPPresenceMutex.RLock()
	defer fake.changeActualLRPPresenceMutex.RUnlock()
	fake.claimActualLRPMutex.RLock()
	defer fake.claimActualLRPMutex.RUnlock()
	fake.convergeLRPsMutex.RLock()
	defer fake.convergeLRPsMutex.RUnlock()
	fake.countActualLRPsByStateMutex.RLock()
	defer fake.countActualLRPsByStateMutex.RUnlock()
	fake.countDesiredInstancesMutex.RLock()
	defer fake.countDesiredInstancesMutex.RUnlock()
	fake.crashActualLRPMutex.RLock()
	defer fake.crashActualLRPMutex.RUnlock()
	fake.createUnclaimedActualLRPMutex.RLock()
	defer fake.createUnclaimedActualLRPMutex.RUnlock()
	fake.desireLRPMutex.RLock()
	defer fake.desireLRPMutex.RUnlock()
	fake.desiredLRPByProcessGuidMutex.RLock()
	defer fake.desiredLRPByProcessGuidMutex.RUnlock()
	fake.desiredLRPSchedulingInfosMutex.RLock()
	defer fake.desiredLRPSchedulingInfosMutex.RUnlock()
	fake.desiredLRPsMutex.RLock()
	defer fake.desiredLRPsMutex.RUnlock()
	fake.failActualLRPMutex.RLock()
	defer fake.failActualLRPMutex.RUnlock()
	fake.removeActualLRPMutex.RLock()
	defer fake.removeActualLRPMutex.RUnlock()
	fake.removeDesiredLRPMutex.RLock()
	defer fake.removeDesiredLRPMutex.RUnlock()
	fake.startActualLRPMutex.RLock()
	defer fake.startActualLRPMutex.RUnlock()
	fake.unclaimActualLRPMutex.RLock()
	defer fake.unclaimActualLRPMutex.RUnlock()
	fake.updateDesiredLRPMutex.RLock()
	defer fake.updateDesiredLRPMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

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