|
0
|
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 |
|