diff options
Diffstat (limited to 'scripts/command/lcov-to-covertura-xml.sh')
| -rwxr-xr-x | scripts/command/lcov-to-covertura-xml.sh | 414 |
1 files changed, 414 insertions, 0 deletions
diff --git a/scripts/command/lcov-to-covertura-xml.sh b/scripts/command/lcov-to-covertura-xml.sh new file mode 100755 index 000000000..7aae6d115 --- /dev/null +++ b/scripts/command/lcov-to-covertura-xml.sh @@ -0,0 +1,414 @@ +#!/usr/bin/env python + +# Copyright 2011-2012 Eric Wendelin +# +# This is free software, licensed under the Apache License, Version 2.0, +# available in the accompanying LICENSE.txt file. + +""" +Converts lcov line coverage output to Cobertura-compatible XML for CI +""" + +import re +import sys +import os +import time +import subprocess +from xml.dom import minidom +from optparse import OptionParser + +from distutils.spawn import find_executable + +CPPFILT = "c++filt" +HAVE_CPPFILT = False + +if find_executable(CPPFILT) is not None: + HAVE_CPPFILT = True + +VERSION = '1.6' +__all__ = ['LcovCobertura'] + + +class Demangler(object): + def __init__(self): + self.pipe = subprocess.Popen( + CPPFILT, stdin=subprocess.PIPE, stdout=subprocess.PIPE) + + def demangle(self, name): + self.pipe.stdin.write(name + "\n") + return self.pipe.stdout.readline().rstrip() + + +class LcovCobertura(object): + """ + Converts code coverage report files in lcov format to Cobertura's XML + report format so that CI servers like Jenkins can aggregate results and + determine build stability etc. + + >>> from lcov_cobertura import LcovCobertura + >>> LCOV_INPUT = 'your lcov input' + >>> converter = LcovCobertura(LCOV_INPUT) + >>> cobertura_xml = converter.convert() + >>> print(cobertura_xml) + """ + + def __init__(self, lcov_data, base_dir='.', excludes=None, demangle=False): + """ + Create a new :class:`LcovCobertura` object using the given `lcov_data` + and `options`. + + :param lcov_data: Path to LCOV data file + :type lcov_data: string + :param base_dir: Path upon which to base all sources + :type base_dir: string + :param excludes: list of regexes to packages as excluded + :type excludes: [string] + :param demangle: whether to demangle function names using c++filt + :type demangle: bool + """ + + if not excludes: + excludes = [] + self.lcov_data = lcov_data + self.base_dir = base_dir + self.excludes = excludes + if demangle: + demangler = Demangler() + self.format = demangler.demangle + else: + self.format = lambda x: x + + def convert(self): + """ + Convert lcov file to cobertura XML using options from this instance. + """ + coverage_data = self.parse() + return self.generate_cobertura_xml(coverage_data) + + def parse(self): + """ + Generate a data structure representing it that can be serialized in any + logical format. + """ + + coverage_data = { + 'packages': {}, + 'summary': {'lines-total': 0, 'lines-covered': 0, + 'branches-total': 0, 'branches-covered': 0}, + 'timestamp': str(int(time.time())) + } + package = None + current_file = None + file_lines_total = 0 + file_lines_covered = 0 + file_lines = {} + file_methods = {} + file_branches_total = 0 + file_branches_covered = 0 + + for line in self.lcov_data.split('\n'): + if line.strip() == 'end_of_record': + if current_file is not None: + package_dict = coverage_data['packages'][package] + package_dict['lines-total'] += file_lines_total + package_dict['lines-covered'] += file_lines_covered + package_dict['branches-total'] += file_branches_total + package_dict['branches-covered'] += file_branches_covered + file_dict = package_dict['classes'][current_file] + file_dict['lines-total'] = file_lines_total + file_dict['lines-covered'] = file_lines_covered + file_dict['lines'] = dict(file_lines) + file_dict['methods'] = dict(file_methods) + file_dict['branches-total'] = file_branches_total + file_dict['branches-covered'] = file_branches_covered + coverage_data['summary']['lines-total'] += file_lines_total + coverage_data['summary']['lines-covered'] += file_lines_covered + coverage_data['summary']['branches-total'] += file_branches_total + coverage_data['summary']['branches-covered'] += file_branches_covered + + line_parts = line.split(':', 1) + input_type = line_parts[0] + + if input_type == 'SF': + # Get file name + file_name = line_parts[-1].strip() + relative_file_name = os.path.relpath(file_name, self.base_dir) + package = '.'.join(relative_file_name.split(os.path.sep)[0:-1]) + class_name = '.'.join(relative_file_name.split(os.path.sep)) + if package not in coverage_data['packages']: + coverage_data['packages'][package] = { + 'classes': {}, 'lines-total': 0, 'lines-covered': 0, + 'branches-total': 0, 'branches-covered': 0 + } + coverage_data['packages'][package]['classes'][ + relative_file_name] = { + 'name': class_name, 'lines': {}, 'lines-total': 0, + 'lines-covered': 0, 'branches-total': 0, + 'branches-covered': 0 + } + package = package + current_file = relative_file_name + file_lines_total = 0 + file_lines_covered = 0 + file_lines.clear() + file_methods.clear() + file_branches_total = 0 + file_branches_covered = 0 + elif input_type == 'DA': + # DA:2,0 + (line_number, line_hits) = line_parts[-1].strip().split(',') + line_number = int(line_number) + if line_number not in file_lines: + file_lines[line_number] = { + 'branch': 'false', 'branches-total': 0, + 'branches-covered': 0 + } + file_lines[line_number]['hits'] = line_hits + # Increment lines total/covered for class and package + try: + if int(line_hits) > 0: + file_lines_covered += 1 + except: + pass + file_lines_total += 1 + elif input_type == 'BRDA': + # BRDA:1,1,2,0 + (line_number, block_number, branch_number, branch_hits) = line_parts[-1].strip().split(',') + line_number = int(line_number) + if line_number not in file_lines: + file_lines[line_number] = { + 'branch': 'true', 'branches-total': 0, + 'branches-covered': 0, 'hits': 0 + } + file_lines[line_number]['branch'] = 'true' + file_lines[line_number]['branches-total'] += 1 + file_branches_total += 1 + if branch_hits != '-' and int(branch_hits) > 0: + file_lines[line_number]['branches-covered'] += 1 + file_branches_covered += 1 + elif input_type == 'BRF': + file_branches_total = int(line_parts[1]) + elif input_type == 'BRH': + file_branches_covered = int(line_parts[1]) + elif input_type == 'FN': + # FN:5,(anonymous_1) + function_line, function_name = line_parts[-1].strip().split(',') + file_methods[function_name] = [function_line, '0'] + elif input_type == 'FNDA': + # FNDA:0,(anonymous_1) + (function_hits, function_name) = line_parts[-1].strip().split(',') + if function_name not in file_methods: + file_methods[function_name] = ['0', '0'] + file_methods[function_name][-1] = function_hits + + # Exclude packages + excluded = [x for x in coverage_data['packages'] for e in self.excludes + if re.match(e, x)] + for package in excluded: + del coverage_data['packages'][package] + + # Compute line coverage rates + for package_data in list(coverage_data['packages'].values()): + package_data['line-rate'] = self._percent( + package_data['lines-total'], + package_data['lines-covered']) + package_data['branch-rate'] = self._percent( + package_data['branches-total'], + package_data['branches-covered']) + + return coverage_data + + def generate_cobertura_xml(self, coverage_data): + """ + Given parsed coverage data, return a String cobertura XML representation. + + :param coverage_data: Nested dict representing coverage information. + :type coverage_data: dict + """ + + dom_impl = minidom.getDOMImplementation() + doctype = dom_impl.createDocumentType("coverage", None, + "http://cobertura.sourceforge.net/xml/coverage-04.dtd") + document = dom_impl.createDocument(None, "coverage", doctype) + root = document.documentElement + summary = coverage_data['summary'] + self._attrs(root, { + 'branch-rate': self._percent(summary['branches-total'], + summary['branches-covered']), + 'branches-covered': str(summary['branches-covered']), + 'branches-valid': str(summary['branches-total']), + 'complexity': '0', + 'line-rate': self._percent(summary['lines-total'], + summary['lines-covered']), + 'lines-covered': str(summary['lines-covered']), + 'lines-valid': str(summary['lines-total']), + 'timestamp': coverage_data['timestamp'], + 'version': '2.0.3' + }) + + sources = self._el(document, 'sources', {}) + source = self._el(document, 'source', {}) + source.appendChild(document.createTextNode(self.base_dir)) + sources.appendChild(source) + + root.appendChild(sources) + + packages_el = self._el(document, 'packages', {}) + + packages = coverage_data['packages'] + for package_name, package_data in list(packages.items()): + package_el = self._el(document, 'package', { + 'line-rate': package_data['line-rate'], + 'branch-rate': package_data['branch-rate'], + 'name': package_name, + 'complexity': '0', + }) + classes_el = self._el(document, 'classes', {}) + for class_name, class_data in list(package_data['classes'].items()): + class_el = self._el(document, 'class', { + 'branch-rate': self._percent(class_data['branches-total'], + class_data['branches-covered']), + 'complexity': '0', + 'filename': class_name, + 'line-rate': self._percent(class_data['lines-total'], + class_data['lines-covered']), + 'name': class_data['name'] + }) + + # Process methods + methods_el = self._el(document, 'methods', {}) + for method_name, (line, hits) in list(class_data['methods'].items()): + method_el = self._el(document, 'method', { + 'name': self.format(method_name), + 'signature': '', + 'line-rate': '1.0' if int(hits) > 0 else '0.0', + 'branch-rate': '1.0' if int(hits) > 0 else '0.0', + }) + method_lines_el = self._el(document, 'lines', {}) + method_line_el = self._el(document, 'line', { + 'hits': hits, + 'number': line, + 'branch': 'false', + }) + method_lines_el.appendChild(method_line_el) + method_el.appendChild(method_lines_el) + methods_el.appendChild(method_el) + + # Process lines + lines_el = self._el(document, 'lines', {}) + lines = list(class_data['lines'].keys()) + lines.sort() + for line_number in lines: + line_el = self._el(document, 'line', { + 'branch': class_data['lines'][line_number]['branch'], + 'hits': str(class_data['lines'][line_number]['hits']), + 'number': str(line_number) + }) + if class_data['lines'][line_number]['branch'] == 'true': + total = int(class_data['lines'][line_number]['branches-total']) + covered = int(class_data['lines'][line_number]['branches-covered']) + percentage = int((covered * 100.0) / total) + line_el.setAttribute('condition-coverage', + '{0}% ({1}/{2})'.format( + percentage, covered, total)) + lines_el.appendChild(line_el) + + class_el.appendChild(methods_el) + class_el.appendChild(lines_el) + classes_el.appendChild(class_el) + package_el.appendChild(classes_el) + packages_el.appendChild(package_el) + root.appendChild(packages_el) + + return document.toprettyxml() + + def _el(self, document, name, attrs): + """ + Create an element within document with given name and attributes. + + :param document: Document element + :type document: Document + :param name: Element name + :type name: string + :param attrs: Attributes for element + :type attrs: dict + """ + return self._attrs(document.createElement(name), attrs) + + def _attrs(self, element, attrs): + """ + Set attributes on given element. + + :param element: DOM Element + :type element: Element + :param attrs: Attributes for element + :type attrs: dict + """ + for attr, val in list(attrs.items()): + element.setAttribute(attr, val) + return element + + def _percent(self, lines_total, lines_covered): + """ + Get the percentage of lines covered in the total, with formatting. + + :param lines_total: Total number of lines in given module + :type lines_total: number + :param lines_covered: Number of lines covered by tests in module + :type lines_covered: number + """ + + if lines_total == 0: + return '0.0' + return str(float(float(lines_covered) / float(lines_total))) + + +def main(argv=None): + """ + Converts LCOV coverage data to Cobertura-compatible XML for reporting. + + Usage: + lcov_cobertura.py lcov-file.dat + lcov_cobertura.py lcov-file.dat -b src/dir -e test.lib -o path/out.xml + + By default, XML output will be written to ./coverage.xml + """ + if argv is None: + argv = sys.argv + parser = OptionParser() + parser.usage = ('lcov_cobertura.py lcov-file.dat [-b source/dir] ' + '[-e <exclude packages regex>] [-o output.xml] [-d]') + parser.description = 'Converts lcov output to cobertura-compatible XML' + parser.add_option('-b', '--base-dir', action='store', + help='Directory where source files are located', + dest='base_dir', default='.') + parser.add_option('-e', '--excludes', + help='Comma-separated list of regexes of packages to exclude', + action='append', dest='excludes', default=[]) + parser.add_option('-o', '--output', + help='Path to store cobertura xml file', + action='store', dest='output', default='coverage.xml') + parser.add_option('-d', '--demangle', + help='Demangle C++ function names using %s' % CPPFILT, + action='store_true', dest='demangle', default=False) + (options, args) = parser.parse_args(args=argv) + + if options.demangle and not HAVE_CPPFILT: + raise RuntimeError("C++ filter executable (%s) not found!" % CPPFILT) + + if len(args) != 2: + print(main.__doc__) + sys.exit(1) + + try: + with open(args[1], 'r') as lcov_file: + lcov_data = lcov_file.read() + lcov_cobertura = LcovCobertura(lcov_data, options.base_dir, options.excludes, options.demangle) + cobertura_xml = lcov_cobertura.convert() + with open(options.output, mode='wt') as output_file: + output_file.write(cobertura_xml) + except IOError: + sys.stderr.write("Unable to convert %s to Cobertura XML" % args[1]) + +if __name__ == '__main__': + main() |