clean up of XML reporting in staf tests

gary_williams

29.53.2009 673cf2694fc5463a9f8a3f2df17f207480c288c6

clean up of XML reporting in staf tests

 opends/tests/staf-tests/shared/functions/utils.xml

@@ -842,6 +842,16 @@
        else:
          numFail=int(0)
        
        if STAFResult.has_key('startedTimestamp'):
          startTimestamp=STAFResult['startedTimestamp']
        else:
          startTimestamp=int(0)

        if STAFResult.has_key('information'):
          information=STAFResult['information']
        else:
          information=''
        
        if numFail == 0:
          if numPass == 0:
            _status='INCONCLUSIVE'
@@ -858,6 +868,24 @@

      <script>
        testcaseEndTime = strftime("%Y%m%d@%H:%M:%S",localtime())

        testcaseStop=int(time.time())        
        testcaseDuration=testcaseStop-testcaseStart
        shortName=get_test_name(STAXCurrentTestcase)

        xml.testcase = doc.createElement("testcase")
        xml.createAttr(doc,xml.testcase,"name",STAXCurrentTestcase)
        xml.createAttr(doc,xml.testcase,"duration",testcaseDuration)
        xml.createAttr(doc,xml.testcase,"group",ThisGroupName)
        xml.createAttr(doc,xml.testcase,"result",_status)
        xml.createAttr(doc,xml.testcase,"shortname",shortName.lower())
        xml.createAttr(doc,xml.testcase,"start",startTimestamp)
        xml.createAttr(doc,xml.testcase,"stop",testcaseEndTime)
        xml.createAttr(doc,xml.testcase,"suite",ThisSuiteName)
        xml.createAttr(doc,xml.testcase,"info",information)
        xml.testsuite.appendChild(xml.testcase)

        xml.writeXMLfile(doc,"%s/results2.xml" % logs.reports)
      </script>

      <call function="'queryLogs'">
