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

---

Member Function Documentation

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

Definition at line 1548 of file GaudiTest.py.

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

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

Definition at line 1114 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 1181 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 1147 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 1337 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 1102 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::PlatformIsNotSupported	(		self,
			context,
			result
	)

Definition at line 1088 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 1348 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.GetPlatform()[0:3] == "win":
            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.GetPlatform()[0:3] == "win":
                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 1434 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 1272 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 1215 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 1275 of file GaudiTest.py.

list GaudiTest::GaudiExeTest::arguments [static]

Definition at line 974 of file GaudiTest.py.

GaudiTest::GaudiExeTest::callable

Definition at line 1275 of file GaudiTest.py.

GaudiTest::GaudiExeTest::error_reference

Definition at line 1356 of file GaudiTest.py.

GaudiTest::GaudiExeTest::extra_args

Definition at line 1275 of file GaudiTest.py.

GaudiTest::GaudiExeTest::program

Definition at line 1356 of file GaudiTest.py.

GaudiTest::GaudiExeTest::reference

Definition at line 1356 of file GaudiTest.py.

GaudiTest::GaudiExeTest::timeout

Definition at line 1356 of file GaudiTest.py.

GaudiTest::GaudiExeTest::use_temp_dir

Definition at line 1356 of file GaudiTest.py.

---

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

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