// Copyright 2018 The dexon-consensus Authors
// This file is part of the dexon-consensus library.
//
// The dexon-consensus library is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// The dexon-consensus library is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
// General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the dexon-consensus library. If not, see
// <http://www.gnu.org/licenses/>.
package dex
import (
"math/rand"
"reflect"
"sort"
"strings"
"testing"
coreCommon "github.com/dexon-foundation/dexon-consensus/common"
coreDb "github.com/dexon-foundation/dexon-consensus/core/db"
coreTypes "github.com/dexon-foundation/dexon-consensus/core/types"
)
type byHash []*coreTypes.Vote
func (v byHash) Len() int {
return len(v)
}
func (v byHash) Less(i int, j int) bool {
return strings.Compare(v[i].BlockHash.String(), v[j].BlockHash.String()) < 0
}
func (v byHash) Swap(i int, j int) {
v[i], v[j] = v[j], v[i]
}
func TestCacheVote(t *testing.T) {
db, err := coreDb.NewMemBackedDB()
if err != nil {
panic(err)
}
cache := newCache(3, db)
pos0 := coreTypes.Position{
Height: uint64(0),
}
pos1 := coreTypes.Position{
Height: uint64(1),
}
vote1 := &coreTypes.Vote{
VoteHeader: coreTypes.VoteHeader{
BlockHash: coreCommon.NewRandomHash(),
Position: pos0,
},
}
vote2 := &coreTypes.Vote{
VoteHeader: coreTypes.VoteHeader{
BlockHash: coreCommon.NewRandomHash(),
Position: pos0,
},
}
vote3 := &coreTypes.Vote{
VoteHeader: coreTypes.VoteHeader{
BlockHash: coreCommon.NewRandomHash(),
Position: pos1,
},
}
vote4 := &coreTypes.Vote{
VoteHeader: coreTypes.VoteHeader{
BlockHash: coreCommon.NewRandomHash(),
Position: pos1,
},
}
cache.addVote(vote1)
cache.addVote(vote2)
cache.addVote(vote3)
votes := cache.votes(pos0)
sort.Sort(byHash(votes))
resultVotes := []*coreTypes.Vote{vote1, vote2}
sort.Sort(byHash(resultVotes))
if len(votes) != 2 {
t.Errorf("fail to get votes: have %d, want 2", len(votes))
}
if !votes[0].BlockHash.Equal(resultVotes[0].BlockHash) {
t.Errorf("get wrong vote: have %s, want %s", votes[0], resultVotes[0])
}
if !votes[1].BlockHash.Equal(resultVotes[1].BlockHash) {
t.Errorf("get wrong vote: have %s, want %s", votes[1], resultVotes[1])
}
votes = cache.votes(pos1)
sort.Sort(byHash(votes))
if len(votes) != 1 {
t.Errorf("fail to get votes: have %d, want 1", len(votes))
}
if !votes[0].BlockHash.Equal(vote3.BlockHash) {
t.Errorf("get wrong vote: have %s, want %s", votes[0], vote3)
}
cache.addVote(vote4)
votes = cache.votes(pos0)
sort.Sort(byHash(votes))
if len(votes) != 0 {
t.Errorf("fail to get votes: have %d, want 0", len(votes))
}
votes = cache.votes(pos1)
sort.Sort(byHash(votes))
resultVotes = []*coreTypes.Vote{vote3, vote4}
sort.Sort(byHash(resultVotes))
if len(votes) != 2 {
t.Errorf("fail to get votes: have %d, want 1", len(votes))
}
if !votes[0].BlockHash.Equal(resultVotes[0].BlockHash) {
t.Errorf("get wrong vote: have %s, want %s", votes[0], resultVotes[0])
}
if !votes[1].BlockHash.Equal(resultVotes[1].BlockHash) {
t.Errorf("get wrong vote: have %s, want %s", votes[1], resultVotes[1])
}
}
func TestCacheBlock(t *testing.T) {
db, err := coreDb.NewMemBackedDB()
if err != nil {
panic(err)
}
cache := newCache(3, db)
block1 := &coreTypes.Block{
Hash: coreCommon.NewRandomHash(),
}
block2 := &coreTypes.Block{
Hash: coreCommon.NewRandomHash(),
}
block3 := &coreTypes.Block{
Hash: coreCommon.NewRandomHash(),
}
block4 := &coreTypes.Block{
Hash: coreCommon.NewRandomHash(),
}
cache.addBlock(block1)
cache.addBlock(block2)
cache.addBlock(block3)
hashes := coreCommon.Hashes{block1.Hash, block2.Hash, block3.Hash, block4.Hash}
hashMap := map[coreCommon.Hash]struct{}{
block1.Hash: {},
block2.Hash: {},
block3.Hash: {},
}
blocks := cache.blocks(hashes)
if len(blocks) != 3 {
t.Errorf("fail to get blocks: have %d, want 3", len(blocks))
}
for _, block := range blocks {
if _, exist := hashMap[block.Hash]; !exist {
t.Errorf("get wrong block: have %s, want %v", block, hashMap)
}
}
cache.addBlock(block4)
blocks = cache.blocks(hashes)
hashMap[block4.Hash] = struct{}{}
if len(blocks) != 3 {
t.Errorf("fail to get blocks: have %d, want 3", len(blocks))
}
hasNewBlock := false
for _, block := range blocks {
if _, exist := hashMap[block.Hash]; !exist {
t.Errorf("get wrong block: have %s, want %v", block, hashMap)
}
if block.Hash.Equal(block4.Hash) {
hasNewBlock = true
}
}
if !hasNewBlock {
t.Errorf("expect block %s in cache, have %v", block4, blocks)
}
block5 := &coreTypes.Block{
Hash: coreCommon.NewRandomHash(),
}
if err := db.PutBlock(*block5); err != nil {
panic(err)
}
blocks = cache.blocks(coreCommon.Hashes{block5.Hash})
if len(blocks) != 1 {
t.Errorf("fail to get blocks: have %d, want 1", len(blocks))
} else {
if !blocks[0].Hash.Equal(block5.Hash) {
t.Errorf("get wrong block: have %s, want %s", blocks[0], block5)
}
}
}
func TestCacheFinalizedBlock(t *testing.T) {
db, err := coreDb.NewMemBackedDB()
if err != nil {
panic(err)
}
cache := newCache(3, db)
block1 := &coreTypes.Block{
Position: coreTypes.Position{
Height: 1,
},
Hash: coreCommon.NewRandomHash(),
Finalization: coreTypes.FinalizationResult{
Randomness: randomBytes(),
},
}
block2 := &coreTypes.Block{
Position: coreTypes.Position{
Height: 2,
},
Hash: coreCommon.NewRandomHash(),
Finalization: coreTypes.FinalizationResult{
Randomness: randomBytes(),
},
}
block3 := &coreTypes.Block{
Position: coreTypes.Position{
Height: 3,
},
Hash: coreCommon.NewRandomHash(),
Finalization: coreTypes.FinalizationResult{
Randomness: randomBytes(),
},
}
block4 := &coreTypes.Block{
Position: coreTypes.Position{
Height: 4,
},
Hash: coreCommon.NewRandomHash(),
Finalization: coreTypes.FinalizationResult{
Randomness: randomBytes(),
},
}
cache.addFinalizedBlock(block1)
cache.addFinalizedBlock(block2)
cache.addFinalizedBlock(block3)
hashes := coreCommon.Hashes{block1.Hash, block2.Hash, block3.Hash, block4.Hash}
for i := 0; i < 3; i++ {
pos := coreTypes.Position{
Height: uint64(i + 1),
}
block := cache.finalizedBlock(pos)
if block.Hash != hashes[i] {
t.Errorf("failed to get block: have %s, want %s", block, hashes[i])
}
}
cache.addFinalizedBlock(block4)
block := cache.finalizedBlock(block4.Position)
if block == nil {
t.Errorf("should have block %s in cache", block4)
}
if block.Hash != block4.Hash {
t.Errorf("failed to get block: have %s, want %s", block, block4)
}
block5 := &coreTypes.Block{
Position: coreTypes.Position{
Height: 5,
},
Hash: coreCommon.NewRandomHash(),
}
cache.addBlock(block5)
if block := cache.finalizedBlock(block5.Position); block != nil {
t.Errorf("unexpected block %s in cache", block)
}
blocks := cache.blocks(coreCommon.Hashes{block5.Hash})
if len(blocks) != 1 {
t.Errorf("fail to get blocks: have %d, want 1", len(blocks))
} else {
if !blocks[0].Hash.Equal(block5.Hash) {
t.Errorf("get wrong block: have %s, want %s", blocks[0], block5)
}
}
finalizedBlock5 := block5.Clone()
finalizedBlock5.Finalization.Randomness = randomBytes()
cache.addFinalizedBlock(finalizedBlock5)
block = cache.finalizedBlock(block5.Position)
if block == nil {
t.Errorf("expecting block %s in cache", finalizedBlock5)
}
if !reflect.DeepEqual(
block.Finalization.Randomness,
finalizedBlock5.Finalization.Randomness) {
t.Errorf("mismatch randomness, have %s, want %s",
block.Finalization.Randomness,
finalizedBlock5.Finalization.Randomness)
}
blocks = cache.blocks(coreCommon.Hashes{block5.Hash})
if len(blocks) != 1 {
t.Errorf("fail to get blocks: have %d, want 1", len(blocks))
} else {
if !blocks[0].Hash.Equal(finalizedBlock5.Hash) {
t.Errorf("get wrong block: have %s, want %s", blocks[0], block5)
}
if !reflect.DeepEqual(
blocks[0].Finalization.Randomness,
finalizedBlock5.Finalization.Randomness) {
t.Errorf("mismatch randomness, have %s, want %s",
blocks[0].Finalization.Randomness,
finalizedBlock5.Finalization.Randomness)
}
}
}
func randomBytes() []byte {
bytes := make([]byte, 32)
for i := range bytes {
bytes[i] = byte(rand.Int() % 256)
}
return bytes
}
