Classes
class	BaseTest

class	BasicOutputValidator

class	BlockSkipper

class	FilePreprocessor

class	FilePreprocessorSequence

class	LineSkipper

class	LineSorter

class	ReferenceFileValidator

class	RegexpReplacer

class	Result

class	SortGroupOfLines

Functions
def	_new_backslashreplace_errors (exc)

def	sanitize_for_xml (data)

def	dumpProcs (name)

def	kill_tree (ppid, sig)

def	ROOT6WorkAroundEnabled (id=None)

def	RationalizePath (p)

def	which (executable)

def	findTTreeSummaries (stdout)

def	cmpTreesDicts (reference, to_check, ignore=None)

def	getCmpFailingValues (reference, to_check, fail_path)

def	_parseTTreeSummary (lines, pos)

def	parseHistosSummary (lines, pos)

def	findHistosSummaries (stdout)

def	PlatformIsNotSupported (self, context, result)

def	GetPlatform (self)

def	isWinPlatform (self)

Variables
	maskPointers = RegexpReplacer("0x[0-9a-fA-F]{4,16}", "0x########")

	normalizeDate

	normalizeEOL = FilePreprocessor()

	__processLine__

	skipEmptyLines = FilePreprocessor()

	normalizeExamples = maskPointers + normalizeDate

	lineSkipper

	regexps

	h_count_re

Function Documentation

◆ _new_backslashreplace_errors()

def GaudiTesting.BaseTest._new_backslashreplace_errors ( exc )

private

Definition at line 23 of file BaseTest.py.

     def _new_backslashreplace_errors(exc):
         if isinstance(exc, UnicodeDecodeError):
             code = hex(ord(exc.object[exc.start]))
             return (u'\\' + code[1:], exc.start + 1)
         else:
             return backslashreplace_errors(exc)
 

◆ _parseTTreeSummary()

def GaudiTesting.BaseTest._parseTTreeSummary	(	lines,
		pos
	)

private

Parse the TTree summary table in lines, starting from pos.
Returns a tuple with the dictionary with the digested informations and the
position of the first line after the summary.

Definition at line 1160 of file BaseTest.py.

 def _parseTTreeSummary(lines, pos):
     """
     Parse the TTree summary table in lines, starting from pos.
     Returns a tuple with the dictionary with the digested informations and the
     position of the first line after the summary.
     """
     result = {}
     i = pos + 1  # first line is a sequence of '*'
     count = len(lines)
 
     def splitcols(l):
         return [f.strip() for f in l.strip("*\n").split(':', 2)]
 
     def parseblock(ll):
         r = {}
         cols = splitcols(ll[0])
         r["Name"], r["Title"] = cols[1:]
 
         cols = splitcols(ll[1])
         r["Entries"] = int(cols[1])
 
         sizes = cols[2].split()
         r["Total size"] = int(sizes[2])
         if sizes[-1] == "memory":
             r["File size"] = 0
         else:
             r["File size"] = int(sizes[-1])
 
         cols = splitcols(ll[2])
         sizes = cols[2].split()
         if cols[0] == "Baskets":
             r["Baskets"] = int(cols[1])
             r["Basket size"] = int(sizes[2])
         r["Compression"] = float(sizes[-1])
         return r
 
     if i < (count - 3) and lines[i].startswith("*Tree"):
         result = parseblock(lines[i:i + 3])
         result["Branches"] = {}
         i += 4
         while i < (count - 3) and lines[i].startswith("*Br"):
             if i < (count - 2) and lines[i].startswith("*Branch "):
                 # skip branch header
                 i += 3
                 continue
             branch = parseblock(lines[i:i + 3])
             result["Branches"][branch["Name"]] = branch
             i += 4
 
     return (result, i)
 
 

◆ cmpTreesDicts()

def GaudiTesting.BaseTest.cmpTreesDicts	(	reference,
		to_check,
		ignore = `None`
	)

    Check that all the keys in reference are in to_check too, with the same value.
    If the value is a dict, the function is called recursively. to_check can
    contain more keys than reference, that will not be tested.
    The function returns at the first difference found.

Definition at line 1110 of file BaseTest.py.

 def cmpTreesDicts(reference, to_check, ignore=None):
     """
         Check that all the keys in reference are in to_check too, with the same value.
         If the value is a dict, the function is called recursively. to_check can
         contain more keys than reference, that will not be tested.
         The function returns at the first difference found.
         """
     fail_keys = []
     # filter the keys in the reference dictionary
     if ignore:
         ignore_re = re.compile(ignore)
         keys = [key for key in reference if not ignore_re.match(key)]
     else:
         keys = reference.keys()
     # loop over the keys (not ignored) in the reference dictionary
     for k in keys:
         if k in to_check:  # the key must be in the dictionary to_check
             if (type(reference[k]) is dict) and (type(to_check[k]) is dict):
                 # if both reference and to_check values are dictionaries,
                 # recurse
                 failed = fail_keys = cmpTreesDicts(reference[k], to_check[k],
                                                    ignore)
             else:
                 # compare the two values
                 failed = to_check[k] != reference[k]
         else:  # handle missing keys in the dictionary to check (i.e. failure)
             to_check[k] = None
             failed = True
         if failed:
             fail_keys.insert(0, k)
             break  # exit from the loop at the first failure
     return fail_keys  # return the list of keys bringing to the different values
 
 

