# Copyright 2018 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
#
# The script intentionally does not have a shebang, as it is Py2/Py3 compatible.
import argparse
from collections import defaultdict
import functools
import json
import logging
import os
import re
import shutil
import subprocess
import sys
# Appends third_party/ so that coverage_utils can import jinja2 from
# third_party/.
sys.path.append(
os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir,
'third_party'))
import jinja2
# The default name of the html coverage report for a directory.
DIRECTORY_COVERAGE_HTML_REPORT_NAME = os.extsep.join(['report', 'html'])
# Name of the html index files for different views.
COMPONENT_VIEW_INDEX_FILE = os.extsep.join(['component_view_index', 'html'])
DIRECTORY_VIEW_INDEX_FILE = os.extsep.join(['directory_view_index', 'html'])
FILE_VIEW_INDEX_FILE = os.extsep.join(['file_view_index', 'html'])
INDEX_HTML_FILE = os.extsep.join(['index', 'html'])
REPORT_DIR = 'coverage'
class CoverageSummary(object):
"""Encapsulates coverage summary representation."""
def __init__(self,
regions_total=0,
regions_covered=0,
functions_total=0,
functions_covered=0,
lines_total=0,
lines_covered=0):
"""Initializes CoverageSummary object."""
self._summary = {
'regions': {
'total': regions_total,
'covered': regions_covered
},
'functions': {
'total': functions_total,
'covered': functions_covered
},
'lines': {
'total': lines_total,
'covered': lines_covered
}
}
def Get(self):
"""Returns summary as a dictionary."""
return self._summary
def AddSummary(self, other_summary):
"""Adds another summary to this one element-wise."""
for feature in self._summary:
self._summary[feature]['total'] += other_summary.Get()[feature]['total']
self._summary[feature]['covered'] += other_summary.Get()[feature][
'covered']
class CoverageReportHtmlGenerator(object):
"""Encapsulates coverage html report generation.
The generated html has a table that contains links to other coverage reports.
"""
def __init__(self, output_dir, output_path, table_entry_type):
"""Initializes _CoverageReportHtmlGenerator object.
Args:
output_dir: Path to the dir for writing coverage report to.
output_path: Path to the html report that will be generated.
table_entry_type: Type of the table entries to be displayed in the table
header. For example: 'Path', 'Component'.
"""
css_file_name = os.extsep.join(['style', 'css'])
css_absolute_path = os.path.join(output_dir, css_file_name)
assert os.path.exists(css_absolute_path), (
'css file doesn\'t exit. Please make sure "llvm-cov show -format=html" '
'is called first, and the css file is generated at: "%s".' %
css_absolute_path)
self._css_absolute_path = css_absolute_path
self._output_dir = output_dir
self._output_path = output_path
self._table_entry_type = table_entry_type
self._table_entries = []
self._total_entry = {}
source_dir = os.path.dirname(os.path.realpath(__file__))
template_dir = os.path.join(source_dir, 'html_templates')
jinja_env = jinja2.Environment(
loader=jinja2.FileSystemLoader(template_dir), trim_blocks=True)
self._header_template = jinja_env.get_template('header.html')
self._table_template = jinja_env.get_template('table.html')
self._footer_template = jinja_env.get_template('footer.html')
self._style_overrides = open(
os.path.join(source_dir, 'static', 'css', 'style.css')).read()
def AddLinkToAnotherReport(self, html_report_path, name, summary):
"""Adds a link to another html report in this report.
The link to be added is assumed to be an entry in this directory.
"""
# Use relative paths instead of absolute paths to make the generated reports
# portable.
html_report_relative_path = GetRelativePathToDirectoryOfFile(
html_report_path, self._output_path)
table_entry = self._CreateTableEntryFromCoverageSummary(
summary, html_report_relative_path, name,
os.path.basename(html_report_path) ==
DIRECTORY_COVERAGE_HTML_REPORT_NAME)
self._table_entries.append(table_entry)
def CreateTotalsEntry(self, summary):
"""Creates an entry corresponds to the 'Totals' row in the html report."""
self._total_entry = self._CreateTableEntryFromCoverageSummary(summary)
def _CreateTableEntryFromCoverageSummary(self,
summary,
href=None,
name=None,
is_dir=None):
"""Creates an entry to display in the html report."""
assert (href is None and name is None and is_dir is None) or (
href is not None and name is not None and is_dir is not None), (
'The only scenario when href or name or is_dir can be None is when '
'creating an entry for the Totals row, and in that case, all three '
'attributes must be None.')
entry = {}
if href is not None:
entry['href'] = href
if name is not None:
entry['name'] = name
if is_dir is not None:
entry['is_dir'] = is_dir
summary_dict = summary.Get()
for feature in summary_dict:
if summary_dict[feature]['total'] == 0:
percentage = 0.0
else:
percentage = float(summary_dict[feature]
['covered']) / summary_dict[feature]['total'] * 100
color_class = self._GetColorClass(percentage)
entry[feature] = {
'total': summary_dict[feature]['total'],
'covered': summary_dict[feature]['covered'],
'percentage': '{:6.2f}'.format(percentage),
'color_class': color_class
}
return entry
def _GetColorClass(self, percentage):
"""Returns the css color class based on coverage percentage."""
if percentage >= 0 and percentage < 80:
return 'red'
if percentage >= 80 and percentage < 100:
return 'yellow'
if percentage == 100:
return 'green'
assert False, 'Invalid coverage percentage: "%d".' % percentage
def WriteHtmlCoverageReport(self, no_component_view, no_file_view):
"""Writes html coverage report.
In the report, sub-directories are displayed before files and within each
category, entries are sorted alphabetically.
"""
def EntryCmp(left, right):
"""Compare function for table entries."""
if left['is_dir'] != right['is_dir']:
return -1 if left['is_dir'] == True else 1
return -1 if left['name'] < right['name'] else 1
self._table_entries = sorted(
self._table_entries, key=functools.cmp_to_key(EntryCmp))
css_path = os.path.join(self._output_dir, os.extsep.join(['style', 'css']))
directory_view_path = GetDirectoryViewPath(self._output_dir)
directory_view_href = GetRelativePathToDirectoryOfFile(
directory_view_path, self._output_path)
component_view_href = None
if not no_component_view:
component_view_path = GetComponentViewPath(self._output_dir)
component_view_href = GetRelativePathToDirectoryOfFile(
component_view_path, self._output_path)
# File view is optional in the report.
file_view_href = None
if not no_file_view:
file_view_path = GetFileViewPath(self._output_dir)
file_view_href = GetRelativePathToDirectoryOfFile(file_view_path,
self._output_path)
html_header = self._header_template.render(
css_path=GetRelativePathToDirectoryOfFile(css_path, self._output_path),
directory_view_href=directory_view_href,
component_view_href=component_view_href,
file_view_href=file_view_href,
style_overrides=self._style_overrides)
html_table = self._table_template.render(
entries=self._table_entries,
total_entry=self._total_entry,
table_entry_type=self._table_entry_type)
html_footer = self._footer_template.render()
if not os.path.exists(os.path.dirname(self._output_path)):
os.makedirs(os.path.dirname(self._output_path))
with open(self._output_path, 'w') as html_file:
html_file.write(html_header + html_table + html_footer)
class CoverageReportPostProcessor(object):
"""Post processing of code coverage reports produced by llvm-cov."""
def __init__(self,
output_dir,
src_root_dir,
summary_data,
no_component_view,
no_file_view,
component_mappings={},
path_equivalence=None):
"""Initializes CoverageReportPostProcessor object."""
# Caller provided parameters.
self.output_dir = output_dir
self.src_root_dir = os.path.normpath(GetFullPath(src_root_dir))
if not self.src_root_dir.endswith(os.sep):
self.src_root_dir += os.sep
self.summary_data = json.loads(summary_data)
assert len(self.summary_data['data']) == 1
self.no_component_view = no_component_view
self.no_file_view = no_file_view
# Mapping from components to directories
self.component_to_directories = None
if component_mappings:
self._ExtractComponentToDirectoriesMapping(component_mappings)
# The root directory that contains all generated coverage html reports.
self.report_root_dir = GetCoverageReportRootDirPath(self.output_dir)
# The root directory that all coverage html files generated by llvm-cov.
self.html_file_root_dir = GetHtmlFileRootDirPath(self.output_dir)
# Path to the HTML file for the component view.
self.component_view_path = GetComponentViewPath(self.output_dir)
# Path to the HTML file for the directory view.
self.directory_view_path = GetDirectoryViewPath(self.output_dir)
# Path to the HTML file for the file view.
self.file_view_path = GetFileViewPath(self.output_dir)
# Path to the main HTML index file.
self.html_index_path = GetHtmlIndexPath(self.output_dir)
self.path_map = None
if path_equivalence:
def _PreparePath(path):
path = os.path.normpath(path)
if not path.endswith(os.sep):
# A normalized path does not end with '/', unless it is a root dir.
path += os.sep
return path
self.path_map = [_PreparePath(p) for p in path_equivalence.split(',')]
assert len(self.path_map) == 2, 'Path equivalence argument is incorrect.'
def _ExtractComponentToDirectoriesMapping(self, component_mappings):
"""Initializes a mapping from components to directories."""
directory_to_component = component_mappings['dir-to-component']
self.component_to_directories = defaultdict(list)
for directory in sorted(directory_to_component):
component = directory_to_component[directory]
# Check if we already added the parent directory of this directory. If
# yes,skip this sub-directory to avoid double-counting.
found_parent_directory = False
for component_directory in self.component_to_directories[component]:
if directory.startswith(component_directory + '/'):
found_parent_directory = True
break
if not found_parent_directory:
self.component_to_directories[component].append(directory)
def _MapToLocal(self, path):
"""Maps a path from the coverage data to a local path."""
if not self.path_map:
return path
return path.replace(self.path_map[0], self.path_map[1], 1)
def CalculatePerDirectoryCoverageSummary(self, per_file_coverage_summary):
"""Calculates per directory coverage summary."""
logging.debug('Calculating per-directory coverage summary.')
per_directory_coverage_summary = defaultdict(lambda: CoverageSummary())
for file_path in per_file_coverage_summary:
summary = per_file_coverage_summary[file_path]
parent_dir = os.path.dirname(file_path)
while True:
per_directory_coverage_summary[parent_dir].AddSummary(summary)
if os.path.normpath(parent_dir) == os.path.normpath(self.src_root_dir):
break
parent_dir = os.path.dirname(parent_dir)
logging.debug('Finished calculating per-directory coverage summary.')
return per_directory_coverage_summary
def CalculatePerComponentCoverageSummary(self,
per_directory_coverage_summary):
"""Calculates per component coverage summary."""
logging.debug('Calculating per-component coverage summary.')
per_component_coverage_summary = defaultdict(lambda: CoverageSummary())
for component in self.component_to_directories:
for directory in self.component_to_directories[component]:
absolute_directory_path = GetFullPath(directory)
if absolute_directory_path in per_directory_coverage_summary:
per_component_coverage_summary[component].AddSummary(
per_directory_coverage_summary[absolute_directory_path])
logging.debug('Finished calculating per-component coverage summary.')
return per_component_coverage_summary
def GeneratePerComponentCoverageInHtml(self, per_component_coverage_summary,
per_directory_coverage_summary):
"""Generates per-component coverage reports in html."""
logging.debug('Writing per-component coverage html reports.')
for component in per_component_coverage_summary:
self.GenerateCoverageInHtmlForComponent(component,
per_component_coverage_summary,
per_directory_coverage_summary)
logging.debug('Finished writing per-component coverage html reports.')
def GenerateComponentViewHtmlIndexFile(self, per_component_coverage_summary):
"""Generates the html index file for component view."""
component_view_index_file_path = self.component_view_path
logging.debug('Generating component view html index file as: "%s".',
component_view_index_file_path)
html_generator = CoverageReportHtmlGenerator(
self.output_dir, component_view_index_file_path, 'Component')
for component in per_component_coverage_summary:
html_generator.AddLinkToAnotherReport(
self.GetCoverageHtmlReportPathForComponent(component), component,
per_component_coverage_summary[component])
# Do not create a totals row for the component view as the value is
# incorrect due to failure to account for UNKNOWN component and some paths
# belonging to multiple components.
html_generator.WriteHtmlCoverageReport(self.no_component_view,
self.no_file_view)
logging.debug('Finished generating component view html index file.')
def GenerateCoverageInHtmlForComponent(self, component_name,
per_component_coverage_summary,
per_directory_coverage_summary):
"""Generates coverage html report for a component."""
component_html_report_path = self.GetCoverageHtmlReportPathForComponent(
component_name)
component_html_report_dir = os.path.dirname(component_html_report_path)
if not os.path.exists(component_html_report_dir):
os.makedirs(component_html_report_dir)
html_generator = CoverageReportHtmlGenerator(
self.output_dir, component_html_report_path, 'Path')
for dir_path in self.component_to_directories[component_name]:
dir_absolute_path = GetFullPath(dir_path)
if dir_absolute_path not in per_directory_coverage_summary:
# Any directory without an exercised file shouldn't be included into
# the report.
continue
html_generator.AddLinkToAnotherReport(
self.GetCoverageHtmlReportPathForDirectory(dir_path),
os.path.relpath(dir_path, self.src_root_dir),
per_directory_coverage_summary[dir_absolute_path])
html_generator.CreateTotalsEntry(
per_component_coverage_summary[component_name])
html_generator.WriteHtmlCoverageReport(self.no_component_view,
self.no_file_view)
def GetCoverageHtmlReportPathForComponent(self, component_name):
"""Given a component, returns the corresponding html report path."""
component_file_name = component_name.lower().replace('>', '-')
html_report_name = os.extsep.join([component_file_name, 'html'])
return os.path.join(self.report_root_dir, 'components', html_report_name)
def GetCoverageHtmlReportPathForDirectory(self, dir_path):
"""Given a directory path, returns the corresponding html report path."""
assert os.path.isdir(
self._MapToLocal(dir_path)), '"%s" is not a directory.' % dir_path
html_report_path = os.path.join(
GetFullPath(dir_path), DIRECTORY_COVERAGE_HTML_REPORT_NAME)
return self.CombineAbsolutePaths(self.report_root_dir, html_report_path)
def GetCoverageHtmlReportPathForFile(self, file_path):
"""Given a file path, returns the corresponding html report path."""
assert os.path.isfile(
self._MapToLocal(file_path)), '"%s" is not a file.' % file_path
html_report_path = os.extsep.join([GetFullPath(file_path), 'html'])
return self.CombineAbsolutePaths(self.html_file_root_dir, html_report_path)
def CombineAbsolutePaths(self, path1, path2):
if GetHostPlatform() == 'win':
# Absolute paths in Windows may start with a drive letter and colon.
# Remove them from the second path before appending to the first.
_, path2 = os.path.splitdrive(path2)
# '+' is used instead of os.path.join because both of them are absolute
# paths and os.path.join ignores the first path.
return path1 + path2
def GenerateFileViewHtmlIndexFile(self, per_file_coverage_summary,
file_view_index_file_path):
"""Generates html index file for file view."""
logging.debug('Generating file view html index file as: "%s".',
file_view_index_file_path)
html_generator = CoverageReportHtmlGenerator(
self.output_dir, file_view_index_file_path, 'Path')
totals_coverage_summary = CoverageSummary()
for file_path in per_file_coverage_summary:
if not os.path.isfile(self._MapToLocal(file_path)):
logging.warning('%s is not a file.', file_path)
continue
totals_coverage_summary.AddSummary(per_file_coverage_summary[file_path])
html_generator.AddLinkToAnotherReport(
self.GetCoverageHtmlReportPathForFile(file_path),
os.path.relpath(file_path, self.src_root_dir),
per_file_coverage_summary[file_path])
html_generator.CreateTotalsEntry(totals_coverage_summary)
html_generator.WriteHtmlCoverageReport(self.no_component_view,
self.no_file_view)
logging.debug('Finished generating file view html index file.')
def GeneratePerFileCoverageSummary(self):
"""Generate per file coverage summary using coverage data in JSON format."""
files_coverage_data = self.summary_data['data'][0]['files']
per_file_coverage_summary = {}
for file_coverage_data in files_coverage_data:
file_path = os.path.normpath(file_coverage_data['filename'])
assert file_path.startswith(self.src_root_dir), (
'File path "%s" in coverage summary is outside source checkout.' %
file_path)
summary = file_coverage_data['summary']
if summary['lines']['count'] == 0:
continue
per_file_coverage_summary[file_path] = CoverageSummary(
regions_total=summary['regions']['count'],
regions_covered=summary['regions']['covered'],
functions_total=summary['functions']['count'],
functions_covered=summary['functions']['covered'],
lines_total=summary['lines']['count'],
lines_covered=summary['lines']['covered'])
logging.debug('Finished generating per-file code coverage summary.')
return per_file_coverage_summary
def GeneratePerDirectoryCoverageInHtml(self, per_directory_coverage_summary,
per_file_coverage_summary):
"""Generates per directory coverage breakdown in html."""
logging.debug('Writing per-directory coverage html reports.')
for dir_path in per_directory_coverage_summary:
self.GenerateCoverageInHtmlForDirectory(
dir_path, per_directory_coverage_summary, per_file_coverage_summary)
logging.debug('Finished writing per-directory coverage html reports.')
def GenerateCoverageInHtmlForDirectory(self, dir_path,
per_directory_coverage_summary,
per_file_coverage_summary):
"""Generates coverage html report for a single directory."""
html_generator = CoverageReportHtmlGenerator(
self.output_dir, self.GetCoverageHtmlReportPathForDirectory(dir_path),
'Path')
for entry_name in os.listdir(self._MapToLocal(dir_path)):
entry_path = os.path.normpath(os.path.join(dir_path, entry_name))
if entry_path in per_file_coverage_summary:
entry_html_report_path = self.GetCoverageHtmlReportPathForFile(
entry_path)
entry_coverage_summary = per_file_coverage_summary[entry_path]
elif entry_path in per_directory_coverage_summary:
entry_html_report_path = self.GetCoverageHtmlReportPathForDirectory(
entry_path)
entry_coverage_summary = per_directory_coverage_summary[entry_path]
else:
# Any file without executable lines shouldn't be included into the
# report. For example, OWNER and README.md files.
continue
html_generator.AddLinkToAnotherReport(entry_html_report_path,
os.path.basename(entry_path),
entry_coverage_summary)
html_generator.CreateTotalsEntry(per_directory_coverage_summary[dir_path])
html_generator.WriteHtmlCoverageReport(self.no_component_view,
self.no_file_view)
def GenerateDirectoryViewHtmlIndexFile(self):
"""Generates the html index file for directory view.
Note that the index file is already generated under src_root_dir, so this
file simply redirects to it, and the reason of this extra layer is for
structural consistency with other views.
"""
directory_view_index_file_path = self.directory_view_path
logging.debug('Generating directory view html index file as: "%s".',
directory_view_index_file_path)
src_root_html_report_path = self.GetCoverageHtmlReportPathForDirectory(
self.src_root_dir)
WriteRedirectHtmlFile(directory_view_index_file_path,
src_root_html_report_path)
logging.debug('Finished generating directory view html index file.')
def OverwriteHtmlReportsIndexFile(self):
"""Overwrites the root index file to redirect to the default view."""
html_index_file_path = self.html_index_path
directory_view_index_file_path = self.directory_view_path
WriteRedirectHtmlFile(html_index_file_path, directory_view_index_file_path)
def CleanUpOutputDir(self):
"""Perform a cleanup of the output dir."""
# Remove the default index.html file produced by llvm-cov.
index_path = os.path.join(self.output_dir, INDEX_HTML_FILE)
if os.path.exists(index_path):
os.remove(index_path)
def PrepareHtmlReport(self):
per_file_coverage_summary = self.GeneratePerFileCoverageSummary()
if not self.no_file_view:
self.GenerateFileViewHtmlIndexFile(per_file_coverage_summary,
self.file_view_path)
per_directory_coverage_summary = self.CalculatePerDirectoryCoverageSummary(
per_file_coverage_summary)
self.GeneratePerDirectoryCoverageInHtml(per_directory_coverage_summary,
per_file_coverage_summary)
self.GenerateDirectoryViewHtmlIndexFile()
if not self.no_component_view:
per_component_coverage_summary = (
self.CalculatePerComponentCoverageSummary(
per_directory_coverage_summary))
self.GeneratePerComponentCoverageInHtml(per_component_coverage_summary,
per_directory_coverage_summary)
self.GenerateComponentViewHtmlIndexFile(per_component_coverage_summary)
# The default index file is generated only for the list of source files,
# needs to overwrite it to display per directory coverage view by default.
self.OverwriteHtmlReportsIndexFile()
self.CleanUpOutputDir()
html_index_file_path = 'file://' + GetFullPath(self.html_index_path)
logging.info('Index file for html report is generated as: "%s".',
html_index_file_path)
def ConfigureLogging(verbose=False, log_file=None):
"""Configures logging settings for later use."""
log_level = logging.DEBUG if verbose else logging.INFO
log_format = '[%(asctime)s %(levelname)s] %(message)s'
logging.basicConfig(filename=log_file, level=log_level, format=log_format)
def GetComponentViewPath(output_dir):
"""Path to the HTML file for the component view."""
return os.path.join(
GetCoverageReportRootDirPath(output_dir), COMPONENT_VIEW_INDEX_FILE)
def GetCoverageReportRootDirPath(output_dir):
"""The root directory that contains all generated coverage html reports."""
return os.path.join(output_dir, GetHostPlatform())
def GetHtmlFileRootDirPath(output_dir):
"""The directory that contains llvm-cov generated coverage html reports. """
return os.path.join(output_dir, REPORT_DIR)
def GetDirectoryViewPath(output_dir):
"""Path to the HTML file for the directory view."""
return os.path.join(
GetCoverageReportRootDirPath(output_dir), DIRECTORY_VIEW_INDEX_FILE)
def GetFileViewPath(output_dir):
"""Path to the HTML file for the file view."""
return os.path.join(
GetCoverageReportRootDirPath(output_dir), FILE_VIEW_INDEX_FILE)
def GetHtmlIndexPath(output_dir):
"""Path to the main HTML index file."""
return os.path.join(GetCoverageReportRootDirPath(output_dir), INDEX_HTML_FILE)
def GetFullPath(path):
"""Return full absolute path."""
return os.path.abspath(os.path.expandvars(os.path.expanduser(path)))
def GetHostPlatform():
"""Returns the host platform.
This is separate from the target platform/os that coverage is running for.
"""
if sys.platform == 'win32' or sys.platform == 'cygwin':
return 'win'
if sys.platform.startswith('linux'):
return 'linux'
else:
assert sys.platform == 'darwin'
return 'mac'
def GetRelativePathToDirectoryOfFile(target_path, base_path):
"""Returns a target path relative to the directory of base_path.
This method requires base_path to be a file, otherwise, one should call
os.path.relpath directly.
"""
assert os.path.dirname(base_path) != base_path, (
'Base path: "%s" is a directory, please call os.path.relpath directly.' %
base_path)
base_dir = os.path.dirname(base_path)
return os.path.relpath(target_path, base_dir)
def GetSharedLibraries(binary_paths, build_dir, otool_path):
"""Returns list of shared libraries used by specified binaries."""
logging.info('Finding shared libraries for targets (if any).')
shared_libraries = []
cmd = []
shared_library_re = None
if sys.platform.startswith('linux'):
cmd.extend(['ldd'])
shared_library_re = re.compile(r'.*\.so[.0-9]*\s=>\s(.*' + build_dir +
r'.*\.so[.0-9]*)\s.*')
elif sys.platform.startswith('darwin'):
otool = otool_path if otool_path else 'otool'
cmd.extend([otool, '-L'])
shared_library_re = re.compile(r'\s+(@rpath/.*\.dylib)\s.*')
else:
assert False, 'Cannot detect shared libraries used by the given targets.'
assert shared_library_re is not None
cmd.extend(binary_paths)
output = subprocess.check_output(cmd).decode('utf-8', 'ignore')
for line in output.splitlines():
m = shared_library_re.match(line)
if not m:
continue
shared_library_path = m.group(1)
if sys.platform.startswith('darwin'):
# otool outputs "@rpath" macro instead of the dirname of the given binary.
shared_library_path = shared_library_path.replace('@rpath', build_dir)
if shared_library_path in shared_libraries:
continue
assert os.path.exists(shared_library_path), ('Shared library "%s" used by '
'the given target(s) does not '
'exist.' % shared_library_path)
with open(shared_library_path, 'rb') as f:
data = f.read()
# Do not add non-instrumented libraries. Otherwise, llvm-cov errors outs.
if b'__llvm_cov' in data:
shared_libraries.append(shared_library_path)
logging.debug('Found shared libraries (%d): %s.', len(shared_libraries),
shared_libraries)
logging.info('Finished finding shared libraries for targets.')
return shared_libraries
def WriteRedirectHtmlFile(from_html_path, to_html_path):
"""Writes a html file that redirects to another html file."""
to_html_relative_path = GetRelativePathToDirectoryOfFile(
to_html_path, from_html_path)
content = ("""
<!DOCTYPE html>
<html>
<head>
<!-- HTML meta refresh URL redirection -->
<meta http-equiv="refresh" content="0; url=%s">
</head>
</html>""" % to_html_relative_path)
with open(from_html_path, 'w') as f:
f.write(content)
def _CmdSharedLibraries(args):
"""Handles 'shared_libs' command."""
if not args.object:
logging.error('No binaries are specified.')
return 1
library_paths = GetSharedLibraries(args.object, args.build_dir, None)
if not library_paths:
return 0
# Print output in the format that can be passed to llvm-cov tool.
output = ' '.join(
'-object=%s' % os.path.normpath(path) for path in library_paths)
print(output)
return 0
def _CmdPostProcess(args):
"""Handles 'post_process' command."""
with open(args.summary_file) as f:
summary_data = f.read()
processor = CoverageReportPostProcessor(
args.output_dir,
args.src_root_dir,
summary_data,
no_component_view=True,
no_file_view=False,
path_equivalence=args.path_equivalence)
processor.PrepareHtmlReport()
def Main():
parser = argparse.ArgumentParser(
'coverage_utils', description='Code coverage utils.')
parser.add_argument(
'-v',
'--verbose',
action='store_true',
help='Prints additional debug output.')
subparsers = parser.add_subparsers(dest='command')
shared_libs_parser = subparsers.add_parser(
'shared_libs', help='Detect shared libraries.')
shared_libs_parser.add_argument(
'-build-dir', help='Path to the build dir.', required=True)
shared_libs_parser.add_argument(
'-object',
action='append',
help='Path to the binary using shared libs.',
required=True)
post_processing_parser = subparsers.add_parser(
'post_process', help='Post process a report.')
post_processing_parser.add_argument(
'-output-dir', help='Path to the report dir.', required=True)
post_processing_parser.add_argument(
'-src-root-dir', help='Path to the src root dir.', required=True)
post_processing_parser.add_argument(
'-summary-file', help='Path to the summary file.', required=True)
post_processing_parser.add_argument(
'-path-equivalence',
help='Map the paths in the coverage data to local '
'source files path (=<from>,<to>)')
args = parser.parse_args()
ConfigureLogging(args.verbose)
if args.command == 'shared_libs':
return _CmdSharedLibraries(args)
elif args.command == 'post_process':
return _CmdPostProcess(args)
else:
parser.print_help(sys.stderr)
if __name__ == '__main__':
sys.exit(Main())
Codebase Browser
chromium