github.com/k8snetworkplumbingwg/sriov-network-operator@v1.2.1-0.20240408194816-2d2e5a45d453/pkg/host/mock/mock_host.go

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

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	ghw "github.com/jaypipes/ghw"
	v1 "github.com/k8snetworkplumbingwg/sriov-network-operator/api/v1"
	store "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/host/store"
	types "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/host/types"
	netlink "github.com/vishvananda/netlink"
)

// MockHostManagerInterface is a mock of HostManagerInterface interface.
type MockHostManagerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockHostManagerInterfaceMockRecorder
}

// MockHostManagerInterfaceMockRecorder is the mock recorder for MockHostManagerInterface.
type MockHostManagerInterfaceMockRecorder struct {
	mock *MockHostManagerInterface
}

// NewMockHostManagerInterface creates a new mock instance.
func NewMockHostManagerInterface(ctrl *gomock.Controller) *MockHostManagerInterface {
	mock := &MockHostManagerInterface{ctrl: ctrl}
	mock.recorder = &MockHostManagerInterfaceMockRecorder{mock}
	return mock
}

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

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

// AddDisableNMUdevRule indicates an expected call of AddDisableNMUdevRule.
func (mr *MockHostManagerInterfaceMockRecorder) AddDisableNMUdevRule(pfPciAddress interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDisableNMUdevRule", reflect.TypeOf((*MockHostManagerInterface)(nil).AddDisableNMUdevRule), pfPciAddress)
}

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

// AddPersistPFNameUdevRule indicates an expected call of AddPersistPFNameUdevRule.
func (mr *MockHostManagerInterfaceMockRecorder) AddPersistPFNameUdevRule(pfPciAddress, pfName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPersistPFNameUdevRule", reflect.TypeOf((*MockHostManagerInterface)(nil).AddPersistPFNameUdevRule), pfPciAddress, pfName)
}