◆ dumpProcs()

def GaudiTesting.BaseTest.dumpProcs ( name )

helper to debug GAUDI-1084, dump the list of processes

Definition at line 54 of file BaseTest.py.

 def dumpProcs(name):
     '''helper to debug GAUDI-1084, dump the list of processes'''
     from getpass import getuser
     if 'WORKSPACE' in os.environ:
         p = Popen(['ps', '-fH', '-U', getuser()], stdout=PIPE)
         with open(os.path.join(os.environ['WORKSPACE'], name), 'wb') as f:
             f.write(p.communicate()[0])
 
 

◆ findHistosSummaries()

def GaudiTesting.BaseTest.findHistosSummaries ( stdout )

    Scan stdout to find ROOT TTree summaries and digest them.

Definition at line 1282 of file BaseTest.py.

 def findHistosSummaries(stdout):
     """
         Scan stdout to find ROOT TTree summaries and digest them.
         """
     outlines = stdout.splitlines()
     nlines = len(outlines) - 1
     summaries = {}
     global h_count_re
 
     pos = 0
     while pos < nlines:
         summ = {}
         # find first line of block:
         match = h_count_re.search(outlines[pos])
         while pos < nlines and not match:
             pos += 1
             match = h_count_re.search(outlines[pos])
         if match:
             summ, pos = parseHistosSummary(outlines, pos)
         summaries.update(summ)
     return summaries
 
 

◆ findTTreeSummaries()

def GaudiTesting.BaseTest.findTTreeSummaries ( stdout )

    Scan stdout to find ROOT TTree summaries and digest them.

Definition at line 1088 of file BaseTest.py.

 def findTTreeSummaries(stdout):
     """
         Scan stdout to find ROOT TTree summaries and digest them.
         """
     stars = re.compile(r"^\*+$")
     outlines = stdout.splitlines()
     nlines = len(outlines)
     trees = {}
 
     i = 0
     while i < nlines:  # loop over the output
         # look for
         while i < nlines and not stars.match(outlines[i]):
             i += 1
         if i < nlines:
             tree, i = _parseTTreeSummary(outlines, i)
             if tree:
                 trees[tree["Name"]] = tree
 
     return trees
 
 

◆ getCmpFailingValues()

def GaudiTesting.BaseTest.getCmpFailingValues	(	reference,
		to_check,
		fail_path
	)

Definition at line 1144 of file BaseTest.py.

 def getCmpFailingValues(reference, to_check, fail_path):
     c = to_check
     r = reference
     for k in fail_path:
         c = c.get(k, None)
         r = r.get(k, None)
         if c is None or r is None:
             break  # one of the dictionaries is not deep enough
     return (fail_path, r, c)
 
 
 # signature of the print-out of the histograms

◆ GetPlatform()

def GaudiTesting.BaseTest.GetPlatform ( self )

    Return the platform Id defined in CMTCONFIG or SCRAM_ARCH.

Definition at line 1319 of file BaseTest.py.

 def GetPlatform(self):
     """
         Return the platform Id defined in CMTCONFIG or SCRAM_ARCH.
         """
     arch = "None"
     # check architecture name
     if "BINARY_TAG" in os.environ:
         arch = os.environ["BINARY_TAG"]
     elif "CMTCONFIG" in os.environ:
         arch = os.environ["CMTCONFIG"]
     elif "SCRAM_ARCH" in os.environ:
         arch = os.environ["SCRAM_ARCH"]
     return arch
 
 

◆ isWinPlatform()

def GaudiTesting.BaseTest.isWinPlatform ( self )

    Return True if the current platform is Windows.

    This function was needed because of the change in the CMTCONFIG format,
    from win32_vc71_dbg to i686-winxp-vc9-dbg.

Definition at line 1334 of file BaseTest.py.

 def isWinPlatform(self):
     """
         Return True if the current platform is Windows.
 
         This function was needed because of the change in the CMTCONFIG format,
         from win32_vc71_dbg to i686-winxp-vc9-dbg.
         """
     platform = GetPlatform(self)
     return "winxp" in platform or platform.startswith("win")

◆ kill_tree()

