def test_comparison(self):
acu = code_unit_factory("aa/afile.py", FileLocator())[0]
acu2 = code_unit_factory("aa/afile.py", FileLocator())[0]
zcu = code_unit_factory("aa/zfile.py", FileLocator())[0]
bcu = code_unit_factory("aa/bb/bfile.py", FileLocator())[0]
assert acu == acu2 and acu <= acu2 and acu >= acu2
assert acu < zcu and acu <= zcu and acu != zcu
assert zcu > acu and zcu >= acu and zcu != acu
assert acu < bcu and acu <= bcu and acu != bcu
assert bcu > acu and bcu >= acu and bcu != acu
def test_filenames(self):
acu = code_unit_factory("aa/afile.py", FileLocator())
bcu = code_unit_factory("aa/bb/bfile.py", FileLocator())
ccu = code_unit_factory("aa/bb/cc/cfile.py", FileLocator())
self.assertEqual(acu[0].name, "aa/afile")
self.assertEqual(bcu[0].name, "aa/bb/bfile")
self.assertEqual(ccu[0].name, "aa/bb/cc/cfile")
self.assertEqual(acu[0].flat_rootname(), "aa_afile")
self.assertEqual(bcu[0].flat_rootname(), "aa_bb_bfile")
self.assertEqual(ccu[0].flat_rootname(), "aa_bb_cc_cfile")
self.assertEqual(acu[0].source_file().read(), "# afile.py\n")
self.assertEqual(bcu[0].source_file().read(), "# bfile.py\n")
self.assertEqual(ccu[0].source_file().read(), "# cfile.py\n")
def test_odd_filenames(self):
acu = code_unit_factory("aa/afile.odd.py", FileLocator())
bcu = code_unit_factory("aa/bb/bfile.odd.py", FileLocator())
b2cu = code_unit_factory("aa/bb.odd/bfile.py", FileLocator())
self.assertEqual(acu[0].name, "aa/afile.odd")
self.assertEqual(bcu[0].name, "aa/bb/bfile.odd")
self.assertEqual(b2cu[0].name, "aa/bb.odd/bfile")
self.assertEqual(acu[0].flat_rootname(), "aa_afile_odd")
self.assertEqual(bcu[0].flat_rootname(), "aa_bb_bfile_odd")
self.assertEqual(b2cu[0].flat_rootname(), "aa_bb_odd_bfile")
self.assertEqual(acu[0].source_file().read(), "# afile.odd.py\n")
self.assertEqual(bcu[0].source_file().read(), "# bfile.odd.py\n")
self.assertEqual(b2cu[0].source_file().read(), "# bfile.py\n")
def test_simple(self):
self.make_file("hello.py")
fl = FileLocator()
self.assertEqual(fl.relative_filename("hello.py"), "hello.py")
a = self.abs_path("hello.py")
self.assertNotEqual(a, "hello.py")
self.assertEqual(fl.relative_filename(a), "hello.py")
def setUp(self):
coverage = coveralls(data_file=Arguments.data_file,
config_file=Arguments.config_file)
coverage.load()
self.reporter = CoverallsReporter(coverage, coverage.config)
self.reporter.find_code_units(None)
self.reporter.code_units.append(CodeUnit('LICENSE', FileLocator()))
def test_filepath_contains_absolute_prefix_twice(self):
# https://bitbucket.org/ned/coveragepy/issue/194
# Build a path that has two pieces matching the absolute path prefix.
# Technically, this test doesn't do that on Windows, but drive
# letters make that impractical to achieve.
fl = FileLocator()
d = abs_file(os.curdir)
trick = os.path.splitdrive(d)[1].lstrip(os.path.sep)
rel = os.path.join('sub', trick, 'file1.py')
self.assertEqual(fl.relative_filename(abs_file(rel)), rel)
def test_peer_directories(self):
self.make_file("sub/proj1/file1.py")
self.make_file("sub/proj2/file2.py")
a1 = self.abs_path("sub/proj1/file1.py")
a2 = self.abs_path("sub/proj2/file2.py")
d = os.path.normpath("sub/proj1")
os.chdir(d)
fl = FileLocator()
self.assertEqual(fl.relative_filename(a1), "file1.py")
self.assertEqual(fl.relative_filename(a2), a2)
def __init__(self, filename, file_locator=None):
self.file_locator = file_locator or FileLocator()
# TODO: do we want the .filename attribute to be part of the public
# API of the coverage plugin?
self.filename = self.file_locator.canonical_filename(filename)
# TODO: is self.name required? Can the base class provide it somehow?
self.name = os.path.relpath(filename)
# TODO: html filenames are absolute.
self._source = None
def test_modules(self):
import aa, aa.bb, aa.bb.cc
cu = code_unit_factory([aa, aa.bb, aa.bb.cc], FileLocator())
self.assertEqual(cu[0].name, "aa")
self.assertEqual(cu[1].name, "aa.bb")
self.assertEqual(cu[2].name, "aa.bb.cc")
self.assertEqual(cu[0].flat_rootname(), "aa")
self.assertEqual(cu[1].flat_rootname(), "aa_bb")
self.assertEqual(cu[2].flat_rootname(), "aa_bb_cc")
self.assertEqual(cu[0].source_file().read(), "# aa\n")
self.assertEqual(cu[1].source_file().read(), "# bb\n")
self.assertEqual(cu[2].source_file().read(), "") # yes, empty
def test_egg(self):
# Test that we can get files out of eggs, and read their source files.
# The egg1 module is installed by an action in igor.py.
import egg1, egg1.egg1
# Verify that we really imported from an egg. If we did, then the
# __file__ won't be an actual file, because one of the "directories"
# in the path is actually the .egg zip file.
self.assert_doesnt_exist(egg1.__file__)
cu = code_unit_factory([egg1, egg1.egg1], FileLocator())
self.assertEqual(cu[0].source(), "")
self.assertEqual(cu[1].source().split("\n")[0], "# My egg file!")
def test_module_files(self):
import aa.afile, aa.bb.bfile, aa.bb.cc.cfile
cu = code_unit_factory([aa.afile, aa.bb.bfile, aa.bb.cc.cfile],
FileLocator())
self.assertEqual(cu[0].name, "aa.afile")
self.assertEqual(cu[1].name, "aa.bb.bfile")
self.assertEqual(cu[2].name, "aa.bb.cc.cfile")
self.assertEqual(cu[0].flat_rootname(), "aa_afile")
self.assertEqual(cu[1].flat_rootname(), "aa_bb_bfile")
self.assertEqual(cu[2].flat_rootname(), "aa_bb_cc_cfile")
self.assertEqual(cu[0].source_file().read(), "# afile.py\n")
self.assertEqual(cu[1].source_file().read(), "# bfile.py\n")
self.assertEqual(cu[2].source_file().read(), "# cfile.py\n")
def test_fnmatch_matcher(self):
file1 = self.make_file("sub/file1.py")
file2 = self.make_file("sub/file2.c")
file3 = self.make_file("sub2/file3.h")
file4 = self.make_file("sub3/file4.py")
file5 = self.make_file("sub3/file5.c")
fl = FileLocator()
fnm = FnmatchMatcher(["*.py", "*/sub2/*"])
self.assertTrue(fnm.match(fl.canonical_filename(file1)))
self.assertFalse(fnm.match(fl.canonical_filename(file2)))
self.assertTrue(fnm.match(fl.canonical_filename(file3)))
self.assertTrue(fnm.match(fl.canonical_filename(file4)))
self.assertFalse(fnm.match(fl.canonical_filename(file5)))
def __init__(self, morf, file_locator=None):
self.file_locator = file_locator or FileLocator()
if hasattr(morf, '__file__'):
filename = morf.__file__
else:
filename = morf
filename = self._adjust_filename(filename)
self.filename = self.file_locator.canonical_filename(filename)
if hasattr(morf, '__name__'):
name = morf.__name__
name = name.replace(".", os.sep) + ".py"
else:
name = self.file_locator.relative_filename(filename)
self.name = name
def test_tree_matcher(self):
file1 = self.make_file("sub/file1.py")
file2 = self.make_file("sub/file2.c")
file3 = self.make_file("sub2/file3.h")
file4 = self.make_file("sub3/file4.py")
file5 = self.make_file("sub3/file5.c")
fl = FileLocator()
tm = TreeMatcher([
fl.canonical_filename("sub"),
fl.canonical_filename(file4),
])
self.assertTrue(tm.match(fl.canonical_filename(file1)))
self.assertTrue(tm.match(fl.canonical_filename(file2)))
self.assertFalse(tm.match(fl.canonical_filename(file3)))
self.assertTrue(tm.match(fl.canonical_filename(file4)))
self.assertFalse(tm.match(fl.canonical_filename(file5)))
def test_tree_matcher(self):
matches_to_try = [
(self.make_file("sub/file1.py"), True),
(self.make_file("sub/file2.c"), True),
(self.make_file("sub2/file3.h"), False),
(self.make_file("sub3/file4.py"), True),
(self.make_file("sub3/file5.c"), False),
]
fl = FileLocator()
trees = [
fl.canonical_filename("sub"),
fl.canonical_filename("sub3/file4.py"),
]
tm = TreeMatcher(trees)
self.assertEqual(tm.info(), trees)
for filepath, matches in matches_to_try:
self.assertMatches(tm, filepath, matches)
def test_egg(self):
import egg1, egg1.egg1
cu = code_unit_factory([egg1, egg1.egg1], FileLocator())
self.assertEqual(cu[0].source_file().read(), "")
self.assertEqual(cu[1].source_file().read().split("\n")[0],
"# My egg file!")
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,
debug=None,
debug_file=None):
from coverage import __version__
self._warnings = []
self.config = CoverageConfig()
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))
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
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,
debug=debug)
self.debug = DebugControl(self.config.debug, debug_file or sys.stderr)
self.auto_data = auto_data
self._exclude_re = {}
self._exclude_regex_stale()
self.file_locator = FileLocator()
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 = prep_patterns(self.config.omit)
self.include = prep_patterns(self.config.include)
self.collector = Collector(self._should_trace,
timid=self.config.timid,
branch=self.config.branch,
warn=self._warn)
if data_suffix or self.config.parallel:
if not isinstance(data_suffix, string_class):
data_suffix = True
else:
data_suffix = None
self.data_suffix = None
self.run_suffix = data_suffix
self.data = CoverageData(basename=self.config.data_file,
collector='coverage v%s' % __version__,
debug=self.debug)
self.pylib_dirs = []
if not self.config.cover_pylib:
for m in (atexit, os, random, socket, _structseq):
if m is not None and hasattr(m, '__file__'):
m_dir = self._canonical_dir(m)
if m_dir not in self.pylib_dirs:
self.pylib_dirs.append(m_dir)
self.cover_dir = self._canonical_dir(__file__)
self.source_match = None
self.pylib_match = self.cover_match = None
self.include_match = self.omit_match = None
Numbers.set_precision(self.config.precision)
self._warn_no_data = True
self._warn_unimported_source = True
self._started = False
self._measured = False
atexit.register(self._atexit)
def __init__(self, data_file=None, data_suffix=False, cover_pylib=False,
auto_data=False, timid=False, branch=False):
"""
`data_file` is the base name of the data file to use, defaulting to
".coverage". `data_suffix` is appended 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.
"""
from coverage import __version__
self.cover_pylib = cover_pylib
self.auto_data = auto_data
self.atexit_registered = False
self.exclude_re = ""
self.exclude_list = []
self.file_locator = FileLocator()
# Timidity: for nose users, read an environment variable. This is a
# cheap hack, since the rest of the command line arguments aren't
# recognized, but it solves some users' problems.
timid = timid or ('--timid' in os.environ.get('COVERAGE_OPTIONS', ''))
self.collector = Collector(
self._should_trace, timid=timid, branch=branch
)
# Create the data file.
if data_suffix:
if not isinstance(data_suffix, string_class):
# if data_suffix=True, use .machinename.pid
data_suffix = ".%s.%s" % (socket.gethostname(), os.getpid())
else:
data_suffix = None
self.data = CoverageData(
basename=data_file, suffix=data_suffix,
collector="coverage v%s" % __version__
)
# The default exclude pattern.
self.exclude('# *pragma[: ]*[nN][oO] *[cC][oO][vV][eE][rR]')
# The prefix for files considered "installed with the interpreter".
if not self.cover_pylib:
# Look at where the "os" module is located. That's the indication
# for "installed with the interpreter".
os_file = self.file_locator.canonical_filename(os.__file__)
self.pylib_prefix = os.path.split(os_file)[0]
# To avoid tracing the coverage code itself, we skip anything located
# where we are.
here = self.file_locator.canonical_filename(__file__)
self.cover_prefix = os.path.split(here)[0]
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:
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
# _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 = prep_patterns(self.config.omit)
self.include = 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)
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)
# Is it ok for no data to be collected?
self._warn_no_data = True
self._started = False
atexit.register(self._atexit)
def _init(self):
"""Set all the initial state.
This is called by the public methods to initialize state. This lets us
construct a Coverage object, then tweak its state before this function
is called.
"""
from coverage import __version__
if self._inited:
return
# Create and configure the debugging controller.
if self._debug_file is None:
self._debug_file = sys.stderr
self.debug = DebugControl(self.config.debug, self._debug_file)
# Load plugins
self.plugins = Plugins.load_plugins(self.config.plugins, self.config)
self.file_tracers = []
for plugin in self.plugins:
if overrides(plugin, "file_tracer", CoveragePlugin):
self.file_tracers.append(plugin)
# _exclude_re is a dict that maps 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 = prep_patterns(self.config.omit)
self.include = prep_patterns(self.config.include)
concurrency = self.config.concurrency
if concurrency == "multiprocessing":
patch_multiprocessing()
concurrency = None
self.collector = Collector(
should_trace=self._should_trace,
check_include=self._check_include_omit_etc,
timid=self.config.timid,
branch=self.config.branch,
warn=self._warn,
concurrency=concurrency,
)
# Early warning if we aren't going to be able to support plugins.
if self.file_tracers and not self.collector.supports_plugins:
raise CoverageException(
"Plugin file tracers (%s) aren't supported with %s" % (
", ".join(ft._coverage_plugin_name
for ft in self.file_tracers),
self.collector.tracer_name(),
))
# 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 self._data_suffix or self.config.parallel:
if not isinstance(self._data_suffix, string_class):
# if data_suffix=True, use .machinename.pid.random
self._data_suffix = True
else:
self._data_suffix = None
self.data_suffix = None
self.run_suffix = self._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__,
debug=self.debug,
)
# The dirs for files considered "installed with the interpreter".
self.pylib_dirs = set()
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, platform, random, socket, _structseq):
if m is not None and hasattr(m, "__file__"):
self.pylib_dirs.add(self._canonical_dir(m))
if _structseq and not hasattr(_structseq, '__file__'):
# PyPy 2.4 has no __file__ in the builtin modules, but the code
# objects still have the filenames. So dig into one to find
# the path to exclude.
structseq_new = _structseq.structseq_new
try:
structseq_file = structseq_new.func_code.co_filename
except AttributeError:
structseq_file = structseq_new.__code__.co_filename
self.pylib_dirs.add(self._canonical_dir(structseq_file))
# To avoid tracing the coverage code itself, we skip anything located
# where we are.
self.cover_dir = self._canonical_dir(__file__)
# Set the reporting precision.
Numbers.set_precision(self.config.precision)
atexit.register(self._atexit)
self._inited = True
# Create the matchers we need for _should_trace
if self.source or self.source_pkgs:
self.source_match = TreeMatcher(self.source)
self.source_pkgs_match = ModuleMatcher(self.source_pkgs)
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)
# The user may want to debug things, show info if desired.
wrote_any = False
if self.debug.should('config'):
config_info = sorted(self.config.__dict__.items())
self.debug.write_formatted_info("config", config_info)
wrote_any = True
if self.debug.should('sys'):
self.debug.write_formatted_info("sys", self.sys_info())
for plugin in self.plugins:
header = "sys: " + plugin._coverage_plugin_name
info = plugin.sys_info()
self.debug.write_formatted_info(header, info)
wrote_any = True
if wrote_any:
self.debug.write_formatted_info("end", ())
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.
"""
from coverage import __version__
# 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"
self.config.from_file(config_file)
# 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:
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
self.exclude_re = ""
self._compile_exclude()
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._abs_files(self.config.omit)
self.include = self._abs_files(self.config.include)
self.collector = Collector(self._should_trace,
timid=self.config.timid,
branch=self.config.branch)
# 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 the "os" module is located. That's the indication
# for "installed with the interpreter".
os_dir = self.canonical_dir(os.__file__)
self.pylib_dirs.append(os_dir)
# In a virtualenv, there're actually two lib directories. Find the
# other one. This is kind of ad-hoc, but it works.
random_dir = self.canonical_dir(random.__file__)
if random_dir != os_dir:
self.pylib_dirs.append(random_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
def setUp(self):
super(MatcherTest, self).setUp()
self.fl = FileLocator()
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,
debug=None,
debug_file=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.
`debug` is a list of strings indicating what debugging information is
desired. `debug_file` is the file to write debug messages to,
defaulting to stderr.
"""
from coverage import __version__
self._warnings = []
self.config = CoverageConfig()
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))
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
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,
debug=debug)
self.debug = DebugControl(self.config.debug, debug_file or sys.stderr)
self.auto_data = auto_data
self._exclude_re = {}
self._exclude_regex_stale()
self.file_locator = FileLocator()
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 = prep_patterns(self.config.omit)
self.include = prep_patterns(self.config.include)
self.collector = Collector(self._should_trace,
timid=self.config.timid,
branch=self.config.branch,
warn=self._warn)
if data_suffix or self.config.parallel:
if not isinstance(data_suffix, string_class):
data_suffix = True
else:
data_suffix = None
self.data_suffix = None
self.run_suffix = data_suffix
self.data = CoverageData(basename=self.config.data_file,
collector='coverage v%s' % __version__,
debug=self.debug)
self.pylib_dirs = []
if not self.config.cover_pylib:
for m in (atexit, os, random, socket, _structseq):
if m is not None and hasattr(m, '__file__'):
m_dir = self._canonical_dir(m)
if m_dir not in self.pylib_dirs:
self.pylib_dirs.append(m_dir)
self.cover_dir = self._canonical_dir(__file__)
self.source_match = None
self.pylib_match = self.cover_match = None
self.include_match = self.omit_match = None
Numbers.set_precision(self.config.precision)
self._warn_no_data = True
self._warn_unimported_source = True
self._started = False
self._measured = False
atexit.register(self._atexit)
