fake_manager.go

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

import (
	"sync"

	"github.com/cloudfoundry/bosh-agent/platform/disk"
)

type FakeManager struct {
	GetEphemeralDevicePartitionerStub        func() disk.Partitioner
	getEphemeralDevicePartitionerMutex       sync.RWMutex
	getEphemeralDevicePartitionerArgsForCall []struct{}
	getEphemeralDevicePartitionerReturns     struct {
		result1 disk.Partitioner
	}
	getEphemeralDevicePartitionerReturnsOnCall map[int]struct {
		result1 disk.Partitioner
	}
	GetFormatterStub        func() disk.Formatter
	getFormatterMutex       sync.RWMutex
	getFormatterArgsForCall []struct{}
	getFormatterReturns     struct {
		result1 disk.Formatter
	}
	getFormatterReturnsOnCall map[int]struct {
		result1 disk.Formatter
	}
	GetMounterStub        func() disk.Mounter
	getMounterMutex       sync.RWMutex
	getMounterArgsForCall []struct{}
	getMounterReturns     struct {
		result1 disk.Mounter
	}
	getMounterReturnsOnCall map[int]struct {
		result1 disk.Mounter
	}
	GetMountsSearcherStub        func() disk.MountsSearcher
	getMountsSearcherMutex       sync.RWMutex
	getMountsSearcherArgsForCall []struct{}
	getMountsSearcherReturns     struct {
		result1 disk.MountsSearcher
	}
	getMountsSearcherReturnsOnCall map[int]struct {
		result1 disk.MountsSearcher
	}
	GetPersistentDevicePartitionerStub        func(partitionerType string) (disk.Partitioner, error)
	getPersistentDevicePartitionerMutex       sync.RWMutex
	getPersistentDevicePartitionerArgsForCall []struct {
		partitionerType string
	}
	getPersistentDevicePartitionerReturns struct {
		result1 disk.Partitioner
		result2 error
	}
	getPersistentDevicePartitionerReturnsOnCall map[int]struct {
		result1 disk.Partitioner
		result2 error
	}
	GetRootDevicePartitionerStub        func() disk.Partitioner
	getRootDevicePartitionerMutex       sync.RWMutex
	getRootDevicePartitionerArgsForCall []struct{}
	getRootDevicePartitionerReturns     struct {
		result1 disk.Partitioner
	}
	getRootDevicePartitionerReturnsOnCall map[int]struct {
		result1 disk.Partitioner
	}
	GetUtilStub        func() disk.Util
	getUtilMutex       sync.RWMutex
	getUtilArgsForCall []struct{}
	getUtilReturns     struct {
		result1 disk.Util
	}
	getUtilReturnsOnCall map[int]struct {
		result1 disk.Util
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeManager) GetEphemeralDevicePartitioner() disk.Partitioner {
	fake.getEphemeralDevicePartitionerMutex.Lock()
	ret, specificReturn := fake.getEphemeralDevicePartitionerReturnsOnCall[len(fake.getEphemeralDevicePartitionerArgsForCall)]
	fake.getEphemeralDevicePartitionerArgsForCall = append(fake.getEphemeralDevicePartitionerArgsForCall, struct{}{})
	fake.recordInvocation("GetEphemeralDevicePartitioner", []interface{}{})
	fake.getEphemeralDevicePartitionerMutex.Unlock()
	if fake.GetEphemeralDevicePartitionerStub != nil {
		return fake.GetEphemeralDevicePartitionerStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.getEphemeralDevicePartitionerReturns.result1
}

func (fake *FakeManager) GetEphemeralDevicePartitionerCallCount() int {
	fake.getEphemeralDevicePartitionerMutex.RLock()
	defer fake.getEphemeralDevicePartitionerMutex.RUnlock()
	return len(fake.getEphemeralDevicePartitionerArgsForCall)
}

func (fake *FakeManager) GetEphemeralDevicePartitionerReturns(result1 disk.Partitioner) {
	fake.GetEphemeralDevicePartitionerStub = nil
	fake.getEphemeralDevicePartitionerReturns = struct {
		result1 disk.Partitioner
	}{result1}
}

func (fake *FakeManager) GetEphemeralDevicePartitionerReturnsOnCall(i int, result1 disk.Partitioner) {
	fake.GetEphemeralDevicePartitionerStub = nil
	if fake.getEphemeralDevicePartitionerReturnsOnCall == nil {
		fake.getEphemeralDevicePartitionerReturnsOnCall = make(map[int]struct {
			result1 disk.Partitioner
		})
	}
	fake.getEphemeralDevicePartitionerReturnsOnCall[i] = struct {
		result1 disk.Partitioner
	}{result1}
}

func (fake *FakeManager) GetFormatter() disk.Formatter {
	fake.getFormatterMutex.Lock()
	ret, specificReturn := fake.getFormatterReturnsOnCall[len(fake.getFormatterArgsForCall)]
	fake.getFormatterArgsForCall = append(fake.getFormatterArgsForCall, struct{}{})
	fake.recordInvocation("GetFormatter", []interface{}{})
	fake.getFormatterMutex.Unlock()
	if fake.GetFormatterStub != nil {
		return fake.GetFormatterStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.getFormatterReturns.result1
}

func (fake *FakeManager) GetFormatterCallCount() int {
	fake.getFormatterMutex.RLock()
	defer fake.getFormatterMutex.RUnlock()
	return len(fake.getFormatterArgsForCall)
}

func (fake *FakeManager) GetFormatterReturns(result1 disk.Formatter) {
	fake.GetFormatterStub = nil
	fake.getFormatterReturns = struct {
		result1 disk.Formatter
	}{result1}
}

func (fake *FakeManager) GetFormatterReturnsOnCall(i int, result1 disk.Formatter) {
	fake.GetFormatterStub = nil
	if fake.getFormatterReturnsOnCall == nil {
		fake.getFormatterReturnsOnCall = make(map[int]struct {
			result1 disk.Formatter
		})
	}
	fake.getFormatterReturnsOnCall[i] = struct {
		result1 disk.Formatter
	}{result1}
}

func (fake *FakeManager) GetMounter() disk.Mounter {
	fake.getMounterMutex.Lock()
	ret, specificReturn := fake.getMounterReturnsOnCall[len(fake.getMounterArgsForCall)]
	fake.getMounterArgsForCall = append(fake.getMounterArgsForCall, struct{}{})
	fake.recordInvocation("GetMounter", []interface{}{})
	fake.getMounterMutex.Unlock()
	if fake.GetMounterStub != nil {
		return fake.GetMounterStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.getMounterReturns.result1
}

func (fake *FakeManager) GetMounterCallCount() int {
	fake.getMounterMutex.RLock()
	defer fake.getMounterMutex.RUnlock()
	return len(fake.getMounterArgsForCall)
}

func (fake *FakeManager) GetMounterReturns(result1 disk.Mounter) {
	fake.GetMounterStub = nil
	fake.getMounterReturns = struct {
		result1 disk.Mounter
	}{result1}
}

func (fake *FakeManager) GetMounterReturnsOnCall(i int, result1 disk.Mounter) {
	fake.GetMounterStub = nil
	if fake.getMounterReturnsOnCall == nil {
		fake.getMounterReturnsOnCall = make(map[int]struct {
			result1 disk.Mounter
		})
	}
	fake.getMounterReturnsOnCall[i] = struct {
		result1 disk.Mounter
	}{result1}
}

func (fake *FakeManager) GetMountsSearcher() disk.MountsSearcher {
	fake.getMountsSearcherMutex.Lock()
	ret, specificReturn := fake.getMountsSearcherReturnsOnCall[len(fake.getMountsSearcherArgsForCall)]
	fake.getMountsSearcherArgsForCall = append(fake.getMountsSearcherArgsForCall, struct{}{})
	fake.recordInvocation("GetMountsSearcher", []interface{}{})
	fake.getMountsSearcherMutex.Unlock()
	if fake.GetMountsSearcherStub != nil {
		return fake.GetMountsSearcherStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.getMountsSearcherReturns.result1
}

func (fake *FakeManager) GetMountsSearcherCallCount() int {
	fake.getMountsSearcherMutex.RLock()
	defer fake.getMountsSearcherMutex.RUnlock()
	return len(fake.getMountsSearcherArgsForCall)
}

func (fake *FakeManager) GetMountsSearcherReturns(result1 disk.MountsSearcher) {
	fake.GetMountsSearcherStub = nil
	fake.getMountsSearcherReturns = struct {
		result1 disk.MountsSearcher
	}{result1}
}

func (fake *FakeManager) GetMountsSearcherReturnsOnCall(i int, result1 disk.MountsSearcher) {
	fake.GetMountsSearcherStub = nil
	if fake.getMountsSearcherReturnsOnCall == nil {
		fake.getMountsSearcherReturnsOnCall = make(map[int]struct {
			result1 disk.MountsSearcher
		})
	}
	fake.getMountsSearcherReturnsOnCall[i] = struct {
		result1 disk.MountsSearcher
	}{result1}
}

func (fake *FakeManager) GetPersistentDevicePartitioner(partitionerType string) (disk.Partitioner, error) {
	fake.getPersistentDevicePartitionerMutex.Lock()
	ret, specificReturn := fake.getPersistentDevicePartitionerReturnsOnCall[len(fake.getPersistentDevicePartitionerArgsForCall)]
	fake.getPersistentDevicePartitionerArgsForCall = append(fake.getPersistentDevicePartitionerArgsForCall, struct {
		partitionerType string
	}{partitionerType})
	fake.recordInvocation("GetPersistentDevicePartitioner", []interface{}{partitionerType})
	fake.getPersistentDevicePartitionerMutex.Unlock()
	if fake.GetPersistentDevicePartitionerStub != nil {
		return fake.GetPersistentDevicePartitionerStub(partitionerType)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.getPersistentDevicePartitionerReturns.result1, fake.getPersistentDevicePartitionerReturns.result2
}

func (fake *FakeManager) GetPersistentDevicePartitionerCallCount() int {
	fake.getPersistentDevicePartitionerMutex.RLock()
	defer fake.getPersistentDevicePartitionerMutex.RUnlock()
	return len(fake.getPersistentDevicePartitionerArgsForCall)
}

func (fake *FakeManager) GetPersistentDevicePartitionerArgsForCall(i int) string {
	fake.getPersistentDevicePartitionerMutex.RLock()
	defer fake.getPersistentDevicePartitionerMutex.RUnlock()
	return fake.getPersistentDevicePartitionerArgsForCall[i].partitionerType
}

func (fake *FakeManager) GetPersistentDevicePartitionerReturns(result1 disk.Partitioner, result2 error) {
	fake.GetPersistentDevicePartitionerStub = nil
	fake.getPersistentDevicePartitionerReturns = struct {
		result1 disk.Partitioner
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) GetPersistentDevicePartitionerReturnsOnCall(i int, result1 disk.Partitioner, result2 error) {
	fake.GetPersistentDevicePartitionerStub = nil
	if fake.getPersistentDevicePartitionerReturnsOnCall == nil {
		fake.getPersistentDevicePartitionerReturnsOnCall = make(map[int]struct {
			result1 disk.Partitioner
			result2 error
		})
	}
	fake.getPersistentDevicePartitionerReturnsOnCall[i] = struct {
		result1 disk.Partitioner
		result2 error
	}{result1, result2}
}

func (fake *FakeManager) GetRootDevicePartitioner() disk.Partitioner {
	fake.getRootDevicePartitionerMutex.Lock()
	ret, specificReturn := fake.getRootDevicePartitionerReturnsOnCall[len(fake.getRootDevicePartitionerArgsForCall)]
	fake.getRootDevicePartitionerArgsForCall = append(fake.getRootDevicePartitionerArgsForCall, struct{}{})
	fake.recordInvocation("GetRootDevicePartitioner", []interface{}{})
	fake.getRootDevicePartitionerMutex.Unlock()
	if fake.GetRootDevicePartitionerStub != nil {
		return fake.GetRootDevicePartitionerStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.getRootDevicePartitionerReturns.result1
}

func (fake *FakeManager) GetRootDevicePartitionerCallCount() int {
	fake.getRootDevicePartitionerMutex.RLock()
	defer fake.getRootDevicePartitionerMutex.RUnlock()
	return len(fake.getRootDevicePartitionerArgsForCall)
}

func (fake *FakeManager) GetRootDevicePartitionerReturns(result1 disk.Partitioner) {
	fake.GetRootDevicePartitionerStub = nil
	fake.getRootDevicePartitionerReturns = struct {
		result1 disk.Partitioner
	}{result1}
}

func (fake *FakeManager) GetRootDevicePartitionerReturnsOnCall(i int, result1 disk.Partitioner) {
	fake.GetRootDevicePartitionerStub = nil
	if fake.getRootDevicePartitionerReturnsOnCall == nil {
		fake.getRootDevicePartitionerReturnsOnCall = make(map[int]struct {
			result1 disk.Partitioner
		})
	}
	fake.getRootDevicePartitionerReturnsOnCall[i] = struct {
		result1 disk.Partitioner
	}{result1}
}

func (fake *FakeManager) GetUtil() disk.Util {
	fake.getUtilMutex.Lock()
	ret, specificReturn := fake.getUtilReturnsOnCall[len(fake.getUtilArgsForCall)]
	fake.getUtilArgsForCall = append(fake.getUtilArgsForCall, struct{}{})
	fake.recordInvocation("GetUtil", []interface{}{})
	fake.getUtilMutex.Unlock()
	if fake.GetUtilStub != nil {
		return fake.GetUtilStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.getUtilReturns.result1
}

func (fake *FakeManager) GetUtilCallCount() int {
	fake.getUtilMutex.RLock()
	defer fake.getUtilMutex.RUnlock()
	return len(fake.getUtilArgsForCall)
}

func (fake *FakeManager) GetUtilReturns(result1 disk.Util) {
	fake.GetUtilStub = nil
	fake.getUtilReturns = struct {
		result1 disk.Util
	}{result1}
}

func (fake *FakeManager) GetUtilReturnsOnCall(i int, result1 disk.Util) {
	fake.GetUtilStub = nil
	if fake.getUtilReturnsOnCall == nil {
		fake.getUtilReturnsOnCall = make(map[int]struct {
			result1 disk.Util
		})
	}
	fake.getUtilReturnsOnCall[i] = struct {
		result1 disk.Util
	}{result1}
}

func (fake *FakeManager) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.getEphemeralDevicePartitionerMutex.RLock()
	defer fake.getEphemeralDevicePartitionerMutex.RUnlock()
	fake.getFormatterMutex.RLock()
	defer fake.getFormatterMutex.RUnlock()
	fake.getMounterMutex.RLock()
	defer fake.getMounterMutex.RUnlock()
	fake.getMountsSearcherMutex.RLock()
	defer fake.getMountsSearcherMutex.RUnlock()
	fake.getPersistentDevicePartitionerMutex.RLock()
	defer fake.getPersistentDevicePartitionerMutex.RUnlock()
	fake.getRootDevicePartitionerMutex.RLock()
	defer fake.getRootDevicePartitionerMutex.RUnlock()
	fake.getUtilMutex.RLock()
	defer fake.getUtilMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeManager) 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 _ disk.Manager = new(FakeManager)