GaudiTest::GaudiExeTest Class Reference

Inheritance diagram for GaudiTest::GaudiExeTest:

Collaboration diagram for GaudiTest::GaudiExeTest:

List of all members.

Public Member Functions
def	PlatformIsNotSupported
def	GetPlatform
def	isWinPlatform
def	CheckTTreesSummaries
def	CheckHistosSummaries
def	ValidateWithReference
def	ValidateOutput
def	DumpEnvironment
def	Run
def	RunProgram
Public Attributes
	callable
	extra_args
	args_order
	program
	reference
	error_reference
	use_temp_dir
	timeout
Static Public Attributes
list	arguments
Private Member Functions
def	_expandReferenceFileName
def	_CreateEclipseLaunch

---

Detailed Description

Standard Gaudi test.

Definition at line 979 of file GaudiTest.py.

---

Member Function Documentation

def GaudiTest::GaudiExeTest::_CreateEclipseLaunch	(		self,
			prog,
			args,
			destdir = None
	)		[private]

Definition at line 1566 of file GaudiTest.py.

01567                                                               :
01568         # Find the project name used in ecplise.
01569         # The name is in a file called ".project" in one of the parent directories
01570         projbasedir = os.path.normpath(destdir)
01571         while not os.path.exists(os.path.join(projbasedir, ".project")):
01572             oldprojdir = projbasedir
01573             projbasedir = os.path.normpath(os.path.join(projbasedir, os.pardir))
01574             # FIXME: the root level is invariant when trying to go up one level,
01575             #        but it must be cheched on windows
01576             if oldprojdir == projbasedir:
01577                 # If we cannot find a .project, so no point in creating a .launch file
01578                 return
01579         # Use ElementTree to parse the XML file
01580         from xml.etree import ElementTree as ET
01581         t = ET.parse(os.path.join(projbasedir, ".project"))
01582         projectName = t.find("name").text
01583 
01584         # prepare the name/path of the generated file
01585         destfile = "%s.launch" % self._Runnable__id
01586         if destdir:
01587             destfile = os.path.join(destdir, destfile)
01588 
01589         if self.options.strip():
01590             # this means we have some custom options in the qmt file, so we have
01591             # to copy them from the temporary file at the end of the arguments
01592             # in another file
01593             tempfile = args.pop()
01594             optsfile = destfile + os.path.splitext(tempfile)[1]
01595             shutil.copyfile(tempfile, optsfile)
01596             args.append(optsfile)
01597 
01598         # prepare the data to insert in the XML file
01599         from xml.sax.saxutils import quoteattr # useful to quote XML special chars
01600         data = {}
01601         # Note: the "quoteattr(k)" is not needed because special chars cannot be part of a variable name,
01602         # but it doesn't harm.
01603         data["environment"] = "\n".join(['<mapEntry key=%s value=%s/>' % (quoteattr(k), quoteattr(v))
01604                                          for k, v in os.environ.iteritems()])
01605 
01606         data["exec"] = which(prog) or prog
01607         if os.path.basename(data["exec"]).lower().startswith("python"):
01608             data["stopAtMain"] = "false" # do not stop at main when debugging Python scripts
01609         else:
01610             data["stopAtMain"] = "true"
01611 
01612         data["args"] = "&#10;".join(map(rationalizepath, args))
01613         if self.isWinPlatform():
01614             data["args"] = "&#10;".join(["/debugexe"] + map(rationalizepath, [data["exec"]] + args))
01615             data["exec"] = which("vcexpress.exe")
01616 
01617         if not self.use_temp_dir:
01618             data["workdir"] = os.getcwd()
01619         else:
01620             # If the test is using a tmporary directory, it is better to run it
01621             # in the same directory as the .launch file when debugged in eclipse
01622             data["workdir"] = destdir
01623 
01624         data["project"] = projectName.strip()
01625 
01626         # Template for the XML file, based on eclipse 3.4
01627         xml = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
01628 <launchConfiguration type="org.eclipse.cdt.launch.applicationLaunchType">
01629 <booleanAttribute key="org.eclipse.cdt.debug.mi.core.AUTO_SOLIB" value="true"/>
01630 <listAttribute key="org.eclipse.cdt.debug.mi.core.AUTO_SOLIB_LIST"/>
01631 <stringAttribute key="org.eclipse.cdt.debug.mi.core.DEBUG_NAME" value="gdb"/>
01632 <stringAttribute key="org.eclipse.cdt.debug.mi.core.GDB_INIT" value=".gdbinit"/>
01633 <listAttribute key="org.eclipse.cdt.debug.mi.core.SOLIB_PATH"/>
01634 <booleanAttribute key="org.eclipse.cdt.debug.mi.core.STOP_ON_SOLIB_EVENTS" value="false"/>
01635 <booleanAttribute key="org.eclipse.cdt.debug.mi.core.breakpointsFullPath" value="false"/>
01636 <stringAttribute key="org.eclipse.cdt.debug.mi.core.commandFactory" value="org.eclipse.cdt.debug.mi.core.standardCommandFactory"/>
01637 <stringAttribute key="org.eclipse.cdt.debug.mi.core.protocol" value="mi"/>
01638 <booleanAttribute key="org.eclipse.cdt.debug.mi.core.verboseMode" value="false"/>
01639 <intAttribute key="org.eclipse.cdt.launch.ATTR_BUILD_BEFORE_LAUNCH_ATTR" value="0"/>
01640 <stringAttribute key="org.eclipse.cdt.launch.COREFILE_PATH" value=""/>
01641 <stringAttribute key="org.eclipse.cdt.launch.DEBUGGER_ID" value="org.eclipse.cdt.debug.mi.core.CDebuggerNew"/>
01642 <stringAttribute key="org.eclipse.cdt.launch.DEBUGGER_REGISTER_GROUPS" value=""/>
01643 <stringAttribute key="org.eclipse.cdt.launch.DEBUGGER_START_MODE" value="run"/>
01644 <booleanAttribute key="org.eclipse.cdt.launch.DEBUGGER_STOP_AT_MAIN" value="%(stopAtMain)s"/>
01645 <stringAttribute key="org.eclipse.cdt.launch.DEBUGGER_STOP_AT_MAIN_SYMBOL" value="main"/>
01646 <booleanAttribute key="org.eclipse.cdt.launch.ENABLE_REGISTER_BOOKKEEPING" value="false"/>
01647 <booleanAttribute key="org.eclipse.cdt.launch.ENABLE_VARIABLE_BOOKKEEPING" value="false"/>
01648 <stringAttribute key="org.eclipse.cdt.launch.FORMAT" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&lt;contentList/&gt;"/>
01649 <stringAttribute key="org.eclipse.cdt.launch.GLOBAL_VARIABLES" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;globalVariableList/&gt;&#10;"/>
01650 <stringAttribute key="org.eclipse.cdt.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;memoryBlockExpressionList/&gt;&#10;"/>
01651 <stringAttribute key="org.eclipse.cdt.launch.PROGRAM_ARGUMENTS" value="%(args)s"/>
01652 <stringAttribute key="org.eclipse.cdt.launch.PROGRAM_NAME" value="%(exec)s"/>
01653 <stringAttribute key="org.eclipse.cdt.launch.PROJECT_ATTR" value="%(project)s"/>
01654 <stringAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_ID_ATTR" value=""/>
01655 <stringAttribute key="org.eclipse.cdt.launch.WORKING_DIRECTORY" value="%(workdir)s"/>
01656 <booleanAttribute key="org.eclipse.cdt.launch.ui.ApplicationCDebuggerTab.DEFAULTS_SET" value="true"/>
01657 <booleanAttribute key="org.eclipse.cdt.launch.use_terminal" value="true"/>
01658 <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
01659 <listEntry value="/%(project)s"/>
01660 </listAttribute>
01661 <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
01662 <listEntry value="4"/>
01663 </listAttribute>
01664 <booleanAttribute key="org.eclipse.debug.core.appendEnvironmentVariables" value="false"/>
01665 <mapAttribute key="org.eclipse.debug.core.environmentVariables">
01666 %(environment)s
01667 </mapAttribute>
01668 <mapAttribute key="org.eclipse.debug.core.preferred_launchers">
01669 <mapEntry key="[debug]" value="org.eclipse.cdt.cdi.launch.localCLaunch"/>
01670 </mapAttribute>
01671 <listAttribute key="org.eclipse.debug.ui.favoriteGroups">
01672 <listEntry value="org.eclipse.debug.ui.launchGroup.debug"/>
01673 </listAttribute>
01674 </launchConfiguration>
01675 """ % data
01676 
01677         # Write the output file
01678         open(destfile, "w").write(xml)
01679         #open(destfile + "_copy.xml", "w").write(xml)
01680 
01681 
try:

def GaudiTest::GaudiExeTest::_expandReferenceFileName	(		self,
			reffile
	)		[private]

Definition at line 1132 of file GaudiTest.py.

                                               :
        # if no file is passed, do nothing
        if not reffile:
            return ""

        # function to split an extension in constituents parts
        platformSplit = lambda p: set(p.split('-' in p and '-' or '_'))

        reference = os.path.normpath(os.path.expandvars(reffile))
        # old-style platform-specific reference name
        spec_ref = reference[:-3] + self.GetPlatform()[0:3] + reference[-3:]
        if os.path.isfile(spec_ref):
            reference = spec_ref
        else: # look for new-style platform specific reference files:
            # get all the files whose name start with the reference filename
            dirname, basename = os.path.split(reference)
            if not dirname: dirname = '.'
            head = basename + "."
            head_len = len(head)
            platform = platformSplit(self.GetPlatform())
            candidates = []
            for f in os.listdir(dirname):
                if f.startswith(head):
                    req_plat = platformSplit(f[head_len:])
                    if platform.issuperset(req_plat):
                        candidates.append( (len(req_plat), f) )
            if candidates: # take the one with highest matching
                # FIXME: it is not possible to say if x86_64-slc5-gcc43-dbg
                #        has to use ref.x86_64-gcc43 or ref.slc5-dbg
                candidates.sort()
                reference = os.path.join(dirname, candidates[-1][1])
        return reference

def GaudiTest::GaudiExeTest::CheckHistosSummaries	(		self,
			stdout,
			result,
			causes,
			dict = None,
			ignore = None
	)

Compare the TTree summaries in stdout with the ones in trees_dict or in
the reference file. By default ignore the size, compression and basket
fields.
The presence of TTree summaries when none is expected is not a failure.

Definition at line 1199 of file GaudiTest.py.

                                           :
        """
        Compare the TTree summaries in stdout with the ones in trees_dict or in
        the reference file. By default ignore the size, compression and basket
        fields.
        The presence of TTree summaries when none is expected is not a failure.
        """
        if dict is None:
            reference = self._expandReferenceFileName(self.reference)
            # call the validator if the file exists
            if reference and os.path.isfile(reference):
                dict = findHistosSummaries(open(reference).read())
            else:
                dict = {}

        from pprint import PrettyPrinter
        pp = PrettyPrinter()
        if dict:
            result["GaudiTest.Histos.expected"] = result.Quote(pp.pformat(dict))
            if ignore:
                result["GaudiTest.Histos.ignore"] = result.Quote(ignore)

        histos = findHistosSummaries(stdout)
        failed = cmpTreesDicts(dict, histos, ignore)
        if failed:
            causes.append("histos summaries")
            msg = "%s: %s != %s" % getCmpFailingValues(dict, histos, failed)
            result["GaudiTest.Histos.failure_on"] = result.Quote(msg)
            result["GaudiTest.Histos.found"] = result.Quote(pp.pformat(histos))

        return causes

def GaudiTest::GaudiExeTest::CheckTTreesSummaries	(		self,
			stdout,
			result,
			causes,
			trees_dict = None,
			ignore = r"Basket|.*size|Compression"
	)

Compare the TTree summaries in stdout with the ones in trees_dict or in
the reference file. By default ignore the size, compression and basket
fields.
The presence of TTree summaries when none is expected is not a failure.

Definition at line 1165 of file GaudiTest.py.

                                                                   :
        """
        Compare the TTree summaries in stdout with the ones in trees_dict or in
        the reference file. By default ignore the size, compression and basket
        fields.
        The presence of TTree summaries when none is expected is not a failure.
        """
        if trees_dict is None:
            reference = self._expandReferenceFileName(self.reference)
            # call the validator if the file exists
            if reference and os.path.isfile(reference):
                trees_dict = findTTreeSummaries(open(reference).read())
            else:
                trees_dict = {}

        from pprint import PrettyPrinter
        pp = PrettyPrinter()
        if trees_dict:
            result["GaudiTest.TTrees.expected"] = result.Quote(pp.pformat(trees_dict))
            if ignore:
                result["GaudiTest.TTrees.ignore"] = result.Quote(ignore)

        trees = findTTreeSummaries(stdout)
        failed = cmpTreesDicts(trees_dict, trees, ignore)
        if failed:
            causes.append("trees summaries")
            msg = "%s: %s != %s" % getCmpFailingValues(trees_dict, trees, failed)
            result["GaudiTest.TTrees.failure_on"] = result.Quote(msg)
            result["GaudiTest.TTrees.found"] = result.Quote(pp.pformat(trees))

        return causes

def GaudiTest::GaudiExeTest::DumpEnvironment	(		self,
			result
	)

Add the content of the environment to the result object.

Copied from the QMTest class of COOL.

Definition at line 1355 of file GaudiTest.py.

                                     :
        """
        Add the content of the environment to the result object.

        Copied from the QMTest class of COOL.
        """
        vars = os.environ.keys()
        vars.sort()
        result['GaudiTest.environment'] = \
            result.Quote('\n'.join(["%s=%s"%(v,os.environ[v]) for v in vars]))

def GaudiTest::GaudiExeTest::GetPlatform

(

self )

Return the platform Id defined in CMTCONFIG or SCRAM_ARCH.

Definition at line 1110 of file GaudiTest.py.

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

def GaudiTest::GaudiExeTest::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 1122 of file GaudiTest.py.

                           :
        """
        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 = self.GetPlatform()
        return "winxp" in platform or platform.startswith("win")

