ATLAS Offline Software
Public Member Functions | Public Attributes | List of all members
python.CFElements.TestCF Class Reference
Inheritance diagram for python.CFElements.TestCF:
Collaboration diagram for python.CFElements.TestCF:

Public Member Functions

def setUp (self)
 
def test_findTop (self)
 
def test_findDeep (self)
 
def test_findMissing (self)
 
def test_findRespectingScope (self)
 
def test_iterSequences (self)
 
def test_findAlgorithms (self)
 

Public Attributes

 top
 

Detailed Description

Definition at line 197 of file CFElements.py.

Member Function Documentation

◆ setUp()

def python.CFElements.TestCF.setUp (   self)

Definition at line 198 of file CFElements.py.

198  def setUp( self ):
199  import AthenaPython.PyAthena as PyAthena
200 
201  top = parOR("top")
202  top.Members += [parOR("nest1")]
203  nest2 = seqAND("nest2")
204  top.Members += [nest2]
205  top.Members += [PyAthena.Alg("SomeAlg0")]
206  nest2.Members += [parOR("deep_nest1")]
207  nest2.Members += [parOR("deep_nest2")]
208 
209  nest2.Members += [PyAthena.Alg("SomeAlg1")]
210  nest2.Members += [PyAthena.Alg("SomeAlg2")]
211  nest2.Members += [PyAthena.Alg("SomeAlg3")]
212  self.top = top
213 

◆ test_findAlgorithms()

def python.CFElements.TestCF.test_findAlgorithms (   self)

Definition at line 277 of file CFElements.py.

277  def test_findAlgorithms( self ):
278  a1 = findAlgorithm( self.top, "SomeAlg0" )
279  self.assertIsNotNone( a1, "Can't find algorithm present in sequence" )
280 
281  a1 = findAlgorithm( self.top, "SomeAlg1" )
282  self.assertIsNotNone( a1, "Can't find nested algorithm " )
283 
284  nest2 = findSubSequence( self.top, "nest2" )
285 
286  a1 = findAlgorithm( nest2, "SomeAlg0" )
287  self.assertIsNone( a1, "Finding algorithm that is in the upper sequence" )
288 
289  a1 = findAlgorithm( nest2, "NonexistentAlg" )
290  self.assertIsNone( a1, "Finding algorithm that is does not exist" )
291 
292  a1 = findAlgorithm( self.top, "SomeAlg0", 1)
293  self.assertIsNotNone( a1, "Could not find algorithm within the required nesting depth == 1" )
294 
295  a1 = findAlgorithm( self.top, "SomeAlg1", 1)
296  self.assertIsNone( a1, "Could find algorithm even if it is deep in sequences structure" )
297 
298  a1 = findAlgorithm( self.top, "SomeAlg1", 2)
299  self.assertIsNotNone( a1, "Could not find algorithm within the required nesting depth == 2" )
300 
301  a1 = findAlgorithm( self.top, "SomeAlg3", 2)
302  self.assertIsNotNone( a1 is None, "Could find algorithm even if it is deep in sequences structure" )
303 
304 

◆ test_findDeep()

def python.CFElements.TestCF.test_findDeep (   self)

Definition at line 223 of file CFElements.py.

223  def test_findDeep( self ):
224  # deeper search
225  d = findSubSequence( self.top, "deep_nest2")
226  self.assertIsNotNone( d, "Deep searching for sub seqeunce fails" )
227  self.assertEqual( d.getName(), "deep_nest2", "Wrong sub sequence in deep search" )
228 

◆ test_findMissing()

def python.CFElements.TestCF.test_findMissing (   self)

Definition at line 229 of file CFElements.py.

229  def test_findMissing( self ):
230  # algorithm is not a sequence
231  d = findSubSequence( self.top, "SomeAlg1")
232  self.assertIsNone( d, "Algorithm confused as a sequence" )
233 
234  # no on demand creation
235  inexistent = findSubSequence( self.top, "not_there" )
236  self.assertIsNone( inexistent, "ERROR, found sub sequence that does not relay exist" )
237 
238  # owner finding
239  inexistent = findOwningSequence(self.top, "not_there")
240  self.assertIsNone( inexistent, "ERROR, found owner of inexistent sequence " )
241 

