918 lines
35 KiB
Go
918 lines
35 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: rpc/chain/client.go
|
|
|
|
// Package mock_client is a generated GoMock package.
|
|
package mock_client
|
|
|
|
import (
|
|
context "context"
|
|
big "math/big"
|
|
reflect "reflect"
|
|
|
|
gomock "github.com/golang/mock/gomock"
|
|
|
|
ethereum "github.com/ethereum/go-ethereum"
|
|
common "github.com/ethereum/go-ethereum/common"
|
|
types "github.com/ethereum/go-ethereum/core/types"
|
|
rpc "github.com/ethereum/go-ethereum/rpc"
|
|
chain "github.com/status-im/status-go/rpc/chain"
|
|
)
|
|
|
|
// MockBatchCallClient is a mock of BatchCallClient interface.
|
|
type MockBatchCallClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockBatchCallClientMockRecorder
|
|
}
|
|
|
|
// MockBatchCallClientMockRecorder is the mock recorder for MockBatchCallClient.
|
|
type MockBatchCallClientMockRecorder struct {
|
|
mock *MockBatchCallClient
|
|
}
|
|
|
|
// NewMockBatchCallClient creates a new mock instance.
|
|
func NewMockBatchCallClient(ctrl *gomock.Controller) *MockBatchCallClient {
|
|
mock := &MockBatchCallClient{ctrl: ctrl}
|
|
mock.recorder = &MockBatchCallClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockBatchCallClient) EXPECT() *MockBatchCallClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BatchCallContext mocks base method.
|
|
func (m *MockBatchCallClient) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BatchCallContext", ctx, b)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// BatchCallContext indicates an expected call of BatchCallContext.
|
|
func (mr *MockBatchCallClientMockRecorder) BatchCallContext(ctx, b interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallContext", reflect.TypeOf((*MockBatchCallClient)(nil).BatchCallContext), ctx, b)
|
|
}
|
|
|
|
// MockChainInterface is a mock of ChainInterface interface.
|
|
type MockChainInterface struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockChainInterfaceMockRecorder
|
|
}
|
|
|
|
// MockChainInterfaceMockRecorder is the mock recorder for MockChainInterface.
|
|
type MockChainInterfaceMockRecorder struct {
|
|
mock *MockChainInterface
|
|
}
|
|
|
|
// NewMockChainInterface creates a new mock instance.
|
|
func NewMockChainInterface(ctrl *gomock.Controller) *MockChainInterface {
|
|
mock := &MockChainInterface{ctrl: ctrl}
|
|
mock.recorder = &MockChainInterfaceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockChainInterface) EXPECT() *MockChainInterfaceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BalanceAt mocks base method.
|
|
func (m *MockChainInterface) BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BalanceAt", ctx, account, blockNumber)
|
|
ret0, _ := ret[0].(*big.Int)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// BalanceAt indicates an expected call of BalanceAt.
|
|
func (mr *MockChainInterfaceMockRecorder) BalanceAt(ctx, account, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceAt", reflect.TypeOf((*MockChainInterface)(nil).BalanceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// BatchCallContext mocks base method.
|
|
func (m *MockChainInterface) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BatchCallContext", ctx, b)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// BatchCallContext indicates an expected call of BatchCallContext.
|
|
func (mr *MockChainInterfaceMockRecorder) BatchCallContext(ctx, b interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallContext", reflect.TypeOf((*MockChainInterface)(nil).BatchCallContext), ctx, b)
|
|
}
|
|
|
|
// BlockByHash mocks base method.
|
|
func (m *MockChainInterface) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BlockByHash", ctx, hash)
|
|
ret0, _ := ret[0].(*types.Block)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// BlockByHash indicates an expected call of BlockByHash.
|
|
func (mr *MockChainInterfaceMockRecorder) BlockByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockChainInterface)(nil).BlockByHash), ctx, hash)
|
|
}
|
|
|
|
// BlockByNumber mocks base method.
|
|
func (m *MockChainInterface) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BlockByNumber", ctx, number)
|
|
ret0, _ := ret[0].(*types.Block)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// BlockByNumber indicates an expected call of BlockByNumber.
|
|
func (mr *MockChainInterfaceMockRecorder) BlockByNumber(ctx, number interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockChainInterface)(nil).BlockByNumber), ctx, number)
|
|
}
|
|
|
|
// BlockNumber mocks base method.
|
|
func (m *MockChainInterface) BlockNumber(ctx context.Context) (uint64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BlockNumber", ctx)
|
|
ret0, _ := ret[0].(uint64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// BlockNumber indicates an expected call of BlockNumber.
|
|
func (mr *MockChainInterfaceMockRecorder) BlockNumber(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockNumber", reflect.TypeOf((*MockChainInterface)(nil).BlockNumber), ctx)
|
|
}
|
|
|
|
// CallBlockHashByTransaction mocks base method.
|
|
func (m *MockChainInterface) CallBlockHashByTransaction(ctx context.Context, blockNumber *big.Int, index uint) (common.Hash, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CallBlockHashByTransaction", ctx, blockNumber, index)
|
|
ret0, _ := ret[0].(common.Hash)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CallBlockHashByTransaction indicates an expected call of CallBlockHashByTransaction.
|
|
func (mr *MockChainInterfaceMockRecorder) CallBlockHashByTransaction(ctx, blockNumber, index interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallBlockHashByTransaction", reflect.TypeOf((*MockChainInterface)(nil).CallBlockHashByTransaction), ctx, blockNumber, index)
|
|
}
|
|
|
|
// CallContext mocks base method.
|
|
func (m *MockChainInterface) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, result, method}
|
|
for _, a := range args {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "CallContext", varargs...)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CallContext indicates an expected call of CallContext.
|
|
func (mr *MockChainInterfaceMockRecorder) CallContext(ctx, result, method interface{}, args ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, result, method}, args...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContext", reflect.TypeOf((*MockChainInterface)(nil).CallContext), varargs...)
|
|
}
|
|
|
|
// CallContract mocks base method.
|
|
func (m *MockChainInterface) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CallContract", ctx, call, blockNumber)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CallContract indicates an expected call of CallContract.
|
|
func (mr *MockChainInterfaceMockRecorder) CallContract(ctx, call, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockChainInterface)(nil).CallContract), ctx, call, blockNumber)
|
|
}
|
|
|
|
// CodeAt mocks base method.
|
|
func (m *MockChainInterface) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CodeAt", ctx, contract, blockNumber)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CodeAt indicates an expected call of CodeAt.
|
|
func (mr *MockChainInterfaceMockRecorder) CodeAt(ctx, contract, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockChainInterface)(nil).CodeAt), ctx, contract, blockNumber)
|
|
}
|
|
|
|
// FilterLogs mocks base method.
|
|
func (m *MockChainInterface) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FilterLogs", ctx, q)
|
|
ret0, _ := ret[0].([]types.Log)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FilterLogs indicates an expected call of FilterLogs.
|
|
func (mr *MockChainInterfaceMockRecorder) FilterLogs(ctx, q interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterLogs", reflect.TypeOf((*MockChainInterface)(nil).FilterLogs), ctx, q)
|
|
}
|
|
|
|
// GetBaseFeeFromBlock mocks base method.
|
|
func (m *MockChainInterface) GetBaseFeeFromBlock(ctx context.Context, blockNumber *big.Int) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetBaseFeeFromBlock", ctx, blockNumber)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetBaseFeeFromBlock indicates an expected call of GetBaseFeeFromBlock.
|
|
func (mr *MockChainInterfaceMockRecorder) GetBaseFeeFromBlock(ctx, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBaseFeeFromBlock", reflect.TypeOf((*MockChainInterface)(nil).GetBaseFeeFromBlock), ctx, blockNumber)
|
|
}
|
|
|
|
// HeaderByHash mocks base method.
|
|
func (m *MockChainInterface) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HeaderByHash", ctx, hash)
|
|
ret0, _ := ret[0].(*types.Header)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// HeaderByHash indicates an expected call of HeaderByHash.
|
|
func (mr *MockChainInterfaceMockRecorder) HeaderByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockChainInterface)(nil).HeaderByHash), ctx, hash)
|
|
}
|
|
|
|
// HeaderByNumber mocks base method.
|
|
func (m *MockChainInterface) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HeaderByNumber", ctx, number)
|
|
ret0, _ := ret[0].(*types.Header)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// HeaderByNumber indicates an expected call of HeaderByNumber.
|
|
func (mr *MockChainInterfaceMockRecorder) HeaderByNumber(ctx, number interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockChainInterface)(nil).HeaderByNumber), ctx, number)
|
|
}
|
|
|
|
// NetworkID mocks base method.
|
|
func (m *MockChainInterface) NetworkID() uint64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "NetworkID")
|
|
ret0, _ := ret[0].(uint64)
|
|
return ret0
|
|
}
|
|
|
|
// NetworkID indicates an expected call of NetworkID.
|
|
func (mr *MockChainInterfaceMockRecorder) NetworkID() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkID", reflect.TypeOf((*MockChainInterface)(nil).NetworkID))
|
|
}
|
|
|
|
// NonceAt mocks base method.
|
|
func (m *MockChainInterface) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "NonceAt", ctx, account, blockNumber)
|
|
ret0, _ := ret[0].(uint64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// NonceAt indicates an expected call of NonceAt.
|
|
func (mr *MockChainInterfaceMockRecorder) NonceAt(ctx, account, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NonceAt", reflect.TypeOf((*MockChainInterface)(nil).NonceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// ToBigInt mocks base method.
|
|
func (m *MockChainInterface) ToBigInt() *big.Int {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ToBigInt")
|
|
ret0, _ := ret[0].(*big.Int)
|
|
return ret0
|
|
}
|
|
|
|
// ToBigInt indicates an expected call of ToBigInt.
|
|
func (mr *MockChainInterfaceMockRecorder) ToBigInt() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToBigInt", reflect.TypeOf((*MockChainInterface)(nil).ToBigInt))
|
|
}
|
|
|
|
// TransactionByHash mocks base method.
|
|
func (m *MockChainInterface) TransactionByHash(ctx context.Context, hash common.Hash) (*types.Transaction, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TransactionByHash", ctx, hash)
|
|
ret0, _ := ret[0].(*types.Transaction)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// TransactionByHash indicates an expected call of TransactionByHash.
|
|
func (mr *MockChainInterfaceMockRecorder) TransactionByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByHash", reflect.TypeOf((*MockChainInterface)(nil).TransactionByHash), ctx, hash)
|
|
}
|
|
|
|
// TransactionReceipt mocks base method.
|
|
func (m *MockChainInterface) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TransactionReceipt", ctx, txHash)
|
|
ret0, _ := ret[0].(*types.Receipt)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TransactionReceipt indicates an expected call of TransactionReceipt.
|
|
func (mr *MockChainInterfaceMockRecorder) TransactionReceipt(ctx, txHash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionReceipt", reflect.TypeOf((*MockChainInterface)(nil).TransactionReceipt), ctx, txHash)
|
|
}
|
|
|
|
// MockClientInterface is a mock of ClientInterface interface.
|
|
type MockClientInterface struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockClientInterfaceMockRecorder
|
|
}
|
|
|
|
// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
|
|
type MockClientInterfaceMockRecorder struct {
|
|
mock *MockClientInterface
|
|
}
|
|
|
|
// NewMockClientInterface creates a new mock instance.
|
|
func NewMockClientInterface(ctrl *gomock.Controller) *MockClientInterface {
|
|
mock := &MockClientInterface{ctrl: ctrl}
|
|
mock.recorder = &MockClientInterfaceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockClientInterface) EXPECT() *MockClientInterfaceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BalanceAt mocks base method.
|
|
func (m *MockClientInterface) BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BalanceAt", ctx, account, blockNumber)
|
|
ret0, _ := ret[0].(*big.Int)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// BalanceAt indicates an expected call of BalanceAt.
|
|
func (mr *MockClientInterfaceMockRecorder) BalanceAt(ctx, account, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BalanceAt", reflect.TypeOf((*MockClientInterface)(nil).BalanceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// BatchCallContext mocks base method.
|
|
func (m *MockClientInterface) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BatchCallContext", ctx, b)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// BatchCallContext indicates an expected call of BatchCallContext.
|
|
func (mr *MockClientInterfaceMockRecorder) BatchCallContext(ctx, b interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCallContext", reflect.TypeOf((*MockClientInterface)(nil).BatchCallContext), ctx, b)
|
|
}
|
|
|
|
// BlockByHash mocks base method.
|
|
func (m *MockClientInterface) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BlockByHash", ctx, hash)
|
|
ret0, _ := ret[0].(*types.Block)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// BlockByHash indicates an expected call of BlockByHash.
|
|
func (mr *MockClientInterfaceMockRecorder) BlockByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockClientInterface)(nil).BlockByHash), ctx, hash)
|
|
}
|
|
|
|
// BlockByNumber mocks base method.
|
|
func (m *MockClientInterface) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BlockByNumber", ctx, number)
|
|
ret0, _ := ret[0].(*types.Block)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// BlockByNumber indicates an expected call of BlockByNumber.
|
|
func (mr *MockClientInterfaceMockRecorder) BlockByNumber(ctx, number interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockClientInterface)(nil).BlockByNumber), ctx, number)
|
|
}
|
|
|
|
// BlockNumber mocks base method.
|
|
func (m *MockClientInterface) BlockNumber(ctx context.Context) (uint64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BlockNumber", ctx)
|
|
ret0, _ := ret[0].(uint64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// BlockNumber indicates an expected call of BlockNumber.
|
|
func (mr *MockClientInterfaceMockRecorder) BlockNumber(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockNumber", reflect.TypeOf((*MockClientInterface)(nil).BlockNumber), ctx)
|
|
}
|
|
|
|
// CallBlockHashByTransaction mocks base method.
|
|
func (m *MockClientInterface) CallBlockHashByTransaction(ctx context.Context, blockNumber *big.Int, index uint) (common.Hash, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CallBlockHashByTransaction", ctx, blockNumber, index)
|
|
ret0, _ := ret[0].(common.Hash)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CallBlockHashByTransaction indicates an expected call of CallBlockHashByTransaction.
|
|
func (mr *MockClientInterfaceMockRecorder) CallBlockHashByTransaction(ctx, blockNumber, index interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallBlockHashByTransaction", reflect.TypeOf((*MockClientInterface)(nil).CallBlockHashByTransaction), ctx, blockNumber, index)
|
|
}
|
|
|
|
// CallContext mocks base method.
|
|
func (m *MockClientInterface) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{ctx, result, method}
|
|
for _, a := range args {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "CallContext", varargs...)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CallContext indicates an expected call of CallContext.
|
|
func (mr *MockClientInterfaceMockRecorder) CallContext(ctx, result, method interface{}, args ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{ctx, result, method}, args...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContext", reflect.TypeOf((*MockClientInterface)(nil).CallContext), varargs...)
|
|
}
|
|
|
|
// CallContract mocks base method.
|
|
func (m *MockClientInterface) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CallContract", ctx, call, blockNumber)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CallContract indicates an expected call of CallContract.
|
|
func (mr *MockClientInterfaceMockRecorder) CallContract(ctx, call, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockClientInterface)(nil).CallContract), ctx, call, blockNumber)
|
|
}
|
|
|
|
// CodeAt mocks base method.
|
|
func (m *MockClientInterface) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CodeAt", ctx, contract, blockNumber)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CodeAt indicates an expected call of CodeAt.
|
|
func (mr *MockClientInterfaceMockRecorder) CodeAt(ctx, contract, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockClientInterface)(nil).CodeAt), ctx, contract, blockNumber)
|
|
}
|
|
|
|
// EstimateGas mocks base method.
|
|
func (m *MockClientInterface) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "EstimateGas", ctx, call)
|
|
ret0, _ := ret[0].(uint64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// EstimateGas indicates an expected call of EstimateGas.
|
|
func (mr *MockClientInterfaceMockRecorder) EstimateGas(ctx, call interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateGas", reflect.TypeOf((*MockClientInterface)(nil).EstimateGas), ctx, call)
|
|
}
|
|
|
|
// FilterLogs mocks base method.
|
|
func (m *MockClientInterface) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FilterLogs", ctx, q)
|
|
ret0, _ := ret[0].([]types.Log)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FilterLogs indicates an expected call of FilterLogs.
|
|
func (mr *MockClientInterfaceMockRecorder) FilterLogs(ctx, q interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterLogs", reflect.TypeOf((*MockClientInterface)(nil).FilterLogs), ctx, q)
|
|
}
|
|
|
|
// GetBaseFeeFromBlock mocks base method.
|
|
func (m *MockClientInterface) GetBaseFeeFromBlock(ctx context.Context, blockNumber *big.Int) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetBaseFeeFromBlock", ctx, blockNumber)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetBaseFeeFromBlock indicates an expected call of GetBaseFeeFromBlock.
|
|
func (mr *MockClientInterfaceMockRecorder) GetBaseFeeFromBlock(ctx, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBaseFeeFromBlock", reflect.TypeOf((*MockClientInterface)(nil).GetBaseFeeFromBlock), ctx, blockNumber)
|
|
}
|
|
|
|
// GetLimiter mocks base method.
|
|
func (m *MockClientInterface) GetLimiter() chain.RequestLimiter {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLimiter")
|
|
ret0, _ := ret[0].(chain.RequestLimiter)
|
|
return ret0
|
|
}
|
|
|
|
// GetLimiter indicates an expected call of GetLimiter.
|
|
func (mr *MockClientInterfaceMockRecorder) GetLimiter() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLimiter", reflect.TypeOf((*MockClientInterface)(nil).GetLimiter))
|
|
}
|
|
|
|
// GetWalletNotifier mocks base method.
|
|
func (m *MockClientInterface) GetWalletNotifier() func(uint64, string) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWalletNotifier")
|
|
ret0, _ := ret[0].(func(uint64, string))
|
|
return ret0
|
|
}
|
|
|
|
// GetWalletNotifier indicates an expected call of GetWalletNotifier.
|
|
func (mr *MockClientInterfaceMockRecorder) GetWalletNotifier() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWalletNotifier", reflect.TypeOf((*MockClientInterface)(nil).GetWalletNotifier))
|
|
}
|
|
|
|
// HeaderByHash mocks base method.
|
|
func (m *MockClientInterface) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HeaderByHash", ctx, hash)
|
|
ret0, _ := ret[0].(*types.Header)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// HeaderByHash indicates an expected call of HeaderByHash.
|
|
func (mr *MockClientInterfaceMockRecorder) HeaderByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockClientInterface)(nil).HeaderByHash), ctx, hash)
|
|
}
|
|
|
|
// HeaderByNumber mocks base method.
|
|
func (m *MockClientInterface) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "HeaderByNumber", ctx, number)
|
|
ret0, _ := ret[0].(*types.Header)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// HeaderByNumber indicates an expected call of HeaderByNumber.
|
|
func (mr *MockClientInterfaceMockRecorder) HeaderByNumber(ctx, number interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockClientInterface)(nil).HeaderByNumber), ctx, number)
|
|
}
|
|
|
|
// IsConnected mocks base method.
|
|
func (m *MockClientInterface) IsConnected() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsConnected")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsConnected indicates an expected call of IsConnected.
|
|
func (mr *MockClientInterfaceMockRecorder) IsConnected() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockClientInterface)(nil).IsConnected))
|
|
}
|
|
|
|
// NetworkID mocks base method.
|
|
func (m *MockClientInterface) NetworkID() uint64 {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "NetworkID")
|
|
ret0, _ := ret[0].(uint64)
|
|
return ret0
|
|
}
|
|
|
|
// NetworkID indicates an expected call of NetworkID.
|
|
func (mr *MockClientInterfaceMockRecorder) NetworkID() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkID", reflect.TypeOf((*MockClientInterface)(nil).NetworkID))
|
|
}
|
|
|
|
// NonceAt mocks base method.
|
|
func (m *MockClientInterface) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "NonceAt", ctx, account, blockNumber)
|
|
ret0, _ := ret[0].(uint64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// NonceAt indicates an expected call of NonceAt.
|
|
func (mr *MockClientInterfaceMockRecorder) NonceAt(ctx, account, blockNumber interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NonceAt", reflect.TypeOf((*MockClientInterface)(nil).NonceAt), ctx, account, blockNumber)
|
|
}
|
|
|
|
// PendingCodeAt mocks base method.
|
|
func (m *MockClientInterface) PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "PendingCodeAt", ctx, account)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// PendingCodeAt indicates an expected call of PendingCodeAt.
|
|
func (mr *MockClientInterfaceMockRecorder) PendingCodeAt(ctx, account interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingCodeAt", reflect.TypeOf((*MockClientInterface)(nil).PendingCodeAt), ctx, account)
|
|
}
|
|
|
|
// PendingNonceAt mocks base method.
|
|
func (m *MockClientInterface) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "PendingNonceAt", ctx, account)
|
|
ret0, _ := ret[0].(uint64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// PendingNonceAt indicates an expected call of PendingNonceAt.
|
|
func (mr *MockClientInterfaceMockRecorder) PendingNonceAt(ctx, account interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingNonceAt", reflect.TypeOf((*MockClientInterface)(nil).PendingNonceAt), ctx, account)
|
|
}
|
|
|
|
// SendTransaction mocks base method.
|
|
func (m *MockClientInterface) SendTransaction(ctx context.Context, tx *types.Transaction) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SendTransaction", ctx, tx)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SendTransaction indicates an expected call of SendTransaction.
|
|
func (mr *MockClientInterfaceMockRecorder) SendTransaction(ctx, tx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransaction", reflect.TypeOf((*MockClientInterface)(nil).SendTransaction), ctx, tx)
|
|
}
|
|
|
|
// SetIsConnected mocks base method.
|
|
func (m *MockClientInterface) SetIsConnected(arg0 bool) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetIsConnected", arg0)
|
|
}
|
|
|
|
// SetIsConnected indicates an expected call of SetIsConnected.
|
|
func (mr *MockClientInterfaceMockRecorder) SetIsConnected(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsConnected", reflect.TypeOf((*MockClientInterface)(nil).SetIsConnected), arg0)
|
|
}
|
|
|
|
// SetLimiter mocks base method.
|
|
func (m *MockClientInterface) SetLimiter(arg0 chain.RequestLimiter) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetLimiter", arg0)
|
|
}
|
|
|
|
// SetLimiter indicates an expected call of SetLimiter.
|
|
func (mr *MockClientInterfaceMockRecorder) SetLimiter(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLimiter", reflect.TypeOf((*MockClientInterface)(nil).SetLimiter), arg0)
|
|
}
|
|
|
|
// SetWalletNotifier mocks base method.
|
|
func (m *MockClientInterface) SetWalletNotifier(notifier func(uint64, string)) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetWalletNotifier", notifier)
|
|
}
|
|
|
|
// SetWalletNotifier indicates an expected call of SetWalletNotifier.
|
|
func (mr *MockClientInterfaceMockRecorder) SetWalletNotifier(notifier interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWalletNotifier", reflect.TypeOf((*MockClientInterface)(nil).SetWalletNotifier), notifier)
|
|
}
|
|
|
|
// SubscribeFilterLogs mocks base method.
|
|
func (m *MockClientInterface) SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SubscribeFilterLogs", ctx, query, ch)
|
|
ret0, _ := ret[0].(ethereum.Subscription)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SubscribeFilterLogs indicates an expected call of SubscribeFilterLogs.
|
|
func (mr *MockClientInterfaceMockRecorder) SubscribeFilterLogs(ctx, query, ch interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeFilterLogs", reflect.TypeOf((*MockClientInterface)(nil).SubscribeFilterLogs), ctx, query, ch)
|
|
}
|
|
|
|
// SuggestGasPrice mocks base method.
|
|
func (m *MockClientInterface) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SuggestGasPrice", ctx)
|
|
ret0, _ := ret[0].(*big.Int)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SuggestGasPrice indicates an expected call of SuggestGasPrice.
|
|
func (mr *MockClientInterfaceMockRecorder) SuggestGasPrice(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasPrice", reflect.TypeOf((*MockClientInterface)(nil).SuggestGasPrice), ctx)
|
|
}
|
|
|
|
// SuggestGasTipCap mocks base method.
|
|
func (m *MockClientInterface) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SuggestGasTipCap", ctx)
|
|
ret0, _ := ret[0].(*big.Int)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SuggestGasTipCap indicates an expected call of SuggestGasTipCap.
|
|
func (mr *MockClientInterfaceMockRecorder) SuggestGasTipCap(ctx interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestGasTipCap", reflect.TypeOf((*MockClientInterface)(nil).SuggestGasTipCap), ctx)
|
|
}
|
|
|
|
// ToBigInt mocks base method.
|
|
func (m *MockClientInterface) ToBigInt() *big.Int {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ToBigInt")
|
|
ret0, _ := ret[0].(*big.Int)
|
|
return ret0
|
|
}
|
|
|
|
// ToBigInt indicates an expected call of ToBigInt.
|
|
func (mr *MockClientInterfaceMockRecorder) ToBigInt() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToBigInt", reflect.TypeOf((*MockClientInterface)(nil).ToBigInt))
|
|
}
|
|
|
|
// TransactionByHash mocks base method.
|
|
func (m *MockClientInterface) TransactionByHash(ctx context.Context, hash common.Hash) (*types.Transaction, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TransactionByHash", ctx, hash)
|
|
ret0, _ := ret[0].(*types.Transaction)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// TransactionByHash indicates an expected call of TransactionByHash.
|
|
func (mr *MockClientInterfaceMockRecorder) TransactionByHash(ctx, hash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByHash", reflect.TypeOf((*MockClientInterface)(nil).TransactionByHash), ctx, hash)
|
|
}
|
|
|
|
// TransactionReceipt mocks base method.
|
|
func (m *MockClientInterface) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TransactionReceipt", ctx, txHash)
|
|
ret0, _ := ret[0].(*types.Receipt)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TransactionReceipt indicates an expected call of TransactionReceipt.
|
|
func (mr *MockClientInterfaceMockRecorder) TransactionReceipt(ctx, txHash interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionReceipt", reflect.TypeOf((*MockClientInterface)(nil).TransactionReceipt), ctx, txHash)
|
|
}
|
|
|
|
// MockTagger is a mock of Tagger interface.
|
|
type MockTagger struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockTaggerMockRecorder
|
|
}
|
|
|
|
// MockTaggerMockRecorder is the mock recorder for MockTagger.
|
|
type MockTaggerMockRecorder struct {
|
|
mock *MockTagger
|
|
}
|
|
|
|
// NewMockTagger creates a new mock instance.
|
|
func NewMockTagger(ctrl *gomock.Controller) *MockTagger {
|
|
mock := &MockTagger{ctrl: ctrl}
|
|
mock.recorder = &MockTaggerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockTagger) EXPECT() *MockTaggerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// DeepCopyTag mocks base method.
|
|
func (m *MockTagger) DeepCopyTag() chain.Tagger {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeepCopyTag")
|
|
ret0, _ := ret[0].(chain.Tagger)
|
|
return ret0
|
|
}
|
|
|
|
// DeepCopyTag indicates an expected call of DeepCopyTag.
|
|
func (mr *MockTaggerMockRecorder) DeepCopyTag() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeepCopyTag", reflect.TypeOf((*MockTagger)(nil).DeepCopyTag))
|
|
}
|
|
|
|
// GroupTag mocks base method.
|
|
func (m *MockTagger) GroupTag() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GroupTag")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// GroupTag indicates an expected call of GroupTag.
|
|
func (mr *MockTaggerMockRecorder) GroupTag() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupTag", reflect.TypeOf((*MockTagger)(nil).GroupTag))
|
|
}
|
|
|
|
// SetGroupTag mocks base method.
|
|
func (m *MockTagger) SetGroupTag(tag string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetGroupTag", tag)
|
|
}
|
|
|
|
// SetGroupTag indicates an expected call of SetGroupTag.
|
|
func (mr *MockTaggerMockRecorder) SetGroupTag(tag interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGroupTag", reflect.TypeOf((*MockTagger)(nil).SetGroupTag), tag)
|
|
}
|
|
|
|
// SetTag mocks base method.
|
|
func (m *MockTagger) SetTag(tag string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "SetTag", tag)
|
|
}
|
|
|
|
// SetTag indicates an expected call of SetTag.
|
|
func (mr *MockTaggerMockRecorder) SetTag(tag interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTag", reflect.TypeOf((*MockTagger)(nil).SetTag), tag)
|
|
}
|
|
|
|
// Tag mocks base method.
|
|
func (m *MockTagger) Tag() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Tag")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// Tag indicates an expected call of Tag.
|
|
func (mr *MockTaggerMockRecorder) Tag() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tag", reflect.TypeOf((*MockTagger)(nil).Tag))
|
|
}
|