def GaudiTesting.BaseTest.kill_tree	(	ppid,
		sig
	)

Send a signal to a process and all its child processes (starting from the
leaves).

Definition at line 63 of file BaseTest.py.

 def kill_tree(ppid, sig):
     '''
     Send a signal to a process and all its child processes (starting from the
     leaves).
     '''
     log = logging.getLogger('kill_tree')
     ps_cmd = ['ps', '--no-headers', '-o', 'pid', '--ppid', str(ppid)]
     get_children = Popen(ps_cmd, stdout=PIPE, stderr=PIPE)
     children = map(int, get_children.communicate()[0].split())
     for child in children:
         kill_tree(child, sig)
     try:
         log.debug('killing process %d', ppid)
         os.kill(ppid, sig)
     except OSError as err:
         if err.errno != 3:  # No such process
             raise
         log.debug('no such process %d', ppid)
 
 
 # -------------------------------------------------------------------------#
 
 

◆ parseHistosSummary()

def GaudiTesting.BaseTest.parseHistosSummary	(	lines,
		pos
	)

    Extract the histograms infos from the lines starting at pos.
    Returns the position of the first line after the summary block.

Definition at line 1212 of file BaseTest.py.

 def parseHistosSummary(lines, pos):
     """
         Extract the histograms infos from the lines starting at pos.
         Returns the position of the first line after the summary block.
         """
     global h_count_re
     h_table_head = re.compile(
         r'SUCCESS\s+(1D|2D|3D|1D profile|2D profile) histograms in directory\s+"(\w*)"'
     )
     h_short_summ = re.compile(r"ID=([^\"]+)\s+\"([^\"]+)\"\s+(.*)")
 
     nlines = len(lines)
 
     # decode header
     m = h_count_re.search(lines[pos])
     name = m.group(1).strip()
     total = int(m.group(2))
     header = {}
     for k, v in [x.split("=") for x in m.group(3).split()]:
         header[k] = int(v)
     pos += 1
     header["Total"] = total
 
     summ = {}
     while pos < nlines:
         m = h_table_head.search(lines[pos])
         if m:
             t, d = m.groups(1)  # type and directory
             t = t.replace(" profile", "Prof")
             pos += 1
             if pos < nlines:
                 l = lines[pos]
             else:
                 l = ""
             cont = {}
             if l.startswith(" | ID"):
                 # table format
                 titles = [x.strip() for x in l.split("|")][1:]
                 pos += 1
                 while pos < nlines and lines[pos].startswith(" |"):
                     l = lines[pos]
                     values = [x.strip() for x in l.split("|")][1:]
                     hcont = {}
                     for i in range(len(titles)):
                         hcont[titles[i]] = values[i]
                     cont[hcont["ID"]] = hcont
                     pos += 1
             elif l.startswith(" ID="):
                 while pos < nlines and lines[pos].startswith(" ID="):
                     values = [
                         x.strip()
                         for x in h_short_summ.search(lines[pos]).groups()
                     ]
                     cont[values[0]] = values
                     pos += 1
             else:  # not interpreted
                 raise RuntimeError(
                     "Cannot understand line %d: '%s'" % (pos, l))
             if not d in summ:
                 summ[d] = {}
             summ[d][t] = cont
             summ[d]["header"] = header
         else:
             break
     if not summ:
         # If the full table is not present, we use only the header
         summ[name] = {"header": header}
     return summ, pos
 
 

◆ PlatformIsNotSupported()

def GaudiTesting.BaseTest.PlatformIsNotSupported	(	self,
		context,
		result
	)

Definition at line 1305 of file BaseTest.py.

 def PlatformIsNotSupported(self, context, result):
     platform = GetPlatform(self)
     unsupported = [
         re.compile(x) for x in [str(y).strip() for y in unsupported_platforms]
         if x
     ]
     for p_re in unsupported:
         if p_re.search(platform):
             result.SetOutcome(result.UNTESTED)
             result[result.CAUSE] = 'Platform not supported.'
             return True
     return False
 
 

◆ RationalizePath()

def GaudiTesting.BaseTest.RationalizePath ( p )

Function used to normalize the used path

Definition at line 645 of file BaseTest.py.

 def RationalizePath(p):
     """
     Function used to normalize the used path
     """
     newPath = os.path.normpath(os.path.expandvars(p))
     if os.path.exists(newPath):
         p = os.path.realpath(newPath)
     return p
 
 

◆ ROOT6WorkAroundEnabled()

def GaudiTesting.BaseTest.ROOT6WorkAroundEnabled ( id = None )

Definition at line 637 of file BaseTest.py.

     def ROOT6WorkAroundEnabled(id=None):
         # dummy implementation
         return False
 
 # --------------------------------- TOOLS ---------------------------------#

