7 "github.com/bytom/protocol/bc"
8 "github.com/bytom/protocol/bc/types"
9 "github.com/bytom/testutil"
12 var testBlocks = []*types.Block{
13 {BlockHeader: types.BlockHeader{
14 PreviousBlockHash: bc.Hash{V0: 1},
17 {BlockHeader: types.BlockHeader{
18 PreviousBlockHash: bc.Hash{V0: 1},
21 {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]: {testBlocks[0], now},
46 prevOrphans: map[bc.Hash][]*bc.Hash{
47 {V0: 1}: {&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]: {testBlocks[0], now.Add(2)},
69 blockHashes[1]: {testBlocks[1], now.Add(1)},
71 prevOrphans: map[bc.Hash][]*bc.Hash{
72 {V0: 1}: {&blockHashes[0], &blockHashes[1]},
76 orphan: map[bc.Hash]*OrphanBlock{
77 blockHashes[0]: {testBlocks[0], now.Add(2)},
79 prevOrphans: map[bc.Hash][]*bc.Hash{
80 {V0: 1}: {&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]: {testBlocks[0], time.Time{}},
109 prevOrphans: map[bc.Hash][]*bc.Hash{
110 {V0: 1}: {&blockHashes[0]},
113 addOrphan: testBlocks[0],
116 before: &OrphanManage{
117 orphan: map[bc.Hash]*OrphanBlock{
118 blockHashes[0]: {testBlocks[0], time.Time{}},
120 prevOrphans: map[bc.Hash][]*bc.Hash{
121 {V0: 1}: {&blockHashes[0]},
124 after: &OrphanManage{
125 orphan: map[bc.Hash]*OrphanBlock{
126 blockHashes[0]: {testBlocks[0], time.Time{}},
128 prevOrphans: map[bc.Hash][]*bc.Hash{
129 {V0: 1}: {&blockHashes[0]},
132 addOrphan: testBlocks[0],
135 before: &OrphanManage{
136 orphan: map[bc.Hash]*OrphanBlock{
137 blockHashes[0]: {testBlocks[0], time.Time{}},
139 prevOrphans: map[bc.Hash][]*bc.Hash{
140 {V0: 1}: {&blockHashes[0]},
143 after: &OrphanManage{
144 orphan: map[bc.Hash]*OrphanBlock{
145 blockHashes[0]: {testBlocks[0], time.Time{}},
146 blockHashes[1]: {testBlocks[1], time.Time{}},
148 prevOrphans: map[bc.Hash][]*bc.Hash{
149 {V0: 1}: {&blockHashes[0], &blockHashes[1]},
152 addOrphan: testBlocks[1],
155 before: &OrphanManage{
156 orphan: map[bc.Hash]*OrphanBlock{
157 blockHashes[0]: {testBlocks[0], time.Time{}},
159 prevOrphans: map[bc.Hash][]*bc.Hash{
160 {V0: 1}: {&blockHashes[0]},
163 after: &OrphanManage{
164 orphan: map[bc.Hash]*OrphanBlock{
165 blockHashes[0]: {testBlocks[0], time.Time{}},
166 blockHashes[2]: {testBlocks[2], time.Time{}},
168 prevOrphans: map[bc.Hash][]*bc.Hash{
169 {V0: 1}: {&blockHashes[0]},
170 {V0: 2}: {&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]: {testBlocks[0], time.Time{}},
199 prevOrphans: map[bc.Hash][]*bc.Hash{
200 {V0: 1}: {&blockHashes[0]},
203 after: &OrphanManage{
204 orphan: map[bc.Hash]*OrphanBlock{
205 blockHashes[0]: {testBlocks[0], time.Time{}},
207 prevOrphans: map[bc.Hash][]*bc.Hash{
208 {V0: 1}: {&blockHashes[0]},
211 remove: &blockHashes[1],
214 before: &OrphanManage{
215 orphan: map[bc.Hash]*OrphanBlock{
216 blockHashes[0]: {testBlocks[0], time.Time{}},
218 prevOrphans: map[bc.Hash][]*bc.Hash{
219 {V0: 1}: {&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]: {testBlocks[0], time.Time{}},
232 blockHashes[1]: {testBlocks[1], time.Time{}},
234 prevOrphans: map[bc.Hash][]*bc.Hash{
235 {V0: 1}: {&blockHashes[0], &blockHashes[1]},
238 after: &OrphanManage{
239 orphan: map[bc.Hash]*OrphanBlock{
240 blockHashes[0]: {testBlocks[0], time.Time{}},
242 prevOrphans: map[bc.Hash][]*bc.Hash{
243 {V0: 1}: {&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{
268 time.Unix(1633479700, 0),
271 prevOrphans: map[bc.Hash][]*bc.Hash{
272 {V0: 1}: {&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{
285 time.Unix(1633479702, 0),
288 prevOrphans: map[bc.Hash][]*bc.Hash{
289 {V0: 1}: {&blockHashes[0]},
292 after: &OrphanManage{
293 orphan: map[bc.Hash]*OrphanBlock{
296 time.Unix(1633479702, 0),
299 prevOrphans: map[bc.Hash][]*bc.Hash{
300 {V0: 1}: {&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)