decred.org/dcrwallet/v3@v3.1.0/wallet/udb/txcommon_test.go (about)

     1  // Copyright (c) 2016-2017 The Decred developers
     2  // Use of this source code is governed by an ISC
     3  // license that can be found in the LICENSE file.
     4  
     5  package udb
     6  
     7  import (
     8  	"bytes"
     9  	"os"
    10  	"testing"
    11  	"time"
    12  
    13  	_ "decred.org/dcrwallet/v3/wallet/drivers/bdb"
    14  	"decred.org/dcrwallet/v3/wallet/walletdb"
    15  	"github.com/decred/dcrd/chaincfg/chainhash"
    16  	"github.com/decred/dcrd/chaincfg/v3"
    17  	gcs2 "github.com/decred/dcrd/gcs/v4"
    18  	"github.com/decred/dcrd/gcs/v4/blockcf2"
    19  	"github.com/decred/dcrd/wire"
    20  )
    21  
    22  func tempDB(t *testing.T) (db walletdb.DB, teardown func()) {
    23  	f, err := os.CreateTemp("", "udb")
    24  	if err != nil {
    25  		t.Fatal(err)
    26  	}
    27  	f.Close()
    28  	db, err = walletdb.Create("bdb", f.Name())
    29  	if err != nil {
    30  		t.Fatal(err)
    31  	}
    32  	teardown = func() {
    33  		db.Close()
    34  		os.Remove(f.Name())
    35  	}
    36  	return
    37  }
    38  
    39  type blockGenerator struct {
    40  	lastHash   chainhash.Hash
    41  	lastHeight int32
    42  }
    43  
    44  func makeBlockGenerator() blockGenerator {
    45  	return blockGenerator{lastHash: chaincfg.TestNet3Params().GenesisHash}
    46  }
    47  
    48  func (g *blockGenerator) generate(voteBits uint16) *wire.BlockHeader {
    49  	h := &wire.BlockHeader{
    50  		PrevBlock: g.lastHash,
    51  		VoteBits:  voteBits,
    52  		Height:    uint32(g.lastHeight + 1),
    53  	}
    54  	g.lastHash = h.BlockHash()
    55  	g.lastHeight++
    56  	return h
    57  }
    58  
    59  func makeHeaderData(h *wire.BlockHeader) BlockHeaderData {
    60  	var b bytes.Buffer
    61  	b.Grow(wire.MaxBlockHeaderPayload)
    62  	err := h.Serialize(&b)
    63  	if err != nil {
    64  		panic(err)
    65  	}
    66  	d := BlockHeaderData{BlockHash: h.BlockHash()}
    67  	copy(d.SerializedHeader[:], b.Bytes())
    68  	return d
    69  }
    70  
    71  func makeHeaderDataSlice(headers ...*wire.BlockHeader) []BlockHeaderData {
    72  	data := make([]BlockHeaderData, 0, len(headers))
    73  	for _, h := range headers {
    74  		data = append(data, makeHeaderData(h))
    75  	}
    76  	return data
    77  }
    78  
    79  func emptyFilters(n int) []*gcs2.FilterV2 {
    80  	f := make([]*gcs2.FilterV2, n)
    81  	for i := range f {
    82  		f[i], _ = gcs2.FromBytesV2(blockcf2.B, blockcf2.M, nil)
    83  	}
    84  	return f
    85  }
    86  
    87  func makeBlockMeta(h *wire.BlockHeader) *BlockMeta {
    88  	return &BlockMeta{
    89  		Block: Block{
    90  			Hash:   h.BlockHash(),
    91  			Height: int32(h.Height),
    92  		},
    93  		Time: time.Time{},
    94  	}
    95  }
    96  
    97  func decodeHash(reversedHash string) *chainhash.Hash {
    98  	h, err := chainhash.NewHashFromStr(reversedHash)
    99  	if err != nil {
   100  		panic(err)
   101  	}
   102  	return h
   103  }