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 string

    19 import sys

    20 import __init__

    21 

    22 from cone.public import api, exceptions

    23 from cone.confml import model

    24 

    25 

    26 class TestConfmlMeta(unittest.TestCase):

    27     def test_create_meta(self):

    28         metaelem = model.ConfmlMeta()

    29         self.assertTrue(metaelem)

    30 

    31     def test_create_with_data(self):

    32         prop1 = model.ConfmlMetaProperty("foo", 123)

    33         prop2 = model.ConfmlMetaProperty("bar", 312)

    34         prop3 = model.ConfmlMetaProperty("test", 'testing string')

    35         prop4 = model.ConfmlMetaProperty("testName", 'testing string2', \

    36                                          "http://www.nokia.com/xml/cpf-id/1", \

    37                                          attrs={"name":"name1", "value": "value1"})            

    38         metaelem = model.ConfmlMeta([prop1, prop2, prop3, prop4])

    39         self.assertEquals(metaelem[0].tag, "foo")

    40         self.assertEquals(metaelem[0].value, 123)

    41         self.assertEquals(metaelem[1].tag, "bar")

    42         self.assertEquals(metaelem[1].value, 312)

    43         self.assertEquals(metaelem[2].tag, "test")

    44         self.assertEquals(metaelem[2].value, "testing string")

    45         self.assertEquals(metaelem[3].tag, "testName")

    46         self.assertEquals(metaelem[3].value, "testing string2")

    47         self.assertEquals(metaelem[3].ns, "http://www.nokia.com/xml/cpf-id/1")

    48         

    49     def test_add_data(self):

    50         metaelem = model.ConfmlMeta()

    51         metaelem.append(model.ConfmlMetaProperty('test', 123, "abc", attrs = {"foo":"bar", "abc":1}))

    52         self.assertEquals(metaelem[0].tag, 'test')

    53         self.assertEquals(metaelem[0].value, 123)

    54         self.assertEquals(metaelem[0].ns, "abc")

    55         self.assertEquals(metaelem[0].attrs, {"foo":"bar", "abc":1})

    56 

    57     def test_find_data(self):

    58         metaelem = model.ConfmlMeta()

    59         metaelem.append(model.ConfmlMetaProperty('test', 123, "abc",\

    60                                                   attrs = {"foo":"bar", "abc":1}))

    61         metaelem.append(model.ConfmlMetaProperty('abc', "efg", None,\

    62                                                   attrs = {"foo2":"bar2", "abc2":2}))

    63         self.assertEquals(metaelem.find_by_tag("test"), 0)

    64         self.assertEquals(metaelem.get_property_by_tag("test").tag, 'test')

    65         self.assertEquals(metaelem.get_property_by_tag("test").value, 123)

    66         self.assertEquals(metaelem.get("test"), 123)

    67         self.assertEquals(metaelem.get("test", 'ddd'), 123)

    68         # test get_value with not found elem

    69         self.assertEquals(metaelem.get("notthere"), None)

    70         self.assertEquals(metaelem.get("notthere", 'fooman'), 'fooman')

    71         self.assertEquals(metaelem.find_by_attribute("foo2", "bar2"), 1)

    72         self.assertEquals(metaelem.find_by_attribute("qwerty", ""), -1)

    73 

    74     def test_clone_meta(self):

    75         prop1 = model.ConfmlMetaProperty("foo", 123)

    76         prop2 = model.ConfmlMetaProperty("bar", 312)

    77         prop3 = model.ConfmlMetaProperty("test", 'testing string')        

    78         metaelem1 = model.ConfmlMeta([prop1, prop2, prop3])        

    79         metaelem2 = metaelem1.clone()

    80         self.assertEquals(metaelem1, metaelem2)

    81 

    82 

    83 class TestConfmlDescription(unittest.TestCase):

    84     def test_create_desc(self):

    85         descelem1 = model.ConfmlDescription("testing")

    86         descelem2 = model.ConfmlDescription()

    87         descelem3 = model.ConfmlDescription()

    88         descelem3.text = "changed"

    89         self.assertEquals(descelem1.text, "testing")

    90         self.assertEquals(descelem2.text, "")

    91         self.assertEquals(descelem3.text, "changed")

    92 

    93     def test_clone_desc(self):

    94         descelem1 = model.ConfmlDescription("testing")

    95         descelem2 = descelem1._clone()

    96         self.assertEquals(descelem1.text, descelem2.text)

    97 

    98 class TestConfmlGroup(unittest.TestCase):

    99     def test_create_group(self):

   100         group1 = model.ConfmlGroup("foo")

   101         self.assertEquals(group1.ref, "foo")

   102         self.assertEquals(group1.icon, None)

   103         self.assertEquals(group1.desc, None)

   104 

   105     def test_group_access_icon(self):

   106         group1 = model.ConfmlGroup("foo", icon='first/icon.bmp')

   107         self.assertEquals(group1.icon, "first/icon.bmp")

   108         group1.icon = 'foo/bar.jpg'

   109         self.assertEquals(group1.icon, "foo/bar.jpg")

   110         del group1.icon

   111         self.assertEquals(group1.icon, None)

   112 

   113     def test_group_access_description(self):

   114         group1 = model.ConfmlGroup("foo", desc='Testing description. for this something!')

   115         self.assertEquals(group1.desc, "Testing description. for this something!")

   116         group1.desc = 'Something else'

   117         self.assertEquals(group1.desc, "Something else")

   118         del group1.desc

   119         self.assertEquals(group1.icon, None)

   120 

   121     def test_clone_group(self):

   122         group1 = model.ConfmlGroup("foo")

   123         group2 = group1._clone()

   124         self.assertEquals(group1.ref, group2.ref)

   125         self.assertEquals(group1.desc, group2.desc)

   126         self.assertEquals(group1.icon, group2.icon)

   127 

   128         group1 = model.ConfmlGroup("foo", desc='testing desc', icon='link.bmp')

   129         group2 = group1._clone(recursion=True)

   130         self.assertEquals(group1.ref, group2.ref)

   131         self.assertEquals(group1.desc, group2.desc)

   132         self.assertEquals(group1.icon, group2.icon)

   133 

   134 

   135 class TestConfmlSetting(unittest.TestCase):

   136     def test_create_setting(self):

   137         elem = model.ConfmlSetting('test')

   138         self.assertTrue(elem)

   139         self.assertEquals(elem.desc, None)

   140         self.assertEquals(elem.readOnly, None)

   141         self.assertEquals(elem.constraint, None)

   142         self.assertEquals(elem.required, None)

   143         self.assertEquals(elem.relevant, None)

   144 

   145     def test_getters(self):

   146         elem = model.ConfmlSetting('foo')

   147         self.assertTrue(elem.get_ref(),'foo')

   148         self.assertEquals(elem.get_type(),None)

   149         self.assertTrue(elem.get_name(),'foo')

   150 

   151     def test_set_type(self):

   152         elem = model.ConfmlSetting('foo')

   153         elem.type = 'string'

   154         self.assertTrue(elem.ref,'foo')

   155         self.assertTrue(elem.type,'string')

   156         self.assertTrue(elem.name,'foo')

   157 

   158     def test_setting_with_options(self):

   159         elem = model.ConfmlSetting('foo',type='selection')

   160         elem.create_option('foo','1')

   161         elem.create_option('bar','bar')

   162         elem.create_option('hou','sut')

   163         self.assertTrue('1' in elem.get_valueset()) 

   164         self.assertEquals(elem.options['1'].name, 'foo')

   165         self.assertEquals(elem.options['1'].value, '1')

   166         self.assertEquals(elem.options['bar'].name, 'bar')

   167 

   168     def test_setting_create_with_nonetype(self):

   169         elem = model.ConfmlSetting('foo',type=None)

   170         self.assertEqual(elem.type,None) 

   171 

   172     def test_setting_with_properties(self):

   173         elem = model.ConfmlSetting('foo')

   174         elem.add_property(name='foo',value='bar/foo')

   175         elem.add_property(name='bar',value='only/bar')

   176         elem.add_property(name='testing',value='1', unit='mB')

   177         self.assertEquals(elem.list_properties(), ['foo','bar','testing'])

   178         self.assertEquals(elem.get_property('foo').value, 'bar/foo')

   179         elem.remove_property('foo')

   180         try:

   181             elem.remove_property('bss')

   182             self.fail('removing invalid succeeds')

   183         except exceptions.NotFound:

   184             pass

   185         self.assertEquals(elem.list_properties(), ['bar','testing'])

   186         for property_name in elem.list_properties():

   187             elem.remove_property(property_name)

   188         self.assertEquals(elem.list_properties(), [])

   189         

   190 

   191     def test_setting_with_properties_property(self):

   192         elem = model.ConfmlSetting('foo')

   193         elem.add_property(name='foo',value='bar/foo')

   194         elem.add_property(name='bar',value='only/bar')

   195         elem.add_property(name='testing',value='1', unit='mB')

   196         self.assertEquals(elem.properties['foo'].value,'bar/foo')

   197         self.assertEquals(elem.properties['bar'].value,'only/bar')

   198 

   199     def test_setting_with_readOnly_value(self):

   200         elem = model.ConfmlSetting('foo', readOnly=True)

   201         self.assertEquals(elem.readOnly,True)

   202         elem.readOnly = False

   203         self.assertEquals(elem.readOnly,False)

   204 

   205     def test_setting_with_constaint(self):

   206         elem = model.ConfmlSetting('foo', constraint=". > '1'")

   207         self.assertEquals(elem.constraint,". > '1'")

   208         elem.constraint = 'foobar'

   209         self.assertEquals(elem.constraint,"foobar")

   210 

   211     def test_setting_with_required_value(self):

   212         elem = model.ConfmlSetting('foo', required=False)

   213         self.assertEquals(elem.required,False)

   214         elem = model.ConfmlSetting('foo', required=True)

   215         self.assertEquals(elem.required,True)

   216         elem.required = False

   217         self.assertEquals(elem.required,False)

   218 

   219     def test_setting_with_relevant_value(self):

   220         elem = model.ConfmlSetting('foo', relevant='ffoo oss')

   221         self.assertEquals(elem.relevant,'ffoo oss')

   222         elem.relevant = ''

   223         self.assertEquals(elem.relevant,'')

   224 

   225     def test_setting_with_max_length(self):

   226         elem = model.ConfmlSetting('foo', maxLength=10)

   227         self.assertEquals(elem.maxLength,10)

   228         elem.maxLength = 20

   229         self.assertEquals(elem.maxLength,20)

   230         self.assertTrue(elem._has(model.ConfmlMaxLength.refname))

   231 

   232     def test_setting_with_min_length(self):

   233         elem = model.ConfmlSetting('foo', minLength=10)

   234         self.assertEquals(elem.minLength,10)

   235         elem.minLength = 20

   236         self.assertEquals(elem.minLength,20)

   237         self.assertTrue(elem._has(model.ConfmlMinLength.refname))

   238 

   239     def test_setting_rfs_casting(self):

   240         elem = model.ConfmlSetting('foo', minLength=10)

   241         self.assertEquals(elem.get_rfs_cast('true'),True)

   242         self.assertEquals(elem.get_rfs_cast('false'),False)

   243         self.assertEquals(elem.set_rfs_cast(True),'true')

   244         self.assertEquals(elem.set_rfs_cast(False),'false')

   245         self.assertEquals(elem.set_rfs_cast(1),'true')

   246 

   247 class TestConfmlSelectionSetting(unittest.TestCase):

   248     def test_create_selection_setting(self):

   249         elem = model.ConfmlSelectionSetting('foo')

   250         self.assertTrue(elem)

   251         self.assertEquals(elem.type, 'selection')

   252         self.assertEquals(elem.desc, None)

   253         self.assertEquals(elem.readOnly, None)

   254         self.assertEquals(elem.constraint, None)

   255         self.assertEquals(elem.required, None)

   256         self.assertEquals(elem.relevant, None)

   257     

   258     def test_selection_valueset(self):

   259         elem = model.ConfmlSelectionSetting('foo')

   260         self.assertEquals(elem.type, 'selection')

   261         elem.create_option('foo', '1')

   262         elem.create_option('bar', '2')

   263         elem.create_option('baz', '3')

   264         self.assertEquals(elem.get_valueset(), api.ValueSet(['1', '2', '3']))

   265 

   266 class TestConfmlMultiSelectionSetting(unittest.TestCase):

   267     def test_create_multiselection_setting(self):

   268         elem = model.ConfmlMultiSelectionSetting('mset1')

   269         self.assertTrue(elem)

   270         self.assertEquals(elem.type, 'multiSelection')

   271         self.assertEquals(elem.desc, None)

   272         self.assertEquals(elem.readOnly, None)

   273         self.assertEquals(elem.constraint, None)

   274         self.assertEquals(elem.required, None)

   275         self.assertEquals(elem.relevant, None)

   276     

   277     def test_multiselection_valueset(self):

   278         elem = model.ConfmlMultiSelectionSetting('foo')

   279         self.assertEquals(elem.type, 'multiSelection')

   280         elem.create_option('foo', '1')

   281         elem.create_option('bar', '2')

   282         elem.create_option('baz', '3')

   283         self.assertEquals(elem.get_valueset(), api.ValueSet(['1', '2', '3']))

   284 

   285     def test_setting_value_to_multiselection(self):

   286         conf = model.ConfmlConfiguration('test.confml')

   287         elem = model.ConfmlMultiSelectionSetting('mset2', type='multiSelection')

   288         conf.add_feature(elem)

   289         elem.value = "\"sel1\" \"sel2\""

   290         self.assertEquals(elem.type, 'multiSelection')

   291         self.assertEquals(elem.get_data_cast("\"sel1\" \"sel2\""), ["sel1", "sel2"])

   292         self.assertEquals(elem.get_value(), ["sel1", "sel2"])

   293 

   294     def test_set_data_cast(self):

   295         elem = model.ConfmlMultiSelectionSetting('mset3', type='multiSelection')

   296         self.assertEquals(elem.set_data_cast('"sel1" "sel2 with some spaces"'), '"sel1" "sel2 with some spaces"')

   297         self.assertEquals(elem.set_data_cast(["sel1", "sel2 with some spaces"]), '"sel1" "sel2 with some spaces"')

   298         self.assertEquals(elem.set_data_cast(["1", "1"]), '"1" "1"')

   299         self.assertEquals(elem.set_data_cast([1, 2, 3]), '"1" "2" "3"')

   300 

   301 

   302     def test_get_data_cast(self):

   303         elem = model.ConfmlMultiSelectionSetting('mset3', type='multiSelection')

   304         self.assertEquals(elem.get_data_cast('"sel1" "sel2 with some spaces"'), ["sel1", "sel2 with some spaces"])

   305         self.assertEquals(elem.get_data_cast('"sel1" "sel2 space" "foo bar"'), ["sel1", "sel2 space", "foo bar"])

   306 

   307     def test_setting_value_to_multiselection2(self):

   308         conf = model.ConfmlConfiguration('test.confml')

   309         elem = model.ConfmlMultiSelectionSetting('mset3', type='multiSelection')

   310         conf.add_feature(elem)

   311         elem.value = '"sel1" "sel2 with some spaces"'

   312         self.assertEquals(elem.type, 'multiSelection')

   313         self.assertEquals(elem.get_value(), ["sel1", "sel2 with some spaces"])

   314         elem.value = ["sel1", "sel2 with some spaces"]

   315         self.assertEquals(elem.get_value(), ["sel1", "sel2 with some spaces"])

   316         

   317     def test_setting_not_list_value_to_multiselection(self):

   318         conf = model.ConfmlConfiguration('test.confml')

   319         elem = model.ConfmlMultiSelectionSetting('mset4', type='multiSelection')

   320         conf.add_feature(elem)

   321         self.assertRaises(ValueError, elem.set_value, "not list")

   322         

   323     def test_setting_list_value_to_multiselection(self):

   324         conf = model.ConfmlConfiguration('test.confml')

   325         elem = model.ConfmlMultiSelectionSetting('mset5', type='multiSelection')

   326         conf.add_feature(elem)

   327         elem.set_value(["li1", "li2"])

   328         self.assertEquals(elem.get_value(), ["li1", "li2"])

   329         self.assertEquals(elem.get_data().get_value(), '"li1" "li2"')

   330 

   331 class TestConfmlIntSetting(unittest.TestCase):

   332     def test_create_setting(self):

   333         elem = model.ConfmlIntSetting('test')

   334         self.assertTrue(elem)

   335         self.assertEquals(elem.type, 'int')

   336         self.assertEquals(elem.desc, None)

   337         self.assertEquals(elem.readOnly, None)

   338         self.assertEquals(elem.constraint, None)

   339         self.assertEquals(elem.required, None)

   340         self.assertEquals(elem.relevant, None)

   341 

   342     def test_setting_value_to_int(self):

   343         conf = model.ConfmlConfiguration('test.confml')

   344         elem = model.ConfmlIntSetting('foo', type='int')

   345         conf.add_feature(elem)

   346         elem.value = 1

   347         self.assertEquals(elem.value,1)

   348         self.assertEquals(elem.get_original_value(),'1')

   349         self.assertEquals(elem.get_data().get_value(),'1')

   350 

   351     def test_setting_value_with_incompatible_values(self):

   352         conf = model.ConfmlConfiguration('test.confml')

   353         elem = model.ConfmlIntSetting('foo')

   354         conf.add_feature(elem)

   355         try:

   356             elem.value = 'hh'

   357             self.fail('setting string to int succeeds')

   358         except ValueError:

   359             pass

   360         elem.value = '1234'

   361         self.assertEquals(elem.value, 1234)

   362         elem.value = 0xA

   363         self.assertEquals(elem.value, 10)

   364         del elem.value

   365         self.assertEquals(elem.value, None)

   366 

   367     def test_setting_value_to_int(self):

   368         conf = model.ConfmlConfiguration('test.confml')

   369         elem1 = model.ConfmlIntSetting('foo')

   370         elem2 = model.ConfmlIntSetting('bar')

   371         conf.add_feature(elem1)

   372         conf.add_feature(elem2)

   373         elem1.value = 1

   374         elem2.value = 2

   375         test = elem1.value + elem2.value

   376         self.assertEquals(test,3)

   377         elem1.value = elem1.value + elem2.value + 5

   378         self.assertEquals(elem1.value,8)

   379 

   380 class TestConfmlBooleanSetting(unittest.TestCase):

   381     def test_create_setting(self):

   382         elem = model.ConfmlBooleanSetting('test')

   383         self.assertTrue(elem)

   384         self.assertEquals(elem.type, 'boolean')

   385         self.assertEquals(elem.desc, None)

   386         self.assertEquals(elem.readOnly, None)

   387         self.assertEquals(elem.constraint, None)

   388         self.assertEquals(elem.required, None)

   389         self.assertEquals(elem.relevant, None)

   390 

   391     def test_setting_value_to_int(self):

   392         conf = model.ConfmlConfiguration('test.confml')

   393         elem = model.ConfmlBooleanSetting('foo', type='int')

   394         self.assertEquals(elem.type, 'boolean')

   395         conf.add_feature(elem)

   396         elem.value = 1

   397         # Set elem rfs value

   398         elem.set_value(True, 'rfs')

   399         self.assertEquals(elem.get_value('rfs'),True)

   400         self.assertEquals(elem.get_original_value('rfs'),'true')

   401         self.assertEquals(elem.value,1)

   402         self.assertEquals(elem.get_original_value(),'true')

   403         self.assertEquals(elem.get_data().get_value(),'true')

   404 

   405     def test_setting_value_with_incompatible_values(self):

   406         conf = model.ConfmlConfiguration('test.confml')

   407         elem = model.ConfmlBooleanSetting('foo')

   408         conf.add_feature(elem)

   409         elem.value = '1234'

   410         self.assertEquals(elem.value, True)

   411         elem.value = 0xA

   412         self.assertEquals(elem.value, True)

   413         elem.value = False

   414         self.assertEquals(elem.value, False)

   415         elem.value = ''

   416         self.assertEquals(elem.value, False)

   417         del elem.value

   418         self.assertEquals(elem.value, None)

   419     

   420     def test_setting_value_with_supported_values(self):

   421         conf = model.ConfmlConfiguration('test.confml')

   422         elem = model.ConfmlBooleanSetting('foo')

   423         conf.add_feature(elem)

   424         elem.value = '1'

   425         self.assertEquals(elem.value, True)

   426         elem.value = 'true'

   427         self.assertEquals(elem.value, True)

   428         elem.value = True

   429         self.assertEquals(elem.value, True)

   430         elem.value = '0'

   431         self.assertEquals(elem.value, False)

   432         elem.value = 'false'

   433         self.assertEquals(elem.value, False)

   434         elem.value = False

   435         self.assertEquals(elem.value, False)

   436         del elem.value

   437         self.assertEquals(elem.value, None)

   438 

   439 class TestConfmlSequenceSetting(unittest.TestCase):

   440     def test_create_setting(self):

   441         elem = model.ConfmlSequenceSetting('test')

   442         self.assertTrue(elem)

   443         self.assertEquals(elem.desc, None)

   444 

   445     def test_setting_with_properties_property(self):

   446         elem = model.ConfmlSequenceSetting('foo')

   447         elem.add_property(name='foo',value='bar/foo')

   448         elem.add_property(name='bar',value='only/bar')

   449         elem.add_property(name='testing',value='1', unit='mB')

   450         self.assertEquals(elem.properties['foo'].value,'bar/foo')

   451         self.assertEquals(elem.properties['bar'].value,'only/bar')

   452 

   453     def test_setting_with_min_occurs(self):

   454         elem = model.ConfmlSequenceSetting('foo', minOccurs=1)

   455         self.assertEquals(elem.minOccurs,1)

   456         elem.minOccurs = 2

   457         self.assertEquals(elem.minOccurs,2)

   458 

   459     def test_setting_with_max_occurs(self):

   460         elem = model.ConfmlSequenceSetting('foo', maxOccurs=10)

   461         self.assertEquals(elem.maxOccurs,10)

   462         elem.maxOccurs = 20

   463         self.assertEquals(elem.maxOccurs,20)

   464 

   465     def test_create_feature_seq_with_int_bool_settings_access_feature_value_with_property(self):

   466         config = api.Configuration('foo.confml')

   467         fea= model.ConfmlSequenceSetting("foo")

   468         fea.add_feature(model.ConfmlIntSetting('child1'))

   469         fea.add_feature(model.ConfmlBooleanSetting('child2'))

   470         fea.add_feature(model.ConfmlSetting('child3'))

   471         config.add_feature(fea)

   472         dview = config.get_default_view()

   473         foofea = dview.get_feature('foo')

   474         # Test adding a data row with array

   475         foofea.set_value([['1','2','3'],

   476                          ['4','5','6'],

   477                          ['7','8','9']

   478                          ])

   479         self.assertEquals(foofea.value, [['1','2','3'],

   480                                          ['4','5','6'],

   481                                          ['7','8','9']

   482                                         ])

   483 

   484         foofea.value = [['1','2','3'],

   485                          ['7','8','9']

   486                         ]

   487         

   488         self.assertEquals(foofea.data[0].value,['1','2','3'])

   489         self.assertEquals(foofea.data[1].value,['7','8','9'])

   490         self.assertEquals(foofea.data[1][1].value,'8')

   491         self.assertEquals(foofea.get_value(), [['1','2','3'],

   492                                                ['7','8','9']

   493                                                ])

   494         self.assertEquals(foofea.child1.value,['1','7'])

   495 

   496 class TestConfmlFile(unittest.TestCase):

   497     def test_create_localpath_elem(self):

   498         elem = model.ConfmlLocalPath()

   499         self.assertTrue(elem)

   500         self.assertEquals(elem.get_ref(),'localPath')

   501 

   502     def test_create_targetpath_elem(self):

   503         elem = model.ConfmlTargetPath()

   504         self.assertTrue(elem)

   505         self.assertEquals(elem.get_ref(),'targetPath')

   506 

   507     def test_create_file_elem(self):

   508         elem = model.ConfmlFileSetting('test')

   509         self.assertTrue(elem)

   510         self.assertEquals(elem.get_ref(),'test')

   511         self.assertEquals(elem.list_features(), ['localPath','targetPath'])

   512         self.assertEquals(elem.get_feature('localPath').fqr, 'test.localPath')

   513         self.assertEquals(elem.get_feature('targetPath').fqr, 'test.targetPath')

   514 

   515     def test_create_file_elem_and_set_value(self):

   516         config = api.Configuration('test.confml')

   517         elem = model.ConfmlFileSetting('test', localpath='test.txt')

   518         config.add_feature(elem)

   519         dview = config.get_default_view()

   520         self.assertEquals(dview.list_all_features(),['test','test.localPath','test.targetPath'])

   521         dview.get_feature('test.localPath').set_value('foo/test.txt')

   522         dview.get_feature('test.targetPath').set_value('Z:\\test\test.txt')

   523         dview.get_feature('test.localPath').set_value('now/test.txt')

   524         self.assertEquals(dview.get_feature('test.localPath').get_value(),'now/test.txt')

   525         self.assertEquals(len(dview.get_feature('test.localPath').get_datas()),1)

   526 

   527     def test_clone_file_elem(self):

   528         elem1 = model.ConfmlFileSetting('test')

   529         elem2 = elem1._clone(recursion=True)

   530         

   531 

   532 class TestConfmlIcon(unittest.TestCase):

   533     def test_create_icon(self):

   534         icon = model.ConfmlIcon("test/foo/bar.jpg")

   535         self.assertEquals(icon.href, "test/foo/bar.jpg")

   536         icon.href = 'new/icon.jpg'

   537         self.assertEquals(icon.href, "new/icon.jpg")

   538 

   539     def test_clone_icon(self):

   540         icon1 = model.ConfmlIcon("test/foo/bar.jpg")

   541         icon2 = icon1._clone()

   542         self.assertEquals(icon1.href, icon2.href)

   543 

   544 

   545 class TestLengths(unittest.TestCase):

   546     def test_create_maxLength(self):

   547         max = model.ConfmlMaxLength('100')

   548         self.assertEquals(max.value, '100')

   549 

   550     def test_create_minLength(self):

   551         min = model.ConfmlMinLength('100')

   552         self.assertEquals(min.value, '100')

   553 

   554 class TestConfmlFacets(unittest.TestCase):

   555     def test_create_inclusive(self):

   556         min = model.ConfmlMinInclusive('-10')

   557         max = model.ConfmlMaxInclusive('10')

   558         self.assertEquals(min.value, '-10')

   559         self.assertEquals(max.value, '10')

   560 

   561     def test_create_exclusive(self):

   562         min = model.ConfmlMinExclusive('0')

   563         max = model.ConfmlMaxExclusive("9")

   564         self.assertEquals(min.value, '0')

   565         self.assertEquals(max.value, '9')

   566 

   567     def test_create_pattern(self):

   568         pattern = model.ConfmlPattern("[a-zA-Z]")

   569         self.assertEquals(pattern.value, "[a-zA-Z]")

   570 

   571     def test_create_totalDigits(self):

   572         digits = model.ConfmlTotalDigits("3")

   573         self.assertEquals(digits.value, '3')

   574 

   575 class TestConfmlConfiguration(unittest.TestCase):

   576     def test_create_configuration(self):

   577         config = model.ConfmlConfiguration("test/foo/bar.jpg")

   578         self.assertEquals(config.meta, None)

   579         self.assertEquals(config.desc, None)

   580         self.assertEquals(config.name, 'test__foo__bar_jpg')

   581         self.assertEquals(config.ref, 'test__foo__bar_jpg')

   582         self.assertEquals(config.path, 'test/foo/bar.jpg')

   583 

   584 #    def test_configuration_access_meta(self):

   585 #        config = model.ConfmlConfiguration("test/foo/bar.jpg", meta={'test':'foo','bar':' hd dd'})

   586 #        self.assertEquals(config.meta.dict, {'test':'foo','bar':' hd dd'})

   587 #        self.assertEquals(config.meta['test'],'foo')

   588 #        config.meta = {'test':'123'}

   589 #        self.assertEquals(config.meta['test'],'123')

   590 #        del config.meta

   591 #        self.assertEquals(config.meta, None)

   592         

   593     def test_configuration_access_desc(self):

   594         config = model.ConfmlConfiguration("test/foo/bar.jpg", desc="testing description")

   595         self.assertEquals(config.desc, "testing description")

   596         config.desc = 'new desc'

   597         self.assertEquals(config.desc, "new desc")

   598         del config.desc

   599         self.assertEquals(config.desc, None)

   600 

   601 class TestConfmlProperty(unittest.TestCase):

   602     def test_create_property(self):

   603         property = model.ConfmlProperty(name='test',value='foo', unit='kB')

   604         self.assertEquals(property.name, 'test')

   605         self.assertEquals(property.value, 'foo')

   606         self.assertEquals(property.unit, 'kB')

   607         property.name = 'testnew'

   608         property.value = 'foo faa'

   609         self.assertEquals(property.name, 'testnew')

   610         self.assertEquals(property.value, 'foo faa')

   611