mock_fs.go

// Code generated by MockGen. DO NOT EDIT.
// Source: fs.go

// Package os is a generated GoMock package.
package os

import (
	io "io"
	fs "io/fs"
	os "os"
	reflect "reflect"
	syscall "syscall"
	time "time"

	gomock "github.com/golang/mock/gomock"
)

// Mockany is a mock of any interface.
type Mockany struct {
	ctrl     *gomock.Controller
	recorder *MockanyMockRecorder
}

// MockanyMockRecorder is the mock recorder for Mockany.
type MockanyMockRecorder struct {
	mock *Mockany
}

// NewMockany creates a new mock instance.
func NewMockany(ctrl *gomock.Controller) *Mockany {
	mock := &Mockany{ctrl: ctrl}
	mock.recorder = &MockanyMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *Mockany) EXPECT() *MockanyMockRecorder {
	return m.recorder
}

// MockOsInterface is a mock of OsInterface interface.
type MockOsInterface struct {
	ctrl     *gomock.Controller
	recorder *MockOsInterfaceMockRecorder
}

// MockOsInterfaceMockRecorder is the mock recorder for MockOsInterface.
type MockOsInterfaceMockRecorder struct {
	mock *MockOsInterface
}

// NewMockOsInterface creates a new mock instance.
func NewMockOsInterface(ctrl *gomock.Controller) *MockOsInterface {
	mock := &MockOsInterface{ctrl: ctrl}
	mock.recorder = &MockOsInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockOsInterface) EXPECT() *MockOsInterfaceMockRecorder {
	return m.recorder
}

// Chdir mocks base method.
func (m *MockOsInterface) Chdir(dir string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chdir", dir)
	ret0, _ := ret[0].(error)
	return ret0
}

// Chdir indicates an expected call of Chdir.
func (mr *MockOsInterfaceMockRecorder) Chdir(dir interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chdir", reflect.TypeOf((*MockOsInterface)(nil).Chdir), dir)
}

// Chmod mocks base method.
func (m *MockOsInterface) Chmod(name string, mode os.FileMode) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chmod", name, mode)
	ret0, _ := ret[0].(error)
	return ret0
}

// Chmod indicates an expected call of Chmod.
func (mr *MockOsInterfaceMockRecorder) Chmod(name, mode interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chmod", reflect.TypeOf((*MockOsInterface)(nil).Chmod), name, mode)
}

// Chown mocks base method.
func (m *MockOsInterface) Chown(name string, uid, gid int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chown", name, uid, gid)
	ret0, _ := ret[0].(error)
	return ret0
}

// Chown indicates an expected call of Chown.
func (mr *MockOsInterfaceMockRecorder) Chown(name, uid, gid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chown", reflect.TypeOf((*MockOsInterface)(nil).Chown), name, uid, gid)
}

// Chtimes mocks base method.
func (m *MockOsInterface) Chtimes(name string, atime, mtime time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chtimes", name, atime, mtime)
	ret0, _ := ret[0].(error)
	return ret0
}

// Chtimes indicates an expected call of Chtimes.
func (mr *MockOsInterfaceMockRecorder) Chtimes(name, atime, mtime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chtimes", reflect.TypeOf((*MockOsInterface)(nil).Chtimes), name, atime, mtime)
}

// Clearenv mocks base method.
func (m *MockOsInterface) Clearenv() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Clearenv")
}

// Clearenv indicates an expected call of Clearenv.
func (mr *MockOsInterfaceMockRecorder) Clearenv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clearenv", reflect.TypeOf((*MockOsInterface)(nil).Clearenv))
}

// Create mocks base method.
func (m *MockOsInterface) Create(name string) (*os.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", name)
	ret0, _ := ret[0].(*os.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockOsInterfaceMockRecorder) Create(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOsInterface)(nil).Create), name)
}

// CreateTemp mocks base method.
func (m *MockOsInterface) CreateTemp(dir, pattern string) (*os.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTemp", dir, pattern)
	ret0, _ := ret[0].(*os.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTemp indicates an expected call of CreateTemp.
func (mr *MockOsInterfaceMockRecorder) CreateTemp(dir, pattern interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTemp", reflect.TypeOf((*MockOsInterface)(nil).CreateTemp), dir, pattern)
}

// DirFS mocks base method.
func (m *MockOsInterface) DirFS(dir string) fs.FS {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DirFS", dir)
	ret0, _ := ret[0].(fs.FS)
	return ret0
}

// DirFS indicates an expected call of DirFS.
func (mr *MockOsInterfaceMockRecorder) DirFS(dir interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DirFS", reflect.TypeOf((*MockOsInterface)(nil).DirFS), dir)
}

// Environ mocks base method.
func (m *MockOsInterface) Environ() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Environ")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Environ indicates an expected call of Environ.
func (mr *MockOsInterfaceMockRecorder) Environ() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Environ", reflect.TypeOf((*MockOsInterface)(nil).Environ))
}

// Executable mocks base method.
func (m *MockOsInterface) Executable() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Executable")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Executable indicates an expected call of Executable.
func (mr *MockOsInterfaceMockRecorder) Executable() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Executable", reflect.TypeOf((*MockOsInterface)(nil).Executable))
}

// Exit mocks base method.
func (m *MockOsInterface) Exit(code int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Exit", code)
}

// Exit indicates an expected call of Exit.
func (mr *MockOsInterfaceMockRecorder) Exit(code interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exit", reflect.TypeOf((*MockOsInterface)(nil).Exit), code)
}

// Expand mocks base method.
func (m *MockOsInterface) Expand(s string, mapping func(string) string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expand", s, mapping)
	ret0, _ := ret[0].(string)
	return ret0
}

// Expand indicates an expected call of Expand.
func (mr *MockOsInterfaceMockRecorder) Expand(s, mapping interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expand", reflect.TypeOf((*MockOsInterface)(nil).Expand), s, mapping)
}

// ExpandEnv mocks base method.
func (m *MockOsInterface) ExpandEnv(s string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpandEnv", s)
	ret0, _ := ret[0].(string)
	return ret0
}

// ExpandEnv indicates an expected call of ExpandEnv.
func (mr *MockOsInterfaceMockRecorder) ExpandEnv(s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpandEnv", reflect.TypeOf((*MockOsInterface)(nil).ExpandEnv), s)
}

// FindProcess mocks base method.
func (m *MockOsInterface) FindProcess(pid int) (*os.Process, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindProcess", pid)
	ret0, _ := ret[0].(*os.Process)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindProcess indicates an expected call of FindProcess.
func (mr *MockOsInterfaceMockRecorder) FindProcess(pid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindProcess", reflect.TypeOf((*MockOsInterface)(nil).FindProcess), pid)
}

// Getegid mocks base method.
func (m *MockOsInterface) Getegid() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Getegid")
	ret0, _ := ret[0].(int)
	return ret0
}

// Getegid indicates an expected call of Getegid.
func (mr *MockOsInterfaceMockRecorder) Getegid() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getegid", reflect.TypeOf((*MockOsInterface)(nil).Getegid))
}

// Getenv mocks base method.
func (m *MockOsInterface) Getenv(key string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Getenv", key)
	ret0, _ := ret[0].(string)
	return ret0
}

// Getenv indicates an expected call of Getenv.
func (mr *MockOsInterfaceMockRecorder) Getenv(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getenv", reflect.TypeOf((*MockOsInterface)(nil).Getenv), key)
}

// Geteuid mocks base method.
func (m *MockOsInterface) Geteuid() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Geteuid")
	ret0, _ := ret[0].(int)
	return ret0
}

// Geteuid indicates an expected call of Geteuid.
func (mr *MockOsInterfaceMockRecorder) Geteuid() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Geteuid", reflect.TypeOf((*MockOsInterface)(nil).Geteuid))
}

// Getgid mocks base method.
func (m *MockOsInterface) Getgid() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Getgid")
	ret0, _ := ret[0].(int)
	return ret0
}

// Getgid indicates an expected call of Getgid.
func (mr *MockOsInterfaceMockRecorder) Getgid() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getgid", reflect.TypeOf((*MockOsInterface)(nil).Getgid))
}

// Getgroups mocks base method.
func (m *MockOsInterface) Getgroups() ([]int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Getgroups")
	ret0, _ := ret[0].([]int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Getgroups indicates an expected call of Getgroups.
func (mr *MockOsInterfaceMockRecorder) Getgroups() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getgroups", reflect.TypeOf((*MockOsInterface)(nil).Getgroups))
}

// Getpagesize mocks base method.
func (m *MockOsInterface) Getpagesize() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Getpagesize")
	ret0, _ := ret[0].(int)
	return ret0
}

// Getpagesize indicates an expected call of Getpagesize.
func (mr *MockOsInterfaceMockRecorder) Getpagesize() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getpagesize", reflect.TypeOf((*MockOsInterface)(nil).Getpagesize))
}

// Getpid mocks base method.
func (m *MockOsInterface) Getpid() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Getpid")
	ret0, _ := ret[0].(int)
	return ret0
}

// Getpid indicates an expected call of Getpid.
func (mr *MockOsInterfaceMockRecorder) Getpid() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getpid", reflect.TypeOf((*MockOsInterface)(nil).Getpid))
}

// Getppid mocks base method.
func (m *MockOsInterface) Getppid() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Getppid")
	ret0, _ := ret[0].(int)
	return ret0
}

// Getppid indicates an expected call of Getppid.
func (mr *MockOsInterfaceMockRecorder) Getppid() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getppid", reflect.TypeOf((*MockOsInterface)(nil).Getppid))
}

// Getuid mocks base method.
func (m *MockOsInterface) Getuid() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Getuid")
	ret0, _ := ret[0].(int)
	return ret0
}

// Getuid indicates an expected call of Getuid.
func (mr *MockOsInterfaceMockRecorder) Getuid() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getuid", reflect.TypeOf((*MockOsInterface)(nil).Getuid))
}

// Getwd mocks base method.
func (m *MockOsInterface) Getwd() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Getwd")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Getwd indicates an expected call of Getwd.
func (mr *MockOsInterfaceMockRecorder) Getwd() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getwd", reflect.TypeOf((*MockOsInterface)(nil).Getwd))
}

