package diskfakes

import (
	"sync"

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

type FakeMounter struct {
	MountStub        func(partitionPath, mountPoint string, mountOptions ...string) (err error)
	mountMutex       sync.RWMutex
	mountArgsForCall []struct {
		partitionPath string
		mountPoint    string
		mountOptions  []string
	}
	mountReturns struct {
		result1 error
	}
	mountReturnsOnCall map[int]struct {
		result1 error
	}
	MountFilesystemStub        func(partitionPath, mountPoint, fstype string, mountOptions ...string) (err error)
	mountFilesystemMutex       sync.RWMutex
	mountFilesystemArgsForCall []struct {
		partitionPath string
		mountPoint    string
		fstype        string
		mountOptions  []string
	}
	mountFilesystemReturns struct {
		result1 error
	}
	mountFilesystemReturnsOnCall map[int]struct {
		result1 error
	}
	UnmountStub        func(partitionOrMountPoint string) (didUnmount bool, err error)
	unmountMutex       sync.RWMutex
	unmountArgsForCall []struct {
		partitionOrMountPoint string
	}
	unmountReturns struct {
		result1 bool
		result2 error
	}
	unmountReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	RemountAsReadonlyStub        func(mountPoint string) (err error)
	remountAsReadonlyMutex       sync.RWMutex
	remountAsReadonlyArgsForCall []struct {
		mountPoint string
	}
	remountAsReadonlyReturns struct {
		result1 error
	}
	remountAsReadonlyReturnsOnCall map[int]struct {
		result1 error
	}
	RemountStub        func(fromMountPoint, toMountPoint string, mountOptions ...string) (err error)
	remountMutex       sync.RWMutex
	remountArgsForCall []struct {
		fromMountPoint string
		toMountPoint   string
		mountOptions   []string
	}
	remountReturns struct {
		result1 error
	}
	remountReturnsOnCall map[int]struct {
		result1 error
	}
	RemountInPlaceStub        func(mountPoint string, mountOptions ...string) (err error)
	remountInPlaceMutex       sync.RWMutex
	remountInPlaceArgsForCall []struct {
		mountPoint   string
		mountOptions []string
	}
	remountInPlaceReturns struct {
		result1 error
	}
	remountInPlaceReturnsOnCall map[int]struct {
		result1 error
	}
	SwapOnStub        func(partitionPath string) (err error)
	swapOnMutex       sync.RWMutex
	swapOnArgsForCall []struct {
		partitionPath string
	}
	swapOnReturns struct {
		result1 error
	}
	swapOnReturnsOnCall map[int]struct {
		result1 error
	}
	IsMountPointStub        func(path string) (parititionPath string, result bool, err error)
	isMountPointMutex       sync.RWMutex
	isMountPointArgsForCall []struct {
		path string
	}
	isMountPointReturns struct {
		result1 string
		result2 bool
		result3 error
	}
	isMountPointReturnsOnCall map[int]struct {
		result1 string
		result2 bool
		result3 error
	}
	IsMountedStub        func(devicePathOrMountPoint string) (result bool, err error)
	isMountedMutex       sync.RWMutex
	isMountedArgsForCall []struct {
		devicePathOrMountPoint string
	}
	isMountedReturns struct {
		result1 bool
		result2 error
	}
	isMountedReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeMounter) Mount(partitionPath string, mountPoint string, mountOptions ...string) (err error) {
	fake.mountMutex.Lock()
	ret, specificReturn := fake.mountReturnsOnCall[len(fake.mountArgsForCall)]
	fake.mountArgsForCall = append(fake.mountArgsForCall, struct {
		partitionPath string
		mountPoint    string
		mountOptions  []string
	}{partitionPath, mountPoint, mountOptions})
	fake.recordInvocation("Mount", []interface{}{partitionPath, mountPoint, mountOptions})
	fake.mountMutex.Unlock()
	if fake.MountStub != nil {
		return fake.MountStub(partitionPath, mountPoint, mountOptions...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.mountReturns.result1
}

func (fake *FakeMounter) MountCallCount() int {
	fake.mountMutex.RLock()
	defer fake.mountMutex.RUnlock()
	return len(fake.mountArgsForCall)
}

func (fake *FakeMounter) MountArgsForCall(i int) (string, string, []string) {
	fake.mountMutex.RLock()
	defer fake.mountMutex.RUnlock()
	return fake.mountArgsForCall[i].partitionPath, fake.mountArgsForCall[i].mountPoint, fake.mountArgsForCall[i].mountOptions
}

func (fake *FakeMounter) MountReturns(result1 error) {
	fake.MountStub = nil
	fake.mountReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) MountReturnsOnCall(i int, result1 error) {
	fake.MountStub = nil
	if fake.mountReturnsOnCall == nil {
		fake.mountReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.mountReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) MountFilesystem(partitionPath string, mountPoint string, fstype string, mountOptions ...string) (err error) {
	fake.mountFilesystemMutex.Lock()
	ret, specificReturn := fake.mountFilesystemReturnsOnCall[len(fake.mountFilesystemArgsForCall)]
	fake.mountFilesystemArgsForCall = append(fake.mountFilesystemArgsForCall, struct {
		partitionPath string
		mountPoint    string
		fstype        string
		mountOptions  []string
	}{partitionPath, mountPoint, fstype, mountOptions})
	fake.recordInvocation("MountFilesystem", []interface{}{partitionPath, mountPoint, fstype, mountOptions})
	fake.mountFilesystemMutex.Unlock()
	if fake.MountFilesystemStub != nil {
		return fake.MountFilesystemStub(partitionPath, mountPoint, fstype, mountOptions...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.mountFilesystemReturns.result1
}

func (fake *FakeMounter) MountFilesystemCallCount() int {
	fake.mountFilesystemMutex.RLock()
	defer fake.mountFilesystemMutex.RUnlock()
	return len(fake.mountFilesystemArgsForCall)
}

func (fake *FakeMounter) MountFilesystemArgsForCall(i int) (string, string, string, []string) {
	fake.mountFilesystemMutex.RLock()
	defer fake.mountFilesystemMutex.RUnlock()
	return fake.mountFilesystemArgsForCall[i].partitionPath, fake.mountFilesystemArgsForCall[i].mountPoint, fake.mountFilesystemArgsForCall[i].fstype, fake.mountFilesystemArgsForCall[i].mountOptions
}

func (fake *FakeMounter) MountFilesystemReturns(result1 error) {
	fake.MountFilesystemStub = nil
	fake.mountFilesystemReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) MountFilesystemReturnsOnCall(i int, result1 error) {
	fake.MountFilesystemStub = nil
	if fake.mountFilesystemReturnsOnCall == nil {
		fake.mountFilesystemReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.mountFilesystemReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) Unmount(partitionOrMountPoint string) (didUnmount bool, err error) {
	fake.unmountMutex.Lock()
	ret, specificReturn := fake.unmountReturnsOnCall[len(fake.unmountArgsForCall)]
	fake.unmountArgsForCall = append(fake.unmountArgsForCall, struct {
		partitionOrMountPoint string
	}{partitionOrMountPoint})
	fake.recordInvocation("Unmount", []interface{}{partitionOrMountPoint})
	fake.unmountMutex.Unlock()
	if fake.UnmountStub != nil {
		return fake.UnmountStub(partitionOrMountPoint)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.unmountReturns.result1, fake.unmountReturns.result2
}

func (fake *FakeMounter) UnmountCallCount() int {
	fake.unmountMutex.RLock()
	defer fake.unmountMutex.RUnlock()
	return len(fake.unmountArgsForCall)
}

func (fake *FakeMounter) UnmountArgsForCall(i int) string {
	fake.unmountMutex.RLock()
	defer fake.unmountMutex.RUnlock()
	return fake.unmountArgsForCall[i].partitionOrMountPoint
}

func (fake *FakeMounter) UnmountReturns(result1 bool, result2 error) {
	fake.UnmountStub = nil
	fake.unmountReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeMounter) UnmountReturnsOnCall(i int, result1 bool, result2 error) {
	fake.UnmountStub = nil
	if fake.unmountReturnsOnCall == nil {
		fake.unmountReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.unmountReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeMounter) RemountAsReadonly(mountPoint string) (err error) {
	fake.remountAsReadonlyMutex.Lock()
	ret, specificReturn := fake.remountAsReadonlyReturnsOnCall[len(fake.remountAsReadonlyArgsForCall)]
	fake.remountAsReadonlyArgsForCall = append(fake.remountAsReadonlyArgsForCall, struct {
		mountPoint string
	}{mountPoint})
	fake.recordInvocation("RemountAsReadonly", []interface{}{mountPoint})
	fake.remountAsReadonlyMutex.Unlock()
	if fake.RemountAsReadonlyStub != nil {
		return fake.RemountAsReadonlyStub(mountPoint)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.remountAsReadonlyReturns.result1
}

func (fake *FakeMounter) RemountAsReadonlyCallCount() int {
	fake.remountAsReadonlyMutex.RLock()
	defer fake.remountAsReadonlyMutex.RUnlock()
	return len(fake.remountAsReadonlyArgsForCall)
}

func (fake *FakeMounter) RemountAsReadonlyArgsForCall(i int) string {
	fake.remountAsReadonlyMutex.RLock()
	defer fake.remountAsReadonlyMutex.RUnlock()
	return fake.remountAsReadonlyArgsForCall[i].mountPoint
}

func (fake *FakeMounter) RemountAsReadonlyReturns(result1 error) {
	fake.RemountAsReadonlyStub = nil
	fake.remountAsReadonlyReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) RemountAsReadonlyReturnsOnCall(i int, result1 error) {
	fake.RemountAsReadonlyStub = nil
	if fake.remountAsReadonlyReturnsOnCall == nil {
		fake.remountAsReadonlyReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.remountAsReadonlyReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) Remount(fromMountPoint string, toMountPoint string, mountOptions ...string) (err error) {
	fake.remountMutex.Lock()
	ret, specificReturn := fake.remountReturnsOnCall[len(fake.remountArgsForCall)]
	fake.remountArgsForCall = append(fake.remountArgsForCall, struct {
		fromMountPoint string
		toMountPoint   string
		mountOptions   []string
	}{fromMountPoint, toMountPoint, mountOptions})
	fake.recordInvocation("Remount", []interface{}{fromMountPoint, toMountPoint, mountOptions})
	fake.remountMutex.Unlock()
	if fake.RemountStub != nil {
		return fake.RemountStub(fromMountPoint, toMountPoint, mountOptions...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.remountReturns.result1
}

func (fake *FakeMounter) RemountCallCount() int {
	fake.remountMutex.RLock()
	defer fake.remountMutex.RUnlock()
	return len(fake.remountArgsForCall)
}

func (fake *FakeMounter) RemountArgsForCall(i int) (string, string, []string) {
	fake.remountMutex.RLock()
	defer fake.remountMutex.RUnlock()
	return fake.remountArgsForCall[i].fromMountPoint, fake.remountArgsForCall[i].toMountPoint, fake.remountArgsForCall[i].mountOptions
}

func (fake *FakeMounter) RemountReturns(result1 error) {
	fake.RemountStub = nil
	fake.remountReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) RemountReturnsOnCall(i int, result1 error) {
	fake.RemountStub = nil
	if fake.remountReturnsOnCall == nil {
		fake.remountReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.remountReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) RemountInPlace(mountPoint string, mountOptions ...string) (err error) {
	fake.remountInPlaceMutex.Lock()
	ret, specificReturn := fake.remountInPlaceReturnsOnCall[len(fake.remountInPlaceArgsForCall)]
	fake.remountInPlaceArgsForCall = append(fake.remountInPlaceArgsForCall, struct {
		mountPoint   string
		mountOptions []string
	}{mountPoint, mountOptions})
	fake.recordInvocation("RemountInPlace", []interface{}{mountPoint, mountOptions})
	fake.remountInPlaceMutex.Unlock()
	if fake.RemountInPlaceStub != nil {
		return fake.RemountInPlaceStub(mountPoint, mountOptions...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.remountInPlaceReturns.result1
}

func (fake *FakeMounter) RemountInPlaceCallCount() int {
	fake.remountInPlaceMutex.RLock()
	defer fake.remountInPlaceMutex.RUnlock()
	return len(fake.remountInPlaceArgsForCall)
}

func (fake *FakeMounter) RemountInPlaceArgsForCall(i int) (string, []string) {
	fake.remountInPlaceMutex.RLock()
	defer fake.remountInPlaceMutex.RUnlock()
	return fake.remountInPlaceArgsForCall[i].mountPoint, fake.remountInPlaceArgsForCall[i].mountOptions
}

func (fake *FakeMounter) RemountInPlaceReturns(result1 error) {
	fake.RemountInPlaceStub = nil
	fake.remountInPlaceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) RemountInPlaceReturnsOnCall(i int, result1 error) {
	fake.RemountInPlaceStub = nil
	if fake.remountInPlaceReturnsOnCall == nil {
		fake.remountInPlaceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.remountInPlaceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) SwapOn(partitionPath string) (err error) {
	fake.swapOnMutex.Lock()
	ret, specificReturn := fake.swapOnReturnsOnCall[len(fake.swapOnArgsForCall)]
	fake.swapOnArgsForCall = append(fake.swapOnArgsForCall, struct {
		partitionPath string
	}{partitionPath})
	fake.recordInvocation("SwapOn", []interface{}{partitionPath})
	fake.swapOnMutex.Unlock()
	if fake.SwapOnStub != nil {
		return fake.SwapOnStub(partitionPath)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.swapOnReturns.result1
}

func (fake *FakeMounter) SwapOnCallCount() int {
	fake.swapOnMutex.RLock()
	defer fake.swapOnMutex.RUnlock()
	return len(fake.swapOnArgsForCall)
}

func (fake *FakeMounter) SwapOnArgsForCall(i int) string {
	fake.swapOnMutex.RLock()
	defer fake.swapOnMutex.RUnlock()
	return fake.swapOnArgsForCall[i].partitionPath
}

func (fake *FakeMounter) SwapOnReturns(result1 error) {
	fake.SwapOnStub = nil
	fake.swapOnReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) SwapOnReturnsOnCall(i int, result1 error) {
	fake.SwapOnStub = nil
	if fake.swapOnReturnsOnCall == nil {
		fake.swapOnReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.swapOnReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) IsMountPoint(path string) (parititionPath string, result bool, err error) {
	fake.isMountPointMutex.Lock()
	ret, specificReturn := fake.isMountPointReturnsOnCall[len(fake.isMountPointArgsForCall)]
	fake.isMountPointArgsForCall = append(fake.isMountPointArgsForCall, struct {
		path string
	}{path})
	fake.recordInvocation("IsMountPoint", []interface{}{path})
	fake.isMountPointMutex.Unlock()
	if fake.IsMountPointStub != nil {
		return fake.IsMountPointStub(path)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.isMountPointReturns.result1, fake.isMountPointReturns.result2, fake.isMountPointReturns.result3
}

func (fake *FakeMounter) IsMountPointCallCount() int {
	fake.isMountPointMutex.RLock()
	defer fake.isMountPointMutex.RUnlock()
	return len(fake.isMountPointArgsForCall)
}

func (fake *FakeMounter) IsMountPointArgsForCall(i int) string {
	fake.isMountPointMutex.RLock()
	defer fake.isMountPointMutex.RUnlock()
	return fake.isMountPointArgsForCall[i].path
}

func (fake *FakeMounter) IsMountPointReturns(result1 string, result2 bool, result3 error) {
	fake.IsMountPointStub = nil
	fake.isMountPointReturns = struct {
		result1 string
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeMounter) IsMountPointReturnsOnCall(i int, result1 string, result2 bool, result3 error) {
	fake.IsMountPointStub = nil
	if fake.isMountPointReturnsOnCall == nil {
		fake.isMountPointReturnsOnCall = make(map[int]struct {
			result1 string
			result2 bool
			result3 error
		})
	}
	fake.isMountPointReturnsOnCall[i] = struct {
		result1 string
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeMounter) IsMounted(devicePathOrMountPoint string) (result bool, err error) {
	fake.isMountedMutex.Lock()
	ret, specificReturn := fake.isMountedReturnsOnCall[len(fake.isMountedArgsForCall)]
	fake.isMountedArgsForCall = append(fake.isMountedArgsForCall, struct {
		devicePathOrMountPoint string
	}{devicePathOrMountPoint})
	fake.recordInvocation("IsMounted", []interface{}{devicePathOrMountPoint})
	fake.isMountedMutex.Unlock()
	if fake.IsMountedStub != nil {
		return fake.IsMountedStub(devicePathOrMountPoint)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.isMountedReturns.result1, fake.isMountedReturns.result2
}

func (fake *FakeMounter) IsMountedCallCount() int {
	fake.isMountedMutex.RLock()
	defer fake.isMountedMutex.RUnlock()
	return len(fake.isMountedArgsForCall)
}

func (fake *FakeMounter) IsMountedArgsForCall(i int) string {
	fake.isMountedMutex.RLock()
	defer fake.isMountedMutex.RUnlock()
	return fake.isMountedArgsForCall[i].devicePathOrMountPoint
}

func (fake *FakeMounter) IsMountedReturns(result1 bool, result2 error) {
	fake.IsMountedStub = nil
	fake.isMountedReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeMounter) IsMountedReturnsOnCall(i int, result1 bool, result2 error) {
	fake.IsMountedStub = nil
	if fake.isMountedReturnsOnCall == nil {
		fake.isMountedReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.isMountedReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeMounter) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.mountMutex.RLock()
	defer fake.mountMutex.RUnlock()
	fake.mountFilesystemMutex.RLock()
	defer fake.mountFilesystemMutex.RUnlock()
	fake.unmountMutex.RLock()
	defer fake.unmountMutex.RUnlock()
	fake.remountAsReadonlyMutex.RLock()
	defer fake.remountAsReadonlyMutex.RUnlock()
	fake.remountMutex.RLock()
	defer fake.remountMutex.RUnlock()
	fake.remountInPlaceMutex.RLock()
	defer fake.remountInPlaceMutex.RUnlock()
	fake.swapOnMutex.RLock()
	defer fake.swapOnMutex.RUnlock()
	fake.isMountPointMutex.RLock()
	defer fake.isMountPointMutex.RUnlock()
	fake.isMountedMutex.RLock()
	defer fake.isMountedMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeMounter) 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.Mounter = new(FakeMounter)
// Code generated by counterfeiter. DO NOT EDIT.
package diskfakes

import (
	"sync"

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

type FakeMounter struct {
	MountStub        func(partitionPath, mountPoint string, mountOptions ...string) (err error)
	mountMutex       sync.RWMutex
	mountArgsForCall []struct {
		partitionPath string
		mountPoint    string
		mountOptions  []string
	}
	mountReturns struct {
		result1 error
	}
	mountReturnsOnCall map[int]struct {
		result1 error
	}
	MountFilesystemStub        func(partitionPath, mountPoint, fstype string, mountOptions ...string) (err error)
	mountFilesystemMutex       sync.RWMutex
	mountFilesystemArgsForCall []struct {
		partitionPath string
		mountPoint    string
		fstype        string
		mountOptions  []string
	}
	mountFilesystemReturns struct {
		result1 error
	}
	mountFilesystemReturnsOnCall map[int]struct {
		result1 error
	}
	UnmountStub        func(partitionOrMountPoint string) (didUnmount bool, err error)
	unmountMutex       sync.RWMutex
	unmountArgsForCall []struct {
		partitionOrMountPoint string
	}
	unmountReturns struct {
		result1 bool
		result2 error
	}
	unmountReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	RemountAsReadonlyStub        func(mountPoint string) (err error)
	remountAsReadonlyMutex       sync.RWMutex
	remountAsReadonlyArgsForCall []struct {
		mountPoint string
	}
	remountAsReadonlyReturns struct {
		result1 error
	}
	remountAsReadonlyReturnsOnCall map[int]struct {
		result1 error
	}
	RemountStub        func(fromMountPoint, toMountPoint string, mountOptions ...string) (err error)
	remountMutex       sync.RWMutex
	remountArgsForCall []struct {
		fromMountPoint string
		toMountPoint   string
		mountOptions   []string
	}
	remountReturns struct {
		result1 error
	}
	remountReturnsOnCall map[int]struct {
		result1 error
	}
	RemountInPlaceStub        func(mountPoint string, mountOptions ...string) (err error)
	remountInPlaceMutex       sync.RWMutex
	remountInPlaceArgsForCall []struct {
		mountPoint   string
		mountOptions []string
	}
	remountInPlaceReturns struct {
		result1 error
	}
	remountInPlaceReturnsOnCall map[int]struct {
		result1 error
	}
	SwapOnStub        func(partitionPath string) (err error)
	swapOnMutex       sync.RWMutex
	swapOnArgsForCall []struct {
		partitionPath string
	}
	swapOnReturns struct {
		result1 error
	}
	swapOnReturnsOnCall map[int]struct {
		result1 error
	}
	IsMountPointStub        func(path string) (parititionPath string, result bool, err error)
	isMountPointMutex       sync.RWMutex
	isMountPointArgsForCall []struct {
		path string
	}
	isMountPointReturns struct {
		result1 string
		result2 bool
		result3 error
	}
	isMountPointReturnsOnCall map[int]struct {
		result1 string
		result2 bool
		result3 error
	}
	IsMountedStub        func(devicePathOrMountPoint string) (result bool, err error)
	isMountedMutex       sync.RWMutex
	isMountedArgsForCall []struct {
		devicePathOrMountPoint string
	}
	isMountedReturns struct {
		result1 bool
		result2 error
	}
	isMountedReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeMounter) Mount(partitionPath string, mountPoint string, mountOptions ...string) (err error) {
	fake.mountMutex.Lock()
	ret, specificReturn := fake.mountReturnsOnCall[len(fake.mountArgsForCall)]
	fake.mountArgsForCall = append(fake.mountArgsForCall, struct {
		partitionPath string
		mountPoint    string
		mountOptions  []string
	}{partitionPath, mountPoint, mountOptions})
	fake.recordInvocation("Mount", []interface{}{partitionPath, mountPoint, mountOptions})
	fake.mountMutex.Unlock()
	if fake.MountStub != nil {
		return fake.MountStub(partitionPath, mountPoint, mountOptions...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.mountReturns.result1
}

func (fake *FakeMounter) MountCallCount() int {
	fake.mountMutex.RLock()
	defer fake.mountMutex.RUnlock()
	return len(fake.mountArgsForCall)
}

func (fake *FakeMounter) MountArgsForCall(i int) (string, string, []string) {
	fake.mountMutex.RLock()
	defer fake.mountMutex.RUnlock()
	return fake.mountArgsForCall[i].partitionPath, fake.mountArgsForCall[i].mountPoint, fake.mountArgsForCall[i].mountOptions
}

func (fake *FakeMounter) MountReturns(result1 error) {
	fake.MountStub = nil
	fake.mountReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) MountReturnsOnCall(i int, result1 error) {
	fake.MountStub = nil
	if fake.mountReturnsOnCall == nil {
		fake.mountReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.mountReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) MountFilesystem(partitionPath string, mountPoint string, fstype string, mountOptions ...string) (err error) {
	fake.mountFilesystemMutex.Lock()
	ret, specificReturn := fake.mountFilesystemReturnsOnCall[len(fake.mountFilesystemArgsForCall)]
	fake.mountFilesystemArgsForCall = append(fake.mountFilesystemArgsForCall, struct {
		partitionPath string
		mountPoint    string
		fstype        string
		mountOptions  []string
	}{partitionPath, mountPoint, fstype, mountOptions})
	fake.recordInvocation("MountFilesystem", []interface{}{partitionPath, mountPoint, fstype, mountOptions})
	fake.mountFilesystemMutex.Unlock()
	if fake.MountFilesystemStub != nil {
		return fake.MountFilesystemStub(partitionPath, mountPoint, fstype, mountOptions...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.mountFilesystemReturns.result1
}

func (fake *FakeMounter) MountFilesystemCallCount() int {
	fake.mountFilesystemMutex.RLock()
	defer fake.mountFilesystemMutex.RUnlock()
	return len(fake.mountFilesystemArgsForCall)
}

func (fake *FakeMounter) MountFilesystemArgsForCall(i int) (string, string, string, []string) {
	fake.mountFilesystemMutex.RLock()
	defer fake.mountFilesystemMutex.RUnlock()
	return fake.mountFilesystemArgsForCall[i].partitionPath, fake.mountFilesystemArgsForCall[i].mountPoint, fake.mountFilesystemArgsForCall[i].fstype, fake.mountFilesystemArgsForCall[i].mountOptions
}

func (fake *FakeMounter) MountFilesystemReturns(result1 error) {
	fake.MountFilesystemStub = nil
	fake.mountFilesystemReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) MountFilesystemReturnsOnCall(i int, result1 error) {
	fake.MountFilesystemStub = nil
	if fake.mountFilesystemReturnsOnCall == nil {
		fake.mountFilesystemReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.mountFilesystemReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) Unmount(partitionOrMountPoint string) (didUnmount bool, err error) {
	fake.unmountMutex.Lock()
	ret, specificReturn := fake.unmountReturnsOnCall[len(fake.unmountArgsForCall)]
	fake.unmountArgsForCall = append(fake.unmountArgsForCall, struct {
		partitionOrMountPoint string
	}{partitionOrMountPoint})
	fake.recordInvocation("Unmount", []interface{}{partitionOrMountPoint})
	fake.unmountMutex.Unlock()
	if fake.UnmountStub != nil {
		return fake.UnmountStub(partitionOrMountPoint)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.unmountReturns.result1, fake.unmountReturns.result2
}

func (fake *FakeMounter) UnmountCallCount() int {
	fake.unmountMutex.RLock()
	defer fake.unmountMutex.RUnlock()
	return len(fake.unmountArgsForCall)
}

func (fake *FakeMounter) UnmountArgsForCall(i int) string {
	fake.unmountMutex.RLock()
	defer fake.unmountMutex.RUnlock()
	return fake.unmountArgsForCall[i].partitionOrMountPoint
}

func (fake *FakeMounter) UnmountReturns(result1 bool, result2 error) {
	fake.UnmountStub = nil
	fake.unmountReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeMounter) UnmountReturnsOnCall(i int, result1 bool, result2 error) {
	fake.UnmountStub = nil
	if fake.unmountReturnsOnCall == nil {
		fake.unmountReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.unmountReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeMounter) RemountAsReadonly(mountPoint string) (err error) {
	fake.remountAsReadonlyMutex.Lock()
	ret, specificReturn := fake.remountAsReadonlyReturnsOnCall[len(fake.remountAsReadonlyArgsForCall)]
	fake.remountAsReadonlyArgsForCall = append(fake.remountAsReadonlyArgsForCall, struct {
		mountPoint string
	}{mountPoint})
	fake.recordInvocation("RemountAsReadonly", []interface{}{mountPoint})
	fake.remountAsReadonlyMutex.Unlock()
	if fake.RemountAsReadonlyStub != nil {
		return fake.RemountAsReadonlyStub(mountPoint)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.remountAsReadonlyReturns.result1
}

func (fake *FakeMounter) RemountAsReadonlyCallCount() int {
	fake.remountAsReadonlyMutex.RLock()
	defer fake.remountAsReadonlyMutex.RUnlock()
	return len(fake.remountAsReadonlyArgsForCall)
}

func (fake *FakeMounter) RemountAsReadonlyArgsForCall(i int) string {
	fake.remountAsReadonlyMutex.RLock()
	defer fake.remountAsReadonlyMutex.RUnlock()
	return fake.remountAsReadonlyArgsForCall[i].mountPoint
}

func (fake *FakeMounter) RemountAsReadonlyReturns(result1 error) {
	fake.RemountAsReadonlyStub = nil
	fake.remountAsReadonlyReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) RemountAsReadonlyReturnsOnCall(i int, result1 error) {
	fake.RemountAsReadonlyStub = nil
	if fake.remountAsReadonlyReturnsOnCall == nil {
		fake.remountAsReadonlyReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.remountAsReadonlyReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) Remount(fromMountPoint string, toMountPoint string, mountOptions ...string) (err error) {
	fake.remountMutex.Lock()
	ret, specificReturn := fake.remountReturnsOnCall[len(fake.remountArgsForCall)]
	fake.remountArgsForCall = append(fake.remountArgsForCall, struct {
		fromMountPoint string
		toMountPoint   string
		mountOptions   []string
	}{fromMountPoint, toMountPoint, mountOptions})
	fake.recordInvocation("Remount", []interface{}{fromMountPoint, toMountPoint, mountOptions})
	fake.remountMutex.Unlock()
	if fake.RemountStub != nil {
		return fake.RemountStub(fromMountPoint, toMountPoint, mountOptions...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.remountReturns.result1
}

func (fake *FakeMounter) RemountCallCount() int {
	fake.remountMutex.RLock()
	defer fake.remountMutex.RUnlock()
	return len(fake.remountArgsForCall)
}

func (fake *FakeMounter) RemountArgsForCall(i int) (string, string, []string) {
	fake.remountMutex.RLock()
	defer fake.remountMutex.RUnlock()
	return fake.remountArgsForCall[i].fromMountPoint, fake.remountArgsForCall[i].toMountPoint, fake.remountArgsForCall[i].mountOptions
}

func (fake *FakeMounter) RemountReturns(result1 error) {
	fake.RemountStub = nil
	fake.remountReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) RemountReturnsOnCall(i int, result1 error) {
	fake.RemountStub = nil
	if fake.remountReturnsOnCall == nil {
		fake.remountReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.remountReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) RemountInPlace(mountPoint string, mountOptions ...string) (err error) {
	fake.remountInPlaceMutex.Lock()
	ret, specificReturn := fake.remountInPlaceReturnsOnCall[len(fake.remountInPlaceArgsForCall)]
	fake.remountInPlaceArgsForCall = append(fake.remountInPlaceArgsForCall, struct {
		mountPoint   string
		mountOptions []string
	}{mountPoint, mountOptions})
	fake.recordInvocation("RemountInPlace", []interface{}{mountPoint, mountOptions})
	fake.remountInPlaceMutex.Unlock()
	if fake.RemountInPlaceStub != nil {
		return fake.RemountInPlaceStub(mountPoint, mountOptions...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.remountInPlaceReturns.result1
}

func (fake *FakeMounter) RemountInPlaceCallCount() int {
	fake.remountInPlaceMutex.RLock()
	defer fake.remountInPlaceMutex.RUnlock()
	return len(fake.remountInPlaceArgsForCall)
}

func (fake *FakeMounter) RemountInPlaceArgsForCall(i int) (string, []string) {
	fake.remountInPlaceMutex.RLock()
	defer fake.remountInPlaceMutex.RUnlock()
	return fake.remountInPlaceArgsForCall[i].mountPoint, fake.remountInPlaceArgsForCall[i].mountOptions
}

func (fake *FakeMounter) RemountInPlaceReturns(result1 error) {
	fake.RemountInPlaceStub = nil
	fake.remountInPlaceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) RemountInPlaceReturnsOnCall(i int, result1 error) {
	fake.RemountInPlaceStub = nil
	if fake.remountInPlaceReturnsOnCall == nil {
		fake.remountInPlaceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.remountInPlaceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) SwapOn(partitionPath string) (err error) {
	fake.swapOnMutex.Lock()
	ret, specificReturn := fake.swapOnReturnsOnCall[len(fake.swapOnArgsForCall)]
	fake.swapOnArgsForCall = append(fake.swapOnArgsForCall, struct {
		partitionPath string
	}{partitionPath})
	fake.recordInvocation("SwapOn", []interface{}{partitionPath})
	fake.swapOnMutex.Unlock()
	if fake.SwapOnStub != nil {
		return fake.SwapOnStub(partitionPath)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.swapOnReturns.result1
}

func (fake *FakeMounter) SwapOnCallCount() int {
	fake.swapOnMutex.RLock()
	defer fake.swapOnMutex.RUnlock()
	return len(fake.swapOnArgsForCall)
}

func (fake *FakeMounter) SwapOnArgsForCall(i int) string {
	fake.swapOnMutex.RLock()
	defer fake.swapOnMutex.RUnlock()
	return fake.swapOnArgsForCall[i].partitionPath
}

func (fake *FakeMounter) SwapOnReturns(result1 error) {
	fake.SwapOnStub = nil
	fake.swapOnReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) SwapOnReturnsOnCall(i int, result1 error) {
	fake.SwapOnStub = nil
	if fake.swapOnReturnsOnCall == nil {
		fake.swapOnReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.swapOnReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeMounter) IsMountPoint(path string) (parititionPath string, result bool, err error) {
	fake.isMountPointMutex.Lock()
	ret, specificReturn := fake.isMountPointReturnsOnCall[len(fake.isMountPointArgsForCall)]
	fake.isMountPointArgsForCall = append(fake.isMountPointArgsForCall, struct {
		path string
	}{path})
	fake.recordInvocation("IsMountPoint", []interface{}{path})
	fake.isMountPointMutex.Unlock()
	if fake.IsMountPointStub != nil {
		return fake.IsMountPointStub(path)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.isMountPointReturns.result1, fake.isMountPointReturns.result2, fake.isMountPointReturns.result3
}

func (fake *FakeMounter) IsMountPointCallCount() int {
	fake.isMountPointMutex.RLock()
	defer fake.isMountPointMutex.RUnlock()
	return len(fake.isMountPointArgsForCall)
}

func (fake *FakeMounter) IsMountPointArgsForCall(i int) string {
	fake.isMountPointMutex.RLock()
	defer fake.isMountPointMutex.RUnlock()
	return fake.isMountPointArgsForCall[i].path
}

func (fake *FakeMounter) IsMountPointReturns(result1 string, result2 bool, result3 error) {
	fake.IsMountPointStub = nil
	fake.isMountPointReturns = struct {
		result1 string
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeMounter) IsMountPointReturnsOnCall(i int, result1 string, result2 bool, result3 error) {
	fake.IsMountPointStub = nil
	if fake.isMountPointReturnsOnCall == nil {
		fake.isMountPointReturnsOnCall = make(map[int]struct {
			result1 string
			result2 bool
			result3 error
		})
	}
	fake.isMountPointReturnsOnCall[i] = struct {
		result1 string
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeMounter) IsMounted(devicePathOrMountPoint string) (result bool, err error) {
	fake.isMountedMutex.Lock()
	ret, specificReturn := fake.isMountedReturnsOnCall[len(fake.isMountedArgsForCall)]
	fake.isMountedArgsForCall = append(fake.isMountedArgsForCall, struct {
		devicePathOrMountPoint string
	}{devicePathOrMountPoint})
	fake.recordInvocation("IsMounted", []interface{}{devicePathOrMountPoint})
	fake.isMountedMutex.Unlock()
	if fake.IsMountedStub != nil {
		return fake.IsMountedStub(devicePathOrMountPoint)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.isMountedReturns.result1, fake.isMountedReturns.result2
}

func (fake *FakeMounter) IsMountedCallCount() int {
	fake.isMountedMutex.RLock()
	defer fake.isMountedMutex.RUnlock()
	return len(fake.isMountedArgsForCall)
}

func (fake *FakeMounter) IsMountedArgsForCall(i int) string {
	fake.isMountedMutex.RLock()
	defer fake.isMountedMutex.RUnlock()
	return fake.isMountedArgsForCall[i].devicePathOrMountPoint
}

func (fake *FakeMounter) IsMountedReturns(result1 bool, result2 error) {
	fake.IsMountedStub = nil
	fake.isMountedReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeMounter) IsMountedReturnsOnCall(i int, result1 bool, result2 error) {
	fake.IsMountedStub = nil
	if fake.isMountedReturnsOnCall == nil {
		fake.isMountedReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.isMountedReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeMounter) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.mountMutex.RLock()
	defer fake.mountMutex.RUnlock()
	fake.mountFilesystemMutex.RLock()
	defer fake.mountFilesystemMutex.RUnlock()
	fake.unmountMutex.RLock()
	defer fake.unmountMutex.RUnlock()
	fake.remountAsReadonlyMutex.RLock()
	defer fake.remountAsReadonlyMutex.RUnlock()
	fake.remountMutex.RLock()
	defer fake.remountMutex.RUnlock()
	fake.remountInPlaceMutex.RLock()
	defer fake.remountInPlaceMutex.RUnlock()
	fake.swapOnMutex.RLock()
	defer fake.swapOnMutex.RUnlock()
	fake.isMountPointMutex.RLock()
	defer fake.isMountPointMutex.RUnlock()
	fake.isMountedMutex.RLock()
	defer fake.isMountedMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

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