def GaudiTest::GaudiExeTest::PlatformIsNotSupported	(		self,
			context,
			result
	)

Definition at line 1096 of file GaudiTest.py.

                                                     :
        platform = self.GetPlatform()
        unsupported = [ re.compile(x)
                        for x in [ str(y).strip()
                                   for y in self.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

def GaudiTest::GaudiExeTest::Run	(		self,
			context,
			result
	)

Run the test.

'context' -- A 'Context' giving run-time parameters to the
test.

'result' -- A 'Result' object.  The outcome will be
'Result.PASS' when this method is called.  The 'result' may be
modified by this method to indicate outcomes other than
'Result.PASS' or to add annotations.

Definition at line 1366 of file GaudiTest.py.

                                  :
        """Run the test.

        'context' -- A 'Context' giving run-time parameters to the
        test.

        'result' -- A 'Result' object.  The outcome will be
        'Result.PASS' when this method is called.  The 'result' may be
        modified by this method to indicate outcomes other than
        'Result.PASS' or to add annotations."""

        # Check if the platform is supported
        if self.PlatformIsNotSupported(context, result):
            return

        # Prepare program name and arguments (expanding variables, and converting to absolute)
        if self.program:
            prog = rationalizepath(self.program)
        elif "GAUDIEXE" in os.environ:
            prog = os.environ["GAUDIEXE"]
        else:
            prog = "Gaudi.exe"
        self.program = prog

        dummy, prog_ext = os.path.splitext(prog)
        if prog_ext not in [ ".exe", ".py", ".bat" ] and self.isWinPlatform():
            prog += ".exe"
            prog_ext = ".exe"

        prog = which(prog) or prog

        # Convert paths to absolute paths in arguments and reference files
        args = map(rationalizepath, self.args)
        self.reference = rationalizepath(self.reference)
        self.error_reference = rationalizepath(self.error_reference)


        # check if the user provided inline options
        tmpfile = None
        if self.options.strip():
            ext = ".opts"
            if re.search(r"from\s*Gaudi.Configuration\s*import\s*\*", self.options):
                ext = ".py"
            tmpfile = TempFile(ext)
            tmpfile.writelines("\n".join(self.options.splitlines()))
            tmpfile.flush()
            args.append(tmpfile.name)
            result["GaudiTest.options"] = result.Quote(self.options)

        # if the program is a python file, execute it through python
        if prog_ext == ".py":
            args.insert(0,prog)
            if self.isWinPlatform():
                prog = which("python.exe") or "python.exe"
            else:
                prog = which("python") or "python"

        # Change to the working directory if specified or to the default temporary
        origdir = os.getcwd()
        if self.workdir:
            os.chdir(str(os.path.normpath(os.path.expandvars(self.workdir))))
        elif self.use_temp_dir == "true":
            if "QMTEST_TMPDIR" in os.environ:
                os.chdir(os.environ["QMTEST_TMPDIR"])
            elif "qmtest.tmpdir" in context:
                os.chdir(context["qmtest.tmpdir"])

        if "QMTEST_IGNORE_TIMEOUT" not in os.environ:
            self.timeout = max(self.timeout,600)
        else:
            self.timeout = -1

        try:
            # Generate eclipse.org debug launcher for the test
            self._CreateEclipseLaunch(prog, args, destdir = origdir)
            # Run the test
            self.RunProgram(prog,
                            [ prog ] + args,
                            context, result)
            # Record the content of the enfironment for failing tests
            if result.GetOutcome() not in [ result.PASS ]:
                self.DumpEnvironment(result)
        finally:
            # revert to the original directory
            os.chdir(origdir)

def GaudiTest::GaudiExeTest::RunProgram	(		self,
			program,
			arguments,
			context,
			result
	)

Run the 'program'.

'program' -- The path to the program to run.

'arguments' -- A list of the arguments to the program.  This
list must contain a first argument corresponding to 'argv[0]'.

'context' -- A 'Context' giving run-time parameters to the
test.

'result' -- A 'Result' object.  The outcome will be
'Result.PASS' when this method is called.  The 'result' may be
modified by this method to indicate outcomes other than
'Result.PASS' or to add annotations.

@attention: This method has been copied from command.ExecTestBase
    (QMTest 2.3.0) and modified to keep stdout and stderr
    for tests that have been terminated by a signal.
    (Fundamental for debugging in the Application Area)

Definition at line 1452 of file GaudiTest.py.

                                                             :
        """Run the 'program'.

        'program' -- The path to the program to run.

        'arguments' -- A list of the arguments to the program.  This
        list must contain a first argument corresponding to 'argv[0]'.

        'context' -- A 'Context' giving run-time parameters to the
        test.

        'result' -- A 'Result' object.  The outcome will be
        'Result.PASS' when this method is called.  The 'result' may be
        modified by this method to indicate outcomes other than
        'Result.PASS' or to add annotations.

        @attention: This method has been copied from command.ExecTestBase
                    (QMTest 2.3.0) and modified to keep stdout and stderr
                    for tests that have been terminated by a signal.
                    (Fundamental for debugging in the Application Area)
        """

        # Construct the environment.
        environment = self.MakeEnvironment(context)
        # Create the executable.
        if self.timeout >= 0:
            timeout = self.timeout
        else:
            # If no timeout was specified, we sill run this process in a
            # separate process group and kill the entire process group
            # when the child is done executing.  That means that
            # orphaned child processes created by the test will be
            # cleaned up.
            timeout = -2
        e = GaudiFilterExecutable(self.stdin, timeout)
        # Run it.
        exit_status = e.Run(arguments, environment, path = program)
        # Get the stack trace from the temporary file (if present)
        if e.stack_trace_file and os.path.exists(e.stack_trace_file):
            stack_trace = open(e.stack_trace_file).read()
            os.remove(e.stack_trace_file)
        else:
            stack_trace = None
        if stack_trace:
            result["ExecTest.stack_trace"] = result.Quote(stack_trace)

        # If the process terminated normally, check the outputs.
        if sys.platform == "win32" or os.WIFEXITED(exit_status):
            # There are no causes of failure yet.
            causes = []
            # The target program terminated normally.  Extract the
            # exit code, if this test checks it.
            if self.exit_code is None:
                exit_code = None
            elif sys.platform == "win32":
                exit_code = exit_status
            else:
                exit_code = os.WEXITSTATUS(exit_status)
            # Get the output generated by the program.
            stdout = e.stdout
            stderr = e.stderr
            # Record the results.
            result["ExecTest.exit_code"] = str(exit_code)
            result["ExecTest.stdout"] = result.Quote(stdout)
            result["ExecTest.stderr"] = result.Quote(stderr)
            # Check to see if the exit code matches.
            if exit_code != self.exit_code:
                causes.append("exit_code")
                result["ExecTest.expected_exit_code"] \
                    = str(self.exit_code)
            # Validate the output.
            causes += self.ValidateOutput(stdout, stderr, result)
            # If anything went wrong, the test failed.
            if causes:
                result.Fail("Unexpected %s." % string.join(causes, ", "))
        elif os.WIFSIGNALED(exit_status):
            # The target program terminated with a signal.  Construe
            # that as a test failure.
            signal_number = str(os.WTERMSIG(exit_status))
            if not stack_trace:
                result.Fail("Program terminated by signal.")
            else:
                # The presence of stack_trace means tha we stopped the job because
                # of a time-out
                result.Fail("Exceeded time limit (%ds), terminated." % timeout)
            result["ExecTest.signal_number"] = signal_number
            result["ExecTest.stdout"] = result.Quote(e.stdout)
            result["ExecTest.stderr"] = result.Quote(e.stderr)
        elif os.WIFSTOPPED(exit_status):
            # The target program was stopped.  Construe that as a
            # test failure.
            signal_number = str(os.WSTOPSIG(exit_status))
            if not stack_trace:
                result.Fail("Program stopped by signal.")
            else:
                # The presence of stack_trace means tha we stopped the job because
                # of a time-out
                result.Fail("Exceeded time limit (%ds), stopped." % timeout)
            result["ExecTest.signal_number"] = signal_number
            result["ExecTest.stdout"] = result.Quote(e.stdout)
            result["ExecTest.stderr"] = result.Quote(e.stderr)
        else:
            # The target program terminated abnormally in some other
            # manner.  (This shouldn't normally happen...)
            result.Fail("Program did not terminate normally.")

        # Marco Cl.: This is a special trick to fix a "problem" with the output
        # of gaudi jobs when they use colors
        esc = '\x1b'
        repr_esc = '\\x1b'
        result["ExecTest.stdout"] = result["ExecTest.stdout"].replace(esc,repr_esc)
        # TODO: (MCl) improve the hack for colors in standard output
        #             may be converting them to HTML tags

def GaudiTest::GaudiExeTest::ValidateOutput	(		self,
			stdout,
			stderr,
			result
	)

Definition at line 1290 of file GaudiTest.py.

                                                    :
        causes = []
        # if the test definition contains a custom validator, use it
        if self.validator.strip() != "":
            class CallWrapper(object):
                """
                Small wrapper class to dynamically bind some default arguments
                to a callable.
                """
                def __init__(self, callable, extra_args = {}):
                    self.callable = callable
                    self.extra_args = extra_args
                    # get the list of names of positional arguments
                    from inspect import getargspec
                    self.args_order = getargspec(callable)[0]
                    # Remove "self" from the list of positional arguments
                    # since it is added automatically
                    if self.args_order[0] == "self":
                        del self.args_order[0]
                def __call__(self, *args, **kwargs):
                    # Check which positional arguments are used
                    positional = self.args_order[:len(args)]

                    kwargs = dict(kwargs) # copy the arguments dictionary
                    for a in self.extra_args:
                        # use "extra_args" for the arguments not specified as
                        # positional or keyword
                        if a not in positional and a not in kwargs:
                            kwargs[a] = self.extra_args[a]
                    return apply(self.callable, args, kwargs)
            # local names to be exposed in the script
            exported_symbols = {"self":self,
                                "stdout":stdout,
                                "stderr":stderr,
                                "result":result,
                                "causes":causes,
                                "findReferenceBlock":
                                    CallWrapper(findReferenceBlock, {"stdout":stdout,
                                                                     "result":result,
                                                                     "causes":causes}),
                                "validateWithReference":
                                    CallWrapper(self.ValidateWithReference, {"stdout":stdout,
                                                                             "stderr":stderr,
                                                                             "result":result,
                                                                             "causes":causes}),
                                "countErrorLines":
                                    CallWrapper(countErrorLines, {"stdout":stdout,
                                                                  "result":result,
                                                                  "causes":causes}),
                                "checkTTreesSummaries":
                                    CallWrapper(self.CheckTTreesSummaries, {"stdout":stdout,
                                                                            "result":result,
                                                                            "causes":causes}),
                                "checkHistosSummaries":
                                    CallWrapper(self.CheckHistosSummaries, {"stdout":stdout,
                                                                            "result":result,
                                                                            "causes":causes}),

                                }
            exec self.validator in globals(), exported_symbols
        else:
            self.ValidateWithReference(stdout, stderr, result, causes)

        return causes

def GaudiTest::GaudiExeTest::ValidateWithReference	(		self,
			stdout,
			stderr,
			result,
			causes,
			preproc = None
	)

Default validation action: compare standard output and error to the
reference files.

Definition at line 1233 of file GaudiTest.py.

                                                                                   :
        """
        Default validation action: compare standard output and error to the
        reference files.
        """
        # set the default output preprocessor
        if preproc is None:
            preproc = normalizeExamples
        # check standard output
        reference = self._expandReferenceFileName(self.reference)
        # call the validator if the file exists
        if reference and os.path.isfile(reference):
            result["GaudiTest.output_reference"] = reference
            causes += ReferenceFileValidator(reference,
                                             "standard output",
                                             "GaudiTest.output_diff",
                                             preproc = preproc)(stdout, result)

        # Compare TTree summaries
        causes = self.CheckTTreesSummaries(stdout, result, causes)
        causes = self.CheckHistosSummaries(stdout, result, causes)

        if causes: # Write a new reference file for stdout
            try:
                newref = open(reference + ".new","w")
                # sanitize newlines
                for l in stdout.splitlines():
                    newref.write(l.rstrip() + '\n')
                del newref # flush and close
            except IOError:
                # Ignore IO errors when trying to update reference files
                # because we may be in a read-only filesystem
                pass

        # check standard error
        reference = self._expandReferenceFileName(self.error_reference)
        # call the validator if we have a file to use
        if reference and os.path.isfile(reference):
            result["GaudiTest.error_reference"] = reference
            newcauses = ReferenceFileValidator(reference,
                                               "standard error",
                                               "GaudiTest.error_diff",
                                               preproc = preproc)(stderr, result)
            causes += newcauses
            if newcauses: # Write a new reference file for stdedd
                newref = open(reference + ".new","w")
                # sanitize newlines
                for l in stderr.splitlines():
                    newref.write(l.rstrip() + '\n')
                del newref # flush and close
        else:
            causes += BasicOutputValidator(self.stderr,
                                           "standard error",
                                           "ExecTest.expected_stderr")(stderr, result)

        return causes

---

Member Data Documentation

GaudiTest::GaudiExeTest::args_order

Definition at line 1293 of file GaudiTest.py.

list GaudiTest::GaudiExeTest::arguments [static]

Definition at line 982 of file GaudiTest.py.

GaudiTest::GaudiExeTest::callable

Definition at line 1293 of file GaudiTest.py.

GaudiTest::GaudiExeTest::error_reference

Definition at line 1374 of file GaudiTest.py.

GaudiTest::GaudiExeTest::extra_args

Definition at line 1293 of file GaudiTest.py.

GaudiTest::GaudiExeTest::program

Definition at line 1374 of file GaudiTest.py.

GaudiTest::GaudiExeTest::reference

Definition at line 1374 of file GaudiTest.py.

GaudiTest::GaudiExeTest::timeout

Definition at line 1374 of file GaudiTest.py.

GaudiTest::GaudiExeTest::use_temp_dir

Definition at line 1374 of file GaudiTest.py.

---

The documentation for this class was generated from the following file:

• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v23r0/GaudiPolicy/qmtest_classes/GaudiTest.py