Debian Codegraph @

csb/test/cases/core/__init__.py

raw ◀ ▶
Source reconstructed at patch state 0 of 1 — not the installed (fully patched) source.
1 Debian patch touch this file
1 import sys
2 import operator
3 import copy
4
5 import csb.test as test
6 import csb.core as utils
7
8 from csb.io import Pickle
9
10
11 @test.unit
12 class TestDeepCopy(test.Case):
13
14 def runTest(self):
15
16 rec = sys.getrecursionlimit()
17 obj = ['X']
18 copy = utils.deepcopy(obj, recursion=(rec + 1))
19
20 self.assertEqual(obj, copy)
21 self.assertNotEquals(id(obj), id(copy))
22
23 @test.unit
24 class TestIterable(test.Case):
25
26 def runTest(self):
27
28 for i in [ [], tuple(), iter([]) ]:
29 self.assertTrue(utils.iterable(i))
30
31 self.assertFalse(utils.iterable(""))
32
33 @test.unit
34 class TestEnum(test.Case):
35
36 def setUp(self):
37
38 class SampleEnum(utils.enum):
39 A=0; B=1; C=66
40
41 super(TestEnum, self).setUp()
42 self.enum = SampleEnum
43
44 def testConstructor(self):
45
46 def test():
47 class FaultyEnum(utils.enum):
48 A=1; B=1
49
50 self.assertRaises(utils.EnumValueError, test)
51 self.assertEqual(self.enum.__name__, 'SampleEnum')
52
53 def testIterator(self):
54
55 result = list(self.enum)
56 members = [self.enum.A, self.enum.B, self.enum.C]
57 self.assertEqual(set(result), set(members))
58
59 def testInOperator(self):
60 self.assertTrue(self.enum.C in self.enum)
61
62 def testMutability(self):
63
64 def test():
65 self.enum.NEW = 1
66
67 self.assertRaises(AttributeError, test)
68 self.assertRaises(TypeError, self.enum)
69
70 def testComparison(self):
71 self.assertEqual(self.enum.A, 0)
72 self.assertEqual(self.enum.C, 66)
73 self.assertFalse(self.enum.C is 66)
74 self.assertFalse(isinstance(self.enum.A, int))
75
76 def testStr(self):
77 self.assertEqual(str(self.enum.A), '0')
78 self.assertEqual(int(self.enum.A), 0)
79 self.assertEqual(self.enum.A.value, 0)
80
81 def testRepr(self):
82 self.assertEqual(repr(self.enum.A), 'A')
83 self.assertEqual(self.enum.A.name, 'A')
84
85 def testMembers(self):
86 result = utils.Enum.members(self.enum)
87 members = [self.enum.A, self.enum.B, self.enum.C]
88 self.assertEqual(set(result), set(members))
89
90 def testCreate(self):
91 new = utils.Enum.create('NewEnum', A=11, B=22)
92 self.assertEqual(new.__name__, 'NewEnum')
93 self.assertEqual(new.B, 22)
94
95 def testNames(self):
96 result = utils.Enum.names(self.enum)
97 names = map(repr, [self.enum.A, self.enum.B, self.enum.C])
98 names2 = map(operator.attrgetter('name'), [self.enum.A, self.enum.B, self.enum.C])
99 self.assertEqual(set(result), set(names))
100 self.assertEqual(set(result), set(names2))
101
102 def testValues(self):
103 result = utils.Enum.values(self.enum)
104 values = map(int, [self.enum.A, self.enum.B, self.enum.C])
105 values2 = map(operator.attrgetter('value'), [self.enum.A, self.enum.B, self.enum.C])
106 self.assertEqual(set(result), set(values))
107 self.assertEqual(set(result), set(values2))
108
109 def testParseValue(self):
110 item = utils.Enum.parse(self.enum, 66)
111 self.assertTrue(item is self.enum.C)
112 self.assertRaises(utils.EnumValueError, utils.Enum.parse, self.enum, 111)
113 self.assertRaises(utils.EnumValueError, utils.Enum.parse, self.enum, '0')
114
115 def testParseName(self):
116 item = utils.Enum.parsename(self.enum, 'A')
117 self.assertTrue(item is self.enum.A)
118 self.assertRaises(utils.EnumMemberError, utils.Enum.parsename, self.enum, 'XXX')
119
120 def testIsMember(self):
121 self.assertTrue(utils.Enum.ismember(self.enum.A, self.enum))
122
123 def testSerialization(self):
124
125 from csb.bio.sequence import SequenceTypes
126
127 self.assertTrue(copy.copy(SequenceTypes.Protein) is SequenceTypes.Protein)
128 self.assertTrue(copy.deepcopy(SequenceTypes.Protein) is SequenceTypes.Protein)
129 self.assertTrue(utils.deepcopy(SequenceTypes.Protein) is SequenceTypes.Protein)
130 self.assertTrue(Pickle.loads(Pickle.dumps(SequenceTypes.Protein)) is SequenceTypes.Protein)
131
132 self.assertTrue(copy.deepcopy(SequenceTypes) is SequenceTypes)
133 self.assertTrue(copy.deepcopy(SequenceTypes) is SequenceTypes)
134 self.assertTrue(Pickle.loads(Pickle.dumps(SequenceTypes)) is SequenceTypes)
135
136 @test.unit
137 class TestDictionaryContainer(test.Case):
138
139 def setUp(self):
140
141 super(TestDictionaryContainer, self).setUp()
142
143 self.dict = utils.OrderedDict([('A', 1), ('B', 2)])
144 self.keys = ('A', 'B', 'C', 'D', 'Z')
145 self.new = utils.DictionaryContainer
146 self.test = utils.DictionaryContainer(items=self.dict, restrict=self.keys)
147
148 def testConstructor(self):
149 new = utils.DictionaryContainer(items=self.dict, restrict=self.keys)
150 self.assertEqual(dict(new), dict(self.dict))
151 self.assertEqual(list(new), list(self.dict)) # True if the dictionary is ordered
152 self.assertEqual(new.length, len(self.dict))
153 self.assertRaises(utils.InvalidKeyError, self.new, items={'X': 1}, restrict=self.keys)
154
155 def testAppend(self):
156 self.test.append('C', 1)
157 self.assertTrue('C' in self.test)
158 self.assertRaises(utils.DuplicateKeyError, self.test.append, key='C', item=1)
159 self.assertRaises(utils.InvalidKeyError, self.test.append, key='X', item=1)
160
161 def testRemove(self):
162 self.assertTrue('A' in self.test)
163 self.test._remove('A')
164 self.assertFalse('A' in self.test)
165
166 def testGetitem(self):
167 self.assertEqual(self.test['B'], self.dict['B'])
168 self.assertRaises(utils.ItemNotFoundError, lambda k: self.test[k], 66)
169
170 def testLength(self):
171 self.assertEqual(self.test.length, len(self.test))
172 self.assertEqual(self.test.length, 2)
173
174 def testBool(self):
175 self.assertTrue(self.test)
176 self.assertFalse(self.new())
177
178 def testSet(self):
179 new = utils.DictionaryContainer(items=self.dict, restrict=self.keys)
180 new._set({'Z': 6})
181 self.assertTrue('Z' in new)
182 self.assertFalse('A' in new)
183
184 def testUpdate(self):
185 new = utils.DictionaryContainer(items=self.dict, restrict=self.keys)
186
187 new._update({'A': 7})
188 self.assertTrue('A' in new)
189 self.assertEqual(new['A'], 7)
190
191 self.assertRaises(utils.ItemNotFoundError, new._update, {'Z': 0})
192
193 @test.unit
194 class TestCollectionContainer(test.Case):
195
196 def setUp(self):
197
198 super(TestCollectionContainer, self).setUp()
199
200 self.items = [11, 22, 33]
201 self.start = 5
202 self.new = utils.CollectionContainer
203 self.test = utils.CollectionContainer(items=self.items, type=int, start_index=self.start)
204
205 def testConstructor(self):
206 new = utils.CollectionContainer(items=self.items, type=int, start_index=self.start)
207 self.assertEqual(list(new), list(self.items))
208 self.assertEqual(new.length, len(self.items))
209 self.assertRaises(TypeError, self.new, items=['S', 1.2], type=int)
210
211 def testGetitem(self):
212 self.assertEqual(self.test[self.start], self.items[0])
213 self.assertEqual(self.test[self.test.start_index], self.items[0])
214 self.assertEqual(self.test[self.test.last_index], self.items[-1])
215 self.assertEqual(self.test[-1], self.items[-1])
216 self.assertEqual(self.test[-1 :-2], self.items[-1 :-2])
217
218 self.assertEqual(self.test[: self.start + 2], self.items[:2])
219 self.assertEqual(self.test[self.start + 2 :], self.items[2:])
220 self.assertEqual(self.test[:], self.items[:])
221
222 def get(i):
223 return self.test[i]
224
225 self.assertRaises(utils.CollectionIndexError, get, self.start + len(self.items)) # i = end + 1
226 if self.start > 0:
227 self.assertRaises(utils.CollectionIndexError, get, self.start - 1) # i = start - 1, i >= 0
228
229 def testLength(self):
230 self.assertEqual(self.test.length, len(self.test))
231 self.assertEqual(self.test.length, len(self.items))
232
233 def testBool(self):
234 self.assertTrue(self.test)
235 self.assertFalse(self.new())
236
237 def testIndices(self):
238 new = self.new(items=self.items, type=int, start_index=self.start)
239 self.assertEqual(new.start_index, self.start)
240 self.assertEqual(new.last_index, self.start + len(self.items) - 1)
241 self.assertEqual(new.length, len(self.items))
242
243 def testAppend(self):
244 rank = self.test.append(44)
245 self.assertTrue(44 in self.test)
246 self.assertEqual(rank, self.test.last_index)
247 self.assertRaises(TypeError, self.test.append, item='S')
248
249 def testUpdate(self):
250 new = self.new(items=self.items, type=int, start_index=self.start)
251
252 new._update([98, 99])
253 self.assertTrue(98 in new)
254 self.assertEqual(new.length, 2)
255
256 self.assertRaises(TypeError, new._update, ['S'])
257
258 @test.unit
259 class TestAbstractContainer(test.Case):
260
261 def setUp(self):
262
263 super(TestAbstractContainer, self).setUp()
264
265 dictitems = {'A': 1, 'B': 2}
266 self.items = dictitems
267
268 listitems = [11, 22]
269 start = 5
270 self.listitems = listitems
271 self.start = start
272
273 class DummyDict(utils.AbstractContainer):
274 @property
275 def _children(self):
276 return utils.DictionaryContainer(dictitems)
277
278 class DummyList(utils.AbstractContainer):
279 @property
280 def _children(self):
281 return utils.CollectionContainer(listitems, start_index=start)
282
283 self.dict = DummyDict()
284 self.list = DummyList()
285
286 def testGetitem(self):
287 self.assertEqual(self.dict['A'], 1)
288 self.assertRaises(utils.ItemNotFoundError, lambda k: self.dict[k], 'X')
289
290 self.assertEqual(self.list[self.start], self.listitems[0])
291 if self.start > 0:
292 self.assertRaises(utils.CollectionIndexError, lambda i: self.list[i], 0)
293
294 def testIterator(self):
295 self.assertEqual(list(self.items), list(self.dict))
296 self.assertEqual(list(self.listitems), list(self.list))
297
298 @test.unit
299 class TestAbstractNIContainer(test.Case):
300
301 def setUp(self):
302
303 super(TestAbstractNIContainer, self).setUp()
304
305 items = list(set([11, 22, 33]))
306 start = 1
307
308 self.items = items
309 self.start = start
310
311 class Dummy(utils.AbstractNIContainer):
312 @property
313 def _children(self):
314 return utils.CollectionContainer(items, start_index=start)
315
316 self.test = Dummy()
317
318 def testGetitem(self):
319 assert self.start > 0
320
321 self.assertEqual(self.test[0], self.items[0])
322 self.assertEqual(self.test[1:2], self.items[1:2])
323 self.assertEqual(self.test[0], self.test._children[self.start])
324 self.assertNotEqual(self.test[1], self.test._children[1])
325
326 self.assertRaises(IndexError, lambda i: self.test[i], 9999999)
327
328 def testIterator(self):
329 self.assertEqual(list(self.items), list(self.test))
330
331 @test.functional
332 class TestOrderedDict(test.Case):
333
334 def runTest(self):
335
336 items = [('G', 4), ('A', 2), ('C', 8), ('B', 7)]
337 odict = utils.OrderedDict(items)
338
339 self.assertEqual(list(odict.items()), items)
340
341 for i, k in enumerate(odict):
342 self.assertEqual(k, items[i][0])
343 self.assertEqual(odict[k], items[i][1])
344
345
346 if __name__ == '__main__':
347
348 test.Console()