// Code generated by MockGen. DO NOT EDIT.
// Source: consensus/tendermint/router/interfaces/interfaces.go
//
// Generated by this command:
//
//	mockgen -source=consensus/tendermint/router/interfaces/interfaces.go -package=mocks -destination=consensus/tendermint/router/mocks/interfaces_mock.go
//

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

import (
	big "math/big"
	reflect "reflect"

	common "github.com/autonity/autonity/common"
	consensus "github.com/autonity/autonity/consensus"
	message "github.com/autonity/autonity/consensus/tendermint/core/message"
	cluster "github.com/autonity/autonity/consensus/tendermint/router/cluster"
	interfaces "github.com/autonity/autonity/consensus/tendermint/router/interfaces"
	ping "github.com/autonity/autonity/consensus/tendermint/router/ping"
	core "github.com/autonity/autonity/core"
	types "github.com/autonity/autonity/core/types"
	event "github.com/autonity/autonity/event"
	enode "github.com/autonity/autonity/p2p/enode"
	gomock "go.uber.org/mock/gomock"
)

// MockClustersProvider is a mock of ClustersProvider interface.
type MockClustersProvider struct {
	ctrl     *gomock.Controller
	recorder *MockClustersProviderMockRecorder
	isgomock struct{}
}

// MockClustersProviderMockRecorder is the mock recorder for MockClustersProvider.
type MockClustersProviderMockRecorder struct {
	mock *MockClustersProvider
}

// NewMockClustersProvider creates a new mock instance.
func NewMockClustersProvider(ctrl *gomock.Controller) *MockClustersProvider {
	mock := &MockClustersProvider{ctrl: ctrl}
	mock.recorder = &MockClustersProviderMockRecorder{mock}
	return mock
}

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

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

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

// UpdateClusters mocks base method.
func (m *MockClustersProvider) UpdateClusters(arg0 cluster.Clusters) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateClusters", arg0)
}

// UpdateClusters indicates an expected call of UpdateClusters.
func (mr *MockClustersProviderMockRecorder) UpdateClusters(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusters", reflect.TypeOf((*MockClustersProvider)(nil).UpdateClusters), arg0)
}

// MockLatencyProvider is a mock of LatencyProvider interface.
type MockLatencyProvider struct {
	ctrl     *gomock.Controller
	recorder *MockLatencyProviderMockRecorder
	isgomock struct{}
}

// MockLatencyProviderMockRecorder is the mock recorder for MockLatencyProvider.
type MockLatencyProviderMockRecorder struct {
	mock *MockLatencyProvider
}

// NewMockLatencyProvider creates a new mock instance.
func NewMockLatencyProvider(ctrl *gomock.Controller) *MockLatencyProvider {
	mock := &MockLatencyProvider{ctrl: ctrl}
	mock.recorder = &MockLatencyProviderMockRecorder{mock}
	return mock
}

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

// Fetch mocks base method.
func (m *MockLatencyProvider) Fetch(validators []common.Address, self common.Address) (map[common.Address]uint, []common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fetch", validators, self)
	ret0, _ := ret[0].(map[common.Address]uint)
	ret1, _ := ret[1].([]common.Address)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Fetch indicates an expected call of Fetch.
func (mr *MockLatencyProviderMockRecorder) Fetch(validators, self any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockLatencyProvider)(nil).Fetch), validators, self)
}

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

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

// SetBroadcaster mocks base method.
func (m *MockLatencyProvider) SetBroadcaster(broadcaster interfaces.PeerFinder) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBroadcaster", broadcaster)
}

// SetBroadcaster indicates an expected call of SetBroadcaster.
func (mr *MockLatencyProviderMockRecorder) SetBroadcaster(broadcaster any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBroadcaster", reflect.TypeOf((*MockLatencyProvider)(nil).SetBroadcaster), broadcaster)
}

// SetPinger mocks base method.
func (m *MockLatencyProvider) SetPinger(arg0 ping.Pinger) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPinger", arg0)
}

// SetPinger indicates an expected call of SetPinger.
func (mr *MockLatencyProviderMockRecorder) SetPinger(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPinger", reflect.TypeOf((*MockLatencyProvider)(nil).SetPinger), arg0)
}

// MockPeerFinder is a mock of PeerFinder interface.
type MockPeerFinder struct {
	ctrl     *gomock.Controller
	recorder *MockPeerFinderMockRecorder
	isgomock struct{}
}

// MockPeerFinderMockRecorder is the mock recorder for MockPeerFinder.
type MockPeerFinderMockRecorder struct {
	mock *MockPeerFinder
}

// NewMockPeerFinder creates a new mock instance.
func NewMockPeerFinder(ctrl *gomock.Controller) *MockPeerFinder {
	mock := &MockPeerFinder{ctrl: ctrl}
	mock.recorder = &MockPeerFinderMockRecorder{mock}
	return mock
}

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

