cubefs

sorted_extents_test.go
139 строк · 5.0 Кб
Перенос по словам
1
package metanode
2

3
import (
4
	"testing"
5

6
	"github.com/cubefs/cubefs/proto"
7
)
8

9
func TestAppend01(t *testing.T) {
10
	se := NewSortedExtents()
11
	se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 0, Size: 1000, ExtentId: 1}, nil, nil)
12
	se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 2000, Size: 1000, ExtentId: 2}, nil, nil)
13
	se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 4000, Size: 1000, ExtentId: 3}, nil, nil)
14
	se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 3000, Size: 500, ExtentId: 4}, nil, nil)
15
	t.Logf("\neks: %v\n", se.eks)
16
	if se.Size() != 5000 || len(se.eks) != 4 || se.eks[2].ExtentId != 4 {
17
		t.Fail()
18
	}
19
	t.Logf("%v\n", se.Size())
20
}
21

22
// The same extent file is extended
23
func TestAppend02(t *testing.T) {
24
	se := NewSortedExtents()
25
	delExtents, status := se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 0, Size: 1000, ExtentId: 1}, nil, nil)
26
	t.Logf("\ndel: %v\nstatus: %v\neks: %v", delExtents, status, se.eks)
27
	if status != proto.OpOk || len(delExtents) != 0 {
28
		t.Fail()
29
	}
30
	delExtents, status = se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 0, Size: 2000, ExtentId: 1}, nil, nil)
31
	t.Logf("\ndel: %v\nstatus: %v\neks: %v", delExtents, status, se.eks)
32
	if status != proto.OpOk || len(delExtents) != 0 || se.Size() != 2000 {
33
		t.Fail()
34
	}
35
	discard := make([]proto.ExtentKey, 0)
36
	discard = append(discard, proto.ExtentKey{FileOffset: 0, Size: 2000, ExtentId: 1})
37
	delExtents, status = se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 0, Size: 2000, ExtentId: 2}, nil, discard)
38
	t.Logf("\ndel: %v\nstatus: %v\neks: %v", delExtents, status, se.eks)
39
	if status != proto.OpOk || len(delExtents) != 1 || delExtents[0].ExtentId != 1 || se.eks[0].ExtentId != 2 {
40
		t.Fail()
41
	}
42
	t.Logf("%v\n", se.Size())
43
}
44

45
func TestAppend03(t *testing.T) {
46
	se := NewSortedExtents()
47
	delExtents, status := se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 0, Size: 1000, ExtentId: 1}, nil, nil)
48
	t.Logf("\ndel: %v\nstatus: %v\neks: %v", delExtents, status, se.eks)
49
	discard := make([]proto.ExtentKey, 0)
50
	discard = append(discard, proto.ExtentKey{FileOffset: 0, Size: 1000, ExtentId: 1})
51
	delExtents, status = se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 0, Size: 1000, ExtentId: 2}, nil, discard)
52
	t.Logf("\ndel: %v\nstatus: %v\neks: %v", delExtents, status, se.eks)
53
	if status != proto.OpOk || len(delExtents) != 1 || delExtents[0].ExtentId != 1 ||
54
		se.eks[0].ExtentId != 2 || se.Size() != 1000 {
55
		t.Fail()
56
	}
57
}
58

59
// This is the case when multiple clients are writing to the same file
60
// with an overlapping file range. The final file data is not guaranteed
61
// for such case, but we should be aware of what the extents look like.
62
func TestAppend04(t *testing.T) {
63
	se := NewSortedExtents()
64
	delExtents, status := se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 0, Size: 1000, ExtentId: 1}, nil, nil)
65
	t.Logf("\nstatus: %v\ndel: %v\neks: %v", status, delExtents, se.eks)
66
	delExtents, status = se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 1000, Size: 1000, ExtentId: 2}, nil, nil)
67
	t.Logf("\nstatus: %v\ndel: %v\neks: %v", status, delExtents, se.eks)
68
	delExtents, status = se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 1500, Size: 4000, ExtentId: 3}, nil, nil)
69
	t.Logf("\nstatus: %v\ndel: %v\neks: %v", status, delExtents, se.eks)
70
	discard := make([]proto.ExtentKey, 0)
71
	discard = append(discard, proto.ExtentKey{FileOffset: 1000, Size: 1000, ExtentId: 2})
72
	delExtents, status = se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 500, Size: 4000, ExtentId: 4}, nil, discard)
73
	t.Logf("\nstatus: %v\ndel: %v\neks: %v", status, delExtents, se.eks)
74
	if len(delExtents) != 1 || delExtents[0].ExtentId != 2 ||
75
		len(se.eks) != 3 || se.Size() != 5500 ||
76
		se.eks[0].ExtentId != 1 || se.eks[1].ExtentId != 4 ||
77
		se.eks[2].ExtentId != 3 {
78
		t.Fail()
79
	}
80
	t.Logf("%v\n", se.Size())
81
}
82

83
func TestTruncate01(t *testing.T) {
84
	se := NewSortedExtents()
85
	delExtents, _ := se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 0, Size: 1000, ExtentId: 1}, nil, nil)
86
	t.Logf("\ndel: %v\neks: %v", delExtents, se.eks)
87
	delExtents, _ = se.AppendWithCheck(0, proto.ExtentKey{FileOffset: 2000, Size: 1000, ExtentId: 2}, nil, nil)
88
	t.Logf("\ndel: %v\neks: %v", delExtents, se.eks)
89
	delExtents = se.Truncate(500, nil, nil)
90
	t.Logf("\ndel: %v\neks: %v", delExtents, se.eks)
91
	if len(delExtents) != 2 || delExtents[1].ExtentId != 2 ||
92
		len(se.eks) != 1 || se.eks[0].ExtentId != 1 ||
93
		se.Size() != 500 {
94
		t.Fail()
95
	}
96
}
97

98
func TestSortedMarshal(t *testing.T) {
99
	se := NewSortedExtents()
100

101
	e1 := proto.ExtentKey{
102
		FileOffset:   1,
103
		Size:         1010,
104
		ExtentId:     10,
105
		ExtentOffset: 10110,
106
		PartitionId:  100,
107
		CRC:          0o000,
108
	}
109
	e2 := proto.ExtentKey{
110
		FileOffset:   4,
111
		Size:         1030,
112
		ExtentId:     10,
113
		ExtentOffset: 1010,
114
		PartitionId:  100,
115
		CRC:          0o200,
116
	}
117

118
	se.eks = append(se.eks, e1)
119
	se.eks = append(se.eks, e2)
120

121
	data, err := se.MarshalBinary(false)
122
	if err != nil {
123
		t.Fail()
124
	}
125

126
	se2 := NewSortedExtents()
127
	err, _ = se2.UnmarshalBinary(data, false)
128
	if err != nil {
129
		t.Fail()
130
	}
131

132
	for idx := 0; idx < len(se.eks); idx++ {
133
		e1 := se.eks[idx]
134
		e2 := se2.eks[idx]
135
		if e1 != e2 || e1.CRC != e2.CRC {
136
			t.Fail()
137
		}
138
	}
139
}
140
cubefs

Использование cookies
