aboutsummaryrefslogtreecommitdiffstats
path: root/chain/chain_manager_test.go
blob: 0314914a9ff6746c4f5cc5f1d30eb0f45ad1774e (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package chain

import (
    "fmt"
    "math/big"
    "testing"
    "time"

    "github.com/ethereum/go-ethereum/chain/types"
    "github.com/ethereum/go-ethereum/ethdb"
    "github.com/ethereum/go-ethereum/ethutil"
    "github.com/ethereum/go-ethereum/state"
)

var TD *big.Int

func init() {
    ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
    ethutil.Config.Db, _ = ethdb.NewMemDatabase()
}

type fakeproc struct {
}

func (self fakeproc) ProcessWithParent(a, b *types.Block) (*big.Int, state.Messages, error) {
    TD = new(big.Int).Add(TD, big.NewInt(1))
    return TD, nil, nil
}

func makechain(cman *ChainManager, max int) *BlockChain {
    blocks := make(types.Blocks, max)
    for i := 0; i < max; i++ {
        addr := ethutil.LeftPadBytes([]byte{byte(i)}, 20)
        block := cman.NewBlock(addr)
        if i != 0 {
            cman.CurrentBlock = blocks[i-1]
        }
        blocks[i] = block
    }
    return NewChain(blocks)
}

func TestLongerFork(t *testing.T) {
    cman := NewChainManager()
    cman.SetProcessor(fakeproc{})

    TD = big.NewInt(1)
    chainA := makechain(cman, 5)

    TD = big.NewInt(1)
    chainB := makechain(cman, 10)

    td, err := cman.TestChain(chainA)
    if err != nil {
        t.Error("unable to create new TD from chainA:", err)
    }
    cman.TD = td

    _, err = cman.TestChain(chainB)
    if err != nil {
        t.Error("expected chainB not to give errors:", err)
    }
}

func TestEqualFork(t *testing.T) {
    cman := NewChainManager()
    cman.SetProcessor(fakeproc{})

    TD = big.NewInt(1)
    chainA := makechain(cman, 5)

    TD = big.NewInt(2)
    chainB := makechain(cman, 5)

    td, err := cman.TestChain(chainA)
    if err != nil {
        t.Error("unable to create new TD from chainA:", err)
    }
    cman.TD = td

    _, err = cman.TestChain(chainB)
    if err != nil {
        t.Error("expected chainB not to give errors:", err)
    }
}

func TestBrokenChain(t *testing.T) {
    cman := NewChainManager()
    cman.SetProcessor(fakeproc{})

    TD = big.NewInt(1)
    chain := makechain(cman, 5)
    chain.Remove(chain.Front())

    _, err := cman.TestChain(chain)
    if err == nil {
        t.Error("expected broken chain to return error")
    }
}

func BenchmarkChainTesting(b *testing.B) {
    const chainlen = 1000

    ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
    ethutil.Config.Db, _ = ethdb.NewMemDatabase()

    cman := NewChainManager()
    cman.SetProcessor(fakeproc{})

    TD = big.NewInt(1)
    chain := makechain(cman, chainlen)

    stime := time.Now()
    cman.TestChain(chain)
    fmt.Println(chainlen, "took", time.Since(stime))
}