10179580977

Committed 31 Jul 2024 11:45AM UTC coverage: 43.816% (-0.2%) from 43.968%

Build # 10179580977

Build Type

Pull #733

github

Committed by

web-flow

Commit Message

Merge d80add92c into 57e1e9056

Pull Request Pull Request #733: feat: implement MlxResetFW to reset the FW on VF changes

Run Details

1 of 63 new or added lines in 6 files covered. (1.59%)

6 existing lines in 2 files now uncovered.

6536 of 14917 relevant lines covered (43.82%)

0.48 hits per line

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

21.79

/pkg/helper/mock/mock_helper.go

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

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

import (
        reflect "reflect"

        gomock "github.com/golang/mock/gomock"
        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"
        mlxutils "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vendors/mellanox"
        netlink "github.com/vishvananda/netlink"
)

// MockHostHelpersInterface is a mock of HostHelpersInterface interface.
type MockHostHelpersInterface struct {
        ctrl     *gomock.Controller
        recorder *MockHostHelpersInterfaceMockRecorder
}

// MockHostHelpersInterfaceMockRecorder is the mock recorder for MockHostHelpersInterface.
type MockHostHelpersInterfaceMockRecorder struct {
        mock *MockHostHelpersInterface
}

// NewMockHostHelpersInterface creates a new mock instance.
func NewMockHostHelpersInterface(ctrl *gomock.Controller) *MockHostHelpersInterface {
        mock := &MockHostHelpersInterface{ctrl: ctrl}
        mock.recorder = &MockHostHelpersInterfaceMockRecorder{mock}
        return mock
}

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

// AddDisableNMUdevRule mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) AddDisableNMUdevRule(pfPciAddress interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDisableNMUdevRule", reflect.TypeOf((*MockHostHelpersInterface)(nil).AddDisableNMUdevRule), pfPciAddress)
}

// AddPersistPFNameUdevRule mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) AddPersistPFNameUdevRule(pfPciAddress, pfName interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPersistPFNameUdevRule", reflect.TypeOf((*MockHostHelpersInterface)(nil).AddPersistPFNameUdevRule), pfPciAddress, pfName)
}

// AddVfRepresentorUdevRule mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) AddVfRepresentorUdevRule(pfPciAddress, pfName, pfSwitchID, pfSwitchPort interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddVfRepresentorUdevRule", reflect.TypeOf((*MockHostHelpersInterface)(nil).AddVfRepresentorUdevRule), pfPciAddress, pfName, pfSwitchID, pfSwitchPort)
}

// BindDefaultDriver mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) BindDefaultDriver(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindDefaultDriver", reflect.TypeOf((*MockHostHelpersInterface)(nil).BindDefaultDriver), pciAddr)
}

// BindDpdkDriver mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) BindDpdkDriver(pciAddr, driver interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindDpdkDriver", reflect.TypeOf((*MockHostHelpersInterface)(nil).BindDpdkDriver), pciAddr, driver)
}

// BindDriverByBusAndDevice mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) BindDriverByBusAndDevice(bus, device, driver interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindDriverByBusAndDevice", reflect.TypeOf((*MockHostHelpersInterface)(nil).BindDriverByBusAndDevice), bus, device, driver)
}

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

// Chroot indicates an expected call of Chroot.
func (mr *MockHostHelpersInterfaceMockRecorder) Chroot(arg0 interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chroot", reflect.TypeOf((*MockHostHelpersInterface)(nil).Chroot), arg0)
}

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

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

// CompareServices mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) CompareServices(serviceA, serviceB interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompareServices", reflect.TypeOf((*MockHostHelpersInterface)(nil).CompareServices), serviceA, serviceB)
}

// ConfigSriovDeviceVirtual mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) ConfigSriovDeviceVirtual(iface interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSriovDeviceVirtual", reflect.TypeOf((*MockHostHelpersInterface)(nil).ConfigSriovDeviceVirtual), iface)
}

// ConfigSriovInterfaces mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) ConfigSriovInterfaces(storeManager, interfaces, ifaceStatuses, skipVFConfiguration interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSriovInterfaces", reflect.TypeOf((*MockHostHelpersInterface)(nil).ConfigSriovInterfaces), storeManager, interfaces, ifaceStatuses, skipVFConfiguration)
}

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