@@ -867,203 +895,6 @@
          'endat'     : testcaseEndTime }
      </call>
      
      <script>
        class Test:
          def __init__(self, group, suite, fullname, start, stop, failures, successes, issues, duration):
            self.message=[]
            self.log='%s/test.log'      % local.temp
            self.errors='%s/error.log'   % local.temp
            self.access='%s/access.log' % local.temp
            for f in [self.log,self.errors,self.access]:
              if os.path.exists(local.temp):
                fh=open(f,'w')
                fh.write('')
                fh.close()
            self.group=group
            self.suite=suite
            self.fullname=fullname
            self.start=start
            self.stop=stop
            tmp=fullname.split(":")
            if len(tmp) > 2:
              del tmp[0:2]
              self.name=''.join(tmp)
            else:
              self.name=fullname
            self.duration = duration
            if failures == 0:
              if successes == 0:
                self.result='inconclusive'
              else:
                self.result='pass'
            else:
              if len(issues) == 0:
                self.result='fail'
              else:
                self.result='known'
            self.issues=issues
            
          def toXML(self):
            xml  = '      &lt;test&gt;%s' % newLine
            xml += '        &lt;name&gt;%s&lt;/name&gt;%s'         % (self.name,newLine)
            xml += '        &lt;group&gt;%s&lt;/group&gt;%s'       % (self.group,newLine)
            xml += '        &lt;suite&gt;%s&lt;/suite&gt;%s'       % (self.suite,newLine)
            xml += '        &lt;start&gt;%s&lt;/start&gt;%s'       % (self.start,newLine)
            xml += '        &lt;stop&gt;%s&lt;/stop&gt;%s'         % (self.stop,newLine)
            xml += '        &lt;result&gt;%s&lt;/result&gt;%s'     % (self.result,newLine)
            xml += '        &lt;duration&gt;%d&lt;/duration&gt;%s' % (self.duration,newLine)
            xml += '        &lt;issues&gt;%s'                      % newLine
            for issue in self.issues:
              xml += '          &lt;issue&gt;%s&lt;/issue&gt;%s'   % (issue,newLine)
            xml += '        &lt;/issues&gt;%s'                     % newLine
            xml += '        &lt;log&gt;%s'                         % newLine
            xml += '          &lt;![CDATA[%s'                      % newLine
            if self.result!='pass':
              try:
                fh=open(self.log)
                xml += fh.read()
                fh.close()
              except IOError,details:
                self.message.append('IOError: Opening %s for reading %s' % (self.log,details.args))              
            xml += '          ]]&gt;%s'                            % newLine
            xml += '        &lt;/log&gt;%s'                        % newLine
            xml += '        &lt;error&gt;%s'                       % newLine
            xml += '          &lt;![CDATA[%s'                      % newLine
            if self.result!='pass':
              try:
                fh=open(self.errors)
                xml += fh.read()
                fh.close()
              except IOError,details:
                self.message.append('IOError: Opening %s for reading %s' % (self.errors,details.args))
            xml += '          ]]&gt;%s'                            % newLine
            xml += '        &lt;/error&gt;%s'                      % newLine
            xml += '        &lt;access&gt;%s'                      % newLine
            xml += '          &lt;![CDATA[%s'                      % newLine
            if self.result!='pass':
              try:
                fh=open(self.access)
                xml += fh.read()
                fh.close()
              except IOError,details:
                self.message.append('IOError: Opening %s for reading %s' % (self.access,details.args))
            xml += '          ]]&gt;%s'                            % newLine
            xml += '        &lt;/access&gt;%s'                     % newLine
            xml += '      &lt;/test&gt;%s'                         % newLine
            return xml
          
          def appendLog(self, category, log):
            wrappedLog=''
            for _line in log.splitlines():
              _line=_line.strip()
              _leftPadding=''
              while len(_line)>100:
                _logChunk=_line[:100]
                _line=_line[100:]
                wrappedLog+='%s%s%s' % (_leftPadding,_logChunk,newLine)
                _leftPadding='...    '
              wrappedLog += '%s%s%s' % (_leftPadding,_line,newLine)
            if category == 'access':
              try:
                fh=open(self.access,'a')
              except IOError,details:
                self.message.append('IOError: Opening %s for appending %s' % (self.access,details.args))
            elif category == 'error':
              try:
                fh=open(self.errors,'a')
              except IOError,details:
                self.message.append('IOError: Opening %s for appending %s' % (self.errors,details.args))              
            else:
              try:
                fh=open(self.log,'a')
              except IOError,details:
                self.message.append('IOError: Opening %s for appending %s' % (self.log,details.args))              
            fh.seek(0,2)
            fh.write(wrappedLog)
            fh.close()
            
          def getName(self):
            return self.name
            
          def clean(self):
            for _file in [self.log,self.errors,self.access]:
              if os.path.exists(_file):
                os.remove(_file)
        
        testcaseStop=int(time.time())
        testcaseDuration=testcaseStop-testcaseStart
        thisTest = Test(CurrentTestPath['group'],CurrentTestPath['suite'],STAXCurrentTestcase, testcaseStartTime,testcaseEndTime,numFail,numPass,issuesList,testcaseDuration)
        
        doLog = False
        
        # loop through the log lines
        for element in STAFResult:
          level=element['level'] 
          
          # this test is BEFORE the append so we don't get the
          # end of testcase banner in the XML but only the relevant data
          if level == 'Stop':
            doLog=False
          
          # if the current element is actually this test's output then log it
          if doLog == True:
            thisTest.appendLog('test',element['message'])
            
          # this test is AFTER the append log so we don't get the
          # "starting testcase ..." header in the XML
          if level == 'Start':
            tmp = element['message'].split(':')
            # this is a verification that we start logging for the right
            # test case. this is especially useful for tests that execute
            # within the same second (that is the resolution of the STAF
            # log facility)
            if thisTest.getName().startswith(tmp[3]):
              doLog=True
        
        # parse the server's error log
        # TODO: figure out how to do this for multiple instance for the replication
        #       tests for example
        for logType in ['errors','access']:
          if os.path.exists('%s/%s/logs/%s' % (DIRECTORY_INSTANCE_DIR,OPENDSNAME,logType)):
            logfile=open('%s/%s/logs/%s' % (DIRECTORY_INSTANCE_DIR,OPENDSNAME,logType),'a')
            logfile.seek(0,2)
            logfile.write('End testcase %s\n' % STAXCurrentTestcase)
            logfile.close()
            logfile=open('%s/%s/logs/%s' % (DIRECTORY_INSTANCE_DIR,OPENDSNAME,logType), 'r')
            _log=''
            _doLog=False
            while True:
              line = logfile.readline()
              if not line:
                break
              if line.startswith('End testcase %s' % STAXCurrentTestcase):
                _doLog=False
              if _doLog:
                _log+=line
              if line.startswith('Begin testcase %s' % STAXCurrentTestcase):
                _doLog=True
            logfile.close()
            thisTest.appendLog(logType, _log)
        
        # save to test log
        testlog=open('%s/tests-log.xml' % logs.tests,'a')
        testlog.seek(0,2)
        testlog.write(thisTest.toXML())
        testlog.close()

        # clean the temporary log files for this test
        # this MUST be done AFTER the call to toXML or the logs will appear empty
        thisTest.clean()
      </script>

      <if expr="thisTest.message">      
        <iterate in="thisTest.message" var="_message">      
          <message>'%s' % _message</message>
        </iterate>
      </if>
      
      <script>thisTest.message=[]</script>

    </sequence>
  </function>