// CommitteeEnodes mocks base method.
func (m *MockPeerFinder) CommitteeEnodes() []*enode.Node {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitteeEnodes")
	ret0, _ := ret[0].([]*enode.Node)
	return ret0
}

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

// FindPeer mocks base method.
func (m *MockPeerFinder) FindPeer(addr common.Address) (consensus.Peer, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindPeer", addr)
	ret0, _ := ret[0].(consensus.Peer)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// FindPeer indicates an expected call of FindPeer.
func (mr *MockPeerFinderMockRecorder) FindPeer(addr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPeer", reflect.TypeOf((*MockPeerFinder)(nil).FindPeer), addr)
}

// FindPeers mocks base method.
func (m *MockPeerFinder) FindPeers(arg0 []common.Address) map[common.Address]consensus.Peer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindPeers", arg0)
	ret0, _ := ret[0].(map[common.Address]consensus.Peer)
	return ret0
}

// FindPeers indicates an expected call of FindPeers.
func (mr *MockPeerFinderMockRecorder) FindPeers(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPeers", reflect.TypeOf((*MockPeerFinder)(nil).FindPeers), arg0)
}

// MockPeerSelector is a mock of PeerSelector interface.
type MockPeerSelector struct {
	ctrl     *gomock.Controller
	recorder *MockPeerSelectorMockRecorder
	isgomock struct{}
}

// MockPeerSelectorMockRecorder is the mock recorder for MockPeerSelector.
type MockPeerSelectorMockRecorder struct {
	mock *MockPeerSelector
}

// NewMockPeerSelector creates a new mock instance.
func NewMockPeerSelector(ctrl *gomock.Controller) *MockPeerSelector {
	mock := &MockPeerSelector{ctrl: ctrl}
	mock.recorder = &MockPeerSelectorMockRecorder{mock}
	return mock
}

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

// SelectPeers mocks base method.
func (m *MockPeerSelector) SelectPeers(committee *types.Committee, msg message.Msg, from common.Address) ([]common.Address, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectPeers", committee, msg, from)
	ret0, _ := ret[0].([]common.Address)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectPeers indicates an expected call of SelectPeers.
func (mr *MockPeerSelectorMockRecorder) SelectPeers(committee, msg, from any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectPeers", reflect.TypeOf((*MockPeerSelector)(nil).SelectPeers), committee, msg, from)
}

// SetBroadcaster mocks base method.
func (m *MockPeerSelector) SetBroadcaster(broadcaster interfaces.PeerFinder) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBroadcaster", broadcaster)
}

// SetBroadcaster indicates an expected call of SetBroadcaster.
func (mr *MockPeerSelectorMockRecorder) SetBroadcaster(broadcaster any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBroadcaster", reflect.TypeOf((*MockPeerSelector)(nil).SetBroadcaster), broadcaster)
}

// MockBlockChainProvider is a mock of BlockChainProvider interface.
type MockBlockChainProvider struct {
	ctrl     *gomock.Controller
	recorder *MockBlockChainProviderMockRecorder
	isgomock struct{}
}

// MockBlockChainProviderMockRecorder is the mock recorder for MockBlockChainProvider.
type MockBlockChainProviderMockRecorder struct {
	mock *MockBlockChainProvider
}

// NewMockBlockChainProvider creates a new mock instance.
func NewMockBlockChainProvider(ctrl *gomock.Controller) *MockBlockChainProvider {
	mock := &MockBlockChainProvider{ctrl: ctrl}
	mock.recorder = &MockBlockChainProviderMockRecorder{mock}
	return mock
}

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

// ClusteringThresholdByHeight mocks base method.
func (m *MockBlockChainProvider) ClusteringThresholdByHeight(height uint64) (*big.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusteringThresholdByHeight", height)
	ret0, _ := ret[0].(*big.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ClusteringThresholdByHeight indicates an expected call of ClusteringThresholdByHeight.
func (mr *MockBlockChainProviderMockRecorder) ClusteringThresholdByHeight(height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusteringThresholdByHeight", reflect.TypeOf((*MockBlockChainProvider)(nil).ClusteringThresholdByHeight), height)
}

// LatestEpoch mocks base method.
func (m *MockBlockChainProvider) LatestEpoch() (*types.EpochInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LatestEpoch")
	ret0, _ := ret[0].(*types.EpochInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeEpochHeadEvent mocks base method.
func (m *MockBlockChainProvider) SubscribeEpochHeadEvent(arg0 chan<- core.EpochHeadEvent) event.Subscription {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubscribeEpochHeadEvent", arg0)
	ret0, _ := ret[0].(event.Subscription)
	return ret0
}

// SubscribeEpochHeadEvent indicates an expected call of SubscribeEpochHeadEvent.
func (mr *MockBlockChainProviderMockRecorder) SubscribeEpochHeadEvent(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeEpochHeadEvent", reflect.TypeOf((*MockBlockChainProvider)(nil).SubscribeEpochHeadEvent), arg0)
}