// ConfigureVfGUID indicates an expected call of ConfigureVfGUID.
func (mr *MockHostHelpersInterfaceMockRecorder) ConfigureVfGUID(vfAddr, pfAddr, vfID, pfLink interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureVfGUID", reflect.TypeOf((*MockHostHelpersInterface)(nil).ConfigureVfGUID), vfAddr, pfAddr, vfID, pfLink)
}

// CreateVDPADevice mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) CreateVDPADevice(pciAddr, vdpaType interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVDPADevice", reflect.TypeOf((*MockHostHelpersInterface)(nil).CreateVDPADevice), pciAddr, vdpaType)
}

// DeleteVDPADevice mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) DeleteVDPADevice(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVDPADevice", reflect.TypeOf((*MockHostHelpersInterface)(nil).DeleteVDPADevice), pciAddr)
}

// DiscoverSriovDevices mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) DiscoverSriovDevices(storeManager interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverSriovDevices", reflect.TypeOf((*MockHostHelpersInterface)(nil).DiscoverSriovDevices), storeManager)
}

// DiscoverVDPAType mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) DiscoverVDPAType(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverVDPAType", reflect.TypeOf((*MockHostHelpersInterface)(nil).DiscoverVDPAType), pciAddr)
}

// EnableHwTcOffload mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) EnableHwTcOffload(ifaceName interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHwTcOffload", reflect.TypeOf((*MockHostHelpersInterface)(nil).EnableHwTcOffload), ifaceName)
}

// EnableRDMA mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) EnableRDMA(conditionFilePath, serviceName, packageManager interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRDMA", reflect.TypeOf((*MockHostHelpersInterface)(nil).EnableRDMA), conditionFilePath, serviceName, packageManager)
}

// EnableRDMAOnRHELMachine mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) EnableRDMAOnRHELMachine() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRDMAOnRHELMachine", reflect.TypeOf((*MockHostHelpersInterface)(nil).EnableRDMAOnRHELMachine))
}

// EnableService mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) EnableService(service interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableService", reflect.TypeOf((*MockHostHelpersInterface)(nil).EnableService), service)
}

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

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

// GetCurrentKernelArgs mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetCurrentKernelArgs() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentKernelArgs", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetCurrentKernelArgs))
}

// GetDevlinkDeviceParam mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetDevlinkDeviceParam(pciAddr, paramName interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDevlinkDeviceParam", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetDevlinkDeviceParam), pciAddr, paramName)
}

// GetDriverByBusAndDevice mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetDriverByBusAndDevice(bus, device interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDriverByBusAndDevice", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetDriverByBusAndDevice), bus, device)
}

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

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

// GetLinkType mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetLinkType(name interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLinkType", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetLinkType), name)
}

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

// GetMellanoxBlueFieldMode indicates an expected call of GetMellanoxBlueFieldMode.
func (mr *MockHostHelpersInterfaceMockRecorder) GetMellanoxBlueFieldMode(arg0 interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMellanoxBlueFieldMode", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetMellanoxBlueFieldMode), arg0)
}

// GetMlxNicFwData mocks base method.
func (m *MockHostHelpersInterface) GetMlxNicFwData(pciAddress string) (*mlxutils.MlxNic, *mlxutils.MlxNic, error) {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "GetMlxNicFwData", pciAddress)
        ret0, _ := ret[0].(*mlxutils.MlxNic)
        ret1, _ := ret[1].(*mlxutils.MlxNic)
        ret2, _ := ret[2].(error)
        return ret0, ret1, ret2
}

// GetMlxNicFwData indicates an expected call of GetMlxNicFwData.
func (mr *MockHostHelpersInterfaceMockRecorder) GetMlxNicFwData(pciAddress interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMlxNicFwData", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetMlxNicFwData), pciAddress)
}

// GetNetDevLinkAdminState mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetNetDevLinkAdminState(ifaceName interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetDevLinkAdminState", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetNetDevLinkAdminState), ifaceName)
}

// GetNetDevLinkSpeed mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetNetDevLinkSpeed(name interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetDevLinkSpeed", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetNetDevLinkSpeed), name)
}

// GetNetDevMac mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetNetDevMac(name interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetDevMac", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetNetDevMac), name)
}

// GetNetDevNodeGUID mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetNetDevNodeGUID(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetDevNodeGUID", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetNetDevNodeGUID), pciAddr)
}

// GetNetdevMTU mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetNetdevMTU(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetdevMTU", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetNetdevMTU), pciAddr)
}