// AddVfRepresentorUdevRule mocks base method.
func (m *MockHostManagerInterface) AddVfRepresentorUdevRule(pfPciAddress, pfName, pfSwitchID, pfSwitchPort string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddVfRepresentorUdevRule", pfPciAddress, pfName, pfSwitchID, pfSwitchPort)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddVfRepresentorUdevRule indicates an expected call of AddVfRepresentorUdevRule.
func (mr *MockHostManagerInterfaceMockRecorder) AddVfRepresentorUdevRule(pfPciAddress, pfName, pfSwitchID, pfSwitchPort interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddVfRepresentorUdevRule", reflect.TypeOf((*MockHostManagerInterface)(nil).AddVfRepresentorUdevRule), pfPciAddress, pfName, pfSwitchID, pfSwitchPort)
}

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

// BindDefaultDriver indicates an expected call of BindDefaultDriver.
func (mr *MockHostManagerInterfaceMockRecorder) BindDefaultDriver(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindDefaultDriver", reflect.TypeOf((*MockHostManagerInterface)(nil).BindDefaultDriver), pciAddr)
}

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

// BindDpdkDriver indicates an expected call of BindDpdkDriver.
func (mr *MockHostManagerInterfaceMockRecorder) BindDpdkDriver(pciAddr, driver interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindDpdkDriver", reflect.TypeOf((*MockHostManagerInterface)(nil).BindDpdkDriver), pciAddr, driver)
}

// BindDriverByBusAndDevice mocks base method.
func (m *MockHostManagerInterface) BindDriverByBusAndDevice(bus, device, driver string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BindDriverByBusAndDevice", bus, device, driver)
	ret0, _ := ret[0].(error)
	return ret0
}

// BindDriverByBusAndDevice indicates an expected call of BindDriverByBusAndDevice.
func (mr *MockHostManagerInterfaceMockRecorder) BindDriverByBusAndDevice(bus, device, driver interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindDriverByBusAndDevice", reflect.TypeOf((*MockHostManagerInterface)(nil).BindDriverByBusAndDevice), bus, device, driver)
}

// CompareServices mocks base method.
func (m *MockHostManagerInterface) CompareServices(serviceA, serviceB *types.Service) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompareServices", serviceA, serviceB)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CompareServices indicates an expected call of CompareServices.
func (mr *MockHostManagerInterfaceMockRecorder) CompareServices(serviceA, serviceB interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareServices", reflect.TypeOf((*MockHostManagerInterface)(nil).CompareServices), serviceA, serviceB)
}

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

// ConfigSriovDeviceVirtual indicates an expected call of ConfigSriovDeviceVirtual.
func (mr *MockHostManagerInterfaceMockRecorder) ConfigSriovDeviceVirtual(iface interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSriovDeviceVirtual", reflect.TypeOf((*MockHostManagerInterface)(nil).ConfigSriovDeviceVirtual), iface)
}

// ConfigSriovInterfaces mocks base method.
func (m *MockHostManagerInterface) ConfigSriovInterfaces(storeManager store.ManagerInterface, interfaces []v1.Interface, ifaceStatuses []v1.InterfaceExt, skipVFConfiguration bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigSriovInterfaces", storeManager, interfaces, ifaceStatuses, skipVFConfiguration)
	ret0, _ := ret[0].(error)
	return ret0
}

// ConfigSriovInterfaces indicates an expected call of ConfigSriovInterfaces.
func (mr *MockHostManagerInterfaceMockRecorder) ConfigSriovInterfaces(storeManager, interfaces, ifaceStatuses, skipVFConfiguration interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSriovInterfaces", reflect.TypeOf((*MockHostManagerInterface)(nil).ConfigSriovInterfaces), storeManager, interfaces, ifaceStatuses, skipVFConfiguration)
}

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

// CreateVDPADevice indicates an expected call of CreateVDPADevice.
func (mr *MockHostManagerInterfaceMockRecorder) CreateVDPADevice(pciAddr, vdpaType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVDPADevice", reflect.TypeOf((*MockHostManagerInterface)(nil).CreateVDPADevice), pciAddr, vdpaType)
}

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

// DeleteVDPADevice indicates an expected call of DeleteVDPADevice.
func (mr *MockHostManagerInterfaceMockRecorder) DeleteVDPADevice(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVDPADevice", reflect.TypeOf((*MockHostManagerInterface)(nil).DeleteVDPADevice), pciAddr)
}

// DiscoverSriovDevices mocks base method.
func (m *MockHostManagerInterface) DiscoverSriovDevices(storeManager store.ManagerInterface) ([]v1.InterfaceExt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DiscoverSriovDevices", storeManager)
	ret0, _ := ret[0].([]v1.InterfaceExt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DiscoverSriovDevices indicates an expected call of DiscoverSriovDevices.
func (mr *MockHostManagerInterfaceMockRecorder) DiscoverSriovDevices(storeManager interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverSriovDevices", reflect.TypeOf((*MockHostManagerInterface)(nil).DiscoverSriovDevices), storeManager)
}

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

// DiscoverVDPAType indicates an expected call of DiscoverVDPAType.
func (mr *MockHostManagerInterfaceMockRecorder) DiscoverVDPAType(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverVDPAType", reflect.TypeOf((*MockHostManagerInterface)(nil).DiscoverVDPAType), pciAddr)
}

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

// EnableHwTcOffload indicates an expected call of EnableHwTcOffload.
func (mr *MockHostManagerInterfaceMockRecorder) EnableHwTcOffload(ifaceName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHwTcOffload", reflect.TypeOf((*MockHostManagerInterface)(nil).EnableHwTcOffload), ifaceName)
}

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

// EnableRDMA indicates an expected call of EnableRDMA.
func (mr *MockHostManagerInterfaceMockRecorder) EnableRDMA(conditionFilePath, serviceName, packageManager interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRDMA", reflect.TypeOf((*MockHostManagerInterface)(nil).EnableRDMA), conditionFilePath, serviceName, packageManager)
}

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

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

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

// EnableService indicates an expected call of EnableService.
func (mr *MockHostManagerInterfaceMockRecorder) EnableService(service interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableService", reflect.TypeOf((*MockHostManagerInterface)(nil).EnableService), service)
}

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

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

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

// GetDevlinkDeviceParam indicates an expected call of GetDevlinkDeviceParam.
func (mr *MockHostManagerInterfaceMockRecorder) GetDevlinkDeviceParam(pciAddr, paramName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDevlinkDeviceParam", reflect.TypeOf((*MockHostManagerInterface)(nil).GetDevlinkDeviceParam), pciAddr, paramName)
}

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

// GetDriverByBusAndDevice indicates an expected call of GetDriverByBusAndDevice.
func (mr *MockHostManagerInterfaceMockRecorder) GetDriverByBusAndDevice(bus, device interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDriverByBusAndDevice", reflect.TypeOf((*MockHostManagerInterface)(nil).GetDriverByBusAndDevice), bus, device)
}

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

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

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

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

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

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

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

// GetNetdevMTU indicates an expected call of GetNetdevMTU.
func (mr *MockHostManagerInterfaceMockRecorder) GetNetdevMTU(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetdevMTU", reflect.TypeOf((*MockHostManagerInterface)(nil).GetNetdevMTU), pciAddr)
}

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

// GetNicSriovMode indicates an expected call of GetNicSriovMode.
func (mr *MockHostManagerInterfaceMockRecorder) GetNicSriovMode(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNicSriovMode", reflect.TypeOf((*MockHostManagerInterface)(nil).GetNicSriovMode), pciAddr)
}

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

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

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

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

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

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

// GetVfInfo mocks base method.
func (m *MockHostManagerInterface) GetVfInfo(pciAddr string, devices []*ghw.PCIDevice) v1.VirtualFunction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVfInfo", pciAddr, devices)
	ret0, _ := ret[0].(v1.VirtualFunction)
	return ret0
}

// GetVfInfo indicates an expected call of GetVfInfo.
func (mr *MockHostManagerInterfaceMockRecorder) GetVfInfo(pciAddr, devices interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVfInfo", reflect.TypeOf((*MockHostManagerInterface)(nil).GetVfInfo), pciAddr, devices)
}

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

// HasDriver indicates an expected call of HasDriver.
func (mr *MockHostManagerInterfaceMockRecorder) HasDriver(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasDriver", reflect.TypeOf((*MockHostManagerInterface)(nil).HasDriver), pciAddr)
}

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

// InstallRDMA indicates an expected call of InstallRDMA.
func (mr *MockHostManagerInterfaceMockRecorder) InstallRDMA(packageManager interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallRDMA", reflect.TypeOf((*MockHostManagerInterface)(nil).InstallRDMA), packageManager)
}

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

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

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

// IsKernelArgsSet indicates an expected call of IsKernelArgsSet.
func (mr *MockHostManagerInterfaceMockRecorder) IsKernelArgsSet(cmdLine, karg interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsKernelArgsSet", reflect.TypeOf((*MockHostManagerInterface)(nil).IsKernelArgsSet), cmdLine, karg)
}

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

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

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

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

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

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

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

// IsServiceEnabled indicates an expected call of IsServiceEnabled.
func (mr *MockHostManagerInterfaceMockRecorder) IsServiceEnabled(servicePath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsServiceEnabled", reflect.TypeOf((*MockHostManagerInterface)(nil).IsServiceEnabled), servicePath)
}

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

// IsServiceExist indicates an expected call of IsServiceExist.
func (mr *MockHostManagerInterfaceMockRecorder) IsServiceExist(servicePath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsServiceExist", reflect.TypeOf((*MockHostManagerInterface)(nil).IsServiceExist), servicePath)
}

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

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

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

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

// LoadKernelModule mocks base method.
func (m *MockHostManagerInterface) LoadKernelModule(name string, args ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LoadKernelModule", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// LoadKernelModule indicates an expected call of LoadKernelModule.
func (mr *MockHostManagerInterfaceMockRecorder) LoadKernelModule(name interface{}, args ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadKernelModule", reflect.TypeOf((*MockHostManagerInterface)(nil).LoadKernelModule), varargs...)
}

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

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

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

// PrepareNMUdevRule indicates an expected call of PrepareNMUdevRule.
func (mr *MockHostManagerInterfaceMockRecorder) PrepareNMUdevRule(supportedVfIds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareNMUdevRule", reflect.TypeOf((*MockHostManagerInterface)(nil).PrepareNMUdevRule), supportedVfIds)
}

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

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

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

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

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

// ReadService indicates an expected call of ReadService.
func (mr *MockHostManagerInterfaceMockRecorder) ReadService(servicePath interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadService", reflect.TypeOf((*MockHostManagerInterface)(nil).ReadService), servicePath)
}

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

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

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

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

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

// RebindVfToDefaultDriver indicates an expected call of RebindVfToDefaultDriver.
func (mr *MockHostManagerInterfaceMockRecorder) RebindVfToDefaultDriver(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebindVfToDefaultDriver", reflect.TypeOf((*MockHostManagerInterface)(nil).RebindVfToDefaultDriver), pciAddr)
}

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

// ReloadDriver indicates an expected call of ReloadDriver.
func (mr *MockHostManagerInterfaceMockRecorder) ReloadDriver(driver interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReloadDriver", reflect.TypeOf((*MockHostManagerInterface)(nil).ReloadDriver), driver)
}

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

// RemoveDisableNMUdevRule indicates an expected call of RemoveDisableNMUdevRule.
func (mr *MockHostManagerInterfaceMockRecorder) RemoveDisableNMUdevRule(pfPciAddress interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveDisableNMUdevRule", reflect.TypeOf((*MockHostManagerInterface)(nil).RemoveDisableNMUdevRule), pfPciAddress)
}

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

// RemovePersistPFNameUdevRule indicates an expected call of RemovePersistPFNameUdevRule.
func (mr *MockHostManagerInterfaceMockRecorder) RemovePersistPFNameUdevRule(pfPciAddress interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePersistPFNameUdevRule", reflect.TypeOf((*MockHostManagerInterface)(nil).RemovePersistPFNameUdevRule), pfPciAddress)
}

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

// RemoveVfRepresentorUdevRule indicates an expected call of RemoveVfRepresentorUdevRule.
func (mr *MockHostManagerInterfaceMockRecorder) RemoveVfRepresentorUdevRule(pfPciAddress interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveVfRepresentorUdevRule", reflect.TypeOf((*MockHostManagerInterface)(nil).RemoveVfRepresentorUdevRule), pfPciAddress)
}

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

// ResetSriovDevice indicates an expected call of ResetSriovDevice.
func (mr *MockHostManagerInterfaceMockRecorder) ResetSriovDevice(ifaceStatus interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSriovDevice", reflect.TypeOf((*MockHostManagerInterface)(nil).ResetSriovDevice), ifaceStatus)
}

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

// SetDevlinkDeviceParam indicates an expected call of SetDevlinkDeviceParam.
func (mr *MockHostManagerInterfaceMockRecorder) SetDevlinkDeviceParam(pciAddr, paramName, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDevlinkDeviceParam", reflect.TypeOf((*MockHostManagerInterface)(nil).SetDevlinkDeviceParam), pciAddr, paramName, value)
}

// SetNetdevMTU mocks base method.
func (m *MockHostManagerInterface) SetNetdevMTU(pciAddr string, mtu int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNetdevMTU", pciAddr, mtu)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetNetdevMTU indicates an expected call of SetNetdevMTU.
func (mr *MockHostManagerInterfaceMockRecorder) SetNetdevMTU(pciAddr, mtu interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNetdevMTU", reflect.TypeOf((*MockHostManagerInterface)(nil).SetNetdevMTU), pciAddr, mtu)
}

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

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

// SetSriovNumVfs mocks base method.
func (m *MockHostManagerInterface) SetSriovNumVfs(pciAddr string, numVfs int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSriovNumVfs", pciAddr, numVfs)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetSriovNumVfs indicates an expected call of SetSriovNumVfs.
func (mr *MockHostManagerInterfaceMockRecorder) SetSriovNumVfs(pciAddr, numVfs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSriovNumVfs", reflect.TypeOf((*MockHostManagerInterface)(nil).SetSriovNumVfs), pciAddr, numVfs)
}

// SetVfAdminMac mocks base method.
func (m *MockHostManagerInterface) SetVfAdminMac(vfAddr string, pfLink, vfLink netlink.Link) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVfAdminMac", vfAddr, pfLink, vfLink)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetVfAdminMac indicates an expected call of SetVfAdminMac.
func (mr *MockHostManagerInterfaceMockRecorder) SetVfAdminMac(vfAddr, pfLink, vfLink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVfAdminMac", reflect.TypeOf((*MockHostManagerInterface)(nil).SetVfAdminMac), vfAddr, pfLink, vfLink)
}

// SetVfGUID mocks base method.
func (m *MockHostManagerInterface) SetVfGUID(vfAddr string, pfLink netlink.Link) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVfGUID", vfAddr, pfLink)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetVfGUID indicates an expected call of SetVfGUID.
func (mr *MockHostManagerInterfaceMockRecorder) SetVfGUID(vfAddr, pfLink interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVfGUID", reflect.TypeOf((*MockHostManagerInterface)(nil).SetVfGUID), vfAddr, pfLink)
}

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

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

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

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

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

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

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

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

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

// TryGetInterfaceName indicates an expected call of TryGetInterfaceName.
func (mr *MockHostManagerInterfaceMockRecorder) TryGetInterfaceName(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryGetInterfaceName", reflect.TypeOf((*MockHostManagerInterface)(nil).TryGetInterfaceName), pciAddr)
}

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

// TryToGetVirtualInterfaceName indicates an expected call of TryToGetVirtualInterfaceName.
func (mr *MockHostManagerInterfaceMockRecorder) TryToGetVirtualInterfaceName(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryToGetVirtualInterfaceName", reflect.TypeOf((*MockHostManagerInterface)(nil).TryToGetVirtualInterfaceName), pciAddr)
}

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

// Unbind indicates an expected call of Unbind.
func (mr *MockHostManagerInterfaceMockRecorder) Unbind(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unbind", reflect.TypeOf((*MockHostManagerInterface)(nil).Unbind), pciAddr)
}

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

// UnbindDriverByBusAndDevice indicates an expected call of UnbindDriverByBusAndDevice.
func (mr *MockHostManagerInterfaceMockRecorder) UnbindDriverByBusAndDevice(bus, device interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnbindDriverByBusAndDevice", reflect.TypeOf((*MockHostManagerInterface)(nil).UnbindDriverByBusAndDevice), bus, device)
}

// UnbindDriverIfNeeded mocks base method.
func (m *MockHostManagerInterface) UnbindDriverIfNeeded(pciAddr string, isRdma bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnbindDriverIfNeeded", pciAddr, isRdma)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnbindDriverIfNeeded indicates an expected call of UnbindDriverIfNeeded.
func (mr *MockHostManagerInterfaceMockRecorder) UnbindDriverIfNeeded(pciAddr, isRdma interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnbindDriverIfNeeded", reflect.TypeOf((*MockHostManagerInterface)(nil).UnbindDriverIfNeeded), pciAddr, isRdma)
}

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

// UpdateSystemService indicates an expected call of UpdateSystemService.
func (mr *MockHostManagerInterfaceMockRecorder) UpdateSystemService(serviceObj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSystemService", reflect.TypeOf((*MockHostManagerInterface)(nil).UpdateSystemService), serviceObj)
}

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

// VFIsReady indicates an expected call of VFIsReady.
func (mr *MockHostManagerInterfaceMockRecorder) VFIsReady(pciAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VFIsReady", reflect.TypeOf((*MockHostManagerInterface)(nil).VFIsReady), pciAddr)
}