GaudiTest.XMLResultStream Class Reference

Inheritance diagram for GaudiTest.XMLResultStream:

Collaboration diagram for GaudiTest.XMLResultStream:

Public Member Functions
def	__init__ (self, arguments=None, **args)
def	WriteAnnotation (self, key, value)
def	WriteResult (self, result)
def	Summarize (self)

Static Public Attributes
list	arguments

Private Attributes
	_xmlFile
	_startTime
	_endTime
	_tree
	_site
	_Testing
	_StartDateTime
	_StartTestTime
	_TestList
	_EndDateTime
	_EndTestTime
	_ElapsedMinutes

Detailed Description

An 'XMLResultStream' writes its output to a Ctest XML file.

The argument 'dir' is used to select the destination file for the XML
report.
The destination directory may already contain the report from a previous run
(for example of a different package), in which case it will be overrided to
with the new data.

Definition at line 2097 of file GaudiTest.py.

Constructor & Destructor Documentation

__init__()

def GaudiTest.XMLResultStream.__init__	(		self,
			arguments = None,
		**	args
	)

Prepare the destination directory.

Creates the destination directory and store in it some preliminary
annotations .

Definition at line 2124 of file GaudiTest.py.

    def __init__(self, arguments=None, **args):
        """Prepare the destination directory.

        Creates the destination directory and store in it some preliminary
        annotations .
        """
        ResultStream.__init__(self, arguments, **args)

        self._xmlFile = os.path.join(self.dir, self.prefix + 'Test.xml')

        # add some global variable
        self._startTime = None
        self._endTime = None
        # Format the XML file if it not exists
        if not os.path.isfile(self._xmlFile):
            # check that the container directory exists and create it if not
            if not os.path.exists(os.path.dirname(self._xmlFile)):
                os.makedirs(os.path.dirname(self._xmlFile))

            newdataset = ET.Element("newdataset")
            self._tree = ET.ElementTree(newdataset)
            self._tree.write(self._xmlFile)
        else:
            # Read the xml file
            self._tree = ET.parse(self._xmlFile)
            newdataset = self._tree.getroot()

        # Find the corresponding site, if do not exist, create it

        #site = newdataset.find('Site[@BuildStamp="'+result["qmtest.start_time"]+'"][@OSPlatform="'+os.getenv("CMTOPT")+'"]')
        # I don't know why this syntax doesn't work. Maybe it is because of the python version. Indeed,
        # This works well in the python terminal. So I have to make a for:
        for site in newdataset.getiterator():
            # and  site.get("BuildStamp") == result["qmtest.start_time"] and:
            if site.get("OSPlatform") == os.uname()[4]:
                # Here we can add some variable to define the difference beetween 2 site
                self._site = site
                break
            else:
                site = None

        if site is None:
            import socket
            import multiprocessing
            attrib = {
                "BuildName": os.getenv("CMTCONFIG"),
                "Name": os.uname()[1],
                "Generator": "QMTest " + qm.version,
                "OSName": os.uname()[0],
                "Hostname": socket.gethostname(),
                "OSRelease": os.uname()[2],
                "OSVersion": os.uname()[3],
                "OSPlatform": os.uname()[4],
                "Is64Bits": "unknown",
                "VendorString": "unknown",
                "VendorID": "unknown",
                "FamilyID": "unknown",
                "ModelID": "unknown",
                "ProcessorCacheSize": "unknown",
                "NumberOfLogicalCPU": str(multiprocessing.cpu_count()),
                "NumberOfPhysicalCPU": "0",
                "TotalVirtualMemory": "0",
                "TotalPhysicalMemory": "0",
                "LogicalProcessorsPerPhysical": "0",
                "ProcessorClockFrequency": "0",
            }
            self._site = ET.SubElement(newdataset, "Site", attrib)
            self._Testing = ET.SubElement(self._site, "Testing")

            # Start time elements
            self._StartDateTime = ET.SubElement(self._Testing, "StartDateTime")

            self._StartTestTime = ET.SubElement(self._Testing, "StartTestTime")

            self._TestList = ET.SubElement(self._Testing, "TestList")

            # End time elements
            self._EndDateTime = ET.SubElement(self._Testing, "EndDateTime")

            self._EndTestTime = ET.SubElement(self._Testing, "EndTestTime")

            self._ElapsedMinutes = ET.SubElement(self._Testing,
                                                 "ElapsedMinutes")

        else:  # We get the elements
            self._Testing = self._site.find("Testing")
            self._StartDateTime = self._Testing.find("StartDateTime")
            self._StartTestTime = self._Testing.find("StartTestTime")
            self._TestList = self._Testing.find("TestList")
            self._EndDateTime = self._Testing.find("EndDateTime")
            self._EndTestTime = self._Testing.find("EndTestTime")
            self._ElapsedMinutes = self._Testing.find("ElapsedMinutes")
        """
        # Add some non-QMTest attributes
        if "CMTCONFIG" in os.environ:
            self.WriteAnnotation("cmt.cmtconfig", os.environ["CMTCONFIG"])
        import socket
        self.WriteAnnotation("hostname", socket.gethostname())
        """