// GetNicSriovMode mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetNicSriovMode(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNicSriovMode", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetNicSriovMode), pciAddr)
}

// GetOSPrettyName mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetOSPrettyName() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOSPrettyName", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetOSPrettyName))
}

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

// GetPciAddressFromInterfaceName indicates an expected call of GetPciAddressFromInterfaceName.
func (mr *MockHostHelpersInterfaceMockRecorder) GetPciAddressFromInterfaceName(interfaceName interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPciAddressFromInterfaceName", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetPciAddressFromInterfaceName), interfaceName)
}

// GetPhysPortName mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetPhysPortName(name interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPhysPortName", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetPhysPortName), name)
}

// GetPhysSwitchID mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) GetPhysSwitchID(name interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPhysSwitchID", reflect.TypeOf((*MockHostHelpersInterface)(nil).GetPhysSwitchID), name)
}

// HasDriver mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) HasDriver(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasDriver", reflect.TypeOf((*MockHostHelpersInterface)(nil).HasDriver), pciAddr)
}

// InstallRDMA mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) InstallRDMA(packageManager interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallRDMA", reflect.TypeOf((*MockHostHelpersInterface)(nil).InstallRDMA), packageManager)
}

// IsCoreOS mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) IsCoreOS() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCoreOS", reflect.TypeOf((*MockHostHelpersInterface)(nil).IsCoreOS))
}

// IsKernelArgsSet mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) IsKernelArgsSet(cmdLine, karg interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsKernelArgsSet", reflect.TypeOf((*MockHostHelpersInterface)(nil).IsKernelArgsSet), cmdLine, karg)
}

// IsKernelLockdownMode mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) IsKernelLockdownMode() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsKernelLockdownMode", reflect.TypeOf((*MockHostHelpersInterface)(nil).IsKernelLockdownMode))
}

// IsKernelModuleLoaded mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) IsKernelModuleLoaded(name interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsKernelModuleLoaded", reflect.TypeOf((*MockHostHelpersInterface)(nil).IsKernelModuleLoaded), name)
}

// IsRHELSystem mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) IsRHELSystem() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsRHELSystem", reflect.TypeOf((*MockHostHelpersInterface)(nil).IsRHELSystem))
}

// IsServiceEnabled mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) IsServiceEnabled(servicePath interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsServiceEnabled", reflect.TypeOf((*MockHostHelpersInterface)(nil).IsServiceEnabled), servicePath)
}

// IsServiceExist mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) IsServiceExist(servicePath interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsServiceExist", reflect.TypeOf((*MockHostHelpersInterface)(nil).IsServiceExist), servicePath)
}

// IsSwitchdev mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) IsSwitchdev(name interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSwitchdev", reflect.TypeOf((*MockHostHelpersInterface)(nil).IsSwitchdev), name)
}

// IsUbuntuSystem mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) IsUbuntuSystem() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUbuntuSystem", reflect.TypeOf((*MockHostHelpersInterface)(nil).IsUbuntuSystem))
}

// LoadKernelModule mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) 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((*MockHostHelpersInterface)(nil).LoadKernelModule), varargs...)
}

// LoadPfsStatus mocks base method.
func (m *MockHostHelpersInterface) LoadPfsStatus(pciAddress string) (*v1.Interface, bool, error) {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "LoadPfsStatus", pciAddress)
        ret0, _ := ret[0].(*v1.Interface)
        ret1, _ := ret[1].(bool)
        ret2, _ := ret[2].(error)
        return ret0, ret1, ret2
}

// LoadPfsStatus indicates an expected call of LoadPfsStatus.
func (mr *MockHostHelpersInterfaceMockRecorder) LoadPfsStatus(pciAddress interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadPfsStatus", reflect.TypeOf((*MockHostHelpersInterface)(nil).LoadPfsStatus), pciAddress)
}

// LoadUdevRules mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) LoadUdevRules() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadUdevRules", reflect.TypeOf((*MockHostHelpersInterface)(nil).LoadUdevRules))
}

// MlxConfigFW mocks base method.
func (m *MockHostHelpersInterface) MlxConfigFW(attributesToChange map[string]mlxutils.MlxNic) error {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "MlxConfigFW", attributesToChange)
        ret0, _ := ret[0].(error)
        return ret0
}

// MlxConfigFW indicates an expected call of MlxConfigFW.
func (mr *MockHostHelpersInterfaceMockRecorder) MlxConfigFW(attributesToChange interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MlxConfigFW", reflect.TypeOf((*MockHostHelpersInterface)(nil).MlxConfigFW), attributesToChange)
}

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

