delete unused

[bytom/vapor.git] / protocol / orphan_manage_test.go

diff --git a/protocol/orphan_manage_test.go b/protocol/orphan_manage_test.go
index ea9910c..0434745 100644 (file)
--- a/protocol/orphan_manage_test.go
+++ b/protocol/orphan_manage_test.go
@@ -12,15 +12,15 @@ import (
 var testBlocks = []*types.Block{
        &types.Block{BlockHeader: types.BlockHeader{
                PreviousBlockHash: bc.Hash{V0: 1},
-               Nonce:             0,
+               Timestamp:         0,
        }},
        &types.Block{BlockHeader: types.BlockHeader{
                PreviousBlockHash: bc.Hash{V0: 1},
-               Nonce:             1,
+               Timestamp:         1,
        }},
        &types.Block{BlockHeader: types.BlockHeader{
                PreviousBlockHash: bc.Hash{V0: 2},
-               Nonce:             3,
+               Timestamp:         3,
        }},
 }
 
@@ -32,6 +32,65 @@ func init() {
        }
 }
 
+func TestDeleteLRU(t *testing.T) {
+       now := time.Now()
+       cases := []struct {
+               before *OrphanManage
+               after  *OrphanManage
+       }{
+               {
+                       before: &OrphanManage{
+                               orphan: map[bc.Hash]*orphanBlock{
+                                       blockHashes[0]: &orphanBlock{testBlocks[0], now},
+                               },
+                               prevOrphans: map[bc.Hash][]*bc.Hash{
+                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                               },
+                       },
+                       after: &OrphanManage{
+                               orphan:      map[bc.Hash]*orphanBlock{},
+                               prevOrphans: map[bc.Hash][]*bc.Hash{},
+                       },
+               },
+               {
+                       before: &OrphanManage{
+                               orphan:      map[bc.Hash]*orphanBlock{},
+                               prevOrphans: map[bc.Hash][]*bc.Hash{},
+                       },
+                       after: &OrphanManage{
+                               orphan:      map[bc.Hash]*orphanBlock{},
+                               prevOrphans: map[bc.Hash][]*bc.Hash{},
+                       },
+               },
+               {
+                       before: &OrphanManage{
+                               orphan: map[bc.Hash]*orphanBlock{
+                                       blockHashes[0]: &orphanBlock{testBlocks[0], now.Add(2)},
+                                       blockHashes[1]: &orphanBlock{testBlocks[1], now.Add(1)},
+                               },
+                               prevOrphans: map[bc.Hash][]*bc.Hash{
+                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0], &blockHashes[1]},
+                               },
+                       },
+                       after: &OrphanManage{
+                               orphan: map[bc.Hash]*orphanBlock{
+                                       blockHashes[0]: &orphanBlock{testBlocks[0], now.Add(2)},
+                               },
+                               prevOrphans: map[bc.Hash][]*bc.Hash{
+                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                               },
+                       },
+               },
+       }
+
+       for i, c := range cases {
+               c.before.deleteLRU()
+               if !testutil.DeepEqual(c.before, c.after) {
+                       t.Errorf("case %d: got %v want %v", i, c.before, c.after)
+               }
+       }
+}
+
 func TestOrphanManageAdd(t *testing.T) {
        cases := []struct {
                before    *OrphanManage
@@ -251,3 +310,40 @@ func TestOrphanManageExpire(t *testing.T) {
                }
        }
 }
+
+func TestOrphanManageNumLimit(t *testing.T) {
+       cases := []struct {
+               addOrphanBlockNum    int
+               expectOrphanBlockNum int
+       }{
+               {
+                       addOrphanBlockNum:    10,
+                       expectOrphanBlockNum: 10,
+               },
+               {
+                       addOrphanBlockNum:    numOrphanBlockLimit,
+                       expectOrphanBlockNum: numOrphanBlockLimit,
+               },
+               {
+                       addOrphanBlockNum:    numOrphanBlockLimit + 1,
+                       expectOrphanBlockNum: numOrphanBlockLimit,
+               },
+               {
+                       addOrphanBlockNum:    numOrphanBlockLimit + 10,
+                       expectOrphanBlockNum: numOrphanBlockLimit,
+               },
+       }
+
+       for i, c := range cases {
+               orphanManage := &OrphanManage{
+                       orphan:      map[bc.Hash]*orphanBlock{},
+                       prevOrphans: map[bc.Hash][]*bc.Hash{},
+               }
+               for num := 0; num < c.addOrphanBlockNum; num++ {
+                       orphanManage.Add(&types.Block{BlockHeader: types.BlockHeader{Height: uint64(num)}})
+               }
+               if len(orphanManage.orphan) != c.expectOrphanBlockNum {
+                       t.Errorf("case %d: got %d want %d", i, len(orphanManage.orphan), c.expectOrphanBlockNum)
+               }
+       }
+}