@@ -1084,6 +915,15 @@
          
        ThisGroupName=CurrentTestPath['group']  
        ThisSuiteName=CurrentTestPath['suite']
        
        #Create testsuite element
        xml.testsuite = doc.createElement("testsuite")
        xml.createAttr(doc,xml.testsuite,"name",ThisSuiteName)
        xml.createAttr(doc,xml.testsuite,"shortname",ThisSuiteName)
        xml.testgroup.appendChild(xml.testsuite)
        
        xml.writeXMLfile(doc,"%s/results2.xml" % logs.reports)

      </script>
      
      <!-- Start time of test suite -->      
@@ -1163,6 +1003,22 @@
          CurrentTestPath['group']='unknown-group'
        
        ThisGroupName=CurrentTestPath['group']

        xml=xmldoc_service()

        doc = xml.parseXMLfile("%s/results2.xml" % logs.reports)
        
        qa = doc.getDocumentElement()
        ft = qa.getChildNodes().item(1)
        results = ft.getChildNodes().item(1)
        
        #Create testgroup element
        xml.testgroup = doc.createElement("testgroup")
        xml.createAttr(doc,xml.testgroup,"name",ThisGroupName)
        results.appendChild(xml.testgroup)
        
        xml.writeXMLfile(doc,"%s/results2.xml" % logs.reports)
        
      </script>
      <message>'##### %s group preamble #####' % ThisGroupName</message>
    </sequence>
@@ -1189,6 +1045,7 @@
      <script>
        emmaJar='%s/%s/lib/emma.jar' % (DIRECTORY_INSTANCE_DIR,OPENDSNAME)
      </script>

      <if expr="os.path.exists(emmaJar)">
        <sequence>
          <script>
@@ -1218,55 +1075,7 @@
              'path' : TMPDIR
            }
          </call>
          <script>
            from java.io import FileInputStream
            from javax.xml.transform.stream import StreamSource
            from javax.xml.transform.stream import StreamResult
            from javax.xml.parsers import DocumentBuilderFactory
            from org.w3c.dom import *
            
            factory = DocumentBuilderFactory.newInstance() 
            builder = factory.newDocumentBuilder()
            
            input = FileInputStream("%s/coverage/%s/coverage.xml" % (TMPDIR,CurrentTestPath['group']))
            document = builder.parse(input)
            dom = document.getDocumentElement()
            coverageNodes = dom.getElementsByTagName("all").item(0).getChildNodes()
            for coverageNodeIndex in range(coverageNodes.getLength()):
              thisNode = coverageNodes.item(coverageNodeIndex)
              if thisNode.getNodeName() == 'coverage':
                thisNodeAttributes = thisNode.getAttributes()
                if thisNodeAttributes.getNamedItem("type").getNodeValue() == 'block, %':
                  rawCoverage = thisNodeAttributes.getNamedItem("value").getNodeValue()
                  coverage = rawCoverage.split('%')[0]
            testlog=open('%s/tests-log.xml' % logs.tests,'a')
            testlog.seek(0,2)
            testlog.write("      &lt;group&gt;\n")
            testlog.write("        &lt;name&gt;\n")
            testlog.write("          %s\n" % CurrentTestPath['group'])
            testlog.write("        &lt;/name&gt;\n")
            testlog.write("        &lt;coverage&gt;\n")
            testlog.write("          %s\n" % coverage)
            testlog.write("        &lt;/coverage&gt;\n")
            testlog.write("      &lt;/group&gt;\n")
            testlog.close()
          </script>
        </sequence>
        <else>
          <script>
            testlog=open('%s/tests-log.xml' % logs.tests,'a')
            testlog.seek(0,2)
            testlog.write("      &lt;group&gt;\n")
            testlog.write("        &lt;name&gt;\n")
            testlog.write("          %s\n" % CurrentTestPath['group'])
            testlog.write("        &lt;/name&gt;\n")
            testlog.write("        &lt;coverage&gt;\n")
            testlog.write("          N/A\n")
            testlog.write("        &lt;/coverage&gt;\n")
            testlog.write("      &lt;/group&gt;\n")
            testlog.close()
          </script>
        </else>
      </if>
      
      <script>

 opends/tests/staf-tests/shared/python/common.py

