Gaudi Framework, version v25r2
Home   Generated: Wed Jun 4 2014
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Public Member Functions | List of all members
EnvConfig.TestEnvOps.Test Class Reference
Inheritance diagram for EnvConfig.TestEnvOps.Test:
Inheritance graph
[legend]
Collaboration diagram for EnvConfig.TestEnvOps.Test:
Collaboration graph
[legend]

Public Member Functions

def setUp
 
def tearDown
 
def testValues
 
def testHidingDotVar
 
def testWrite
 
def testWriteWithList
 
def testSaveToXML
 
def testSaveToFile
 
def testSearch
 
def testVariables
 
def testDelete
 
def testSystemEnvironment
 
def testDependencies
 
def testInclude
 
def testFileDir
 
def testDefaults
 
def testVariableManipulations
 

Detailed Description

Definition at line 69 of file TestEnvOps.py.

Member Function Documentation

def EnvConfig.TestEnvOps.Test.setUp (   self)

Definition at line 72 of file TestEnvOps.py.

72 
73  def setUp(self):
74  pass
def EnvConfig.TestEnvOps.Test.tearDown (   self)

Definition at line 75 of file TestEnvOps.py.

75 
76  def tearDown(self):
77  pass
78 
def EnvConfig.TestEnvOps.Test.testDefaults (   self)

Definition at line 531 of file TestEnvOps.py.

531 
532  def testDefaults(self):
533  tmp = TempDir({'env.xml':
534 '''<?xml version="1.0" ?>
535 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
536 <env:default variable="var1">value1</env:default>
537 <env:declare variable="var2" local="true" />
538 <env:default variable="var2">test2</env:default>
539 </env:config>'''})
540 
541  if 'var1' in os.environ:
542  del os.environ['var1']
543  control = Control.Environment()
544  control.loadXML(tmp('env.xml'))
545  self.assertEqual(str(control['var1']), "value1")
546  self.assertEqual(str(control['var2']), "test2")
547 
548  os.environ['var1'] = "some_value"
549  control = Control.Environment()
550  control.loadXML(tmp('env.xml'))
551  self.assertEqual(str(control['var1']), "some_value")
552  self.assertEqual(str(control['var2']), "test2")
553 
def EnvConfig.TestEnvOps.Test.testDelete (   self)

Definition at line 275 of file TestEnvOps.py.

275 
276  def testDelete(self):
277  control = Control.Environment()
278 
279  control.append('MY_PATH','myVal:anotherVal:lastVal')
280  control.remove('MY_PATH','anotherVal')
281 
282  self.assertFalse('anotherVal' in control['MY_PATH'])
283  self.assertTrue('myVal' in control['MY_PATH'])
284  self.assertTrue('lastVal' in control['MY_PATH'])
285 
286  control.set('MY_PATH','myVal:anotherVal:lastVal:else')
287  control.remove('MY_PATH', '^anotherVal$', False)
288  self.assertTrue('anotherVal' in control['MY_PATH'])
289  control.remove('MY_PATH', '^anotherVal$', True)
290  self.assertFalse('anotherVal' in control['MY_PATH'])
291  self.assertTrue('myVal' in control['MY_PATH'])
292  self.assertTrue('lastVal' in control['MY_PATH'])
293  self.assertTrue('lastVal' in control['MY_PATH'])
294  control.remove('MY_PATH', 'Val', True)
295  self.assertTrue('else' in control['MY_PATH'])
296  self.assertTrue(len(control['MY_PATH']) == 1)
297 
298 
299  control.declare('myLoc', 'scalar', False)
300  control.append('myLoc','myVal:anotherVal:lastVal')
301  control.remove('myLoc', 'Val:', True)
302  self.assertTrue(str(control['myLoc']) == 'myanotherlastVal')
303 
def EnvConfig.TestEnvOps.Test.testDependencies (   self)

Definition at line 320 of file TestEnvOps.py.

