blob: b104ff085b4a66b63ef2f33632b40821ff8c14d9 [file] [log] [blame]
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +00001#!/usr/bin/env python
2
3# portions copyright 2001, Autonomous Zones Industries, Inc., all rights...
4# err... reserved and offered to the public under the terms of the
5# Python 2.2 license.
6# Author: Zooko O'Whielacronx
7# http://zooko.com/
8# mailto:zooko@zooko.com
9#
10# Copyright 2000, Mojam Media, Inc., all rights reserved.
11# Author: Skip Montanaro
12#
13# Copyright 1999, Bioreason, Inc., all rights reserved.
14# Author: Andrew Dalke
15#
16# Copyright 1995-1997, Automatrix, Inc., all rights reserved.
17# Author: Skip Montanaro
18#
19# Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved.
20#
21#
22# Permission to use, copy, modify, and distribute this Python software and
23# its associated documentation for any purpose without fee is hereby
24# granted, provided that the above copyright notice appears in all copies,
25# and that both that copyright notice and this permission notice appear in
26# supporting documentation, and that the name of neither Automatrix,
27# Bioreason or Mojam Media be used in advertising or publicity pertaining to
28# distribution of the software without specific, written prior permission.
29#
30"""program/module to trace Python program or function execution
31
32Sample use, command line:
33 trace.py -c -f counts --ignore-dir '$prefix' spam.py eggs
34 trace.py -t --ignore-dir '$prefix' spam.py eggs
Skip Montanaro5bfd9842004-04-10 16:29:58 +000035 trace.py --trackcalls spam.py eggs
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +000036
37Sample use, programmatically
38 # create a Trace object, telling it what to ignore, and whether to
39 # do tracing or line-counting or both.
40 trace = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix,], trace=0,
41 count=1)
42 # run the new command using the given trace
Skip Montanaro5bfd9842004-04-10 16:29:58 +000043 trace.run('main()')
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +000044 # make a report, telling it where you want output
45 r = trace.results()
Jeremy Hylton38732e12003-04-21 22:04:46 +000046 r.write_results(show_missing=True)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +000047"""
48
Jeremy Hylton38732e12003-04-21 22:04:46 +000049import linecache
Jeremy Hylton38732e12003-04-21 22:04:46 +000050import os
51import re
52import sys
Jeremy Hylton546e34b2003-06-26 14:56:17 +000053import threading
Jeremy Hylton38732e12003-04-21 22:04:46 +000054import token
55import tokenize
56import types
Skip Montanaro5bfd9842004-04-10 16:29:58 +000057import gc
Jeremy Hylton38732e12003-04-21 22:04:46 +000058
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +000059try:
60 import cPickle
61 pickle = cPickle
62except ImportError:
63 import pickle
64
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +000065def usage(outfile):
66 outfile.write("""Usage: %s [OPTIONS] <file> [ARGS]
67
68Meta-options:
69--help Display this help then exit.
70--version Output version information then exit.
71
72Otherwise, exactly one of the following three options must be given:
73-t, --trace Print each line to sys.stdout before it is executed.
74-c, --count Count the number of times each line is executed
75 and write the counts to <module>.cover for each
76 module executed, in the module's directory.
77 See also `--coverdir', `--file', `--no-report' below.
Skip Montanaroa7b8ac62003-06-27 19:09:33 +000078-l, --listfuncs Keep track of which functions are executed at least
Fred Drake01c623b2003-06-27 19:22:11 +000079 once and write the results to sys.stdout after the
Skip Montanaroa7b8ac62003-06-27 19:09:33 +000080 program exits.
Skip Montanarocafc8112004-04-07 15:46:05 +000081-T, --trackcalls Keep track of caller/called pairs and write the
82 results to sys.stdout after the program exits.
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +000083-r, --report Generate a report from a counts file; do not execute
84 any code. `--file' must specify the results file to
85 read, which must have been created in a previous run
86 with `--count --file=FILE'.
87
88Modifiers:
89-f, --file=<file> File to accumulate counts over several runs.
90-R, --no-report Do not generate the coverage report files.
91 Useful if you want to accumulate over several runs.
92-C, --coverdir=<dir> Directory where the report files. The coverage
93 report for <package>.<module> is written to file
94 <dir>/<package>/<module>.cover.
95-m, --missing Annotate executable lines that were not executed
96 with '>>>>>> '.
97-s, --summary Write a brief summary on stdout for each file.
98 (Can only be used with --count or --report.)
99
100Filters, may be repeated multiple times:
101--ignore-module=<mod> Ignore the given module and its submodules
102 (if it is a package).
103--ignore-dir=<dir> Ignore files in the given directory (multiple
104 directories can be joined by os.pathsep).
105""" % sys.argv[0])
106
Jeremy Hylton38732e12003-04-21 22:04:46 +0000107PRAGMA_NOCOVER = "#pragma NO COVER"
108
109# Simple rx to find lines with no code.
110rx_blank = re.compile(r'^\s*(#.*)?$')
111
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000112class Ignore:
113 def __init__(self, modules = None, dirs = None):
114 self._mods = modules or []
115 self._dirs = dirs or []
116
117 self._dirs = map(os.path.normpath, self._dirs)
118 self._ignore = { '<string>': 1 }
119
120 def names(self, filename, modulename):
121 if self._ignore.has_key(modulename):
122 return self._ignore[modulename]
123
124 # haven't seen this one before, so see if the module name is
125 # on the ignore list. Need to take some care since ignoring
126 # "cmp" musn't mean ignoring "cmpcache" but ignoring
127 # "Spam" must also mean ignoring "Spam.Eggs".
128 for mod in self._mods:
129 if mod == modulename: # Identical names, so ignore
130 self._ignore[modulename] = 1
131 return 1
132 # check if the module is a proper submodule of something on
133 # the ignore list
134 n = len(mod)
135 # (will not overflow since if the first n characters are the
136 # same and the name has not already occured, then the size
137 # of "name" is greater than that of "mod")
138 if mod == modulename[:n] and modulename[n] == '.':
139 self._ignore[modulename] = 1
140 return 1
141
142 # Now check that __file__ isn't in one of the directories
143 if filename is None:
144 # must be a built-in, so we must ignore
145 self._ignore[modulename] = 1
146 return 1
147
148 # Ignore a file when it contains one of the ignorable paths
149 for d in self._dirs:
150 # The '+ os.sep' is to ensure that d is a parent directory,
151 # as compared to cases like:
152 # d = "/usr/local"
153 # filename = "/usr/local.py"
154 # or
155 # d = "/usr/local.py"
156 # filename = "/usr/local.py"
157 if filename.startswith(d + os.sep):
158 self._ignore[modulename] = 1
159 return 1
160
161 # Tried the different ways, so we don't ignore this module
162 self._ignore[modulename] = 0
163 return 0
164
Jeremy Hylton38732e12003-04-21 22:04:46 +0000165def modname(path):
166 """Return a plausible module name for the patch."""
Jeremy Hyltondfbfe732003-04-21 22:49:17 +0000167
Jeremy Hylton38732e12003-04-21 22:04:46 +0000168 base = os.path.basename(path)
169 filename, ext = os.path.splitext(base)
170 return filename
171
Jeremy Hyltondfbfe732003-04-21 22:49:17 +0000172def fullmodname(path):
Jeremy Hyltonc8c8b942003-04-22 15:35:51 +0000173 """Return a plausible module name for the path."""
Jeremy Hyltondfbfe732003-04-21 22:49:17 +0000174
175 # If the file 'path' is part of a package, then the filename isn't
176 # enough to uniquely identify it. Try to do the right thing by
177 # looking in sys.path for the longest matching prefix. We'll
178 # assume that the rest is the package name.
179
180 longest = ""
181 for dir in sys.path:
182 if path.startswith(dir) and path[len(dir)] == os.path.sep:
183 if len(dir) > len(longest):
184 longest = dir
185
Guido van Rossumb427c002003-10-10 23:02:01 +0000186 if longest:
187 base = path[len(longest) + 1:]
188 else:
189 base = path
Guido van Rossumbbca8da2004-02-19 19:16:50 +0000190 base = base.replace(os.sep, ".")
191 if os.altsep:
192 base = base.replace(os.altsep, ".")
Jeremy Hyltondfbfe732003-04-21 22:49:17 +0000193 filename, ext = os.path.splitext(base)
194 return filename
195
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000196class CoverageResults:
197 def __init__(self, counts=None, calledfuncs=None, infile=None,
Skip Montanarocafc8112004-04-07 15:46:05 +0000198 callers=None, outfile=None):
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000199 self.counts = counts
200 if self.counts is None:
201 self.counts = {}
202 self.counter = self.counts.copy() # map (filename, lineno) to count
203 self.calledfuncs = calledfuncs
204 if self.calledfuncs is None:
205 self.calledfuncs = {}
206 self.calledfuncs = self.calledfuncs.copy()
Skip Montanarocafc8112004-04-07 15:46:05 +0000207 self.callers = callers
208 if self.callers is None:
209 self.callers = {}
210 self.callers = self.callers.copy()
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000211 self.infile = infile
212 self.outfile = outfile
213 if self.infile:
Jeremy Hyltond7ce86d2003-07-07 16:08:47 +0000214 # Try to merge existing counts file.
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000215 try:
Skip Montanarocafc8112004-04-07 15:46:05 +0000216 counts, calledfuncs, callers = \
217 pickle.load(open(self.infile, 'rb'))
218 self.update(self.__class__(counts, calledfuncs, callers))
Jeremy Hyltond7ce86d2003-07-07 16:08:47 +0000219 except (IOError, EOFError, ValueError), err:
Jeremy Hylton38732e12003-04-21 22:04:46 +0000220 print >> sys.stderr, ("Skipping counts file %r: %s"
221 % (self.infile, err))
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000222
223 def update(self, other):
224 """Merge in the data from another CoverageResults"""
225 counts = self.counts
226 calledfuncs = self.calledfuncs
Skip Montanarocafc8112004-04-07 15:46:05 +0000227 callers = self.callers
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000228 other_counts = other.counts
229 other_calledfuncs = other.calledfuncs
Skip Montanarocafc8112004-04-07 15:46:05 +0000230 other_callers = other.callers
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000231
232 for key in other_counts.keys():
Jeremy Hylton38732e12003-04-21 22:04:46 +0000233 counts[key] = counts.get(key, 0) + other_counts[key]
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000234
235 for key in other_calledfuncs.keys():
236 calledfuncs[key] = 1
237
Skip Montanarocafc8112004-04-07 15:46:05 +0000238 for key in other_callers.keys():
239 callers[key] = 1
240
Jeremy Hylton38732e12003-04-21 22:04:46 +0000241 def write_results(self, show_missing=True, summary=False, coverdir=None):
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000242 """
243 @param coverdir
244 """
Skip Montanarocafc8112004-04-07 15:46:05 +0000245 if self.calledfuncs:
Skip Montanaro5bfd9842004-04-10 16:29:58 +0000246 print
Skip Montanarocafc8112004-04-07 15:46:05 +0000247 print "functions called:"
248 calls = self.calledfuncs.keys()
249 calls.sort()
250 for filename, modulename, funcname in calls:
251 print ("filename: %s, modulename: %s, funcname: %s"
252 % (filename, modulename, funcname))
253
254 if self.callers:
Skip Montanaro5bfd9842004-04-10 16:29:58 +0000255 print
Skip Montanarocafc8112004-04-07 15:46:05 +0000256 print "calling relationships:"
257 calls = self.callers.keys()
258 calls.sort()
259 lastfile = lastcfile = ""
260 for ((pfile, pmod, pfunc), (cfile, cmod, cfunc)) in calls:
261 if pfile != lastfile:
Skip Montanaro5bfd9842004-04-10 16:29:58 +0000262 print
Skip Montanarocafc8112004-04-07 15:46:05 +0000263 print "***", pfile, "***"
264 lastfile = pfile
265 lastcfile = ""
266 if cfile != pfile and lastcfile != cfile:
267 print " -->", cfile
268 lastcfile = cfile
269 print " %s.%s -> %s.%s" % (pmod, pfunc, cmod, cfunc)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000270
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000271 # turn the counts data ("(filename, lineno) = count") into something
272 # accessible on a per-file basis
273 per_file = {}
Jeremy Hylton38732e12003-04-21 22:04:46 +0000274 for filename, lineno in self.counts.keys():
275 lines_hit = per_file[filename] = per_file.get(filename, {})
276 lines_hit[lineno] = self.counts[(filename, lineno)]
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000277
278 # accumulate summary info, if needed
279 sums = {}
280
Jeremy Hylton38732e12003-04-21 22:04:46 +0000281 for filename, count in per_file.iteritems():
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000282 # skip some "files" we don't care about...
283 if filename == "<string>":
284 continue
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000285
286 if filename.endswith(".pyc") or filename.endswith(".pyo"):
287 filename = filename[:-1]
288
Jeremy Hylton38732e12003-04-21 22:04:46 +0000289 if coverdir is None:
290 dir = os.path.dirname(os.path.abspath(filename))
Jeremy Hyltonc8c8b942003-04-22 15:35:51 +0000291 modulename = modname(filename)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000292 else:
Jeremy Hylton38732e12003-04-21 22:04:46 +0000293 dir = coverdir
294 if not os.path.exists(dir):
295 os.makedirs(dir)
Jeremy Hyltonc8c8b942003-04-22 15:35:51 +0000296 modulename = fullmodname(filename)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000297
298 # If desired, get a list of the line numbers which represent
299 # executable content (returned as a dict for better lookup speed)
300 if show_missing:
Jeremy Hylton38732e12003-04-21 22:04:46 +0000301 lnotab = find_executable_linenos(filename)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000302 else:
Jeremy Hylton38732e12003-04-21 22:04:46 +0000303 lnotab = {}
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000304
Jeremy Hylton38732e12003-04-21 22:04:46 +0000305 source = linecache.getlines(filename)
306 coverpath = os.path.join(dir, modulename + ".cover")
307 n_hits, n_lines = self.write_results_file(coverpath, source,
308 lnotab, count)
Tim Peters0eadaac2003-04-24 16:02:54 +0000309
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000310 if summary and n_lines:
311 percent = int(100 * n_hits / n_lines)
312 sums[modulename] = n_lines, percent, modulename, filename
313
314 if summary and sums:
315 mods = sums.keys()
316 mods.sort()
317 print "lines cov% module (path)"
318 for m in mods:
319 n_lines, percent, modulename, filename = sums[m]
320 print "%5d %3d%% %s (%s)" % sums[m]
321
322 if self.outfile:
323 # try and store counts and module info into self.outfile
324 try:
Skip Montanarocafc8112004-04-07 15:46:05 +0000325 pickle.dump((self.counts, self.calledfuncs, self.callers),
Jeremy Hyltond0e27052003-10-14 20:12:06 +0000326 open(self.outfile, 'wb'), 1)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000327 except IOError, err:
Jeremy Hylton38732e12003-04-21 22:04:46 +0000328 print >> sys.stderr, "Can't save counts files because %s" % err
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000329
Jeremy Hylton38732e12003-04-21 22:04:46 +0000330 def write_results_file(self, path, lines, lnotab, lines_hit):
331 """Return a coverage results file in path."""
332
333 try:
334 outfile = open(path, "w")
335 except IOError, err:
336 print >> sys.stderr, ("trace: Could not open %r for writing: %s"
337 "- skipping" % (path, err))
Guido van Rossumbbca8da2004-02-19 19:16:50 +0000338 return 0, 0
Jeremy Hylton38732e12003-04-21 22:04:46 +0000339
340 n_lines = 0
341 n_hits = 0
342 for i, line in enumerate(lines):
343 lineno = i + 1
344 # do the blank/comment match to try to mark more lines
345 # (help the reader find stuff that hasn't been covered)
346 if lineno in lines_hit:
347 outfile.write("%5d: " % lines_hit[lineno])
348 n_hits += 1
349 n_lines += 1
350 elif rx_blank.match(line):
Walter Dörwaldc1711722003-07-15 10:34:02 +0000351 outfile.write(" ")
Jeremy Hylton38732e12003-04-21 22:04:46 +0000352 else:
353 # lines preceded by no marks weren't hit
354 # Highlight them if so indicated, unless the line contains
355 # #pragma: NO COVER
356 if lineno in lnotab and not PRAGMA_NOCOVER in lines[i]:
357 outfile.write(">>>>>> ")
Jeremy Hylton546e34b2003-06-26 14:56:17 +0000358 n_lines += 1
Jeremy Hylton38732e12003-04-21 22:04:46 +0000359 else:
360 outfile.write(" ")
Jeremy Hylton38732e12003-04-21 22:04:46 +0000361 outfile.write(lines[i].expandtabs(8))
362 outfile.close()
363
364 return n_hits, n_lines
365
366def find_lines_from_code(code, strs):
367 """Return dict where keys are lines in the line number table."""
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000368 linenos = {}
369
370 line_increments = [ord(c) for c in code.co_lnotab[1::2]]
371 table_length = len(line_increments)
Jeremy Hylton38732e12003-04-21 22:04:46 +0000372 docstring = False
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000373
374 lineno = code.co_firstlineno
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000375 for li in line_increments:
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000376 lineno += li
Jeremy Hylton38732e12003-04-21 22:04:46 +0000377 if lineno not in strs:
378 linenos[lineno] = 1
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000379
380 return linenos
381
Jeremy Hylton38732e12003-04-21 22:04:46 +0000382def find_lines(code, strs):
383 """Return lineno dict for all code objects reachable from code."""
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000384 # get all of the lineno information from the code of this scope level
Jeremy Hylton38732e12003-04-21 22:04:46 +0000385 linenos = find_lines_from_code(code, strs)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000386
387 # and check the constants for references to other code objects
388 for c in code.co_consts:
Jeremy Hylton38732e12003-04-21 22:04:46 +0000389 if isinstance(c, types.CodeType):
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000390 # find another code object, so recurse into it
Jeremy Hylton38732e12003-04-21 22:04:46 +0000391 linenos.update(find_lines(c, strs))
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000392 return linenos
393
Jeremy Hylton38732e12003-04-21 22:04:46 +0000394def find_strings(filename):
395 """Return a dict of possible docstring positions.
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000396
Jeremy Hylton38732e12003-04-21 22:04:46 +0000397 The dict maps line numbers to strings. There is an entry for
398 line that contains only a string or a part of a triple-quoted
399 string.
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000400 """
Jeremy Hylton38732e12003-04-21 22:04:46 +0000401 d = {}
402 # If the first token is a string, then it's the module docstring.
403 # Add this special case so that the test in the loop passes.
404 prev_ttype = token.INDENT
405 f = open(filename)
406 for ttype, tstr, start, end, line in tokenize.generate_tokens(f.readline):
407 if ttype == token.STRING:
408 if prev_ttype == token.INDENT:
409 sline, scol = start
410 eline, ecol = end
411 for i in range(sline, eline + 1):
412 d[i] = 1
413 prev_ttype = ttype
414 f.close()
415 return d
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000416
Jeremy Hylton38732e12003-04-21 22:04:46 +0000417def find_executable_linenos(filename):
418 """Return dict where keys are line numbers in the line number table."""
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000419 assert filename.endswith('.py')
Jeremy Hylton38732e12003-04-21 22:04:46 +0000420 try:
Skip Montanaroc00fc842004-04-16 03:28:19 +0000421 prog = open(filename, "rU").read()
Jeremy Hylton38732e12003-04-21 22:04:46 +0000422 except IOError, err:
423 print >> sys.stderr, ("Not printing coverage data for %r: %s"
424 % (filename, err))
425 return {}
426 code = compile(prog, filename, "exec")
427 strs = find_strings(filename)
428 return find_lines(code, strs)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000429
430class Trace:
Skip Montanarocafc8112004-04-07 15:46:05 +0000431 def __init__(self, count=1, trace=1, countfuncs=0, countcallers=0,
432 ignoremods=(), ignoredirs=(), infile=None, outfile=None):
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000433 """
434 @param count true iff it should count number of times each
Tim Petersf2715e02003-02-19 02:35:07 +0000435 line is executed
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000436 @param trace true iff it should print out each line that is
Tim Petersf2715e02003-02-19 02:35:07 +0000437 being counted
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000438 @param countfuncs true iff it should just output a list of
439 (filename, modulename, funcname,) for functions
440 that were called at least once; This overrides
Tim Petersf2715e02003-02-19 02:35:07 +0000441 `count' and `trace'
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000442 @param ignoremods a list of the names of modules to ignore
443 @param ignoredirs a list of the names of directories to ignore
Tim Petersf2715e02003-02-19 02:35:07 +0000444 all of the (recursive) contents of
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000445 @param infile file from which to read stored counts to be
Tim Petersf2715e02003-02-19 02:35:07 +0000446 added into the results
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000447 @param outfile file in which to write the results
448 """
449 self.infile = infile
450 self.outfile = outfile
451 self.ignore = Ignore(ignoremods, ignoredirs)
452 self.counts = {} # keys are (filename, linenumber)
453 self.blabbed = {} # for debugging
454 self.pathtobasename = {} # for memoizing os.path.basename
455 self.donothing = 0
456 self.trace = trace
457 self._calledfuncs = {}
Skip Montanarocafc8112004-04-07 15:46:05 +0000458 self._callers = {}
Skip Montanaro5bfd9842004-04-10 16:29:58 +0000459 self._caller_cache = {}
Skip Montanarocafc8112004-04-07 15:46:05 +0000460 if countcallers:
461 self.globaltrace = self.globaltrace_trackcallers
462 elif countfuncs:
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000463 self.globaltrace = self.globaltrace_countfuncs
464 elif trace and count:
465 self.globaltrace = self.globaltrace_lt
466 self.localtrace = self.localtrace_trace_and_count
467 elif trace:
468 self.globaltrace = self.globaltrace_lt
469 self.localtrace = self.localtrace_trace
470 elif count:
471 self.globaltrace = self.globaltrace_lt
472 self.localtrace = self.localtrace_count
473 else:
474 # Ahem -- do nothing? Okay.
475 self.donothing = 1
476
477 def run(self, cmd):
478 import __main__
479 dict = __main__.__dict__
480 if not self.donothing:
481 sys.settrace(self.globaltrace)
Jeremy Hylton546e34b2003-06-26 14:56:17 +0000482 threading.settrace(self.globaltrace)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000483 try:
484 exec cmd in dict, dict
485 finally:
486 if not self.donothing:
487 sys.settrace(None)
Jeremy Hylton546e34b2003-06-26 14:56:17 +0000488 threading.settrace(None)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000489
490 def runctx(self, cmd, globals=None, locals=None):
491 if globals is None: globals = {}
492 if locals is None: locals = {}
493 if not self.donothing:
494 sys.settrace(self.globaltrace)
Jeremy Hylton546e34b2003-06-26 14:56:17 +0000495 threading.settrace(self.globaltrace)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000496 try:
497 exec cmd in globals, locals
498 finally:
499 if not self.donothing:
500 sys.settrace(None)
Jeremy Hylton546e34b2003-06-26 14:56:17 +0000501 threading.settrace(None)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000502
503 def runfunc(self, func, *args, **kw):
504 result = None
505 if not self.donothing:
506 sys.settrace(self.globaltrace)
507 try:
Guido van Rossum68468eb2003-02-27 20:14:51 +0000508 result = func(*args, **kw)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000509 finally:
510 if not self.donothing:
511 sys.settrace(None)
512 return result
513
Skip Montanaro5bfd9842004-04-10 16:29:58 +0000514 def file_module_function_of(self, frame):
515 code = frame.f_code
516 filename = code.co_filename
517 if filename:
518 modulename = modname(filename)
519 else:
520 modulename = None
521
522 funcname = code.co_name
523 clsname = None
524 if code in self._caller_cache:
525 if self._caller_cache[code] is not None:
526 clsname = self._caller_cache[code]
527 else:
528 self._caller_cache[code] = None
529 ## use of gc.get_referrers() was suggested by Michael Hudson
530 # all functions which refer to this code object
531 funcs = [f for f in gc.get_referrers(code)
532 if hasattr(f, "func_doc")]
533 # require len(func) == 1 to avoid ambiguity caused by calls to
534 # new.function(): "In the face of ambiguity, refuse the
535 # temptation to guess."
536 if len(funcs) == 1:
537 dicts = [d for d in gc.get_referrers(funcs[0])
538 if isinstance(d, dict)]
539 if len(dicts) == 1:
540 classes = [c for c in gc.get_referrers(dicts[0])
541 if hasattr(c, "__bases__")]
542 if len(classes) == 1:
543 # ditto for new.classobj()
544 clsname = str(classes[0])
545 # cache the result - assumption is that new.* is
546 # not called later to disturb this relationship
547 # _caller_cache could be flushed if functions in
548 # the new module get called.
549 self._caller_cache[code] = clsname
550 if clsname is not None:
551 # final hack - module name shows up in str(cls), but we've already
552 # computed module name, so remove it
553 clsname = clsname.split(".")[1:]
554 clsname = ".".join(clsname)
555 funcname = "%s.%s" % (clsname, funcname)
556
557 return filename, modulename, funcname
558
Skip Montanarocafc8112004-04-07 15:46:05 +0000559 def globaltrace_trackcallers(self, frame, why, arg):
560 """Handler for call events.
561
562 Adds information about who called who to the self._callers dict.
563 """
564 if why == 'call':
565 # XXX Should do a better job of identifying methods
Skip Montanaro5bfd9842004-04-10 16:29:58 +0000566 this_func = self.file_module_function_of(frame)
567 parent_func = self.file_module_function_of(frame.f_back)
Skip Montanarocafc8112004-04-07 15:46:05 +0000568 self._callers[(parent_func, this_func)] = 1
569
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000570 def globaltrace_countfuncs(self, frame, why, arg):
Jeremy Hylton38732e12003-04-21 22:04:46 +0000571 """Handler for call events.
Tim Peters0eadaac2003-04-24 16:02:54 +0000572
Jeremy Hylton38732e12003-04-21 22:04:46 +0000573 Adds (filename, modulename, funcname) to the self._calledfuncs dict.
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000574 """
575 if why == 'call':
Skip Montanaro5bfd9842004-04-10 16:29:58 +0000576 this_func = self.file_module_function_of(frame)
577 self._calledfuncs[this_func] = 1
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000578
579 def globaltrace_lt(self, frame, why, arg):
Jeremy Hylton38732e12003-04-21 22:04:46 +0000580 """Handler for call events.
581
582 If the code block being entered is to be ignored, returns `None',
583 else returns self.localtrace.
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000584 """
585 if why == 'call':
Jeremy Hylton38732e12003-04-21 22:04:46 +0000586 code = frame.f_code
587 filename = code.co_filename
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000588 if filename:
Jeremy Hyltondfbfe732003-04-21 22:49:17 +0000589 # XXX modname() doesn't work right for packages, so
590 # the ignore support won't work right for packages
Jeremy Hylton38732e12003-04-21 22:04:46 +0000591 modulename = modname(filename)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000592 if modulename is not None:
593 ignore_it = self.ignore.names(filename, modulename)
594 if not ignore_it:
595 if self.trace:
596 print (" --- modulename: %s, funcname: %s"
Jeremy Hylton38732e12003-04-21 22:04:46 +0000597 % (modulename, code.co_name))
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000598 return self.localtrace
599 else:
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000600 return None
601
602 def localtrace_trace_and_count(self, frame, why, arg):
Jeremy Hylton38732e12003-04-21 22:04:46 +0000603 if why == "line":
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000604 # record the file name and line number of every trace
Jeremy Hylton38732e12003-04-21 22:04:46 +0000605 filename = frame.f_code.co_filename
606 lineno = frame.f_lineno
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000607 key = filename, lineno
608 self.counts[key] = self.counts.get(key, 0) + 1
Tim Petersf2715e02003-02-19 02:35:07 +0000609
Jeremy Hylton38732e12003-04-21 22:04:46 +0000610 bname = os.path.basename(filename)
611 print "%s(%d): %s" % (bname, lineno,
612 linecache.getline(filename, lineno)),
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000613 return self.localtrace
614
615 def localtrace_trace(self, frame, why, arg):
Jeremy Hylton38732e12003-04-21 22:04:46 +0000616 if why == "line":
617 # record the file name and line number of every trace
618 filename = frame.f_code.co_filename
619 lineno = frame.f_lineno
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000620
Jeremy Hylton38732e12003-04-21 22:04:46 +0000621 bname = os.path.basename(filename)
622 print "%s(%d): %s" % (bname, lineno,
623 linecache.getline(filename, lineno)),
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000624 return self.localtrace
625
626 def localtrace_count(self, frame, why, arg):
Jeremy Hylton38732e12003-04-21 22:04:46 +0000627 if why == "line":
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000628 filename = frame.f_code.co_filename
629 lineno = frame.f_lineno
630 key = filename, lineno
631 self.counts[key] = self.counts.get(key, 0) + 1
632 return self.localtrace
633
634 def results(self):
635 return CoverageResults(self.counts, infile=self.infile,
636 outfile=self.outfile,
Skip Montanarocafc8112004-04-07 15:46:05 +0000637 calledfuncs=self._calledfuncs,
638 callers=self._callers)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000639
640def _err_exit(msg):
641 sys.stderr.write("%s: %s\n" % (sys.argv[0], msg))
642 sys.exit(1)
643
644def main(argv=None):
645 import getopt
646
647 if argv is None:
648 argv = sys.argv
649 try:
Skip Montanarocafc8112004-04-07 15:46:05 +0000650 opts, prog_argv = getopt.getopt(argv[1:], "tcrRf:d:msC:lT",
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000651 ["help", "version", "trace", "count",
652 "report", "no-report", "summary",
653 "file=", "missing",
654 "ignore-module=", "ignore-dir=",
Skip Montanarocafc8112004-04-07 15:46:05 +0000655 "coverdir=", "listfuncs",
656 "trackcalls"])
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000657
658 except getopt.error, msg:
659 sys.stderr.write("%s: %s\n" % (sys.argv[0], msg))
660 sys.stderr.write("Try `%s --help' for more information\n"
661 % sys.argv[0])
662 sys.exit(1)
663
664 trace = 0
665 count = 0
666 report = 0
667 no_report = 0
668 counts_file = None
669 missing = 0
670 ignore_modules = []
671 ignore_dirs = []
672 coverdir = None
673 summary = 0
674 listfuncs = False
Skip Montanarocafc8112004-04-07 15:46:05 +0000675 countcallers = False
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000676
677 for opt, val in opts:
678 if opt == "--help":
679 usage(sys.stdout)
680 sys.exit(0)
681
682 if opt == "--version":
683 sys.stdout.write("trace 2.0\n")
684 sys.exit(0)
685
Skip Montanarocafc8112004-04-07 15:46:05 +0000686 if opt == "-T" or opt == "--trackcalls":
687 countcallers = True
688 continue
689
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000690 if opt == "-l" or opt == "--listfuncs":
691 listfuncs = True
692 continue
693
694 if opt == "-t" or opt == "--trace":
695 trace = 1
696 continue
697
698 if opt == "-c" or opt == "--count":
699 count = 1
700 continue
701
702 if opt == "-r" or opt == "--report":
703 report = 1
704 continue
705
706 if opt == "-R" or opt == "--no-report":
707 no_report = 1
708 continue
709
710 if opt == "-f" or opt == "--file":
711 counts_file = val
712 continue
713
714 if opt == "-m" or opt == "--missing":
715 missing = 1
716 continue
717
718 if opt == "-C" or opt == "--coverdir":
719 coverdir = val
720 continue
721
722 if opt == "-s" or opt == "--summary":
723 summary = 1
724 continue
725
726 if opt == "--ignore-module":
727 ignore_modules.append(val)
728 continue
729
730 if opt == "--ignore-dir":
731 for s in val.split(os.pathsep):
732 s = os.path.expandvars(s)
733 # should I also call expanduser? (after all, could use $HOME)
734
735 s = s.replace("$prefix",
736 os.path.join(sys.prefix, "lib",
737 "python" + sys.version[:3]))
738 s = s.replace("$exec_prefix",
739 os.path.join(sys.exec_prefix, "lib",
740 "python" + sys.version[:3]))
741 s = os.path.normpath(s)
742 ignore_dirs.append(s)
743 continue
744
745 assert 0, "Should never get here"
746
747 if listfuncs and (count or trace):
748 _err_exit("cannot specify both --listfuncs and (--trace or --count)")
749
Skip Montanarocafc8112004-04-07 15:46:05 +0000750 if not (count or trace or report or listfuncs or countcallers):
751 _err_exit("must specify one of --trace, --count, --report, "
752 "--listfuncs, or --trackcalls")
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000753
754 if report and no_report:
755 _err_exit("cannot specify both --report and --no-report")
756
757 if report and not counts_file:
758 _err_exit("--report requires a --file")
759
760 if no_report and len(prog_argv) == 0:
761 _err_exit("missing name of file to run")
762
763 # everything is ready
764 if report:
765 results = CoverageResults(infile=counts_file, outfile=counts_file)
766 results.write_results(missing, summary=summary, coverdir=coverdir)
767 else:
768 sys.argv = prog_argv
769 progname = prog_argv[0]
770 sys.path[0] = os.path.split(progname)[0]
771
772 t = Trace(count, trace, countfuncs=listfuncs,
Skip Montanarocafc8112004-04-07 15:46:05 +0000773 countcallers=countcallers, ignoremods=ignore_modules,
774 ignoredirs=ignore_dirs, infile=counts_file,
775 outfile=counts_file)
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000776 try:
Walter Dörwald70a6b492004-02-12 17:35:32 +0000777 t.run('execfile(%r)' % (progname,))
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000778 except IOError, err:
Jeremy Hylton38732e12003-04-21 22:04:46 +0000779 _err_exit("Cannot run file %r because: %s" % (sys.argv[0], err))
Jeremy Hylton4edaa0d2003-02-18 15:06:17 +0000780 except SystemExit:
781 pass
782
783 results = t.results()
784
785 if not no_report:
786 results.write_results(missing, summary=summary, coverdir=coverdir)
787
788if __name__=='__main__':
789 main()