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 199 of file CFElements.py.

Member Function Documentation

◆ setUp()

def python.CFElements.TestCF.setUp (   self)

Definition at line 200 of file CFElements.py.

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

◆ test_findAlgorithms()

def python.CFElements.TestCF.test_findAlgorithms (   self)

Definition at line 279 of file CFElements.py.

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

◆ test_findDeep()

def python.CFElements.TestCF.test_findDeep (   self)

Definition at line 225 of file CFElements.py.

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

◆ test_findMissing()

def python.CFElements.TestCF.test_findMissing (   self)

Definition at line 231 of file CFElements.py.

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

◆ test_findRespectingScope()

def python.CFElements.TestCF.test_findRespectingScope (   self)

Definition at line 244 of file CFElements.py.

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

◆ test_findTop()

def python.CFElements.TestCF.test_findTop (   self)

Definition at line 216 of file CFElements.py.

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

◆ test_iterSequences()

def python.CFElements.TestCF.test_iterSequences (   self)

Definition at line 257 of file CFElements.py.

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

Member Data Documentation

◆ top

python.CFElements.TestCF.top

Definition at line 214 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:92
python.CFElements.parOR
def parOR(name, subs=[], invert=False)
Definition: CFElements.py:16
python.CFElements.seqAND
def seqAND(name, subs=[], invert=False)
Definition: CFElements.py:27
PyAthena::Alg
Definition: PyAthenaAlg.h:33
python.CFElements.findSubSequence
def findSubSequence(start, nameToLookFor)
Definition: CFElements.py:78
python.CFElements.findAlgorithm
def findAlgorithm(startSequence, nameToLookFor, depth=1000000)
Definition: CFElements.py:123
python.CFElements.iterSequences
def iterSequences(start)
Definition: CFElements.py:184