def writeTest( gen, test ):
        startElement( gen, None, "Test", { u"Status":checkerResultAsString[test.result]} )
        writeElement( gen, None, "Name", test.name )
        writeElement( gen, None, "FullName", test.name )
        startElement( gen, None, "NamedMeasurement", { u"type":u"text/string", u"name":u"Completion Status"} )
        writeElement( gen, None, "Value", test.errorString )
        endElement( gen, None, "NamedMeasurement" )
        endElement( gen, None, "Test" )
def writeInternalError( gen, errorstr, num ):
        startElement( gen, None, "Test", { u"Status":u"failed"} )
        name = "InternalError{0}".format( num )
        writeElement( gen, None, "Name", name )
        writeElement( gen, None, "FullName", name )
        startElement( gen, None, "NamedMeasurement", { u"type":u"text/string", u"name":u"Completion Status"} )
        writeElement( gen, None, "Value", errorstr )
        endElement( gen, None, "NamedMeasurement" )
        endElement( gen, None, "Test" )
    def genTestXml( self, gen, result ):
        name = "{0} on {1}".format( result._installer.sourceFilename, result._vm.name() )
        startElement( gen, None, "Site", { u"BuildStamp":self._buildStamp, u"Name":name, u"Generator":u"VMTester 0.1" } )
        startElement( gen, None, "Testing" )
        writeElement( gen, None, "StartDateTime", formatDate( result._testStart ) )
        startElement( gen, None, "TestList" )
        internal = result._internalErrors
        for i in range( 0, len( internal ) - 1 ):
            writeElement( gen, None, "Test", "InternalError{0}".format( i ) )

        for stepNum in range( len( result._stepResults ) ):
            step = result._stepResults[stepNum]
            writeElement( gen, None, "Test", "installer-run{0}".format( stepNum ) )
            for i in step.checkerResults:
                writeElement( gen, None, "Test", i.name )              
        endElement( gen, None, "TestList" )
        
        for i in range( 0, len( internal ) - 1 ):
            writeInternalError( gen, internal[i], i )
        for stepNum in range( len( result._stepResults ) ):
            step = result._stepResults[stepNum]    
            writeExecutionResult( gen, "installer-run{0}".format( stepNum ), step.executionResult )
            for i in step.checkerResults:
                writeTest( gen, i )
        endElement( gen, None, "Testing" )
        endElement( gen, None, "Site" )
def writeExecutionResult( gen, name, r ):
        if r == None or r.hasError():
            stat = "failed"
        else:
            stat = "passed"

        startElement( gen, None, "Test", { u"Status":stat } )
        writeElement( gen, None, "Name", name )
        writeElement( gen, None, "FullName", name )
        startElement( gen, None, "NamedMeasurement", { u"type":u"text/string", u"name":u"Exit Code"} )
        if r:
            msg = "(Unexpected)"
            ec = r.exitCode           
            if ec == 0:
               msg = "(Success)"
            elif ec == 1:
               msg = "(Failed)"
            elif ec == 2:
               msg = "(Canceled)"
  
            writeElement( gen, None, "Value", "Exit status: {0}; Installer exit code: {1} {2}".format( exitStatusAsString( r.exitStatus ), str( r.exitCode ), msg ) )
        else:
            writeElement( gen, None, "Value", "Could not determine installation result." )

        endElement( gen, None, "NamedMeasurement" )


        if r:
            startElement( gen, None, "NamedMeasurement", { u"type":u"numeric/double", u"name":u"Execution Time"} )
            writeElement( gen, None, "Value", str( r.executionTime ) )
            endElement( gen, None, "NamedMeasurement" )


        endElement( gen, None, "Test" )
    def toXml( self, result, out ):
        atom = "http://www.w3.org/2005/Atom"
        tf = "http://sdk.nokia.com/test-framework/ns/1.0"
        
        gen = XMLGenerator( out, 'utf-8' )
        gen.startDocument()
        gen.startPrefixMapping( 'atom', atom)
        gen.startPrefixMapping( 'tf', tf )

        startElement( gen, atom, 'entry' )
        
        writeElement( gen, atom, 'title', result.constructTitle() )
        writeElement( gen, atom, 'updated', datetime.datetime.now().isoformat() )

        writeElement( gen, tf, 'errorSummary', exitStatusAsString( result.status() ) )

        writeElement( gen, tf, 'host', socket.gethostname() )
        if result._testStart != None:
            writeElement( gen, tf, 'testStart', result._testStart.isoformat() )
        else:
            result._internalErrors.append( "Result generator: no start timestamp found." )

        if result._testEnd != None:
            writeElement( gen, tf, 'testEnd', result._testEnd.isoformat() )
        else:
            result._internalErrors.append( "Result generator: no end timestamp found." )
            
        
        startElement( gen, tf, 'installer' )
        writeElement( gen, tf, 'sourceUrl', result._installerSourceLocation )
        writeElement( gen, tf, 'platform', result._installerTargetPlatform )
        #TODO revision
        endElement( gen, tf, 'installer' )

        if result._testcase != None:
            startElement( gen, tf, 'testCase' )
            writeElement( gen, tf, 'name', result._testcase.name() )
            writeElement( gen, tf, 'path', result._testcase.path() )
            writeElement( gen, tf, 'installScript', result._testcase.installscript() )
            endElement( gen, tf, 'testCase' )
        else:
            result._internalErrors.append( "Result generator: No test case given." )

        if result._installationResult != None:
            startElement( gen, tf, 'installationResult' )
            writeElement( gen, tf, 'exitCode', str( result._installationResult.exitCode ) )    
            writeElement( gen, tf, 'exitStatus', exitStatusAsString( result._installationResult.exitStatus ) )    
            endElement( gen, tf, 'installationResult' )
        else:
            result._internalErrors.append( "Result generator: No installation result given." )
        startElement( gen, tf, 'checkerResult' )
        
        for err in result._checkerErrors:
            writeElement( gen, tf, 'error', err )    
        endElement( gen, tf, 'checkerResult' )
            
        startElement( gen, tf, 'virtualMachine' )
        writeElement( gen, tf, 'path', result._vm.vmxPath() )
        writeElement( gen, tf, 'platform', result._vm.ostype() )
        writeElement( gen, tf, 'snapshot', result._vm.snapshot() )
        endElement( gen, tf, 'virtualMachine' )

        startElement( gen, tf, 'internalErrors' )
        for i in result._internalErrors:
            writeElement( gen, tf, 'internalError', str( i ) )

        endElement( gen, tf, 'internalErrors' )
        
        if result._errorSnapshot != None:
            writeElement( gen, tf, 'errorSnapshot', result._errorSnapshot )
            
        endElement( gen, atom, 'entry' )
        
        gen.endDocument()