9206688050

Committed 23 May 2024 10:50AM UTC coverage: 39.655% (+0.06%) from 39.599%

Build # 9206688050

Build Type

Pull #587

github

Committed by

web-flow

Commit Message

Merge 5f3c4e903 into 87e4dadb1

Pull Request Pull Request #587: Add more checks on generic plugin to discover discrepancies from the desired state

Run Details

54 of 127 new or added lines in 7 files covered. (42.52%)

6 existing lines in 2 files now uncovered.

5175 of 13050 relevant lines covered (39.66%)

0.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

30.62

/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)
}

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

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

// 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)
}

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

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

// 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)
}

k8snetworkplumbingwg / sriov-network-operator / 9206688050

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous