diff -r 000000000000 -r 2e8eeb919028 configurationengine/source/plugins/symbian/ConeCRMLPlugin/CRMLPlugin/tests/unittest_crml_model.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/configurationengine/source/plugins/symbian/ConeCRMLPlugin/CRMLPlugin/tests/unittest_crml_model.py Thu Mar 11 17:04:37 2010 +0200 @@ -0,0 +1,497 @@ +# +# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +# All rights reserved. +# This component and the accompanying materials are made available +# under the terms of "Eclipse Public License v1.0" +# which accompanies this distribution, and is available +# at the URL "http://www.eclipse.org/legal/epl-v10.html". +# +# Initial Contributors: +# Nokia Corporation - initial contribution. +# +# Contributors: +# +# Description: +# + +import unittest +import __init__ + +from cone.public import api, exceptions +from CRMLPlugin.crml_model import * + +class TestCrmlAccess(unittest.TestCase): + def test_create_access_object(self): + acc = CrmlAccess() + self.assertEquals(acc.cap_rd, None) + self.assertEquals(acc.cap_wr, None) + self.assertEquals(acc.sid_rd, None) + self.assertEquals(acc.sid_wr, None) + + acc = CrmlAccess(cap_rd='AlwaysPass', cap_wr='WriteUserData', sid_rd='0x12345678', sid_wr='0x87654321') + self.assertEquals(acc.cap_rd, 'AlwaysPass') + self.assertEquals(acc.cap_wr, 'WriteUserData') + self.assertEquals(acc.sid_rd, '0x12345678') + self.assertEquals(acc.sid_wr, '0x87654321') + + def test_clone_access_object(self): + acc1 = CrmlAccess(cap_rd='AlwaysPass', cap_wr='WriteUserData', sid_rd='0x12345678', sid_wr='0x87654321') + acc2 = acc1.copy() + self.assertFalse(acc1 is acc2) + self.assertTrue(acc1 == acc2) + self.assertFalse(acc1 != acc2) + + def test_compare_access_objects(self): + acc1 = CrmlAccess(cap_rd='AlwaysPass', cap_wr='WriteUserData', sid_rd='0x12345678', sid_wr='0x87654321') + acc2 = acc1.copy() + self.assertTrue(acc1 == acc2) + self.assertFalse(acc1 != acc2) + + def check(attrname, value): + acc2 = acc1.copy() + setattr(acc1, attrname, value) + self.assertFalse(acc1 == acc2) + self.assertTrue(acc1 != acc2) + + # Check that changing each individual attribute makes the comparison fail + check('cap_rd', 'ReadDeviceData') + check('cap_wr', 'WriteDeviceData') + check('sid_rd', '0x11223344') + check('sid_wr', '0x44332211') + + subkeys = [ + CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), + CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2'), + CrmlKeyRangeSubKey(ref='Sub3', name='Sub-key 3', type='string', int='0x3'), + ] + self.keyrange = CrmlKeyRange( + first_int = '0x10000000', + last_int = '0x1FFFFFFF', + first_index = 2, + index_bits = 0x0ff0, + backup = True, + read_only = True, + access = CrmlAccess(cap_rd='ReadUserData'), + subkeys = subkeys) + + def test_create_keyrange_object(self): + self.assertRaises(ValueError, CrmlKeyRange) + self.assertRaises(ValueError, CrmlKeyRange, first_int='0x10') + self.assertRaises(ValueError, CrmlKeyRange, last_int='0x1F') + + keyrange = CrmlKeyRange(first_int='0x10', last_int='0x1F') + +class TestCrmlRepository(unittest.TestCase): + + def setUp(self): + keys = [ + CrmlSimpleKey(ref='Foo.Bar', int='0x1'), + CrmlBitmaskKey(int='0x2', bits=[CrmlBit(ref='Foo.Bit1', index=1), + CrmlBit(ref='Foo.Bit2', index=2), + CrmlBit(ref='Foo.Bit4', index=4, invert=True)]), + CrmlKeyRange(first_int='0x10000000', last_int='0x1FFFFFFF', ref="Foo.Seq", + subkeys=[CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), + CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2')]), + ] + + self.repo = CrmlRepository( + uid_value = '0x10203040', + uid_name = 'KCrUidTest', + owner = '0x11223344', + backup = True, + rfs = True, + version = '2', + access = CrmlAccess(cap_rd='ReadUserData'), + keys = keys) + + def test_create_repo_object(self): + repo = CrmlRepository() + self.assertEquals(repo.uid_value, None) + self.assertEquals(repo.uid_name, None) + self.assertEquals(repo.owner, None) + self.assertEquals(repo.backup, False) + self.assertEquals(repo.rfs, False) + self.assertEquals(repo.access, CrmlAccess()) + self.assertEquals(repo.keys, []) + + + keys = [ + CrmlSimpleKey(ref='Foo.Bar', int='0x1'), + CrmlBitmaskKey(int='0x2', bits=[CrmlBit(ref='Foo.Bit1', index=1), + CrmlBit(ref='Foo.Bit2', index=2), + CrmlBit(ref='Foo.Bit4', index=4, invert=True)]), + CrmlKeyRange(first_int='0x10000000', last_int='0x1FFFFFFF', ref="Foo.Seq", + subkeys=[CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), + CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2')]), + ] + + repo = self.repo + self.assertEquals(repo.uid_value, '0x10203040') + self.assertEquals(repo.uid_name, 'KCrUidTest') + self.assertEquals(repo.owner, '0x11223344') + self.assertEquals(repo.backup, True) + self.assertEquals(repo.rfs, True) + self.assertEquals(repo.version, '2') + self.assertEquals(repo.access, CrmlAccess(cap_rd='ReadUserData')) + self.assertEquals(repo.keys, keys) + + def test_clone_repo_object(self): + repo1 = self.repo + repo2 = repo1.copy() + self.assertFalse(repo1 is repo2) + self.assertTrue(repo1 == repo2) + self.assertFalse(repo1 != repo2) + + # Assert that the keys have been deep-copied + self.assertFalse(repo1.keys is repo2.keys) + self.assertEquals(repo1.keys, repo2.keys) + for i in xrange(len(repo1.keys)): + self.assertFalse(repo1.keys[i] is repo2.keys[i]) + + def test_compare_repo_objects(self): + repo1 = CrmlRepository() + repo2 = repo1.copy() + self.assertTrue(repo1 == repo2) + self.assertFalse(repo1 != repo2) + + def check(attrname, value): + repo1 = self.repo + repo2 = repo1.copy() + setattr(repo2, attrname, value) + self.assertFalse(repo1 == repo2) + self.assertTrue(repo1 != repo2) + + # Check that changing each individual attribute makes the comparison fail + check('uid_value', '0xbaadf00d') + check('uid_name', 'KFooUid') + check('owner', '0xbeef') + check('backup', False) + check('rfs', False) + check('access', CrmlAccess(cap_wr='WriteUserData')) + check('keys', ['foo']) + check('version', '3') + + def check2(mod_func): + repo1 = self.repo + repo2 = repo1.copy() + mod_func(repo2) + self.assertFalse(repo1 == repo2) + self.assertTrue(repo1 != repo2) + + # Check that changing the keys makes the comparison fail + check2(lambda r: setattr(r.keys[0], 'name', 'foo')) + check2(lambda r: setattr(r.keys[1], 'type', 'binary')) + check2(lambda r: setattr(r.keys[2], 'index_bits', 0x00ffff00)) + + def test_get_repo_refs(self): + self.assertEquals([], CrmlRepository(uid_value='0x1').get_refs()) + + expected = ['Foo.Bar', + 'Foo.Bit1', + 'Foo.Bit2', + 'Foo.Bit4', + 'Foo.Seq', + 'Foo.Seq.Sub1', + 'Foo.Seq.Sub2'] + self.assertEquals(sorted(expected), sorted(self.repo.get_refs())) + + +class TestCrmlSimpleKey(unittest.TestCase): + def setUp(self): + self.key = CrmlSimpleKey( + ref = 'Foo.Bar', + name = 'Foobar', + int = '0x1020', + type = 'real', + backup = True, + read_only = True, + access = CrmlAccess(cap_rd='ReadUserData')) + + def test_create_key_object(self): + # Not specifying ref or index should make the constructor fail + self.assertRaises(ValueError, CrmlSimpleKey) + self.assertRaises(ValueError, CrmlSimpleKey, ref='Foo.Bar') + self.assertRaises(ValueError, CrmlSimpleKey, int='0x1') + + key = CrmlSimpleKey(ref='Foo.Bar', int='0x1') + self.assertEquals(key.ref, 'Foo.Bar') + self.assertEquals(key.name, None) + self.assertEquals(key.int, '0x1') + self.assertEquals(key.type, 'int') + self.assertEquals(key.backup, False) + self.assertEquals(key.read_only, False) + self.assertEquals(key.access, CrmlAccess()) + + key = self.key + self.assertEquals(key.ref, 'Foo.Bar') + self.assertEquals(key.name, 'Foobar') + self.assertEquals(key.int, '0x1020') + self.assertEquals(key.type, 'real') + self.assertEquals(key.backup, True) + self.assertEquals(key.read_only, True) + self.assertEquals(key.access, CrmlAccess(cap_rd='ReadUserData')) + + def test_clone_key_object(self): + key1 = self.key + key2 = key1.copy() + self.assertFalse(key1 is key2) + self.assertTrue(key1 == key2) + self.assertFalse(key1 != key2) + + def test_compare_key_objects(self): + def check(attrname, value): + key1 = self.key + key2 = key1.copy() + setattr(key2, attrname, value) + self.assertFalse(key1 == key2) + self.assertTrue(key1 != key2) + + # Check that changing each individual attribute makes the comparison fail + check('ref', 'Foo.Bar.Baz') + check('name', 'Testing') + check('int', 'KFooUid') + check('type', 'selection') + check('backup', False) + check('read_only', False) + check('access', CrmlAccess(cap_wr='WriteUserData')) + + def test_get_key_refs(self): + self.assertEquals(['Foo.Bar'], self.key.get_refs()) + +class TestCrmlBit(unittest.TestCase): + def test_create_bit_object(self): + # Not specifying ref or index should make the constructor fail + self.assertRaises(ValueError, CrmlBit) + self.assertRaises(ValueError, CrmlBit, ref='Foo.Bar') + self.assertRaises(ValueError, CrmlBit, index='3') + + bit = CrmlBit(ref='Foo.Bar', index=1) + self.assertEquals(bit.ref, 'Foo.Bar') + self.assertEquals(bit.index, 1) + self.assertEquals(bit.invert, False) + + bit = CrmlBit(ref='Foo.Bar.Baz', index=2, invert=True) + self.assertEquals(bit.ref, 'Foo.Bar.Baz') + self.assertEquals(bit.index, 2) + self.assertEquals(bit.invert, True) + + def test_clone_bit_object(self): + bit1 = CrmlBit(ref='Foo.Bar.Baz', index=2, invert=True) + bit2 = bit1.copy() + self.assertFalse(bit1 is bit2) + self.assertTrue(bit1 == bit2) + self.assertFalse(bit1 != bit2) + + def test_compare_bit_objects(self): + bit1 = CrmlBit(ref='Foo.Bar.Baz', index=2, invert=True) + + def check(attrname, value): + bit2 = bit1.copy() + setattr(bit1, attrname, value) + self.assertFalse(bit1 == bit2) + self.assertTrue(bit1 != bit2) + + check('ref', 'Foo.Bar') + check('index', 5) + check('invert', False) + +class TestCrmlBitmaskKey(unittest.TestCase): + def setUp(self): + bits = [ + CrmlBit(ref='Foo.Bit1', index=1), + CrmlBit(ref='Foo.Bit2', index=2), + CrmlBit(ref='Foo.Bit4', index=4, invert=True), + ] + self.bm = CrmlBitmaskKey( + int = '0x500', + type = 'int', + backup = True, + read_only = True, + access = CrmlAccess(cap_rd='ReadUserData'), + bits = bits) + + def test_create_bitmask_object(self): + self.assertRaises(ValueError, CrmlBitmaskKey) + + bm = CrmlBitmaskKey(int='0x2') + self.assertEquals(bm.int, '0x2') + self.assertEquals(bm.type, 'int') + self.assertEquals(bm.backup, False) + self.assertEquals(bm.read_only, False) + self.assertEquals(bm.access, CrmlAccess()) + self.assertEquals(bm.bits, []) + + bm = self.bm + self.assertEquals(bm.int, '0x500') + self.assertEquals(bm.type, 'int') + self.assertEquals(bm.backup, True) + self.assertEquals(bm.read_only, True) + self.assertEquals(bm.access, CrmlAccess(cap_rd='ReadUserData')) + self.assertEquals(bm.bits, [CrmlBit(ref='Foo.Bit1', index=1), + CrmlBit(ref='Foo.Bit2', index=2), + CrmlBit(ref='Foo.Bit4', index=4, invert=True)]) + + def test_clone_bitmask_object(self): + bm1 = self.bm + bm2 = bm1.copy() + self.assertFalse(bm1 is bm2) + self.assertTrue(bm1 == bm2) + self.assertFalse(bm1 != bm2) + + # Assert that the bits have been deep-copied + self.assertFalse(bm1.bits is bm2.bits) + self.assertEquals(bm1.bits, bm2.bits) + for i in xrange(len(bm1.bits)): + self.assertFalse(bm1.bits[i] is bm2.bits[i]) + + def test_compare_bitmask_objects(self): + def check(attrname, value): + bm1 = self.bm + bm2 = bm1.copy() + setattr(bm2, attrname, value) + self.assertFalse(bm1 == bm2) + self.assertTrue(bm1 != bm2) + + check('int', '0x600') + check('type', 'binary') + check('backup', False) + check('read_only', False) + check('access', CrmlAccess(cap_rd='ReadDeviceData')) + check('bits', [CrmlBit(ref='Foo.Bit7', index=7), + CrmlBit(ref='Foo.Bit9', index=9)]) + + def test_get_bitmask_refs(self): + self.assertEquals([], CrmlBitmaskKey(int='0x1').get_refs()) + + expected = ['Foo.Bit1', + 'Foo.Bit2', + 'Foo.Bit4',] + self.assertEquals(sorted(expected), sorted(self.bm.get_refs())) + +class TestCrmlKeyRangeSubKey(unittest.TestCase): + + def setUp(self): + self.subkey = CrmlKeyRangeSubKey(ref='Foo.Bar', name='Foobar', type='int', int='0x1') + + def test_create_subkey_object(self): + self.assertRaises(ValueError, CrmlKeyRangeSubKey) + self.assertRaises(ValueError, CrmlKeyRangeSubKey, ref='Foo.Bar') + self.assertRaises(ValueError, CrmlKeyRangeSubKey, type='int') + self.assertRaises(ValueError, CrmlKeyRangeSubKey, int='0x1') + + subkey = self.subkey + self.assertEquals(subkey.ref, 'Foo.Bar') + self.assertEquals(subkey.name, 'Foobar') + self.assertEquals(subkey.type, 'int') + self.assertEquals(subkey.int, '0x1') + + def test_clone_subkey_object(self): + subkey1 = self.subkey + subkey2 = subkey1.copy() + self.assertFalse(subkey1 is subkey2) + self.assertTrue(subkey1 == subkey2) + self.assertFalse(subkey1 != subkey2) + + def test_compare_subkey_objects(self): + def check(attrname, value): + subkey1 = self.subkey + subkey2 = subkey1.copy() + setattr(subkey2, attrname, value) + self.assertFalse(subkey1 == subkey2) + self.assertTrue(subkey1 != subkey2) + + check('ref', 'Foo.Bar.Baz') + check('name', 'Test') + check('int', '0x2') + check('type', 'binary') + +class TestCrmlKeyRange(unittest.TestCase): + def setUp(self): + subkeys = [ + CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), + CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2'), + CrmlKeyRangeSubKey(ref='Sub3', name='Sub-key 3', type='string', int='0x3'), + ] + self.keyrange = CrmlKeyRange( + ref = 'Foo.Seq', + first_int = '0x10000000', + last_int = '0x1FFFFFFF', + first_index = 2, + index_bits = 0x0ff0, + backup = True, + read_only = True, + access = CrmlAccess(cap_rd='ReadUserData'), + subkeys = subkeys) + + def test_create_keyrange_object(self): + self.assertRaises(ValueError, CrmlKeyRange) + self.assertRaises(ValueError, CrmlKeyRange, first_int='0x10') + self.assertRaises(ValueError, CrmlKeyRange, last_int='0x1F') + + keyrange = CrmlKeyRange(first_int='0x10', last_int='0x1F') + self.assertEquals(keyrange.first_int, '0x10') + self.assertEquals(keyrange.last_int, '0x1F') + self.assertEquals(keyrange.first_index, 0) + self.assertEquals(keyrange.index_bits, None) + self.assertEquals(keyrange.backup, False) + self.assertEquals(keyrange.read_only, False) + self.assertEquals(keyrange.access, CrmlAccess()) + self.assertEquals(keyrange.subkeys, []) + + keyrange = self.keyrange + self.assertEquals(keyrange.first_int, '0x10000000') + self.assertEquals(keyrange.last_int, '0x1FFFFFFF') + self.assertEquals(keyrange.first_index, 2) + self.assertEquals(keyrange.index_bits, 0x0ff0) + self.assertEquals(keyrange.backup, True) + self.assertEquals(keyrange.read_only, True) + self.assertEquals(keyrange.access, CrmlAccess(cap_rd='ReadUserData')) + self.assertEquals(keyrange.subkeys, [ + CrmlKeyRangeSubKey(ref='Sub1', name='Sub-key 1', type='int', int='0x1'), + CrmlKeyRangeSubKey(ref='Sub2', name='Sub-key 2', type='real', int='0x2'), + CrmlKeyRangeSubKey(ref='Sub3', name='Sub-key 3', type='string', int='0x3')]) + + + def test_clone_keyrange_object(self): + keyrange1 = self.keyrange + keyrange2 = keyrange1.copy() + self.assertFalse(keyrange1 is keyrange2) + self.assertTrue(keyrange1 == keyrange2) + self.assertFalse(keyrange1 != keyrange2) + + # Assert that the sub-keys have been deep-copied + self.assertFalse(keyrange1.subkeys is keyrange2.subkeys) + self.assertEquals(keyrange1.subkeys, keyrange2.subkeys) + for i in xrange(len(keyrange1.subkeys)): + self.assertFalse(keyrange1.subkeys[i] is keyrange2.subkeys[i]) + + def test_compare_keyrange_objects(self): + def check(attrname, value): + keyrange1 = self.keyrange + keyrange2 = keyrange1.copy() + setattr(keyrange2, attrname, value) + self.assertFalse(keyrange1 == keyrange2) + self.assertTrue(keyrange1 != keyrange2) + + check('first_int', '0x20000000') + check('last_int', '0x2FFFFFFF') + check('first_index', 3) + check('index_bits', 0xf00) + check('backup', False) + check('read_only', False) + check('access', CrmlAccess(cap_rd='ReadDeviceData')) + check('subkeys', [ + CrmlKeyRangeSubKey(ref='Sub0x100', name='Sub-key 0x100', type='string', int='0x100'), + CrmlKeyRangeSubKey(ref='Sub0x200', name='Sub-key 0x200', type='binary', int='0x200')]) + + def test_get_keyrange_refs(self): + self.assertEquals([], CrmlKeyRange(first_int='0x1', last_int='0x2').get_refs()) + + expected = ['Foo.Seq', + 'Foo.Seq.Sub1', + 'Foo.Seq.Sub2', + 'Foo.Seq.Sub3',] + self.assertEquals(sorted(expected), sorted(self.keyrange.get_refs())) + +if __name__ == "__main__": + unittest.main() \ No newline at end of file