mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
689 lines
26 KiB
Python
689 lines
26 KiB
Python
"""Core control stuff for Coverage."""
|
|
|
|
import atexit, os, random, socket, sys
|
|
|
|
from coverage.annotate import AnnotateReporter
|
|
from coverage.backward import string_class
|
|
from coverage.codeunit import code_unit_factory, CodeUnit
|
|
from coverage.collector import Collector
|
|
from coverage.config import CoverageConfig
|
|
from coverage.data import CoverageData
|
|
from coverage.files import FileLocator, TreeMatcher, FnmatchMatcher
|
|
from coverage.files import PathAliases, find_python_files
|
|
from coverage.html import HtmlReporter
|
|
from coverage.misc import CoverageException, bool_or_none, join_regex
|
|
from coverage.results import Analysis, Numbers
|
|
from coverage.summary import SummaryReporter
|
|
from coverage.xmlreport import XmlReporter
|
|
|
|
class coverage(object):
|
|
"""Programmatic access to Coverage.
|
|
|
|
To use::
|
|
|
|
from coverage import coverage
|
|
|
|
cov = coverage()
|
|
cov.start()
|
|
#.. blah blah (run your code) blah blah ..
|
|
cov.stop()
|
|
cov.html_report(directory='covhtml')
|
|
|
|
"""
|
|
def __init__(self, data_file=None, data_suffix=None, cover_pylib=None,
|
|
auto_data=False, timid=None, branch=None, config_file=True,
|
|
source=None, omit=None, include=None):
|
|
"""
|
|
`data_file` is the base name of the data file to use, defaulting to
|
|
".coverage". `data_suffix` is appended (with a dot) to `data_file` to
|
|
create the final file name. If `data_suffix` is simply True, then a
|
|
suffix is created with the machine and process identity included.
|
|
|
|
`cover_pylib` is a boolean determining whether Python code installed
|
|
with the Python interpreter is measured. This includes the Python
|
|
standard library and any packages installed with the interpreter.
|
|
|
|
If `auto_data` is true, then any existing data file will be read when
|
|
coverage measurement starts, and data will be saved automatically when
|
|
measurement stops.
|
|
|
|
If `timid` is true, then a slower and simpler trace function will be
|
|
used. This is important for some environments where manipulation of
|
|
tracing functions breaks the faster trace function.
|
|
|
|
If `branch` is true, then branch coverage will be measured in addition
|
|
to the usual statement coverage.
|
|
|
|
`config_file` determines what config file to read. If it is a string,
|
|
it is the name of the config file to read. If it is True, then a
|
|
standard file is read (".coveragerc"). If it is False, then no file is
|
|
read.
|
|
|
|
`source` is a list of file paths or package names. Only code located
|
|
in the trees indicated by the file paths or package names will be
|
|
measured.
|
|
|
|
`include` and `omit` are lists of filename patterns. Files that match
|
|
`include` will be measured, files that match `omit` will not. Each
|
|
will also accept a single string argument.
|
|
|
|
"""
|
|
from coverage import __version__
|
|
|
|
# A record of all the warnings that have been issued.
|
|
self._warnings = []
|
|
|
|
# Build our configuration from a number of sources:
|
|
# 1: defaults:
|
|
self.config = CoverageConfig()
|
|
|
|
# 2: from the coveragerc file:
|
|
if config_file:
|
|
if config_file is True:
|
|
config_file = ".coveragerc"
|
|
try:
|
|
self.config.from_file(config_file)
|
|
except ValueError:
|
|
_, err, _ = sys.exc_info()
|
|
raise CoverageException(
|
|
"Couldn't read config file %s: %s" % (config_file, err)
|
|
)
|
|
|
|
# 3: from environment variables:
|
|
self.config.from_environment('COVERAGE_OPTIONS')
|
|
env_data_file = os.environ.get('COVERAGE_FILE')
|
|
if env_data_file:
|
|
self.config.data_file = env_data_file
|
|
|
|
# 4: from constructor arguments:
|
|
if isinstance(omit, string_class):
|
|
omit = [omit]
|
|
if isinstance(include, string_class):
|
|
include = [include]
|
|
self.config.from_args(
|
|
data_file=data_file, cover_pylib=cover_pylib, timid=timid,
|
|
branch=branch, parallel=bool_or_none(data_suffix),
|
|
source=source, omit=omit, include=include
|
|
)
|
|
|
|
self.auto_data = auto_data
|
|
self.atexit_registered = False
|
|
|
|
# _exclude_re is a dict mapping exclusion list names to compiled
|
|
# regexes.
|
|
self._exclude_re = {}
|
|
self._exclude_regex_stale()
|
|
|
|
self.file_locator = FileLocator()
|
|
|
|
# The source argument can be directories or package names.
|
|
self.source = []
|
|
self.source_pkgs = []
|
|
for src in self.config.source or []:
|
|
if os.path.exists(src):
|
|
self.source.append(self.file_locator.canonical_filename(src))
|
|
else:
|
|
self.source_pkgs.append(src)
|
|
|
|
self.omit = self._prep_patterns(self.config.omit)
|
|
self.include = self._prep_patterns(self.config.include)
|
|
|
|
self.collector = Collector(
|
|
self._should_trace, timid=self.config.timid,
|
|
branch=self.config.branch, warn=self._warn
|
|
)
|
|
|
|
# Suffixes are a bit tricky. We want to use the data suffix only when
|
|
# collecting data, not when combining data. So we save it as
|
|
# `self.run_suffix` now, and promote it to `self.data_suffix` if we
|
|
# find that we are collecting data later.
|
|
if data_suffix or self.config.parallel:
|
|
if not isinstance(data_suffix, string_class):
|
|
# if data_suffix=True, use .machinename.pid.random
|
|
data_suffix = True
|
|
else:
|
|
data_suffix = None
|
|
self.data_suffix = None
|
|
self.run_suffix = data_suffix
|
|
|
|
# Create the data file. We do this at construction time so that the
|
|
# data file will be written into the directory where the process
|
|
# started rather than wherever the process eventually chdir'd to.
|
|
self.data = CoverageData(
|
|
basename=self.config.data_file,
|
|
collector="coverage v%s" % __version__
|
|
)
|
|
|
|
# The dirs for files considered "installed with the interpreter".
|
|
self.pylib_dirs = []
|
|
if not self.config.cover_pylib:
|
|
# Look at where some standard modules are located. That's the
|
|
# indication for "installed with the interpreter". In some
|
|
# environments (virtualenv, for example), these modules may be
|
|
# spread across a few locations. Look at all the candidate modules
|
|
# we've imported, and take all the different ones.
|
|
for m in (atexit, os, random, socket):
|
|
if hasattr(m, "__file__"):
|
|
m_dir = self._canonical_dir(m.__file__)
|
|
if m_dir not in self.pylib_dirs:
|
|
self.pylib_dirs.append(m_dir)
|
|
|
|
# To avoid tracing the coverage code itself, we skip anything located
|
|
# where we are.
|
|
self.cover_dir = self._canonical_dir(__file__)
|
|
|
|
# The matchers for _should_trace, created when tracing starts.
|
|
self.source_match = None
|
|
self.pylib_match = self.cover_match = None
|
|
self.include_match = self.omit_match = None
|
|
|
|
# Only _harvest_data once per measurement cycle.
|
|
self._harvested = False
|
|
|
|
# Set the reporting precision.
|
|
Numbers.set_precision(self.config.precision)
|
|
|
|
# When tearing down the coverage object, modules can become None.
|
|
# Saving the modules as object attributes avoids problems, but it is
|
|
# quite ad-hoc which modules need to be saved and which references
|
|
# need to use the object attributes.
|
|
self.socket = socket
|
|
self.os = os
|
|
self.random = random
|
|
|
|
def _canonical_dir(self, f):
|
|
"""Return the canonical directory of the file `f`."""
|
|
return os.path.split(self.file_locator.canonical_filename(f))[0]
|
|
|
|
def _source_for_file(self, filename):
|
|
"""Return the source file for `filename`."""
|
|
if not filename.endswith(".py"):
|
|
if filename[-4:-1] == ".py":
|
|
filename = filename[:-1]
|
|
return filename
|
|
|
|
def _should_trace(self, filename, frame):
|
|
"""Decide whether to trace execution in `filename`
|
|
|
|
This function is called from the trace function. As each new file name
|
|
is encountered, this function determines whether it is traced or not.
|
|
|
|
Returns a canonicalized filename if it should be traced, False if it
|
|
should not.
|
|
|
|
"""
|
|
if os is None:
|
|
return False
|
|
|
|
if filename.startswith('<'):
|
|
# Lots of non-file execution is represented with artificial
|
|
# filenames like "<string>", "<doctest readme.txt[0]>", or
|
|
# "<exec_function>". Don't ever trace these executions, since we
|
|
# can't do anything with the data later anyway.
|
|
return False
|
|
|
|
if filename.endswith(".html"):
|
|
# Jinja and maybe other templating systems compile templates into
|
|
# Python code, but use the template filename as the filename in
|
|
# the compiled code. Of course, those filenames are useless later
|
|
# so don't bother collecting. TODO: How should we really separate
|
|
# out good file extensions from bad?
|
|
return False
|
|
|
|
self._check_for_packages()
|
|
|
|
# Compiled Python files have two filenames: frame.f_code.co_filename is
|
|
# the filename at the time the .pyc was compiled. The second name is
|
|
# __file__, which is where the .pyc was actually loaded from. Since
|
|
# .pyc files can be moved after compilation (for example, by being
|
|
# installed), we look for __file__ in the frame and prefer it to the
|
|
# co_filename value.
|
|
dunder_file = frame.f_globals.get('__file__')
|
|
if dunder_file:
|
|
filename = self._source_for_file(dunder_file)
|
|
|
|
# Jython reports the .class file to the tracer, use the source file.
|
|
if filename.endswith("$py.class"):
|
|
filename = filename[:-9] + ".py"
|
|
|
|
canonical = self.file_locator.canonical_filename(filename)
|
|
|
|
# If the user specified source or include, then that's authoritative
|
|
# about the outer bound of what to measure and we don't have to apply
|
|
# any canned exclusions. If they didn't, then we have to exclude the
|
|
# stdlib and coverage.py directories.
|
|
if self.source_match:
|
|
if not self.source_match.match(canonical):
|
|
return False
|
|
elif self.include_match:
|
|
if not self.include_match.match(canonical):
|
|
return False
|
|
else:
|
|
# If we aren't supposed to trace installed code, then check if this
|
|
# is near the Python standard library and skip it if so.
|
|
if self.pylib_match and self.pylib_match.match(canonical):
|
|
return False
|
|
|
|
# We exclude the coverage code itself, since a little of it will be
|
|
# measured otherwise.
|
|
if self.cover_match and self.cover_match.match(canonical):
|
|
return False
|
|
|
|
# Check the file against the omit pattern.
|
|
if self.omit_match and self.omit_match.match(canonical):
|
|
return False
|
|
|
|
return canonical
|
|
|
|
# To log what should_trace returns, change this to "if 1:"
|
|
if 0:
|
|
_real_should_trace = _should_trace
|
|
def _should_trace(self, filename, frame): # pylint: disable=E0102
|
|
"""A logging decorator around the real _should_trace function."""
|
|
ret = self._real_should_trace(filename, frame)
|
|
print("should_trace: %r -> %r" % (filename, ret))
|
|
return ret
|
|
|
|
def _warn(self, msg):
|
|
"""Use `msg` as a warning."""
|
|
self._warnings.append(msg)
|
|
sys.stderr.write("Coverage.py warning: %s\n" % msg)
|
|
|
|
def _prep_patterns(self, patterns):
|
|
"""Prepare the file patterns for use in a `FnmatchMatcher`.
|
|
|
|
If a pattern starts with a wildcard, it is used as a pattern
|
|
as-is. If it does not start with a wildcard, then it is made
|
|
absolute with the current directory.
|
|
|
|
If `patterns` is None, an empty list is returned.
|
|
|
|
"""
|
|
patterns = patterns or []
|
|
prepped = []
|
|
for p in patterns or []:
|
|
if p.startswith("*") or p.startswith("?"):
|
|
prepped.append(p)
|
|
else:
|
|
prepped.append(self.file_locator.abs_file(p))
|
|
return prepped
|
|
|
|
def _check_for_packages(self):
|
|
"""Update the source_match matcher with latest imported packages."""
|
|
# Our self.source_pkgs attribute is a list of package names we want to
|
|
# measure. Each time through here, we see if we've imported any of
|
|
# them yet. If so, we add its file to source_match, and we don't have
|
|
# to look for that package any more.
|
|
if self.source_pkgs:
|
|
found = []
|
|
for pkg in self.source_pkgs:
|
|
try:
|
|
mod = sys.modules[pkg]
|
|
except KeyError:
|
|
continue
|
|
|
|
found.append(pkg)
|
|
|
|
try:
|
|
pkg_file = mod.__file__
|
|
except AttributeError:
|
|
self._warn("Module %s has no Python source." % pkg)
|
|
else:
|
|
d, f = os.path.split(pkg_file)
|
|
if f.startswith('__init__.'):
|
|
# This is actually a package, return the directory.
|
|
pkg_file = d
|
|
else:
|
|
pkg_file = self._source_for_file(pkg_file)
|
|
pkg_file = self.file_locator.canonical_filename(pkg_file)
|
|
self.source.append(pkg_file)
|
|
self.source_match.add(pkg_file)
|
|
|
|
for pkg in found:
|
|
self.source_pkgs.remove(pkg)
|
|
|
|
def use_cache(self, usecache):
|
|
"""Control the use of a data file (incorrectly called a cache).
|
|
|
|
`usecache` is true or false, whether to read and write data on disk.
|
|
|
|
"""
|
|
self.data.usefile(usecache)
|
|
|
|
def load(self):
|
|
"""Load previously-collected coverage data from the data file."""
|
|
self.collector.reset()
|
|
self.data.read()
|
|
|
|
def start(self):
|
|
"""Start measuring code coverage."""
|
|
if self.run_suffix:
|
|
# Calling start() means we're running code, so use the run_suffix
|
|
# as the data_suffix when we eventually save the data.
|
|
self.data_suffix = self.run_suffix
|
|
if self.auto_data:
|
|
self.load()
|
|
# Save coverage data when Python exits.
|
|
if not self.atexit_registered:
|
|
atexit.register(self.save)
|
|
self.atexit_registered = True
|
|
|
|
# Create the matchers we need for _should_trace
|
|
if self.source or self.source_pkgs:
|
|
self.source_match = TreeMatcher(self.source)
|
|
else:
|
|
if self.cover_dir:
|
|
self.cover_match = TreeMatcher([self.cover_dir])
|
|
if self.pylib_dirs:
|
|
self.pylib_match = TreeMatcher(self.pylib_dirs)
|
|
if self.include:
|
|
self.include_match = FnmatchMatcher(self.include)
|
|
if self.omit:
|
|
self.omit_match = FnmatchMatcher(self.omit)
|
|
|
|
self._harvested = False
|
|
self.collector.start()
|
|
|
|
def stop(self):
|
|
"""Stop measuring code coverage."""
|
|
self.collector.stop()
|
|
self._harvest_data()
|
|
|
|
def erase(self):
|
|
"""Erase previously-collected coverage data.
|
|
|
|
This removes the in-memory data collected in this session as well as
|
|
discarding the data file.
|
|
|
|
"""
|
|
self.collector.reset()
|
|
self.data.erase()
|
|
|
|
def clear_exclude(self, which='exclude'):
|
|
"""Clear the exclude list."""
|
|
setattr(self.config, which + "_list", [])
|
|
self._exclude_regex_stale()
|
|
|
|
def exclude(self, regex, which='exclude'):
|
|
"""Exclude source lines from execution consideration.
|
|
|
|
A number of lists of regular expressions are maintained. Each list
|
|
selects lines that are treated differently during reporting.
|
|
|
|
`which` determines which list is modified. The "exclude" list selects
|
|
lines that are not considered executable at all. The "partial" list
|
|
indicates lines with branches that are not taken.
|
|
|
|
`regex` is a regular expression. The regex is added to the specified
|
|
list. If any of the regexes in the list is found in a line, the line
|
|
is marked for special treatment during reporting.
|
|
|
|
"""
|
|
excl_list = getattr(self.config, which + "_list")
|
|
excl_list.append(regex)
|
|
self._exclude_regex_stale()
|
|
|
|
def _exclude_regex_stale(self):
|
|
"""Drop all the compiled exclusion regexes, a list was modified."""
|
|
self._exclude_re.clear()
|
|
|
|
def _exclude_regex(self, which):
|
|
"""Return a compiled regex for the given exclusion list."""
|
|
if which not in self._exclude_re:
|
|
excl_list = getattr(self.config, which + "_list")
|
|
self._exclude_re[which] = join_regex(excl_list)
|
|
return self._exclude_re[which]
|
|
|
|
def get_exclude_list(self, which='exclude'):
|
|
"""Return a list of excluded regex patterns.
|
|
|
|
`which` indicates which list is desired. See `exclude` for the lists
|
|
that are available, and their meaning.
|
|
|
|
"""
|
|
return getattr(self.config, which + "_list")
|
|
|
|
def save(self):
|
|
"""Save the collected coverage data to the data file."""
|
|
data_suffix = self.data_suffix
|
|
if data_suffix is True:
|
|
# If data_suffix was a simple true value, then make a suffix with
|
|
# plenty of distinguishing information. We do this here in
|
|
# `save()` at the last minute so that the pid will be correct even
|
|
# if the process forks.
|
|
data_suffix = "%s.%s.%06d" % (
|
|
self.socket.gethostname(), self.os.getpid(),
|
|
self.random.randint(0, 99999)
|
|
)
|
|
|
|
self._harvest_data()
|
|
self.data.write(suffix=data_suffix)
|
|
|
|
def combine(self):
|
|
"""Combine together a number of similarly-named coverage data files.
|
|
|
|
All coverage data files whose name starts with `data_file` (from the
|
|
coverage() constructor) will be read, and combined together into the
|
|
current measurements.
|
|
|
|
"""
|
|
aliases = None
|
|
if self.config.paths:
|
|
aliases = PathAliases(self.file_locator)
|
|
for paths in self.config.paths.values():
|
|
result = paths[0]
|
|
for pattern in paths[1:]:
|
|
aliases.add(pattern, result)
|
|
self.data.combine_parallel_data(aliases=aliases)
|
|
|
|
def _harvest_data(self):
|
|
"""Get the collected data and reset the collector.
|
|
|
|
Also warn about various problems collecting data.
|
|
|
|
"""
|
|
if not self._harvested:
|
|
self.data.add_line_data(self.collector.get_line_data())
|
|
self.data.add_arc_data(self.collector.get_arc_data())
|
|
self.collector.reset()
|
|
|
|
# If there are still entries in the source_pkgs list, then we never
|
|
# encountered those packages.
|
|
for pkg in self.source_pkgs:
|
|
self._warn("Module %s was never imported." % pkg)
|
|
|
|
# Find out if we got any data.
|
|
summary = self.data.summary()
|
|
if not summary:
|
|
self._warn("No data was collected.")
|
|
|
|
# Find files that were never executed at all.
|
|
for src in self.source:
|
|
for py_file in find_python_files(src):
|
|
self.data.touch_file(py_file)
|
|
|
|
self._harvested = True
|
|
|
|
# Backward compatibility with version 1.
|
|
def analysis(self, morf):
|
|
"""Like `analysis2` but doesn't return excluded line numbers."""
|
|
f, s, _, m, mf = self.analysis2(morf)
|
|
return f, s, m, mf
|
|
|
|
def analysis2(self, morf):
|
|
"""Analyze a module.
|
|
|
|
`morf` is a module or a filename. It will be analyzed to determine
|
|
its coverage statistics. The return value is a 5-tuple:
|
|
|
|
* The filename for the module.
|
|
* A list of line numbers of executable statements.
|
|
* A list of line numbers of excluded statements.
|
|
* A list of line numbers of statements not run (missing from
|
|
execution).
|
|
* A readable formatted string of the missing line numbers.
|
|
|
|
The analysis uses the source file itself and the current measured
|
|
coverage data.
|
|
|
|
"""
|
|
analysis = self._analyze(morf)
|
|
return (
|
|
analysis.filename, analysis.statements, analysis.excluded,
|
|
analysis.missing, analysis.missing_formatted()
|
|
)
|
|
|
|
def _analyze(self, it):
|
|
"""Analyze a single morf or code unit.
|
|
|
|
Returns an `Analysis` object.
|
|
|
|
"""
|
|
if not isinstance(it, CodeUnit):
|
|
it = code_unit_factory(it, self.file_locator)[0]
|
|
|
|
return Analysis(self, it)
|
|
|
|
def report(self, morfs=None, show_missing=True, ignore_errors=None,
|
|
file=None, # pylint: disable=W0622
|
|
omit=None, include=None
|
|
):
|
|
"""Write a summary report to `file`.
|
|
|
|
Each module in `morfs` is listed, with counts of statements, executed
|
|
statements, missing statements, and a list of lines missed.
|
|
|
|
`include` is a list of filename patterns. Modules whose filenames
|
|
match those patterns will be included in the report. Modules matching
|
|
`omit` will not be included in the report.
|
|
|
|
"""
|
|
self.config.from_args(
|
|
ignore_errors=ignore_errors, omit=omit, include=include
|
|
)
|
|
reporter = SummaryReporter(
|
|
self, show_missing, self.config.ignore_errors
|
|
)
|
|
reporter.report(morfs, outfile=file, config=self.config)
|
|
|
|
def annotate(self, morfs=None, directory=None, ignore_errors=None,
|
|
omit=None, include=None):
|
|
"""Annotate a list of modules.
|
|
|
|
Each module in `morfs` is annotated. The source is written to a new
|
|
file, named with a ",cover" suffix, with each line prefixed with a
|
|
marker to indicate the coverage of the line. Covered lines have ">",
|
|
excluded lines have "-", and missing lines have "!".
|
|
|
|
See `coverage.report()` for other arguments.
|
|
|
|
"""
|
|
self.config.from_args(
|
|
ignore_errors=ignore_errors, omit=omit, include=include
|
|
)
|
|
reporter = AnnotateReporter(self, self.config.ignore_errors)
|
|
reporter.report(morfs, config=self.config, directory=directory)
|
|
|
|
def html_report(self, morfs=None, directory=None, ignore_errors=None,
|
|
omit=None, include=None):
|
|
"""Generate an HTML report.
|
|
|
|
See `coverage.report()` for other arguments.
|
|
|
|
"""
|
|
self.config.from_args(
|
|
ignore_errors=ignore_errors, omit=omit, include=include,
|
|
html_dir=directory,
|
|
)
|
|
reporter = HtmlReporter(self, self.config.ignore_errors)
|
|
reporter.report(morfs, config=self.config)
|
|
|
|
def xml_report(self, morfs=None, outfile=None, ignore_errors=None,
|
|
omit=None, include=None):
|
|
"""Generate an XML report of coverage results.
|
|
|
|
The report is compatible with Cobertura reports.
|
|
|
|
Each module in `morfs` is included in the report. `outfile` is the
|
|
path to write the file to, "-" will write to stdout.
|
|
|
|
See `coverage.report()` for other arguments.
|
|
|
|
"""
|
|
self.config.from_args(
|
|
ignore_errors=ignore_errors, omit=omit, include=include,
|
|
xml_output=outfile,
|
|
)
|
|
file_to_close = None
|
|
if self.config.xml_output:
|
|
if self.config.xml_output == '-':
|
|
outfile = sys.stdout
|
|
else:
|
|
outfile = open(self.config.xml_output, "w")
|
|
file_to_close = outfile
|
|
try:
|
|
reporter = XmlReporter(self, self.config.ignore_errors)
|
|
reporter.report(morfs, outfile=outfile, config=self.config)
|
|
finally:
|
|
if file_to_close:
|
|
file_to_close.close()
|
|
|
|
def sysinfo(self):
|
|
"""Return a list of (key, value) pairs showing internal information."""
|
|
|
|
import coverage as covmod
|
|
import platform, re
|
|
|
|
try:
|
|
implementation = platform.python_implementation()
|
|
except AttributeError:
|
|
implementation = "unknown"
|
|
|
|
info = [
|
|
('version', covmod.__version__),
|
|
('coverage', covmod.__file__),
|
|
('cover_dir', self.cover_dir),
|
|
('pylib_dirs', self.pylib_dirs),
|
|
('tracer', self.collector.tracer_name()),
|
|
('data_path', self.data.filename),
|
|
('python', sys.version.replace('\n', '')),
|
|
('platform', platform.platform()),
|
|
('implementation', implementation),
|
|
('cwd', os.getcwd()),
|
|
('path', sys.path),
|
|
('environment', [
|
|
("%s = %s" % (k, v)) for k, v in os.environ.items()
|
|
if re.search("^COV|^PY", k)
|
|
]),
|
|
]
|
|
return info
|
|
|
|
|
|
def process_startup():
|
|
"""Call this at Python startup to perhaps measure coverage.
|
|
|
|
If the environment variable COVERAGE_PROCESS_START is defined, coverage
|
|
measurement is started. The value of the variable is the config file
|
|
to use.
|
|
|
|
There are two ways to configure your Python installation to invoke this
|
|
function when Python starts:
|
|
|
|
#. Create or append to sitecustomize.py to add these lines::
|
|
|
|
import coverage
|
|
coverage.process_startup()
|
|
|
|
#. Create a .pth file in your Python installation containing::
|
|
|
|
import coverage; coverage.process_startup()
|
|
|
|
"""
|
|
cps = os.environ.get("COVERAGE_PROCESS_START")
|
|
if cps:
|
|
cov = coverage(config_file=cps, auto_data=True)
|
|
if os.environ.get("COVERAGE_COVERAGE"):
|
|
# Measuring coverage within coverage.py takes yet more trickery.
|
|
cov.cover_dir = "Please measure coverage.py!"
|
|
cov.start()
|