// Hostname mocks base method.
func (m *MockOsInterface) Hostname() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Hostname")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Hostname indicates an expected call of Hostname.
func (mr *MockOsInterfaceMockRecorder) Hostname() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hostname", reflect.TypeOf((*MockOsInterface)(nil).Hostname))
}

// IsExist mocks base method.
func (m *MockOsInterface) IsExist(err error) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsExist", err)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsExist indicates an expected call of IsExist.
func (mr *MockOsInterfaceMockRecorder) IsExist(err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsExist", reflect.TypeOf((*MockOsInterface)(nil).IsExist), err)
}

// IsNotExist mocks base method.
func (m *MockOsInterface) IsNotExist(err error) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsNotExist", err)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsNotExist indicates an expected call of IsNotExist.
func (mr *MockOsInterfaceMockRecorder) IsNotExist(err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNotExist", reflect.TypeOf((*MockOsInterface)(nil).IsNotExist), err)
}

// IsPathSeparator mocks base method.
func (m *MockOsInterface) IsPathSeparator(c uint8) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPathSeparator", c)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsPathSeparator indicates an expected call of IsPathSeparator.
func (mr *MockOsInterfaceMockRecorder) IsPathSeparator(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPathSeparator", reflect.TypeOf((*MockOsInterface)(nil).IsPathSeparator), c)
}

// IsPermission mocks base method.
func (m *MockOsInterface) IsPermission(err error) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPermission", err)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsPermission indicates an expected call of IsPermission.
func (mr *MockOsInterfaceMockRecorder) IsPermission(err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPermission", reflect.TypeOf((*MockOsInterface)(nil).IsPermission), err)
}

// IsTimeout mocks base method.
func (m *MockOsInterface) IsTimeout(err error) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsTimeout", err)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsTimeout indicates an expected call of IsTimeout.
func (mr *MockOsInterfaceMockRecorder) IsTimeout(err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTimeout", reflect.TypeOf((*MockOsInterface)(nil).IsTimeout), err)
}

// Lchown mocks base method.
func (m *MockOsInterface) Lchown(name string, uid, gid int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Lchown", name, uid, gid)
	ret0, _ := ret[0].(error)
	return ret0
}

// Lchown indicates an expected call of Lchown.
func (mr *MockOsInterfaceMockRecorder) Lchown(name, uid, gid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lchown", reflect.TypeOf((*MockOsInterface)(nil).Lchown), name, uid, gid)
}

// Link mocks base method.
func (m *MockOsInterface) Link(oldname, newname string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Link", oldname, newname)
	ret0, _ := ret[0].(error)
	return ret0
}

// Link indicates an expected call of Link.
func (mr *MockOsInterfaceMockRecorder) Link(oldname, newname interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Link", reflect.TypeOf((*MockOsInterface)(nil).Link), oldname, newname)
}

