mock_openflow.go

// Copyright 2022 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/openflow (interfaces: Client,OFEntryOperations)

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

import (
	config "antrea.io/antrea/pkg/agent/config"
	types "antrea.io/antrea/pkg/agent/types"
	v1alpha2 "antrea.io/antrea/pkg/apis/crd/v1alpha2"
	openflow "antrea.io/antrea/pkg/ovs/openflow"
	ip "antrea.io/antrea/pkg/util/ip"
	proxy "antrea.io/antrea/third_party/proxy"
	util "antrea.io/libOpenflow/util"
	gomock "github.com/golang/mock/gomock"
	v1 "k8s.io/api/core/v1"
	net "net"
	reflect "reflect"
)

// MockClient is a mock of Client interface
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

// AddAddressToDNSConjunction mocks base method
func (m *MockClient) AddAddressToDNSConjunction(arg0 uint32, arg1 []types.Address) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAddressToDNSConjunction", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// AddPolicyRuleAddress mocks base method
func (m *MockClient) AddPolicyRuleAddress(arg0 uint32, arg1 types.AddressType, arg2 []types.Address, arg3 *uint16) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPolicyRuleAddress", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddPolicyRuleAddress indicates an expected call of AddPolicyRuleAddress
func (mr *MockClientMockRecorder) AddPolicyRuleAddress(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPolicyRuleAddress", reflect.TypeOf((*MockClient)(nil).AddPolicyRuleAddress), arg0, arg1, arg2, arg3)
}

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

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

// DeleteAddressFromDNSConjunction mocks base method
func (m *MockClient) DeleteAddressFromDNSConjunction(arg0 uint32, arg1 []types.Address) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAddressFromDNSConjunction", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeletePolicyRuleAddress mocks base method
func (m *MockClient) DeletePolicyRuleAddress(arg0 uint32, arg1 types.AddressType, arg2 []types.Address, arg3 *uint16) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePolicyRuleAddress", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePolicyRuleAddress indicates an expected call of DeletePolicyRuleAddress
func (mr *MockClientMockRecorder) DeletePolicyRuleAddress(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyRuleAddress", reflect.TypeOf((*MockClient)(nil).DeletePolicyRuleAddress), arg0, arg1, arg2, arg3)
}

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

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

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

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

// GetFlowTableStatus mocks base method
func (m *MockClient) GetFlowTableStatus() []openflow.TableStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFlowTableStatus")
	ret0, _ := ret[0].([]openflow.TableStatus)
	return ret0
}

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

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

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

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

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

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

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

// GetServiceFlowKeys mocks base method
func (m *MockClient) GetServiceFlowKeys(arg0 net.IP, arg1 uint16, arg2 openflow.Protocol, arg3 []proxy.Endpoint) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceFlowKeys", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetServiceFlowKeys indicates an expected call of GetServiceFlowKeys
func (mr *MockClientMockRecorder) GetServiceFlowKeys(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceFlowKeys", reflect.TypeOf((*MockClient)(nil).GetServiceFlowKeys), arg0, arg1, arg2, arg3)
}

// GetTunnelVirtualMAC mocks base method
func (m *MockClient) GetTunnelVirtualMAC() net.HardwareAddr {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTunnelVirtualMAC")
	ret0, _ := ret[0].(net.HardwareAddr)
	return ret0
}

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

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

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