320 
321  def testDependencies(self):
322  control = Control.Environment()
323 
324  control.declare('myVar', 'list', False)
325 
326  control.declare('loc', 'list', True)
327  control.append('loc','locVal')
328  control.append('loc','locVal2')
329 
330  control.declare('scal', 'scalar', False)
331  control.append('scal','scalVal')
332  control.append('scal','scalVal2')
333 
334  control.declare('scal2', 'scalar', True)
335  control.append('scal2','locScal')
336  control.append('scal2','locScal2')
337 
338  control.set('myVar', 'newValue:$loc:endValue')
339  self.assertEqual(str(control['myVar']),'newValue:locVal:locVal2:endValue')
340 
341  control.set('myVar', 'newValue:$scal:endValue')
342  self.assertEqual(str(control['myVar']),'newValue:scalValscalVal2:endValue')
343 
344  control.set('myVar', 'new${scal}Value:endValue')
345  self.assertEqual(str(control['myVar']),'newscalValscalVal2Value:endValue')
346 
347  control.set('myVar', 'bla:$myVar:Value')
348  self.assertEqual(str(control['myVar']),'bla:newscalValscalVal2Value:endValue:Value')
349 
350  control.set('scal', 'new${scal2}Value')
351  self.assertEqual(str(control['scal']),'newlocScallocScal2Value')
352 
353  control.set('scal', 'new${loc}Value')
354  self.assertEqual(str(control['scal']),'newlocVal:locVal2Value')
355 
356  control.set('scal2', 'new${scal2}Value')
357  self.assertEqual(str(control['scal2']),'newlocScallocScal2Value')
def EnvConfig.TestEnvOps.Test.testFileDir (   self)

Definition at line 508 of file TestEnvOps.py.

508 
509  def testFileDir(self):
510  tmp = TempDir({'env.xml':
511 '''<?xml version="1.0" ?>
512 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
513 <env:set variable="mydirs">${.}</env:set>
514 <env:set variable="myparent">${.}/..</env:set>
515 </env:config>'''})
516 
517  control = Control.Environment()
518  control.loadXML(tmp('env.xml'))
519  self.assertEqual(str(control['mydirs']), tmp())
520  self.assertEqual(str(control['myparent']), os.path.dirname(tmp()))
521 
522  olddir = os.getcwd()
523  os.chdir(tmp())
524  try:
525  control = Control.Environment()
526  control.loadXML('env.xml')
527  self.assertEqual(str(control['mydirs']), tmp())
528  self.assertEqual(str(control['myparent']), os.path.dirname(tmp()))
529  finally:
530  os.chdir(olddir)
def EnvConfig.TestEnvOps.Test.testHidingDotVar (   self)

Definition at line 106 of file TestEnvOps.py.

106 
107  def testHidingDotVar(self):
108  control = Control.Environment()
109  control.variables['.'].set('some/dir')
110 
111  self.assertTrue('.' in control.variables)
112  self.assertTrue('.' not in control.vars())
113  self.assertTrue('.' not in control.vars(strings=False))
114 
115  control.set('MY_DIR', '${.}')
116  self.assertEqual(control.var('MY_DIR').value(True), 'some/dir')
117  self.assertEqual(control.vars()['MY_DIR'], 'some/dir')
118 
119 
def EnvConfig.TestEnvOps.Test.testInclude (   self)

Definition at line 358 of file TestEnvOps.py.

