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

import (
	"sync"
	"syscall"

	"github.com/ehsaniara/joblet/pkg/platform"
)

type FakeSyscallOperations struct {
	ChdirStub        func(string) error
	chdirMutex       sync.RWMutex
	chdirArgsForCall []struct {
		arg1 string
	}
	chdirReturns struct {
		result1 error
	}
	chdirReturnsOnCall map[int]struct {
		result1 error
	}
	ChmodStub        func(string, uint32) error
	chmodMutex       sync.RWMutex
	chmodArgsForCall []struct {
		arg1 string
		arg2 uint32
	}
	chmodReturns struct {
		result1 error
	}
	chmodReturnsOnCall map[int]struct {
		result1 error
	}
	ChrootStub        func(string) error
	chrootMutex       sync.RWMutex
	chrootArgsForCall []struct {
		arg1 string
	}
	chrootReturns struct {
		result1 error
	}
	chrootReturnsOnCall map[int]struct {
		result1 error
	}
	CreateProcessGroupStub        func() *syscall.SysProcAttr
	createProcessGroupMutex       sync.RWMutex
	createProcessGroupArgsForCall []struct {
	}
	createProcessGroupReturns struct {
		result1 *syscall.SysProcAttr
	}
	createProcessGroupReturnsOnCall map[int]struct {
		result1 *syscall.SysProcAttr
	}
	ExecStub        func(string, []string, []string) error
	execMutex       sync.RWMutex
	execArgsForCall []struct {
		arg1 string
		arg2 []string
		arg3 []string
	}
	execReturns struct {
		result1 error
	}
	execReturnsOnCall map[int]struct {
		result1 error
	}
	FstatStub        func(int) (uint64, error)
	fstatMutex       sync.RWMutex
	fstatArgsForCall []struct {
		arg1 int
	}
	fstatReturns struct {
		result1 uint64
		result2 error
	}
	fstatReturnsOnCall map[int]struct {
		result1 uint64
		result2 error
	}
	KillStub        func(int, syscall.Signal) error
	killMutex       sync.RWMutex
	killArgsForCall []struct {
		arg1 int
		arg2 syscall.Signal
	}
	killReturns struct {
		result1 error
	}
	killReturnsOnCall map[int]struct {
		result1 error
	}
	MkfifoStub        func(string, uint32) error
	mkfifoMutex       sync.RWMutex
	mkfifoArgsForCall []struct {
		arg1 string
		arg2 uint32
	}
	mkfifoReturns struct {
		result1 error
	}
	mkfifoReturnsOnCall map[int]struct {
		result1 error
	}
	MknodStub        func(string, uint32, int) error
	mknodMutex       sync.RWMutex
	mknodArgsForCall []struct {
		arg1 string
		arg2 uint32
		arg3 int
	}
	mknodReturns struct {
		result1 error
	}
	mknodReturnsOnCall map[int]struct {
		result1 error
	}
	MountStub        func(string, string, string, uintptr, string) error
	mountMutex       sync.RWMutex
	mountArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 uintptr
		arg5 string
	}
	mountReturns struct {
		result1 error
	}
	mountReturnsOnCall map[int]struct {
		result1 error
	}
	SetNonblockStub        func(int, bool) error
	setNonblockMutex       sync.RWMutex
	setNonblockArgsForCall []struct {
		arg1 int
		arg2 bool
	}
	setNonblockReturns struct {
		result1 error
	}
	setNonblockReturnsOnCall map[int]struct {
		result1 error
	}
	StatfsStub        func(string, *syscall.Statfs_t) error
	statfsMutex       sync.RWMutex
	statfsArgsForCall []struct {
		arg1 string
		arg2 *syscall.Statfs_t
	}
	statfsReturns struct {
		result1 error
	}
	statfsReturnsOnCall map[int]struct {
		result1 error
	}
	StatxStub        func(int, string, int, int) (uint64, error)
	statxMutex       sync.RWMutex
	statxArgsForCall []struct {
		arg1 int
		arg2 string
		arg3 int
		arg4 int
	}
	statxReturns struct {
		result1 uint64
		result2 error
	}
	statxReturnsOnCall map[int]struct {
		result1 uint64
		result2 error
	}
	UnmountStub        func(string, int) error
	unmountMutex       sync.RWMutex
	unmountArgsForCall []struct {
		arg1 string
		arg2 int
	}
	unmountReturns struct {
		result1 error
	}
	unmountReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeSyscallOperations) Chdir(arg1 string) error {
	fake.chdirMutex.Lock()
	ret, specificReturn := fake.chdirReturnsOnCall[len(fake.chdirArgsForCall)]
	fake.chdirArgsForCall = append(fake.chdirArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.ChdirStub
	fakeReturns := fake.chdirReturns
	fake.recordInvocation("Chdir", []interface{}{arg1})
	fake.chdirMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) ChdirCallCount() int {
	fake.chdirMutex.RLock()
	defer fake.chdirMutex.RUnlock()
	return len(fake.chdirArgsForCall)
}

func (fake *FakeSyscallOperations) ChdirCalls(stub func(string) error) {
	fake.chdirMutex.Lock()
	defer fake.chdirMutex.Unlock()
	fake.ChdirStub = stub
}

func (fake *FakeSyscallOperations) ChdirArgsForCall(i int) string {
	fake.chdirMutex.RLock()
	defer fake.chdirMutex.RUnlock()
	argsForCall := fake.chdirArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeSyscallOperations) ChdirReturns(result1 error) {
	fake.chdirMutex.Lock()
	defer fake.chdirMutex.Unlock()
	fake.ChdirStub = nil
	fake.chdirReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) ChdirReturnsOnCall(i int, result1 error) {
	fake.chdirMutex.Lock()
	defer fake.chdirMutex.Unlock()
	fake.ChdirStub = nil
	if fake.chdirReturnsOnCall == nil {
		fake.chdirReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.chdirReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) Chmod(arg1 string, arg2 uint32) error {
	fake.chmodMutex.Lock()
	ret, specificReturn := fake.chmodReturnsOnCall[len(fake.chmodArgsForCall)]
	fake.chmodArgsForCall = append(fake.chmodArgsForCall, struct {
		arg1 string
		arg2 uint32
	}{arg1, arg2})
	stub := fake.ChmodStub
	fakeReturns := fake.chmodReturns
	fake.recordInvocation("Chmod", []interface{}{arg1, arg2})
	fake.chmodMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) ChmodCallCount() int {
	fake.chmodMutex.RLock()
	defer fake.chmodMutex.RUnlock()
	return len(fake.chmodArgsForCall)
}

func (fake *FakeSyscallOperations) ChmodCalls(stub func(string, uint32) error) {
	fake.chmodMutex.Lock()
	defer fake.chmodMutex.Unlock()
	fake.ChmodStub = stub
}

func (fake *FakeSyscallOperations) ChmodArgsForCall(i int) (string, uint32) {
	fake.chmodMutex.RLock()
	defer fake.chmodMutex.RUnlock()
	argsForCall := fake.chmodArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeSyscallOperations) ChmodReturns(result1 error) {
	fake.chmodMutex.Lock()
	defer fake.chmodMutex.Unlock()
	fake.ChmodStub = nil
	fake.chmodReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) ChmodReturnsOnCall(i int, result1 error) {
	fake.chmodMutex.Lock()
	defer fake.chmodMutex.Unlock()
	fake.ChmodStub = nil
	if fake.chmodReturnsOnCall == nil {
		fake.chmodReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.chmodReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) Chroot(arg1 string) error {
	fake.chrootMutex.Lock()
	ret, specificReturn := fake.chrootReturnsOnCall[len(fake.chrootArgsForCall)]
	fake.chrootArgsForCall = append(fake.chrootArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.ChrootStub
	fakeReturns := fake.chrootReturns
	fake.recordInvocation("Chroot", []interface{}{arg1})
	fake.chrootMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) ChrootCallCount() int {
	fake.chrootMutex.RLock()
	defer fake.chrootMutex.RUnlock()
	return len(fake.chrootArgsForCall)
}

func (fake *FakeSyscallOperations) ChrootCalls(stub func(string) error) {
	fake.chrootMutex.Lock()
	defer fake.chrootMutex.Unlock()
	fake.ChrootStub = stub
}

func (fake *FakeSyscallOperations) ChrootArgsForCall(i int) string {
	fake.chrootMutex.RLock()
	defer fake.chrootMutex.RUnlock()
	argsForCall := fake.chrootArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeSyscallOperations) ChrootReturns(result1 error) {
	fake.chrootMutex.Lock()
	defer fake.chrootMutex.Unlock()
	fake.ChrootStub = nil
	fake.chrootReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) ChrootReturnsOnCall(i int, result1 error) {
	fake.chrootMutex.Lock()
	defer fake.chrootMutex.Unlock()
	fake.ChrootStub = nil
	if fake.chrootReturnsOnCall == nil {
		fake.chrootReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.chrootReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) CreateProcessGroup() *syscall.SysProcAttr {
	fake.createProcessGroupMutex.Lock()
	ret, specificReturn := fake.createProcessGroupReturnsOnCall[len(fake.createProcessGroupArgsForCall)]
	fake.createProcessGroupArgsForCall = append(fake.createProcessGroupArgsForCall, struct {
	}{})
	stub := fake.CreateProcessGroupStub
	fakeReturns := fake.createProcessGroupReturns
	fake.recordInvocation("CreateProcessGroup", []interface{}{})
	fake.createProcessGroupMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) CreateProcessGroupCallCount() int {
	fake.createProcessGroupMutex.RLock()
	defer fake.createProcessGroupMutex.RUnlock()
	return len(fake.createProcessGroupArgsForCall)
}

func (fake *FakeSyscallOperations) CreateProcessGroupCalls(stub func() *syscall.SysProcAttr) {
	fake.createProcessGroupMutex.Lock()
	defer fake.createProcessGroupMutex.Unlock()
	fake.CreateProcessGroupStub = stub
}

func (fake *FakeSyscallOperations) CreateProcessGroupReturns(result1 *syscall.SysProcAttr) {
	fake.createProcessGroupMutex.Lock()
	defer fake.createProcessGroupMutex.Unlock()
	fake.CreateProcessGroupStub = nil
	fake.createProcessGroupReturns = struct {
		result1 *syscall.SysProcAttr
	}{result1}
}

func (fake *FakeSyscallOperations) CreateProcessGroupReturnsOnCall(i int, result1 *syscall.SysProcAttr) {
	fake.createProcessGroupMutex.Lock()
	defer fake.createProcessGroupMutex.Unlock()
	fake.CreateProcessGroupStub = nil
	if fake.createProcessGroupReturnsOnCall == nil {
		fake.createProcessGroupReturnsOnCall = make(map[int]struct {
			result1 *syscall.SysProcAttr
		})
	}
	fake.createProcessGroupReturnsOnCall[i] = struct {
		result1 *syscall.SysProcAttr
	}{result1}
}

func (fake *FakeSyscallOperations) Exec(arg1 string, arg2 []string, arg3 []string) error {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	var arg3Copy []string
	if arg3 != nil {
		arg3Copy = make([]string, len(arg3))
		copy(arg3Copy, arg3)
	}
	fake.execMutex.Lock()
	ret, specificReturn := fake.execReturnsOnCall[len(fake.execArgsForCall)]
	fake.execArgsForCall = append(fake.execArgsForCall, struct {
		arg1 string
		arg2 []string
		arg3 []string
	}{arg1, arg2Copy, arg3Copy})
	stub := fake.ExecStub
	fakeReturns := fake.execReturns
	fake.recordInvocation("Exec", []interface{}{arg1, arg2Copy, arg3Copy})
	fake.execMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) ExecCallCount() int {
	fake.execMutex.RLock()
	defer fake.execMutex.RUnlock()
	return len(fake.execArgsForCall)
}

func (fake *FakeSyscallOperations) ExecCalls(stub func(string, []string, []string) error) {
	fake.execMutex.Lock()
	defer fake.execMutex.Unlock()
	fake.ExecStub = stub
}

func (fake *FakeSyscallOperations) ExecArgsForCall(i int) (string, []string, []string) {
	fake.execMutex.RLock()
	defer fake.execMutex.RUnlock()
	argsForCall := fake.execArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeSyscallOperations) ExecReturns(result1 error) {
	fake.execMutex.Lock()
	defer fake.execMutex.Unlock()
	fake.ExecStub = nil
	fake.execReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) ExecReturnsOnCall(i int, result1 error) {
	fake.execMutex.Lock()
	defer fake.execMutex.Unlock()
	fake.ExecStub = nil
	if fake.execReturnsOnCall == nil {
		fake.execReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.execReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) Fstat(arg1 int) (uint64, error) {
	fake.fstatMutex.Lock()
	ret, specificReturn := fake.fstatReturnsOnCall[len(fake.fstatArgsForCall)]
	fake.fstatArgsForCall = append(fake.fstatArgsForCall, struct {
		arg1 int
	}{arg1})
	stub := fake.FstatStub
	fakeReturns := fake.fstatReturns
	fake.recordInvocation("Fstat", []interface{}{arg1})
	fake.fstatMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeSyscallOperations) FstatCallCount() int {
	fake.fstatMutex.RLock()
	defer fake.fstatMutex.RUnlock()
	return len(fake.fstatArgsForCall)
}

func (fake *FakeSyscallOperations) FstatCalls(stub func(int) (uint64, error)) {
	fake.fstatMutex.Lock()
	defer fake.fstatMutex.Unlock()
	fake.FstatStub = stub
}

func (fake *FakeSyscallOperations) FstatArgsForCall(i int) int {
	fake.fstatMutex.RLock()
	defer fake.fstatMutex.RUnlock()
	argsForCall := fake.fstatArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeSyscallOperations) FstatReturns(result1 uint64, result2 error) {
	fake.fstatMutex.Lock()
	defer fake.fstatMutex.Unlock()
	fake.FstatStub = nil
	fake.fstatReturns = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeSyscallOperations) FstatReturnsOnCall(i int, result1 uint64, result2 error) {
	fake.fstatMutex.Lock()
	defer fake.fstatMutex.Unlock()
	fake.FstatStub = nil
	if fake.fstatReturnsOnCall == nil {
		fake.fstatReturnsOnCall = make(map[int]struct {
			result1 uint64
			result2 error
		})
	}
	fake.fstatReturnsOnCall[i] = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeSyscallOperations) Kill(arg1 int, arg2 syscall.Signal) error {
	fake.killMutex.Lock()
	ret, specificReturn := fake.killReturnsOnCall[len(fake.killArgsForCall)]
	fake.killArgsForCall = append(fake.killArgsForCall, struct {
		arg1 int
		arg2 syscall.Signal
	}{arg1, arg2})
	stub := fake.KillStub
	fakeReturns := fake.killReturns
	fake.recordInvocation("Kill", []interface{}{arg1, arg2})
	fake.killMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) KillCallCount() int {
	fake.killMutex.RLock()
	defer fake.killMutex.RUnlock()
	return len(fake.killArgsForCall)
}

func (fake *FakeSyscallOperations) KillCalls(stub func(int, syscall.Signal) error) {
	fake.killMutex.Lock()
	defer fake.killMutex.Unlock()
	fake.KillStub = stub
}

func (fake *FakeSyscallOperations) KillArgsForCall(i int) (int, syscall.Signal) {
	fake.killMutex.RLock()
	defer fake.killMutex.RUnlock()
	argsForCall := fake.killArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeSyscallOperations) KillReturns(result1 error) {
	fake.killMutex.Lock()
	defer fake.killMutex.Unlock()
	fake.KillStub = nil
	fake.killReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) KillReturnsOnCall(i int, result1 error) {
	fake.killMutex.Lock()
	defer fake.killMutex.Unlock()
	fake.KillStub = nil
	if fake.killReturnsOnCall == nil {
		fake.killReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.killReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) Mkfifo(arg1 string, arg2 uint32) error {
	fake.mkfifoMutex.Lock()
	ret, specificReturn := fake.mkfifoReturnsOnCall[len(fake.mkfifoArgsForCall)]
	fake.mkfifoArgsForCall = append(fake.mkfifoArgsForCall, struct {
		arg1 string
		arg2 uint32
	}{arg1, arg2})
	stub := fake.MkfifoStub
	fakeReturns := fake.mkfifoReturns
	fake.recordInvocation("Mkfifo", []interface{}{arg1, arg2})
	fake.mkfifoMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) MkfifoCallCount() int {
	fake.mkfifoMutex.RLock()
	defer fake.mkfifoMutex.RUnlock()
	return len(fake.mkfifoArgsForCall)
}

func (fake *FakeSyscallOperations) MkfifoCalls(stub func(string, uint32) error) {
	fake.mkfifoMutex.Lock()
	defer fake.mkfifoMutex.Unlock()
	fake.MkfifoStub = stub
}

func (fake *FakeSyscallOperations) MkfifoArgsForCall(i int) (string, uint32) {
	fake.mkfifoMutex.RLock()
	defer fake.mkfifoMutex.RUnlock()
	argsForCall := fake.mkfifoArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeSyscallOperations) MkfifoReturns(result1 error) {
	fake.mkfifoMutex.Lock()
	defer fake.mkfifoMutex.Unlock()
	fake.MkfifoStub = nil
	fake.mkfifoReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) MkfifoReturnsOnCall(i int, result1 error) {
	fake.mkfifoMutex.Lock()
	defer fake.mkfifoMutex.Unlock()
	fake.MkfifoStub = nil
	if fake.mkfifoReturnsOnCall == nil {
		fake.mkfifoReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.mkfifoReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) Mknod(arg1 string, arg2 uint32, arg3 int) error {
	fake.mknodMutex.Lock()
	ret, specificReturn := fake.mknodReturnsOnCall[len(fake.mknodArgsForCall)]
	fake.mknodArgsForCall = append(fake.mknodArgsForCall, struct {
		arg1 string
		arg2 uint32
		arg3 int
	}{arg1, arg2, arg3})
	stub := fake.MknodStub
	fakeReturns := fake.mknodReturns
	fake.recordInvocation("Mknod", []interface{}{arg1, arg2, arg3})
	fake.mknodMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) MknodCallCount() int {
	fake.mknodMutex.RLock()
	defer fake.mknodMutex.RUnlock()
	return len(fake.mknodArgsForCall)
}

func (fake *FakeSyscallOperations) MknodCalls(stub func(string, uint32, int) error) {
	fake.mknodMutex.Lock()
	defer fake.mknodMutex.Unlock()
	fake.MknodStub = stub
}

func (fake *FakeSyscallOperations) MknodArgsForCall(i int) (string, uint32, int) {
	fake.mknodMutex.RLock()
	defer fake.mknodMutex.RUnlock()
	argsForCall := fake.mknodArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeSyscallOperations) MknodReturns(result1 error) {
	fake.mknodMutex.Lock()
	defer fake.mknodMutex.Unlock()
	fake.MknodStub = nil
	fake.mknodReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) MknodReturnsOnCall(i int, result1 error) {
	fake.mknodMutex.Lock()
	defer fake.mknodMutex.Unlock()
	fake.MknodStub = nil
	if fake.mknodReturnsOnCall == nil {
		fake.mknodReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.mknodReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) Mount(arg1 string, arg2 string, arg3 string, arg4 uintptr, arg5 string) error {
	fake.mountMutex.Lock()
	ret, specificReturn := fake.mountReturnsOnCall[len(fake.mountArgsForCall)]
	fake.mountArgsForCall = append(fake.mountArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 uintptr
		arg5 string
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.MountStub
	fakeReturns := fake.mountReturns
	fake.recordInvocation("Mount", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.mountMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

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

func (fake *FakeSyscallOperations) MountCalls(stub func(string, string, string, uintptr, string) error) {
	fake.mountMutex.Lock()
	defer fake.mountMutex.Unlock()
	fake.MountStub = stub
}

func (fake *FakeSyscallOperations) MountArgsForCall(i int) (string, string, string, uintptr, string) {
	fake.mountMutex.RLock()
	defer fake.mountMutex.RUnlock()
	argsForCall := fake.mountArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeSyscallOperations) MountReturns(result1 error) {
	fake.mountMutex.Lock()
	defer fake.mountMutex.Unlock()
	fake.MountStub = nil
	fake.mountReturns = struct {
		result1 error
	}{result1}
}

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

func (fake *FakeSyscallOperations) SetNonblock(arg1 int, arg2 bool) error {
	fake.setNonblockMutex.Lock()
	ret, specificReturn := fake.setNonblockReturnsOnCall[len(fake.setNonblockArgsForCall)]
	fake.setNonblockArgsForCall = append(fake.setNonblockArgsForCall, struct {
		arg1 int
		arg2 bool
	}{arg1, arg2})
	stub := fake.SetNonblockStub
	fakeReturns := fake.setNonblockReturns
	fake.recordInvocation("SetNonblock", []interface{}{arg1, arg2})
	fake.setNonblockMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) SetNonblockCallCount() int {
	fake.setNonblockMutex.RLock()
	defer fake.setNonblockMutex.RUnlock()
	return len(fake.setNonblockArgsForCall)
}

func (fake *FakeSyscallOperations) SetNonblockCalls(stub func(int, bool) error) {
	fake.setNonblockMutex.Lock()
	defer fake.setNonblockMutex.Unlock()
	fake.SetNonblockStub = stub
}

func (fake *FakeSyscallOperations) SetNonblockArgsForCall(i int) (int, bool) {
	fake.setNonblockMutex.RLock()
	defer fake.setNonblockMutex.RUnlock()
	argsForCall := fake.setNonblockArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeSyscallOperations) SetNonblockReturns(result1 error) {
	fake.setNonblockMutex.Lock()
	defer fake.setNonblockMutex.Unlock()
	fake.SetNonblockStub = nil
	fake.setNonblockReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) SetNonblockReturnsOnCall(i int, result1 error) {
	fake.setNonblockMutex.Lock()
	defer fake.setNonblockMutex.Unlock()
	fake.SetNonblockStub = nil
	if fake.setNonblockReturnsOnCall == nil {
		fake.setNonblockReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setNonblockReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) Statfs(arg1 string, arg2 *syscall.Statfs_t) error {
	fake.statfsMutex.Lock()
	ret, specificReturn := fake.statfsReturnsOnCall[len(fake.statfsArgsForCall)]
	fake.statfsArgsForCall = append(fake.statfsArgsForCall, struct {
		arg1 string
		arg2 *syscall.Statfs_t
	}{arg1, arg2})
	stub := fake.StatfsStub
	fakeReturns := fake.statfsReturns
	fake.recordInvocation("Statfs", []interface{}{arg1, arg2})
	fake.statfsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeSyscallOperations) StatfsCallCount() int {
	fake.statfsMutex.RLock()
	defer fake.statfsMutex.RUnlock()
	return len(fake.statfsArgsForCall)
}

func (fake *FakeSyscallOperations) StatfsCalls(stub func(string, *syscall.Statfs_t) error) {
	fake.statfsMutex.Lock()
	defer fake.statfsMutex.Unlock()
	fake.StatfsStub = stub
}

func (fake *FakeSyscallOperations) StatfsArgsForCall(i int) (string, *syscall.Statfs_t) {
	fake.statfsMutex.RLock()
	defer fake.statfsMutex.RUnlock()
	argsForCall := fake.statfsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeSyscallOperations) StatfsReturns(result1 error) {
	fake.statfsMutex.Lock()
	defer fake.statfsMutex.Unlock()
	fake.StatfsStub = nil
	fake.statfsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) StatfsReturnsOnCall(i int, result1 error) {
	fake.statfsMutex.Lock()
	defer fake.statfsMutex.Unlock()
	fake.StatfsStub = nil
	if fake.statfsReturnsOnCall == nil {
		fake.statfsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.statfsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) Statx(arg1 int, arg2 string, arg3 int, arg4 int) (uint64, error) {
	fake.statxMutex.Lock()
	ret, specificReturn := fake.statxReturnsOnCall[len(fake.statxArgsForCall)]
	fake.statxArgsForCall = append(fake.statxArgsForCall, struct {
		arg1 int
		arg2 string
		arg3 int
		arg4 int
	}{arg1, arg2, arg3, arg4})
	stub := fake.StatxStub
	fakeReturns := fake.statxReturns
	fake.recordInvocation("Statx", []interface{}{arg1, arg2, arg3, arg4})
	fake.statxMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeSyscallOperations) StatxCallCount() int {
	fake.statxMutex.RLock()
	defer fake.statxMutex.RUnlock()
	return len(fake.statxArgsForCall)
}

func (fake *FakeSyscallOperations) StatxCalls(stub func(int, string, int, int) (uint64, error)) {
	fake.statxMutex.Lock()
	defer fake.statxMutex.Unlock()
	fake.StatxStub = stub
}

func (fake *FakeSyscallOperations) StatxArgsForCall(i int) (int, string, int, int) {
	fake.statxMutex.RLock()
	defer fake.statxMutex.RUnlock()
	argsForCall := fake.statxArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeSyscallOperations) StatxReturns(result1 uint64, result2 error) {
	fake.statxMutex.Lock()
	defer fake.statxMutex.Unlock()
	fake.StatxStub = nil
	fake.statxReturns = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeSyscallOperations) StatxReturnsOnCall(i int, result1 uint64, result2 error) {
	fake.statxMutex.Lock()
	defer fake.statxMutex.Unlock()
	fake.StatxStub = nil
	if fake.statxReturnsOnCall == nil {
		fake.statxReturnsOnCall = make(map[int]struct {
			result1 uint64
			result2 error
		})
	}
	fake.statxReturnsOnCall[i] = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeSyscallOperations) Unmount(arg1 string, arg2 int) error {
	fake.unmountMutex.Lock()
	ret, specificReturn := fake.unmountReturnsOnCall[len(fake.unmountArgsForCall)]
	fake.unmountArgsForCall = append(fake.unmountArgsForCall, struct {
		arg1 string
		arg2 int
	}{arg1, arg2})
	stub := fake.UnmountStub
	fakeReturns := fake.unmountReturns
	fake.recordInvocation("Unmount", []interface{}{arg1, arg2})
	fake.unmountMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

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

func (fake *FakeSyscallOperations) UnmountCalls(stub func(string, int) error) {
	fake.unmountMutex.Lock()
	defer fake.unmountMutex.Unlock()
	fake.UnmountStub = stub
}

func (fake *FakeSyscallOperations) UnmountArgsForCall(i int) (string, int) {
	fake.unmountMutex.RLock()
	defer fake.unmountMutex.RUnlock()
	argsForCall := fake.unmountArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeSyscallOperations) UnmountReturns(result1 error) {
	fake.unmountMutex.Lock()
	defer fake.unmountMutex.Unlock()
	fake.UnmountStub = nil
	fake.unmountReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeSyscallOperations) UnmountReturnsOnCall(i int, result1 error) {
	fake.unmountMutex.Lock()
	defer fake.unmountMutex.Unlock()
	fake.UnmountStub = nil
	if fake.unmountReturnsOnCall == nil {
		fake.unmountReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.unmountReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

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

func (fake *FakeSyscallOperations) 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 _ platform.SyscallOperations = new(FakeSyscallOperations)
