// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ChainSafe/gossamer/lib/babe (interfaces: ImportedBlockNotifierManager,TransactionState,EpochState,BlockImportHandler,SlotState)
//
// Generated by this command:
//
//	mockgen -destination=mock_state_test.go -package babe . ImportedBlockNotifierManager,TransactionState,EpochState,BlockImportHandler,SlotState
//

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

import (
	reflect "reflect"
	time "time"

	types "github.com/ChainSafe/gossamer/dot/types"
	common "github.com/ChainSafe/gossamer/lib/common"
	storage "github.com/ChainSafe/gossamer/lib/runtime/storage"
	transaction "github.com/ChainSafe/gossamer/lib/transaction"
	gomock "go.uber.org/mock/gomock"
)

// MockImportedBlockNotifierManager is a mock of ImportedBlockNotifierManager interface.
type MockImportedBlockNotifierManager struct {
	ctrl     *gomock.Controller
	recorder *MockImportedBlockNotifierManagerMockRecorder
	isgomock struct{}
}

// MockImportedBlockNotifierManagerMockRecorder is the mock recorder for MockImportedBlockNotifierManager.
type MockImportedBlockNotifierManagerMockRecorder struct {
	mock *MockImportedBlockNotifierManager
}

// NewMockImportedBlockNotifierManager creates a new mock instance.
func NewMockImportedBlockNotifierManager(ctrl *gomock.Controller) *MockImportedBlockNotifierManager {
	mock := &MockImportedBlockNotifierManager{ctrl: ctrl}
	mock.recorder = &MockImportedBlockNotifierManagerMockRecorder{mock}
	return mock
}

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

// FreeImportedBlockNotifierChannel mocks base method.
func (m *MockImportedBlockNotifierManager) FreeImportedBlockNotifierChannel(ch chan *types.Block) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FreeImportedBlockNotifierChannel", ch)
}

// FreeImportedBlockNotifierChannel indicates an expected call of FreeImportedBlockNotifierChannel.
func (mr *MockImportedBlockNotifierManagerMockRecorder) FreeImportedBlockNotifierChannel(ch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FreeImportedBlockNotifierChannel", reflect.TypeOf((*MockImportedBlockNotifierManager)(nil).FreeImportedBlockNotifierChannel), ch)
}

// GetImportedBlockNotifierChannel mocks base method.
func (m *MockImportedBlockNotifierManager) GetImportedBlockNotifierChannel() chan *types.Block {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImportedBlockNotifierChannel")
	ret0, _ := ret[0].(chan *types.Block)
	return ret0
}

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

// MockTransactionState is a mock of TransactionState interface.
type MockTransactionState struct {
	ctrl     *gomock.Controller
	recorder *MockTransactionStateMockRecorder
	isgomock struct{}
}

// MockTransactionStateMockRecorder is the mock recorder for MockTransactionState.
type MockTransactionStateMockRecorder struct {
	mock *MockTransactionState
}

// NewMockTransactionState creates a new mock instance.
func NewMockTransactionState(ctrl *gomock.Controller) *MockTransactionState {
	mock := &MockTransactionState{ctrl: ctrl}
	mock.recorder = &MockTransactionStateMockRecorder{mock}
	return mock
}

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

// PopWithTimer mocks base method.
func (m *MockTransactionState) PopWithTimer(timerCh <-chan time.Time) *transaction.ValidTransaction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PopWithTimer", timerCh)
	ret0, _ := ret[0].(*transaction.ValidTransaction)
	return ret0
}

// PopWithTimer indicates an expected call of PopWithTimer.
func (mr *MockTransactionStateMockRecorder) PopWithTimer(timerCh any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopWithTimer", reflect.TypeOf((*MockTransactionState)(nil).PopWithTimer), timerCh)
}

// Push mocks base method.
func (m *MockTransactionState) Push(vt *transaction.ValidTransaction) (common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Push", vt)
	ret0, _ := ret[0].(common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Push indicates an expected call of Push.
func (mr *MockTransactionStateMockRecorder) Push(vt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockTransactionState)(nil).Push), vt)
}

// MockEpochState is a mock of EpochState interface.
type MockEpochState struct {
	ctrl     *gomock.Controller
	recorder *MockEpochStateMockRecorder
	isgomock struct{}
}

// MockEpochStateMockRecorder is the mock recorder for MockEpochState.
type MockEpochStateMockRecorder struct {
	mock *MockEpochState
}

// NewMockEpochState creates a new mock instance.
func NewMockEpochState(ctrl *gomock.Controller) *MockEpochState {
	mock := &MockEpochState{ctrl: ctrl}
	mock.recorder = &MockEpochStateMockRecorder{mock}
	return mock
}

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