@@ -46,7 +46,8 @@
            "dn2list",
            "list2dn",
            "dn2rfcmailaddr",
            "java_properties" ]
            "java_properties",
            "xmldoc_service" ]

class format_testcase:
  'Format the Test name objects'
@@ -622,3 +623,60 @@
    print "Exception:", sys.exc_info()[0]

    return 1

class xmldoc_service:

  def __init__(self):
    self.testgroup=''
    self.testsuite=''
    self.testcase=''

  def createBlankDocument(self):
    try:
      import sys, traceback
      from javax.xml.parsers import DocumentBuilderFactory
      builderFactory=DocumentBuilderFactory.newInstance()
      return builderFactory.newDocumentBuilder()
    except:
      print "exception: %s" % traceback.format_exception(*sys.exc_info())

  def writeXMLfile(self,doc,xmlfile):
    try:
      import sys, traceback
      from java.io import File
      from javax.xml.transform import TransformerFactory
      from javax.xml.transform import OutputKeys
      from javax.xml.transform.stream import StreamResult
      from javax.xml.transform.dom import DOMSource
      tranFactory = TransformerFactory.newInstance();
      aTransformer = tranFactory.newTransformer();
      aTransformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1")
      aTransformer.setOutputProperty(OutputKeys.INDENT, "yes")

      src = DOMSource(doc);
      dest = StreamResult(File(xmlfile));
      aTransformer.transform(src, dest);
    except:
      print "exception: %s" % traceback.format_exception(*sys.exc_info())

  def parseXMLfile(self,xmlfile):
    try:
      import sys, traceback
      from java.io import FileInputStream
      self.builder= self.createBlankDocument()
      self.input = FileInputStream(xmlfile)
      self.doc = self.builder.parse(self.input)
      self.input.close()
      return self.doc
    except:
      print "exception: %s" % traceback.format_exception(*sys.exc_info())

  def createAttr(self,doc,tag,attr,value):
    try:
      import sys, traceback
      newAttribute= doc.createAttribute(attr)
      newAttribute.setValue('%s' % value)
      tag.setAttributeNode(newAttribute)
    except:
      print "exception: %s" % traceback.format_exception(*sys.exc_info())
                                                         

 opends/tests/staf-tests/shared/tests/runTestJob.xml

@@ -735,7 +735,6 @@
        _message='Generated groups test report.'
        xslfile= '%s/gen-groups-report.xsl' % TESTS_XSL_DIR
        htmlfile= '%s/groups.html' % logsReportDir
        testslog= '%s/tests-log.xml' % logsTestsDir
        groupsReport=report_generation()
        stringParamsDict={}

@@ -812,7 +811,7 @@
                
                htmlfile='%s/%s-report.html' % (groupDir,testSuiteShortName)

                stringParamsDict={ 'group' : testGroupName, 'suite' : testSuiteName, 'tests-log' : testslog }
                stringParamsDict={ 'group' : testGroupName, 'suite' : testSuiteName }

                casesReport=report_generation()
    
