← Back to branch summary

~libbls/libbls/libbls-package

« back to all changes in this revision

Viewing changes to test/segment_tests.py

  • Committer: Alexandros Frantzis
  • Date: 2011-10-01 10:10:46 UTC
  • Revision ID: alf82@freemail.gr-20111001101046-etz52jurwzwc007x
Tags: upstream-0.3.2
Import upstream version 0.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/segment_tests.py
 
1
import unittest
 
2
import errno
 
3
from libbls import *
 
4
 
 
5
class SegmentTests(unittest.TestCase):
 
6
 
 
7
        def setUp(self):
 
8
                self.abc = "abc"
 
9
                (self.error, self.seg) = segment_new(self.abc, 0, 0, None)
 
10
        
 
11
        def tearDown(self):
 
12
                segment_free(self.seg)
 
13
 
 
14
        def testNew(self):
 
15
                "Create a segment"
 
16
                self.assertNotEqual(self.seg, None)
 
17
                self.assertEqual(segment_get_size(self.seg)[1], 0)
 
18
                self.assert_(segment_get_data(self.seg)[1] is self.abc)
 
19
        
 
20
        def testCopy(self):
 
21
                "Copy a segment"
 
22
 
 
23
                self.testChangeRange()
 
24
 
 
25
                (err, seg1) = segment_copy(self.seg)
 
26
 
 
27
                self.assertEqual(segment_get_start(seg1)[1],
 
28
                                segment_get_start(self.seg)[1])
 
29
 
 
30
                self.assertEqual(segment_get_size(seg1)[1],
 
31
                                segment_get_size(self.seg)[1])
 
32
 
 
33
                self.assert_(segment_get_data(seg1)[1] is
 
34
                                segment_get_data(self.seg)[1])
 
35
 
 
36
                segment_free(seg1)
 
37
                
 
38
        def testClear(self):
 
39
                "Clear a segment"
 
40
                self.testChangeRange()
 
41
 
 
42
                segment_clear(self.seg)
 
43
                self.assertEqual(segment_get_size(self.seg)[1], 0)
 
44
 
 
45
        def testChangeRange(self):
 
46
                "Change a segment"
 
47
                segment_set_range(self.seg, 666, 112358)
 
48
                
 
49
                self.assertEqual(segment_get_start(self.seg)[1], 666)
 
50
 
 
51
                self.assertEqual(segment_get_size(self.seg)[1], 112358)
 
52
        
 
53
        def testSplitMiddle(self):
 
54
                "Split a segment in the middle"
 
55
                segment_set_range(self.seg, 0, 1000)
 
56
 
 
57
                (err, seg1) = segment_split(self.seg, 99)
 
58
                
 
59
                self.assertEqual(segment_get_start(self.seg)[1], 0)
 
60
                self.assertEqual(segment_get_size(self.seg)[1], 99)
 
61
 
 
62
                self.assertEqual(segment_get_start(seg1)[1], 99)
 
63
                self.assertEqual(segment_get_size(seg1)[1], 901)
 
64
                
 
65
                segment_free(seg1)
 
66
 
 
67
        def testSplitEnd(self):
 
68
                "Split a segment at the end"
 
69
                segment_set_range(self.seg, 0, 1000)
 
70
 
 
71
                (err, seg1) = segment_split(self.seg, 999)
 
72
                
 
73
                self.assertEqual(segment_get_start(self.seg)[1], 0)
 
74
                self.assertEqual(segment_get_size(self.seg)[1], 999)
 
75
 
 
76
                self.assertEqual(segment_get_start(seg1)[1], 999)
 
77
                self.assertEqual(segment_get_size(seg1)[1], 1)
 
78
                
 
79
                segment_free(seg1)
 
80
 
 
81
        def testSplitStart(self):
 
82
                "Split a segment at the start"
 
83
                segment_set_range(self.seg, 0, 1000)
 
84
 
 
85
                (err, seg1) = segment_split(self.seg, 0)
 
86
                
 
87
                self.assertEqual(segment_get_size(self.seg)[1], 0)
 
88
 
 
89
                self.assertEqual(segment_get_start(seg1)[1], 0)
 
90
                self.assertEqual(segment_get_size(seg1)[1], 1000)
 
91
                
 
92
                segment_free(seg1)
 
93
 
 
94
        def testSplitOutOfRange(self):
 