// GetConfigData mocks base method.
func (m *MockEpochState) GetConfigData(epoch uint64, header *types.Header) (*types.ConfigData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigData", epoch, header)
	ret0, _ := ret[0].(*types.ConfigData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigData indicates an expected call of GetConfigData.
func (mr *MockEpochStateMockRecorder) GetConfigData(epoch, header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigData", reflect.TypeOf((*MockEpochState)(nil).GetConfigData), epoch, header)
}

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

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

// GetEpochDataRaw mocks base method.
func (m *MockEpochState) GetEpochDataRaw(epoch uint64, header *types.Header) (*types.EpochDataRaw, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEpochDataRaw", epoch, header)
	ret0, _ := ret[0].(*types.EpochDataRaw)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEpochDataRaw indicates an expected call of GetEpochDataRaw.
func (mr *MockEpochStateMockRecorder) GetEpochDataRaw(epoch, header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEpochDataRaw", reflect.TypeOf((*MockEpochState)(nil).GetEpochDataRaw), epoch, header)
}

// GetEpochForBlock mocks base method.
func (m *MockEpochState) GetEpochForBlock(header *types.Header) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEpochForBlock", header)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEpochForBlock indicates an expected call of GetEpochForBlock.
func (mr *MockEpochStateMockRecorder) GetEpochForBlock(header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEpochForBlock", reflect.TypeOf((*MockEpochState)(nil).GetEpochForBlock), header)
}

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

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

// GetSkippedConfigData mocks base method.
func (m *MockEpochState) GetSkippedConfigData(skippedEpoch, currentEpoch uint64, header *types.Header) (*types.ConfigData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSkippedConfigData", skippedEpoch, currentEpoch, header)
	ret0, _ := ret[0].(*types.ConfigData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSkippedConfigData indicates an expected call of GetSkippedConfigData.
func (mr *MockEpochStateMockRecorder) GetSkippedConfigData(skippedEpoch, currentEpoch, header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSkippedConfigData", reflect.TypeOf((*MockEpochState)(nil).GetSkippedConfigData), skippedEpoch, currentEpoch, header)
}

// GetSkippedEpochDataRaw mocks base method.
func (m *MockEpochState) GetSkippedEpochDataRaw(skippedEpoch, currentEpoch uint64, header *types.Header) (*types.EpochDataRaw, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSkippedEpochDataRaw", skippedEpoch, currentEpoch, header)
	ret0, _ := ret[0].(*types.EpochDataRaw)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSkippedEpochDataRaw indicates an expected call of GetSkippedEpochDataRaw.
func (mr *MockEpochStateMockRecorder) GetSkippedEpochDataRaw(skippedEpoch, currentEpoch, header any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSkippedEpochDataRaw", reflect.TypeOf((*MockEpochState)(nil).GetSkippedEpochDataRaw), skippedEpoch, currentEpoch, header)
}

// GetSlotDuration mocks base method.
func (m *MockEpochState) GetSlotDuration() (time.Duration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSlotDuration")
	ret0, _ := ret[0].(time.Duration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetStartSlotForEpoch mocks base method.
func (m *MockEpochState) GetStartSlotForEpoch(epoch uint64, bestBlockHash common.Hash) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStartSlotForEpoch", epoch, bestBlockHash)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStartSlotForEpoch indicates an expected call of GetStartSlotForEpoch.
func (mr *MockEpochStateMockRecorder) GetStartSlotForEpoch(epoch, bestBlockHash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStartSlotForEpoch", reflect.TypeOf((*MockEpochState)(nil).GetStartSlotForEpoch), epoch, bestBlockHash)
}

// SkipVerify mocks base method.
func (m *MockEpochState) SkipVerify(arg0 *types.Header) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SkipVerify", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// StoreCurrentEpoch indicates an expected call of StoreCurrentEpoch.
func (mr *MockEpochStateMockRecorder) StoreCurrentEpoch(epoch any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreCurrentEpoch", reflect.TypeOf((*MockEpochState)(nil).StoreCurrentEpoch), epoch)
}

// MockBlockImportHandler is a mock of BlockImportHandler interface.
type MockBlockImportHandler struct {
	ctrl     *gomock.Controller
	recorder *MockBlockImportHandlerMockRecorder
	isgomock struct{}
}

// MockBlockImportHandlerMockRecorder is the mock recorder for MockBlockImportHandler.
type MockBlockImportHandlerMockRecorder struct {
	mock *MockBlockImportHandler
}

// NewMockBlockImportHandler creates a new mock instance.
func NewMockBlockImportHandler(ctrl *gomock.Controller) *MockBlockImportHandler {
	mock := &MockBlockImportHandler{ctrl: ctrl}
	mock.recorder = &MockBlockImportHandlerMockRecorder{mock}
	return mock
}

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

// HandleBlockProduced mocks base method.
func (m *MockBlockImportHandler) HandleBlockProduced(block *types.Block, state storage.TrieState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleBlockProduced", block, state)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleBlockProduced indicates an expected call of HandleBlockProduced.
func (mr *MockBlockImportHandlerMockRecorder) HandleBlockProduced(block, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleBlockProduced", reflect.TypeOf((*MockBlockImportHandler)(nil).HandleBlockProduced), block, state)
}

// MockSlotState is a mock of SlotState interface.
type MockSlotState struct {
	ctrl     *gomock.Controller
	recorder *MockSlotStateMockRecorder
	isgomock struct{}
}

// MockSlotStateMockRecorder is the mock recorder for MockSlotState.
type MockSlotStateMockRecorder struct {
	mock *MockSlotState
}

// NewMockSlotState creates a new mock instance.
func NewMockSlotState(ctrl *gomock.Controller) *MockSlotState {
	mock := &MockSlotState{ctrl: ctrl}
	mock.recorder = &MockSlotStateMockRecorder{mock}
	return mock
}

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

// CheckEquivocation mocks base method.
func (m *MockSlotState) CheckEquivocation(slotNow, slot uint64, header *types.Header, signer types.AuthorityID) (*types.BabeEquivocationProof, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckEquivocation", slotNow, slot, header, signer)
	ret0, _ := ret[0].(*types.BabeEquivocationProof)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckEquivocation indicates an expected call of CheckEquivocation.
func (mr *MockSlotStateMockRecorder) CheckEquivocation(slotNow, slot, header, signer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckEquivocation", reflect.TypeOf((*MockSlotState)(nil).CheckEquivocation), slotNow, slot, header, signer)
}
