diff --git a/blockdag/accept.go b/blockdag/accept.go index 9f981f4fd..4bf819242 100644 --- a/blockdag/accept.go +++ b/blockdag/accept.go @@ -13,7 +13,7 @@ import ( func (dag *BlockDAG) addNodeToIndexWithInvalidAncestor(block *util.Block) error { blockHeader := &block.MsgBlock().Header - newNode, _ := dag.newBlockNode(blockHeader, newSet()) + newNode, _ := dag.newBlockNode(blockHeader, newBlockSet()) newNode.status = statusInvalidAncestor dag.index.AddNode(newNode) return dag.index.flushToDB() @@ -114,7 +114,7 @@ func lookupParentNodes(block *util.Block, blockDAG *BlockDAG) (blockSet, error) header := block.MsgBlock().Header parentHashes := header.ParentHashes - nodes := newSet() + nodes := newBlockSet() for _, parentHash := range parentHashes { node := blockDAG.index.LookupNode(parentHash) if node == nil { diff --git a/blockdag/blockheap_test.go b/blockdag/blockheap_test.go index 6dd8a6630..7a046f2e1 100644 --- a/blockdag/blockheap_test.go +++ b/blockdag/blockheap_test.go @@ -19,12 +19,12 @@ func TestBlockHeap(t *testing.T) { defer teardownFunc() block0Header := dagconfig.MainnetParams.GenesisBlock.Header - block0, _ := dag.newBlockNode(&block0Header, newSet()) + block0, _ := dag.newBlockNode(&block0Header, newBlockSet()) block100000Header := Block100000.Header - block100000, _ := dag.newBlockNode(&block100000Header, setFromSlice(block0)) + block100000, _ := dag.newBlockNode(&block100000Header, blockSetFromSlice(block0)) - block0smallHash, _ := dag.newBlockNode(&block0Header, newSet()) + block0smallHash, _ := dag.newBlockNode(&block0Header, newBlockSet()) block0smallHash.hash = &daghash.Hash{} tests := []struct { diff --git a/blockdag/blockindex_test.go b/blockdag/blockindex_test.go index 15f5f0b91..15883a63a 100644 --- a/blockdag/blockindex_test.go +++ b/blockdag/blockindex_test.go @@ -18,7 +18,7 @@ func TestAncestorErrors(t *testing.T) { } defer teardownFunc() - node := newTestNode(dag, newSet(), int32(0x10000000), 0, time.Unix(0, 0)) + node := newTestNode(dag, newBlockSet(), int32(0x10000000), 0, time.Unix(0, 0)) node.blueScore = 2 ancestor := node.SelectedAncestor(3) if ancestor != nil { diff --git a/blockdag/blocknode_test.go b/blockdag/blocknode_test.go index 49685f579..2a611eaea 100644 --- a/blockdag/blocknode_test.go +++ b/blockdag/blocknode_test.go @@ -25,7 +25,7 @@ func TestBlueAnticoneSizesSize(t *testing.T) { } blockHeader := dagconfig.SimnetParams.GenesisBlock.Header - node, _ := dag.newBlockNode(&blockHeader, newSet()) + node, _ := dag.newBlockNode(&blockHeader, newBlockSet()) fakeBlue := &blockNode{hash: &daghash.Hash{1}} dag.index.AddNode(fakeBlue) // Setting maxKType to maximum value of KType. diff --git a/blockdag/blockset.go b/blockdag/blockset.go index 13aa17635..0fabc2017 100644 --- a/blockdag/blockset.go +++ b/blockdag/blockset.go @@ -9,14 +9,14 @@ import ( // blockSet implements a basic unsorted set of blocks type blockSet map[*blockNode]struct{} -// newSet creates a new, empty BlockSet -func newSet() blockSet { +// newBlockSet creates a new, empty BlockSet +func newBlockSet() blockSet { return map[*blockNode]struct{}{} } -// setFromSlice converts a slice of blockNodes into an unordered set represented as map -func setFromSlice(nodes ...*blockNode) blockSet { - set := newSet() +// blockSetFromSlice converts a slice of blockNodes into an unordered set represented as map +func blockSetFromSlice(nodes ...*blockNode) blockSet { + set := newBlockSet() for _, node := range nodes { set.add(node) } @@ -36,7 +36,7 @@ func (bs blockSet) remove(node *blockNode) { // clone clones thie block set func (bs blockSet) clone() blockSet { - clone := newSet() + clone := newBlockSet() for node := range bs { clone.add(node) } @@ -45,7 +45,7 @@ func (bs blockSet) clone() blockSet { // subtract returns the difference between the BlockSet and another BlockSet func (bs blockSet) subtract(other blockSet) blockSet { - diff := newSet() + diff := newBlockSet() for node := range bs { if !other.contains(node) { diff.add(node) diff --git a/blockdag/blockset_test.go b/blockdag/blockset_test.go index 60188cb4d..545f31ecc 100644 --- a/blockdag/blockset_test.go +++ b/blockdag/blockset_test.go @@ -8,7 +8,7 @@ import ( ) func TestHashes(t *testing.T) { - bs := setFromSlice( + bs := blockSetFromSlice( &blockNode{ hash: &daghash.Hash{3}, }, @@ -49,33 +49,33 @@ func TestBlockSetSubtract(t *testing.T) { }{ { name: "both sets empty", - setA: setFromSlice(), - setB: setFromSlice(), - expectedResult: setFromSlice(), + setA: blockSetFromSlice(), + setB: blockSetFromSlice(), + expectedResult: blockSetFromSlice(), }, { name: "subtract an empty set", - setA: setFromSlice(node1), - setB: setFromSlice(), - expectedResult: setFromSlice(node1), + setA: blockSetFromSlice(node1), + setB: blockSetFromSlice(), + expectedResult: blockSetFromSlice(node1), }, { name: "subtract from empty set", - setA: setFromSlice(), - setB: setFromSlice(node1), - expectedResult: setFromSlice(), + setA: blockSetFromSlice(), + setB: blockSetFromSlice(node1), + expectedResult: blockSetFromSlice(), }, { name: "subtract unrelated set", - setA: setFromSlice(node1), - setB: setFromSlice(node2), - expectedResult: setFromSlice(node1), + setA: blockSetFromSlice(node1), + setB: blockSetFromSlice(node2), + expectedResult: blockSetFromSlice(node1), }, { name: "typical case", - setA: setFromSlice(node1, node2), - setB: setFromSlice(node2, node3), - expectedResult: setFromSlice(node1), + setA: blockSetFromSlice(node1, node2), + setB: blockSetFromSlice(node2, node3), + expectedResult: blockSetFromSlice(node1), }, } @@ -101,33 +101,33 @@ func TestBlockSetAddSet(t *testing.T) { }{ { name: "both sets empty", - setA: setFromSlice(), - setB: setFromSlice(), - expectedResult: setFromSlice(), + setA: blockSetFromSlice(), + setB: blockSetFromSlice(), + expectedResult: blockSetFromSlice(), }, { name: "add an empty set", - setA: setFromSlice(node1), - setB: setFromSlice(), - expectedResult: setFromSlice(node1), + setA: blockSetFromSlice(node1), + setB: blockSetFromSlice(), + expectedResult: blockSetFromSlice(node1), }, { name: "add to empty set", - setA: setFromSlice(), - setB: setFromSlice(node1), - expectedResult: setFromSlice(node1), + setA: blockSetFromSlice(), + setB: blockSetFromSlice(node1), + expectedResult: blockSetFromSlice(node1), }, { name: "add already added member", - setA: setFromSlice(node1, node2), - setB: setFromSlice(node1), - expectedResult: setFromSlice(node1, node2), + setA: blockSetFromSlice(node1, node2), + setB: blockSetFromSlice(node1), + expectedResult: blockSetFromSlice(node1, node2), }, { name: "typical case", - setA: setFromSlice(node1, node2), - setB: setFromSlice(node2, node3), - expectedResult: setFromSlice(node1, node2, node3), + setA: blockSetFromSlice(node1, node2), + setB: blockSetFromSlice(node2, node3), + expectedResult: blockSetFromSlice(node1, node2, node3), }, } @@ -153,33 +153,33 @@ func TestBlockSetAddSlice(t *testing.T) { }{ { name: "add empty slice to empty set", - set: setFromSlice(), + set: blockSetFromSlice(), slice: []*blockNode{}, - expectedResult: setFromSlice(), + expectedResult: blockSetFromSlice(), }, { name: "add an empty slice", - set: setFromSlice(node1), + set: blockSetFromSlice(node1), slice: []*blockNode{}, - expectedResult: setFromSlice(node1), + expectedResult: blockSetFromSlice(node1), }, { name: "add to empty set", - set: setFromSlice(), + set: blockSetFromSlice(), slice: []*blockNode{node1}, - expectedResult: setFromSlice(node1), + expectedResult: blockSetFromSlice(node1), }, { name: "add already added member", - set: setFromSlice(node1, node2), + set: blockSetFromSlice(node1, node2), slice: []*blockNode{node1}, - expectedResult: setFromSlice(node1, node2), + expectedResult: blockSetFromSlice(node1, node2), }, { name: "typical case", - set: setFromSlice(node1, node2), + set: blockSetFromSlice(node1, node2), slice: []*blockNode{node2, node3}, - expectedResult: setFromSlice(node1, node2, node3), + expectedResult: blockSetFromSlice(node1, node2, node3), }, } @@ -205,33 +205,33 @@ func TestBlockSetUnion(t *testing.T) { }{ { name: "both sets empty", - setA: setFromSlice(), - setB: setFromSlice(), - expectedResult: setFromSlice(), + setA: blockSetFromSlice(), + setB: blockSetFromSlice(), + expectedResult: blockSetFromSlice(), }, { name: "union against an empty set", - setA: setFromSlice(node1), - setB: setFromSlice(), - expectedResult: setFromSlice(node1), + setA: blockSetFromSlice(node1), + setB: blockSetFromSlice(), + expectedResult: blockSetFromSlice(node1), }, { name: "union from an empty set", - setA: setFromSlice(), - setB: setFromSlice(node1), - expectedResult: setFromSlice(node1), + setA: blockSetFromSlice(), + setB: blockSetFromSlice(node1), + expectedResult: blockSetFromSlice(node1), }, { name: "union with subset", - setA: setFromSlice(node1, node2), - setB: setFromSlice(node1), - expectedResult: setFromSlice(node1, node2), + setA: blockSetFromSlice(node1, node2), + setB: blockSetFromSlice(node1), + expectedResult: blockSetFromSlice(node1, node2), }, { name: "typical case", - setA: setFromSlice(node1, node2), - setB: setFromSlice(node2, node3), - expectedResult: setFromSlice(node1, node2, node3), + setA: blockSetFromSlice(node1, node2), + setB: blockSetFromSlice(node2, node3), + expectedResult: blockSetFromSlice(node1, node2, node3), }, } diff --git a/blockdag/common_test.go b/blockdag/common_test.go index a80529d75..9a2f28523 100644 --- a/blockdag/common_test.go +++ b/blockdag/common_test.go @@ -118,10 +118,10 @@ func newTestDAG(params *dagconfig.Params) *BlockDAG { // Create a genesis block node and block index index populated with it // on the above fake DAG. - dag.genesis, _ = dag.newBlockNode(¶ms.GenesisBlock.Header, newSet()) + dag.genesis, _ = dag.newBlockNode(¶ms.GenesisBlock.Header, newBlockSet()) index.AddNode(dag.genesis) - dag.virtual = newVirtualBlock(dag, setFromSlice(dag.genesis)) + dag.virtual = newVirtualBlock(dag, blockSetFromSlice(dag.genesis)) return dag } diff --git a/blockdag/dag.go b/blockdag/dag.go index 3bdf96cef..a13c44352 100644 --- a/blockdag/dag.go +++ b/blockdag/dag.go @@ -1650,7 +1650,7 @@ func (dag *BlockDAG) antiPastBetween(lowHash, highHash *daghash.Hash, maxEntries // Collect every node in highNode's past (including itself) but // NOT in the lowNode's past (excluding itself) into an up-heap // (a heap sorted by blueScore from lowest to greatest). - visited := newSet() + visited := newBlockSet() candidateNodes := newUpHeap() queue := newDownHeap() queue.Push(highNode) @@ -1731,7 +1731,7 @@ func (dag *BlockDAG) GetTopHeaders(highHash *daghash.Hash, maxHeaders uint64) ([ queue := newDownHeap() queue.pushSet(highNode.parents) - visited := newSet() + visited := newBlockSet() for i := uint32(0); queue.Len() > 0 && uint64(len(headers)) < maxHeaders; i++ { current := queue.pop() if !visited.contains(current) { diff --git a/blockdag/dag_test.go b/blockdag/dag_test.go index b5c1c14f3..a39521682 100644 --- a/blockdag/dag_test.go +++ b/blockdag/dag_test.go @@ -243,9 +243,9 @@ func TestCalcSequenceLock(t *testing.T) { numBlocksToGenerate := 5 for i := 0; i < numBlocksToGenerate; i++ { blockTime = blockTime.Add(time.Second) - node = newTestNode(dag, setFromSlice(node), blockVersion, 0, blockTime) + node = newTestNode(dag, blockSetFromSlice(node), blockVersion, 0, blockTime) dag.index.AddNode(node) - dag.virtual.SetTips(setFromSlice(node)) + dag.virtual.SetTips(blockSetFromSlice(node)) } // Create a utxo view with a fake utxo for the inputs used in the @@ -511,7 +511,7 @@ func TestCalcPastMedianTime(t *testing.T) { blockTime := dag.genesis.Header().Timestamp for i := uint32(1); i < numBlocks; i++ { blockTime = blockTime.Add(time.Second) - nodes[i] = newTestNode(dag, setFromSlice(nodes[i-1]), blockVersion, 0, blockTime) + nodes[i] = newTestNode(dag, blockSetFromSlice(nodes[i-1]), blockVersion, 0, blockTime) dag.index.AddNode(nodes[i]) } @@ -621,7 +621,7 @@ func TestAcceptingInInit(t *testing.T) { // Create a test blockNode with an unvalidated status genesisNode := dag.index.LookupNode(genesisBlock.Hash()) - testNode, _ := dag.newBlockNode(&testBlock.MsgBlock().Header, setFromSlice(genesisNode)) + testNode, _ := dag.newBlockNode(&testBlock.MsgBlock().Header, blockSetFromSlice(genesisNode)) testNode.status = statusDataStored // Manually add the test block to the database @@ -910,7 +910,7 @@ func testFinalizeNodesBelowFinalityPoint(t *testing.T, deleteDiffData bool) { addNode := func(parent *blockNode) *blockNode { blockTime = blockTime.Add(time.Second) - node := newTestNode(dag, setFromSlice(parent), blockVersion, 0, blockTime) + node := newTestNode(dag, blockSetFromSlice(parent), blockVersion, 0, blockTime) node.updateParentsChildren() dag.index.AddNode(node) diff --git a/blockdag/dagio.go b/blockdag/dagio.go index c368db39e..6676fc8d9 100644 --- a/blockdag/dagio.go +++ b/blockdag/dagio.go @@ -577,7 +577,7 @@ func (dag *BlockDAG) initDAGState() error { } // Apply the stored tips to the virtual block. - tips := newSet() + tips := newBlockSet() for _, tipHash := range state.TipHashes { tip := dag.index.LookupNode(tipHash) if tip == nil { @@ -657,8 +657,8 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) { utxoCommitment: header.UTXOCommitment, } - node.children = newSet() - node.parents = newSet() + node.children = newBlockSet() + node.parents = newBlockSet() for _, hash := range header.ParentHashes { parent := dag.index.LookupNode(hash) diff --git a/blockdag/difficulty_test.go b/blockdag/difficulty_test.go index a19908e4c..3a0aee5e2 100644 --- a/blockdag/difficulty_test.go +++ b/blockdag/difficulty_test.go @@ -117,28 +117,28 @@ func TestDifficulty(t *testing.T) { } tip := dag.genesis for i := uint64(0); i < dag.difficultyAdjustmentWindowSize; i++ { - tip = addNode(setFromSlice(tip), zeroTime) + tip = addNode(blockSetFromSlice(tip), zeroTime) if tip.bits != dag.genesis.bits { t.Fatalf("As long as the bluest parent's blue score is less then the difficulty adjustment window size, the difficulty should be the same as genesis'") } } for i := uint64(0); i < dag.difficultyAdjustmentWindowSize+100; i++ { - tip = addNode(setFromSlice(tip), zeroTime) + tip = addNode(blockSetFromSlice(tip), zeroTime) if tip.bits != dag.genesis.bits { t.Fatalf("As long as the block rate remains the same, the difficulty shouldn't change") } } - nodeInThePast := addNode(setFromSlice(tip), tip.PastMedianTime(dag)) + nodeInThePast := addNode(blockSetFromSlice(tip), tip.PastMedianTime(dag)) if nodeInThePast.bits != tip.bits { t.Fatalf("The difficulty should only change when nodeInThePast is in the past of a block bluest parent") } tip = nodeInThePast - tip = addNode(setFromSlice(tip), zeroTime) + tip = addNode(blockSetFromSlice(tip), zeroTime) if tip.bits != nodeInThePast.bits { t.Fatalf("The difficulty should only change when nodeInThePast is in the past of a block bluest parent") } - tip = addNode(setFromSlice(tip), zeroTime) + tip = addNode(blockSetFromSlice(tip), zeroTime) if compareBits(tip.bits, nodeInThePast.bits) >= 0 { t.Fatalf("tip.bits should be smaller than nodeInThePast.bits because nodeInThePast increased the block rate, so the difficulty should increase as well") } @@ -149,7 +149,7 @@ func TestDifficulty(t *testing.T) { // Increase block rate to increase difficulty for i := uint64(0); i < dag.difficultyAdjustmentWindowSize; i++ { - tip = addNode(setFromSlice(tip), tip.PastMedianTime(dag)) + tip = addNode(blockSetFromSlice(tip), tip.PastMedianTime(dag)) if compareBits(tip.bits, tip.parents.bluest().bits) > 0 { t.Fatalf("Because we're increasing the block rate, the difficulty can't decrease") } @@ -159,7 +159,7 @@ func TestDifficulty(t *testing.T) { lastBits := tip.bits sameBitsCount := uint64(0) for sameBitsCount < dag.difficultyAdjustmentWindowSize+1 { - tip = addNode(setFromSlice(tip), zeroTime) + tip = addNode(blockSetFromSlice(tip), zeroTime) if tip.bits == lastBits { sameBitsCount++ } else { @@ -167,35 +167,35 @@ func TestDifficulty(t *testing.T) { sameBitsCount = 0 } } - slowNode := addNode(setFromSlice(tip), time.Unix(tip.timestamp+2, 0)) + slowNode := addNode(blockSetFromSlice(tip), time.Unix(tip.timestamp+2, 0)) if slowNode.bits != tip.bits { t.Fatalf("The difficulty should only change when slowNode is in the past of a block bluest parent") } tip = slowNode - tip = addNode(setFromSlice(tip), zeroTime) + tip = addNode(blockSetFromSlice(tip), zeroTime) if tip.bits != slowNode.bits { t.Fatalf("The difficulty should only change when slowNode is in the past of a block bluest parent") } - tip = addNode(setFromSlice(tip), zeroTime) + tip = addNode(blockSetFromSlice(tip), zeroTime) if compareBits(tip.bits, slowNode.bits) <= 0 { t.Fatalf("tip.bits should be smaller than slowNode.bits because slowNode decreased the block rate, so the difficulty should decrease as well") } - splitNode := addNode(setFromSlice(tip), zeroTime) + splitNode := addNode(blockSetFromSlice(tip), zeroTime) tip = splitNode for i := 0; i < 100; i++ { - tip = addNode(setFromSlice(tip), zeroTime) + tip = addNode(blockSetFromSlice(tip), zeroTime) } blueTip := tip redChainTip := splitNode for i := 0; i < 10; i++ { - redChainTip = addNode(setFromSlice(redChainTip), redChainTip.PastMedianTime(dag)) + redChainTip = addNode(blockSetFromSlice(redChainTip), redChainTip.PastMedianTime(dag)) } - tipWithRedPast := addNode(setFromSlice(redChainTip, blueTip), zeroTime) - tipWithoutRedPast := addNode(setFromSlice(blueTip), zeroTime) + tipWithRedPast := addNode(blockSetFromSlice(redChainTip, blueTip), zeroTime) + tipWithoutRedPast := addNode(blockSetFromSlice(blueTip), zeroTime) if tipWithoutRedPast.bits != tipWithRedPast.bits { t.Fatalf("tipWithoutRedPast.bits should be the same as tipWithRedPast.bits because red blocks shouldn't affect the difficulty") } diff --git a/blockdag/ghostdag.go b/blockdag/ghostdag.go index e3ac81026..6f8f488fc 100644 --- a/blockdag/ghostdag.go +++ b/blockdag/ghostdag.go @@ -126,9 +126,9 @@ func (dag *BlockDAG) ghostdag(newNode *blockNode) (selectedParentAnticone []*blo // we check whether it is in the past of the selected parent. // If not, we add the node to the resulting anticone-set and queue it for processing. func (dag *BlockDAG) selectedParentAnticone(node *blockNode) ([]*blockNode, error) { - anticoneSet := newSet() + anticoneSet := newBlockSet() var anticoneSlice []*blockNode - selectedParentPast := newSet() + selectedParentPast := newBlockSet() var queue []*blockNode // Queueing all parents (other than the selected parent itself) for processing. for parent := range node.parents { diff --git a/blockdag/test_utils.go b/blockdag/test_utils.go index 38f6e76dd..fb3e2c8b0 100644 --- a/blockdag/test_utils.go +++ b/blockdag/test_utils.go @@ -163,7 +163,7 @@ func SetVirtualForTest(dag *BlockDAG, virtual VirtualForTest) VirtualForTest { // GetVirtualFromParentsForTest generates a virtual block with the given parents. func GetVirtualFromParentsForTest(dag *BlockDAG, parentHashes []*daghash.Hash) (VirtualForTest, error) { - parents := newSet() + parents := newBlockSet() for _, hash := range parentHashes { parent := dag.index.LookupNode(hash) if parent == nil { diff --git a/blockdag/validate.go b/blockdag/validate.go index aea0e4a81..60c6d5607 100644 --- a/blockdag/validate.go +++ b/blockdag/validate.go @@ -601,7 +601,7 @@ func (dag *BlockDAG) validateDifficulty(header *wire.BlockHeader, bluestParent * func validateParents(blockHeader *wire.BlockHeader, parents blockSet) error { minBlueScore := uint64(math.MaxUint64) queue := newDownHeap() - visited := newSet() + visited := newBlockSet() for parent := range parents { // isFinalized might be false-negative because node finality status is // updated in a separate goroutine. This is why later the block is diff --git a/blockdag/validate_test.go b/blockdag/validate_test.go index 8588f61eb..21eb60530 100644 --- a/blockdag/validate_test.go +++ b/blockdag/validate_test.go @@ -512,14 +512,14 @@ func TestPastMedianTime(t *testing.T) { for i := 0; i < 100; i++ { blockTime = blockTime.Add(time.Second) - tip = newTestNode(dag, setFromSlice(tip), + tip = newTestNode(dag, blockSetFromSlice(tip), blockVersion, 0, blockTime) } // Checks that a block is valid if it has timestamp equals to past median time - node := newTestNode(dag, setFromSlice(tip), + node := newTestNode(dag, blockSetFromSlice(tip), blockVersion, dag.powMaxBits, tip.PastMedianTime(dag)) @@ -532,7 +532,7 @@ func TestPastMedianTime(t *testing.T) { } // Checks that a block is valid if its timestamp is after past median time - node = newTestNode(dag, setFromSlice(tip), + node = newTestNode(dag, blockSetFromSlice(tip), blockVersion, dag.powMaxBits, tip.PastMedianTime(dag).Add(time.Second)) @@ -545,7 +545,7 @@ func TestPastMedianTime(t *testing.T) { } // Checks that a block is invalid if its timestamp is before past median time - node = newTestNode(dag, setFromSlice(tip), + node = newTestNode(dag, blockSetFromSlice(tip), blockVersion, 0, tip.PastMedianTime(dag).Add(-time.Second)) @@ -567,7 +567,7 @@ func TestValidateParents(t *testing.T) { generateNode := func(parents ...*blockNode) *blockNode { // The timestamp of each block is changed to prevent a situation where two blocks share the same hash blockTime = blockTime.Add(time.Second) - return newTestNode(dag, setFromSlice(parents...), + return newTestNode(dag, blockSetFromSlice(parents...), blockVersion, 0, blockTime) @@ -584,19 +584,19 @@ func TestValidateParents(t *testing.T) { } // Check direct parents relation - err := validateParents(fakeBlockHeader, setFromSlice(a, b)) + err := validateParents(fakeBlockHeader, blockSetFromSlice(a, b)) if err == nil { t.Errorf("validateParents: `a` is a parent of `b`, so an error is expected") } // Check indirect parents relation - err = validateParents(fakeBlockHeader, setFromSlice(genesisNode, b)) + err = validateParents(fakeBlockHeader, blockSetFromSlice(genesisNode, b)) if err == nil { t.Errorf("validateParents: `genesis` and `b` are indirectly related, so an error is expected") } // Check parents with no relation - err = validateParents(fakeBlockHeader, setFromSlice(b, c)) + err = validateParents(fakeBlockHeader, blockSetFromSlice(b, c)) if err != nil { t.Errorf("validateParents: unexpected error: %v", err) } diff --git a/blockdag/virtualblock.go b/blockdag/virtualblock.go index bad5e1c4c..102b8acca 100644 --- a/blockdag/virtualblock.go +++ b/blockdag/virtualblock.go @@ -32,7 +32,7 @@ func newVirtualBlock(dag *BlockDAG, tips blockSet) *virtualBlock { var virtual virtualBlock virtual.dag = dag virtual.utxoSet = NewFullUTXOSet() - virtual.selectedParentChainSet = newSet() + virtual.selectedParentChainSet = newBlockSet() virtual.selectedParentChainSlice = nil virtual.setTips(tips) diff --git a/blockdag/virtualblock_test.go b/blockdag/virtualblock_test.go index 414314fb0..9a4fc2f5d 100644 --- a/blockdag/virtualblock_test.go +++ b/blockdag/virtualblock_test.go @@ -52,12 +52,12 @@ func TestVirtualBlock(t *testing.T) { // \ X // <- 4 <- 6 node0 := dag.genesis - node1 := buildNode(t, dag, setFromSlice(node0)) - node2 := buildNode(t, dag, setFromSlice(node1)) - node3 := buildNode(t, dag, setFromSlice(node0)) - node4 := buildNode(t, dag, setFromSlice(node0)) - node5 := buildNode(t, dag, setFromSlice(node3, node4)) - node6 := buildNode(t, dag, setFromSlice(node3, node4)) + node1 := buildNode(t, dag, blockSetFromSlice(node0)) + node2 := buildNode(t, dag, blockSetFromSlice(node1)) + node3 := buildNode(t, dag, blockSetFromSlice(node0)) + node4 := buildNode(t, dag, blockSetFromSlice(node0)) + node5 := buildNode(t, dag, blockSetFromSlice(node3, node4)) + node6 := buildNode(t, dag, blockSetFromSlice(node3, node4)) // Given an empty VirtualBlock, each of the following test cases will: // Set its tips to tipsToSet @@ -75,28 +75,28 @@ func TestVirtualBlock(t *testing.T) { name: "empty virtual", tipsToSet: []*blockNode{}, tipsToAdd: []*blockNode{}, - expectedTips: newSet(), + expectedTips: newBlockSet(), expectedSelectedParent: nil, }, { name: "virtual with genesis tip", tipsToSet: []*blockNode{node0}, tipsToAdd: []*blockNode{}, - expectedTips: setFromSlice(node0), + expectedTips: blockSetFromSlice(node0), expectedSelectedParent: node0, }, { name: "virtual with genesis tip, add child of genesis", tipsToSet: []*blockNode{node0}, tipsToAdd: []*blockNode{node1}, - expectedTips: setFromSlice(node1), + expectedTips: blockSetFromSlice(node1), expectedSelectedParent: node1, }, { name: "empty virtual, add a full DAG", tipsToSet: []*blockNode{}, tipsToAdd: []*blockNode{node0, node1, node2, node3, node4, node5, node6}, - expectedTips: setFromSlice(node2, node5, node6), + expectedTips: blockSetFromSlice(node2, node5, node6), expectedSelectedParent: node5, }, } @@ -106,7 +106,7 @@ func TestVirtualBlock(t *testing.T) { virtual := newVirtualBlock(dag, nil) // Set the tips. This will be the initial state - virtual.SetTips(setFromSlice(test.tipsToSet...)) + virtual.SetTips(blockSetFromSlice(test.tipsToSet...)) // Add all blockNodes in tipsToAdd in order for _, tipToAdd := range test.tipsToAdd { @@ -147,9 +147,9 @@ func TestSelectedPath(t *testing.T) { tip := dag.genesis virtual.AddTip(tip) - initialPath := setFromSlice(tip) + initialPath := blockSetFromSlice(tip) for i := 0; i < 5; i++ { - tip = buildNode(t, dag, setFromSlice(tip)) + tip = buildNode(t, dag, blockSetFromSlice(tip)) initialPath.add(tip) virtual.AddTip(tip) } @@ -157,7 +157,7 @@ func TestSelectedPath(t *testing.T) { firstPath := initialPath.clone() for i := 0; i < 5; i++ { - tip = buildNode(t, dag, setFromSlice(tip)) + tip = buildNode(t, dag, blockSetFromSlice(tip)) firstPath.add(tip) virtual.AddTip(tip) } @@ -175,7 +175,7 @@ func TestSelectedPath(t *testing.T) { secondPath := initialPath.clone() tip = initialTip for i := 0; i < 100; i++ { - tip = buildNode(t, dag, setFromSlice(tip)) + tip = buildNode(t, dag, blockSetFromSlice(tip)) secondPath.add(tip) virtual.AddTip(tip) } @@ -193,7 +193,7 @@ func TestSelectedPath(t *testing.T) { tip = initialTip for i := 0; i < 3; i++ { - tip = buildNode(t, dag, setFromSlice(tip)) + tip = buildNode(t, dag, blockSetFromSlice(tip)) virtual.AddTip(tip) } // Because we added a very short chain, the selected path should not be affected. @@ -215,7 +215,7 @@ func TestSelectedPath(t *testing.T) { t.Fatalf("updateSelectedParentSet didn't panic") } }() - virtual2.updateSelectedParentSet(buildNode(t, dag, setFromSlice())) + virtual2.updateSelectedParentSet(buildNode(t, dag, blockSetFromSlice())) } func TestChainUpdates(t *testing.T) { @@ -236,23 +236,23 @@ func TestChainUpdates(t *testing.T) { var toBeRemovedNodes []*blockNode toBeRemovedTip := genesis for i := 0; i < 5; i++ { - toBeRemovedTip = buildNode(t, dag, setFromSlice(toBeRemovedTip)) + toBeRemovedTip = buildNode(t, dag, blockSetFromSlice(toBeRemovedTip)) toBeRemovedNodes = append(toBeRemovedNodes, toBeRemovedTip) } // Create a VirtualBlock with the toBeRemoved chain - virtual := newVirtualBlock(dag, setFromSlice(toBeRemovedNodes...)) + virtual := newVirtualBlock(dag, blockSetFromSlice(toBeRemovedNodes...)) // Create a chain to be added var toBeAddedNodes []*blockNode toBeAddedTip := genesis for i := 0; i < 8; i++ { - toBeAddedTip = buildNode(t, dag, setFromSlice(toBeAddedTip)) + toBeAddedTip = buildNode(t, dag, blockSetFromSlice(toBeAddedTip)) toBeAddedNodes = append(toBeAddedNodes, toBeAddedTip) } // Set the virtual tip to be the tip of the toBeAdded chain - chainUpdates := virtual.setTips(setFromSlice(toBeAddedTip)) + chainUpdates := virtual.setTips(blockSetFromSlice(toBeAddedTip)) // Make sure that the removed blocks are as expected (in reverse order) if len(chainUpdates.removedChainBlockHashes) != len(toBeRemovedNodes) {