◆ sanitize_for_xml()

def GaudiTesting.BaseTest.sanitize_for_xml ( data )

Take a string with invalid ASCII/UTF characters and quote them so that the
string can be used in an XML text.

>>> sanitize_for_xml('this is \x1b')
'this is [NON-XML-CHAR-0x1B]'

Definition at line 36 of file BaseTest.py.

 def sanitize_for_xml(data):
     '''
     Take a string with invalid ASCII/UTF characters and quote them so that the
     string can be used in an XML text.
 
     >>> sanitize_for_xml('this is \x1b')
     'this is [NON-XML-CHAR-0x1B]'
     '''
     bad_chars = re.compile(
         u'[\x00-\x08\x0b\x0c\x0e-\x1F\uD800-\uDFFF\uFFFE\uFFFF]')
 
     def quote(match):
         'helper function'
         return ''.join('[NON-XML-CHAR-0x%2X]' % ord(c) for c in match.group())
 
     return bad_chars.sub(quote, data)
 
 

◆ which()

def GaudiTesting.BaseTest.which ( executable )

Locates an executable in the executables path ($PATH) and returns the full
path to it.  An application is looked for with or without the '.exe' suffix.
If the executable cannot be found, None is returned

Definition at line 655 of file BaseTest.py.

 def which(executable):
     """
     Locates an executable in the executables path ($PATH) and returns the full
     path to it.  An application is looked for with or without the '.exe' suffix.
     If the executable cannot be found, None is returned
     """
     if os.path.isabs(executable):
         if not os.path.exists(executable):
             if executable.endswith('.exe'):
                 if os.path.exists(executable[:-4]):
                     return executable[:-4]
             else:
                 head, executable = os.path.split(executable)
         else:
             return executable
     for d in os.environ.get("PATH").split(os.pathsep):
         fullpath = os.path.join(d, executable)
         if os.path.exists(fullpath):
             return fullpath
     if executable.endswith('.exe'):
         return which(executable[:-4])
     return None
 
 
 # -------------------------------------------------------------------------#
 # ----------------------------- Result Classe -----------------------------#
 # -------------------------------------------------------------------------#

Variable Documentation

◆ processLine

GaudiTesting.BaseTest.__processLine__

private

Definition at line 878 of file BaseTest.py.

◆ h_count_re

GaudiTesting.BaseTest.h_count_re

Initial value:

1 = re.compile(

2 r"^(.*)SUCCESS\s+Booked (\d+) Histogram\(s\) :\s+([\s\w=-]*)")

Definition at line 1156 of file BaseTest.py.

◆ lineSkipper

GaudiTesting.BaseTest.lineSkipper

Definition at line 957 of file BaseTest.py.

◆ maskPointers

GaudiTesting.BaseTest.maskPointers = RegexpReplacer("0x[0-9a-fA-F]{4,16}", "0x########")

Definition at line 873 of file BaseTest.py.

◆ normalizeDate

GaudiTesting.BaseTest.normalizeDate

Initial value:

 =  RegexpReplacer(
     "[0-2]?[0-9]:[0-5][0-9]:[0-5][0-9] [0-9]{4}[-/][01][0-9][-/][0-3][0-9][ A-Z]*",
     "00:00:00 1970-01-01")

Definition at line 874 of file BaseTest.py.

◆ normalizeEOL

GaudiTesting.BaseTest.normalizeEOL = FilePreprocessor()

Definition at line 877 of file BaseTest.py.

◆ normalizeExamples

tuple GaudiTesting.BaseTest.normalizeExamples = maskPointers + normalizeDate

Definition at line 928 of file BaseTest.py.

◆ regexps

GaudiTesting.BaseTest.regexps

Definition at line 1040 of file BaseTest.py.

◆ skipEmptyLines

GaudiTesting.BaseTest.skipEmptyLines = FilePreprocessor()

Definition at line 880 of file BaseTest.py.

Classes

Functions

Variables

Function Documentation

◆ _new_backslashreplace_errors()

◆ _parseTTreeSummary()

◆ cmpTreesDicts()

◆ dumpProcs()

◆ findHistosSummaries()

◆ findTTreeSummaries()

◆ getCmpFailingValues()

◆ GetPlatform()

◆ isWinPlatform()

◆ kill_tree()

◆ parseHistosSummary()

◆ PlatformIsNotSupported()

◆ RationalizePath()

◆ ROOT6WorkAroundEnabled()

◆ sanitize_for_xml()

◆ which()

Variable Documentation

◆ __processLine__

◆ h_count_re

◆ lineSkipper

◆ maskPointers

◆ normalizeDate

◆ normalizeEOL

◆ normalizeExamples

◆ regexps

◆ skipEmptyLines

◆ processLine