358 
359  def testInclude(self):
360  tmp = TempDir({'first.xml':
361 '''<?xml version="1.0" ?>
362 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
363 <env:set variable="main">first</env:set>
364 <env:append variable="test_path">data1</env:append>
365 <env:include>first_inc.xml</env:include>
366 </env:config>''',
367  'second.xml':
368 '''<?xml version="1.0" ?>
369 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
370 <env:set variable="main">second</env:set>
371 <env:include>second_inc.xml</env:include>
372 <env:append variable="test_path">data1</env:append>
373 </env:config>''',
374  'third.xml':
375 '''<?xml version="1.0" ?>
376 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
377 <env:set variable="main">third</env:set>
378 <env:append variable="test_path">data1</env:append>
379 <env:include>subdir/first_inc.xml</env:include>
380 </env:config>''',
381  'fourth.xml':
382 '''<?xml version="1.0" ?>
383 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
384 <env:set variable="main">fourth</env:set>
385 <env:include hints="subdir2">fourth_inc.xml</env:include>
386 </env:config>''',
387  'recursion.xml':
388 '''<?xml version="1.0" ?>
389 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
390 <env:set variable="main">recursion</env:set>
391 <env:include>recursion.xml</env:include>
392 </env:config>''',
393  'first_inc.xml':
394 '''<?xml version="1.0" ?>
395 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
396 <env:append variable="test_path">data2</env:append>
397 <env:append variable="derived">another_${main}</env:append>
398 </env:config>''',
399  'subdir': {'second_inc.xml':
400 '''<?xml version="1.0" ?>
401 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
402 <env:append variable="test_path">data0</env:append>
403 <env:set variable="map">this_is_second_inc</env:set>
404 </env:config>''',
405  'first_inc.xml':
406 '''<?xml version="1.0" ?>
407 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
408 <env:append variable="derived">second_${main}</env:append>
409 </env:config>''',
410  'fourth_inc.xml':
411 '''<?xml version="1.0" ?>
412 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
413 <env:append variable="included">from subdir</env:append>
414 </env:config>''',},
415  'subdir2': {'fourth_inc.xml':
416 '''<?xml version="1.0" ?>
417 <env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
418 <env:append variable="included">from subdir2</env:append>
419 </env:config>''',}})
420 
421  # set the basic search path to the minimal default
422  if 'ENVXMLPATH' in os.environ:
423  del os.environ['ENVXMLPATH']
424  import EnvConfig
425  saved_path = list(EnvConfig.path)
426  EnvConfig.path[:] = ['.']
427 
428  control = Control.Environment(searchPath=[])
429 
430  #self.assertRaises(OSError, control.loadXML, tmp('first.xml'))
431  control.loadXML(tmp('first.xml'))
432  self.assertEqual(str(control['main']), 'first')
433  self.assertEqual(str(control['test_path']), 'data1:data2')
434  self.assertEqual(str(control['derived']), 'another_first')
435 
436  control = Control.Environment(searchPath=[tmp()])
437  control.loadXML(tmp('first.xml'))
438  self.assertEqual(str(control['main']), 'first')
439  self.assertEqual(str(control['test_path']), 'data1:data2')
440  self.assertEqual(str(control['derived']), 'another_first')
441 
442  control = Control.Environment(searchPath=[tmp()])
443  control.loadXML('first.xml')
444  self.assertEqual(str(control['main']), 'first')
445  self.assertEqual(str(control['test_path']), 'data1:data2')
446  self.assertEqual(str(control['derived']), 'another_first')
447 
448  control = Control.Environment(searchPath=[tmp()])
449  self.assertRaises(OSError, control.loadXML, tmp('second.xml'))
450 
451  control = Control.Environment(searchPath=[tmp(), tmp('subdir')])
452  control.loadXML(tmp('second.xml'))
453  self.assertEqual(str(control['main']), 'second')
454  self.assertEqual(str(control['test_path']), 'data0:data1')
455  self.assertEqual(str(control['map']), 'this_is_second_inc')
456 
457  control = Control.Environment(searchPath=[tmp(), tmp('subdir')])
458  control.loadXML(tmp('first.xml'))
459  self.assertEqual(str(control['main']), 'first')
460  self.assertEqual(str(control['test_path']), 'data1:data2')
461  self.assertEqual(str(control['derived']), 'another_first')
462 
463  control = Control.Environment(searchPath=[tmp('subdir'), tmp()])
464  control.loadXML(tmp('first.xml'))
465  self.assertEqual(str(control['main']), 'first')
466  self.assertEqual(str(control['test_path']), 'data1:data2')
467  self.assertEqual(str(control['derived']), 'another_first')
468 
469  control = Control.Environment(searchPath=[tmp('subdir'), tmp()])
470  control.loadXML('first.xml')
471  self.assertEqual(str(control['main']), 'first')
472  self.assertEqual(str(control['test_path']), 'data1:data2')
473  self.assertEqual(str(control['derived']), 'another_first')
474 
475  #os.environ['ENVXMLPATH'] = os.pathsep.join([tmp(), tmp('subdir')])
476  EnvConfig.path[:] = ['.', tmp(), tmp('subdir')]
477  control = Control.Environment(searchPath=[])
478  control.loadXML(tmp('second.xml'))
479  self.assertEqual(str(control['main']), 'second')
480  self.assertEqual(str(control['test_path']), 'data0:data1')
481  self.assertEqual(str(control['map']), 'this_is_second_inc')
482  #del os.environ['ENVXMLPATH']
483  EnvConfig.path[:] = ['.']
484 
485  control = Control.Environment(searchPath=[])
486  control.loadXML(tmp('third.xml'))
487  self.assertEqual(str(control['main']), 'third')
488  self.assertEqual(str(control['test_path']), 'data1')
489  self.assertEqual(str(control['derived']), 'second_third')
490 
491  control = Control.Environment(searchPath=[tmp('subdir')])
492  control.loadXML(tmp('fourth.xml'))
493  self.assertEqual(str(control['main']), 'fourth')
494  self.assertEqual(str(control['included']), 'from subdir')
495 
496  control = Control.Environment(searchPath=[])
497  control.loadXML(tmp('fourth.xml'))
498  self.assertEqual(str(control['main']), 'fourth')
499  self.assertEqual(str(control['included']), 'from subdir2')
500 
501  control = Control.Environment(searchPath=[])
502  #self.assertRaises(OSError, control.loadXML, tmp('first.xml'))
503  control.loadXML(tmp('recursion.xml'))
504 
505  # restore search path
506  EnvConfig.path = saved_path
507 
def EnvConfig.TestEnvOps.Test.testSaveToFile (   self) 
Test addition of variable to system

Definition at line 192 of file TestEnvOps.py.

192 
193  def testSaveToFile(self):
194  '''Test addition of variable to system'''
195  control = Control.Environment()
196 
197  control.append('sysVar', 'newValue:lala')
198  control.writeToFile('setupFile.txt')
199 
200  with open('setupFile.txt', "r") as f:
201  f.readline()
202  stri = f.readline()
203  f.close()
204 
205  self.assertEqual(stri, 'export sysVar=newValue:lala\n')
206 
207  os.remove('setupFile.txt')
def EnvConfig.TestEnvOps.Test.testSaveToXML (   self) 
XML file write and load test

Definition at line 168 of file TestEnvOps.py.

168 
169  def testSaveToXML(self):
170  """XML file write and load test"""
171  control = Control.Environment()
172 
173  control.unset('MY_PATH')
174  control.set('MY_PATH', 'set:toDelete')
175  control.append('MY_PATH', 'appended:toDelete')
176  control.prepend('MY_PATH', 'prepended:toDelete')
177  control.remove('MY_PATH', 'toDelete')
178  control.writeToXMLFile('testOutputFile.xml')
179 
180  control = Control.Environment()
181  self.assertFalse('MY_PATH' in control.vars())
182  control.loadXML('testOutputFile.xml')
183 
184  self.assertTrue('MY_PATH' in control.vars())
185  var = control.var('MY_PATH')
186  self.assertTrue(var[0] == 'prepended')
187  self.assertTrue(var[1] == 'set')
188  self.assertTrue(var[2] == 'appended')
189  self.assertFalse('toDelete' in var)
190 
191  os.remove('testOutputFile.xml')
def EnvConfig.TestEnvOps.Test.testSearch (   self) 
Testing searching in variables

Definition at line 208 of file TestEnvOps.py.

208 
209  def testSearch(self):
210  '''Testing searching in variables'''
211  control = Control.Environment()
212 
213  control.append('MY_PATH', 'newValue:mess:something new:aaaabbcc')
214 
215  def count(val, regExp = False):
216  return len(control.search('MY_PATH', val, regExp))
217 
218  self.assertEqual(count('new'), 0)
219  self.assertEqual(count('newValue'), 1)
220 
221  self.assertEqual(count('me', False), 0)
222  self.assertEqual(count('me', True), 2)
223 
224  self.assertEqual(count('cc', False), 0)
225  self.assertEqual(count('cc', True), 1)
226 
227  self.assertEqual(count('a{2}b{2}c{2}', True), 1)
228  self.assertEqual(count('a{2}b{2}', True), 1)
229  self.assertEqual(count('a{1}b{2}c{2}', True), 1)
230  self.assertEqual(count('a{1}b{1}c{2}', True), 0)
231  self.assertEqual(count('a{1,2}b{1,2}c{2}', True), 1)
232  self.assertEqual(count('a{2,3}', True), 1)
233  self.assertEqual(count('a{2,3}?', True), 1)
def EnvConfig.TestEnvOps.Test.testSystemEnvironment (   self)

Definition at line 304 of file TestEnvOps.py.

304 
305  def testSystemEnvironment(self):
306  control = Control.Environment()
307 
308  os.environ['MY_PATH'] = '$myVal'
309  os.environ['myScal'] = '$myVal'
310 
311  control.set('ABC','anyValue')
312  control.declare('MY_PATH', 'list', False)
313  control.append('MY_PATH','$ABC')
314  self.assertTrue(control['MY_PATH'].value(True) == '$myVal:anyValue')
315 
316  control.declare('myScal', 'scalar', False)
317  control.append('myScal', '$ABC')
318  self.assertTrue(control['myScal'].value(True) == '$myValanyValue')
319 
def EnvConfig.TestEnvOps.Test.testValues (   self) 
Test of value appending, prepending, setting, unsetting, removing

Definition at line 79 of file TestEnvOps.py.

79 
80  def testValues(self):
81  '''Test of value appending, prepending, setting, unsetting, removing'''
82  control = Control.Environment()
83 
84  self.assertFalse('MY_PATH' in control.vars())
85  control.append('MY_PATH', 'newValue')
86  self.assertTrue('MY_PATH' in control.vars())
87  var = control.var('MY_PATH')
88 
89  control.append('MY_PATH', 'newValue:secondVal:valval')
90  self.assertTrue(var[len(var)-1] == 'valval')
91 
92  self.assertTrue('newValue' in var)
93  control.remove('MY_PATH', 'newValue')
94  self.assertFalse('newValue' in var)
95 
96  control.prepend('MY_PATH', 'newValue')
97  self.assertTrue('newValue' == var[0])
98 
99  control.set('MY_PATH', 'hi:hello')
100  self.assertTrue(len(var) == 2)
101  self.assertTrue('hi' == var[0])
102 
103  control.unset('MY_PATH')
104  self.assertTrue('MY_PATH' not in control)
105 
def EnvConfig.TestEnvOps.Test.testVariableManipulations (   self)

Definition at line 554 of file TestEnvOps.py.

554 
555  def testVariableManipulations(self):
556  l = Variable.List('PATH')
557 
558  l.set("/usr/bin:/some//strange/../nice/./location")
559  assert l.value(asString=True) == "/usr/bin:/some/nice/location"
560 
561  l.append("/another/path")
562  assert l.value(asString=True) == "/usr/bin:/some/nice/location:/another/path"
563 
564  # duplicates removal
565  l.append("/usr/bin")
566  assert l.value(asString=True) == "/usr/bin:/some/nice/location:/another/path"
567  l.prepend("/another/path")
568  assert l.value(asString=True) == "/another/path:/usr/bin:/some/nice/location"
569 
570  s = Variable.Scalar('VAR')
571 
572  s.set("/usr/bin")
573  assert s.value(asString=True) == "/usr/bin"
574 
575  s.set("/some//strange/../nice/./location")
576  assert s.value(asString=True) == "/some/nice/location"
577 
578  # This is undefined
579  # l.set("http://cern.ch")
580 
581  s.set("http://cern.ch")
582  assert s.value(asString=True) == "http://cern.ch"
def EnvConfig.TestEnvOps.Test.testVariables (   self) 
Tests variables creation and redeclaration.

Definition at line 234 of file TestEnvOps.py.

234 
235  def testVariables(self):
236  '''Tests variables creation and redeclaration.'''
237  control = Control.Environment()
238 
239  control.append('MY_PATH', 'newValue')
240  self.assertFalse(control.var('MY_PATH').local)
241  self.assertTrue(isinstance(control.var('MY_PATH'),Variable.List))
242 
243  control.declare('loc', 'list', True)
244  self.assertTrue(control.var('loc').local)
245  self.assertTrue(isinstance(control.var('loc'),Variable.List))
246 
247  control.declare('myVar2', 'scalar', False)
248  self.assertFalse(control.var('myVar2').local)
249  self.assertTrue(isinstance(control.var('myVar2'),Variable.Scalar))
250 
251  control.declare('loc2', 'scalar', True)
252  self.assertTrue(control.var('loc2').local)
253  self.assertTrue(isinstance(control.var('loc2'),Variable.Scalar))
254 
255  control.declare('MY_PATH', 'list', False)
256  self.failUnlessRaises(Variable.EnvError, control.declare, 'MY_PATH', 'list', True)
257  self.failUnlessRaises(Variable.EnvError, control.declare, 'MY_PATH', 'scalar', True)
258  self.failUnlessRaises(Variable.EnvError, control.declare, 'MY_PATH', 'scalar', True)
259 
260  control.declare('loc', 'list', True)
261  self.failUnlessRaises(Variable.EnvError, control.declare,'loc', 'list', False)
262  self.failUnlessRaises(Variable.EnvError, control.declare,'loc', 'scalar', True)
263  self.failUnlessRaises(Variable.EnvError, control.declare,'loc', 'scalar', True)
264 
265  control.declare('myVar2', 'scalar', False)
266  self.failUnlessRaises(Variable.EnvError, control.declare,'myVar2', 'list', False)
267  self.failUnlessRaises(Variable.EnvError, control.declare,'myVar2', 'list', True)
268  self.failUnlessRaises(Variable.EnvError, control.declare,'myVar2', 'scalar', True)
269 
270  control.declare('loc2', 'scalar', True)
271  self.failUnlessRaises(Variable.EnvError, control.declare,'loc2', 'list', False)
272  self.failUnlessRaises(Variable.EnvError, control.declare,'loc2', 'list', True)
273  self.failUnlessRaises(Variable.EnvError, control.declare,'loc2', 'scalar', False)
274 
def EnvConfig.TestEnvOps.Test.testWrite (   self) 
XML file write and load test

Definition at line 120 of file TestEnvOps.py.

120 
121  def testWrite(self):
122  """XML file write and load test"""
123  control = Control.Environment(useAsWriter = True)
124  control.unset('MY_PATH')
125  control.set('MY_PATH', 'set:toDelete')
126  control.append('MY_PATH', 'appended:toDelete')
127  control.prepend('MY_PATH', 'prepended:toDelete')
128  control.remove('MY_PATH', 'toDelete')
129  control.finishXMLinput('testOutputFile.xml')
130 
131  control = Control.Environment()
132  self.assertFalse('MY_PATH' in control.vars())
133  control.loadXML('testOutputFile.xml')
134 
135  self.assertTrue('MY_PATH' in control.vars())
136  var = control.var('MY_PATH')
137  self.assertTrue(var[0] == 'prepended')
138  self.assertTrue(var[1] == 'set')
139  self.assertTrue(var[2] == 'appended')
140  self.assertFalse('toDelete' in var)
141 
142  os.remove('testOutputFile.xml')
143 
def EnvConfig.TestEnvOps.Test.testWriteWithList (   self) 
XML file write and load test

Definition at line 144 of file TestEnvOps.py.

144 
145  def testWriteWithList(self):
146  """XML file write and load test"""
147  control = Control.Environment(useAsWriter = True)
148  control.unset('MY_PATH')
149  control.set('MY_PATH', ['set','toDelete'])
150  control.append('MY_PATH', ['appended','toDelete'])
151  control.prepend('MY_PATH', ['prepended','toDelete'])
152  control.remove('MY_PATH', ['toDelete'])
153  control.finishXMLinput('testOutputFile.xml')
154 
155  control = Control.Environment()
156  self.assertFalse('MY_PATH' in control.vars())
157  control.loadXML('testOutputFile.xml')
158 
159  self.assertTrue('MY_PATH' in control.vars())
160  var = control.var('MY_PATH')
161  self.assertTrue(var[0] == 'prepended')
162  self.assertTrue(var[1] == 'set')
163  self.assertTrue(var[2] == 'appended')
164  self.assertFalse('toDelete' in var)
165 
166  os.remove('testOutputFile.xml')
167 
The documentation for this class was generated from the following file:
Generated at Wed Jun 4 2014 14:49:04 for Gaudi Framework, version v25r2 by Doxygen version 1.8.2 written by Dimitri van Heesch, © 1997-2004