@@ -910,7 +909,7 @@
            <location>'%s' % STAF_LOCAL_HOSTNAME </location>
            <service>'email'</service>
            <request>
              'send %s contenttype "text/html" file %s subject "%s" noheader' % (MailSendTo,MailSendReport,MailSubject)
              'send %s contenttype "text/html" file "%s" subject "%s" noheader' % (MailSendTo,MailSendReport,MailSubject)
            </request>
          </stafcmd>


 opends/tests/staf-tests/shared/tests/runTests.xml

@@ -39,6 +39,22 @@
      <script>
        listOfChildren=[]

        xml=xmldoc_service()
        
        xml.createBlankDocument()
        
        builder = xml.createBlankDocument()
        
        doc = builder.newDocument()
        root = doc.createElement("qa")
        doc.appendChild(root)
        ft = doc.createElement("%s" % TESTS_TYPE)
        root.appendChild(ft);
        results = doc.createElement("results")
        ft.appendChild(results);
        
        xml.writeXMLfile(doc,"%s/results2.xml" % logs.reports)

        class groupToRun:
          def __init__(self, name):
            self.name = name
@@ -46,12 +62,6 @@
          def getName(self):
            return self.name

        testlog=open('%s/tests-log.xml' % logs.tests,'w')
        testlog.write('&lt;qa&gt;\n')
        testlog.write('  &lt;%s&gt;\n' % TESTS_TYPE)
        testlog.write('    &lt;results&gt;\n')
        testlog.close()

        groupsToRun = []
        for line in TEST_PLAN_CUSTOM.split(","):
          groupsToRun.append(groupToRun(line.rstrip()))
