// 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/third_party/proxy (interfaces: Provider)
//
// Generated by this command:
//
//	mockgen -copyright_file hack/boilerplate/license_header.raw.txt -destination third_party/proxy/testing/mock_proxy.go -package testing antrea.io/antrea/third_party/proxy Provider
//

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

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	v1 "k8s.io/api/core/v1"
	v10 "k8s.io/api/discovery/v1"
)

// MockProvider is a mock of Provider interface.
type MockProvider struct {
	ctrl     *gomock.Controller
	recorder *MockProviderMockRecorder
	isgomock struct{}
}

// MockProviderMockRecorder is the mock recorder for MockProvider.
type MockProviderMockRecorder struct {
	mock *MockProvider
}

// NewMockProvider creates a new mock instance.
func NewMockProvider(ctrl *gomock.Controller) *MockProvider {
	mock := &MockProvider{ctrl: ctrl}
	mock.recorder = &MockProviderMockRecorder{mock}
	return mock
}

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

// OnEndpointSliceAdd mocks base method.
func (m *MockProvider) OnEndpointSliceAdd(endpointSlice *v10.EndpointSlice) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEndpointSliceAdd", endpointSlice)
}

// OnEndpointSliceAdd indicates an expected call of OnEndpointSliceAdd.
func (mr *MockProviderMockRecorder) OnEndpointSliceAdd(endpointSlice any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnEndpointSliceAdd", reflect.TypeOf((*MockProvider)(nil).OnEndpointSliceAdd), endpointSlice)
}

// OnEndpointSliceDelete mocks base method.
func (m *MockProvider) OnEndpointSliceDelete(endpointSlice *v10.EndpointSlice) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEndpointSliceDelete", endpointSlice)
}

// OnEndpointSliceDelete indicates an expected call of OnEndpointSliceDelete.
func (mr *MockProviderMockRecorder) OnEndpointSliceDelete(endpointSlice any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnEndpointSliceDelete", reflect.TypeOf((*MockProvider)(nil).OnEndpointSliceDelete), endpointSlice)
}

// OnEndpointSliceUpdate mocks base method.
func (m *MockProvider) OnEndpointSliceUpdate(oldEndpointSlice, newEndpointSlice *v10.EndpointSlice) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEndpointSliceUpdate", oldEndpointSlice, newEndpointSlice)
}

// OnEndpointSliceUpdate indicates an expected call of OnEndpointSliceUpdate.
func (mr *MockProviderMockRecorder) OnEndpointSliceUpdate(oldEndpointSlice, newEndpointSlice any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnEndpointSliceUpdate", reflect.TypeOf((*MockProvider)(nil).OnEndpointSliceUpdate), oldEndpointSlice, newEndpointSlice)
}

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

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

// OnEndpointsAdd mocks base method.
func (m *MockProvider) OnEndpointsAdd(endpoints *v1.Endpoints) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEndpointsAdd", endpoints)
}

// OnEndpointsAdd indicates an expected call of OnEndpointsAdd.
func (mr *MockProviderMockRecorder) OnEndpointsAdd(endpoints any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnEndpointsAdd", reflect.TypeOf((*MockProvider)(nil).OnEndpointsAdd), endpoints)
}

// OnEndpointsDelete mocks base method.
func (m *MockProvider) OnEndpointsDelete(endpoints *v1.Endpoints) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEndpointsDelete", endpoints)
}

// OnEndpointsDelete indicates an expected call of OnEndpointsDelete.
func (mr *MockProviderMockRecorder) OnEndpointsDelete(endpoints any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnEndpointsDelete", reflect.TypeOf((*MockProvider)(nil).OnEndpointsDelete), endpoints)
}

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

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

// OnEndpointsUpdate mocks base method.
func (m *MockProvider) OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEndpointsUpdate", oldEndpoints, endpoints)
}

// OnEndpointsUpdate indicates an expected call of OnEndpointsUpdate.
func (mr *MockProviderMockRecorder) OnEndpointsUpdate(oldEndpoints, endpoints any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnEndpointsUpdate", reflect.TypeOf((*MockProvider)(nil).OnEndpointsUpdate), oldEndpoints, endpoints)
}

// OnNodeAdd mocks base method.
func (m *MockProvider) OnNodeAdd(node *v1.Node) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnNodeAdd", node)
}

// OnNodeAdd indicates an expected call of OnNodeAdd.
func (mr *MockProviderMockRecorder) OnNodeAdd(node any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnNodeAdd", reflect.TypeOf((*MockProvider)(nil).OnNodeAdd), node)
}

// OnNodeDelete mocks base method.
func (m *MockProvider) OnNodeDelete(node *v1.Node) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnNodeDelete", node)
}

// OnNodeDelete indicates an expected call of OnNodeDelete.
func (mr *MockProviderMockRecorder) OnNodeDelete(node any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnNodeDelete", reflect.TypeOf((*MockProvider)(nil).OnNodeDelete), node)
}

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

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

// OnNodeUpdate mocks base method.
func (m *MockProvider) OnNodeUpdate(oldNode, node *v1.Node) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnNodeUpdate", oldNode, node)
}

// OnNodeUpdate indicates an expected call of OnNodeUpdate.
func (mr *MockProviderMockRecorder) OnNodeUpdate(oldNode, node any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnNodeUpdate", reflect.TypeOf((*MockProvider)(nil).OnNodeUpdate), oldNode, node)
}

// OnServiceAdd mocks base method.
func (m *MockProvider) OnServiceAdd(service *v1.Service) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnServiceAdd", service)
}

// OnServiceAdd indicates an expected call of OnServiceAdd.
func (mr *MockProviderMockRecorder) OnServiceAdd(service any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnServiceAdd", reflect.TypeOf((*MockProvider)(nil).OnServiceAdd), service)
}

// OnServiceDelete mocks base method.
func (m *MockProvider) OnServiceDelete(service *v1.Service) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnServiceDelete", service)
}

// OnServiceDelete indicates an expected call of OnServiceDelete.
func (mr *MockProviderMockRecorder) OnServiceDelete(service any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnServiceDelete", reflect.TypeOf((*MockProvider)(nil).OnServiceDelete), service)
}

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

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

// OnServiceUpdate mocks base method.
func (m *MockProvider) OnServiceUpdate(oldService, service *v1.Service) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnServiceUpdate", oldService, service)
}

// OnServiceUpdate indicates an expected call of OnServiceUpdate.
func (mr *MockProviderMockRecorder) OnServiceUpdate(oldService, service any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnServiceUpdate", reflect.TypeOf((*MockProvider)(nil).OnServiceUpdate), oldService, service)
}

// Run mocks base method.
func (m *MockProvider) Run(stopCh <-chan struct{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Run", stopCh)
}

// Run indicates an expected call of Run.
func (mr *MockProviderMockRecorder) Run(stopCh any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockProvider)(nil).Run), stopCh)
}

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

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

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

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