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

import (
	"sync"

	"github.com/cloudfoundry/bosh-agent/agent/applier/jobs"
	"github.com/cloudfoundry/bosh-agent/agent/applier/models"
)

type FakeApplier struct {
	ApplyStub        func(models.Job) error
	applyMutex       sync.RWMutex
	applyArgsForCall []struct {
		arg1 models.Job
	}
	applyReturns struct {
		result1 error
	}
	applyReturnsOnCall map[int]struct {
		result1 error
	}
	ConfigureStub        func(models.Job, int) error
	configureMutex       sync.RWMutex
	configureArgsForCall []struct {
		arg1 models.Job
		arg2 int
	}
	configureReturns struct {
		result1 error
	}
	configureReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteSourceBlobsStub        func([]models.Job) error
	deleteSourceBlobsMutex       sync.RWMutex
	deleteSourceBlobsArgsForCall []struct {
		arg1 []models.Job
	}
	deleteSourceBlobsReturns struct {
		result1 error
	}
	deleteSourceBlobsReturnsOnCall map[int]struct {
		result1 error
	}
	KeepOnlyStub        func([]models.Job) error
	keepOnlyMutex       sync.RWMutex
	keepOnlyArgsForCall []struct {
		arg1 []models.Job
	}
	keepOnlyReturns struct {
		result1 error
	}
	keepOnlyReturnsOnCall map[int]struct {
		result1 error
	}
	PrepareStub        func(models.Job) error
	prepareMutex       sync.RWMutex
	prepareArgsForCall []struct {
		arg1 models.Job
	}
	prepareReturns struct {
		result1 error
	}
	prepareReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeApplier) Apply(arg1 models.Job) error {
	fake.applyMutex.Lock()
	ret, specificReturn := fake.applyReturnsOnCall[len(fake.applyArgsForCall)]
	fake.applyArgsForCall = append(fake.applyArgsForCall, struct {
		arg1 models.Job
	}{arg1})
	fake.recordInvocation("Apply", []interface{}{arg1})
	fake.applyMutex.Unlock()
	if fake.ApplyStub != nil {
		return fake.ApplyStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.applyReturns
	return fakeReturns.result1
}

func (fake *FakeApplier) ApplyCallCount() int {
	fake.applyMutex.RLock()
	defer fake.applyMutex.RUnlock()
	return len(fake.applyArgsForCall)
}

func (fake *FakeApplier) ApplyCalls(stub func(models.Job) error) {
	fake.applyMutex.Lock()
	defer fake.applyMutex.Unlock()
	fake.ApplyStub = stub
}

func (fake *FakeApplier) ApplyArgsForCall(i int) models.Job {
	fake.applyMutex.RLock()
	defer fake.applyMutex.RUnlock()
	argsForCall := fake.applyArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeApplier) ApplyReturns(result1 error) {
	fake.applyMutex.Lock()
	defer fake.applyMutex.Unlock()
	fake.ApplyStub = nil
	fake.applyReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) ApplyReturnsOnCall(i int, result1 error) {
	fake.applyMutex.Lock()
	defer fake.applyMutex.Unlock()
	fake.ApplyStub = nil
	if fake.applyReturnsOnCall == nil {
		fake.applyReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.applyReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) Configure(arg1 models.Job, arg2 int) error {
	fake.configureMutex.Lock()
	ret, specificReturn := fake.configureReturnsOnCall[len(fake.configureArgsForCall)]
	fake.configureArgsForCall = append(fake.configureArgsForCall, struct {
		arg1 models.Job
		arg2 int
	}{arg1, arg2})
	fake.recordInvocation("Configure", []interface{}{arg1, arg2})
	fake.configureMutex.Unlock()
	if fake.ConfigureStub != nil {
		return fake.ConfigureStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.configureReturns
	return fakeReturns.result1
}

func (fake *FakeApplier) ConfigureCallCount() int {
	fake.configureMutex.RLock()
	defer fake.configureMutex.RUnlock()
	return len(fake.configureArgsForCall)
}

func (fake *FakeApplier) ConfigureCalls(stub func(models.Job, int) error) {
	fake.configureMutex.Lock()
	defer fake.configureMutex.Unlock()
	fake.ConfigureStub = stub
}

func (fake *FakeApplier) ConfigureArgsForCall(i int) (models.Job, int) {
	fake.configureMutex.RLock()
	defer fake.configureMutex.RUnlock()
	argsForCall := fake.configureArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeApplier) ConfigureReturns(result1 error) {
	fake.configureMutex.Lock()
	defer fake.configureMutex.Unlock()
	fake.ConfigureStub = nil
	fake.configureReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) ConfigureReturnsOnCall(i int, result1 error) {
	fake.configureMutex.Lock()
	defer fake.configureMutex.Unlock()
	fake.ConfigureStub = nil
	if fake.configureReturnsOnCall == nil {
		fake.configureReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.configureReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) DeleteSourceBlobs(arg1 []models.Job) error {
	var arg1Copy []models.Job
	if arg1 != nil {
		arg1Copy = make([]models.Job, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.deleteSourceBlobsMutex.Lock()
	ret, specificReturn := fake.deleteSourceBlobsReturnsOnCall[len(fake.deleteSourceBlobsArgsForCall)]
	fake.deleteSourceBlobsArgsForCall = append(fake.deleteSourceBlobsArgsForCall, struct {
		arg1 []models.Job
	}{arg1Copy})
	fake.recordInvocation("DeleteSourceBlobs", []interface{}{arg1Copy})
	fake.deleteSourceBlobsMutex.Unlock()
	if fake.DeleteSourceBlobsStub != nil {
		return fake.DeleteSourceBlobsStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.deleteSourceBlobsReturns
	return fakeReturns.result1
}

func (fake *FakeApplier) DeleteSourceBlobsCallCount() int {
	fake.deleteSourceBlobsMutex.RLock()
	defer fake.deleteSourceBlobsMutex.RUnlock()
	return len(fake.deleteSourceBlobsArgsForCall)
}

func (fake *FakeApplier) DeleteSourceBlobsCalls(stub func([]models.Job) error) {
	fake.deleteSourceBlobsMutex.Lock()
	defer fake.deleteSourceBlobsMutex.Unlock()
	fake.DeleteSourceBlobsStub = stub
}

func (fake *FakeApplier) DeleteSourceBlobsArgsForCall(i int) []models.Job {
	fake.deleteSourceBlobsMutex.RLock()
	defer fake.deleteSourceBlobsMutex.RUnlock()
	argsForCall := fake.deleteSourceBlobsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeApplier) DeleteSourceBlobsReturns(result1 error) {
	fake.deleteSourceBlobsMutex.Lock()
	defer fake.deleteSourceBlobsMutex.Unlock()
	fake.DeleteSourceBlobsStub = nil
	fake.deleteSourceBlobsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) DeleteSourceBlobsReturnsOnCall(i int, result1 error) {
	fake.deleteSourceBlobsMutex.Lock()
	defer fake.deleteSourceBlobsMutex.Unlock()
	fake.DeleteSourceBlobsStub = nil
	if fake.deleteSourceBlobsReturnsOnCall == nil {
		fake.deleteSourceBlobsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteSourceBlobsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) KeepOnly(arg1 []models.Job) error {
	var arg1Copy []models.Job
	if arg1 != nil {
		arg1Copy = make([]models.Job, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.keepOnlyMutex.Lock()
	ret, specificReturn := fake.keepOnlyReturnsOnCall[len(fake.keepOnlyArgsForCall)]
	fake.keepOnlyArgsForCall = append(fake.keepOnlyArgsForCall, struct {
		arg1 []models.Job
	}{arg1Copy})
	fake.recordInvocation("KeepOnly", []interface{}{arg1Copy})
	fake.keepOnlyMutex.Unlock()
	if fake.KeepOnlyStub != nil {
		return fake.KeepOnlyStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.keepOnlyReturns
	return fakeReturns.result1
}

func (fake *FakeApplier) KeepOnlyCallCount() int {
	fake.keepOnlyMutex.RLock()
	defer fake.keepOnlyMutex.RUnlock()
	return len(fake.keepOnlyArgsForCall)
}

func (fake *FakeApplier) KeepOnlyCalls(stub func([]models.Job) error) {
	fake.keepOnlyMutex.Lock()
	defer fake.keepOnlyMutex.Unlock()
	fake.KeepOnlyStub = stub
}

func (fake *FakeApplier) KeepOnlyArgsForCall(i int) []models.Job {
	fake.keepOnlyMutex.RLock()
	defer fake.keepOnlyMutex.RUnlock()
	argsForCall := fake.keepOnlyArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeApplier) KeepOnlyReturns(result1 error) {
	fake.keepOnlyMutex.Lock()
	defer fake.keepOnlyMutex.Unlock()
	fake.KeepOnlyStub = nil
	fake.keepOnlyReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) KeepOnlyReturnsOnCall(i int, result1 error) {
	fake.keepOnlyMutex.Lock()
	defer fake.keepOnlyMutex.Unlock()
	fake.KeepOnlyStub = nil
	if fake.keepOnlyReturnsOnCall == nil {
		fake.keepOnlyReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.keepOnlyReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) Prepare(arg1 models.Job) error {
	fake.prepareMutex.Lock()
	ret, specificReturn := fake.prepareReturnsOnCall[len(fake.prepareArgsForCall)]
	fake.prepareArgsForCall = append(fake.prepareArgsForCall, struct {
		arg1 models.Job
	}{arg1})
	fake.recordInvocation("Prepare", []interface{}{arg1})
	fake.prepareMutex.Unlock()
	if fake.PrepareStub != nil {
		return fake.PrepareStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.prepareReturns
	return fakeReturns.result1
}

func (fake *FakeApplier) PrepareCallCount() int {
	fake.prepareMutex.RLock()
	defer fake.prepareMutex.RUnlock()
	return len(fake.prepareArgsForCall)
}

func (fake *FakeApplier) PrepareCalls(stub func(models.Job) error) {
	fake.prepareMutex.Lock()
	defer fake.prepareMutex.Unlock()
	fake.PrepareStub = stub
}

func (fake *FakeApplier) PrepareArgsForCall(i int) models.Job {
	fake.prepareMutex.RLock()
	defer fake.prepareMutex.RUnlock()
	argsForCall := fake.prepareArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeApplier) PrepareReturns(result1 error) {
	fake.prepareMutex.Lock()
	defer fake.prepareMutex.Unlock()
	fake.PrepareStub = nil
	fake.prepareReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) PrepareReturnsOnCall(i int, result1 error) {
	fake.prepareMutex.Lock()
	defer fake.prepareMutex.Unlock()
	fake.PrepareStub = nil
	if fake.prepareReturnsOnCall == nil {
		fake.prepareReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.prepareReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeApplier) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.applyMutex.RLock()
	defer fake.applyMutex.RUnlock()
	fake.configureMutex.RLock()
	defer fake.configureMutex.RUnlock()
	fake.deleteSourceBlobsMutex.RLock()
	defer fake.deleteSourceBlobsMutex.RUnlock()
	fake.keepOnlyMutex.RLock()
	defer fake.keepOnlyMutex.RUnlock()
	fake.prepareMutex.RLock()
	defer fake.prepareMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeApplier) 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 _ jobs.Applier = new(FakeApplier)
