|
1 # |
|
2 # Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 # All rights reserved. |
|
4 # This component and the accompanying materials are made available |
|
5 # under the terms of "Eclipse Public License v1.0" |
|
6 # which accompanies this distribution, and is available |
|
7 # at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 # |
|
9 # Initial Contributors: |
|
10 # Nokia Corporation - initial contribution. |
|
11 # |
|
12 # Contributors: |
|
13 # |
|
14 # Description: |
|
15 # |
|
16 |
|
17 import unittest |
|
18 import __init__ |
|
19 |
|
20 from cone.public import api, exceptions |
|
21 from CRMLPlugin.crml_model import * |
|
22 |
|
23 class TestCrmlAccess(unittest.TestCase): |
|
24 def test_create_access_object(self): |
|
25 acc = CrmlAccess() |
|
26 self.assertEquals(acc.cap_rd, None) |
|
27 self.assertEquals(acc.cap_wr, None) |
|
28 self.assertEquals(acc.sid_rd, None) |
|
29 self.assertEquals(acc.sid_wr, None) |
|
30 |
|
31 acc = CrmlAccess(cap_rd='AlwaysPass', cap_wr='WriteUserData', sid_rd='0x12345678', sid_wr='0x87654321') |
|
32 self.assertEquals(acc.cap_rd, 'AlwaysPass') |
|
33 self.assertEquals(acc.cap_wr, 'WriteUserData') |
|
34 self.assertEquals(acc.sid_rd, '0x12345678') |
|
35 self.assertEquals(acc.sid_wr, '0x87654321') |
|
36 |
|
37 def test_clone_access_object(self): |
|
38 acc1 = CrmlAccess(cap_rd='AlwaysPass', cap_wr='WriteUserData', sid_rd='0x12345678', sid_wr='0x87654321') |
|
39 acc2 = acc1.copy() |
|
40 self.assertFalse(acc1 is acc2) |
|
41 self.assertTrue(acc1 == acc2) |
|
42 self.assertFalse(acc1 != acc2) |
|
43 |
|
44 def test_compare_access_objects(self): |
|
45 acc1 = CrmlAccess(cap_rd='AlwaysPass', cap_wr='WriteUserData', sid_rd='0x12345678', sid_wr='0x87654321') |
|
46 acc2 = acc1.copy() |
|
47 self.assertTrue(acc1 == acc2) |
|
48 self.assertFalse(acc1 != acc2) |
|
49 |
|
50 def check(attrname, value): |
|
51 acc2 = acc1.copy() |
|
52 setattr(acc1, attrname, value) |
|
53 self.assertFalse(acc1 == acc2) |
|
54 self.assertTrue(acc1 != acc2) |
|
55 |
|
56 # Check that changing each individual attribute makes the comparison fail |
|
57 check('cap_rd', 'ReadDeviceData') |
|
58 check('cap_wr', 'WriteDeviceData') |
|
59 check('sid_rd', '0x11223344') |
|
60 check('sid_wr', '0x44332211') |
|
61 |
|
62 subkeys = [ |
|
63 CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), |
|
64 CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2'), |
|
65 CrmlKeyRangeSubKey(ref='Sub3', name='Sub-key 3', type='string', int='0x3'), |
|
66 ] |
|
67 self.keyrange = CrmlKeyRange( |
|
68 first_int = '0x10000000', |
|
69 last_int = '0x1FFFFFFF', |
|
70 first_index = 2, |
|
71 index_bits = 0x0ff0, |
|
72 backup = True, |
|
73 read_only = True, |
|
74 access = CrmlAccess(cap_rd='ReadUserData'), |
|
75 subkeys = subkeys) |
|
76 |
|
77 def test_create_keyrange_object(self): |
|
78 self.assertRaises(ValueError, CrmlKeyRange) |
|
79 self.assertRaises(ValueError, CrmlKeyRange, first_int='0x10') |
|
80 self.assertRaises(ValueError, CrmlKeyRange, last_int='0x1F') |
|
81 |
|
82 keyrange = CrmlKeyRange(first_int='0x10', last_int='0x1F') |
|
83 |
|
84 class TestCrmlRepository(unittest.TestCase): |
|
85 |
|
86 def setUp(self): |
|
87 keys = [ |
|
88 CrmlSimpleKey(ref='Foo.Bar', int='0x1'), |
|
89 CrmlBitmaskKey(int='0x2', bits=[CrmlBit(ref='Foo.Bit1', index=1), |
|
90 CrmlBit(ref='Foo.Bit2', index=2), |
|
91 CrmlBit(ref='Foo.Bit4', index=4, invert=True)]), |
|
92 CrmlKeyRange(first_int='0x10000000', last_int='0x1FFFFFFF', ref="Foo.Seq", |
|
93 subkeys=[CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), |
|
94 CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2')]), |
|
95 ] |
|
96 |
|
97 self.repo = CrmlRepository( |
|
98 uid_value = '0x10203040', |
|
99 uid_name = 'KCrUidTest', |
|
100 owner = '0x11223344', |
|
101 backup = True, |
|
102 rfs = True, |
|
103 version = '2', |
|
104 access = CrmlAccess(cap_rd='ReadUserData'), |
|
105 keys = keys) |
|
106 |
|
107 def test_create_repo_object(self): |
|
108 repo = CrmlRepository() |
|
109 self.assertEquals(repo.uid_value, None) |
|
110 self.assertEquals(repo.uid_name, None) |
|
111 self.assertEquals(repo.owner, None) |
|
112 self.assertEquals(repo.backup, False) |
|
113 self.assertEquals(repo.rfs, False) |
|
114 self.assertEquals(repo.access, CrmlAccess()) |
|
115 self.assertEquals(repo.keys, []) |
|
116 |
|
117 |
|
118 keys = [ |
|
119 CrmlSimpleKey(ref='Foo.Bar', int='0x1'), |
|
120 CrmlBitmaskKey(int='0x2', bits=[CrmlBit(ref='Foo.Bit1', index=1), |
|
121 CrmlBit(ref='Foo.Bit2', index=2), |
|
122 CrmlBit(ref='Foo.Bit4', index=4, invert=True)]), |
|
123 CrmlKeyRange(first_int='0x10000000', last_int='0x1FFFFFFF', ref="Foo.Seq", |
|
124 subkeys=[CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), |
|
125 CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2')]), |
|
126 ] |
|
127 |
|
128 repo = self.repo |
|
129 self.assertEquals(repo.uid_value, '0x10203040') |
|
130 self.assertEquals(repo.uid_name, 'KCrUidTest') |
|
131 self.assertEquals(repo.owner, '0x11223344') |
|
132 self.assertEquals(repo.backup, True) |
|
133 self.assertEquals(repo.rfs, True) |
|
134 self.assertEquals(repo.version, '2') |
|
135 self.assertEquals(repo.access, CrmlAccess(cap_rd='ReadUserData')) |
|
136 self.assertEquals(repo.keys, keys) |
|
137 |
|
138 def test_clone_repo_object(self): |
|
139 repo1 = self.repo |
|
140 repo2 = repo1.copy() |
|
141 self.assertFalse(repo1 is repo2) |
|
142 self.assertTrue(repo1 == repo2) |
|
143 self.assertFalse(repo1 != repo2) |
|
144 |
|
145 # Assert that the keys have been deep-copied |
|
146 self.assertFalse(repo1.keys is repo2.keys) |
|
147 self.assertEquals(repo1.keys, repo2.keys) |
|
148 for i in xrange(len(repo1.keys)): |
|
149 self.assertFalse(repo1.keys[i] is repo2.keys[i]) |
|
150 |
|
151 def test_compare_repo_objects(self): |
|
152 repo1 = CrmlRepository() |
|
153 repo2 = repo1.copy() |
|
154 self.assertTrue(repo1 == repo2) |
|
155 self.assertFalse(repo1 != repo2) |
|
156 |
|
157 def check(attrname, value): |
|
158 repo1 = self.repo |
|
159 repo2 = repo1.copy() |
|
160 setattr(repo2, attrname, value) |
|
161 self.assertFalse(repo1 == repo2) |
|
162 self.assertTrue(repo1 != repo2) |
|
163 |
|
164 # Check that changing each individual attribute makes the comparison fail |
|
165 check('uid_value', '0xbaadf00d') |
|
166 check('uid_name', 'KFooUid') |
|
167 check('owner', '0xbeef') |
|
168 check('backup', False) |
|
169 check('rfs', False) |
|
170 check('access', CrmlAccess(cap_wr='WriteUserData')) |
|
171 check('keys', ['foo']) |
|
172 check('version', '3') |
|
173 |
|
174 def check2(mod_func): |
|
175 repo1 = self.repo |
|
176 repo2 = repo1.copy() |
|
177 mod_func(repo2) |
|
178 self.assertFalse(repo1 == repo2) |
|
179 self.assertTrue(repo1 != repo2) |
|
180 |
|
181 # Check that changing the keys makes the comparison fail |
|
182 check2(lambda r: setattr(r.keys[0], 'name', 'foo')) |
|
183 check2(lambda r: setattr(r.keys[1], 'type', 'binary')) |
|
184 check2(lambda r: setattr(r.keys[2], 'index_bits', 0x00ffff00)) |
|
185 |
|
186 def test_get_repo_refs(self): |
|
187 self.assertEquals([], CrmlRepository(uid_value='0x1').get_refs()) |
|
188 |
|
189 expected = ['Foo.Bar', |
|
190 'Foo.Bit1', |
|
191 'Foo.Bit2', |
|
192 'Foo.Bit4', |
|
193 'Foo.Seq', |
|
194 'Foo.Seq.Sub1', |
|
195 'Foo.Seq.Sub2'] |
|
196 self.assertEquals(sorted(expected), sorted(self.repo.get_refs())) |
|
197 |
|
198 |
|
199 class TestCrmlSimpleKey(unittest.TestCase): |
|
200 def setUp(self): |
|
201 self.key = CrmlSimpleKey( |
|
202 ref = 'Foo.Bar', |
|
203 name = 'Foobar', |
|
204 int = '0x1020', |
|
205 type = 'real', |
|
206 backup = True, |
|
207 read_only = True, |
|
208 access = CrmlAccess(cap_rd='ReadUserData')) |
|
209 |
|
210 def test_create_key_object(self): |
|
211 # Not specifying ref or index should make the constructor fail |
|
212 self.assertRaises(ValueError, CrmlSimpleKey) |
|
213 self.assertRaises(ValueError, CrmlSimpleKey, ref='Foo.Bar') |
|
214 self.assertRaises(ValueError, CrmlSimpleKey, int='0x1') |
|
215 |
|
216 key = CrmlSimpleKey(ref='Foo.Bar', int='0x1') |
|
217 self.assertEquals(key.ref, 'Foo.Bar') |
|
218 self.assertEquals(key.name, None) |
|
219 self.assertEquals(key.int, '0x1') |
|
220 self.assertEquals(key.type, 'int') |
|
221 self.assertEquals(key.backup, False) |
|
222 self.assertEquals(key.read_only, False) |
|
223 self.assertEquals(key.access, CrmlAccess()) |
|
224 |
|
225 key = self.key |
|
226 self.assertEquals(key.ref, 'Foo.Bar') |
|
227 self.assertEquals(key.name, 'Foobar') |
|
228 self.assertEquals(key.int, '0x1020') |
|
229 self.assertEquals(key.type, 'real') |
|
230 self.assertEquals(key.backup, True) |
|
231 self.assertEquals(key.read_only, True) |
|
232 self.assertEquals(key.access, CrmlAccess(cap_rd='ReadUserData')) |
|
233 |
|
234 def test_clone_key_object(self): |
|
235 key1 = self.key |
|
236 key2 = key1.copy() |
|
237 self.assertFalse(key1 is key2) |
|
238 self.assertTrue(key1 == key2) |
|
239 self.assertFalse(key1 != key2) |
|
240 |
|
241 def test_compare_key_objects(self): |
|
242 def check(attrname, value): |
|
243 key1 = self.key |
|
244 key2 = key1.copy() |
|
245 setattr(key2, attrname, value) |
|
246 self.assertFalse(key1 == key2) |
|
247 self.assertTrue(key1 != key2) |
|
248 |
|
249 # Check that changing each individual attribute makes the comparison fail |
|
250 check('ref', 'Foo.Bar.Baz') |
|
251 check('name', 'Testing') |
|
252 check('int', 'KFooUid') |
|
253 check('type', 'selection') |
|
254 check('backup', False) |
|
255 check('read_only', False) |
|
256 check('access', CrmlAccess(cap_wr='WriteUserData')) |
|
257 |
|
258 def test_get_key_refs(self): |
|
259 self.assertEquals(['Foo.Bar'], self.key.get_refs()) |
|
260 |
|
261 class TestCrmlBit(unittest.TestCase): |
|
262 def test_create_bit_object(self): |
|
263 # Not specifying ref or index should make the constructor fail |
|
264 self.assertRaises(ValueError, CrmlBit) |
|
265 self.assertRaises(ValueError, CrmlBit, ref='Foo.Bar') |
|
266 self.assertRaises(ValueError, CrmlBit, index='3') |
|
267 |
|
268 bit = CrmlBit(ref='Foo.Bar', index=1) |
|
269 self.assertEquals(bit.ref, 'Foo.Bar') |
|
270 self.assertEquals(bit.index, 1) |
|
271 self.assertEquals(bit.invert, False) |
|
272 |
|
273 bit = CrmlBit(ref='Foo.Bar.Baz', index=2, invert=True) |
|
274 self.assertEquals(bit.ref, 'Foo.Bar.Baz') |
|
275 self.assertEquals(bit.index, 2) |
|
276 self.assertEquals(bit.invert, True) |
|
277 |
|
278 def test_clone_bit_object(self): |
|
279 bit1 = CrmlBit(ref='Foo.Bar.Baz', index=2, invert=True) |
|
280 bit2 = bit1.copy() |
|
281 self.assertFalse(bit1 is bit2) |
|
282 self.assertTrue(bit1 == bit2) |
|
283 self.assertFalse(bit1 != bit2) |
|
284 |
|
285 def test_compare_bit_objects(self): |
|
286 bit1 = CrmlBit(ref='Foo.Bar.Baz', index=2, invert=True) |
|
287 |
|
288 def check(attrname, value): |
|
289 bit2 = bit1.copy() |
|
290 setattr(bit1, attrname, value) |
|
291 self.assertFalse(bit1 == bit2) |
|
292 self.assertTrue(bit1 != bit2) |
|
293 |
|
294 check('ref', 'Foo.Bar') |
|
295 check('index', 5) |
|
296 check('invert', False) |
|
297 |
|
298 class TestCrmlBitmaskKey(unittest.TestCase): |
|
299 def setUp(self): |
|
300 bits = [ |
|
301 CrmlBit(ref='Foo.Bit1', index=1), |
|
302 CrmlBit(ref='Foo.Bit2', index=2), |
|
303 CrmlBit(ref='Foo.Bit4', index=4, invert=True), |
|
304 ] |
|
305 self.bm = CrmlBitmaskKey( |
|
306 int = '0x500', |
|
307 type = 'int', |
|
308 backup = True, |
|
309 read_only = True, |
|
310 access = CrmlAccess(cap_rd='ReadUserData'), |
|
311 bits = bits) |
|
312 |
|
313 def test_create_bitmask_object(self): |
|
314 self.assertRaises(ValueError, CrmlBitmaskKey) |
|
315 |
|
316 bm = CrmlBitmaskKey(int='0x2') |
|
317 self.assertEquals(bm.int, '0x2') |
|
318 self.assertEquals(bm.type, 'int') |
|
319 self.assertEquals(bm.backup, False) |
|
320 self.assertEquals(bm.read_only, False) |
|
321 self.assertEquals(bm.access, CrmlAccess()) |
|
322 self.assertEquals(bm.bits, []) |
|
323 |
|
324 bm = self.bm |
|
325 self.assertEquals(bm.int, '0x500') |
|
326 self.assertEquals(bm.type, 'int') |
|
327 self.assertEquals(bm.backup, True) |
|
328 self.assertEquals(bm.read_only, True) |
|
329 self.assertEquals(bm.access, CrmlAccess(cap_rd='ReadUserData')) |
|
330 self.assertEquals(bm.bits, [CrmlBit(ref='Foo.Bit1', index=1), |
|
331 CrmlBit(ref='Foo.Bit2', index=2), |
|
332 CrmlBit(ref='Foo.Bit4', index=4, invert=True)]) |
|
333 |
|
334 def test_clone_bitmask_object(self): |
|
335 bm1 = self.bm |
|
336 bm2 = bm1.copy() |
|
337 self.assertFalse(bm1 is bm2) |
|
338 self.assertTrue(bm1 == bm2) |
|
339 self.assertFalse(bm1 != bm2) |
|
340 |
|
341 # Assert that the bits have been deep-copied |
|
342 self.assertFalse(bm1.bits is bm2.bits) |
|
343 self.assertEquals(bm1.bits, bm2.bits) |
|
344 for i in xrange(len(bm1.bits)): |
|
345 self.assertFalse(bm1.bits[i] is bm2.bits[i]) |
|
346 |
|
347 def test_compare_bitmask_objects(self): |
|
348 def check(attrname, value): |
|
349 bm1 = self.bm |
|
350 bm2 = bm1.copy() |
|
351 setattr(bm2, attrname, value) |
|
352 self.assertFalse(bm1 == bm2) |
|
353 self.assertTrue(bm1 != bm2) |
|
354 |
|
355 check('int', '0x600') |
|
356 check('type', 'binary') |
|
357 check('backup', False) |
|
358 check('read_only', False) |
|
359 check('access', CrmlAccess(cap_rd='ReadDeviceData')) |
|
360 check('bits', [CrmlBit(ref='Foo.Bit7', index=7), |
|
361 CrmlBit(ref='Foo.Bit9', index=9)]) |
|
362 |
|
363 def test_get_bitmask_refs(self): |
|
364 self.assertEquals([], CrmlBitmaskKey(int='0x1').get_refs()) |
|
365 |
|
366 expected = ['Foo.Bit1', |
|
367 'Foo.Bit2', |
|
368 'Foo.Bit4',] |
|
369 self.assertEquals(sorted(expected), sorted(self.bm.get_refs())) |
|
370 |
|
371 class TestCrmlKeyRangeSubKey(unittest.TestCase): |
|
372 |
|
373 def setUp(self): |
|
374 self.subkey = CrmlKeyRangeSubKey(ref='Foo.Bar', name='Foobar', type='int', int='0x1') |
|
375 |
|
376 def test_create_subkey_object(self): |
|
377 self.assertRaises(ValueError, CrmlKeyRangeSubKey) |
|
378 self.assertRaises(ValueError, CrmlKeyRangeSubKey, ref='Foo.Bar') |
|
379 self.assertRaises(ValueError, CrmlKeyRangeSubKey, type='int') |
|
380 self.assertRaises(ValueError, CrmlKeyRangeSubKey, int='0x1') |
|
381 |
|
382 subkey = self.subkey |
|
383 self.assertEquals(subkey.ref, 'Foo.Bar') |
|
384 self.assertEquals(subkey.name, 'Foobar') |
|
385 self.assertEquals(subkey.type, 'int') |
|
386 self.assertEquals(subkey.int, '0x1') |
|
387 |
|
388 def test_clone_subkey_object(self): |
|
389 subkey1 = self.subkey |
|
390 subkey2 = subkey1.copy() |
|
391 self.assertFalse(subkey1 is subkey2) |
|
392 self.assertTrue(subkey1 == subkey2) |
|
393 self.assertFalse(subkey1 != subkey2) |
|
394 |
|
395 def test_compare_subkey_objects(self): |
|
396 def check(attrname, value): |
|
397 subkey1 = self.subkey |
|
398 subkey2 = subkey1.copy() |
|
399 setattr(subkey2, attrname, value) |
|
400 self.assertFalse(subkey1 == subkey2) |
|
401 self.assertTrue(subkey1 != subkey2) |
|
402 |
|
403 check('ref', 'Foo.Bar.Baz') |
|
404 check('name', 'Test') |
|
405 check('int', '0x2') |
|
406 check('type', 'binary') |
|
407 |
|
408 class TestCrmlKeyRange(unittest.TestCase): |
|
409 def setUp(self): |
|
410 subkeys = [ |
|
411 CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), |
|
412 CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2'), |
|
413 CrmlKeyRangeSubKey(ref='Sub3', name='Sub-key 3', type='string', int='0x3'), |
|
414 ] |
|
415 self.keyrange = CrmlKeyRange( |
|
416 ref = 'Foo.Seq', |
|
417 first_int = '0x10000000', |
|
418 last_int = '0x1FFFFFFF', |
|
419 first_index = 2, |
|
420 index_bits = 0x0ff0, |
|
421 backup = True, |
|
422 read_only = True, |
|
423 access = CrmlAccess(cap_rd='ReadUserData'), |
|
424 subkeys = subkeys) |
|
425 |
|
426 def test_create_keyrange_object(self): |
|
427 self.assertRaises(ValueError, CrmlKeyRange) |
|
428 self.assertRaises(ValueError, CrmlKeyRange, first_int='0x10') |
|
429 self.assertRaises(ValueError, CrmlKeyRange, last_int='0x1F') |
|
430 |
|
431 keyrange = CrmlKeyRange(first_int='0x10', last_int='0x1F') |
|
432 self.assertEquals(keyrange.first_int, '0x10') |
|
433 self.assertEquals(keyrange.last_int, '0x1F') |
|
434 self.assertEquals(keyrange.first_index, 0) |
|
435 self.assertEquals(keyrange.index_bits, None) |
|
436 self.assertEquals(keyrange.backup, False) |
|
437 self.assertEquals(keyrange.read_only, False) |
|
438 self.assertEquals(keyrange.access, CrmlAccess()) |
|
439 self.assertEquals(keyrange.subkeys, []) |
|
440 |
|
441 keyrange = self.keyrange |
|
442 self.assertEquals(keyrange.first_int, '0x10000000') |
|
443 self.assertEquals(keyrange.last_int, '0x1FFFFFFF') |
|
444 self.assertEquals(keyrange.first_index, 2) |
|
445 self.assertEquals(keyrange.index_bits, 0x0ff0) |
|
446 self.assertEquals(keyrange.backup, True) |
|
447 self.assertEquals(keyrange.read_only, True) |
|
448 self.assertEquals(keyrange.access, CrmlAccess(cap_rd='ReadUserData')) |
|
449 self.assertEquals(keyrange.subkeys, [ |
|
450 CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), |
|
451 CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2'), |
|
452 CrmlKeyRangeSubKey(ref='Sub3', name='Sub-key 3', type='string', int='0x3')]) |
|
453 |
|
454 |
|
455 def test_clone_keyrange_object(self): |
|
456 keyrange1 = self.keyrange |
|
457 keyrange2 = keyrange1.copy() |
|
458 self.assertFalse(keyrange1 is keyrange2) |
|
459 self.assertTrue(keyrange1 == keyrange2) |
|
460 self.assertFalse(keyrange1 != keyrange2) |
|
461 |
|
462 # Assert that the sub-keys have been deep-copied |
|
463 self.assertFalse(keyrange1.subkeys is keyrange2.subkeys) |
|
464 self.assertEquals(keyrange1.subkeys, keyrange2.subkeys) |
|
465 for i in xrange(len(keyrange1.subkeys)): |
|
466 self.assertFalse(keyrange1.subkeys[i] is keyrange2.subkeys[i]) |
|
467 |
|
468 def test_compare_keyrange_objects(self): |
|
469 def check(attrname, value): |
|
470 keyrange1 = self.keyrange |
|
471 keyrange2 = keyrange1.copy() |
|
472 setattr(keyrange2, attrname, value) |
|
473 self.assertFalse(keyrange1 == keyrange2) |
|
474 self.assertTrue(keyrange1 != keyrange2) |
|
475 |
|
476 check('first_int', '0x20000000') |
|
477 check('last_int', '0x2FFFFFFF') |
|
478 check('first_index', 3) |
|
479 check('index_bits', 0xf00) |
|
480 check('backup', False) |
|
481 check('read_only', False) |
|
482 check('access', CrmlAccess(cap_rd='ReadDeviceData')) |
|
483 check('subkeys', [ |
|
484 CrmlKeyRangeSubKey(ref='Sub0x100', name='Sub-key 0x100', type='string', int='0x100'), |
|
485 CrmlKeyRangeSubKey(ref='Sub0x200', name='Sub-key 0x200', type='binary', int='0x200')]) |
|
486 |
|
487 def test_get_keyrange_refs(self): |
|
488 self.assertEquals([], CrmlKeyRange(first_int='0x1', last_int='0x2').get_refs()) |
|
489 |
|
490 expected = ['Foo.Seq', |
|
491 'Foo.Seq.Sub1', |
|
492 'Foo.Seq.Sub2', |
|
493 'Foo.Seq.Sub3',] |
|
494 self.assertEquals(sorted(expected), sorted(self.keyrange.get_refs())) |
|
495 |
|
496 if __name__ == "__main__": |
|
497 unittest.main() |