77913ad2e8
This modifies the blockchain.ProcessBlock function to return an additional boolean as the first parameter which indicates whether or not the block ended up on the main chain. This is primarily useful for upcoming test code that needs to be able to tell the difference between a block accepted to a side chain and a block that either extends the main chain or causes a reorganize that causes it to become the main chain. However, it is also useful for the addblock utility since it allows a better error in the case a file with out of order blocks is provided.
133 lines
3.2 KiB
Go
133 lines
3.2 KiB
Go
// Copyright (c) 2013-2014 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package blockchain_test
|
|
|
|
import (
|
|
"compress/bzip2"
|
|
"encoding/binary"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/btcsuite/btcd/blockchain"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/btcsuite/btcutil"
|
|
)
|
|
|
|
// TestReorganization loads a set of test blocks which force a chain
|
|
// reorganization to test the block chain handling code.
|
|
// The test blocks were originally from a post on the bitcoin talk forums:
|
|
// https://bitcointalk.org/index.php?topic=46370.msg577556#msg577556
|
|
func TestReorganization(t *testing.T) {
|
|
// Intentionally load the side chain blocks out of order to ensure
|
|
// orphans are handled properly along with chain reorganization.
|
|
testFiles := []string{
|
|
"blk_0_to_4.dat.bz2",
|
|
"blk_4A.dat.bz2",
|
|
"blk_5A.dat.bz2",
|
|
"blk_3A.dat.bz2",
|
|
}
|
|
|
|
var blocks []*btcutil.Block
|
|
for _, file := range testFiles {
|
|
blockTmp, err := loadBlocks(file)
|
|
if err != nil {
|
|
t.Errorf("Error loading file: %v\n", err)
|
|
}
|
|
for _, block := range blockTmp {
|
|
blocks = append(blocks, block)
|
|
}
|
|
}
|
|
|
|
t.Logf("Number of blocks: %v\n", len(blocks))
|
|
|
|
// Create a new database and chain instance to run tests against.
|
|
chain, teardownFunc, err := chainSetup("reorg")
|
|
if err != nil {
|
|
t.Errorf("Failed to setup chain instance: %v", err)
|
|
return
|
|
}
|
|
defer teardownFunc()
|
|
|
|
// Since we're not dealing with the real block chain, disable
|
|
// checkpoints and set the coinbase maturity to 1.
|
|
chain.DisableCheckpoints(true)
|
|
chain.TstSetCoinbaseMaturity(1)
|
|
|
|
expectedOrphans := map[int]struct{}{5: {}, 6: {}}
|
|
for i := 1; i < len(blocks); i++ {
|
|
_, isOrphan, err := chain.ProcessBlock(blocks[i], blockchain.BFNone)
|
|
if err != nil {
|
|
t.Errorf("ProcessBlock fail on block %v: %v\n", i, err)
|
|
return
|
|
}
|
|
if _, ok := expectedOrphans[i]; !ok && isOrphan {
|
|
t.Errorf("ProcessBlock incorrectly returned block %v "+
|
|
"is an orphan\n", i)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// loadBlocks reads files containing bitcoin block data (gzipped but otherwise
|
|
// in the format bitcoind writes) from disk and returns them as an array of
|
|
// btcutil.Block. This is largely borrowed from the test code in btcdb.
|
|
func loadBlocks(filename string) (blocks []*btcutil.Block, err error) {
|
|
filename = filepath.Join("testdata/", filename)
|
|
|
|
var network = wire.MainNet
|
|
var dr io.Reader
|
|
var fi io.ReadCloser
|
|
|
|
fi, err = os.Open(filename)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if strings.HasSuffix(filename, ".bz2") {
|
|
dr = bzip2.NewReader(fi)
|
|
} else {
|
|
dr = fi
|
|
}
|
|
defer fi.Close()
|
|
|
|
var block *btcutil.Block
|
|
|
|
err = nil
|
|
for height := int64(1); err == nil; height++ {
|
|
var rintbuf uint32
|
|
err = binary.Read(dr, binary.LittleEndian, &rintbuf)
|
|
if err == io.EOF {
|
|
// hit end of file at expected offset: no warning
|
|
height--
|
|
err = nil
|
|
break
|
|
}
|
|
if err != nil {
|
|
break
|
|
}
|
|
if rintbuf != uint32(network) {
|
|
break
|
|
}
|
|
err = binary.Read(dr, binary.LittleEndian, &rintbuf)
|
|
blocklen := rintbuf
|
|
|
|
rbytes := make([]byte, blocklen)
|
|
|
|
// read block
|
|
dr.Read(rbytes)
|
|
|
|
block, err = btcutil.NewBlockFromBytes(rbytes)
|
|
if err != nil {
|
|
return
|
|
}
|
|
blocks = append(blocks, block)
|
|
}
|
|
|
|
return
|
|
}
|