#!/cvmfs/neugrid.egi.eu/software/x86_64/c-pack-d788610/linuxbrew/bin/python
# GLib Testing Framework Utility -*- Mode: python; -*-
# Copyright (C) 2007 Imendio AB
# Authors: Tim Janik
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, see .
import datetime
import optparse
import sys, re, xml.dom.minidom
try:
import subunit
from subunit import iso8601
from testtools.content import Content, ContentType
mime_utf8 = ContentType('text', 'plain', {'charset': 'utf8'})
except ImportError:
subunit = None
pkginstall_configvars = {
#@PKGINSTALL_CONFIGVARS_IN24LINES@ # configvars are substituted upon script installation
}
# xml utilities
def find_child (node, child_name):
for child in node.childNodes:
if child.nodeName == child_name:
return child
return None
def list_children (node, child_name):
rlist = []
for child in node.childNodes:
if child.nodeName == child_name:
rlist += [ child ]
return rlist
def find_node (node, name = None):
if not node or node.nodeName == name or not name:
return node
for child in node.childNodes:
c = find_node (child, name)
if c:
return c
return None
def node_as_text (node, name = None):
if name:
node = find_node (node, name)
txt = ''
if node:
if node.nodeValue:
txt += node.nodeValue
for child in node.childNodes:
txt += node_as_text (child)
return txt
def attribute_as_text (node, aname, node_name = None):
node = find_node (node, node_name)
if not node:
return ''
attr = node.attributes.get (aname, '')
if hasattr (attr, 'value'):
return attr.value
return ''
# HTML utilities
def html_indent_string (n):
uncollapsible_space = ' ' # HTML won't compress alternating sequences of ' ' and ' '
string = ''
for i in range (0, (n + 1) / 2):
string += uncollapsible_space
return string
# TestBinary object, instantiated per test binary in the log file
class TestBinary:
def __init__ (self, name):
self.name = name
self.testcases = []
self.duration = 0
self.success_cases = 0
self.skipped_cases = 0
self.file = '???'
self.random_seed = ''
# base class to handle processing/traversion of XML nodes
class TreeProcess:
def __init__ (self):
self.nest_level = 0
def trampoline (self, node):
name = node.nodeName
if name == '#text':
self.handle_text (node)
else:
try: method = getattr (self, 'handle_' + re.sub ('[^a-zA-Z0-9]', '_', name))
except: method = None
if method:
return method (node)
else:
return self.process_recursive (name, node)
def process_recursive (self, node_name, node):
self.process_children (node)
def process_children (self, node):
self.nest_level += 1
for child in node.childNodes:
self.trampoline (child)
self.nest_level += 1
# test report reader, this class collects some statistics and merges duplicate test binary runs
class ReportReader (TreeProcess):
def __init__ (self):
TreeProcess.__init__ (self)
self.binary_names = []
self.binaries = {}
self.last_binary = None
self.info = {}
def binary_list (self):
lst = []
for name in self.binary_names:
lst += [ self.binaries[name] ]
return lst
def get_info (self):
return self.info
def handle_info (self, node):
dn = find_child (node, 'package')
self.info['package'] = node_as_text (dn)
dn = find_child (node, 'version')
self.info['version'] = node_as_text (dn)
dn = find_child (node, 'revision')
if dn is not None:
self.info['revision'] = node_as_text (dn)
def handle_testcase (self, node):
self.last_binary.testcases += [ node ]
result = attribute_as_text (node, 'result', 'status')
if result == 'success':
self.last_binary.success_cases += 1
if bool (int (attribute_as_text (node, 'skipped') + '0')):
self.last_binary.skipped_cases += 1
def handle_text (self, node):
pass
def handle_testbinary (self, node):
path = node.attributes.get ('path', None).value
if self.binaries.get (path, -1) == -1:
self.binaries[path] = TestBinary (path)
self.binary_names += [ path ]
self.last_binary = self.binaries[path]
dn = find_child (node, 'duration')
dur = node_as_text (dn)
try: dur = float (dur)
except: dur = 0
if dur:
self.last_binary.duration += dur
bin = find_child (node, 'binary')
if bin:
self.last_binary.file = attribute_as_text (bin, 'file')
rseed = find_child (node, 'random-seed')
if rseed:
self.last_binary.random_seed = node_as_text (rseed)
self.process_children (node)
class ReportWriter(object):
"""Base class for reporting."""
def __init__(self, binary_list):
self.binaries = binary_list
def _error_text(self, node):
"""Get a string representing the error children of node."""
rlist = list_children(node, 'error')
txt = ''
for enode in rlist:
txt += node_as_text (enode)
if txt and txt[-1] != '\n':
txt += '\n'
return txt
class HTMLReportWriter(ReportWriter):
# Javascript/CSS snippet to toggle element visibility
cssjs = r'''
'''
def __init__ (self, info, binary_list):
ReportWriter.__init__(self, binary_list)
self.info = info
self.bcounter = 0
self.tcounter = 0
self.total_tcounter = 0
self.total_fcounter = 0
self.total_duration = 0
self.indent_depth = 0
self.lastchar = ''
def oprint (self, message):
sys.stdout.write (message)
if message:
self.lastchar = message[-1]
def handle_info (self):
self.oprint ('
Package: %(package)s, version: %(version)s
\n' % self.info)
if self.info['revision']:
self.oprint ('Report generated from: %(revision)s
\n' % self.info)
def handle_text (self, node):
self.oprint (node.nodeValue)
def handle_testcase (self, node, binary):
skipped = bool (int (attribute_as_text (node, 'skipped') + '0'))
if skipped:
return # skipped tests are uninteresting for HTML reports
path = attribute_as_text (node, 'path')
duration = node_as_text (node, 'duration')
result = attribute_as_text (node, 'result', 'status')
rcolor = {
'success': 'bgcolor="lightgreen"',
'failed': 'bgcolor="red"',
}.get (result, '')
if result != 'success':
duration = '-' # ignore bogus durations
self.oprint ('\n' % (self.bcounter, self.tcounter, result))
self.oprint ('%s %s | %s | \n' % (html_indent_string (4), path, duration))
perflist = list_children (node, 'performance')
if result != 'success':
txt = self._error_text(node)
txt = re.sub (r'"', r'\\"', txt)
txt = re.sub (r'\n', r'\\n', txt)
txt = re.sub (r'&', r'&', txt)
txt = re.sub (r'<', r'<', txt)
self.oprint ('\n' % (self.bcounter, self.tcounter, txt))
self.oprint ('Details | \n' %
('TestResultWindow', binary.file, binary.random_seed, path, self.bcounter, self.tcounter))
elif perflist:
presults = []
for perf in perflist:
pmin = bool (int (attribute_as_text (perf, 'minimize')))
pmax = bool (int (attribute_as_text (perf, 'maximize')))
pval = float (attribute_as_text (perf, 'value'))
txt = node_as_text (perf)
txt = re.sub (r'&', r'&', txt)
txt = re.sub (r'<', r'>', txt)
txt = 'Performance(' + (pmin and 'minimized' or 'maximized') + '): ' + txt.strip() + '
\n'
txt = re.sub (r'"', r'\\"', txt)
txt = re.sub (r'\n', r'\\n', txt)
presults += [ (pval, txt) ]
presults.sort()
ptxt = ''.join ([e[1] for e in presults])
self.oprint ('\n' % (self.bcounter, self.tcounter, ptxt))
self.oprint ('Details | \n' %
('TestResultWindow', binary.file, binary.random_seed, path, self.bcounter, self.tcounter))
else:
self.oprint ('- | \n')
self.oprint ('%s | \n' % (rcolor, result))
self.oprint ('
\n')
self.tcounter += 1
self.total_tcounter += 1
self.total_fcounter += result != 'success'
def handle_binary (self, binary):
self.tcounter = 1
self.bcounter += 1
self.total_duration += binary.duration
self.oprint ('%s | %f | \n' % (binary.name, binary.duration))
erlink, oklink = ('', '')
real_cases = len (binary.testcases) - binary.skipped_cases
if binary.success_cases < real_cases:
erlink = 'href="javascript:toggle_display (\'ResultTable\', \'tr\', \'b%u_\', \'failed\')"' % self.bcounter
if binary.success_cases:
oklink = 'href="javascript:toggle_display (\'ResultTable\', \'tr\', \'b%u_\', \'success\')"' % self.bcounter
if real_cases != 0:
self.oprint ('ER\n' % erlink)
self.oprint ('OK\n' % oklink)
self.oprint (' | \n')
perc = binary.success_cases * 100.0 / real_cases
pcolor = {
100 : 'bgcolor="lightgreen"',
0 : 'bgcolor="red"',
}.get (int (perc), 'bgcolor="yellow"')
self.oprint ('%.2f%% | \n' % (pcolor, perc))
self.oprint ('
\n')
else:
self.oprint ('Empty\n')
self.oprint ('\n')
self.oprint ('\n')
for tc in binary.testcases:
self.handle_testcase (tc, binary)
def handle_totals (self):
self.oprint ('')
self.oprint ('Totals: %u Binaries, %u Tests, %u Failed, %u Succeeded | ' %
(self.bcounter, self.total_tcounter, self.total_fcounter, self.total_tcounter - self.total_fcounter))
self.oprint ('%f | \n' % self.total_duration)
self.oprint ('- | \n')
if self.total_tcounter != 0:
perc = (self.total_tcounter - self.total_fcounter) * 100.0 / self.total_tcounter
else:
perc = 0.0
pcolor = {
100 : 'bgcolor="lightgreen"',
0 : 'bgcolor="red"',
}.get (int (perc), 'bgcolor="yellow"')
self.oprint ('%.2f%% | \n' % (pcolor, perc))
self.oprint ('
\n')
def printout (self):
self.oprint ('\n')
self.oprint ('GTester Unit Test Report\n')
self.oprint (self.cssjs)
self.oprint ('\n')
self.oprint ('\n')
self.oprint ('GTester Unit Test Report
\n')
self.handle_info ()
self.oprint ('\n\n')
self.oprint ('Program / Testcase | \n')
self.oprint ('Duration (sec) | \n')
self.oprint ('View | \n')
self.oprint ('Result | \n')
self.oprint ('
\n')
for tb in self.binaries:
self.handle_binary (tb)
self.handle_totals()
self.oprint ('
\n')
self.oprint ('\n')
self.oprint ('\n')
class SubunitWriter(ReportWriter):
"""Reporter to output a subunit stream."""
def printout(self):
reporter = subunit.TestProtocolClient(sys.stdout)
for binary in self.binaries:
for tc in binary.testcases:
test = GTestCase(tc, binary)
test.run(reporter)
class GTestCase(object):
"""A representation of a gtester test result as a pyunit TestCase."""
def __init__(self, case, binary):
"""Create a GTestCase for case 'case' from binary program 'binary'."""
self._case = case
self._binary = binary
# the name of the case - e.g. /dbusmenu/glib/objects/menuitem/props_boolstr
self._path = attribute_as_text(self._case, 'path')
def id(self):
"""What test is this? Returns the gtester path for the testcase."""
return self._path
def _get_details(self):
"""Calculate a details dict for the test - attachments etc."""
details = {}
result = attribute_as_text(self._case, 'result', 'status')
details['filename'] = Content(mime_utf8, lambda:[self._binary.file])
details['random_seed'] = Content(mime_utf8,
lambda:[self._binary.random_seed])
if self._get_outcome() == 'addFailure':
# Extract the error details. Skips have no details because its not
# skip like unittest does, instead the runner just bypasses N test.
txt = self._error_text(self._case)
details['error'] = Content(mime_utf8, lambda:[txt])
if self._get_outcome() == 'addSuccess':
# Sucessful tests may have performance metrics.
perflist = list_children(self._case, 'performance')
if perflist:
presults = []
for perf in perflist:
pmin = bool (int (attribute_as_text (perf, 'minimize')))
pmax = bool (int (attribute_as_text (perf, 'maximize')))
pval = float (attribute_as_text (perf, 'value'))
txt = node_as_text (perf)
txt = 'Performance(' + (pmin and 'minimized' or 'maximized'
) + '): ' + txt.strip() + '\n'
presults += [(pval, txt)]
presults.sort()
perf_details = [e[1] for e in presults]
details['performance'] = Content(mime_utf8, lambda:perf_details)
return details
def _get_outcome(self):
if int(attribute_as_text(self._case, 'skipped') + '0'):
return 'addSkip'
outcome = attribute_as_text(self._case, 'result', 'status')
if outcome == 'success':
return 'addSuccess'
else:
return 'addFailure'
def run(self, result):
time = datetime.datetime.utcnow().replace(tzinfo=iso8601.Utc())
result.time(time)
result.startTest(self)
try:
outcome = self._get_outcome()
details = self._get_details()
# Only provide a duration IFF outcome == 'addSuccess' - the main
# parser claims bogus results otherwise: in that case emit time as
# zero perhaps.
if outcome == 'addSuccess':
duration = float(node_as_text(self._case, 'duration'))
duration = duration * 1000000
timedelta = datetime.timedelta(0, 0, duration)
time = time + timedelta
result.time(time)
getattr(result, outcome)(self, details=details)
finally:
result.stopTest(self)
# main program handling
def parse_opts():
"""Parse program options.
:return: An options object and the program arguments.
"""
parser = optparse.OptionParser()
parser.version = pkginstall_configvars.get ('glib-version', '0.0-uninstalled')
parser.usage = "%prog [OPTIONS] "
parser.description = "Generate HTML reports from the XML log files generated by gtester."
parser.epilog = "gtester-report (GLib utils) version %s."% (parser.version,)
parser.add_option("-v", "--version", action="store_true", dest="version", default=False,
help="Show program version.")
parser.add_option("-s", "--subunit", action="store_true", dest="subunit", default=False,
help="Output subunit [See https://launchpad.net/subunit/"
" Needs python-subunit]")
options, files = parser.parse_args()
if options.version:
print parser.epilog
return None, None
if len(files) != 1:
parser.error("Must supply a log file to parse.")
if options.subunit and subunit is None:
parser.error("python-subunit is not installed.")
return options, files
def main():
options, files = parse_opts()
if options is None:
return 0
xd = xml.dom.minidom.parse (files[0])
rr = ReportReader()
rr.trampoline (xd)
if not options.subunit:
HTMLReportWriter(rr.get_info(), rr.binary_list()).printout()
else:
SubunitWriter(rr.get_info(), rr.binary_list()).printout()
if __name__ == '__main__':
main()