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 990 of file GaudiTest.py.

---

Member Function Documentation

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

Definition at line 1580 of file GaudiTest.py.

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

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

Definition at line 1143 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 1210 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 1176 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 1366 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 1121 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 1133 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 1107 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 1377 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 1463 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)
        # FIXME: whithout this, we get some spurious '\x1b[?1034' in the std out on SLC6
        if "slc6" in environment.get('CMTCONFIG', ''):
            environment['TERM'] = 'dumb'
        # 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 1301 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 1244 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 1304 of file GaudiTest.py.

list GaudiTest::GaudiExeTest::arguments [static]

Definition at line 993 of file GaudiTest.py.

GaudiTest::GaudiExeTest::callable

Definition at line 1304 of file GaudiTest.py.

GaudiTest::GaudiExeTest::error_reference

Definition at line 1385 of file GaudiTest.py.

GaudiTest::GaudiExeTest::extra_args

Definition at line 1304 of file GaudiTest.py.

GaudiTest::GaudiExeTest::program

Definition at line 1385 of file GaudiTest.py.

GaudiTest::GaudiExeTest::reference

Definition at line 1385 of file GaudiTest.py.

GaudiTest::GaudiExeTest::timeout

Definition at line 1385 of file GaudiTest.py.

GaudiTest::GaudiExeTest::use_temp_dir

Definition at line 1385 of file GaudiTest.py.

---

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

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