13677347230

Committed 05 Mar 2025 01:40PM UTC coverage: 48.413% (-0.5%) from 48.917%

Build # 13677347230

Build Type

Pull #853

github

Committed by

web-flow

Commit Message

Merge bbc18ece8 into ab7d36758

Pull Request Pull Request #853: Move systemd to host package

Run Details

142 of 318 new or added lines in 6 files covered. (44.65%)

11 existing lines in 4 files now uncovered.

7352 of 15186 relevant lines covered (48.41%)

0.53 hits per line

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

37.46

/pkg/helper/mock/mock_helper.go

// Code generated by MockGen. DO NOT EDIT.
// Source: host.go
//
// Generated by this command:
//
//        mockgen -destination mock/mock_helper.go -source host.go
//

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

import (
        reflect "reflect"

        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"
        gomock "go.uber.org/mock/gomock"
)

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

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

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

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

// 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 any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chroot", reflect.TypeOf((*MockHostHelpersInterface)(nil).Chroot), arg0)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// LoadKernelModule mocks base method.
func (m *MockHostHelpersInterface) LoadKernelModule(name string, args ...string) error {
        m.ctrl.T.Helper()
        varargs := []any{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 any, args ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        varargs := append([]any{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 any) *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 any) *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 any) *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 any) *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 any) *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))
}

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

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

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

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

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

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

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

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

// 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 any) *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 any) *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 any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePfAppliedStatus", reflect.TypeOf((*MockHostHelpersInterface)(nil).RemovePfAppliedStatus), pciAddress)
}

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

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

// 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 any) *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 any) *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 := []any{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 any, arg1 ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        varargs := append([]any{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 any) *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 any) *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 any) *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 any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNicSriovMode", reflect.TypeOf((*MockHostHelpersInterface)(nil).SetNicSriovMode), pciAddr, mode)
}

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

// SetRDMASubsystem indicates an expected call of SetRDMASubsystem.
func (mr *MockHostHelpersInterfaceMockRecorder) SetRDMASubsystem(mode any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRDMASubsystem", reflect.TypeOf((*MockHostHelpersInterface)(nil).SetRDMASubsystem), 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 any) *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 any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVfAdminMac", reflect.TypeOf((*MockHostHelpersInterface)(nil).SetVfAdminMac), vfAddr, pfLink, vfLink)
}

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

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

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

// 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 any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteCheckpointFile", reflect.TypeOf((*MockHostHelpersInterface)(nil).WriteCheckpointFile), arg0)
}

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

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

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

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

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

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

k8snetworkplumbingwg / sriov-network-operator / 13677347230

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