// Code generated by MockGen. DO NOT EDIT.
// Source: gitee.com/aiou-official/go-aiou/core/txpool (interfaces: TxPool)

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

import (
	gomock "github.com/golang/mock/gomock"
	block "gitee.com/aiou-official/go-aiou/core/block"
	blockcache "gitee.com/aiou-official/go-aiou/core/blockcache"
	tx "gitee.com/aiou-official/go-aiou/core/tx"
	txpool "gitee.com/aiou-official/go-aiou/core/txpool"
	reflect "reflect"
)

// MockTxPool is a mock of TxPool interface
type MockTxPool struct {
	ctrl     *gomock.Controller
	recorder *MockTxPoolMockRecorder
}

// MockTxPoolMockRecorder is the mock recorder for MockTxPool
type MockTxPoolMockRecorder struct {
	mock *MockTxPool
}

// NewMockTxPool creates a new mock instance
func NewMockTxPool(ctrl *gomock.Controller) *MockTxPool {
	mock := &MockTxPool{ctrl: ctrl}
	mock.recorder = &MockTxPoolMockRecorder{mock}
	return mock
}

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

// AddDefertx mocks base method
func (m *MockTxPool) AddDefertx(arg0 []byte) error {
	ret := m.ctrl.Call(m, "AddDefertx", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddDefertx indicates an expected call of AddDefertx
func (mr *MockTxPoolMockRecorder) AddDefertx(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDefertx", reflect.TypeOf((*MockTxPool)(nil).AddDefertx), arg0)
}

// AddLinkedNode mocks base method
func (m *MockTxPool) AddLinkedNode(arg0 *blockcache.BlockCacheNode) error {
	ret := m.ctrl.Call(m, "AddLinkedNode", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddLinkedNode indicates an expected call of AddLinkedNode
func (mr *MockTxPoolMockRecorder) AddLinkedNode(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLinkedNode", reflect.TypeOf((*MockTxPool)(nil).AddLinkedNode), arg0)
}

// AddTx mocks base method
func (m *MockTxPool) AddTx(arg0 *tx.Tx) error {
	ret := m.ctrl.Call(m, "AddTx", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddTx indicates an expected call of AddTx
func (mr *MockTxPoolMockRecorder) AddTx(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTx", reflect.TypeOf((*MockTxPool)(nil).AddTx), arg0)
}

// DelTx mocks base method
func (m *MockTxPool) DelTx(arg0 []byte) error {
	ret := m.ctrl.Call(m, "DelTx", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// DelTx indicates an expected call of DelTx
func (mr *MockTxPoolMockRecorder) DelTx(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelTx", reflect.TypeOf((*MockTxPool)(nil).DelTx), arg0)
}

// ExistTxs mocks base method
func (m *MockTxPool) ExistTxs(arg0 []byte, arg1 *block.Block) bool {
	ret := m.ctrl.Call(m, "ExistTxs", arg0, arg1)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExistTxs indicates an expected call of ExistTxs
func (mr *MockTxPoolMockRecorder) ExistTxs(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistTxs", reflect.TypeOf((*MockTxPool)(nil).ExistTxs), arg0, arg1)
}

// GetFromChain mocks base method
func (m *MockTxPool) GetFromChain(arg0 []byte) (*tx.Tx, *tx.TxReceipt, error) {
	ret := m.ctrl.Call(m, "GetFromChain", arg0)
	ret0, _ := ret[0].(*tx.Tx)
	ret1, _ := ret[1].(*tx.TxReceipt)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetFromChain indicates an expected call of GetFromChain
func (mr *MockTxPoolMockRecorder) GetFromChain(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFromChain", reflect.TypeOf((*MockTxPool)(nil).GetFromChain), arg0)
}

// GetFromPending mocks base method
func (m *MockTxPool) GetFromPending(arg0 []byte) (*tx.Tx, error) {
	ret := m.ctrl.Call(m, "GetFromPending", arg0)
	ret0, _ := ret[0].(*tx.Tx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFromPending indicates an expected call of GetFromPending
func (mr *MockTxPoolMockRecorder) GetFromPending(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFromPending", reflect.TypeOf((*MockTxPool)(nil).GetFromPending), arg0)
}

// PendingTx mocks base method
func (m *MockTxPool) PendingTx() (*txpool.SortedTxMap, *blockcache.BlockCacheNode) {
	ret := m.ctrl.Call(m, "PendingTx")
	ret0, _ := ret[0].(*txpool.SortedTxMap)
	ret1, _ := ret[1].(*blockcache.BlockCacheNode)
	return ret0, ret1
}

// PendingTx indicates an expected call of PendingTx
func (mr *MockTxPoolMockRecorder) PendingTx() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingTx", reflect.TypeOf((*MockTxPool)(nil).PendingTx))
}

// Start mocks base method
func (m *MockTxPool) Start() error {
	ret := m.ctrl.Call(m, "Start")
	ret0, _ := ret[0].(error)
	return ret0
}

// Start indicates an expected call of Start
func (mr *MockTxPoolMockRecorder) Start() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockTxPool)(nil).Start))
}

// Stop mocks base method
func (m *MockTxPool) Stop() {
	m.ctrl.Call(m, "Stop")
}

// Stop indicates an expected call of Stop
func (mr *MockTxPoolMockRecorder) Stop() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockTxPool)(nil).Stop))
}