← Back to branch summary

~ubuntu-branches/ubuntu/precise/landscape-client/precise-proposed

« back to all changes in this revision

Viewing changes to landscape/lib/tests/test_sequenceranges.py

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Hasenack
  • Date: 2011-07-21 15:40:46 UTC
  • Revision ID: james.westby@ubuntu.com-20110721154046-l9vwkd062b4war77
Tags: 11.07.1.1-0ubuntu1.11.10.0
https://launchpad.net/bugs/814223
Included missing files (LP: #814223).

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/lib/tests/test_sequenceranges.py
 
1
import unittest
 
2
 
 
3
from landscape.lib.sequenceranges import (
 
4
    SequenceRanges, remove_from_ranges, add_to_ranges, find_ranges_index,
 
5
    ranges_to_sequence, sequence_to_ranges, SequenceError)
 
6
 
 
7
 
 
8
class SequenceRangesTest(unittest.TestCase):
 
9
 
 
10
    def setUp(self):
 
11
        self.ranges = [1, 2, (15, 17), 19, (21, 24), 26, 27]
 
12
        self.sequence = [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27]
 
13
 
 
14
    def test_empty_to_sequence(self):
 
15
        self.assertEqual(SequenceRanges().to_sequence(), [])
 
16
 
 
17
    def test_empty_to_ranges(self):
 
18
        self.assertEqual(SequenceRanges().to_ranges(), [])
 
19
 
 
20
    def test_from_to_sequence(self):
 
21
        obj = SequenceRanges.from_sequence(self.sequence)
 
22
        self.assertEqual(obj.to_sequence(), self.sequence)
 
23
 
 
24
    def test_from_to_ranges(self):
 
25
        obj = SequenceRanges.from_ranges(self.ranges)
 
26
        self.assertEqual(obj.to_ranges(), self.ranges)
 
27
 
 
28
    def test_to_ranges_immutable(self):
 
29
        obj = SequenceRanges.from_ranges(self.ranges)
 
30
        obj.to_ranges().append(123)
 
31
        self.assertEqual(obj.to_ranges(), self.ranges)
 
32
 
 
33
    def test_from_sequence_to_ranges(self):
 
34
        obj = SequenceRanges.from_sequence(self.sequence)
 
35
        self.assertEqual(list(obj.to_ranges()), self.ranges)
 
36
 
 
37
    def test_from_ranges_to_sequence(self):
 
38
        obj = SequenceRanges.from_ranges(self.ranges)
 
39
        self.assertEqual(list(obj.to_sequence()), self.sequence)
 
40
 
 
41
    def test_iter(self):
 
42
        obj = SequenceRanges.from_ranges(self.ranges)
 
43
        self.assertEqual(list(obj), self.sequence)
 
44
 
 
45
    def test_contains(self):
 
46
        obj = SequenceRanges.from_ranges(self.ranges)
 
47
        self.assertTrue(1 in obj)
 
48
        self.assertTrue(2 in obj)
 
49
        self.assertTrue(15 in obj)
 
50
        self.assertTrue(16 in obj)
 
51
        self.assertTrue(17 in obj)
 
52
        self.assertTrue(19 in obj)
 
53
        self.assertTrue(27 in obj)
 
54
        self.assertTrue(0 not in obj)
 
55
        self.assertTrue(3 not in obj)
 
56
        self.assertTrue(14 not in obj)
 
57
        self.assertTrue(18 not in obj)
 
58
        self.assertTrue(20 not in obj)
 
59
        self.assertTrue(28 not in obj)
 
60
 
 
61
    def test_add(self):
 
62
        obj = SequenceRanges()
 
63
        obj.add(1)
 
64
        self.assertEqual(obj.to_ranges(), [1])
 
65
        obj.add(2)
 
66
        self.assertEqual(obj.to_ranges(), [1, 2])
 
67
        obj.add(3)
 
68
        self.assertEqual(obj.to_ranges(), [(1, 3)])
 
69
        obj.add(3)
 
70
        self.assertEqual(obj.to_ranges(), [(1, 3)])
 
71
 
 
72
    def test_remove(self):
 
73
        obj = SequenceRanges.from_ranges([(1, 3)])
 
74
        obj.remove(2)
 
75
        self.assertEqual(obj.to_ranges(), [1, 3])
 
76
        obj.remove(1)
 
77
        self.assertEqual(obj.to_ranges(), [3])
 
78
        obj.remove(3)
 
79
        self.assertEqual(obj.to_ranges(), [])
 
80
        obj.remove(4)
 
81
        self.assertEqual(obj.to_ranges(), [])
 
82
 
 
83
 
 
84
class SequenceToRangesTest(unittest.TestCase):
 
85
 
 
86
    def test_empty(self):
 
87
        self.assertEqual(list(sequence_to_ranges([])), [])
 
88
 
 
89
    def test_one_element(self):
 
90
        self.assertEqual(list(sequence_to_ranges([1])), [1])
 
91
 
 
92
    def test_two_elements(self):
 
93
        self.assertEqual(list(sequence_to_ranges([1, 2])), [1, 2])
 
94
 
 
95
    def test_three_elements(self):
 
96
        self.assertEqual(list(sequence_to_ranges([1, 2, 3])), [(1, 3)])
 
97
 
 
98
    def test_many_elements(self):
 
99
        sequence = [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27]
 
100
        self.assertEqual(list(sequence_to_ranges(sequence)),
 
101
                         [1, 2, (15, 17), 19, (21, 24), 26, 27])
 
102
 
 
103
    def test_out_of_order(self):
 
104
        self.assertRaises(SequenceError, sequence_to_ranges([2, 1]).next)
 
105
 
 
106
    def test_duplicated_item(self):
 
107
        self.assertRaises(SequenceError, sequence_to_ranges([1, 1]).next)
 
108
 
 
109
 
 
110
class RangesToSequenceTest(unittest.TestCase):
 
111
 
 
112
    def test_empty(self):
 
113
        self.assertEqual(list(ranges_to_sequence([])), [])
 
114
 
 
115
    def test_one_element(self):
 
116
        self.assertEqual(list(ranges_to_sequence([1])), [1])
 
117
 
 
118
    def test_two_elements(self):
 
119
        self.assertEqual(list(ranges_to_sequence([1, 2])), [1, 2])
 
120
 
 
121
    def test_three_elements(self):
 
122
        self.assertEqual(list(ranges_to_sequence([(1, 3)])), [1, 2, 3])
 
123
 
 
124
    def test_many_elements(self):
 
125
        ranges = [1, 2, (15, 17), 19, (21, 24), 26, 27]
 
126
        self.assertEqual(list(ranges_to_sequence(ranges)),
 
127
                         [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27])
 
128
 
 
129
 
 
130
class FindRangesIndexTest(unittest.TestCase):
 
131
 
 
132
    def test_empty(self):
 
133
        self.assertEqual(find_ranges_index([], 2), 0)
 
134
 
 
135
    def test_sequence(self):
 
136
        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 0), 0)
 