◆ test_findRespectingScope()

def python.CFElements.TestCF.test_findRespectingScope (   self)

Definition at line 242 of file CFElements.py.

242  def test_findRespectingScope( self ):
243  owner = findOwningSequence( self.top, "deep_nest1")
244  self.assertEqual( owner.getName(), "nest2", "Wrong owner %s" % owner.getName() )
245 
246  owner = findOwningSequence( self.top, "deep_nest2")
247  self.assertEqual( owner.getName(), "nest2", "Wrong owner %s" % owner.getName() )
248 
249  owner = findOwningSequence( self.top, "SomeAlg1")
250  self.assertEqual( owner.getName(), "nest2", "Wrong owner %s" % owner.getName() )
251 
252  owner = findOwningSequence( self.top, "SomeAlg0")
253  self.assertEqual( owner.getName() , "top", "Wrong owner %s" % owner.getName() )
254 

◆ test_findTop()

def python.CFElements.TestCF.test_findTop (   self)

Definition at line 214 of file CFElements.py.

214  def test_findTop( self ):
215  f = findSubSequence( self.top, "top")
216  self.assertIsNotNone( f, "Can not find sequence at start" )
217  self.assertEqual( f.getName(), "top", "Wrong sequence" )
218  # a one level deep search
219  nest2 = findSubSequence( self.top, "nest2" )
220  self.assertIsNotNone( nest2, "Can not find sub sequence" )
221  self.assertEqual( nest2.getName(), "nest2", "Sub sequence incorrect" )
222 

◆ test_iterSequences()

def python.CFElements.TestCF.test_iterSequences (   self)

Definition at line 255 of file CFElements.py.

255  def test_iterSequences( self ):
256  # Traverse from top
257  result = [seq.getName() for seq in iterSequences( self.top )]
258  self.assertEqual( result, ['top', 'nest1', 'nest2', 'deep_nest1', 'deep_nest2',
259  'SomeAlg1', 'SomeAlg2', 'SomeAlg3', 'SomeAlg0'] )
260 
261  # Traverse from nested sequence
262  nest2 = findSubSequence( self.top, "nest2" )
263  result = [seq.getName() for seq in iterSequences( nest2 )]
264  self.assertEqual( result, ['nest2', 'deep_nest1', 'deep_nest2',
265  'SomeAlg1', 'SomeAlg2', 'SomeAlg3'] )
266 
267  # Traverse empty sequence
268  deep_nest2 = findSubSequence( self.top, "deep_nest2" )
269  result = [seq.getName() for seq in iterSequences( deep_nest2 )]
270  self.assertEqual( result, ['deep_nest2'] )
271 
272  # Traverse from algorithm
273  alg1 = findAlgorithm( self.top, "SomeAlg1" )
274  result = [seq.getName() for seq in iterSequences( alg1 )]
275  self.assertEqual( result, ['SomeAlg1'] )
276 

Member Data Documentation

◆ top

python.CFElements.TestCF.top

Definition at line 212 of file CFElements.py.


The documentation for this class was generated from the following file:
python.CFElements.findOwningSequence
def findOwningSequence(start, nameToLookFor)
Definition: CFElements.py:90
python.CFElements.seqAND
def seqAND(name, subs=[])
Definition: CFElements.py:25
python.CFElements.parOR
def parOR(name, subs=[])
Definition: CFElements.py:15
PyAthena::Alg
Definition: PyAthenaAlg.h:33
python.CFElements.findSubSequence
def findSubSequence(start, nameToLookFor)
Definition: CFElements.py:76
python.CFElements.findAlgorithm
def findAlgorithm(startSequence, nameToLookFor, depth=1000000)
Definition: CFElements.py:121
python.CFElements.iterSequences
def iterSequences(start)
Definition: CFElements.py:182