// LookupEnv mocks base method.
func (m *MockOsInterface) LookupEnv(key string) (string, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LookupEnv", key)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// LookupEnv indicates an expected call of LookupEnv.
func (mr *MockOsInterfaceMockRecorder) LookupEnv(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupEnv", reflect.TypeOf((*MockOsInterface)(nil).LookupEnv), key)
}

// Lstat mocks base method.
func (m *MockOsInterface) Lstat(name string) (os.FileInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Lstat", name)
	ret0, _ := ret[0].(os.FileInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Lstat indicates an expected call of Lstat.
func (mr *MockOsInterfaceMockRecorder) Lstat(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lstat", reflect.TypeOf((*MockOsInterface)(nil).Lstat), name)
}

// Mkdir mocks base method.
func (m *MockOsInterface) Mkdir(name string, perm os.FileMode) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Mkdir", name, perm)
	ret0, _ := ret[0].(error)
	return ret0
}

// Mkdir indicates an expected call of Mkdir.
func (mr *MockOsInterfaceMockRecorder) Mkdir(name, perm interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Mkdir", reflect.TypeOf((*MockOsInterface)(nil).Mkdir), name, perm)
}

// MkdirAll mocks base method.
func (m *MockOsInterface) MkdirAll(path string, perm os.FileMode) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MkdirAll", path, perm)
	ret0, _ := ret[0].(error)
	return ret0
}

// MkdirAll indicates an expected call of MkdirAll.
func (mr *MockOsInterfaceMockRecorder) MkdirAll(path, perm interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirAll", reflect.TypeOf((*MockOsInterface)(nil).MkdirAll), path, perm)
}

// MkdirTemp mocks base method.
func (m *MockOsInterface) MkdirTemp(dir, pattern string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MkdirTemp", dir, pattern)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MkdirTemp indicates an expected call of MkdirTemp.
func (mr *MockOsInterfaceMockRecorder) MkdirTemp(dir, pattern interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirTemp", reflect.TypeOf((*MockOsInterface)(nil).MkdirTemp), dir, pattern)
}

// NewFile mocks base method.
func (m *MockOsInterface) NewFile(fd uintptr, name string) *os.File {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewFile", fd, name)
	ret0, _ := ret[0].(*os.File)
	return ret0
}

// NewFile indicates an expected call of NewFile.
func (mr *MockOsInterfaceMockRecorder) NewFile(fd, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewFile", reflect.TypeOf((*MockOsInterface)(nil).NewFile), fd, name)
}

// NewSyscallError mocks base method.
func (m *MockOsInterface) NewSyscallError(syscall string, err error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSyscallError", syscall, err)
	ret0, _ := ret[0].(error)
	return ret0
}

// NewSyscallError indicates an expected call of NewSyscallError.
func (mr *MockOsInterfaceMockRecorder) NewSyscallError(syscall, err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSyscallError", reflect.TypeOf((*MockOsInterface)(nil).NewSyscallError), syscall, err)
}

// Open mocks base method.
func (m *MockOsInterface) Open(name string) (*os.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Open", name)
	ret0, _ := ret[0].(*os.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Open indicates an expected call of Open.
func (mr *MockOsInterfaceMockRecorder) Open(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockOsInterface)(nil).Open), name)
}

// OpenFile mocks base method.
func (m *MockOsInterface) OpenFile(name string, flag int, perm os.FileMode) (*os.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenFile", name, flag, perm)
	ret0, _ := ret[0].(*os.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenFile indicates an expected call of OpenFile.
func (mr *MockOsInterfaceMockRecorder) OpenFile(name, flag, perm interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenFile", reflect.TypeOf((*MockOsInterface)(nil).OpenFile), name, flag, perm)
}

// Pipe mocks base method.
func (m *MockOsInterface) Pipe() (*os.File, *os.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pipe")
	ret0, _ := ret[0].(*os.File)
	ret1, _ := ret[1].(*os.File)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Pipe indicates an expected call of Pipe.
func (mr *MockOsInterfaceMockRecorder) Pipe() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipe", reflect.TypeOf((*MockOsInterface)(nil).Pipe))
}

// ReadDir mocks base method.
func (m *MockOsInterface) ReadDir(name string) ([]os.DirEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadDir", name)
	ret0, _ := ret[0].([]os.DirEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadDir indicates an expected call of ReadDir.
func (mr *MockOsInterfaceMockRecorder) ReadDir(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadDir", reflect.TypeOf((*MockOsInterface)(nil).ReadDir), name)
}

// ReadFile mocks base method.
func (m *MockOsInterface) ReadFile(name string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadFile", name)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadFile indicates an expected call of ReadFile.
func (mr *MockOsInterfaceMockRecorder) ReadFile(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFile", reflect.TypeOf((*MockOsInterface)(nil).ReadFile), name)
}

// Readlink mocks base method.
func (m *MockOsInterface) Readlink(name string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Readlink", name)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Readlink indicates an expected call of Readlink.
func (mr *MockOsInterfaceMockRecorder) Readlink(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Readlink", reflect.TypeOf((*MockOsInterface)(nil).Readlink), name)
}

// Remove mocks base method.
func (m *MockOsInterface) Remove(name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Remove", name)
	ret0, _ := ret[0].(error)
	return ret0
}

// Remove indicates an expected call of Remove.
func (mr *MockOsInterfaceMockRecorder) Remove(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockOsInterface)(nil).Remove), name)
}

// RemoveAll mocks base method.
func (m *MockOsInterface) RemoveAll(path string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveAll", path)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveAll indicates an expected call of RemoveAll.
func (mr *MockOsInterfaceMockRecorder) RemoveAll(path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAll", reflect.TypeOf((*MockOsInterface)(nil).RemoveAll), path)
}

// Rename mocks base method.
func (m *MockOsInterface) Rename(oldpath, newpath string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rename", oldpath, newpath)
	ret0, _ := ret[0].(error)
	return ret0
}

// Rename indicates an expected call of Rename.
func (mr *MockOsInterfaceMockRecorder) Rename(oldpath, newpath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockOsInterface)(nil).Rename), oldpath, newpath)
}

// SameFile mocks base method.
func (m *MockOsInterface) SameFile(fi1, fi2 os.FileInfo) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SameFile", fi1, fi2)
	ret0, _ := ret[0].(bool)
	return ret0
}

// SameFile indicates an expected call of SameFile.
func (mr *MockOsInterfaceMockRecorder) SameFile(fi1, fi2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameFile", reflect.TypeOf((*MockOsInterface)(nil).SameFile), fi1, fi2)
}

// Setenv mocks base method.
func (m *MockOsInterface) Setenv(key, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Setenv", key, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// Setenv indicates an expected call of Setenv.
func (mr *MockOsInterfaceMockRecorder) Setenv(key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Setenv", reflect.TypeOf((*MockOsInterface)(nil).Setenv), key, value)
}

// StartProcess mocks base method.
func (m *MockOsInterface) StartProcess(name string, argv []string, attr *os.ProcAttr) (*os.Process, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartProcess", name, argv, attr)
	ret0, _ := ret[0].(*os.Process)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartProcess indicates an expected call of StartProcess.
func (mr *MockOsInterfaceMockRecorder) StartProcess(name, argv, attr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartProcess", reflect.TypeOf((*MockOsInterface)(nil).StartProcess), name, argv, attr)
}

// Stat mocks base method.
func (m *MockOsInterface) Stat(name string) (os.FileInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stat", name)
	ret0, _ := ret[0].(os.FileInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stat indicates an expected call of Stat.
func (mr *MockOsInterfaceMockRecorder) Stat(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockOsInterface)(nil).Stat), name)
}

// Symlink mocks base method.
func (m *MockOsInterface) Symlink(oldname, newname string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Symlink", oldname, newname)
	ret0, _ := ret[0].(error)
	return ret0
}

// Symlink indicates an expected call of Symlink.
func (mr *MockOsInterfaceMockRecorder) Symlink(oldname, newname interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Symlink", reflect.TypeOf((*MockOsInterface)(nil).Symlink), oldname, newname)
}

// TempDir mocks base method.
func (m *MockOsInterface) TempDir() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TempDir")
	ret0, _ := ret[0].(string)
	return ret0
}

// TempDir indicates an expected call of TempDir.
func (mr *MockOsInterfaceMockRecorder) TempDir() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TempDir", reflect.TypeOf((*MockOsInterface)(nil).TempDir))
}

// Truncate mocks base method.
func (m *MockOsInterface) Truncate(name string, size int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Truncate", name, size)
	ret0, _ := ret[0].(error)
	return ret0
}

// Truncate indicates an expected call of Truncate.
func (mr *MockOsInterfaceMockRecorder) Truncate(name, size interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockOsInterface)(nil).Truncate), name, size)
}

// Unsetenv mocks base method.
func (m *MockOsInterface) Unsetenv(key string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unsetenv", key)
	ret0, _ := ret[0].(error)
	return ret0
}

// Unsetenv indicates an expected call of Unsetenv.
func (mr *MockOsInterfaceMockRecorder) Unsetenv(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsetenv", reflect.TypeOf((*MockOsInterface)(nil).Unsetenv), key)
}

// UserCacheDir mocks base method.
func (m *MockOsInterface) UserCacheDir() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserCacheDir")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UserCacheDir indicates an expected call of UserCacheDir.
func (mr *MockOsInterfaceMockRecorder) UserCacheDir() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserCacheDir", reflect.TypeOf((*MockOsInterface)(nil).UserCacheDir))
}

// UserConfigDir mocks base method.
func (m *MockOsInterface) UserConfigDir() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserConfigDir")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UserConfigDir indicates an expected call of UserConfigDir.
func (mr *MockOsInterfaceMockRecorder) UserConfigDir() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserConfigDir", reflect.TypeOf((*MockOsInterface)(nil).UserConfigDir))
}

// UserHomeDir mocks base method.
func (m *MockOsInterface) UserHomeDir() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserHomeDir")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UserHomeDir indicates an expected call of UserHomeDir.
func (mr *MockOsInterfaceMockRecorder) UserHomeDir() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserHomeDir", reflect.TypeOf((*MockOsInterface)(nil).UserHomeDir))
}

// WriteFile mocks base method.
func (m *MockOsInterface) WriteFile(name string, data []byte, perm os.FileMode) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteFile", name, data, perm)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteFile indicates an expected call of WriteFile.
func (mr *MockOsInterfaceMockRecorder) WriteFile(name, data, perm interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteFile", reflect.TypeOf((*MockOsInterface)(nil).WriteFile), name, data, perm)
}

// MockFileInterface is a mock of FileInterface interface.
type MockFileInterface struct {
	ctrl     *gomock.Controller
	recorder *MockFileInterfaceMockRecorder
}

// MockFileInterfaceMockRecorder is the mock recorder for MockFileInterface.
type MockFileInterfaceMockRecorder struct {
	mock *MockFileInterface
}

// NewMockFileInterface creates a new mock instance.
func NewMockFileInterface(ctrl *gomock.Controller) *MockFileInterface {
	mock := &MockFileInterface{ctrl: ctrl}
	mock.recorder = &MockFileInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFileInterface) EXPECT() *MockFileInterfaceMockRecorder {
	return m.recorder
}

// Chdir mocks base method.
func (m *MockFileInterface) Chdir() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chdir")
	ret0, _ := ret[0].(error)
	return ret0
}

// Chdir indicates an expected call of Chdir.
func (mr *MockFileInterfaceMockRecorder) Chdir() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chdir", reflect.TypeOf((*MockFileInterface)(nil).Chdir))
}

// Chmod mocks base method.
func (m *MockFileInterface) Chmod(mode os.FileMode) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chmod", mode)
	ret0, _ := ret[0].(error)
	return ret0
}

// Chmod indicates an expected call of Chmod.
func (mr *MockFileInterfaceMockRecorder) Chmod(mode interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chmod", reflect.TypeOf((*MockFileInterface)(nil).Chmod), mode)
}

// Chown mocks base method.
func (m *MockFileInterface) Chown(uid, gid int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chown", uid, gid)
	ret0, _ := ret[0].(error)
	return ret0
}

// Chown indicates an expected call of Chown.
func (mr *MockFileInterfaceMockRecorder) Chown(uid, gid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chown", reflect.TypeOf((*MockFileInterface)(nil).Chown), uid, gid)
}

// Close mocks base method.
func (m *MockFileInterface) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockFileInterfaceMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFileInterface)(nil).Close))
}

