forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-20 10:52:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

eth/tracers: fix testcase

Browse source 
Signed-off-by: jsvisa <delweng@gmail.com>
This commit is contained in:
jsvisa 2023-11-03 17:18:13 +08:00
parent a691c08c44
commit a5d05ad71f
1 changed files with 41 additions and 15 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
eth/tracers/api_test.go
View file

@ -200,24 +200,28 @@ func TestTraceCall(t *testing.T) {
} }
genBlocks := 10 genBlocks := 10
signer := types.HomesteadSigner{} signer := types.HomesteadSigner{}
nonce := uint64(0)
backend := newTestBackend(t, genBlocks, genesis, func(i int, b *core.BlockGen) { backend := newTestBackend(t, genBlocks, genesis, func(i int, b *core.BlockGen) {
// Transfer from account[0] to account[1] // Transfer from account[0] to account[1]
// value: 1000 wei // value: 1000 wei
// fee: 0 wei // fee: 0 wei
tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, big.NewInt(1000), params.TxGas, b.BaseFee(), nil), signer, accounts[0].key) tx, _ := types.SignTx(types.NewTransaction(nonce, accounts[1].addr, big.NewInt(1000), params.TxGas, b.BaseFee(), nil), signer, accounts[0].key)
b.AddTx(tx) b.AddTx(tx)
nonce++
if i == genBlocks-1 { if i == genBlocks-2 {
tx, _ := types.SignTx(types.NewTransaction(uint64(i)+1, accounts[2].addr, big.NewInt(1000), params.TxGas, b.BaseFee(), nil), signer, accounts[0].key) // Transfer from account[0] to account[2]
tx, _ = types.SignTx(types.NewTransaction(nonce, accounts[2].addr, big.NewInt(1000), params.TxGas, b.BaseFee(), nil), signer, accounts[0].key)
b.AddTx(tx) b.AddTx(tx)
nonce++
// Transfer from account[0] to account[1] again
tx, _ = types.SignTx(types.NewTransaction(nonce, accounts[1].addr, big.NewInt(1000), params.TxGas, b.BaseFee(), nil), signer, accounts[0].key)
b.AddTx(tx)
nonce++
} }
}) })
// for i := 0; i <= genBlocks; i++ {
// block := backend.chain.GetBlockByNumber(uint64(i))
// fmt.Printf(".......block(%s) %d -> %d \n", block.Hash().String(), i, block.Transactions().Len())
// }
uintPtr := func(i int) *hexutil.Uint { x := hexutil.Uint(i); return &x } uintPtr := func(i int) *hexutil.Uint { x := hexutil.Uint(i); return &x }
defer backend.teardown() defer backend.teardown()
@ -253,26 +257,48 @@ func TestTraceCall(t *testing.T) {
expectErr: nil, expectErr: nil,
expect: `{"gas":21000,"failed":false,"returnValue":"","structLogs":[]}`, expect: `{"gas":21000,"failed":false,"returnValue":"","structLogs":[]}`,
}, },
// Standard JSON trace upon the head, plain transfer. // Upon the last state, default to the post block's state
{ {
blockNumber: rpc.BlockNumber(genBlocks), blockNumber: rpc.BlockNumber(genBlocks - 1),
call: ethapi.TransactionArgs{
From: &accounts[2].addr,
To: &accounts[0].addr,
Value: (*hexutil.Big)(new(big.Int).Add(big.NewInt(params.Ether), big.NewInt(100))),
},
config: nil,
expect: `{"gas":21000,"failed":false,"returnValue":"","structLogs":[]}`,
},
// Before the first transaction, should be failed
{
blockNumber: rpc.BlockNumber(genBlocks - 1),
call: ethapi.TransactionArgs{ call: ethapi.TransactionArgs{
From: &accounts[2].addr, From: &accounts[2].addr,
To: &accounts[0].addr, To: &accounts[0].addr,
Value: (*hexutil.Big)(new(big.Int).Add(big.NewInt(params.Ether), big.NewInt(100))), Value: (*hexutil.Big)(new(big.Int).Add(big.NewInt(params.Ether), big.NewInt(100))),
}, },
config: &TraceCallConfig{TxIndex: uintPtr(0)}, config: &TraceCallConfig{TxIndex: uintPtr(0)},
expectErr: fmt.Errorf("insufficient funds for gas * price + value: address %s have 1000000000000000000 want 1000000000000000100", accounts[2].addr), expectErr: fmt.Errorf("tracing failed: insufficient funds for gas * price + value: address %s have 1000000000000000000 want 1000000000000000100", accounts[2].addr),
}, },
// Standard JSON trace upon the head + txindex, plain transfer. // Before the target transaction, should be failed
{ {
blockNumber: rpc.BlockNumber(genBlocks), blockNumber: rpc.BlockNumber(genBlocks - 1),
call: ethapi.TransactionArgs{ call: ethapi.TransactionArgs{
From: &accounts[2].addr, From: &accounts[2].addr,
To: &accounts[0].addr, To: &accounts[0].addr,
Value: (*hexutil.Big)(new(big.Int).Add(big.NewInt(params.Ether), big.NewInt(100))), Value: (*hexutil.Big)(new(big.Int).Add(big.NewInt(params.Ether), big.NewInt(100))),
}, },
config: &TraceCallConfig{TxIndex: uintPtr(1)}, config: &TraceCallConfig{TxIndex: uintPtr(1)},
expectErr: fmt.Errorf("tracing failed: insufficient funds for gas * price + value: address %s have 1000000000000000000 want 1000000000000000100", accounts[2].addr),
},
// After the target transaction, should be succeed
{
blockNumber: rpc.BlockNumber(genBlocks - 1),
call: ethapi.TransactionArgs{
From: &accounts[2].addr,
To: &accounts[0].addr,
Value: (*hexutil.Big)(new(big.Int).Add(big.NewInt(params.Ether), big.NewInt(100))),
},
config: &TraceCallConfig{TxIndex: uintPtr(2)},
expectErr: nil, expectErr: nil,
expect: `{"gas":21000,"failed":false,"returnValue":"","structLogs":[]}`, expect: `{"gas":21000,"failed":false,"returnValue":"","structLogs":[]}`,
}, },
@ -333,8 +359,8 @@ func TestTraceCall(t *testing.T) {
t.Errorf("test %d: expect error %v, got nothing", i, testspec.expectErr) t.Errorf("test %d: expect error %v, got nothing", i, testspec.expectErr)
continue continue
} }
if !reflect.DeepEqual(err, testspec.expectErr) { if !reflect.DeepEqual(err.Error(), testspec.expectErr.Error()) {
t.Errorf("test %d: error mismatch, want %v, got %v", i, testspec.expectErr, err) t.Errorf("test %d: error mismatch, want '%v', got '%v'", i, testspec.expectErr, err)
} }
} else { } else {
if err != nil { if err != nil {