blockchain_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/klaytn/klaytn/node/cn (interfaces: BlockChain)

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

import (
	gomock "github.com/golang/mock/gomock"
	state "github.com/klaytn/klaytn/blockchain/state"
	types "github.com/klaytn/klaytn/blockchain/types"
	common "github.com/klaytn/klaytn/common"
	params "github.com/klaytn/klaytn/params"
	rlp "github.com/klaytn/klaytn/ser/rlp"
	big "math/big"
	reflect "reflect"
)

// MockBlockChain is a mock of BlockChain interface
type MockBlockChain struct {
	ctrl     *gomock.Controller
	recorder *MockBlockChainMockRecorder
}

// MockBlockChainMockRecorder is the mock recorder for MockBlockChain
type MockBlockChainMockRecorder struct {
	mock *MockBlockChain
}

// NewMockBlockChain creates a new mock instance
func NewMockBlockChain(ctrl *gomock.Controller) *MockBlockChain {
	mock := &MockBlockChain{ctrl: ctrl}
	mock.recorder = &MockBlockChainMockRecorder{mock}
	return mock
}

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

// Config mocks base method
func (m *MockBlockChain) Config() *params.ChainConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Config")
	ret0, _ := ret[0].(*params.ChainConfig)
	return ret0
}

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

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

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

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

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

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

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

// FastSyncCommitHead mocks base method
func (m *MockBlockChain) FastSyncCommitHead(arg0 common.Hash) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FastSyncCommitHead", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// FastSyncCommitHead indicates an expected call of FastSyncCommitHead
func (mr *MockBlockChainMockRecorder) FastSyncCommitHead(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FastSyncCommitHead", reflect.TypeOf((*MockBlockChain)(nil).FastSyncCommitHead), arg0)
}

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

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

// GetBlock mocks base method
func (m *MockBlockChain) GetBlock(arg0 common.Hash, arg1 uint64) *types.Block {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlock", arg0, arg1)
	ret0, _ := ret[0].(*types.Block)
	return ret0
}

// GetBlock indicates an expected call of GetBlock
func (mr *MockBlockChainMockRecorder) GetBlock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlock", reflect.TypeOf((*MockBlockChain)(nil).GetBlock), arg0, arg1)
}

// GetBlockByHash mocks base method
func (m *MockBlockChain) GetBlockByHash(arg0 common.Hash) *types.Block {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockByHash", arg0)
	ret0, _ := ret[0].(*types.Block)
	return ret0
}

// GetBlockByHash indicates an expected call of GetBlockByHash
func (mr *MockBlockChainMockRecorder) GetBlockByHash(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockByHash", reflect.TypeOf((*MockBlockChain)(nil).GetBlockByHash), arg0)
}

// GetBlockHashesFromHash mocks base method
func (m *MockBlockChain) GetBlockHashesFromHash(arg0 common.Hash, arg1 uint64) []common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockHashesFromHash", arg0, arg1)
	ret0, _ := ret[0].([]common.Hash)
	return ret0
}

// GetBlockHashesFromHash indicates an expected call of GetBlockHashesFromHash
func (mr *MockBlockChainMockRecorder) GetBlockHashesFromHash(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockHashesFromHash", reflect.TypeOf((*MockBlockChain)(nil).GetBlockHashesFromHash), arg0, arg1)
}

// GetBodyRLP mocks base method
func (m *MockBlockChain) GetBodyRLP(arg0 common.Hash) rlp.RawValue {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBodyRLP", arg0)
	ret0, _ := ret[0].(rlp.RawValue)
	return ret0
}

// GetBodyRLP indicates an expected call of GetBodyRLP
func (mr *MockBlockChainMockRecorder) GetBodyRLP(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBodyRLP", reflect.TypeOf((*MockBlockChain)(nil).GetBodyRLP), arg0)
}

// GetHeader mocks base method
func (m *MockBlockChain) GetHeader(arg0 common.Hash, arg1 uint64) *types.Header {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeader", arg0, arg1)
	ret0, _ := ret[0].(*types.Header)
	return ret0
}

// GetHeader indicates an expected call of GetHeader
func (mr *MockBlockChainMockRecorder) GetHeader(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeader", reflect.TypeOf((*MockBlockChain)(nil).GetHeader), arg0, arg1)
}

// GetHeaderByHash mocks base method
func (m *MockBlockChain) GetHeaderByHash(arg0 common.Hash) *types.Header {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeaderByHash", arg0)
	ret0, _ := ret[0].(*types.Header)
	return ret0
}

