fix the orphan issue

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

diff --git a/protocol/orphan_manage_test.go b/protocol/orphan_manage_test.go
index 0e60689..6e74265 100644 (file)
--- a/protocol/orphan_manage_test.go
+++ b/protocol/orphan_manage_test.go
@@ -10,15 +10,15 @@ import (
 )
 
 var testBlocks = []*types.Block{
-       &types.Block{BlockHeader: types.BlockHeader{
+       {BlockHeader: types.BlockHeader{
                PreviousBlockHash: bc.Hash{V0: 1},
                Nonce:             0,
        }},
-       &types.Block{BlockHeader: types.BlockHeader{
+       {BlockHeader: types.BlockHeader{
                PreviousBlockHash: bc.Hash{V0: 1},
                Nonce:             1,
        }},
-       &types.Block{BlockHeader: types.BlockHeader{
+       {BlockHeader: types.BlockHeader{
                PreviousBlockHash: bc.Hash{V0: 2},
                Nonce:             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]: {testBlocks[0], now},
+                               },
+                               prevOrphans: map[bc.Hash][]*bc.Hash{
+                                       {V0: 1}: {&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]: {testBlocks[0], now.Add(2)},
+                                       blockHashes[1]: {testBlocks[1], now.Add(1)},
+                               },
+                               prevOrphans: map[bc.Hash][]*bc.Hash{
+                                       {V0: 1}: {&blockHashes[0], &blockHashes[1]},
+                               },
+                       },
+                       after: &OrphanManage{
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], now.Add(2)},
+                               },
+                               prevOrphans: map[bc.Hash][]*bc.Hash{
+                                       {V0: 1}: {&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
@@ -40,75 +99,75 @@ func TestOrphanManageAdd(t *testing.T) {
        }{
                {
                        before: &OrphanManage{
-                               orphan:      map[bc.Hash]*orphanBlock{},
+                               orphan:      map[bc.Hash]*OrphanBlock{},
                                prevOrphans: map[bc.Hash][]*bc.Hash{},
                        },
                        after: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        addOrphan: testBlocks[0],
                },
                {
                        before: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        after: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        addOrphan: testBlocks[0],
                },
                {
                        before: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        after: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
-                                       blockHashes[1]: &orphanBlock{testBlocks[1], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
+                                       blockHashes[1]: {testBlocks[1], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0], &blockHashes[1]},
+                                       {V0: 1}: {&blockHashes[0], &blockHashes[1]},
                                },
                        },
                        addOrphan: testBlocks[1],
                },
                {
                        before: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        after: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
-                                       blockHashes[2]: &orphanBlock{testBlocks[2], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
+                                       blockHashes[2]: {testBlocks[2], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
-                                       bc.Hash{V0: 2}: []*bc.Hash{&blockHashes[2]},
+                                       {V0: 1}: {&blockHashes[0]},
+                                       {V0: 2}: {&blockHashes[2]},
                                },
                        },
                        addOrphan: testBlocks[2],
@@ -134,54 +193,54 @@ func TestOrphanManageDelete(t *testing.T) {
        }{
                {
                        before: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        after: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        remove: &blockHashes[1],
                },
                {
                        before: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        after: &OrphanManage{
-                               orphan:      map[bc.Hash]*orphanBlock{},
+                               orphan:      map[bc.Hash]*OrphanBlock{},
                                prevOrphans: map[bc.Hash][]*bc.Hash{},
                        },
                        remove: &blockHashes[0],
                },
                {
                        before: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
-                                       blockHashes[1]: &orphanBlock{testBlocks[1], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
+                                       blockHashes[1]: {testBlocks[1], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0], &blockHashes[1]},
+                                       {V0: 1}: {&blockHashes[0], &blockHashes[1]},
                                },
                        },
                        after: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {testBlocks[0], time.Time{}},
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        remove: &blockHashes[1],
@@ -203,42 +262,42 @@ func TestOrphanManageExpire(t *testing.T) {
        }{
                {
                        before: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {
                                                testBlocks[0],
                                                time.Unix(1633479700, 0),
                                        },
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        after: &OrphanManage{
-                               orphan:      map[bc.Hash]*orphanBlock{},
+                               orphan:      map[bc.Hash]*OrphanBlock{},
                                prevOrphans: map[bc.Hash][]*bc.Hash{},
                        },
                },
                {
                        before: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {
                                                testBlocks[0],
                                                time.Unix(1633479702, 0),
                                        },
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                        after: &OrphanManage{
-                               orphan: map[bc.Hash]*orphanBlock{
-                                       blockHashes[0]: &orphanBlock{
+                               orphan: map[bc.Hash]*OrphanBlock{
+                                       blockHashes[0]: {
                                                testBlocks[0],
                                                time.Unix(1633479702, 0),
                                        },
                                },
                                prevOrphans: map[bc.Hash][]*bc.Hash{
-                                       bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
+                                       {V0: 1}: {&blockHashes[0]},
                                },
                        },
                },
@@ -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)
+               }
+       }
+}