137
        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 1), 0)
 
138
        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 2), 1)
 
139
        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 3), 2)
 
140
        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 4), 3)
 
141
        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 5), 4)
 
142
        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 6), 5)
 
143
 
 
144
    def test_sequence_with_missing(self):
 
145
        self.assertEqual(find_ranges_index([1, 2, 4, 5], 2), 1)
 
146
        self.assertEqual(find_ranges_index([1, 2, 4, 5], 3), 2)
 
147
        self.assertEqual(find_ranges_index([1, 2, 4, 5], 4), 2)
 
148
 
 
149
    def test_range(self):
 
150
        self.assertEqual(find_ranges_index([1, (2, 4), 5], 0), 0)
 
151
        self.assertEqual(find_ranges_index([1, (2, 4), 5], 1), 0)
 
152
        self.assertEqual(find_ranges_index([1, (2, 4), 5], 2), 1)
 
153
        self.assertEqual(find_ranges_index([1, (2, 4), 5], 3), 1)
 
154
        self.assertEqual(find_ranges_index([1, (2, 4), 5], 4), 1)
 
155
        self.assertEqual(find_ranges_index([1, (2, 4), 5], 5), 2)
 
156
        self.assertEqual(find_ranges_index([1, (2, 4), 5], 6), 3)
 
157
 
 
158
    def test_range_with_missing(self):
 
159
        self.assertEqual(find_ranges_index([1, (3, 4), 5], 0), 0)
 
160
        self.assertEqual(find_ranges_index([1, (3, 4), 5], 1), 0)
 
161
        self.assertEqual(find_ranges_index([1, (3, 4), 5], 2), 1)
 
162
        self.assertEqual(find_ranges_index([1, (3, 4), 5], 3), 1)
 
163
        self.assertEqual(find_ranges_index([1, (3, 4), 5], 4), 1)
 
164
        self.assertEqual(find_ranges_index([1, (3, 4), 5], 5), 2)
 
165
        self.assertEqual(find_ranges_index([1, (3, 4), 5], 6), 3)
 
166
 
 
167
 
 
168
class AddToRangesTest(unittest.TestCase):
 
169
 
 
170
    def test_empty(self):
 
171
        ranges = []
 
172
        add_to_ranges(ranges, 1)
 
173
        self.assertEqual(ranges, [1])
 
174
 
 
175
    def test_append(self):
 
176
        ranges = [1]
 
177
        add_to_ranges(ranges, 2)
 
178
        self.assertEqual(ranges, [1, 2])
 
179
 
 
180
    def test_prepend(self):
 
181
        ranges = [2]
 
182
        add_to_ranges(ranges, 1)
 
183
        self.assertEqual(ranges, [1, 2])
 
184
 
 
185
    def test_insert(self):
 
186
        ranges = [1, 4]
 
187
        add_to_ranges(ranges, 2)
 
188
        self.assertEqual(ranges, [1, 2, 4])
 