// MlxResetFW indicates an expected call of MlxResetFW.
func (mr *MockHostHelpersInterfaceMockRecorder) MlxResetFW(pciAddresses interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MlxResetFW", reflect.TypeOf((*MockHostHelpersInterface)(nil).MlxResetFW), pciAddresses)
}

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

// MstConfigReadData indicates an expected call of MstConfigReadData.
func (mr *MockHostHelpersInterfaceMockRecorder) MstConfigReadData(arg0 interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MstConfigReadData", reflect.TypeOf((*MockHostHelpersInterface)(nil).MstConfigReadData), arg0)
}

// PrepareNMUdevRule mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) PrepareNMUdevRule(supportedVfIds interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareNMUdevRule", reflect.TypeOf((*MockHostHelpersInterface)(nil).PrepareNMUdevRule), supportedVfIds)
}

// PrepareVFRepUdevRule mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) PrepareVFRepUdevRule() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareVFRepUdevRule", reflect.TypeOf((*MockHostHelpersInterface)(nil).PrepareVFRepUdevRule))
}

// RdmaIsLoaded mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) RdmaIsLoaded() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RdmaIsLoaded", reflect.TypeOf((*MockHostHelpersInterface)(nil).RdmaIsLoaded))
}

// ReadService mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) ReadService(servicePath interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadService", reflect.TypeOf((*MockHostHelpersInterface)(nil).ReadService), servicePath)
}

// ReadServiceInjectionManifestFile mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) ReadServiceInjectionManifestFile(path interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadServiceInjectionManifestFile", reflect.TypeOf((*MockHostHelpersInterface)(nil).ReadServiceInjectionManifestFile), path)
}

// ReadServiceManifestFile mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) ReadServiceManifestFile(path interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadServiceManifestFile", reflect.TypeOf((*MockHostHelpersInterface)(nil).ReadServiceManifestFile), path)
}

// RebindVfToDefaultDriver mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) RebindVfToDefaultDriver(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebindVfToDefaultDriver", reflect.TypeOf((*MockHostHelpersInterface)(nil).RebindVfToDefaultDriver), pciAddr)
}

// ReloadDriver mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) ReloadDriver(driver interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReloadDriver", reflect.TypeOf((*MockHostHelpersInterface)(nil).ReloadDriver), driver)
}

// RemoveDisableNMUdevRule mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) RemoveDisableNMUdevRule(pfPciAddress interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveDisableNMUdevRule", reflect.TypeOf((*MockHostHelpersInterface)(nil).RemoveDisableNMUdevRule), pfPciAddress)
}

// RemovePersistPFNameUdevRule mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) RemovePersistPFNameUdevRule(pfPciAddress interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePersistPFNameUdevRule", reflect.TypeOf((*MockHostHelpersInterface)(nil).RemovePersistPFNameUdevRule), pfPciAddress)
}

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

// RemovePfAppliedStatus indicates an expected call of RemovePfAppliedStatus.
func (mr *MockHostHelpersInterfaceMockRecorder) RemovePfAppliedStatus(pciAddress interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePfAppliedStatus", reflect.TypeOf((*MockHostHelpersInterface)(nil).RemovePfAppliedStatus), pciAddress)
}

// RemoveVfRepresentorUdevRule mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) RemoveVfRepresentorUdevRule(pfPciAddress interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveVfRepresentorUdevRule", reflect.TypeOf((*MockHostHelpersInterface)(nil).RemoveVfRepresentorUdevRule), pfPciAddress)
}

// ResetSriovDevice mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) ResetSriovDevice(ifaceStatus interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSriovDevice", reflect.TypeOf((*MockHostHelpersInterface)(nil).ResetSriovDevice), ifaceStatus)
}

// RunCommand mocks base method.
func (m *MockHostHelpersInterface) RunCommand(arg0 string, arg1 ...string) (string, string, error) {
        m.ctrl.T.Helper()
        varargs := []interface{}{arg0}
        for _, a := range arg1 {
                varargs = append(varargs, a)
        }
        ret := m.ctrl.Call(m, "RunCommand", varargs...)
        ret0, _ := ret[0].(string)
        ret1, _ := ret[1].(string)
        ret2, _ := ret[2].(error)
        return ret0, ret1, ret2
}