// Fd mocks base method.
func (m *MockFileInterface) Fd() uintptr {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fd")
	ret0, _ := ret[0].(uintptr)
	return ret0
}

// Fd indicates an expected call of Fd.
func (mr *MockFileInterfaceMockRecorder) Fd() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fd", reflect.TypeOf((*MockFileInterface)(nil).Fd))
}

// Name mocks base method.
func (m *MockFileInterface) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockFileInterfaceMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockFileInterface)(nil).Name))
}

// Read mocks base method.
func (m *MockFileInterface) Read(b []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", b)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockFileInterfaceMockRecorder) Read(b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockFileInterface)(nil).Read), b)
}

// ReadAt mocks base method.
func (m *MockFileInterface) ReadAt(b []byte, off int64) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadAt", b, off)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadAt indicates an expected call of ReadAt.
func (mr *MockFileInterfaceMockRecorder) ReadAt(b, off interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAt", reflect.TypeOf((*MockFileInterface)(nil).ReadAt), b, off)
}

// ReadDir mocks base method.
func (m *MockFileInterface) ReadDir(n int) ([]os.DirEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadDir", n)
	ret0, _ := ret[0].([]os.DirEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadDir indicates an expected call of ReadDir.
func (mr *MockFileInterfaceMockRecorder) ReadDir(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadDir", reflect.TypeOf((*MockFileInterface)(nil).ReadDir), n)
}

// ReadFrom mocks base method.
func (m *MockFileInterface) ReadFrom(r io.Reader) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadFrom", r)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadFrom indicates an expected call of ReadFrom.
func (mr *MockFileInterfaceMockRecorder) ReadFrom(r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFrom", reflect.TypeOf((*MockFileInterface)(nil).ReadFrom), r)
}

// Readdir mocks base method.
func (m *MockFileInterface) Readdir(n int) ([]os.FileInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Readdir", n)
	ret0, _ := ret[0].([]os.FileInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Readdir indicates an expected call of Readdir.
func (mr *MockFileInterfaceMockRecorder) Readdir(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Readdir", reflect.TypeOf((*MockFileInterface)(nil).Readdir), n)
}

// Readdirnames mocks base method.
func (m *MockFileInterface) Readdirnames(n int) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Readdirnames", n)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Readdirnames indicates an expected call of Readdirnames.
func (mr *MockFileInterfaceMockRecorder) Readdirnames(n interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Readdirnames", reflect.TypeOf((*MockFileInterface)(nil).Readdirnames), n)
}

// Seek mocks base method.
func (m *MockFileInterface) Seek(offset int64, whence int) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Seek", offset, whence)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Seek indicates an expected call of Seek.
func (mr *MockFileInterfaceMockRecorder) Seek(offset, whence interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seek", reflect.TypeOf((*MockFileInterface)(nil).Seek), offset, whence)
}

// SetDeadline mocks base method.
func (m *MockFileInterface) SetDeadline(t time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDeadline", t)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetDeadline indicates an expected call of SetDeadline.
func (mr *MockFileInterfaceMockRecorder) SetDeadline(t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockFileInterface)(nil).SetDeadline), t)
}

// SetReadDeadline mocks base method.
func (m *MockFileInterface) SetReadDeadline(t time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetReadDeadline", t)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetReadDeadline indicates an expected call of SetReadDeadline.
func (mr *MockFileInterfaceMockRecorder) SetReadDeadline(t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockFileInterface)(nil).SetReadDeadline), t)
}

// SetWriteDeadline mocks base method.
func (m *MockFileInterface) SetWriteDeadline(t time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetWriteDeadline", t)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetWriteDeadline indicates an expected call of SetWriteDeadline.
func (mr *MockFileInterfaceMockRecorder) SetWriteDeadline(t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockFileInterface)(nil).SetWriteDeadline), t)
}

// Stat mocks base method.
func (m *MockFileInterface) Stat() (os.FileInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stat")
	ret0, _ := ret[0].(os.FileInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stat indicates an expected call of Stat.
func (mr *MockFileInterfaceMockRecorder) Stat() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockFileInterface)(nil).Stat))
}

// Sync mocks base method.
func (m *MockFileInterface) Sync() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sync")
	ret0, _ := ret[0].(error)
	return ret0
}

// Sync indicates an expected call of Sync.
func (mr *MockFileInterfaceMockRecorder) Sync() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockFileInterface)(nil).Sync))
}

// SyscallConn mocks base method.
func (m *MockFileInterface) SyscallConn() (syscall.RawConn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyscallConn")
	ret0, _ := ret[0].(syscall.RawConn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyscallConn indicates an expected call of SyscallConn.
func (mr *MockFileInterfaceMockRecorder) SyscallConn() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyscallConn", reflect.TypeOf((*MockFileInterface)(nil).SyscallConn))
}

// Truncate mocks base method.
func (m *MockFileInterface) Truncate(size int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Truncate", size)
	ret0, _ := ret[0].(error)
	return ret0
}

// Truncate indicates an expected call of Truncate.
func (mr *MockFileInterfaceMockRecorder) Truncate(size interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockFileInterface)(nil).Truncate), size)
}

