ecs-agent/daemonimages/csidriver/mounter/mock_mount_windows.go

// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/mounter/safe_mounter_windows.go

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	mount "k8s.io/mount-utils"
)

// MockProxyMounter is a mock of ProxyMounter interface.
type MockProxyMounter struct {
	mount.Interface
	ctrl     *gomock.Controller
	recorder *MockProxyMounterMockRecorder
}

// MockProxyMounterMockRecorder is the mock recorder for MockProxyMounter.
type MockProxyMounterMockRecorder struct {
	mock *MockProxyMounter
}

// NewMockProxyMounter creates a new mock instance.
func NewMockProxyMounter(ctrl *gomock.Controller) *MockProxyMounter {
	mock := &MockProxyMounter{ctrl: ctrl}
	mock.recorder = &MockProxyMounterMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// FindDiskByLun indicates an expected call of FindDiskByLun.
func (mr *MockProxyMounterMockRecorder) FindDiskByLun(lun interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindDiskByLun", reflect.TypeOf((*MockProxyMounter)(nil).FindDiskByLun), lun)
}

// FormatAndMountSensitiveWithFormatOptions mocks base method.
func (m *MockProxyMounter) FormatAndMountSensitiveWithFormatOptions(source, target, fstype string, options, sensitiveOptions, formatOptions []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FormatAndMountSensitiveWithFormatOptions", source, target, fstype, options, sensitiveOptions, formatOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

// FormatAndMountSensitiveWithFormatOptions indicates an expected call of FormatAndMountSensitiveWithFormatOptions.
func (mr *MockProxyMounterMockRecorder) FormatAndMountSensitiveWithFormatOptions(source, target, fstype, options, sensitiveOptions, formatOptions interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FormatAndMountSensitiveWithFormatOptions", reflect.TypeOf((*MockProxyMounter)(nil).FormatAndMountSensitiveWithFormatOptions), source, target, fstype, options, sensitiveOptions, formatOptions)
}

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

// GetDeviceNameFromMount indicates an expected call of GetDeviceNameFromMount.
func (mr *MockProxyMounterMockRecorder) GetDeviceNameFromMount(mountPath, pluginMountDir interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeviceNameFromMount", reflect.TypeOf((*MockProxyMounter)(nil).GetDeviceNameFromMount), mountPath, pluginMountDir)
}

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

// GetDeviceSize indicates an expected call of GetDeviceSize.
func (mr *MockProxyMounterMockRecorder) GetDeviceSize(devicePath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeviceSize", reflect.TypeOf((*MockProxyMounter)(nil).GetDeviceSize), devicePath)
}

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

// GetMountRefs indicates an expected call of GetMountRefs.
func (mr *MockProxyMounterMockRecorder) GetMountRefs(pathname interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMountRefs", reflect.TypeOf((*MockProxyMounter)(nil).GetMountRefs), pathname)
}

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

// GetVolumeSizeInBytes indicates an expected call of GetVolumeSizeInBytes.
func (mr *MockProxyMounterMockRecorder) GetVolumeSizeInBytes(deviceMountPath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeSizeInBytes", reflect.TypeOf((*MockProxyMounter)(nil).GetVolumeSizeInBytes), deviceMountPath)
}

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

// IsLikelyNotMountPoint indicates an expected call of IsLikelyNotMountPoint.
func (mr *MockProxyMounterMockRecorder) IsLikelyNotMountPoint(file interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsLikelyNotMountPoint", reflect.TypeOf((*MockProxyMounter)(nil).IsLikelyNotMountPoint), file)
}

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

// IsMountPoint indicates an expected call of IsMountPoint.
func (mr *MockProxyMounterMockRecorder) IsMountPoint(file interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsMountPoint", reflect.TypeOf((*MockProxyMounter)(nil).IsMountPoint), file)
}

// IsMountPointMatch mocks base method.
func (m *MockProxyMounter) IsMountPointMatch(mp mount.MountPoint, dir string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsMountPointMatch", mp, dir)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

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

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

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

// MakeFile indicates an expected call of MakeFile.
func (mr *MockProxyMounterMockRecorder) MakeFile(pathname interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeFile", reflect.TypeOf((*MockProxyMounter)(nil).MakeFile), pathname)
}

// Mount mocks base method.
func (m *MockProxyMounter) Mount(source, target, fstype string, options []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Mount", source, target, fstype, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// Mount indicates an expected call of Mount.
func (mr *MockProxyMounterMockRecorder) Mount(source, target, fstype, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Mount", reflect.TypeOf((*MockProxyMounter)(nil).Mount), source, target, fstype, options)
}

// MountSensitive mocks base method.
func (m *MockProxyMounter) MountSensitive(source, target, fstype string, options, sensitiveOptions []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MountSensitive", source, target, fstype, options, sensitiveOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

// MountSensitive indicates an expected call of MountSensitive.
func (mr *MockProxyMounterMockRecorder) MountSensitive(source, target, fstype, options, sensitiveOptions interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MountSensitive", reflect.TypeOf((*MockProxyMounter)(nil).MountSensitive), source, target, fstype, options, sensitiveOptions)
}

// MountSensitiveWithoutSystemd mocks base method.
func (m *MockProxyMounter) MountSensitiveWithoutSystemd(source, target, fstype string, options, sensitiveOptions []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MountSensitiveWithoutSystemd", source, target, fstype, options, sensitiveOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

// MountSensitiveWithoutSystemd indicates an expected call of MountSensitiveWithoutSystemd.
func (mr *MockProxyMounterMockRecorder) MountSensitiveWithoutSystemd(source, target, fstype, options, sensitiveOptions interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MountSensitiveWithoutSystemd", reflect.TypeOf((*MockProxyMounter)(nil).MountSensitiveWithoutSystemd), source, target, fstype, options, sensitiveOptions)
}

// MountSensitiveWithoutSystemdWithMountFlags mocks base method.
func (m *MockProxyMounter) MountSensitiveWithoutSystemdWithMountFlags(source, target, fstype string, options, sensitiveOptions, mountFlags []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MountSensitiveWithoutSystemdWithMountFlags", source, target, fstype, options, sensitiveOptions, mountFlags)
	ret0, _ := ret[0].(error)
	return ret0
}

// MountSensitiveWithoutSystemdWithMountFlags indicates an expected call of MountSensitiveWithoutSystemdWithMountFlags.
func (mr *MockProxyMounterMockRecorder) MountSensitiveWithoutSystemdWithMountFlags(source, target, fstype, options, sensitiveOptions, mountFlags interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MountSensitiveWithoutSystemdWithMountFlags", reflect.TypeOf((*MockProxyMounter)(nil).MountSensitiveWithoutSystemdWithMountFlags), source, target, fstype, options, sensitiveOptions, mountFlags)
}

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

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

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

// ResizeVolume indicates an expected call of ResizeVolume.
func (mr *MockProxyMounterMockRecorder) ResizeVolume(deviceMountPath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResizeVolume", reflect.TypeOf((*MockProxyMounter)(nil).ResizeVolume), deviceMountPath)
}

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

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

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

// Unmount indicates an expected call of Unmount.
func (mr *MockProxyMounterMockRecorder) Unmount(target interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unmount", reflect.TypeOf((*MockProxyMounter)(nil).Unmount), target)
}

// WriteVolumeCache mocks base method.
func (m *MockProxyMounter) WriteVolumeCache(target string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "WriteVolumeCache", target)
}

// WriteVolumeCache indicates an expected call of WriteVolumeCache.
func (mr *MockProxyMounterMockRecorder) WriteVolumeCache(target interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteVolumeCache", reflect.TypeOf((*MockProxyMounter)(nil).WriteVolumeCache), target)
}