// 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/interfacestore (interfaces: InterfaceStore)
//
// Generated by this command:
//
//	mockgen -copyright_file hack/boilerplate/license_header.raw.txt -destination pkg/agent/interfacestore/testing/mock_interfacestore.go -package testing antrea.io/antrea/pkg/agent/interfacestore InterfaceStore
//

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

import (
	reflect "reflect"

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

// MockInterfaceStore is a mock of InterfaceStore interface.
type MockInterfaceStore struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceStoreMockRecorder
	isgomock struct{}
}

// MockInterfaceStoreMockRecorder is the mock recorder for MockInterfaceStore.
type MockInterfaceStoreMockRecorder struct {
	mock *MockInterfaceStore
}

// NewMockInterfaceStore creates a new mock instance.
func NewMockInterfaceStore(ctrl *gomock.Controller) *MockInterfaceStore {
	mock := &MockInterfaceStore{ctrl: ctrl}
	mock.recorder = &MockInterfaceStoreMockRecorder{mock}
	return mock
}

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

// AddInterface mocks base method.
func (m *MockInterfaceStore) AddInterface(interfaceConfig *interfacestore.InterfaceConfig) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddInterface", interfaceConfig)
}

// AddInterface indicates an expected call of AddInterface.
func (mr *MockInterfaceStoreMockRecorder) AddInterface(interfaceConfig any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddInterface", reflect.TypeOf((*MockInterfaceStore)(nil).AddInterface), interfaceConfig)
}

// DeleteInterface mocks base method.
func (m *MockInterfaceStore) DeleteInterface(interfaceConfig *interfacestore.InterfaceConfig) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeleteInterface", interfaceConfig)
}

// DeleteInterface indicates an expected call of DeleteInterface.
func (mr *MockInterfaceStoreMockRecorder) DeleteInterface(interfaceConfig any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInterface", reflect.TypeOf((*MockInterfaceStore)(nil).DeleteInterface), interfaceConfig)
}

// GetContainerInterface mocks base method.
func (m *MockInterfaceStore) GetContainerInterface(containerID string) (*interfacestore.InterfaceConfig, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainerInterface", containerID)
	ret0, _ := ret[0].(*interfacestore.InterfaceConfig)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetContainerInterface indicates an expected call of GetContainerInterface.
func (mr *MockInterfaceStoreMockRecorder) GetContainerInterface(containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInterface", reflect.TypeOf((*MockInterfaceStore)(nil).GetContainerInterface), containerID)
}

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

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

// GetContainerInterfacesByPod mocks base method.
func (m *MockInterfaceStore) GetContainerInterfacesByPod(podName, podNamespace string) []*interfacestore.InterfaceConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainerInterfacesByPod", podName, podNamespace)
	ret0, _ := ret[0].([]*interfacestore.InterfaceConfig)
	return ret0
}

// GetContainerInterfacesByPod indicates an expected call of GetContainerInterfacesByPod.
func (mr *MockInterfaceStoreMockRecorder) GetContainerInterfacesByPod(podName, podNamespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerInterfacesByPod", reflect.TypeOf((*MockInterfaceStore)(nil).GetContainerInterfacesByPod), podName, podNamespace)
}