// GetHeaderByHash indicates an expected call of GetHeaderByHash
func (mr *MockBlockChainMockRecorder) GetHeaderByHash(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeaderByHash", reflect.TypeOf((*MockBlockChain)(nil).GetHeaderByHash), arg0)
}

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

// GetHeaderByNumber indicates an expected call of GetHeaderByNumber
func (mr *MockBlockChainMockRecorder) GetHeaderByNumber(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeaderByNumber", reflect.TypeOf((*MockBlockChain)(nil).GetHeaderByNumber), arg0)
}

// GetReceiptsByBlockHash mocks base method
func (m *MockBlockChain) GetReceiptsByBlockHash(arg0 common.Hash) types.Receipts {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReceiptsByBlockHash", arg0)
	ret0, _ := ret[0].(types.Receipts)
	return ret0
}

// GetReceiptsByBlockHash indicates an expected call of GetReceiptsByBlockHash
func (mr *MockBlockChainMockRecorder) GetReceiptsByBlockHash(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReceiptsByBlockHash", reflect.TypeOf((*MockBlockChain)(nil).GetReceiptsByBlockHash), arg0)
}

// GetTd mocks base method
func (m *MockBlockChain) GetTd(arg0 common.Hash, arg1 uint64) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTd", arg0, arg1)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// GetTd indicates an expected call of GetTd
func (mr *MockBlockChainMockRecorder) GetTd(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTd", reflect.TypeOf((*MockBlockChain)(nil).GetTd), arg0, arg1)
}

// GetTdByHash mocks base method
func (m *MockBlockChain) GetTdByHash(arg0 common.Hash) *big.Int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTdByHash", arg0)
	ret0, _ := ret[0].(*big.Int)
	return ret0
}

// GetTdByHash indicates an expected call of GetTdByHash
func (mr *MockBlockChainMockRecorder) GetTdByHash(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTdByHash", reflect.TypeOf((*MockBlockChain)(nil).GetTdByHash), arg0)
}

// HasBlock mocks base method
func (m *MockBlockChain) HasBlock(arg0 common.Hash, arg1 uint64) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasBlock", arg0, arg1)
	ret0, _ := ret[0].(bool)
	return ret0
}

// HasBlock indicates an expected call of HasBlock
func (mr *MockBlockChainMockRecorder) HasBlock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasBlock", reflect.TypeOf((*MockBlockChain)(nil).HasBlock), arg0, arg1)
}

// HasHeader mocks base method
func (m *MockBlockChain) HasHeader(arg0 common.Hash, arg1 uint64) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasHeader", arg0, arg1)
	ret0, _ := ret[0].(bool)
	return ret0
}

// HasHeader indicates an expected call of HasHeader
func (mr *MockBlockChainMockRecorder) HasHeader(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasHeader", reflect.TypeOf((*MockBlockChain)(nil).HasHeader), arg0, arg1)
}

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

// InsertChain indicates an expected call of InsertChain
func (mr *MockBlockChainMockRecorder) InsertChain(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChain", reflect.TypeOf((*MockBlockChain)(nil).InsertChain), arg0)
}

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

// InsertHeaderChain indicates an expected call of InsertHeaderChain
func (mr *MockBlockChainMockRecorder) InsertHeaderChain(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertHeaderChain", reflect.TypeOf((*MockBlockChain)(nil).InsertHeaderChain), arg0, arg1)
}

// InsertReceiptChain mocks base method
func (m *MockBlockChain) InsertReceiptChain(arg0 types.Blocks, arg1 []types.Receipts) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertReceiptChain", arg0, arg1)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertReceiptChain indicates an expected call of InsertReceiptChain
func (mr *MockBlockChainMockRecorder) InsertReceiptChain(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertReceiptChain", reflect.TypeOf((*MockBlockChain)(nil).InsertReceiptChain), arg0, arg1)
}

// Rollback mocks base method
func (m *MockBlockChain) Rollback(arg0 []common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Rollback", arg0)
}

// Rollback indicates an expected call of Rollback
func (mr *MockBlockChainMockRecorder) Rollback(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockBlockChain)(nil).Rollback), arg0)
}

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

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

// TrieNode mocks base method
func (m *MockBlockChain) TrieNode(arg0 common.Hash) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TrieNode", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TrieNode indicates an expected call of TrieNode
func (mr *MockBlockChainMockRecorder) TrieNode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrieNode", reflect.TypeOf((*MockBlockChain)(nil).TrieNode), arg0)
}