@@ -145,182 +155,13 @@
                'path'      : TMPDIR
              }
          </call>
          <script>
            from java.io import FileInputStream
            from javax.xml.transform.stream import StreamSource
            from javax.xml.transform.stream import StreamResult
            from javax.xml.parsers import DocumentBuilderFactory
            from org.w3c.dom import *

            factory = DocumentBuilderFactory.newInstance()
            builder = factory.newDocumentBuilder()

            input = FileInputStream("%s/coverage/coverage.xml" % TMPDIR)
            document = builder.parse(input)
            dom = document.getDocumentElement()
            coverageNodes = dom.getElementsByTagName("all").item(0).getChildNodes()
            for coverageNodeIndex in range(coverageNodes.getLength()):
              thisNode = coverageNodes.item(coverageNodeIndex)
              if thisNode.getNodeName() == 'coverage':
                thisNodeAttributes = thisNode.getAttributes()
                if thisNodeAttributes.getNamedItem("type").getNodeValue() == 'block, %':
                  rawCoverage = thisNodeAttributes.getNamedItem("value").getNodeValue()
                  coverage = rawCoverage.split('%')[0]
            testlog=open('%s/tests-log.xml' % logs.tests,'a')
            testlog.seek(0,2)
            testlog.write("      &lt;all&gt;\n")
            testlog.write("        &lt;coverage&gt;\n")
            testlog.write("          %s\n" % coverage)
            testlog.write("        &lt;/coverage&gt;\n")
            testlog.write("      &lt;/all&gt;\n")
            testlog.close()
          </script>
        </sequence>
        <else>
          <script>
            testlog=open('%s/tests-log.xml' % logs.tests,'a')
            testlog.seek(0,2)
            testlog.write("      &lt;all&gt;\n")
            testlog.write("        &lt;coverage&gt;\n")
            testlog.write("          N/A\n")
            testlog.write("        &lt;/coverage&gt;\n")
            testlog.write("      &lt;/all&gt;\n")
            testlog.close()
          </script>
        </else>
      </if>

      <!-- here goes the section where we get the product's info -->
      <call function="'GetVar'">
        { 'location'  : STAF_REMOTE_HOSTNAME,
          'type'      : 'shared',
          'variable'  : 'Job%s_ServerInfo' % STAXJobID
        }
      </call>

      <if expr="RC != 0">
        <script>
          STAFResult='{}'
        </script>
      </if>

      <!-- Build the Servers Information Dictionary -->
      <script>
        ServersInfoDict=eval(STAFResult)

        ServerVersion='unknown'
        ServerBuildId='unknown'
        ServerJavaVersion='unknown'
        ServerJavaVendor='unknown'
        ServerJVMVersion='unknown'
        ServerJVMVendor='unknown'
        ServerJVMArchitecture='unknown'
        ServerSystemOS='unknown'
        ServerSystemName='unknown'
        ServerSvnRevision='unknown'

        if ServersInfoDict.has_key('%s/%s' % (DIRECTORY_INSTANCE_DIR,OPENDSNAME)):
          ServerInfoDict=ServersInfoDict['%s/%s' % (DIRECTORY_INSTANCE_DIR,OPENDSNAME)]

          ServerInfoKey='server version'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerVersion=ServerInfoDict[ServerInfoKey]

          ServerInfoKey='server buildid'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerBuildId=ServerInfoDict[ServerInfoKey]

          ServerInfoKey='java version'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerJavaVersion=ServerInfoDict[ServerInfoKey]

          ServerInfoKey='java vendor'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerJavaVendor=ServerInfoDict[ServerInfoKey]

          ServerInfoKey='jvm version'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerJVMVersion=ServerInfoDict[ServerInfoKey]

          ServerInfoKey='jvm vendor'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerJVMVendor=ServerInfoDict[ServerInfoKey]

          ServerInfoKey='jvm architecture'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerJVMArchitecture=ServerInfoDict[ServerInfoKey]

          ServerInfoKey='system os'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerSystemOS=ServerInfoDict[ServerInfoKey]

          ServerInfoKey='system name'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerSystemName=ServerInfoDict[ServerInfoKey]

          ServerInfoKey='svn revision'
          if ServerInfoDict.has_key(ServerInfoKey):
            ServerSvnRevision=ServerInfoDict[ServerInfoKey]

        else:
          ServerInfoDict='No key found (%s/%s)' % (DIRECTORY_INSTANCE_DIR,OPENDSNAME)

        # Platform and JVM can be overridden from config file
        try:
          if TEST_OS_STRING:
            ServerOsString=TEST_OS_STRING
          else:
            ServerOsString=ServerSystemOS
        except NameError,details:
            ServerOsString=ServerSystemOS

        try:
          if TEST_JVM_STRING:
            ServerJVMString=TEST_JVM_STRING
          else:
            ServerJVMString=ServerJVMVersion
        except NameError,details:
            ServerJVMString=ServerJVMVersion

        testlog=open('%s/tests-log.xml' % logs.tests,'a')
        testlog.seek(0,2)
        testlog.write('    &lt;/results&gt;\n')
        testlog.write('    &lt;identification&gt;\n')
        testlog.write('      &lt;version&gt;\n')
        testlog.write('        %s\n' % ServerVersion)
        testlog.write('      &lt;/version&gt;\n')
        testlog.write('      &lt;buildid&gt;\n')
        testlog.write('        %s\n' % ServerBuildId)
        testlog.write('      &lt;/buildid&gt;\n')
        testlog.write('      &lt;revision&gt;\n')
        testlog.write('        %s\n' % ServerSvnRevision)
        testlog.write('      &lt;/revision&gt;\n')
        testlog.write('      &lt;platform&gt;\n')
        testlog.write('        %s\n' % ServerSystemOS)
        testlog.write('      &lt;/platform&gt;\n')
        testlog.write('      &lt;os-label&gt;\n')
        testlog.write('        %s\n' % ServerOsString)
        testlog.write('      &lt;/os-label&gt;\n')
        testlog.write('      &lt;jvm-version&gt;\n')
        testlog.write('        %s\n' % ServerJVMVersion)
        testlog.write('      &lt;/jvm-version&gt;\n')
        testlog.write('      &lt;jvm-label&gt;\n')
        testlog.write('        %s\n' % ServerJVMString)
        testlog.write('      &lt;/jvm-label&gt;\n')
        testlog.write('      &lt;jvm-vendor&gt;\n')
        testlog.write('        %s\n' % ServerJVMVendor)
        testlog.write('      &lt;/jvm-vendor&gt;\n')
        testlog.write('      &lt;tests-dir&gt;\n')
        testlog.write('        %s\n' % logs.directory)
        testlog.write('      &lt;/tests-dir&gt;\n')
        testlog.write('    &lt;/identification&gt;\n')
        testlog.write('  &lt;/%s&gt;\n' % TESTS_TYPE)
        testlog.write('&lt;/qa&gt;\n')
        testlog.close()
      </script>

      <return>listOfChildren</return>

    </sequence>

  </function>

</stax>