123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481 |
- #!/usr/bin/env vpython3
- # Copyright 2015 The Chromium Authors. All rights reserved.
- # Use of this source code is governed by a BSD-style license that can be
- # found in the LICENSE file.
- """Generates incremental code coverage reports for Java code in Chromium.
- Usage:
- build/android/emma_coverage_stats.py -v --out <output file path> --emma-dir
- <EMMA file directory> --lines-for-coverage-file
- <path to file containing lines for coverage>
- Creates a JSON representation of the overall and file coverage stats and saves
- this information to the specified output file.
- """
- import argparse
- import collections
- import json
- import logging
- import os
- import re
- import sys
- from xml.etree import ElementTree
- import devil_chromium
- from devil.utils import run_tests_helper
- NOT_EXECUTABLE = -1
- NOT_COVERED = 0
- COVERED = 1
- PARTIALLY_COVERED = 2
- # Coverage information about a single line of code.
- LineCoverage = collections.namedtuple(
- 'LineCoverage',
- ['lineno', 'source', 'covered_status', 'fractional_line_coverage'])
- class _EmmaHtmlParser:
- """Encapsulates HTML file parsing operations.
- This class contains all operations related to parsing HTML files that were
- produced using the EMMA code coverage tool.
- Example HTML:
- Package links:
- <a href="_files/1.html">org.chromium.chrome</a>
- This is returned by the selector |XPATH_SELECT_PACKAGE_ELEMENTS|.
- Class links:
- <a href="1e.html">DoActivity.java</a>
- This is returned by the selector |XPATH_SELECT_CLASS_ELEMENTS|.
- Line coverage data:
- <tr class="p">
- <td class="l" title="78% line coverage (7 out of 9)">108</td>
- <td title="78% line coverage (7 out of 9 instructions)">
- if (index < 0 || index = mSelectors.size()) index = 0;</td>
- </tr>
- <tr>
- <td class="l">109</td>
- <td> </td>
- </tr>
- <tr class="c">
- <td class="l">110</td>
- <td> if (mSelectors.get(index) != null) {</td>
- </tr>
- <tr class="z">
- <td class="l">111</td>
- <td> for (int i = 0; i < mSelectors.size(); i++) {</td>
- </tr>
- Each <tr> element is returned by the selector |XPATH_SELECT_LOC|.
- We can parse this to get:
- 1. Line number
- 2. Line of source code
- 3. Coverage status (c, z, or p)
- 4. Fractional coverage value (% out of 100 if PARTIALLY_COVERED)
- """
- # Selector to match all <a> elements within the rows that are in the table
- # that displays all of the different packages.
- _XPATH_SELECT_PACKAGE_ELEMENTS = './/BODY/TABLE[4]/TR/TD/A'
- # Selector to match all <a> elements within the rows that are in the table
- # that displays all of the different classes within a package.
- _XPATH_SELECT_CLASS_ELEMENTS = './/BODY/TABLE[3]/TR/TD/A'
- # Selector to match all <tr> elements within the table containing Java source
- # code in an EMMA HTML file.
- _XPATH_SELECT_LOC = './/BODY/TABLE[4]/TR'
- # Children of HTML elements are represented as a list in ElementTree. These
- # constants represent list indices corresponding to relevant child elements.
- # Child 1 contains percentage covered for a line.
- _ELEMENT_PERCENT_COVERED = 1
- # Child 1 contains the original line of source code.
- _ELEMENT_CONTAINING_SOURCE_CODE = 1
- # Child 0 contains the line number.
- _ELEMENT_CONTAINING_LINENO = 0
- # Maps CSS class names to corresponding coverage constants.
- _CSS_TO_STATUS = {'c': COVERED, 'p': PARTIALLY_COVERED, 'z': NOT_COVERED}
- # UTF-8 no break space.
- _NO_BREAK_SPACE = '\xc2\xa0'
- def __init__(self, emma_file_base_dir):
- """Initializes _EmmaHtmlParser.
- Args:
- emma_file_base_dir: Path to the location where EMMA report files are
- stored. Should be where index.html is stored.
- """
- self._base_dir = emma_file_base_dir
- self._emma_files_path = os.path.join(self._base_dir, '_files')
- self._index_path = os.path.join(self._base_dir, 'index.html')
- def GetLineCoverage(self, emma_file_path):
- """Returns a list of LineCoverage objects for the given EMMA HTML file.
- Args:
- emma_file_path: String representing the path to the EMMA HTML file.
- Returns:
- A list of LineCoverage objects.
- """
- line_tr_elements = self._FindElements(
- emma_file_path, self._XPATH_SELECT_LOC)
- line_coverage = []
- for tr in line_tr_elements:
- # Get the coverage status.
- coverage_status = self._CSS_TO_STATUS.get(tr.get('CLASS'), NOT_EXECUTABLE)
- # Get the fractional coverage value.
- if coverage_status == PARTIALLY_COVERED:
- title_attribute = (tr[self._ELEMENT_PERCENT_COVERED].get('TITLE'))
- # Parse string that contains percent covered: "83% line coverage ...".
- percent_covered = title_attribute.split('%')[0]
- fractional_coverage = int(percent_covered) / 100.0
- else:
- fractional_coverage = 1.0
- # Get the line number.
- lineno_element = tr[self._ELEMENT_CONTAINING_LINENO]
- # Handles oddly formatted HTML (where there is an extra <a> tag).
- lineno = int(lineno_element.text or
- lineno_element[self._ELEMENT_CONTAINING_LINENO].text)
- # Get the original line of Java source code.
- raw_source = tr[self._ELEMENT_CONTAINING_SOURCE_CODE].text
- source = raw_source.replace(self._NO_BREAK_SPACE, ' ')
- line = LineCoverage(lineno, source, coverage_status, fractional_coverage)
- line_coverage.append(line)
- return line_coverage
- def GetPackageNameToEmmaFileDict(self):
- """Returns a dict mapping Java packages to EMMA HTML coverage files.
- Parses the EMMA index.html file to get a list of packages, then parses each
- package HTML file to get a list of classes for that package, and creates
- a dict with this info.
- Returns:
- A dict mapping string representation of Java packages (with class
- names appended) to the corresponding file paths of EMMA HTML files.
- """
- # These <a> elements contain each package name and the path of the file
- # where all classes within said package are listed.
- package_link_elements = self._FindElements(
- self._index_path, self._XPATH_SELECT_PACKAGE_ELEMENTS)
- # Maps file path of package directory (EMMA generated) to package name.
- # Example: emma_dir/f.html: org.chromium.chrome.
- package_links = {
- os.path.join(self._base_dir, link.attrib['HREF']): link.text
- for link in package_link_elements if 'HREF' in link.attrib
- }
- package_to_emma = {}
- for package_emma_file_path, package_name in package_links.items():
- # These <a> elements contain each class name in the current package and
- # the path of the file where the coverage info is stored for each class.
- coverage_file_link_elements = self._FindElements(
- package_emma_file_path, self._XPATH_SELECT_CLASS_ELEMENTS)
- for class_name_element in coverage_file_link_elements:
- emma_coverage_file_path = os.path.join(
- self._emma_files_path, class_name_element.attrib['HREF'])
- full_package_name = '%s.%s' % (package_name, class_name_element.text)
- package_to_emma[full_package_name] = emma_coverage_file_path
- return package_to_emma
- # pylint: disable=no-self-use
- def _FindElements(self, file_path, xpath_selector):
- """Reads a HTML file and performs an XPath match.
- Args:
- file_path: String representing the path to the HTML file.
- xpath_selector: String representing xpath search pattern.
- Returns:
- A list of ElementTree.Elements matching the given XPath selector.
- Returns an empty list if there is no match.
- """
- with open(file_path) as f:
- file_contents = f.read()
- root = ElementTree.fromstring(file_contents)
- return root.findall(xpath_selector)
- class _EmmaCoverageStats:
- """Computes code coverage stats for Java code using the coverage tool EMMA.
- This class provides an API that allows users to capture absolute code coverage
- and code coverage on a subset of lines for each Java source file. Coverage
- reports are generated in JSON format.
- """
- # Regular expression to get package name from Java package statement.
- RE_PACKAGE_MATCH_GROUP = 'package'
- RE_PACKAGE = re.compile(r'package (?P<%s>[\w.]*);' % RE_PACKAGE_MATCH_GROUP)
- def __init__(self, emma_file_base_dir, files_for_coverage):
- """Initialize _EmmaCoverageStats.
- Args:
- emma_file_base_dir: String representing the path to the base directory
- where EMMA HTML coverage files are stored, i.e. parent of index.html.
- files_for_coverage: A list of Java source code file paths to get EMMA
- coverage for.
- """
- self._emma_parser = _EmmaHtmlParser(emma_file_base_dir)
- self._source_to_emma = self._GetSourceFileToEmmaFileDict(files_for_coverage)
- def GetCoverageDict(self, lines_for_coverage):
- """Returns a dict containing detailed coverage information.
- Gets detailed coverage stats for each file specified in the
- |lines_for_coverage| dict and the total incremental number of lines covered
- and executable for all files in |lines_for_coverage|.
- Args:
- lines_for_coverage: A dict mapping Java source file paths to lists of line
- numbers.
- Returns:
- A dict containing coverage stats for the given dict of files and lines.
- Contains absolute coverage stats for each file, coverage stats for each
- file's lines specified in |lines_for_coverage|, line by line coverage
- for each file, and overall coverage stats for the lines specified in
- |lines_for_coverage|.
- """
- file_coverage = {}
- for file_path, line_numbers in lines_for_coverage.items():
- file_coverage_dict = self.GetCoverageDictForFile(file_path, line_numbers)
- if file_coverage_dict:
- file_coverage[file_path] = file_coverage_dict
- else:
- logging.warning(
- 'No code coverage data for %s, skipping.', file_path)
- covered_statuses = [s['incremental'] for s in file_coverage.values()]
- num_covered_lines = sum(s['covered'] for s in covered_statuses)
- num_total_lines = sum(s['total'] for s in covered_statuses)
- return {
- 'files': file_coverage,
- 'patch': {
- 'incremental': {
- 'covered': num_covered_lines,
- 'total': num_total_lines
- }
- }
- }
- def GetCoverageDictForFile(self, file_path, line_numbers):
- """Returns a dict containing detailed coverage info for the given file.
- Args:
- file_path: The path to the Java source file that we want to create the
- coverage dict for.
- line_numbers: A list of integer line numbers to retrieve additional stats
- for.
- Returns:
- A dict containing absolute, incremental, and line by line coverage for
- a file.
- """
- if file_path not in self._source_to_emma:
- return None
- emma_file = self._source_to_emma[file_path]
- total_line_coverage = self._emma_parser.GetLineCoverage(emma_file)
- incremental_line_coverage = [line for line in total_line_coverage
- if line.lineno in line_numbers]
- line_by_line_coverage = [
- {
- 'line': line.source,
- 'coverage': line.covered_status,
- 'changed': line.lineno in line_numbers,
- 'fractional_coverage': line.fractional_line_coverage,
- }
- for line in total_line_coverage
- ]
- total_covered_lines, total_lines = (
- self.GetSummaryStatsForLines(total_line_coverage))
- incremental_covered_lines, incremental_total_lines = (
- self.GetSummaryStatsForLines(incremental_line_coverage))
- file_coverage_stats = {
- 'absolute': {
- 'covered': total_covered_lines,
- 'total': total_lines
- },
- 'incremental': {
- 'covered': incremental_covered_lines,
- 'total': incremental_total_lines
- },
- 'source': line_by_line_coverage,
- }
- return file_coverage_stats
- # pylint: disable=no-self-use
- def GetSummaryStatsForLines(self, line_coverage):
- """Gets summary stats for a given list of LineCoverage objects.
- Args:
- line_coverage: A list of LineCoverage objects.
- Returns:
- A tuple containing the number of lines that are covered and the total
- number of lines that are executable, respectively
- """
- partially_covered_sum = 0
- covered_status_totals = {COVERED: 0, NOT_COVERED: 0, PARTIALLY_COVERED: 0}
- for line in line_coverage:
- status = line.covered_status
- if status == NOT_EXECUTABLE:
- continue
- covered_status_totals[status] += 1
- if status == PARTIALLY_COVERED:
- partially_covered_sum += line.fractional_line_coverage
- total_covered = covered_status_totals[COVERED] + partially_covered_sum
- total_lines = sum(covered_status_totals.values())
- return total_covered, total_lines
- def _GetSourceFileToEmmaFileDict(self, files):
- """Gets a dict used to correlate Java source files with EMMA HTML files.
- This method gathers the information needed to correlate EMMA HTML
- files with Java source files. EMMA XML and plain text reports do not provide
- line by line coverage data, so HTML reports must be used instead.
- Unfortunately, the HTML files that are created are given garbage names
- (i.e 1.html) so we need to manually correlate EMMA HTML files
- with the original Java source files.
- Args:
- files: A list of file names for which coverage information is desired.
- Returns:
- A dict mapping Java source file paths to EMMA HTML file paths.
- """
- # Maps Java source file paths to package names.
- # Example: /usr/code/file.java -> org.chromium.file.java.
- source_to_package = {}
- for file_path in files:
- package = self.GetPackageNameFromFile(file_path)
- if package:
- source_to_package[file_path] = package
- else:
- logging.warning("Skipping %s because it doesn\'t have a package "
- "statement.", file_path)
- # Maps package names to EMMA report HTML files.
- # Example: org.chromium.file.java -> out/coverage/1a.html.
- package_to_emma = self._emma_parser.GetPackageNameToEmmaFileDict()
- # Finally, we have a dict mapping Java file paths to EMMA report files.
- # Example: /usr/code/file.java -> out/coverage/1a.html.
- source_to_emma = {
- source: package_to_emma[package]
- for source, package in source_to_package.items()
- if package in package_to_emma
- }
- return source_to_emma
- @staticmethod
- def NeedsCoverage(file_path):
- """Checks to see if the file needs to be analyzed for code coverage.
- Args:
- file_path: A string representing path to the file.
- Returns:
- True for Java files that exist, False for all others.
- """
- if os.path.splitext(file_path)[1] == '.java' and os.path.exists(file_path):
- return True
- logging.info('Skipping file %s, cannot compute code coverage.', file_path)
- return False
- @staticmethod
- def GetPackageNameFromFile(file_path):
- """Gets the full package name including the file name for a given file path.
- Args:
- file_path: String representing the path to the Java source file.
- Returns:
- A string representing the full package name with file name appended or
- None if there is no package statement in the file.
- """
- with open(file_path) as f:
- file_content = f.read()
- package_match = re.search(_EmmaCoverageStats.RE_PACKAGE, file_content)
- if package_match:
- package = package_match.group(_EmmaCoverageStats.RE_PACKAGE_MATCH_GROUP)
- file_name = os.path.basename(file_path)
- return '%s.%s' % (package, file_name)
- return None
- def GenerateCoverageReport(line_coverage_file, out_file_path, coverage_dir):
- """Generates a coverage report for a given set of lines.
- Writes the results of the coverage analysis to the file specified by
- |out_file_path|.
- Args:
- line_coverage_file: The path to a file which contains a dict mapping file
- names to lists of line numbers. Example: {file1: [1, 2, 3], ...} means
- that we should compute coverage information on lines 1 - 3 for file1.
- out_file_path: A string representing the location to write the JSON report.
- coverage_dir: A string representing the file path where the EMMA
- HTML coverage files are located (i.e. folder where index.html is located).
- """
- with open(line_coverage_file) as f:
- potential_files_for_coverage = json.load(f)
- files_for_coverage = {
- f: lines
- for f, lines in potential_files_for_coverage.items()
- if _EmmaCoverageStats.NeedsCoverage(f)
- }
- coverage_results = {}
- if files_for_coverage:
- code_coverage = _EmmaCoverageStats(coverage_dir,
- list(files_for_coverage.keys()))
- coverage_results = code_coverage.GetCoverageDict(files_for_coverage)
- else:
- logging.info('No Java files requiring coverage were included in %s.',
- line_coverage_file)
- with open(out_file_path, 'w+') as out_status_file:
- json.dump(coverage_results, out_status_file)
- def main():
- argparser = argparse.ArgumentParser()
- argparser.add_argument('--out', required=True, type=str,
- help='Report output file path.')
- argparser.add_argument('--emma-dir', required=True, type=str,
- help='EMMA HTML report directory.')
- argparser.add_argument('--lines-for-coverage-file', required=True, type=str,
- help='File containing a JSON object. Should contain a '
- 'dict mapping file names to lists of line numbers of '
- 'code for which coverage information is desired.')
- argparser.add_argument('-v', '--verbose', action='count',
- help='Print verbose log information.')
- args = argparser.parse_args()
- run_tests_helper.SetLogLevel(args.verbose)
- devil_chromium.Initialize()
- GenerateCoverageReport(args.lines_for_coverage_file, args.out, args.emma_dir)
- if __name__ == '__main__':
- sys.exit(main())
|