// Write mocks base method.
func (m *MockFileInterface) Write(b []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", b)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockFileInterfaceMockRecorder) Write(b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockFileInterface)(nil).Write), b)
}

// WriteAt mocks base method.
func (m *MockFileInterface) WriteAt(b []byte, off int64) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteAt", b, off)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteAt indicates an expected call of WriteAt.
func (mr *MockFileInterfaceMockRecorder) WriteAt(b, off interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAt", reflect.TypeOf((*MockFileInterface)(nil).WriteAt), b, off)
}

// WriteString mocks base method.
func (m *MockFileInterface) WriteString(s string) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteString", s)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteString indicates an expected call of WriteString.
func (mr *MockFileInterfaceMockRecorder) WriteString(s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteString", reflect.TypeOf((*MockFileInterface)(nil).WriteString), s)
}

// MockSyscallErrorInterface is a mock of SyscallErrorInterface interface.
type MockSyscallErrorInterface struct {
	ctrl     *gomock.Controller
	recorder *MockSyscallErrorInterfaceMockRecorder
}

// MockSyscallErrorInterfaceMockRecorder is the mock recorder for MockSyscallErrorInterface.
type MockSyscallErrorInterfaceMockRecorder struct {
	mock *MockSyscallErrorInterface
}

// NewMockSyscallErrorInterface creates a new mock instance.
func NewMockSyscallErrorInterface(ctrl *gomock.Controller) *MockSyscallErrorInterface {
	mock := &MockSyscallErrorInterface{ctrl: ctrl}
	mock.recorder = &MockSyscallErrorInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSyscallErrorInterface) EXPECT() *MockSyscallErrorInterfaceMockRecorder {
	return m.recorder
}

// Error mocks base method.
func (m *MockSyscallErrorInterface) Error() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error")
	ret0, _ := ret[0].(string)
	return ret0
}

// Error indicates an expected call of Error.
func (mr *MockSyscallErrorInterfaceMockRecorder) Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockSyscallErrorInterface)(nil).Error))
}

// Timeout mocks base method.
func (m *MockSyscallErrorInterface) Timeout() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Timeout")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Timeout indicates an expected call of Timeout.
func (mr *MockSyscallErrorInterfaceMockRecorder) Timeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timeout", reflect.TypeOf((*MockSyscallErrorInterface)(nil).Timeout))
}

// Unwrap mocks base method.
func (m *MockSyscallErrorInterface) Unwrap() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unwrap")
	ret0, _ := ret[0].(error)
	return ret0
}

// Unwrap indicates an expected call of Unwrap.
func (mr *MockSyscallErrorInterfaceMockRecorder) Unwrap() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unwrap", reflect.TypeOf((*MockSyscallErrorInterface)(nil).Unwrap))
}

// MockProcessInterface is a mock of ProcessInterface interface.
type MockProcessInterface struct {
	ctrl     *gomock.Controller
	recorder *MockProcessInterfaceMockRecorder
}

// MockProcessInterfaceMockRecorder is the mock recorder for MockProcessInterface.
type MockProcessInterfaceMockRecorder struct {
	mock *MockProcessInterface
}

// NewMockProcessInterface creates a new mock instance.
func NewMockProcessInterface(ctrl *gomock.Controller) *MockProcessInterface {
	mock := &MockProcessInterface{ctrl: ctrl}
	mock.recorder = &MockProcessInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProcessInterface) EXPECT() *MockProcessInterfaceMockRecorder {
	return m.recorder
}

// Kill mocks base method.
func (m *MockProcessInterface) Kill() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Kill")
	ret0, _ := ret[0].(error)
	return ret0
}

// Kill indicates an expected call of Kill.
func (mr *MockProcessInterfaceMockRecorder) Kill() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kill", reflect.TypeOf((*MockProcessInterface)(nil).Kill))
}

// Release mocks base method.
func (m *MockProcessInterface) Release() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Release")
	ret0, _ := ret[0].(error)
	return ret0
}

// Release indicates an expected call of Release.
func (mr *MockProcessInterfaceMockRecorder) Release() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Release", reflect.TypeOf((*MockProcessInterface)(nil).Release))
}

// Signal mocks base method.
func (m *MockProcessInterface) Signal(sig os.Signal) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Signal", sig)
	ret0, _ := ret[0].(error)
	return ret0
}

// Signal indicates an expected call of Signal.
func (mr *MockProcessInterfaceMockRecorder) Signal(sig interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Signal", reflect.TypeOf((*MockProcessInterface)(nil).Signal), sig)
}

