7 "github.com/vapor/protocol/bc"
8 "github.com/vapor/protocol/bc/types"
9 "github.com/vapor/testutil"
12 var testBlocks = []*types.Block{
13 &types.Block{BlockHeader: types.BlockHeader{
14 PreviousBlockHash: bc.Hash{V0: 1},
17 &types.Block{BlockHeader: types.BlockHeader{
18 PreviousBlockHash: bc.Hash{V0: 1},
21 &types.Block{BlockHeader: types.BlockHeader{
22 PreviousBlockHash: bc.Hash{V0: 2},
27 var blockHashes = []bc.Hash{}
30 for _, block := range testBlocks {
31 blockHashes = append(blockHashes, block.Hash())
35 func TestDeleteLRU(t *testing.T) {
42 before: &OrphanManage{
43 orphan: map[bc.Hash]*orphanBlock{
44 blockHashes[0]: &orphanBlock{testBlocks[0], now},
46 prevOrphans: map[bc.Hash][]*bc.Hash{
47 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
51 orphan: map[bc.Hash]*orphanBlock{},
52 prevOrphans: map[bc.Hash][]*bc.Hash{},
56 before: &OrphanManage{
57 orphan: map[bc.Hash]*orphanBlock{},
58 prevOrphans: map[bc.Hash][]*bc.Hash{},
61 orphan: map[bc.Hash]*orphanBlock{},
62 prevOrphans: map[bc.Hash][]*bc.Hash{},
66 before: &OrphanManage{
67 orphan: map[bc.Hash]*orphanBlock{
68 blockHashes[0]: &orphanBlock{testBlocks[0], now.Add(2)},
69 blockHashes[1]: &orphanBlock{testBlocks[1], now.Add(1)},
71 prevOrphans: map[bc.Hash][]*bc.Hash{
72 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0], &blockHashes[1]},
76 orphan: map[bc.Hash]*orphanBlock{
77 blockHashes[0]: &orphanBlock{testBlocks[0], now.Add(2)},
79 prevOrphans: map[bc.Hash][]*bc.Hash{
80 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
86 for i, c := range cases {
88 if !testutil.DeepEqual(c.before, c.after) {
89 t.Errorf("case %d: got %v want %v", i, c.before, c.after)
94 func TestOrphanManageAdd(t *testing.T) {
98 addOrphan *types.Block
101 before: &OrphanManage{
102 orphan: map[bc.Hash]*orphanBlock{},
103 prevOrphans: map[bc.Hash][]*bc.Hash{},
105 after: &OrphanManage{
106 orphan: map[bc.Hash]*orphanBlock{
107 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
109 prevOrphans: map[bc.Hash][]*bc.Hash{
110 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
113 addOrphan: testBlocks[0],
116 before: &OrphanManage{
117 orphan: map[bc.Hash]*orphanBlock{
118 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
120 prevOrphans: map[bc.Hash][]*bc.Hash{
121 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
124 after: &OrphanManage{
125 orphan: map[bc.Hash]*orphanBlock{
126 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
128 prevOrphans: map[bc.Hash][]*bc.Hash{
129 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
132 addOrphan: testBlocks[0],
135 before: &OrphanManage{
136 orphan: map[bc.Hash]*orphanBlock{
137 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
139 prevOrphans: map[bc.Hash][]*bc.Hash{
140 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
143 after: &OrphanManage{
144 orphan: map[bc.Hash]*orphanBlock{
145 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
146 blockHashes[1]: &orphanBlock{testBlocks[1], time.Time{}},
148 prevOrphans: map[bc.Hash][]*bc.Hash{
149 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0], &blockHashes[1]},
152 addOrphan: testBlocks[1],
155 before: &OrphanManage{
156 orphan: map[bc.Hash]*orphanBlock{
157 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
159 prevOrphans: map[bc.Hash][]*bc.Hash{
160 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
163 after: &OrphanManage{
164 orphan: map[bc.Hash]*orphanBlock{
165 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
166 blockHashes[2]: &orphanBlock{testBlocks[2], time.Time{}},
168 prevOrphans: map[bc.Hash][]*bc.Hash{
169 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
170 bc.Hash{V0: 2}: []*bc.Hash{&blockHashes[2]},
173 addOrphan: testBlocks[2],
177 for i, c := range cases {
178 c.before.Add(c.addOrphan)
179 for _, orphan := range c.before.orphan {
180 orphan.expiration = time.Time{}
182 if !testutil.DeepEqual(c.before, c.after) {
183 t.Errorf("case %d: got %v want %v", i, c.before, c.after)
188 func TestOrphanManageDelete(t *testing.T) {
195 before: &OrphanManage{
196 orphan: map[bc.Hash]*orphanBlock{
197 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
199 prevOrphans: map[bc.Hash][]*bc.Hash{
200 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
203 after: &OrphanManage{
204 orphan: map[bc.Hash]*orphanBlock{
205 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
207 prevOrphans: map[bc.Hash][]*bc.Hash{
208 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
211 remove: &blockHashes[1],
214 before: &OrphanManage{
215 orphan: map[bc.Hash]*orphanBlock{
216 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
218 prevOrphans: map[bc.Hash][]*bc.Hash{
219 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
222 after: &OrphanManage{
223 orphan: map[bc.Hash]*orphanBlock{},
224 prevOrphans: map[bc.Hash][]*bc.Hash{},
226 remove: &blockHashes[0],
229 before: &OrphanManage{
230 orphan: map[bc.Hash]*orphanBlock{
231 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
232 blockHashes[1]: &orphanBlock{testBlocks[1], time.Time{}},
234 prevOrphans: map[bc.Hash][]*bc.Hash{
235 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0], &blockHashes[1]},
238 after: &OrphanManage{
239 orphan: map[bc.Hash]*orphanBlock{
240 blockHashes[0]: &orphanBlock{testBlocks[0], time.Time{}},
242 prevOrphans: map[bc.Hash][]*bc.Hash{
243 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
246 remove: &blockHashes[1],
250 for i, c := range cases {
251 c.before.delete(c.remove)
252 if !testutil.DeepEqual(c.before, c.after) {
253 t.Errorf("case %d: got %v want %v", i, c.before, c.after)
258 func TestOrphanManageExpire(t *testing.T) {
264 before: &OrphanManage{
265 orphan: map[bc.Hash]*orphanBlock{
266 blockHashes[0]: &orphanBlock{
268 time.Unix(1633479700, 0),
271 prevOrphans: map[bc.Hash][]*bc.Hash{
272 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
275 after: &OrphanManage{
276 orphan: map[bc.Hash]*orphanBlock{},
277 prevOrphans: map[bc.Hash][]*bc.Hash{},
281 before: &OrphanManage{
282 orphan: map[bc.Hash]*orphanBlock{
283 blockHashes[0]: &orphanBlock{
285 time.Unix(1633479702, 0),
288 prevOrphans: map[bc.Hash][]*bc.Hash{
289 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
292 after: &OrphanManage{
293 orphan: map[bc.Hash]*orphanBlock{
294 blockHashes[0]: &orphanBlock{
296 time.Unix(1633479702, 0),
299 prevOrphans: map[bc.Hash][]*bc.Hash{
300 bc.Hash{V0: 1}: []*bc.Hash{&blockHashes[0]},
306 for i, c := range cases {
307 c.before.orphanExpire(time.Unix(1633479701, 0))
308 if !testutil.DeepEqual(c.before, c.after) {
309 t.Errorf("case %d: got %v want %v", i, c.before, c.after)
314 func TestOrphanManageNumLimit(t *testing.T) {
316 addOrphanBlockNum int
317 expectOrphanBlockNum int
320 addOrphanBlockNum: 10,
321 expectOrphanBlockNum: 10,
324 addOrphanBlockNum: numOrphanBlockLimit,
325 expectOrphanBlockNum: numOrphanBlockLimit,
328 addOrphanBlockNum: numOrphanBlockLimit + 1,
329 expectOrphanBlockNum: numOrphanBlockLimit,
332 addOrphanBlockNum: numOrphanBlockLimit + 10,
333 expectOrphanBlockNum: numOrphanBlockLimit,
337 for i, c := range cases {
338 orphanManage := &OrphanManage{
339 orphan: map[bc.Hash]*orphanBlock{},
340 prevOrphans: map[bc.Hash][]*bc.Hash{},
342 for num := 0; num < c.addOrphanBlockNum; num++ {
343 orphanManage.Add(&types.Block{BlockHeader: types.BlockHeader{Height: uint64(num)}})
345 if len(orphanManage.orphan) != c.expectOrphanBlockNum {
346 t.Errorf("case %d: got %d want %d", i, len(orphanManage.orphan), c.expectOrphanBlockNum)