// GetInterface mocks base method.
func (m *MockInterfaceStore) GetInterface(interfaceKey string) (*interfacestore.InterfaceConfig, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInterface", interfaceKey)
	ret0, _ := ret[0].(*interfacestore.InterfaceConfig)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetInterface indicates an expected call of GetInterface.
func (mr *MockInterfaceStoreMockRecorder) GetInterface(interfaceKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInterface", reflect.TypeOf((*MockInterfaceStore)(nil).GetInterface), interfaceKey)
}

// GetInterfaceByIP mocks base method.
func (m *MockInterfaceStore) GetInterfaceByIP(interfaceIP string) (*interfacestore.InterfaceConfig, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInterfaceByIP", interfaceIP)
	ret0, _ := ret[0].(*interfacestore.InterfaceConfig)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetInterfaceByIP indicates an expected call of GetInterfaceByIP.
func (mr *MockInterfaceStoreMockRecorder) GetInterfaceByIP(interfaceIP any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInterfaceByIP", reflect.TypeOf((*MockInterfaceStore)(nil).GetInterfaceByIP), interfaceIP)
}

// GetInterfaceByName mocks base method.
func (m *MockInterfaceStore) GetInterfaceByName(interfaceName string) (*interfacestore.InterfaceConfig, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInterfaceByName", interfaceName)
	ret0, _ := ret[0].(*interfacestore.InterfaceConfig)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetInterfaceByName indicates an expected call of GetInterfaceByName.
func (mr *MockInterfaceStoreMockRecorder) GetInterfaceByName(interfaceName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInterfaceByName", reflect.TypeOf((*MockInterfaceStore)(nil).GetInterfaceByName), interfaceName)
}

// GetInterfaceByOFPort mocks base method.
func (m *MockInterfaceStore) GetInterfaceByOFPort(ofPort uint32) (*interfacestore.InterfaceConfig, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInterfaceByOFPort", ofPort)
	ret0, _ := ret[0].(*interfacestore.InterfaceConfig)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetInterfaceByOFPort indicates an expected call of GetInterfaceByOFPort.
func (mr *MockInterfaceStoreMockRecorder) GetInterfaceByOFPort(ofPort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInterfaceByOFPort", reflect.TypeOf((*MockInterfaceStore)(nil).GetInterfaceByOFPort), ofPort)
}

// GetInterfaceKeysByType mocks base method.
func (m *MockInterfaceStore) GetInterfaceKeysByType(interfaceType interfacestore.InterfaceType) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInterfaceKeysByType", interfaceType)
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetInterfaceKeysByType indicates an expected call of GetInterfaceKeysByType.
func (mr *MockInterfaceStoreMockRecorder) GetInterfaceKeysByType(interfaceType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInterfaceKeysByType", reflect.TypeOf((*MockInterfaceStore)(nil).GetInterfaceKeysByType), interfaceType)
}

// GetInterfacesByEntity mocks base method.
func (m *MockInterfaceStore) GetInterfacesByEntity(name, namespace string) []*interfacestore.InterfaceConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInterfacesByEntity", name, namespace)
	ret0, _ := ret[0].([]*interfacestore.InterfaceConfig)
	return ret0
}

// GetInterfacesByEntity indicates an expected call of GetInterfacesByEntity.
func (mr *MockInterfaceStoreMockRecorder) GetInterfacesByEntity(name, namespace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInterfacesByEntity", reflect.TypeOf((*MockInterfaceStore)(nil).GetInterfacesByEntity), name, namespace)
}

// GetInterfacesByType mocks base method.
func (m *MockInterfaceStore) GetInterfacesByType(interfaceType interfacestore.InterfaceType) []*interfacestore.InterfaceConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInterfacesByType", interfaceType)
	ret0, _ := ret[0].([]*interfacestore.InterfaceConfig)
	return ret0
}

// GetInterfacesByType indicates an expected call of GetInterfacesByType.
func (mr *MockInterfaceStoreMockRecorder) GetInterfacesByType(interfaceType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInterfacesByType", reflect.TypeOf((*MockInterfaceStore)(nil).GetInterfacesByType), interfaceType)
}

// GetNodeTunnelInterface mocks base method.
func (m *MockInterfaceStore) GetNodeTunnelInterface(nodeName string) (*interfacestore.InterfaceConfig, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeTunnelInterface", nodeName)
	ret0, _ := ret[0].(*interfacestore.InterfaceConfig)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetNodeTunnelInterface indicates an expected call of GetNodeTunnelInterface.
func (mr *MockInterfaceStoreMockRecorder) GetNodeTunnelInterface(nodeName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeTunnelInterface", reflect.TypeOf((*MockInterfaceStore)(nil).GetNodeTunnelInterface), nodeName)
}

// Initialize mocks base method.
func (m *MockInterfaceStore) Initialize(interfaces []*interfacestore.InterfaceConfig) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Initialize", interfaces)
}

// Initialize indicates an expected call of Initialize.
func (mr *MockInterfaceStoreMockRecorder) Initialize(interfaces any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockInterfaceStore)(nil).Initialize), interfaces)
}

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

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

// ListInterfaces mocks base method.
func (m *MockInterfaceStore) ListInterfaces() []*interfacestore.InterfaceConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInterfaces")
	ret0, _ := ret[0].([]*interfacestore.InterfaceConfig)
	return ret0
}

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

// UpdateInterface mocks base method.
func (m *MockInterfaceStore) UpdateInterface(interfaceConfig *interfacestore.InterfaceConfig) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateInterface", interfaceConfig)
}

// UpdateInterface indicates an expected call of UpdateInterface.
func (mr *MockInterfaceStoreMockRecorder) UpdateInterface(interfaceConfig any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInterface", reflect.TypeOf((*MockInterfaceStore)(nil).UpdateInterface), interfaceConfig)
}
