func (mock *LinuxNetworkingMock) ipvsAddFWMarkService(svcs []*ipvs.Service, fwMark uint32, protocol uint16, port uint16, persistent bool, persistentTimeout int32, scheduler string, flags schedFlags) (*ipvs.Service, error) {
	if mock.ipvsAddFWMarkServiceFunc == nil {
		panic("LinuxNetworkingMock.ipvsAddFWMarkServiceFunc: method is nil but LinuxNetworking.ipvsAddFWMarkService was just called")
	}
	callInfo := struct {
		Svcs              []*ipvs.Service
		FwMark            uint32
		Protocol          uint16
		Port              uint16
		Persistent        bool
		PersistentTimeout int32
		Scheduler         string
		Flags             schedFlags
	}{
		Svcs:              svcs,
		FwMark:            fwMark,
		Protocol:          protocol,
		Port:              port,
		Persistent:        persistent,
		PersistentTimeout: persistentTimeout,
		Scheduler:         scheduler,
		Flags:             flags,
	}
	mock.lockipvsAddFWMarkService.Lock()
	mock.calls.ipvsAddFWMarkService = append(mock.calls.ipvsAddFWMarkService, callInfo)
	mock.lockipvsAddFWMarkService.Unlock()
	return mock.ipvsAddFWMarkServiceFunc(svcs, fwMark, protocol, port, persistent, persistentTimeout, scheduler, flags)
}
ipvsAddFWMarkService calls ipvsAddFWMarkServiceFunc.
package proxy
import (
	"github.com/moby/ipvs"
	"github.com/vishvananda/netlink"
	"github.com/vishvananda/netns"
	"net"
	"sync"
)
var _ LinuxNetworking = &LinuxNetworkingMock{}
type LinuxNetworkingMock struct {
	cleanupMangleTableRuleFunc func(ip string, protocol string, port string, fwmark string, tcpMSS int) error
	configureContainerForDSRFunc func(vip string, endpointIP string, containerID string, pid int, hostNetworkNamespaceHandle netns.NsHandle) error
	getKubeDummyInterfaceFunc func() (netlink.Link, error)
	ipAddrAddFunc func(iface netlink.Link, ip string, addRoute bool) error
	ipAddrDelFunc func(iface netlink.Link, ip string) error
	ipvsAddFWMarkServiceFunc func(svcs []*ipvs.Service, fwMark uint32, protocol uint16, port uint16, persistent bool, persistentTimeout int32, scheduler string, flags schedFlags) (*ipvs.Service, error)
	ipvsAddServerFunc func(ipvsSvc *ipvs.Service, ipvsDst *ipvs.Destination) error
	ipvsAddServiceFunc func(svcs []*ipvs.Service, vip net.IP, protocol uint16, port uint16, persistent bool, persistentTimeout int32, scheduler string, flags schedFlags) (*ipvs.Service, error)
	ipvsDelDestinationFunc func(ipvsSvc *ipvs.Service, ipvsDst *ipvs.Destination) error
	ipvsDelServiceFunc func(ipvsSvc *ipvs.Service) error
	ipvsGetDestinationsFunc func(ipvsSvc *ipvs.Service) ([]*ipvs.Destination, error)
	ipvsGetServicesFunc func() ([]*ipvs.Service, error)
	ipvsNewDestinationFunc func(ipvsSvc *ipvs.Service, ipvsDst *ipvs.Destination) error
	ipvsNewServiceFunc func(ipvsSvc *ipvs.Service) error
	ipvsUpdateDestinationFunc func(ipvsSvc *ipvs.Service, ipvsDst *ipvs.Destination) error
	ipvsUpdateServiceFunc func(ipvsSvc *ipvs.Service) error
	prepareEndpointForDsrWithCRIFunc func(runtimeEndpoint string, containerID string, endpointIP string, vip string) error
	prepareEndpointForDsrWithDockerFunc func(containerID string, endpointIP string, vip string) error
	setupPolicyRoutingForDSRFunc func() error
	setupRoutesForExternalIPForDSRFunc func(serviceInfoMapMoqParam serviceInfoMap) error
	calls struct {
		cleanupMangleTableRule []struct {
			IP string
			Protocol string
			Port string
			Fwmark string
			TcpMSS int
		}
		configureContainerForDSR []struct {
			Vip string
			EndpointIP string
			ContainerID string
			Pid int
			HostNetworkNamespaceHandle netns.NsHandle
		}
		getKubeDummyInterface []struct {
		}
		ipAddrAdd []struct {
			Iface netlink.Link
			IP string
			AddRoute bool
		}
		ipAddrDel []struct {
			Iface netlink.Link
			IP string
		}
		ipvsAddFWMarkService []struct {
			Svcs []*ipvs.Service
			FwMark uint32
			Protocol uint16
			Port uint16
			Persistent bool
			PersistentTimeout int32
			Scheduler string
			Flags schedFlags
		}
		ipvsAddServer []struct {
			IpvsSvc *ipvs.Service
			IpvsDst *ipvs.Destination
		}
		ipvsAddService []struct {
			Svcs []*ipvs.Service
			Vip net.IP
			Protocol uint16
			Port uint16
			Persistent bool
			PersistentTimeout int32
			Scheduler string
			Flags schedFlags
		}
		ipvsDelDestination []struct {
			IpvsSvc *ipvs.Service
			IpvsDst *ipvs.Destination
		}
		ipvsDelService []struct {
			IpvsSvc *ipvs.Service
		}
		ipvsGetDestinations []struct {
			IpvsSvc *ipvs.Service
		}
		ipvsGetServices []struct {
		}
		ipvsNewDestination []struct {
			IpvsSvc *ipvs.Service
			IpvsDst *ipvs.Destination
		}
		ipvsNewService []struct {
			IpvsSvc *ipvs.Service
		}
		ipvsUpdateDestination []struct {
			IpvsSvc *ipvs.Service
			IpvsDst *ipvs.Destination
		}
		ipvsUpdateService []struct {
			IpvsSvc *ipvs.Service
		}
		prepareEndpointForDsrWithCRI []struct {
			RuntimeEndpoint string
			ContainerID string
			EndpointIP string
			Vip string
		}
		prepareEndpointForDsrWithDocker []struct {
			ContainerID string
			EndpointIP string
			Vip string
		}
		setupPolicyRoutingForDSR []struct {
		}
		setupRoutesForExternalIPForDSR []struct {
			ServiceInfoMapMoqParam serviceInfoMap
		}
	}
	lockcleanupMangleTableRule          sync.RWMutex
	lockconfigureContainerForDSR        sync.RWMutex
	lockgetKubeDummyInterface           sync.RWMutex
	lockipAddrAdd                       sync.RWMutex
	lockipAddrDel                       sync.RWMutex
	lockipvsAddFWMarkService            sync.RWMutex
	lockipvsAddServer                   sync.RWMutex
	lockipvsAddService                  sync.RWMutex
	lockipvsDelDestination              sync.RWMutex
	lockipvsDelService                  sync.RWMutex
	lockipvsGetDestinations             sync.RWMutex
	lockipvsGetServices                 sync.RWMutex
	lockipvsNewDestination              sync.RWMutex
	lockipvsNewService                  sync.RWMutex
	lockipvsUpdateDestination           sync.RWMutex
	lockipvsUpdateService               sync.RWMutex
	lockprepareEndpointForDsrWithCRI    sync.RWMutex
	lockprepareEndpointForDsrWithDocker sync.RWMutex
	locksetupPolicyRoutingForDSR        sync.RWMutex
	locksetupRoutesForExternalIPForDSR  sync.RWMutex
}
func (mock *LinuxNetworkingMock) cleanupMangleTableRule(ip string, protocol string, port string, fwmark string, tcpMSS int) error {
	if mock.cleanupMangleTableRuleFunc == nil {
		panic("LinuxNetworkingMock.cleanupMangleTableRuleFunc: method is nil but LinuxNetworking.cleanupMangleTableRule was just called")
	}
	callInfo := struct {
		IP       string
		Protocol string
		Port     string
		Fwmark   string
		TcpMSS   int
	}{
		IP:       ip,
		Protocol: protocol,
		Port:     port,
		Fwmark:   fwmark,
		TcpMSS:   tcpMSS,
	}
	mock.lockcleanupMangleTableRule.Lock()
	mock.calls.cleanupMangleTableRule = append(mock.calls.cleanupMangleTableRule, callInfo)
	mock.lockcleanupMangleTableRule.Unlock()
	return mock.cleanupMangleTableRuleFunc(ip, protocol, port, fwmark, tcpMSS)
}
func (mock *LinuxNetworkingMock) cleanupMangleTableRuleCalls() []struct {
	IP       string
	Protocol string
	Port     string
	Fwmark   string
	TcpMSS   int
} {
	var calls []struct {
		IP       string
		Protocol string
		Port     string
		Fwmark   string
		TcpMSS   int
	}
	mock.lockcleanupMangleTableRule.RLock()
	calls = mock.calls.cleanupMangleTableRule
	mock.lockcleanupMangleTableRule.RUnlock()
	return calls
}
func (mock *LinuxNetworkingMock) configureContainerForDSR(vip string, endpointIP string, containerID string, pid int, hostNetworkNamespaceHandle netns.NsHandle) error {
	if mock.configureContainerForDSRFunc == nil {
		panic("LinuxNetworkingMock.configureContainerForDSRFunc: method is nil but LinuxNetworking.configureContainerForDSR was just called")
	}
	callInfo := struct {
		Vip                        string
		EndpointIP                 string
		ContainerID                string
		Pid                        int
		HostNetworkNamespaceHandle netns.NsHandle
	}{
		Vip:                        vip,
		EndpointIP:                 endpointIP,
		ContainerID:                containerID,
		Pid:                        pid,
		HostNetworkNamespaceHandle: hostNetworkNamespaceHandle,
	}
	mock.lockconfigureContainerForDSR.Lock()
	mock.calls.configureContainerForDSR = append(mock.calls.configureContainerForDSR, callInfo)
	mock.lockconfigureContainerForDSR.Unlock()
	return mock.configureContainerForDSRFunc(vip, endpointIP, containerID, pid, hostNetworkNamespaceHandle)
}
func (mock *LinuxNetworkingMock) configureContainerForDSRCalls() []struct {
	Vip                        string
	EndpointIP                 string
	ContainerID                string
	Pid                        int
	HostNetworkNamespaceHandle netns.NsHandle
} {
	var calls []struct {
		Vip                        string
		EndpointIP                 string
		ContainerID                string
		Pid                        int
		HostNetworkNamespaceHandle netns.NsHandle
	}
	mock.lockconfigureContainerForDSR.RLock()
	calls = mock.calls.configureContainerForDSR
	mock.lockconfigureContainerForDSR.RUnlock()
	return calls
}
func (mock *LinuxNetworkingMock) getKubeDummyInterface() (netlink.Link, error) {
	if mock.getKubeDummyInterfaceFunc == nil {
		panic("LinuxNetworkingMock.getKubeDummyInterfaceFunc: method is nil but LinuxNetworking.getKubeDummyInterface was just called")
	}
	callInfo := struct {
	}{}
	mock.lockgetKubeDummyInterface.Lock()
	mock.calls.getKubeDummyInterface = append(mock.calls.getKubeDummyInterface, callInfo)
	mock.lockgetKubeDummyInterface.Unlock()
	return mock.getKubeDummyInterfaceFunc()
}
func (mock *LinuxNetworkingMock) getKubeDummyInterfaceCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockgetKubeDummyInterface.RLock()
	calls = mock.calls.getKubeDummyInterface
	mock.lockgetKubeDummyInterface.RUnlock()
	return calls
}
func (mock *LinuxNetworkingMock) ipAddrAdd(iface netlink.Link, ip string, addRoute bool) error {
	if mock.ipAddrAddFunc == nil {
		panic("LinuxNetworkingMock.ipAddrAddFunc: method is nil but LinuxNetworking.ipAddrAdd was just called")
	}
	callInfo := struct {
		Iface    netlink.Link
		IP       string
		AddRoute bool
	}{
		Iface:    iface,
		IP:       ip,
		AddRoute: addRoute,
	}
	mock.lockipAddrAdd.Lock()
	mock.calls.ipAddrAdd = append(mock.calls.ipAddrAdd, callInfo)
	mock.lockipAddrAdd.Unlock()
	return mock.ipAddrAddFunc(iface, ip, addRoute)
}
func (mock *LinuxNetworkingMock) ipAddrAddCalls() []struct {
	Iface    netlink.Link
	IP       string
	AddRoute bool
} {
	var calls []struct {
		Iface    netlink.Link
		IP       string
		AddRoute bool
	}
	mock.lockipAddrAdd.RLock()
	calls = mock.calls.ipAddrAdd
	mock.lockipAddrAdd.RUnlock()
	return calls
}
func (mock *LinuxNetworkingMock) ipAddrDel(iface netlink.Link, ip string) error {
	if mock.ipAddrDelFunc == nil {
		panic("LinuxNetworkingMock.ipAddrDelFunc: method is nil but LinuxNetworking.ipAddrDel was just called")
	}
	callInfo := struct {
		Iface netlink.Link
		IP    string
	}{
		Iface: iface,
		IP:    ip,
	}
	mock.lockipAddrDel.Lock()
	mock.calls.ipAddrDel = append(mock.calls.ipAddrDel, callInfo)
	mock.lockipAddrDel.Unlock()
	return mock.ipAddrDelFunc(iface, ip)
}
func (mock *LinuxNetworkingMock) ipAddrDelCalls() []struct {
	Iface netlink.Link
	IP    string
} {
	var calls []struct {
		Iface netlink.Link
		IP    string
	}
	mock.lockipAddrDel.RLock()
	calls = mock.calls.ipAddrDel
	mock.lockipAddrDel.RUnlock()
	return calls
}