// Initialize mocks base method
func (m *MockClient) Initialize(arg0 types.RoundInfo, arg1 *config.NodeConfig, arg2 *config.NetworkConfig, arg3 *config.EgressConfig, arg4 *config.ServiceConfig) (<-chan struct{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(<-chan struct{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Initialize indicates an expected call of Initialize
func (mr *MockClientMockRecorder) Initialize(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockClient)(nil).Initialize), arg0, arg1, arg2, arg3, arg4)
}

// InstallEndpointFlows mocks base method
func (m *MockClient) InstallEndpointFlows(arg0 openflow.Protocol, arg1 []proxy.Endpoint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallEndpointFlows", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InstallMulticastFlows mocks base method
func (m *MockClient) InstallMulticastFlows(arg0 net.IP, arg1 openflow.GroupIDType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallMulticastFlows", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InstallMulticastGroup mocks base method
func (m *MockClient) InstallMulticastGroup(arg0 openflow.GroupIDType, arg1 []uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallMulticastGroup", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// InstallMulticlusterClassifierFlows mocks base method
func (m *MockClient) InstallMulticlusterClassifierFlows(arg0 uint32, arg1 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallMulticlusterClassifierFlows", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InstallMulticlusterGatewayFlows mocks base method
func (m *MockClient) InstallMulticlusterGatewayFlows(arg0 string, arg1 map[*net.IPNet]net.IP, arg2, arg3 net.IP) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallMulticlusterGatewayFlows", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallMulticlusterGatewayFlows indicates an expected call of InstallMulticlusterGatewayFlows
func (mr *MockClientMockRecorder) InstallMulticlusterGatewayFlows(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallMulticlusterGatewayFlows", reflect.TypeOf((*MockClient)(nil).InstallMulticlusterGatewayFlows), arg0, arg1, arg2, arg3)
}

// InstallMulticlusterNodeFlows mocks base method
func (m *MockClient) InstallMulticlusterNodeFlows(arg0 string, arg1 map[*net.IPNet]net.IP, arg2 net.IP) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallMulticlusterNodeFlows", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallMulticlusterNodeFlows indicates an expected call of InstallMulticlusterNodeFlows
func (mr *MockClientMockRecorder) InstallMulticlusterNodeFlows(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallMulticlusterNodeFlows", reflect.TypeOf((*MockClient)(nil).InstallMulticlusterNodeFlows), arg0, arg1, arg2)
}

// InstallNodeFlows mocks base method
func (m *MockClient) InstallNodeFlows(arg0 string, arg1 map[*net.IPNet]net.IP, arg2 *ip.DualStackIPs, arg3 uint32, arg4 net.HardwareAddr) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallNodeFlows", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallNodeFlows indicates an expected call of InstallNodeFlows
func (mr *MockClientMockRecorder) InstallNodeFlows(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallNodeFlows", reflect.TypeOf((*MockClient)(nil).InstallNodeFlows), arg0, arg1, arg2, arg3, arg4)
}

// InstallPodFlows mocks base method
func (m *MockClient) InstallPodFlows(arg0 string, arg1 []net.IP, arg2 net.HardwareAddr, arg3 uint32, arg4 uint16) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallPodFlows", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallPodFlows indicates an expected call of InstallPodFlows
func (mr *MockClientMockRecorder) InstallPodFlows(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallPodFlows", reflect.TypeOf((*MockClient)(nil).InstallPodFlows), arg0, arg1, arg2, arg3, arg4)
}

// InstallPodSNATFlows mocks base method
func (m *MockClient) InstallPodSNATFlows(arg0 uint32, arg1 net.IP, arg2 uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallPodSNATFlows", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallPodSNATFlows indicates an expected call of InstallPodSNATFlows
func (mr *MockClientMockRecorder) InstallPodSNATFlows(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallPodSNATFlows", reflect.TypeOf((*MockClient)(nil).InstallPodSNATFlows), arg0, arg1, arg2)
}

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

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

// InstallSNATMarkFlows mocks base method
func (m *MockClient) InstallSNATMarkFlows(arg0 net.IP, arg1 uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallSNATMarkFlows", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// InstallServiceFlows mocks base method
func (m *MockClient) InstallServiceFlows(arg0 openflow.GroupIDType, arg1 net.IP, arg2 uint16, arg3 openflow.Protocol, arg4 uint16, arg5 bool, arg6 v1.ServiceType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallServiceFlows", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallServiceFlows indicates an expected call of InstallServiceFlows
func (mr *MockClientMockRecorder) InstallServiceFlows(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallServiceFlows", reflect.TypeOf((*MockClient)(nil).InstallServiceFlows), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// InstallServiceGroup mocks base method
func (m *MockClient) InstallServiceGroup(arg0 openflow.GroupIDType, arg1 bool, arg2 []proxy.Endpoint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallServiceGroup", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallServiceGroup indicates an expected call of InstallServiceGroup
func (mr *MockClientMockRecorder) InstallServiceGroup(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallServiceGroup", reflect.TypeOf((*MockClient)(nil).InstallServiceGroup), arg0, arg1, arg2)
}

// InstallTraceflowFlows mocks base method
func (m *MockClient) InstallTraceflowFlows(arg0 byte, arg1, arg2, arg3 bool, arg4 *openflow.Packet, arg5 uint32, arg6 uint16) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallTraceflowFlows", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallTraceflowFlows indicates an expected call of InstallTraceflowFlows
func (mr *MockClientMockRecorder) InstallTraceflowFlows(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallTraceflowFlows", reflect.TypeOf((*MockClient)(nil).InstallTraceflowFlows), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// InstallTrafficControlMarkFlows mocks base method
func (m *MockClient) InstallTrafficControlMarkFlows(arg0 string, arg1 []uint32, arg2 uint32, arg3 v1alpha2.Direction, arg4 v1alpha2.TrafficControlAction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallTrafficControlMarkFlows", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallTrafficControlMarkFlows indicates an expected call of InstallTrafficControlMarkFlows
func (mr *MockClientMockRecorder) InstallTrafficControlMarkFlows(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallTrafficControlMarkFlows", reflect.TypeOf((*MockClient)(nil).InstallTrafficControlMarkFlows), arg0, arg1, arg2, arg3, arg4)
}

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

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

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

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

// MulticastEgressPodMetrics mocks base method
func (m *MockClient) MulticastEgressPodMetrics() map[string]*types.RuleMetric {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MulticastEgressPodMetrics")
	ret0, _ := ret[0].(map[string]*types.RuleMetric)
	return ret0
}

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

// MulticastEgressPodMetricsByIP mocks base method
func (m *MockClient) MulticastEgressPodMetricsByIP(arg0 net.IP) *types.RuleMetric {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MulticastEgressPodMetricsByIP", arg0)
	ret0, _ := ret[0].(*types.RuleMetric)
	return ret0
}

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

// MulticastIngressPodMetrics mocks base method
func (m *MockClient) MulticastIngressPodMetrics() map[uint32]*types.RuleMetric {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MulticastIngressPodMetrics")
	ret0, _ := ret[0].(map[uint32]*types.RuleMetric)
	return ret0
}

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

// MulticastIngressPodMetricsByOFPort mocks base method
func (m *MockClient) MulticastIngressPodMetricsByOFPort(arg0 int32) *types.RuleMetric {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MulticastIngressPodMetricsByOFPort", arg0)
	ret0, _ := ret[0].(*types.RuleMetric)
	return ret0
}

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

// NetworkPolicyMetrics mocks base method
func (m *MockClient) NetworkPolicyMetrics() map[uint32]*types.RuleMetric {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetworkPolicyMetrics")
	ret0, _ := ret[0].(map[uint32]*types.RuleMetric)
	return ret0
}

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

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

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

// ReassignFlowPriorities mocks base method
func (m *MockClient) ReassignFlowPriorities(arg0 map[uint16]uint16, arg1 byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReassignFlowPriorities", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// RegisterPacketInHandler mocks base method
func (m *MockClient) RegisterPacketInHandler(arg0 byte, arg1 string, arg2 interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterPacketInHandler", arg0, arg1, arg2)
}

// RegisterPacketInHandler indicates an expected call of RegisterPacketInHandler
func (mr *MockClientMockRecorder) RegisterPacketInHandler(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPacketInHandler", reflect.TypeOf((*MockClient)(nil).RegisterPacketInHandler), arg0, arg1, arg2)
}

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

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

// SendICMPPacketOut mocks base method
func (m *MockClient) SendICMPPacketOut(arg0, arg1, arg2, arg3 string, arg4, arg5 uint32, arg6 bool, arg7, arg8 byte, arg9 []byte, arg10 func(openflow.PacketOutBuilder) openflow.PacketOutBuilder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendICMPPacketOut", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendICMPPacketOut indicates an expected call of SendICMPPacketOut
func (mr *MockClientMockRecorder) SendICMPPacketOut(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendICMPPacketOut", reflect.TypeOf((*MockClient)(nil).SendICMPPacketOut), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
}

// SendIGMPQueryPacketOut mocks base method
func (m *MockClient) SendIGMPQueryPacketOut(arg0 net.HardwareAddr, arg1 net.IP, arg2 uint32, arg3 util.Message) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendIGMPQueryPacketOut", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendIGMPQueryPacketOut indicates an expected call of SendIGMPQueryPacketOut
func (mr *MockClientMockRecorder) SendIGMPQueryPacketOut(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendIGMPQueryPacketOut", reflect.TypeOf((*MockClient)(nil).SendIGMPQueryPacketOut), arg0, arg1, arg2, arg3)
}

// SendTCPPacketOut mocks base method
func (m *MockClient) SendTCPPacketOut(arg0, arg1, arg2, arg3 string, arg4, arg5 uint32, arg6 bool, arg7, arg8 uint16, arg9 uint32, arg10 byte, arg11 func(openflow.PacketOutBuilder) openflow.PacketOutBuilder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendTCPPacketOut", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendTCPPacketOut indicates an expected call of SendTCPPacketOut
func (mr *MockClientMockRecorder) SendTCPPacketOut(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTCPPacketOut", reflect.TypeOf((*MockClient)(nil).SendTCPPacketOut), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
}

// SendTraceflowPacket mocks base method
func (m *MockClient) SendTraceflowPacket(arg0 byte, arg1 *openflow.Packet, arg2 uint32, arg3 int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendTraceflowPacket", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendTraceflowPacket indicates an expected call of SendTraceflowPacket
func (mr *MockClientMockRecorder) SendTraceflowPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTraceflowPacket", reflect.TypeOf((*MockClient)(nil).SendTraceflowPacket), arg0, arg1, arg2, arg3)
}

// SendUDPPacketOut mocks base method
func (m *MockClient) SendUDPPacketOut(arg0, arg1, arg2, arg3 string, arg4, arg5 uint32, arg6 bool, arg7, arg8 uint16, arg9 []byte, arg10 func(openflow.PacketOutBuilder) openflow.PacketOutBuilder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendUDPPacketOut", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendUDPPacketOut indicates an expected call of SendUDPPacketOut
func (mr *MockClientMockRecorder) SendUDPPacketOut(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendUDPPacketOut", reflect.TypeOf((*MockClient)(nil).SendUDPPacketOut), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
}

// StartPacketInHandler mocks base method
func (m *MockClient) StartPacketInHandler(arg0 <-chan struct{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StartPacketInHandler", arg0)
}

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

// SubscribePacketIn mocks base method
func (m *MockClient) SubscribePacketIn(arg0 byte, arg1 *openflow.PacketInQueue) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribePacketIn", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UninstallEndpointFlows mocks base method
func (m *MockClient) UninstallEndpointFlows(arg0 openflow.Protocol, arg1 proxy.Endpoint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UninstallEndpointFlows", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UninstallServiceFlows mocks base method
func (m *MockClient) UninstallServiceFlows(arg0 net.IP, arg1 uint16, arg2 openflow.Protocol) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UninstallServiceFlows", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UninstallServiceFlows indicates an expected call of UninstallServiceFlows
func (mr *MockClientMockRecorder) UninstallServiceFlows(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UninstallServiceFlows", reflect.TypeOf((*MockClient)(nil).UninstallServiceFlows), arg0, arg1, arg2)
}

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

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

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

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

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

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

// MockOFEntryOperations is a mock of OFEntryOperations interface
type MockOFEntryOperations struct {
	ctrl     *gomock.Controller
	recorder *MockOFEntryOperationsMockRecorder
}

// MockOFEntryOperationsMockRecorder is the mock recorder for MockOFEntryOperations
type MockOFEntryOperationsMockRecorder struct {
	mock *MockOFEntryOperations
}

// NewMockOFEntryOperations creates a new mock instance
func NewMockOFEntryOperations(ctrl *gomock.Controller) *MockOFEntryOperations {
	mock := &MockOFEntryOperations{ctrl: ctrl}
	mock.recorder = &MockOFEntryOperationsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// BundleOps mocks base method
func (m *MockOFEntryOperations) BundleOps(arg0, arg1, arg2 []openflow.Flow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BundleOps", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// BundleOps indicates an expected call of BundleOps
func (mr *MockOFEntryOperationsMockRecorder) BundleOps(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleOps", reflect.TypeOf((*MockOFEntryOperations)(nil).BundleOps), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

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

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