// Code generated by MockGen. DO NOT EDIT.
// Source: ./mockgen_eon_tracker.go
//
// Generated by this command:
//
//	mockgen -typed=true -source=./mockgen_eon_tracker.go -destination=./eon_tracker_mock.go -package=testhelpers
//

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

import (
	context "context"
	reflect "reflect"

	shutter "github.com/erigontech/erigon/txnprovider/shutter"
	gomock "go.uber.org/mock/gomock"
)

// MockEonTracker is a mock of EonTracker interface.
type MockEonTracker struct {
	ctrl     *gomock.Controller
	recorder *MockEonTrackerMockRecorder
	isgomock struct{}
}

// MockEonTrackerMockRecorder is the mock recorder for MockEonTracker.
type MockEonTrackerMockRecorder struct {
	mock *MockEonTracker
}

// NewMockEonTracker creates a new mock instance.
func NewMockEonTracker(ctrl *gomock.Controller) *MockEonTracker {
	mock := &MockEonTracker{ctrl: ctrl}
	mock.recorder = &MockEonTrackerMockRecorder{mock}
	return mock
}

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

// CurrentEon mocks base method.
func (m *MockEonTracker) CurrentEon() (shutter.Eon, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentEon")
	ret0, _ := ret[0].(shutter.Eon)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// CurrentEon indicates an expected call of CurrentEon.
func (mr *MockEonTrackerMockRecorder) CurrentEon() *MockEonTrackerCurrentEonCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentEon", reflect.TypeOf((*MockEonTracker)(nil).CurrentEon))
	return &MockEonTrackerCurrentEonCall{Call: call}
}

// MockEonTrackerCurrentEonCall wrap *gomock.Call
type MockEonTrackerCurrentEonCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEonTrackerCurrentEonCall) Return(arg0 shutter.Eon, arg1 bool) *MockEonTrackerCurrentEonCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEonTrackerCurrentEonCall) Do(f func() (shutter.Eon, bool)) *MockEonTrackerCurrentEonCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEonTrackerCurrentEonCall) DoAndReturn(f func() (shutter.Eon, bool)) *MockEonTrackerCurrentEonCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EonByBlockNum mocks base method.
func (m *MockEonTracker) EonByBlockNum(blockNum uint64) (shutter.Eon, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EonByBlockNum", blockNum)
	ret0, _ := ret[0].(shutter.Eon)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// EonByBlockNum indicates an expected call of EonByBlockNum.
func (mr *MockEonTrackerMockRecorder) EonByBlockNum(blockNum any) *MockEonTrackerEonByBlockNumCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EonByBlockNum", reflect.TypeOf((*MockEonTracker)(nil).EonByBlockNum), blockNum)
	return &MockEonTrackerEonByBlockNumCall{Call: call}
}

// MockEonTrackerEonByBlockNumCall wrap *gomock.Call
type MockEonTrackerEonByBlockNumCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEonTrackerEonByBlockNumCall) Return(arg0 shutter.Eon, arg1 bool) *MockEonTrackerEonByBlockNumCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEonTrackerEonByBlockNumCall) Do(f func(uint64) (shutter.Eon, bool)) *MockEonTrackerEonByBlockNumCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEonTrackerEonByBlockNumCall) DoAndReturn(f func(uint64) (shutter.Eon, bool)) *MockEonTrackerEonByBlockNumCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RecentEon mocks base method.
func (m *MockEonTracker) RecentEon(index shutter.EonIndex) (shutter.Eon, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecentEon", index)
	ret0, _ := ret[0].(shutter.Eon)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// RecentEon indicates an expected call of RecentEon.
func (mr *MockEonTrackerMockRecorder) RecentEon(index any) *MockEonTrackerRecentEonCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecentEon", reflect.TypeOf((*MockEonTracker)(nil).RecentEon), index)
	return &MockEonTrackerRecentEonCall{Call: call}
}

// MockEonTrackerRecentEonCall wrap *gomock.Call
type MockEonTrackerRecentEonCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEonTrackerRecentEonCall) Return(arg0 shutter.Eon, arg1 bool) *MockEonTrackerRecentEonCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEonTrackerRecentEonCall) Do(f func(shutter.EonIndex) (shutter.Eon, bool)) *MockEonTrackerRecentEonCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEonTrackerRecentEonCall) DoAndReturn(f func(shutter.EonIndex) (shutter.Eon, bool)) *MockEonTrackerRecentEonCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Run indicates an expected call of Run.
func (mr *MockEonTrackerMockRecorder) Run(ctx any) *MockEonTrackerRunCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockEonTracker)(nil).Run), ctx)
	return &MockEonTrackerRunCall{Call: call}
}

// MockEonTrackerRunCall wrap *gomock.Call
type MockEonTrackerRunCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockEonTrackerRunCall) Return(arg0 error) *MockEonTrackerRunCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockEonTrackerRunCall) Do(f func(context.Context) error) *MockEonTrackerRunCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockEonTrackerRunCall) DoAndReturn(f func(context.Context) error) *MockEonTrackerRunCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
