def coverage(ctxt, summary=None, coverdir=None, include=None, exclude=None):
"""Extract data from a ``coverage.py`` run.
:param ctxt: the build context
:type ctxt: `Context`
:param summary: path to the file containing the coverage summary
:param coverdir: name of the directory containing the per-module coverage
details
:param include: patterns of files or directories to include in the report
:param exclude: patterns of files or directories to exclude from the report
"""
assert summary, 'Missing required attribute "summary"'
summary_line_re = re.compile(
r'^(?P<module>.*?)\s+(?P<stmts>\d+)\s+'
r'(?P<exec>\d+)\s+(?P<cov>\d+)%\s+'
r'(?:(?P<missing>(?:\d+(?:-\d+)?(?:, )?)*)\s+)?'
r'(?P<file>.+)$')
fileset = FileSet(ctxt.basedir, include, exclude)
missing_files = []
for filename in fileset:
if os.path.splitext(filename)[1] != '.py':
continue
missing_files.append(filename)
covered_modules = set()
def handle_file(element, modname):
if not coverdir:
return
fp = ctxt.resolve(
os.path.join(coverdir,
modname.replace(".", "_") + ".py,cover"))
if not os.path.exists(fp):
log.info("No line by line coverage available for %s", modname)
return
try:
with open(fp) as f:
lines = []
for line in f:
if line.startswith(">"):
lines.append("1")
elif line.startswith("!"):
lines.append("0")
else:
lines.append("-")
element.append(xmlio.Element('line_hits')[' '.join(lines)])
except Exception, e:
log.info("Error while processing line by line coverage: %s", e)
def test_absolute_path(self):
filename = os.sep.join([self.ctxt.basedir, 'test', 'module.py'])
self._create_file('test', 'module.py')
filenames = pythontools._normalize_filenames(
self.ctxt, [filename], FileSet(self.ctxt.basedir, '**/*.py', None))
self.assertEqual(['test/module.py'], list(filenames))
def trace(ctxt, summary=None, coverdir=None, include=None, exclude=None):
"""Extract data from a ``trace.py`` run.
:param ctxt: the build context
:type ctxt: `Context`
:param summary: path to the file containing the coverage summary
:param coverdir: name of the directory containing the per-module coverage
details
:param include: patterns of files or directories to include in the report
:param exclude: patterns of files or directories to exclude from the report
"""
assert summary, 'Missing required attribute "summary"'
assert coverdir, 'Missing required attribute "coverdir"'
summary_line_re = re.compile(r'^\s*(?P<lines>\d+)\s+(?P<cov>\d+)%\s+'
r'(?P<module>.*?)\s+\((?P<filename>.*?)\)')
coverage_line_re = re.compile(r'\s*(?:(?P<hits>\d+): )?(?P<line>.*)')
fileset = FileSet(ctxt.basedir, include, exclude)
missing_files = []
for filename in fileset:
if os.path.splitext(filename)[1] != '.py':
continue
missing_files.append(filename)
covered_modules = set()
def handle_file(elem, sourcefile, coverfile=None):
code_lines = set()
for lineno, linetype, line in loc.count(sourcefile):
if linetype == loc.CODE:
code_lines.add(lineno)
num_covered = 0
lines = []
if coverfile:
prev_hits = '0'
for idx, coverline in enumerate(coverfile):
match = coverage_line_re.search(coverline)
if match:
hits = match.group(1)
if hits: # Line covered
if hits != '0':
num_covered += 1
lines.append(hits)
prev_hits = hits
elif coverline.startswith('>'): # Line not covered
lines.append('0')
prev_hits = '0'
elif idx not in code_lines: # Not a code line
lines.append('-')
prev_hits = '0'
else: # A code line not flagged by trace.py
if prev_hits != '0':
num_covered += 1
lines.append(prev_hits)
elem.append(xmlio.Element('line_hits')[' '.join(lines)])
num_lines = not lines and len(code_lines) or \
len([l for l in lines if l != '-'])
if num_lines:
percentage = int(round(num_covered * 100 / num_lines))
else:
percentage = 0
elem.attr['percentage'] = percentage
elem.attr['lines'] = num_lines
try:
summary_file = open(ctxt.resolve(summary), 'r')
try:
coverage = xmlio.Fragment()
for summary_line in summary_file:
match = summary_line_re.search(summary_line)
if match:
modname = match.group(3)
filename = match.group(4)
if not os.path.isabs(filename):
filename = os.path.normpath(os.path.join(ctxt.basedir,
filename))
else:
filename = os.path.realpath(filename)
if not filename.startswith(ctxt.basedir):
continue
filename = filename[len(ctxt.basedir) + 1:]
if not filename in fileset:
continue
missing_files.remove(filename)
covered_modules.add(modname)
module = xmlio.Element('coverage', name=modname,
file=filename.replace(os.sep, '/'))
sourcefile = file(ctxt.resolve(filename))
try:
coverpath = ctxt.resolve(coverdir, modname + '.cover')
if os.path.isfile(coverpath):
coverfile = file(coverpath, 'r')
else:
log.warning('No coverage file for module %s at %s',
modname, coverpath)
coverfile = None
try:
handle_file(module, sourcefile, coverfile)
finally:
if coverfile:
coverfile.close()
finally:
sourcefile.close()
coverage.append(module)
for filename in missing_files:
modname = os.path.splitext(filename.replace(os.sep, '.'))[0]
if modname in covered_modules:
continue
covered_modules.add(modname)
module = xmlio.Element('coverage', name=modname,
file=filename.replace(os.sep, '/'),
percentage=0)
filepath = ctxt.resolve(filename)
fileobj = file(filepath, 'r')
try:
handle_file(module, fileobj)
finally:
fileobj.close()
coverage.append(module)
ctxt.report('coverage', coverage)
finally:
summary_file.close()
except IOError, e:
log.warning('Error opening coverage summary file (%s)', e)
def coverage(ctxt, summary=None, coverdir=None, include=None, exclude=None):
"""Extract data from a ``coverage.py`` run.
:param ctxt: the build context
:type ctxt: `Context`
:param summary: path to the file containing the coverage summary
:param coverdir: name of the directory containing the per-module coverage
details
:param include: patterns of files or directories to include in the report
:param exclude: patterns of files or directories to exclude from the report
"""
assert summary, 'Missing required attribute "summary"'
summary_line_re = re.compile(r'^(?P<module>.*?)\s+(?P<stmts>\d+)\s+'
r'(?P<exec>\d+)\s+(?P<cov>\d+)%\s+'
r'(?:(?P<missing>(?:\d+(?:-\d+)?(?:, )?)*)\s+)?'
r'(?P<file>.+)$')
fileset = FileSet(ctxt.basedir, include, exclude)
missing_files = []
for filename in fileset:
if os.path.splitext(filename)[1] != '.py':
continue
missing_files.append(filename)
covered_modules = set()
try:
summary_file = open(ctxt.resolve(summary), 'r')
try:
coverage = xmlio.Fragment()
for summary_line in summary_file:
match = summary_line_re.search(summary_line)
if match:
modname = match.group(1)
filename = match.group(6)
if not os.path.isabs(filename):
filename = os.path.normpath(os.path.join(ctxt.basedir,
filename))
else:
filename = os.path.realpath(filename)
if not filename.startswith(ctxt.basedir):
continue
filename = filename[len(ctxt.basedir) + 1:]
if not filename in fileset:
continue
percentage = int(match.group(4).rstrip('%'))
num_lines = int(match.group(2))
missing_files.remove(filename)
covered_modules.add(modname)
module = xmlio.Element('coverage', name=modname,
file=filename.replace(os.sep, '/'),
percentage=percentage,
lines=num_lines)
coverage.append(module)
for filename in missing_files:
modname = os.path.splitext(filename.replace(os.sep, '.'))[0]
if modname in covered_modules:
continue
covered_modules.add(modname)
module = xmlio.Element('coverage', name=modname,
file=filename.replace(os.sep, '/'),
percentage=0)
coverage.append(module)
ctxt.report('coverage', coverage)
finally:
summary_file.close()
except IOError, e:
log.warning('Error opening coverage summary file (%s)', e)
:param ctxt: the build context
:type ctxt: `Context`
:param summary: path to the file containing the coverage summary
:param include: patterns of files or directories to include in the report
:param exclude: patterns of files or directories to exclude from the report
"""
from figleaf import get_lines
coverage = xmlio.Fragment()
try:
fileobj = open(ctxt.resolve(summary))
except IOError, e:
log.warning('Error opening coverage summary file (%s)', e)
return
coverage_data = pickle.load(fileobj)
fileset = FileSet(ctxt.basedir, include, exclude)
for filename in fileset:
base, ext = os.path.splitext(filename)
if ext != '.py':
continue
modname = base.replace(os.path.sep, '.')
realfilename = ctxt.resolve(filename)
interesting_lines = get_lines(open(realfilename))
covered_lines = coverage_data.get(realfilename, set())
percentage = int(round(len(covered_lines) * 100 / len(interesting_lines)))
line_hits = []
for lineno in xrange(1, max(interesting_lines)+1):
if lineno not in interesting_lines:
line_hits.append('-')
elif lineno in covered_lines:
line_hits.append('1')
def gcov(ctxt, include=None, exclude=None, prefix=None, root=""):
"""Run ``gcov`` to extract coverage data where available.
:param ctxt: the build context
:type ctxt: `Context`
:param include: patterns of files and directories to include
:param exclude: patterns of files and directories that should be excluded
:param prefix: optional prefix name that is added to object files by the
build system
:param root: optional root path in which the build system puts the object
files
"""
file_re = re.compile(r'^File (?:\'|\`)(?P<file>[^\']+)\'\s*$')
lines_re = re.compile(r'^Lines executed:(?P<cov>\d+\.\d+)\% of (?P<num>\d+)\s*$')
files = []
for filename in FileSet(ctxt.basedir, include, exclude):
if os.path.splitext(filename)[1] in ('.c', '.cpp', '.cc', '.cxx'):
files.append(filename)
coverage = xmlio.Fragment()
log_elem = xmlio.Fragment()
def info (msg):
log.info (msg)
log_elem.append (xmlio.Element ('message', level='info')[msg])
def warning (msg):
log.warning (msg)
log_elem.append (xmlio.Element ('message', level='warning')[msg])
def error (msg):
log.error (msg)
log_elem.append (xmlio.Element ('message', level='error')[msg])
for srcfile in files:
# Determine the coverage for each source file by looking for a .gcno
# and .gcda pair
info ("Getting coverage info for %s" % srcfile)
filepath, filename = os.path.split(srcfile)
stem = os.path.splitext(filename)[0]
if prefix is not None:
stem = prefix + '-' + stem
objfile = os.path.join (root, filepath, stem + '.o')
if not os.path.isfile(ctxt.resolve(objfile)):
warning ('No object file found for %s at %s' % (srcfile, objfile))
continue
if not os.path.isfile (ctxt.resolve (os.path.join (root, filepath, stem + '.gcno'))):
warning ('No .gcno file found for %s at %s' % (srcfile, os.path.join (root, filepath, stem + '.gcno')))
continue
if not os.path.isfile (ctxt.resolve (os.path.join (root, filepath, stem + '.gcda'))):
warning ('No .gcda file found for %s at %s' % (srcfile, os.path.join (root, filepath, stem + '.gcda')))
continue
num_lines, num_covered = 0, 0
skip_block = False
cmd = CommandLine('gcov', ['-b', '-n', '-o', objfile, srcfile],
cwd=ctxt.basedir)
for out, err in cmd.execute():
if out == '': # catch blank lines, reset the block state...
skip_block = False
elif out and not skip_block:
# Check for a file name
match = file_re.match(out)
if match:
if os.path.isabs(match.group('file')):
skip_block = True
continue
else:
# check for a "Lines executed" message
match = lines_re.match(out)
if match:
lines = float(match.group('num'))
cov = float(match.group('cov'))
num_covered += int(lines * cov / 100)
num_lines += int(lines)
if cmd.returncode != 0:
continue
module = xmlio.Element('coverage', name=os.path.basename(srcfile),
file=srcfile.replace(os.sep, '/'),
lines=num_lines, percentage=0)
if num_lines:
percent = int(round(num_covered * 100 / num_lines))
module.attr['percentage'] = percent
coverage.append(module)
ctxt.report('coverage', coverage)
ctxt.log (log_elem)
def test_files_in_subdir_with_exclude(self):
self._create_dir('tests')
foo_txt = self._create_file('tests', 'foo.txt')
bar_txt = self._create_file('tests', 'bar.txt')
fileset = FileSet(self.basedir, include='tests/*.txt', exclude='bar.*')
assert foo_txt in fileset and bar_txt not in fileset
def test_files_in_subdir(self):
self._create_dir('tests')
foo_txt = self._create_file('tests', 'foo.txt')
bar_txt = self._create_file('tests', 'bar.txt')
fileset = FileSet(self.basedir)
assert foo_txt in fileset and bar_txt in fileset
def test_top_level_files(self):
foo_txt = self._create_file('foo.txt')
bar_txt = self._create_file('bar.txt')
fileset = FileSet(self.basedir)
assert foo_txt in fileset and bar_txt in fileset
def test_empty(self):
fileset = FileSet(self.basedir)
self.assertRaises(StopIteration, iter(fileset).next)