// RunCommand indicates an expected call of RunCommand.
func (mr *MockHostHelpersInterfaceMockRecorder) RunCommand(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        varargs := append([]interface{}{arg0}, arg1...)
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunCommand", reflect.TypeOf((*MockHostHelpersInterface)(nil).RunCommand), varargs...)
}

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

// SaveLastPfAppliedStatus indicates an expected call of SaveLastPfAppliedStatus.
func (mr *MockHostHelpersInterfaceMockRecorder) SaveLastPfAppliedStatus(PfInfo interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveLastPfAppliedStatus", reflect.TypeOf((*MockHostHelpersInterface)(nil).SaveLastPfAppliedStatus), PfInfo)
}

// SetDevlinkDeviceParam mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) SetDevlinkDeviceParam(pciAddr, paramName, value interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDevlinkDeviceParam", reflect.TypeOf((*MockHostHelpersInterface)(nil).SetDevlinkDeviceParam), pciAddr, paramName, value)
}

// SetNetdevMTU mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) SetNetdevMTU(pciAddr, mtu interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNetdevMTU", reflect.TypeOf((*MockHostHelpersInterface)(nil).SetNetdevMTU), pciAddr, mtu)
}

// SetNicSriovMode mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) SetNicSriovMode(pciAddr, mode interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNicSriovMode", reflect.TypeOf((*MockHostHelpersInterface)(nil).SetNicSriovMode), pciAddr, mode)
}

// SetSriovNumVfs mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) SetSriovNumVfs(pciAddr, numVfs interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSriovNumVfs", reflect.TypeOf((*MockHostHelpersInterface)(nil).SetSriovNumVfs), pciAddr, numVfs)
}

// SetVfAdminMac mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) SetVfAdminMac(vfAddr, pfLink, vfLink interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVfAdminMac", reflect.TypeOf((*MockHostHelpersInterface)(nil).SetVfAdminMac), vfAddr, pfLink, vfLink)
}

// TriggerUdevEvent mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) TriggerUdevEvent() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TriggerUdevEvent", reflect.TypeOf((*MockHostHelpersInterface)(nil).TriggerUdevEvent))
}

// TryEnableRdma mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) TryEnableRdma() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryEnableRdma", reflect.TypeOf((*MockHostHelpersInterface)(nil).TryEnableRdma))
}

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

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

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

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

// TryGetInterfaceName mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) TryGetInterfaceName(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryGetInterfaceName", reflect.TypeOf((*MockHostHelpersInterface)(nil).TryGetInterfaceName), pciAddr)
}

// TryToGetVirtualInterfaceName mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) TryToGetVirtualInterfaceName(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryToGetVirtualInterfaceName", reflect.TypeOf((*MockHostHelpersInterface)(nil).TryToGetVirtualInterfaceName), pciAddr)
}

// Unbind mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) Unbind(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unbind", reflect.TypeOf((*MockHostHelpersInterface)(nil).Unbind), pciAddr)
}

// UnbindDriverByBusAndDevice mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) UnbindDriverByBusAndDevice(bus, device interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnbindDriverByBusAndDevice", reflect.TypeOf((*MockHostHelpersInterface)(nil).UnbindDriverByBusAndDevice), bus, device)
}

// UnbindDriverIfNeeded mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) UnbindDriverIfNeeded(pciAddr, isRdma interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnbindDriverIfNeeded", reflect.TypeOf((*MockHostHelpersInterface)(nil).UnbindDriverIfNeeded), pciAddr, isRdma)
}

// UpdateSystemService mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) UpdateSystemService(serviceObj interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSystemService", reflect.TypeOf((*MockHostHelpersInterface)(nil).UpdateSystemService), serviceObj)
}

// VFIsReady mocks base method.
func (m *MockHostHelpersInterface) 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 *MockHostHelpersInterfaceMockRecorder) VFIsReady(pciAddr interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VFIsReady", reflect.TypeOf((*MockHostHelpersInterface)(nil).VFIsReady), pciAddr)
}

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

// WriteCheckpointFile indicates an expected call of WriteCheckpointFile.
func (mr *MockHostHelpersInterfaceMockRecorder) WriteCheckpointFile(arg0 interface{}) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteCheckpointFile", reflect.TypeOf((*MockHostHelpersInterface)(nil).WriteCheckpointFile), arg0)
}

k8snetworkplumbingwg / sriov-network-operator / 10179580977

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