// Wait mocks base method.
func (m *MockProcessInterface) Wait() (*os.ProcessState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Wait")
	ret0, _ := ret[0].(*os.ProcessState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Wait indicates an expected call of Wait.
func (mr *MockProcessInterfaceMockRecorder) Wait() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Wait", reflect.TypeOf((*MockProcessInterface)(nil).Wait))
}

// MockProcessStateInterface is a mock of ProcessStateInterface interface.
type MockProcessStateInterface struct {
	ctrl     *gomock.Controller
	recorder *MockProcessStateInterfaceMockRecorder
}

// MockProcessStateInterfaceMockRecorder is the mock recorder for MockProcessStateInterface.
type MockProcessStateInterfaceMockRecorder struct {
	mock *MockProcessStateInterface
}

// NewMockProcessStateInterface creates a new mock instance.
func NewMockProcessStateInterface(ctrl *gomock.Controller) *MockProcessStateInterface {
	mock := &MockProcessStateInterface{ctrl: ctrl}
	mock.recorder = &MockProcessStateInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockProcessStateInterface) EXPECT() *MockProcessStateInterfaceMockRecorder {
	return m.recorder
}

// ExitCode mocks base method.
func (m *MockProcessStateInterface) ExitCode() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExitCode")
	ret0, _ := ret[0].(int)
	return ret0
}

// ExitCode indicates an expected call of ExitCode.
func (mr *MockProcessStateInterfaceMockRecorder) ExitCode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitCode", reflect.TypeOf((*MockProcessStateInterface)(nil).ExitCode))
}

// Exited mocks base method.
func (m *MockProcessStateInterface) Exited() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exited")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Exited indicates an expected call of Exited.
func (mr *MockProcessStateInterfaceMockRecorder) Exited() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exited", reflect.TypeOf((*MockProcessStateInterface)(nil).Exited))
}

// Pid mocks base method.
func (m *MockProcessStateInterface) Pid() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pid")
	ret0, _ := ret[0].(int)
	return ret0
}

// Pid indicates an expected call of Pid.
func (mr *MockProcessStateInterfaceMockRecorder) Pid() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pid", reflect.TypeOf((*MockProcessStateInterface)(nil).Pid))
}

// String mocks base method.
func (m *MockProcessStateInterface) String() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "String")
	ret0, _ := ret[0].(string)
	return ret0
}

// String indicates an expected call of String.
func (mr *MockProcessStateInterfaceMockRecorder) String() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockProcessStateInterface)(nil).String))
}

// Success mocks base method.
func (m *MockProcessStateInterface) Success() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Success")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Success indicates an expected call of Success.
func (mr *MockProcessStateInterfaceMockRecorder) Success() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Success", reflect.TypeOf((*MockProcessStateInterface)(nil).Success))
}

// Sys mocks base method.
func (m *MockProcessStateInterface) Sys() any {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sys")
	ret0, _ := ret[0].(any)
	return ret0
}

// Sys indicates an expected call of Sys.
func (mr *MockProcessStateInterfaceMockRecorder) Sys() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sys", reflect.TypeOf((*MockProcessStateInterface)(nil).Sys))
}

// SysUsage mocks base method.
func (m *MockProcessStateInterface) SysUsage() any {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SysUsage")
	ret0, _ := ret[0].(any)
	return ret0
}

// SysUsage indicates an expected call of SysUsage.
func (mr *MockProcessStateInterfaceMockRecorder) SysUsage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SysUsage", reflect.TypeOf((*MockProcessStateInterface)(nil).SysUsage))
}

// SystemTime mocks base method.
func (m *MockProcessStateInterface) SystemTime() time.Duration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SystemTime")
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

// SystemTime indicates an expected call of SystemTime.
func (mr *MockProcessStateInterfaceMockRecorder) SystemTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemTime", reflect.TypeOf((*MockProcessStateInterface)(nil).SystemTime))
}

// UserTime mocks base method.
func (m *MockProcessStateInterface) UserTime() time.Duration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserTime")
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

// UserTime indicates an expected call of UserTime.
func (mr *MockProcessStateInterfaceMockRecorder) UserTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserTime", reflect.TypeOf((*MockProcessStateInterface)(nil).UserTime))
}

// MockLinkErrorInterface is a mock of LinkErrorInterface interface.
type MockLinkErrorInterface struct {
	ctrl     *gomock.Controller
	recorder *MockLinkErrorInterfaceMockRecorder
}

// MockLinkErrorInterfaceMockRecorder is the mock recorder for MockLinkErrorInterface.
type MockLinkErrorInterfaceMockRecorder struct {
	mock *MockLinkErrorInterface
}

// NewMockLinkErrorInterface creates a new mock instance.
func NewMockLinkErrorInterface(ctrl *gomock.Controller) *MockLinkErrorInterface {
	mock := &MockLinkErrorInterface{ctrl: ctrl}
	mock.recorder = &MockLinkErrorInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLinkErrorInterface) EXPECT() *MockLinkErrorInterfaceMockRecorder {
	return m.recorder
}

// Error mocks base method.
func (m *MockLinkErrorInterface) Error() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error")
	ret0, _ := ret[0].(string)
	return ret0
}

// Error indicates an expected call of Error.
func (mr *MockLinkErrorInterfaceMockRecorder) Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLinkErrorInterface)(nil).Error))
}

// Unwrap mocks base method.
func (m *MockLinkErrorInterface) Unwrap() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unwrap")
	ret0, _ := ret[0].(error)
	return ret0
}

// Unwrap indicates an expected call of Unwrap.
func (mr *MockLinkErrorInterfaceMockRecorder) Unwrap() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unwrap", reflect.TypeOf((*MockLinkErrorInterface)(nil).Unwrap))
}