Member Function Documentation

Summarize()

def GaudiTest.XMLResultStream.Summarize

(

self

)

Definition at line 2385 of file GaudiTest.py.

    def Summarize(self):

        # Set the final end date time
        self._EndTestTime.text = str(self._endTime)
        self._EndDateTime.text = time.strftime("%b %d %H:%M %Z",
                                               time.localtime(self._endTime))

        # Compute the total duration
        if self._endTime and self._startTime:
            delta = self._endTime - self._startTime
        else:
            delta = 0
        self._ElapsedMinutes.text = str(delta / 60)

        # Write into the file
        # ,True) in python 2.7 to add the xml header
        self._tree.write(self._xmlFile, "utf-8")

WriteAnnotation()

def GaudiTest.XMLResultStream.WriteAnnotation	(		self,
			key,
			value
	)

Definition at line 2224 of file GaudiTest.py.

    def WriteAnnotation(self, key, value):
        if key == "qmtest.run.start_time":
            if self._site.get("qmtest.run.start_time") is not None:
                return None
        self._site.set(str(key), str(value))

WriteResult()

def GaudiTest.XMLResultStream.WriteResult	(		self,
			result
	)

Prepare the test result directory in the destination directory storing
into it the result fields.
A summary of the test result is stored both in a file in the test directory
and in the global summary file.

Definition at line 2230 of file GaudiTest.py.

    def WriteResult(self, result):
        """Prepare the test result directory in the destination directory storing
        into it the result fields.
        A summary of the test result is stored both in a file in the test directory
        and in the global summary file.
        """
        summary = {}
        summary["id"] = result.GetId()
        summary["outcome"] = result.GetOutcome()
        summary["cause"] = result.GetCause()
        summary["fields"] = result.keys()
        summary["fields"].sort()

        # Since we miss proper JSON support, I hack a bit
        for f in ["id", "outcome", "cause"]:
            summary[f] = str(summary[f])
        summary["fields"] = map(str, summary["fields"])

        # format
        # package_Test.xml

        if "qmtest.start_time" in summary["fields"]:
            haveStartDate = True
        else:
            haveStartDate = False
        if "qmtest.end_time" in summary["fields"]:
            haveEndDate = True
        else:
            haveEndDate = False

        # writing the start date time
        if haveStartDate:
            self._startTime = calendar.timegm(
                time.strptime(result["qmtest.start_time"],
                              "%Y-%m-%dT%H:%M:%SZ"))
            if self._StartTestTime.text is None:
                self._StartDateTime.text = time.strftime(
                    "%b %d %H:%M %Z", time.localtime(self._startTime))
                self._StartTestTime.text = str(self._startTime)
                self._site.set("BuildStamp", result["qmtest.start_time"])

        # Save the end date time in memory
        if haveEndDate:
            self._endTime = calendar.timegm(
                time.strptime(result["qmtest.end_time"], "%Y-%m-%dT%H:%M:%SZ"))

        # add the current test to the test list
        tl = ET.Element("Test")
        tl.text = summary["id"]
        self._TestList.insert(0, tl)

        # Fill the current test
        Test = ET.Element("Test")
        if summary["outcome"] == "PASS":
            Test.set("Status", "passed")
        elif summary["outcome"] == "FAIL":
            Test.set("Status", "failed")
        elif summary["outcome"] == "SKIPPED" or summary[
                "outcome"] == "UNTESTED":
            Test.set("Status", "skipped")
        elif summary["outcome"] == "ERROR":
            Test.set("Status", "failed")
        Name = ET.SubElement(
            Test,
            "Name",
        )
        Name.text = summary["id"]
        Results = ET.SubElement(Test, "Results")

        # add the test after the other test
        self._Testing.insert(3, Test)

        if haveStartDate and haveEndDate:
            # Compute the test duration
            delta = self._endTime - self._startTime
            testduration = str(delta)
            Testduration = ET.SubElement(Results, "NamedMeasurement")
            Testduration.set("name", "Execution Time")
            Testduration.set("type", "numeric/float")
            value = ET.SubElement(Testduration, "Value")
            value.text = testduration

        # remove the fields that we store in a different way
        for n in ("qmtest.end_time", "qmtest.start_time", "qmtest.cause",
                  "ExecTest.stdout"):
            if n in summary["fields"]:
                summary["fields"].remove(n)

        # Here we can add some NamedMeasurment which we know the type
        #
        if "ExecTest.exit_code" in summary["fields"]:
            summary["fields"].remove("ExecTest.exit_code")
            ExitCode = ET.SubElement(Results, "NamedMeasurement")
            ExitCode.set("name", "exit_code")
            ExitCode.set("type", "numeric/integer")
            value = ET.SubElement(ExitCode, "Value")
            value.text = convert_xml_illegal_chars(
                result["ExecTest.exit_code"])

        TestStartTime = ET.SubElement(Results, "NamedMeasurement")
        TestStartTime.set("name", "Start_Time")
        TestStartTime.set("type", "String")
        value = ET.SubElement(TestStartTime, "Value")
        if haveStartDate:
            value.text = escape_xml_illegal_chars(
                time.strftime("%b %d %H:%M %Z %Y",
                              time.localtime(self._startTime)))
        else:
            value.text = ""

        TestEndTime = ET.SubElement(Results, "NamedMeasurement")
        TestEndTime.set("name", "End_Time")
        TestEndTime.set("type", "String")
        value = ET.SubElement(TestEndTime, "Value")
        if haveStartDate:
            value.text = escape_xml_illegal_chars(
                time.strftime("%b %d %H:%M %Z %Y",
                              time.localtime(self._endTime)))
        else:
            value.text = ""

        if summary["cause"]:
            FailureCause = ET.SubElement(Results, "NamedMeasurement")
            FailureCause.set("name", "Cause")
            FailureCause.set("type", "String")
            value = ET.SubElement(FailureCause, "Value")
            value.text = escape_xml_illegal_chars(summary["cause"])

        # Fill the result
        fields = {}
        for field in summary["fields"]:
            fields[field] = ET.SubElement(Results, "NamedMeasurement")
            fields[field].set("type", "String")
            fields[field].set("name", field)
            value = ET.SubElement(fields[field], "Value")
            # to escape the <pre></pre>
            if "<pre>" in result[field][0:6]:
                value.text = convert_xml_illegal_chars(result[field][5:-6])
            else:
                value.text = convert_xml_illegal_chars(result[field])

        if "ExecTest.stdout" in result:  # "ExecTest.stdout" in result :
            Measurement = ET.SubElement(Results, "Measurement")
            value = ET.SubElement(Measurement, "Value")
            if "<pre>" in result["ExecTest.stdout"][0:6]:
                value.text = convert_xml_illegal_chars(
                    result["ExecTest.stdout"][5:-6])
            else:
                value.text = convert_xml_illegal_chars(
                    result["ExecTest.stdout"])

        # write the file
        # ,True) in python 2.7 to add the xml header
        self._tree.write(self._xmlFile, "utf-8")

