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 |
"""
|
|
18 |
Test the configuration
|
|
19 |
"""
|
|
20 |
import unittest
|
|
21 |
import string
|
|
22 |
import sys,os
|
|
23 |
import __init__
|
|
24 |
|
|
25 |
from cone.public import api,exceptions,utils
|
|
26 |
|
|
27 |
|
|
28 |
class TestFeature(unittest.TestCase):
|
|
29 |
def comparefeatures(self,fea1,fea2):
|
|
30 |
self.assertEquals(fea1.ref, fea2.ref)
|
|
31 |
self.assertEquals(fea1.fqr, fea2.fqr)
|
|
32 |
self.assertEquals(fea1.name, fea2.name)
|
|
33 |
self.assertEquals(fea1.type, fea2.type)
|
|
34 |
|
|
35 |
def test_create_feature(self):
|
|
36 |
fea= api.Feature("foo")
|
|
37 |
self.assertTrue(fea)
|
|
38 |
|
|
39 |
def test_get_namespace(self):
|
|
40 |
fea= api.Feature("foo")
|
|
41 |
self.assertTrue(fea)
|
|
42 |
self.assertEquals(fea.namespace,"")
|
|
43 |
|
|
44 |
def test_get_ref(self):
|
|
45 |
fea= api.Feature("foo")
|
|
46 |
self.assertTrue(fea)
|
|
47 |
self.assertEquals(fea.get_ref(),"foo")
|
|
48 |
|
|
49 |
def test_create_config_with_namespace_and_get_fqr(self):
|
|
50 |
conf = api.Configuration("test.confml", namespace="com.nokia.s60")
|
|
51 |
conf.add_feature(api.Feature("foo"))
|
|
52 |
fea= conf.get_feature("foo")
|
|
53 |
self.assertEquals(fea.namespace,"com.nokia.s60")
|
|
54 |
self.assertEquals(fea.fqr,"com.nokia.s60.foo")
|
|
55 |
|
|
56 |
def test_set_ref_and_get_all(self):
|
|
57 |
conf = api.Configuration("test.confml", namespace="com.nokia.s60")
|
|
58 |
conf.add_feature(api.Feature("foo"))
|
|
59 |
fea = conf.get_feature("foo")
|
|
60 |
fea.set_ref("wlan")
|
|
61 |
self.assertEquals(fea.get_ref(),"wlan")
|
|
62 |
self.assertEquals(fea.namespace,"com.nokia.s60")
|
|
63 |
self.assertEquals(fea.fqr,"com.nokia.s60.wlan")
|
|
64 |
|
|
65 |
def test_create_subfeature_and_get_namespace(self):
|
|
66 |
fea= api.Feature("foo")
|
|
67 |
fea.add_feature(api.Feature("bar"))
|
|
68 |
bar = fea.get_feature("bar")
|
|
69 |
self.assertTrue(bar)
|
|
70 |
self.assertEquals(bar.get_ref(),"bar")
|
|
71 |
self.assertEquals(bar.namespace,"foo")
|
|
72 |
self.assertEquals(bar.fqr,"foo.bar")
|
|
73 |
|
|
74 |
def test_create_subfeature_and_get_namespace_with_config(self):
|
|
75 |
conf = api.Configuration("test.confml", namespace="com.nokia.s60")
|
|
76 |
conf.add_feature(api.Feature("foo"))
|
|
77 |
fea= conf.get_feature("foo")
|
|
78 |
fea.add_feature(api.Feature("bar"))
|
|
79 |
bar = fea.get_feature("bar")
|
|
80 |
self.assertTrue(bar)
|
|
81 |
self.assertEquals(bar.get_ref(),"bar")
|
|
82 |
self.assertEquals(bar.namespace,"com.nokia.s60.foo")
|
|
83 |
self.assertEquals(bar.fqr,"com.nokia.s60.foo.bar")
|
|
84 |
|
|
85 |
def test_create_feature_proxy(self):
|
|
86 |
fea= api.Feature("foo", name="foo bar")
|
|
87 |
feaproxy = api._FeatureProxy("foo",fea)
|
|
88 |
self.assertTrue(feaproxy.get_ref(),"foo")
|
|
89 |
self.assertEquals(feaproxy.namespace,"")
|
|
90 |
self.assertEquals(feaproxy.fqr,"foo")
|
|
91 |
self.assertEquals(feaproxy.name,"foo bar")
|
|
92 |
feaproxy.add_feature(api.Feature("bar", name="bar man"))
|
|
93 |
self.assertTrue(feaproxy.bar.get_ref(),"bar")
|
|
94 |
self.assertEquals(feaproxy.bar.namespace,"foo")
|
|
95 |
self.assertEquals(feaproxy.bar.fqr,"foo.bar")
|
|
96 |
self.assertEquals(feaproxy.bar.name,"bar man")
|
|
97 |
|
|
98 |
|
|
99 |
def test_create_feature_data(self):
|
|
100 |
dataobj = api.Data(ref="foo", value=132)
|
|
101 |
self.assertTrue(dataobj.fqr,"foo")
|
|
102 |
self.assertTrue(dataobj.get_value(),123)
|
|
103 |
self.assertTrue(dataobj.value,123)
|
|
104 |
|
|
105 |
def test_create_feature_data_proxy(self):
|
|
106 |
fea= api.Feature("foo")
|
|
107 |
feaproxy = api._FeatureDataProxy("foo",fea)
|
|
108 |
self.assertTrue(feaproxy.get_ref(),"foo")
|
|
109 |
self.assertEquals(feaproxy._get_data(),None)
|
|
110 |
self.assertEquals(feaproxy._get_value(),None)
|
|
111 |
feaproxy._add_data(api.Data(ref="foo", value=123))
|
|
112 |
self.assertEquals(feaproxy._get_data().get_value(),123)
|
|
113 |
feaproxy._add_data(api.Data(ref="foo", value=321))
|
|
114 |
self.assertEquals(feaproxy._get_data().get_value(),321)
|
|
115 |
self.assertEquals(feaproxy._get_datas()[0].get_value(),123)
|
|
116 |
self.assertEquals(feaproxy._get_datas()[1].get_value(),321)
|
|
117 |
self.assertEquals(feaproxy._get_values(),[123,321])
|
|
118 |
|
|
119 |
def test_access_feature_data_proxy_children_with_sequence_operations(self):
|
|
120 |
fea= api.Feature("foo")
|
|
121 |
feaproxy = api._FeatureDataProxy("foo",fea)
|
|
122 |
feaproxy.add_feature(api.Feature("child1"))
|
|
123 |
feaproxy.add_feature(api.Feature("child2"))
|
|
124 |
feaproxy.add_feature(api.Feature("?child"))
|
|
125 |
feaproxy.add_feature(api.Feature("child3"))
|
|
126 |
feaproxy.add_feature(api.Feature("child4"))
|
|
127 |
self.assertEquals(len(feaproxy),4)
|
|
128 |
self.assertEquals(feaproxy[0].get_ref(),'child1')
|
|
129 |
self.assertEquals(feaproxy[1].get_ref(),'child2')
|
|
130 |
self.assertEquals(feaproxy[2].get_ref(),'child3')
|
|
131 |
self.assertEquals(feaproxy[3].get_ref(),'child4')
|
|
132 |
|
|
133 |
del feaproxy[2]
|
|
134 |
self.assertEquals(len(feaproxy),3)
|
|
135 |
self.assertEquals(feaproxy[0].get_ref(),'child1')
|
|
136 |
self.assertEquals(feaproxy[1].get_ref(),'child2')
|
|
137 |
self.assertEquals(feaproxy[2].get_ref(),'child4')
|
|
138 |
self.assertEquals(feaproxy[2].get_ref(),'child4')
|
|
139 |
self.assertEquals(feaproxy.get_feature('?child').get_ref(),'?child')
|
|
140 |
|
|
141 |
def test_create_boolean_feature(self):
|
|
142 |
fea = api.Feature('test',type='boolean')
|
|
143 |
vset = fea.get_valueset()
|
|
144 |
self.assertTrue(vset <= api.ValueSet([True,False]))
|
|
145 |
self.assertTrue(len(vset) == 2)
|
|
146 |
self.assertTrue(True in vset)
|
|
147 |
self.assertTrue(False in vset)
|
|
148 |
self.assertFalse(123 in vset)
|
|
149 |
|
|
150 |
def test_create_string_feature(self):
|
|
151 |
fea = api.Feature('test',type='string')
|
|
152 |
vset = fea.get_valueset()
|
|
153 |
self.assertTrue('test' in vset)
|
|
154 |
self.assertTrue('foobar' in vset)
|
|
155 |
self.assertFalse(False in vset)
|
|
156 |
self.assertFalse(123 in vset)
|
|
157 |
|
|
158 |
def test_create_integer_feature(self):
|
|
159 |
fea = api.Feature('test',type='int')
|
|
160 |
vset = fea.get_valueset()
|
|
161 |
self.assertFalse('test' in vset)
|
|
162 |
self.assertFalse('foobar' in vset)
|
|
163 |
self.assertTrue(False in vset)
|
|
164 |
self.assertTrue(123 in vset)
|
|
165 |
self.assertTrue(0 in vset)
|
|
166 |
self.assertTrue(100000000 in vset)
|
|
167 |
self.assertFalse(-1 in vset)
|
|
168 |
self.assertFalse(0.2 in vset)
|
|
169 |
|
|
170 |
def test_create_selection_feature(self):
|
|
171 |
fea = api.Feature('test',type='selection')
|
|
172 |
fea.create_option('test', '1')
|
|
173 |
fea.create_option('one', '2')
|
|
174 |
fea.create_option('two', '3')
|
|
175 |
vset = fea.get_valueset()
|
|
176 |
self.assertTrue('1' in vset)
|
|
177 |
self.assertFalse('foo' in vset)
|
|
178 |
self.assertTrue('2' in vset)
|
|
179 |
self.assertTrue('3' in vset)
|
|
180 |
self.assertEquals(fea.get_option('value_2').get_name(), 'one')
|
|
181 |
|
|
182 |
def test_create_sequence_feature(self):
|
|
183 |
fea = api.FeatureSequence('test')
|
|
184 |
fea.add_feature(api.Feature('child1',type='int'))
|
|
185 |
fea.add_feature(api.Feature('child2'))
|
|
186 |
fea.add_feature(api.Feature('child3'))
|
|
187 |
self.assertEquals(fea.get_type(), 'sequence')
|
|
188 |
self.assertEquals(fea.list_features(), ['child1','child2','child3'])
|
|
189 |
|
|
190 |
def test_feature_get_dict(self):
|
|
191 |
fea= api.Feature("foo", type='int')
|
|
192 |
self.assertEquals(fea._dict(), {'ref': 'foo','type': 'int', 'name': 'foo'})
|
|
193 |
|
|
194 |
def test_clone_single_feature(self):
|
|
195 |
fea= api.Feature("foo", type='int')
|
|
196 |
fea2 = fea._clone()
|
|
197 |
self.comparefeatures(fea,fea2)
|
|
198 |
|
|
199 |
def test_clone_feature_with_subfeatures(self):
|
|
200 |
fea= api.Feature("foo")
|
|
201 |
fea.add_feature(api.Feature("child1",type='string'))
|
|
202 |
fea.add_feature(api.Feature("child2",type='int'))
|
|
203 |
fea.child1.add_feature(api.Feature("child12",type='int'))
|
|
204 |
fea2 = fea._clone()
|
|
205 |
self.comparefeatures(fea,fea2)
|
|
206 |
fea3 = fea._clone(recursion=True, recursion_depth=1)
|
|
207 |
self.comparefeatures(fea,fea3)
|
|
208 |
self.comparefeatures(fea.get_feature('child1'),fea3.get_feature('child1'))
|
|
209 |
self.comparefeatures(fea.get_feature('child2'),fea3.get_feature('child2'))
|
|
210 |
self.assertEquals(fea3.child1.list_features(),[])
|
|
211 |
fea4 = fea._clone(recursion=True)
|
|
212 |
self.comparefeatures(fea,fea4)
|
|
213 |
self.comparefeatures(fea.get_feature('child1'),fea4.get_feature('child1'))
|
|
214 |
self.comparefeatures(fea.get_feature('child2'),fea4.get_feature('child2'))
|
|
215 |
self.assertEquals(fea4.child1.list_features(),['child12'])
|
|
216 |
self.comparefeatures(fea.child1.get_feature('child12'),fea4.child1.get_feature('child12'))
|
|
217 |
|
|
218 |
def test_clone_feature_with_options(self):
|
|
219 |
fea= api.Feature("foo")
|
|
220 |
fea.add_feature(api.Feature("child1",type='selection'))
|
|
221 |
fea.add_feature(api.Feature("child2",type='int'))
|
|
222 |
fea.child1.create_option('one','1')
|
|
223 |
fea.child1.create_option('two','2')
|
|
224 |
fea.child1.create_option('three','3')
|
|
225 |
fea2 = fea._clone(recursion=True)
|
|
226 |
self.comparefeatures(fea,fea2)
|
|
227 |
self.comparefeatures(fea.get_feature('child1'),fea2.get_feature('child1'))
|
|
228 |
self.assertEquals(fea.child1.list_options(),fea2.child1.list_options())
|
|
229 |
|
|
230 |
def test_compare_features(self):
|
|
231 |
fea1= api.Feature("foo")
|
|
232 |
fea2= api.Feature("foo")
|
|
233 |
fea3= api.Feature("foo", type='boolean')
|
|
234 |
fea4= api.Feature("foo", bar='yes')
|
|
235 |
fea5= api.Feature("foo", bar='yes')
|
|
236 |
self.assertTrue(fea1._compare(fea2))
|
|
237 |
self.assertFalse(fea1._compare(fea3))
|
|
238 |
self.assertTrue(fea1._compare(fea4))
|
|
239 |
self.assertTrue(fea5._compare(fea4, ['bar']))
|
|
240 |
self.assertTrue(fea1._compare(fea2, ['bar']))
|
|
241 |
|
|
242 |
class TestFeatureSequence(unittest.TestCase):
|
|
243 |
def comparefeatures(self,fea1,fea2):
|
|
244 |
self.assertEquals(fea1.ref, fea2.ref)
|
|
245 |
self.assertEquals(fea1.fqr, fea2.fqr)
|
|
246 |
self.assertEquals(fea1.name, fea2.name)
|
|
247 |
self.assertEquals(fea1.type, fea2.type)
|
|
248 |
|
|
249 |
# @test
|
|
250 |
def test_create_feature(self):
|
|
251 |
fea= api.FeatureSequence("foo")
|
|
252 |
self.assertTrue(fea)
|
|
253 |
|
|
254 |
def test_create_feature_with_children(self):
|
|
255 |
fea= api.FeatureSequence("foo")
|
|
256 |
fea.add_feature(api.Feature('child1'))
|
|
257 |
fea.add_feature(api.Feature('child2'))
|
|
258 |
fea.add_feature(api.Feature('child3'))
|
|
259 |
self.assertEquals(fea.list_features(),['child1','child2','child3'])
|
|
260 |
|
|
261 |
def test_create_configuration_with_sequence_and_get_default_view(self):
|
|
262 |
fea= api.FeatureSequence("foo")
|
|
263 |
fea.add_feature(api.Feature('child1'))
|
|
264 |
fea.add_feature(api.Feature('child2'))
|
|
265 |
fea.add_feature(api.Feature('child3'))
|
|
266 |
config = api.Configuration('foo.confml')
|
|
267 |
config.add_feature(fea)
|
|
268 |
dview = config.get_default_view()
|
|
269 |
self.assertEquals(dview.list_all_features(),['foo','foo.child1','foo.child2','foo.child3'])
|
|
270 |
|
|
271 |
def test_create_configuration_with_sequence_and_add_data_with_default_view(self):
|
|
272 |
fea= api.FeatureSequence("foo")
|
|
273 |
fea.add_feature(api.Feature('child1'))
|
|
274 |
fea.add_feature(api.Feature('child2'))
|
|
275 |
fea.add_feature(api.Feature('child3'))
|
|
276 |
config = api.Configuration('foo.confml')
|
|
277 |
config.add_feature(fea)
|
|
278 |
dview = config.get_default_view()
|
|
279 |
foofea = dview.get_feature('foo')
|
|
280 |
|
|
281 |
data = api.Data(ref='foo')
|
|
282 |
data._add(api.Data(ref='child1',value='test1'))
|
|
283 |
data._add(api.Data(ref='child2',value='test2'))
|
|
284 |
data._add(api.Data(ref='child3',value='test3'))
|
|
285 |
foofea.add_data(data)
|
|
286 |
data1 = api.Data(ref='foo', policy='append')
|
|
287 |
data1._add(api.Data(ref='child1',value='jee'))
|
|
288 |
data1._add(api.Data(ref='child2',value='oo'))
|
|
289 |
data1._add(api.Data(ref='child3',value='aa'))
|
|
290 |
|
|
291 |
foofea.add_data(data1)
|
|
292 |
self.assertEquals(len(foofea.get_data()), 2)
|
|
293 |
|
|
294 |
self.assertEquals(foofea.get_data()[0].list_features(), ['child1','child2','child3'])
|
|
295 |
self.assertEquals(foofea.get_data()[0].get_feature('child1').get_value(), 'test1')
|
|
296 |
self.assertEquals(foofea.get_data()[0].get_feature('child2').get_value(), 'test2')
|
|
297 |
self.assertEquals(foofea.get_data()[0].get_feature('child3').get_value(), 'test3')
|
|
298 |
|
|
299 |
self.assertEquals(foofea.get_data()[1].list_features(), ['child1','child2','child3'])
|
|
300 |
self.assertEquals(foofea.get_data()[1].get_feature('child1').get_value(), 'jee')
|
|
301 |
self.assertEquals(foofea.get_data()[1].get_feature('child2').get_value(), 'oo')
|
|
302 |
self.assertEquals(foofea.get_data()[1].get_feature('child3').get_value(), 'aa')
|
|
303 |
|
|
304 |
self.assertEquals(foofea.get_value(), [['test1','test2','test3'],
|
|
305 |
['jee','oo','aa']])
|
|
306 |
self.assertEquals(foofea.get_data()[0][0].get_value(), 'test1')
|
|
307 |
# Test recurse
|
|
308 |
for row in foofea.get_data():
|
|
309 |
for col in row:
|
|
310 |
print col.get_value(),
|
|
311 |
print
|
|
312 |
|
|
313 |
def test_create_configuration_with_sequence_and_add_values_with_default_view(self):
|
|
314 |
fea= api.FeatureSequence("foo")
|
|
315 |
fea.add_feature(api.Feature('child1'))
|
|
316 |
fea.add_feature(api.Feature('child2'))
|
|
317 |
fea.add_feature(api.Feature('child3'))
|
|
318 |
config = api.Configuration('foo.confml')
|
|
319 |
config.add_feature(fea)
|
|
320 |
dview = config.get_default_view()
|
|
321 |
foofea = dview.get_feature('foo')
|
|
322 |
# Test adding a data row with array
|
|
323 |
foofea.add_sequence(['1','2','3'])
|
|
324 |
foofea.add_sequence(['4','5','6'])
|
|
325 |
foofea.add_sequence(['7','8','9'])
|
|
326 |
print foofea.get_data()[0].get_feature('child1').get_value()
|
|
327 |
self.assertEquals(len(foofea.get_data()), 3)
|
|
328 |
self.assertEquals(foofea.get_value(), [['1','2','3'],
|
|
329 |
['4','5','6'],
|
|
330 |
['7','8','9']
|
|
331 |
])
|
|
332 |
|
|
333 |
|
|
334 |
def test_create_configuration_with_sequence_and_add_sequence_value_directly(self):
|
|
335 |
fea= api.FeatureSequence("foo")
|
|
336 |
fea.add_feature(api.Feature('child1'))
|
|
337 |
fea.add_feature(api.Feature('child2'))
|
|
338 |
fea.add_feature(api.Feature('child3'))
|
|
339 |
config = api.Configuration('foo.confml')
|
|
340 |
config.add_feature(fea)
|
|
341 |
dview = config.get_default_view()
|
|
342 |
foofea = dview.get_feature('foo')
|
|
343 |
# Test adding a data row with array
|
|
344 |
foofea.set_value([['1','2','3'],
|
|
345 |
['4','5','6'],
|
|
346 |
['7','8','9']
|
|
347 |
])
|
|
348 |
self.assertEquals(len(foofea.get_data()), 3)
|
|
349 |
self.assertEquals(foofea.get_value(), [['1','2','3'],
|
|
350 |
['4','5','6'],
|
|
351 |
['7','8','9']
|
|
352 |
])
|
|
353 |
|
|
354 |
def test_create_configuration_and_access_feature_value_with_property(self):
|
|
355 |
config = api.Configuration('foo.confml')
|
|
356 |
fea= api.Feature("foo")
|
|
357 |
config.add_feature(fea)
|
|
358 |
fea.set_value('test')
|
|
359 |
self.assertEquals(fea.value,'test')
|
|
360 |
dview = config.get_default_view()
|
|
361 |
feaproxy = dview.get_feature('foo')
|
|
362 |
val = feaproxy.value
|
|
363 |
self.assertEquals(val,'test')
|
|
364 |
feaproxy.value = 'test2'
|
|
365 |
self.assertEquals(feaproxy.value,'test2')
|
|
366 |
del feaproxy.value
|
|
367 |
self.assertEquals(feaproxy.value,None)
|
|
368 |
feaproxy.value = 'test3'
|
|
369 |
self.assertEquals(feaproxy.value,'test3')
|
|
370 |
|
|
371 |
def test_create_configuration_and_access_feature_type_with_property(self):
|
|
372 |
config = api.Configuration('foo.confml')
|
|
373 |
fea= api.Feature("foo", type='int')
|
|
374 |
config.add_feature(fea)
|
|
375 |
self.assertEquals(fea.type, 'int')
|
|
376 |
dview = config.get_default_view()
|
|
377 |
feaproxy = dview.get_feature('foo')
|
|
378 |
self.assertEquals(feaproxy.type, 'int')
|
|
379 |
|
|
380 |
def test_create_feature_seq_and_access_feature_value_with_property(self):
|
|
381 |
config = api.Configuration('foo.confml')
|
|
382 |
fea= api.FeatureSequence("foo")
|
|
383 |
fea.add_feature(api.Feature('child1'))
|
|
384 |
fea.add_feature(api.Feature('child11'),'child1')
|
|
385 |
fea.add_feature(api.Feature('child2'))
|
|
386 |
fea.add_feature(api.Feature('child3'))
|
|
387 |
config.add_feature(fea)
|
|
388 |
dview = config.get_default_view()
|
|
389 |
foofea = dview.get_feature('foo')
|
|
390 |
# Test adding a data row with array
|
|
391 |
foofea.set_value([[['1'],'2','3'],
|
|
392 |
[['4'],'5','6'],
|
|
393 |
[['7'],'8','9']
|
|
394 |
])
|
|
395 |
self.assertEquals(foofea.value, [[['1'],'2','3'],
|
|
396 |
[['4'],'5','6'],
|
|
397 |
[['7'],'8','9']
|
|
398 |
])
|
|
399 |
|
|
400 |
foofea.value = [[['1'],'2','3'],
|
|
401 |
[['7'],'8','9']
|
|
402 |
]
|
|
403 |
|
|
404 |
self.assertEquals(foofea.data[0].value,[['1'],'2','3'])
|
|
405 |
self.assertEquals(foofea.data[1].value,[['7'],'8','9'])
|
|
406 |
self.assertEquals(foofea.data[1][1].value,'8')
|
|
407 |
self.assertEquals(foofea.get_value(), [[['1'],'2','3'],
|
|
408 |
[['7'],'8','9']
|
|
409 |
])
|
|
410 |
self.assertEquals(foofea.child1.child11.value,['1','7'])
|
|
411 |
self.assertEquals(foofea.child1.value,[['1'],['7']])
|
|
412 |
|
|
413 |
def test_create_feature_seq_and_access_empty_data(self):
|
|
414 |
config = api.Configuration('foo.confml')
|
|
415 |
fea= api.FeatureSequence("foo")
|
|
416 |
fea.add_feature(api.Feature('child1'))
|
|
417 |
fea.add_feature(api.Feature('child11'),'child1')
|
|
418 |
fea.add_feature(api.Feature('child2'))
|
|
419 |
fea.add_feature(api.Feature('child3'))
|
|
420 |
config.add_feature(fea)
|
|
421 |
dview = config.get_default_view()
|
|
422 |
foofea = dview.get_feature('foo')
|
|
423 |
foofea.value = []
|
|
424 |
self.assertEquals(foofea.value, [])
|
|
425 |
|
|
426 |
def test_create_feature_seq_get_sequence_parent(self):
|
|
427 |
config = api.Configuration('foo.confml')
|
|
428 |
fea= api.FeatureSequence("foo")
|
|
429 |
fea.add_feature(api.Feature('child1'))
|
|
430 |
fea.add_feature(api.Feature('child11'),'child1')
|
|
431 |
fea.add_feature(api.Feature('child2'))
|
|
432 |
fea.add_feature(api.Feature('child3'))
|
|
433 |
self.assertEquals(fea.child1.get_sequence_parent(), fea)
|
|
434 |
self.assertEquals(fea.child1.child11.get_sequence_parent(), fea)
|
|
435 |
|
|
436 |
def test_clone_feature_sequence(self):
|
|
437 |
fea= api.FeatureSequence("foo")
|
|
438 |
fea.add_feature(api.Feature('child1'))
|
|
439 |
fea.add_feature(api.Feature('child2'))
|
|
440 |
fea.add_feature(api.Feature('child3'))
|
|
441 |
fea2 = fea._clone(recursion=True)
|
|
442 |
self.comparefeatures(fea,fea2)
|
|
443 |
self.assertEquals(fea.list_features(),fea2.list_features())
|
|
444 |
|
|
445 |
def test_create_configuration_with_sequence_and_mapping_properties(self):
|
|
446 |
fea = api.FeatureSequence("SequenceSetting", mapKey='KeySubSetting', mapValue="ValueSubSetting")
|
|
447 |
fea.add_feature(api.Feature('KeySubSetting'))
|
|
448 |
fea.add_feature(api.Feature('ValueSubSetting'))
|
|
449 |
|
|
450 |
config = api.Configuration('foo.confml')
|
|
451 |
config.add_feature(fea)
|
|
452 |
dview = config.get_default_view()
|
|
453 |
seqfea = dview.get_feature("SequenceSetting")
|
|
454 |
|
|
455 |
self.assertEquals(seqfea.get_map_key().name,"KeySubSetting")
|
|
456 |
self.assertEquals(seqfea.get_map_value().name,"ValueSubSetting")
|
|
457 |
#add item 1
|
|
458 |
data = api.Data(ref='SequenceSetting')
|
|
459 |
data._add(api.Data(ref='KeySubSetting',value='Default'))
|
|
460 |
data._add(api.Data(ref='ValueSubSetting',value='Default value'))
|
|
461 |
seqfea.add_data(data)
|
|
462 |
|
|
463 |
#add item 2
|
|
464 |
data1 = api.Data(ref='SequenceSetting', policy='append')
|
|
465 |
data1._add(api.Data(ref='KeySubSetting',value='Key 1'))
|
|
466 |
data1._add(api.Data(ref='ValueSubSetting',value='Value 1'))
|
|
467 |
seqfea.add_data(data1)
|
|
468 |
|
|
469 |
self.assertEquals(len(seqfea.get_data()), 2)
|
|
470 |
|
|
471 |
self.assertEquals(seqfea.get_map_key_value('Default'),'Default value')
|
|
472 |
self.assertEquals(seqfea.get_map_key_value('Key 1'),'Value 1')
|
|
473 |
if __name__ == '__main__':
|
|
474 |
unittest.main()
|
|
475 |
|