mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-08 18:36:17 +01:00
00bfb3ab44
This was mostly machine generated with the following command:
```
codespell \
--builtin clear,rare,usage \
--skip './po/*' --skip './.git/*' --skip './NEWS*' \
--write-changes .
```
using the latest git version of `codespell` as per [these
instructions](https://github.com/codespell-project/codespell#user-content-updating).
Then I manually checked each change using `git add -p`, made a few
manual fixups and dropped a load of incorrect changes.
There are still some outdated or loaded terms used in GLib, mostly to do
with git branch terminology. They will need to be changed later as part
of a wider migration of git terminology.
If I’ve missed anything, please file an issue!
Signed-off-by: Philip Withnall <withnall@endlessm.com>
499 lines
19 KiB
Python
499 lines
19 KiB
Python
#! /usr/bin/env @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.1 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 <http://www.gnu.org/licenses/>.
|
|
|
|
# Deprecated: Since GLib 2.62, gtester and gtester-report have been deprecated
|
|
# in favour of TAP.
|
|
|
|
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
|
|
|
|
|
|
# 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, int((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'''
|
|
<style type="text/css" media="screen">
|
|
.VisibleSection { }
|
|
.HiddenSection { display: none; }
|
|
</style>
|
|
<script language="javascript" type="text/javascript"><!--
|
|
function toggle_display (parentid, tagtype, idmatch, keymatch) {
|
|
ptag = document.getElementById (parentid);
|
|
tags = ptag.getElementsByTagName (tagtype);
|
|
for (var i = 0; i < tags.length; i++) {
|
|
tag = tags[i];
|
|
var key = tag.getAttribute ("keywords");
|
|
if (tag.id.indexOf (idmatch) == 0 && key && key.match (keymatch)) {
|
|
if (tag.className.indexOf ("HiddenSection") >= 0)
|
|
tag.className = "VisibleSection";
|
|
else
|
|
tag.className = "HiddenSection";
|
|
}
|
|
}
|
|
}
|
|
message_array = Array();
|
|
function view_testlog (wname, file, random_seed, tcase, msgtitle, msgid) {
|
|
txt = message_array[msgid];
|
|
var w = window.open ("", // URI
|
|
wname,
|
|
"resizable,scrollbars,status,width=790,height=400");
|
|
var doc = w.document;
|
|
doc.write ("<h2>File: " + file + "</h2>\n");
|
|
doc.write ("<h3>Case: " + tcase + "</h3>\n");
|
|
doc.write ("<strong>Random Seed:</strong> <code>" + random_seed + "</code> <br /><br />\n");
|
|
doc.write ("<strong>" + msgtitle + "</strong><br />\n");
|
|
doc.write ("<pre>");
|
|
doc.write (txt);
|
|
doc.write ("</pre>\n");
|
|
doc.write ("<a href=\'javascript:window.close()\'>Close Window</a>\n");
|
|
doc.close();
|
|
}
|
|
--></script>
|
|
'''
|
|
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):
|
|
if 'package' in self.info and 'version' in self.info:
|
|
self.oprint ('<h3>Package: %(package)s, version: %(version)s</h3>\n' % self.info)
|
|
if 'revision' in self.info:
|
|
self.oprint ('<h5>Report generated from: %(revision)s</h5>\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 ('<tr id="b%u_t%u_" keywords="%s all" class="HiddenSection">\n' % (self.bcounter, self.tcounter, result))
|
|
self.oprint ('<td>%s %s</td> <td align="right">%s</td> \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 ('<script language="javascript" type="text/javascript">message_array["b%u_t%u_"] = "%s";</script>\n' % (self.bcounter, self.tcounter, txt))
|
|
self.oprint ('<td align="center"><a href="javascript:view_testlog (\'%s\', \'%s\', \'%s\', \'%s\', \'Output:\', \'b%u_t%u_\')">Details</a></td>\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 = '<strong>Performance(' + (pmin and '<em>minimized</em>' or '<em>maximized</em>') + '):</strong> ' + txt.strip() + '<br />\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 ('<script language="javascript" type="text/javascript">message_array["b%u_t%u_"] = "%s";</script>\n' % (self.bcounter, self.tcounter, ptxt))
|
|
self.oprint ('<td align="center"><a href="javascript:view_testlog (\'%s\', \'%s\', \'%s\', \'%s\', \'Test Results:\', \'b%u_t%u_\')">Details</a></td>\n' %
|
|
('TestResultWindow', binary.file, binary.random_seed, path, self.bcounter, self.tcounter))
|
|
else:
|
|
self.oprint ('<td align="center">-</td>\n')
|
|
self.oprint ('<td align="right" %s>%s</td>\n' % (rcolor, result))
|
|
self.oprint ('</tr>\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 ('<tr><td><strong>%s</strong></td><td align="right">%f</td> <td align="center">\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 ('<a %s>ER</a>\n' % erlink)
|
|
self.oprint ('<a %s>OK</a>\n' % oklink)
|
|
self.oprint ('</td>\n')
|
|
perc = binary.success_cases * 100.0 / real_cases
|
|
pcolor = {
|
|
100 : 'bgcolor="lightgreen"',
|
|
0 : 'bgcolor="red"',
|
|
}.get (int (perc), 'bgcolor="yellow"')
|
|
self.oprint ('<td align="right" %s>%.2f%%</td>\n' % (pcolor, perc))
|
|
self.oprint ('</tr>\n')
|
|
else:
|
|
self.oprint ('Empty\n')
|
|
self.oprint ('</td>\n')
|
|
self.oprint ('</tr>\n')
|
|
for tc in binary.testcases:
|
|
self.handle_testcase (tc, binary)
|
|
def handle_totals (self):
|
|
self.oprint ('<tr>')
|
|
self.oprint ('<td><strong>Totals:</strong> %u Binaries, %u Tests, %u Failed, %u Succeeded</td>' %
|
|
(self.bcounter, self.total_tcounter, self.total_fcounter, self.total_tcounter - self.total_fcounter))
|
|
self.oprint ('<td align="right">%f</td>\n' % self.total_duration)
|
|
self.oprint ('<td align="center">-</td>\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 ('<td align="right" %s>%.2f%%</td>\n' % (pcolor, perc))
|
|
self.oprint ('</tr>\n')
|
|
def printout (self):
|
|
self.oprint ('<html><head>\n')
|
|
self.oprint ('<title>GTester Unit Test Report</title>\n')
|
|
self.oprint (self.cssjs)
|
|
self.oprint ('</head>\n')
|
|
self.oprint ('<body>\n')
|
|
self.oprint ('<h2>GTester Unit Test Report</h2>\n')
|
|
self.handle_info ()
|
|
self.oprint ('<p style="color:red;font-weight:bold"><blink>'
|
|
'Deprecated: Since GLib 2.62, gtester and gtester-report are '
|
|
'deprecated. Port to TAP.</blink></p>\n');
|
|
self.oprint ('<table id="ResultTable" width="100%" border="1">\n<tr>\n')
|
|
self.oprint ('<th>Program / Testcase </th>\n')
|
|
self.oprint ('<th style="width:8em">Duration (sec)</th>\n')
|
|
self.oprint ('<th style="width:5em">View</th>\n')
|
|
self.oprint ('<th style="width:5em">Result</th>\n')
|
|
self.oprint ('</tr>\n')
|
|
for tb in self.binaries:
|
|
self.handle_binary (tb)
|
|
self.handle_totals()
|
|
self.oprint ('</table>\n')
|
|
self.oprint ('</body>\n')
|
|
self.oprint ('</html>\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':
|
|
# Successful 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 = '@GLIB_VERSION@'
|
|
parser.usage = "%prog [OPTIONS] <gtester-log.xml>"
|
|
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
|
|
|
|
print("Deprecated: Since GLib 2.62, gtester and gtester-report are "
|
|
"deprecated. Port to TAP.", file=sys.stderr)
|
|
|
|
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()
|