Member Data Documentation

_ElapsedMinutes

GaudiTest.XMLResultStream._ElapsedMinutes

private

Definition at line 2205 of file GaudiTest.py.

_EndDateTime

GaudiTest.XMLResultStream._EndDateTime

private

Definition at line 2201 of file GaudiTest.py.

_EndTestTime

GaudiTest.XMLResultStream._EndTestTime

private

Definition at line 2203 of file GaudiTest.py.

_endTime

GaudiTest.XMLResultStream._endTime

private

Definition at line 2136 of file GaudiTest.py.

_site

GaudiTest.XMLResultStream._site

private

Definition at line 2160 of file GaudiTest.py.

_StartDateTime

GaudiTest.XMLResultStream._StartDateTime

private

Definition at line 2194 of file GaudiTest.py.

_StartTestTime

GaudiTest.XMLResultStream._StartTestTime

private

Definition at line 2196 of file GaudiTest.py.

_startTime

GaudiTest.XMLResultStream._startTime

private

Definition at line 2135 of file GaudiTest.py.

_Testing

GaudiTest.XMLResultStream._Testing

private

Definition at line 2191 of file GaudiTest.py.

_TestList

GaudiTest.XMLResultStream._TestList

private

Definition at line 2198 of file GaudiTest.py.

_tree

GaudiTest.XMLResultStream._tree

private

Definition at line 2144 of file GaudiTest.py.

_xmlFile

GaudiTest.XMLResultStream._xmlFile

private

Definition at line 2132 of file GaudiTest.py.

arguments

list GaudiTest.XMLResultStream.arguments

static

Initial value:

=  [
        qm.fields.TextField(
            name="dir",
            title="Destination Directory",
            description=,
            verbatim="true",
            default_value=""),
        qm.fields.TextField(
            name="prefix",
            title="Output File Prefix",
            description=,
            verbatim="true",
            default_value=""),
    ]

Definition at line 2106 of file GaudiTest.py.

---

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

• GaudiPolicy/qmtest_classes/GaudiTest.py