// Copyright 2024 Antrea Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

// Code generated by MockGen. DO NOT EDIT.
// Source: antrea.io/antrea/pkg/agent/util/winnet (interfaces: Interface)
//
// Generated by this command:
//
//	mockgen -copyright_file hack/boilerplate/license_header.raw.txt -destination pkg/agent/util/winnet/testing/mock_net_windows.go -package testing antrea.io/antrea/pkg/agent/util/winnet Interface
//

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

import (
	net "net"
	reflect "reflect"

	winnet "antrea.io/antrea/pkg/agent/util/winnet"
	gomock "go.uber.org/mock/gomock"
)

// MockInterface is a mock of Interface interface.
type MockInterface struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceMockRecorder
	isgomock struct{}
}

// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
	mock *MockInterface
}

// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
	mock := &MockInterface{ctrl: ctrl}
	mock.recorder = &MockInterfaceMockRecorder{mock}
	return mock
}

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

// AddNetAdapterIPAddress mocks base method.
func (m *MockInterface) AddNetAdapterIPAddress(adapterName string, ipConfig *net.IPNet, gateway string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNetAdapterIPAddress", adapterName, ipConfig, gateway)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddNetAdapterIPAddress indicates an expected call of AddNetAdapterIPAddress.
func (mr *MockInterfaceMockRecorder) AddNetAdapterIPAddress(adapterName, ipConfig, gateway any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetAdapterIPAddress", reflect.TypeOf((*MockInterface)(nil).AddNetAdapterIPAddress), adapterName, ipConfig, gateway)
}

// AddNetNat mocks base method.
func (m *MockInterface) AddNetNat(netNatName string, subnetCIDR *net.IPNet) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNetNat", netNatName, subnetCIDR)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddNetNat indicates an expected call of AddNetNat.
func (mr *MockInterfaceMockRecorder) AddNetNat(netNatName, subnetCIDR any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetNat", reflect.TypeOf((*MockInterface)(nil).AddNetNat), netNatName, subnetCIDR)
}

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

// AddNetNatStaticMapping indicates an expected call of AddNetNatStaticMapping.
func (mr *MockInterfaceMockRecorder) AddNetNatStaticMapping(mapping any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetNatStaticMapping", reflect.TypeOf((*MockInterface)(nil).AddNetNatStaticMapping), mapping)
}

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

// AddNetRoute indicates an expected call of AddNetRoute.
func (mr *MockInterfaceMockRecorder) AddNetRoute(route any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetRoute", reflect.TypeOf((*MockInterface)(nil).AddNetRoute), route)
}

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

// AddVMSwitch indicates an expected call of AddVMSwitch.
func (mr *MockInterfaceMockRecorder) AddVMSwitch(adapterName, vmSwitch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddVMSwitch", reflect.TypeOf((*MockInterface)(nil).AddVMSwitch), adapterName, vmSwitch)
}

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

// EnableIPForwarding indicates an expected call of EnableIPForwarding.
func (mr *MockInterfaceMockRecorder) EnableIPForwarding(adapterName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableIPForwarding", reflect.TypeOf((*MockInterface)(nil).EnableIPForwarding), adapterName)
}

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

// EnableNetAdapter indicates an expected call of EnableNetAdapter.
func (mr *MockInterfaceMockRecorder) EnableNetAdapter(adapterName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableNetAdapter", reflect.TypeOf((*MockInterface)(nil).EnableNetAdapter), adapterName)
}

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

// EnableRSCOnVSwitch indicates an expected call of EnableRSCOnVSwitch.
func (mr *MockInterfaceMockRecorder) EnableRSCOnVSwitch(vSwitch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRSCOnVSwitch", reflect.TypeOf((*MockInterface)(nil).EnableRSCOnVSwitch), vSwitch)
}

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

// EnableVMSwitchOVSExtension indicates an expected call of EnableVMSwitchOVSExtension.
func (mr *MockInterfaceMockRecorder) EnableVMSwitchOVSExtension(vmSwitch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVMSwitchOVSExtension", reflect.TypeOf((*MockInterface)(nil).EnableVMSwitchOVSExtension), vmSwitch)
}

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

// GetDNServersByNetAdapterIndex indicates an expected call of GetDNServersByNetAdapterIndex.
func (mr *MockInterfaceMockRecorder) GetDNServersByNetAdapterIndex(adapterIndex any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDNServersByNetAdapterIndex", reflect.TypeOf((*MockInterface)(nil).GetDNServersByNetAdapterIndex), adapterIndex)
}

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

// GetVMSwitchNetAdapterName indicates an expected call of GetVMSwitchNetAdapterName.
func (mr *MockInterfaceMockRecorder) GetVMSwitchNetAdapterName(vmSwitch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVMSwitchNetAdapterName", reflect.TypeOf((*MockInterface)(nil).GetVMSwitchNetAdapterName), vmSwitch)
}

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

// IsNetAdapterIPv4DHCPEnabled indicates an expected call of IsNetAdapterIPv4DHCPEnabled.
func (mr *MockInterfaceMockRecorder) IsNetAdapterIPv4DHCPEnabled(adapterName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNetAdapterIPv4DHCPEnabled", reflect.TypeOf((*MockInterface)(nil).IsNetAdapterIPv4DHCPEnabled), adapterName)
}

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

// IsNetAdapterStatusUp indicates an expected call of IsNetAdapterStatusUp.
func (mr *MockInterfaceMockRecorder) IsNetAdapterStatusUp(adapterName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNetAdapterStatusUp", reflect.TypeOf((*MockInterface)(nil).IsNetAdapterStatusUp), adapterName)
}

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

// IsVMSwitchOVSExtensionEnabled indicates an expected call of IsVMSwitchOVSExtensionEnabled.
func (mr *MockInterfaceMockRecorder) IsVMSwitchOVSExtensionEnabled(vmSwitch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsVMSwitchOVSExtensionEnabled", reflect.TypeOf((*MockInterface)(nil).IsVMSwitchOVSExtensionEnabled), vmSwitch)
}

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

// IsVirtualNetAdapter indicates an expected call of IsVirtualNetAdapter.
func (mr *MockInterfaceMockRecorder) IsVirtualNetAdapter(adapterName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsVirtualNetAdapter", reflect.TypeOf((*MockInterface)(nil).IsVirtualNetAdapter), adapterName)
}

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

// NetAdapterExists indicates an expected call of NetAdapterExists.
func (mr *MockInterfaceMockRecorder) NetAdapterExists(adapterName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetAdapterExists", reflect.TypeOf((*MockInterface)(nil).NetAdapterExists), adapterName)
}

// RemoveNetAdapterIPAddress mocks base method.
func (m *MockInterface) RemoveNetAdapterIPAddress(adapterName string, ipAddr net.IP) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveNetAdapterIPAddress", adapterName, ipAddr)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveNetAdapterIPAddress indicates an expected call of RemoveNetAdapterIPAddress.
func (mr *MockInterfaceMockRecorder) RemoveNetAdapterIPAddress(adapterName, ipAddr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveNetAdapterIPAddress", reflect.TypeOf((*MockInterface)(nil).RemoveNetAdapterIPAddress), adapterName, ipAddr)
}

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

// RemoveNetNatStaticMapping indicates an expected call of RemoveNetNatStaticMapping.
func (mr *MockInterfaceMockRecorder) RemoveNetNatStaticMapping(mapping any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveNetNatStaticMapping", reflect.TypeOf((*MockInterface)(nil).RemoveNetNatStaticMapping), mapping)
}

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

// RemoveNetNatStaticMappingsByNetNat indicates an expected call of RemoveNetNatStaticMappingsByNetNat.
func (mr *MockInterfaceMockRecorder) RemoveNetNatStaticMappingsByNetNat(netNatName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveNetNatStaticMappingsByNetNat", reflect.TypeOf((*MockInterface)(nil).RemoveNetNatStaticMappingsByNetNat), netNatName)
}

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

// RemoveNetRoute indicates an expected call of RemoveNetRoute.
func (mr *MockInterfaceMockRecorder) RemoveNetRoute(route any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveNetRoute", reflect.TypeOf((*MockInterface)(nil).RemoveNetRoute), route)
}

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

// RemoveVMSwitch indicates an expected call of RemoveVMSwitch.
func (mr *MockInterfaceMockRecorder) RemoveVMSwitch(vmSwitch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveVMSwitch", reflect.TypeOf((*MockInterface)(nil).RemoveVMSwitch), vmSwitch)
}

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

// RenameNetAdapter indicates an expected call of RenameNetAdapter.
func (mr *MockInterfaceMockRecorder) RenameNetAdapter(oriName, newName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNetAdapter", reflect.TypeOf((*MockInterface)(nil).RenameNetAdapter), oriName, newName)
}

// RenameVMNetworkAdapter mocks base method.
func (m *MockInterface) RenameVMNetworkAdapter(networkName, macStr, newName string, renameNetAdapter bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenameVMNetworkAdapter", networkName, macStr, newName, renameNetAdapter)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenameVMNetworkAdapter indicates an expected call of RenameVMNetworkAdapter.
func (mr *MockInterfaceMockRecorder) RenameVMNetworkAdapter(networkName, macStr, newName, renameNetAdapter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameVMNetworkAdapter", reflect.TypeOf((*MockInterface)(nil).RenameVMNetworkAdapter), networkName, macStr, newName, renameNetAdapter)
}

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

// ReplaceNetNatStaticMapping indicates an expected call of ReplaceNetNatStaticMapping.
func (mr *MockInterfaceMockRecorder) ReplaceNetNatStaticMapping(mapping any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetNatStaticMapping", reflect.TypeOf((*MockInterface)(nil).ReplaceNetNatStaticMapping), mapping)
}

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

// ReplaceNetNeighbor indicates an expected call of ReplaceNetNeighbor.
func (mr *MockInterfaceMockRecorder) ReplaceNetNeighbor(neighbor any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetNeighbor", reflect.TypeOf((*MockInterface)(nil).ReplaceNetNeighbor), neighbor)
}

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

// ReplaceNetRoute indicates an expected call of ReplaceNetRoute.
func (mr *MockInterfaceMockRecorder) ReplaceNetRoute(route any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetRoute", reflect.TypeOf((*MockInterface)(nil).ReplaceNetRoute), route)
}

// RouteListFiltered mocks base method.
func (m *MockInterface) RouteListFiltered(family uint16, filter *winnet.Route, filterMask uint64) ([]winnet.Route, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RouteListFiltered", family, filter, filterMask)
	ret0, _ := ret[0].([]winnet.Route)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RouteListFiltered indicates an expected call of RouteListFiltered.
func (mr *MockInterfaceMockRecorder) RouteListFiltered(family, filter, filterMask any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RouteListFiltered", reflect.TypeOf((*MockInterface)(nil).RouteListFiltered), family, filter, filterMask)
}

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

// SetNetAdapterDNSServers indicates an expected call of SetNetAdapterDNSServers.
func (mr *MockInterfaceMockRecorder) SetNetAdapterDNSServers(adapterName, dnsServers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNetAdapterDNSServers", reflect.TypeOf((*MockInterface)(nil).SetNetAdapterDNSServers), adapterName, dnsServers)
}

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

// SetNetAdapterMTU indicates an expected call of SetNetAdapterMTU.
func (mr *MockInterfaceMockRecorder) SetNetAdapterMTU(adapterName, mtu any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNetAdapterMTU", reflect.TypeOf((*MockInterface)(nil).SetNetAdapterMTU), adapterName, mtu)
}

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

// VMSwitchExists indicates an expected call of VMSwitchExists.
func (mr *MockInterfaceMockRecorder) VMSwitchExists(vmSwitch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VMSwitchExists", reflect.TypeOf((*MockInterface)(nil).VMSwitchExists), vmSwitch)
}