189
 
 
190
    def test_merge_sequence(self):
 
191
        ranges = [1, 2, 4, 5]
 
192
        add_to_ranges(ranges, 3)
 
193
        self.assertEqual(ranges, [(1, 5)])
 
194
 
 
195
    def test_merge_ranges(self):
 
196
        ranges = [(1, 3), (5, 7)]
 
197
        add_to_ranges(ranges, 4)
 
198
        self.assertEqual(ranges, [(1, 7)])
 
199
 
 
200
    def test_merge_sequence_and_ranges(self):
 
201
        ranges = [(1, 3), 5, 6, 7]
 
202
        add_to_ranges(ranges, 4)
 
203
        self.assertEqual(ranges, [(1, 7)])
 
204
 
 
205
    def test_merge_sequence_and_ranges_with_gaps(self):
 
206
        ranges = [1, (3, 5), 7, 9]
 
207
        add_to_ranges(ranges, 6)
 
208
        self.assertEqual(ranges, [1, (3, 7), 9])
 
209
 
 
210
    def test_dont_merge_ranges_with_gap(self):
 
211
        ranges = [(1, 3), (7, 9)]
 
212
        add_to_ranges(ranges, 5)
 
213
        self.assertEqual(ranges, [(1, 3), 5, (7, 9)])
 
214
 
 
215
    def test_duplicate(self):
 
216
        ranges = [1]
 
217
        add_to_ranges(ranges, 1)
 
218
        self.assertEqual(ranges, [1])
 
219
 
 
220
    def test_duplicate_in_range(self):
 
221
        ranges = [(1, 3)]
 
222
        add_to_ranges(ranges, 1)
 
223
        self.assertEqual(ranges, [(1, 3)])
 
224
        add_to_ranges(ranges, 2)
 
225
        self.assertEqual(ranges, [(1, 3)])
 
226
        add_to_ranges(ranges, 3)
 
227
        self.assertEqual(ranges, [(1, 3)])
 
228
 
 
229
 
 
230
class RemoveFromRangesTest(unittest.TestCase):
 
231
 
 
232
    def test_empty(self):
 
233
        ranges = []
 
234
        remove_from_ranges(ranges, 1)
 
235
        self.assertEqual(ranges, [])
 
236
 
 
237
    def test_single(self):
 
238
        ranges = [1]
 
239
        remove_from_ranges(ranges, 1)
 
240
        self.assertEqual(ranges, [])
 
241
 
 
242
    def test_remove_before(self):
 
243
        ranges = [1, 2]
 
244
        remove_from_ranges(ranges, 1)
 
245
        self.assertEqual(ranges, [2])
 
246
 
 
247
    def test_remove_after(self):
 
248
        ranges = [1, 2]
 
249
        remove_from_ranges(ranges, 2)
 
250
        self.assertEqual(ranges, [1])
 
251
 
 
252
    def test_remove_inside(self):
 
253
        ranges = [1, 2, 3]
 
254
        remove_from_ranges(ranges, 2)
 
255
        self.assertEqual(ranges, [1, 3])
 
256
 
 
257
    def test_remove_unexistent(self):
 
258
        ranges = [1, 3]
 
259
        remove_from_ranges(ranges, 2)
 
260
        self.assertEqual(ranges, [1, 3])
 
261
 
 
262
    def test_split_range(self):
 
263
        ranges = [(1, 5)]
 
264
        remove_from_ranges(ranges, 3)
 
265
        self.assertEqual(ranges, [1, 2, 4, 5])
 
266
 
 
267
    def test_split_range_into_ranges(self):
 
268
        ranges = [(1, 7)]
 
269
        remove_from_ranges(ranges, 4)
 
270
        self.assertEqual(ranges, [(1, 3), (5, 7)])
 
271
 
 
272
    def test_decrement_left(self):
 
273
        ranges = [(1, 5)]
 
274
        remove_from_ranges(ranges, 1)
 
275
        self.assertEqual(ranges, [(2, 5)])
 
276
 
 
277
    def test_decrement_right(self):
 
278
        ranges = [(1, 5)]
 
279
        remove_from_ranges(ranges, 5)
 
280
        self.assertEqual(ranges, [(1, 4)])
 
281
 
 
282
    def test_dont_removing_unmatched_range(self):
 
283
        ranges = [(1, 3), (5, 7)]
 
284
        remove_from_ranges(ranges, 4)
 
285
        self.assertEqual(ranges, [(1, 3), (5, 7)])
 
286
 
 
287
 
 
288
def test_suite():
 
289
    return unittest.TestSuite((
 
290
        unittest.makeSuite(SequenceToRangesTest),
 
291
        unittest.makeSuite(RangesToSequenceTest),
 
292
        unittest.makeSuite(SequenceRangesTest),
 
293
        unittest.makeSuite(FindRangesIndexTest),
 
294
        unittest.makeSuite(AddToRangesTest),
 
295
        unittest.makeSuite(RemoveFromRangesTest),
 
296
    ))