95
                "Try to split at a point out of range"
 
96
                segment_set_range(self.seg, 0, 1000)
 
97
 
 
98
                (err, seg1) = segment_split(self.seg, 1000)
 
99
                
 
100
                self.assertNotEqual(err, 0)
 
101
                self.assertEqual(seg1, None)
 
102
                
 
103
        def testMerge(self):
 
104
                "Merge two segments"
 
105
                segment_set_range(self.seg, 0, 1000)
 
106
 
 
107
                (err, seg1) = segment_split(self.seg, 600)
 
108
                self.assertEqual(err, 0)
 
109
 
 
110
                self.assertEqual(segment_get_start(self.seg)[1], 0)
 
111
                self.assertEqual(segment_get_size(self.seg)[1], 600)
 
112
 
 
113
                self.assertEqual(segment_get_start(seg1)[1], 600)
 
114
                self.assertEqual(segment_get_size(seg1)[1], 400)
 
115
 
 
116
                # Merge the segments
 
117
                err = segment_merge(self.seg, seg1)
 
118
                self.assertEqual(err, 0)
 
119
                self.assertEqual(segment_get_start(self.seg)[1], 0)
 
120
                self.assertEqual(segment_get_size(self.seg)[1], 1000)
 
121
 
 
122
                self.assertEqual(segment_get_start(seg1)[1], 600)
 
123
                self.assertEqual(segment_get_size(seg1)[1], 400)
 
124
                
 
125
                segment_free(seg1)
 
126
 
 
127
        def testMergeBoundaryCases(self):
 
128
                "Try boundary conditions when merging"
 
129
 
 
130
                err = segment_set_range(self.seg, 0, 1000)
 
131
                self.assertEqual(err, 0)
 
132
 
 
133
                (err, seg1) = segment_copy(self.seg)
 
134
                self.assertEqual(err, 0)
 
135
 
 
136
                err = segment_set_range(self.seg, 1001, 10)
 
137
                self.assertEqual(err, 0)
 
138
 
 
139
                err = segment_merge(self.seg, seg1)
 
140
                self.assertNotEqual(err, 0)
 
141
 
 
142
                segment_free(seg1)
 
143
 
 
144
        def testMergeOverflow(self):
 
145
                "Try boundary conditions for overflow when merging"
 
146
 
 
147
                err = segment_set_range(self.seg, 0, 1)
 
148
                self.assertEqual(err, 0)
 
149
 
 
150
                (err, seg1) = segment_copy(self.seg)
 
151
                self.assertEqual(err, 0)
 
152
 
 
153
                err = segment_set_range(seg1, 1, get_max_off_t())
 
154
                self.assertEqual(err, 0)
 
155
 
 
156
                err = segment_merge(self.seg, seg1)
 
157
                self.assertEqual(err, errno.EOVERFLOW)
 
158
 
 
159
                # This should succeed
 
160
                err = segment_set_range(seg1, 1, get_max_off_t() - 1)
 
161
                self.assertEqual(err, 0)
 
162
 
 
163
                err = segment_merge(self.seg, seg1)
 
164
                self.assertEqual(err, 0)
 
165
 
 
166
                segment_free(seg1)
 
167
 
 
168
        def testRangeOverflow(self):
 
169
                "Try boundary conditions for overflow"
 
170
 
 
171
                # These should succeed
 
172
                err = segment_set_range(self.seg, 0, get_max_off_t()) 
 
173
                self.assertEqual(err, 0)
 
174
 
 
175
                err = segment_set_range(self.seg, get_max_off_t(), 0) 
 
176
                self.assertEqual(err, 0)
 
177
 
 
178
                err = segment_set_range(self.seg, 1, get_max_off_t()) 
 
179
                self.assertEqual(err, 0)
 
180
 
 
181
                err = segment_set_range(self.seg, get_max_off_t(), 1) 
 
182
                self.assertEqual(err, 0)
 
183
 
 
184
                # These should fail
 
185
                err = segment_set_range(self.seg, 2, get_max_off_t()) 
 
186
                self.assertNotEqual(err, 0)
 
187
 
 
188
                err = segment_set_range(self.seg, get_max_off_t(), 2) 
 
189
                self.assertNotEqual(err, 0)
 
190
 
 
191
if __name__ == '__main__':
 
192
        unittest.main()