1 #!/usr/bin/python

     2 #

     3 #             Perforce Defect Tracking Integration Project

     4 #              <http://www.ravenbrook.com/project/p4dti/>

     5 #

     6 #                   COVERAGE.PY -- COVERAGE TESTING

     7 #

     8 #             Gareth Rees, Ravenbrook Limited, 2001-12-04

     9 #                     Ned Batchelder, 2004-12-12

    10 #         http://nedbatchelder.com/code/modules/coverage.html

    11 #

    12 #

    13 # 1. INTRODUCTION

    14 #

    15 # This module provides coverage testing for Python code.

    16 #

    17 # The intended readership is all Python developers.

    18 #

    19 # This document is not confidential.

    20 #

    21 # See [GDR 2001-12-04a] for the command-line interface, programmatic

    22 # interface and limitations.  See [GDR 2001-12-04b] for requirements and

    23 # design.

    24 

    25 """Usage:

    26 

    27 coverage.py -x MODULE.py [ARG1 ARG2 ...]

    28     Execute module, passing the given command-line arguments, collecting

    29     coverage data.

    30 

    31 coverage.py -e

    32     Erase collected coverage data.

    33 

    34 coverage.py -r [-m] [-o dir1,dir2,...] FILE1 FILE2 ...

    35     Report on the statement coverage for the given files.  With the -m

    36     option, show line numbers of the statements that weren't executed.

    37 

    38 coverage.py -a [-d dir] [-o dir1,dir2,...] FILE1 FILE2 ...

    39     Make annotated copies of the given files, marking statements that

    40     are executed with > and statements that are missed with !.  With

    41     the -d option, make the copies in that directory.  Without the -d

    42     option, make each copy in the same directory as the original.

    43 

    44 -o dir,dir2,...

    45   Omit reporting or annotating files when their filename path starts with

    46   a directory listed in the omit list.

    47   e.g. python coverage.py -i -r -o c:\python23,lib\enthought\traits

    48 

    49 Coverage data is saved in the file .coverage by default.  Set the

    50 COVERAGE_FILE environment variable to save it somewhere else."""

    51 

    52 __version__ = "2.5.20051204"    # see detailed history at the end of this file.

    53 

    54 import compiler

    55 import compiler.visitor

    56 import os

    57 import re

    58 import string

    59 import sys

    60 import threading

    61 import types

    62 

    63 # 2. IMPLEMENTATION

    64 #

    65 # This uses the "singleton" pattern.

    66 #

    67 # The word "morf" means a module object (from which the source file can

    68 # be deduced by suitable manipulation of the __file__ attribute) or a

    69 # filename.

    70 #

    71 # When we generate a coverage report we have to canonicalize every

    72 # filename in the coverage dictionary just in case it refers to the

    73 # module we are reporting on.  It seems a shame to throw away this

    74 # information so the data in the coverage dictionary is transferred to

    75 # the 'cexecuted' dictionary under the canonical filenames.

    76 #

    77 # The coverage dictionary is called "c" and the trace function "t".  The

    78 # reason for these short names is that Python looks up variables by name

    79 # at runtime and so execution time depends on the length of variables!

    80 # In the bottleneck of this application it's appropriate to abbreviate

    81 # names to increase speed.

    82 

    83 class StatementFindingAstVisitor(compiler.visitor.ASTVisitor):

    84     def __init__(self, statements, excluded, suite_spots):

    85         compiler.visitor.ASTVisitor.__init__(self)

    86         self.statements = statements

    87         self.excluded = excluded

    88         self.suite_spots = suite_spots

    89         self.excluding_suite = 0

    90         

    91     def doRecursive(self, node):

    92         self.recordNodeLine(node)

    93         for n in node.getChildNodes():

    94             self.dispatch(n)

    95 

    96     visitStmt = visitModule = doRecursive

    97     

    98     def doCode(self, node):

    99         if hasattr(node, 'decorators') and node.decorators:

   100             self.dispatch(node.decorators)

   101         self.doSuite(node, node.code)

   102     

   103     visitFunction = visitClass = doCode

   104 

   105     def getFirstLine(self, node):

   106         # Find the first line in the tree node.

   107         lineno = node.lineno

   108         for n in node.getChildNodes():

   109             f = self.getFirstLine(n)

   110             if lineno and f:

   111                 lineno = min(lineno, f)

   112             else:

   113                 lineno = lineno or f

   114         return lineno

   115 

   116     def getLastLine(self, node):

   117         # Find the first line in the tree node.

   118         lineno = node.lineno

   119         for n in node.getChildNodes():

   120             lineno = max(lineno, self.getLastLine(n))

   121         return lineno

   122     

   123     def doStatement(self, node):

   124         self.recordLine(self.getFirstLine(node))

   125 

   126     visitAssert = visitAssign = visitAssTuple = visitDiscard = visitPrint = \

   127         visitPrintnl = visitRaise = visitSubscript = visitDecorators = \

   128         doStatement

   129     

   130     def recordNodeLine(self, node):

   131         return self.recordLine(node.lineno)

   132     

   133     def recordLine(self, lineno):

   134         # Returns a bool, whether the line is included or excluded.

   135         if lineno:

   136             # Multi-line tests introducing suites have to get charged to their

   137             # keyword.

   138             if lineno in self.suite_spots:

   139                 lineno = self.suite_spots[lineno][0]

   140             # If we're inside an exluded suite, record that this line was

   141             # excluded.

   142             if self.excluding_suite:

   143                 self.excluded[lineno] = 1

   144                 return 0

   145             # If this line is excluded, or suite_spots maps this line to

   146             # another line that is exlcuded, then we're excluded.

   147             elif self.excluded.has_key(lineno) or \

   148                  self.suite_spots.has_key(lineno) and \

   149                  self.excluded.has_key(self.suite_spots[lineno][1]):

   150                 return 0

   151             # Otherwise, this is an executable line.

   152             else:

   153                 self.statements[lineno] = 1

   154                 return 1

   155         return 0

   156     

   157     default = recordNodeLine

   158     

   159     def recordAndDispatch(self, node):

   160         self.recordNodeLine(node)

   161         self.dispatch(node)

   162 

   163     def doSuite(self, intro, body, exclude=0):

   164         exsuite = self.excluding_suite

   165         if exclude or (intro and not self.recordNodeLine(intro)):

   166             self.excluding_suite = 1

   167         self.recordAndDispatch(body)

   168         self.excluding_suite = exsuite

   169         

   170     def doPlainWordSuite(self, prevsuite, suite):

   171         # Finding the exclude lines for else's is tricky, because they aren't

   172         # present in the compiler parse tree.  Look at the previous suite,

   173         # and find its last line.  If any line between there and the else's

   174         # first line are excluded, then we exclude the else.

   175         lastprev = self.getLastLine(prevsuite)

   176         firstelse = self.getFirstLine(suite)

   177         for l in range(lastprev+1, firstelse):

   178             if self.suite_spots.has_key(l):

   179                 self.doSuite(None, suite, exclude=self.excluded.has_key(l))

   180                 break

   181         else:

   182             self.doSuite(None, suite)

   183         

   184     def doElse(self, prevsuite, node):

   185         if node.else_:

   186             self.doPlainWordSuite(prevsuite, node.else_)

   187     

   188     def visitFor(self, node):

   189         self.doSuite(node, node.body)

   190         self.doElse(node.body, node)

   191 

   192     def visitIf(self, node):

   193         # The first test has to be handled separately from the rest.

   194         # The first test is credited to the line with the "if", but the others

   195         # are credited to the line with the test for the elif.

   196         self.doSuite(node, node.tests[0][1])

   197         for t, n in node.tests[1:]:

   198             self.doSuite(t, n)

   199         self.doElse(node.tests[-1][1], node)

   200 

   201     def visitWhile(self, node):

   202         self.doSuite(node, node.body)

   203         self.doElse(node.body, node)

   204 

   205     def visitTryExcept(self, node):

   206         self.doSuite(node, node.body)

   207         for i in range(len(node.handlers)):

   208             a, b, h = node.handlers[i]

   209             if not a:

   210                 # It's a plain "except:".  Find the previous suite.

   211                 if i > 0:

   212                     prev = node.handlers[i-1][2]

   213                 else:

   214                     prev = node.body

   215                 self.doPlainWordSuite(prev, h)

   216             else:

   217                 self.doSuite(a, h)

   218         self.doElse(node.handlers[-1][2], node)

   219     

   220     def visitTryFinally(self, node):

   221         self.doSuite(node, node.body)

   222         self.doPlainWordSuite(node.body, node.final)

   223         

   224     def visitGlobal(self, node):

   225         # "global" statements don't execute like others (they don't call the

   226         # trace function), so don't record their line numbers.

   227         pass

   228 

   229 the_coverage = None

   230 

   231 class coverage:

   232     error = "coverage error"

   233 

   234     # Name of the cache file (unless environment variable is set).

   235     cache_default = ".coverage"

   236 

   237     # Environment variable naming the cache file.

   238     cache_env = "COVERAGE_FILE"

   239 

   240     # A dictionary with an entry for (Python source file name, line number

   241     # in that file) if that line has been executed.

   242     c = {}

   243     

   244     # A map from canonical Python source file name to a dictionary in

   245     # which there's an entry for each line number that has been

   246     # executed.

   247     cexecuted = {}

   248 

   249     # Cache of results of calling the analysis2() method, so that you can

   250     # specify both -r and -a without doing double work.

   251     analysis_cache = {}

   252 

   253     # Cache of results of calling the canonical_filename() method, to

   254     # avoid duplicating work.

   255     canonical_filename_cache = {}

   256 

   257     def __init__(self):

   258         global the_coverage

   259         if the_coverage:

   260             raise self.error, "Only one coverage object allowed."

   261         self.usecache = 1

   262         self.cache = None

   263         self.exclude_re = ''

   264         self.nesting = 0

   265         self.cstack = []

   266         self.xstack = []

   267         self.relative_dir = os.path.normcase(os.path.abspath(os.curdir)+os.path.sep)

   268 

   269     # t(f, x, y).  This method is passed to sys.settrace as a trace function.  

   270     # See [van Rossum 2001-07-20b, 9.2] for an explanation of sys.settrace and 

   271     # the arguments and return value of the trace function.

   272     # See [van Rossum 2001-07-20a, 3.2] for a description of frame and code

   273     # objects.

   274     

   275     def t(self, f, w, a):                                   #pragma: no cover

   276         #print w, f.f_code.co_filename, f.f_lineno

   277         if w == 'line':

   278             self.c[(f.f_code.co_filename, f.f_lineno)] = 1

   279             for c in self.cstack:

   280                 c[(f.f_code.co_filename, f.f_lineno)] = 1

   281         return self.t

   282     

   283     def help(self, error=None):

   284         if error:

   285             print error

   286             print

   287         print __doc__

   288         sys.exit(1)

   289 

   290     def command_line(self):

   291         import getopt

   292         settings = {}

   293         optmap = {

   294             '-a': 'annotate',

   295             '-d:': 'directory=',

   296             '-e': 'erase',

   297             '-h': 'help',

   298             '-i': 'ignore-errors',

   299             '-m': 'show-missing',

   300             '-r': 'report',

   301             '-x': 'execute',

   302             '-o': 'omit=',

   303             }

   304         short_opts = string.join(map(lambda o: o[1:], optmap.keys()), '')

   305         long_opts = optmap.values()

   306         options, args = getopt.getopt(sys.argv[1:], short_opts, long_opts)

   307         for o, a in options:

   308             if optmap.has_key(o):

   309                 settings[optmap[o]] = 1

   310             elif optmap.has_key(o + ':'):

   311                 settings[optmap[o + ':']] = a

   312             elif o[2:] in long_opts:

   313                 settings[o[2:]] = 1

   314             elif o[2:] + '=' in long_opts:

   315                 settings[o[2:]] = a

   316             else:

   317                 self.help("Unknown option: '%s'." % o)

   318         if settings.get('help'):

   319             self.help()

   320         for i in ['erase', 'execute']:

   321             for j in ['annotate', 'report']:

   322                 if settings.get(i) and settings.get(j):

   323                     self.help("You can't specify the '%s' and '%s' "

   324                               "options at the same time." % (i, j))

   325         args_needed = (settings.get('execute')

   326                        or settings.get('annotate')

   327                        or settings.get('report'))

   328         action = settings.get('erase') or args_needed

   329         if not action:

   330             self.help("You must specify at least one of -e, -x, -r, or -a.")

   331         if not args_needed and args:

   332             self.help("Unexpected arguments %s." % args)

   333         

   334         self.get_ready()

   335         self.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')

   336 

   337         if settings.get('erase'):

   338             self.erase()

   339         if settings.get('execute'):

   340             if not args:

   341                 self.help("Nothing to do.")

   342             sys.argv = args

   343             self.start()

   344             import __main__

   345             sys.path[0] = os.path.dirname(sys.argv[0])

   346             execfile(sys.argv[0], __main__.__dict__)

   347         if not args:

   348             args = self.cexecuted.keys()

   349         ignore_errors = settings.get('ignore-errors')

   350         show_missing = settings.get('show-missing')

   351         directory = settings.get('directory=')

   352         omit = settings.get('omit=')

   353         if omit is not None:

   354             omit = omit.split(',')

   355         else:

   356             omit = []

   357 

   358         if settings.get('report'):

   359             self.report(args, show_missing, ignore_errors, omit_prefixes=omit)

   360         if settings.get('annotate'):

   361             self.annotate(args, directory, ignore_errors, omit_prefixes=omit)

   362 

   363     def use_cache(self, usecache):

   364         self.usecache = usecache

   365         

   366     def get_ready(self):

   367         if self.usecache and not self.cache:

   368             self.cache = os.environ.get(self.cache_env, self.cache_default)

   369             self.restore()

   370         self.analysis_cache = {}

   371         

   372     def start(self):

   373         self.get_ready()

   374         if self.nesting == 0:                               #pragma: no cover

   375             sys.settrace(self.t)

   376             if hasattr(threading, 'settrace'):

   377                 threading.settrace(self.t)

   378         self.nesting += 1

   379         

   380     def stop(self):

   381         self.nesting -= 1

   382         if self.nesting == 0:                               #pragma: no cover

   383             sys.settrace(None)

   384             if hasattr(threading, 'settrace'):

   385                 threading.settrace(None)

   386 

   387     def erase(self):

   388         self.c = {}

   389         self.analysis_cache = {}

   390         self.cexecuted = {}

   391         if self.cache and os.path.exists(self.cache):

   392             os.remove(self.cache)

   393         self.exclude_re = ""

   394 

   395     def exclude(self, re):

   396         if self.exclude_re:

   397             self.exclude_re += "|"

   398         self.exclude_re += "(" + re + ")"

   399 

   400     def begin_recursive(self):

   401         self.cstack.append(self.c)

   402         self.xstack.append(self.exclude_re)

   403         

   404     def end_recursive(self):

   405         self.c = self.cstack.pop()

   406         self.exclude_re = self.xstack.pop()

   407 

   408     # save().  Save coverage data to the coverage cache.

   409 

   410     def save(self):

   411         if self.usecache and self.cache:

   412             self.canonicalize_filenames()

   413             cache = open(self.cache, 'wb')

   414             import marshal

   415             marshal.dump(self.cexecuted, cache)

   416             cache.close()

   417 

   418     # restore().  Restore coverage data from the coverage cache (if it exists).

   419 

   420     def restore(self):

   421         self.c = {}

   422         self.cexecuted = {}

   423         assert self.usecache

   424         if not os.path.exists(self.cache):

   425             return

   426         try:

   427             cache = open(self.cache, 'rb')

   428             import marshal

   429             cexecuted = marshal.load(cache)

   430             cache.close()

   431             if isinstance(cexecuted, types.DictType):

   432                 self.cexecuted = cexecuted

   433         except:

   434             pass

   435 

   436     # canonical_filename(filename).  Return a canonical filename for the

   437     # file (that is, an absolute path with no redundant components and

   438     # normalized case).  See [GDR 2001-12-04b, 3.3].

   439 

   440     def canonical_filename(self, filename):

   441         if not self.canonical_filename_cache.has_key(filename):

   442             f = filename

   443             if os.path.isabs(f) and not os.path.exists(f):

   444                 f = os.path.basename(f)

   445             if not os.path.isabs(f):

   446                 for path in [os.curdir] + sys.path:

   447                     g = os.path.join(path, f)

   448                     if os.path.exists(g):

   449                         f = g

   450                         break

   451             cf = os.path.normcase(os.path.abspath(f))

   452             self.canonical_filename_cache[filename] = cf

   453         return self.canonical_filename_cache[filename]

   454 

   455     # canonicalize_filenames().  Copy results from "c" to "cexecuted", 

   456     # canonicalizing filenames on the way.  Clear the "c" map.

   457 

   458     def canonicalize_filenames(self):

   459         for filename, lineno in self.c.keys():

   460             f = self.canonical_filename(filename)

   461             if not self.cexecuted.has_key(f):

   462                 self.cexecuted[f] = {}

   463             self.cexecuted[f][lineno] = 1

   464         self.c = {}

   465 

   466     # morf_filename(morf).  Return the filename for a module or file.

   467 

   468     def morf_filename(self, morf):

   469         if isinstance(morf, types.ModuleType):

   470             if not hasattr(morf, '__file__'):

   471                 raise self.error, "Module has no __file__ attribute."

   472             file = morf.__file__

   473         else:

   474             file = morf

   475         return self.canonical_filename(file)

   476 

   477     # analyze_morf(morf).  Analyze the module or filename passed as

   478     # the argument.  If the source code can't be found, raise an error.

   479     # Otherwise, return a tuple of (1) the canonical filename of the

   480     # source code for the module, (2) a list of lines of statements

   481     # in the source code, and (3) a list of lines of excluded statements.

   482 

   483     def analyze_morf(self, morf):

   484         if self.analysis_cache.has_key(morf):

   485             return self.analysis_cache[morf]

   486         filename = self.morf_filename(morf)

   487         ext = os.path.splitext(filename)[1]

   488         if ext == '.pyc':

   489             if not os.path.exists(filename[0:-1]):

   490                 raise self.error, ("No source for compiled code '%s'."

   491                                    % filename)

   492             filename = filename[0:-1]

   493         elif ext != '.py':

   494             raise self.error, "File '%s' not Python source." % filename

   495         source = open(filename, 'r')

   496         lines, excluded_lines = self.find_executable_statements(

   497             source.read(), exclude=self.exclude_re

   498             )

   499         source.close()

   500         result = filename, lines, excluded_lines

   501         self.analysis_cache[morf] = result

   502         return result

   503 

   504     def get_suite_spots(self, tree, spots):

   505         import symbol, token

   506         for i in range(1, len(tree)):

   507             if type(tree[i]) == type(()):

   508                 if tree[i][0] == symbol.suite:

   509                     # Found a suite, look back for the colon and keyword.

   510                     lineno_colon = lineno_word = None

   511                     for j in range(i-1, 0, -1):

   512                         if tree[j][0] == token.COLON:

   513                             lineno_colon = tree[j][2]

   514                         elif tree[j][0] == token.NAME:

   515                             if tree[j][1] == 'elif':

   516                                 # Find the line number of the first non-terminal

   517                                 # after the keyword.

   518                                 t = tree[j+1]

   519                                 while t and token.ISNONTERMINAL(t[0]):

   520                                     t = t[1]

   521                                 if t:

   522                                     lineno_word = t[2]

   523                             else:

   524                                 lineno_word = tree[j][2]

   525                             break

   526                         elif tree[j][0] == symbol.except_clause:

   527                             # "except" clauses look like:

   528                             # ('except_clause', ('NAME', 'except', lineno), ...)

   529                             if tree[j][1][0] == token.NAME:

   530                                 lineno_word = tree[j][1][2]

   531                                 break

   532                     if lineno_colon and lineno_word:

   533                         # Found colon and keyword, mark all the lines

   534                         # between the two with the two line numbers.

   535                         for l in range(lineno_word, lineno_colon+1):

   536                             spots[l] = (lineno_word, lineno_colon)

   537                 self.get_suite_spots(tree[i], spots)

   538 

   539     def find_executable_statements(self, text, exclude=None):

   540         # Find lines which match an exclusion pattern.

   541         excluded = {}

   542         suite_spots = {}

   543         if exclude:

   544             reExclude = re.compile(exclude)

   545             lines = text.split('\n')

   546             for i in range(len(lines)):

   547                 if reExclude.search(lines[i]):

   548                     excluded[i+1] = 1

   549 

   550         import parser

   551         tree = parser.suite(text+'\n\n').totuple(1)

   552         self.get_suite_spots(tree, suite_spots)

   553             

   554         # Use the compiler module to parse the text and find the executable

   555         # statements.  We add newlines to be impervious to final partial lines.

   556         statements = {}

   557         ast = compiler.parse(text+'\n\n')

   558         visitor = StatementFindingAstVisitor(statements, excluded, suite_spots)

   559         compiler.walk(ast, visitor, walker=visitor)

   560 

   561         lines = statements.keys()

   562         lines.sort()

   563         excluded_lines = excluded.keys()

   564         excluded_lines.sort()

   565         return lines, excluded_lines

   566 

   567     # format_lines(statements, lines).  Format a list of line numbers

   568     # for printing by coalescing groups of lines as long as the lines

   569     # represent consecutive statements.  This will coalesce even if

   570     # there are gaps between statements, so if statements =

   571     # [1,2,3,4,5,10,11,12,13,14] and lines = [1,2,5,10,11,13,14] then

   572     # format_lines will return "1-2, 5-11, 13-14".

   573 

   574     def format_lines(self, statements, lines):

   575         pairs = []

   576         i = 0

   577         j = 0

   578         start = None

   579         pairs = []

   580         while i < len(statements) and j < len(lines):

   581             if statements[i] == lines[j]:

   582                 if start == None:

   583                     start = lines[j]

   584                 end = lines[j]

   585                 j = j + 1

   586             elif start:

   587                 pairs.append((start, end))

   588                 start = None

   589             i = i + 1

   590         if start:

   591             pairs.append((start, end))

   592         def stringify(pair):

   593             start, end = pair

   594             if start == end:

   595                 return "%d" % start

   596             else:

   597                 return "%d-%d" % (start, end)

   598         return string.join(map(stringify, pairs), ", ")

   599 

   600     # Backward compatibility with version 1.

   601     def analysis(self, morf):

   602         f, s, _, m, mf = self.analysis2(morf)

   603         return f, s, m, mf

   604 

   605     def analysis2(self, morf):

   606         filename, statements, excluded = self.analyze_morf(morf)

   607         self.canonicalize_filenames()

   608         if not self.cexecuted.has_key(filename):

   609             self.cexecuted[filename] = {}

   610         missing = []

   611         for line in statements:

   612             if not self.cexecuted[filename].has_key(line):

   613                 missing.append(line)

   614         return (filename, statements, excluded, missing,

   615                 self.format_lines(statements, missing))

   616 

   617     def relative_filename(self, filename):

   618         """ Convert filename to relative filename from self.relative_dir.

   619         """

   620         return filename.replace(self.relative_dir, "")

   621 

   622     def morf_name(self, morf):

   623         """ Return the name of morf as used in report.

   624         """

   625         if isinstance(morf, types.ModuleType):

   626             return morf.__name__

   627         else:

   628             return self.relative_filename(os.path.splitext(morf)[0])

   629 

   630     def filter_by_prefix(self, morfs, omit_prefixes):

   631         """ Return list of morfs where the morf name does not begin

   632             with any one of the omit_prefixes.

   633         """

   634         filtered_morfs = []

   635         for morf in morfs:

   636             for prefix in omit_prefixes:

   637                 if self.morf_name(morf).startswith(prefix):

   638                     break

   639             else:

   640                 filtered_morfs.append(morf)

   641 

   642         return filtered_morfs

   643 

   644     def morf_name_compare(self, x, y):

   645         return cmp(self.morf_name(x), self.morf_name(y))

   646 

   647     def report(self, morfs, show_missing=1, ignore_errors=0, file=None, omit_prefixes=[]):

   648         if not isinstance(morfs, types.ListType):

   649             morfs = [morfs]

   650         morfs = self.filter_by_prefix(morfs, omit_prefixes)

   651         morfs.sort(self.morf_name_compare)

   652 

   653         max_name = max([5,] + map(len, map(self.morf_name, morfs)))

   654         fmt_name = "%%- %ds  " % max_name

   655         fmt_err = fmt_name + "%s: %s"

   656         header = fmt_name % "Name" + " Stmts   Exec  Cover"

   657         fmt_coverage = fmt_name + "% 6d % 6d % 5d%%"

   658         if show_missing:

   659             header = header + "   Missing"

   660             fmt_coverage = fmt_coverage + "   %s"

   661         if not file:

   662             file = sys.stdout

   663         print >>file, header

   664         print >>file, "-" * len(header)

   665         total_statements = 0

   666         total_executed = 0

   667         for morf in morfs:

   668             name = self.morf_name(morf)

   669             try:

   670                 _, statements, _, missing, readable  = self.analysis2(morf)

   671                 n = len(statements)

   672                 m = n - len(missing)

   673                 if n > 0:

   674                     pc = 100.0 * m / n

   675                 else:

   676                     pc = 100.0

   677                 args = (name, n, m, pc)

   678                 if show_missing:

   679                     args = args + (readable,)

   680                 print >>file, fmt_coverage % args

   681                 total_statements = total_statements + n

   682                 total_executed = total_executed + m

   683             except KeyboardInterrupt:                       #pragma: no cover

   684                 raise

   685             except:

   686                 if not ignore_errors:

   687                     type, msg = sys.exc_info()[0:2]

   688                     print >>file, fmt_err % (name, type, msg)

   689         if len(morfs) > 1:

   690             print >>file, "-" * len(header)

   691             if total_statements > 0:

   692                 pc = 100.0 * total_executed / total_statements

   693             else:

   694                 pc = 100.0

   695             args = ("TOTAL", total_statements, total_executed, pc)

   696             if show_missing:

   697                 args = args + ("",)

   698             print >>file, fmt_coverage % args

   699 

   700     # annotate(morfs, ignore_errors).

   701 

   702     blank_re = re.compile(r"\s*(#|$)")

   703     else_re = re.compile(r"\s*else\s*:\s*(#|$)")

   704 

   705     def annotate(self, morfs, directory=None, ignore_errors=0, omit_prefixes=[]):

   706         morfs = self.filter_by_prefix(morfs, omit_prefixes)

   707         for morf in morfs:

   708             try:

   709                 filename, statements, excluded, missing, _ = self.analysis2(morf)

   710                 self.annotate_file(filename, statements, excluded, missing, directory)

   711             except KeyboardInterrupt:

   712                 raise

   713             except:

   714                 if not ignore_errors:

   715                     raise

   716                 

   717     def annotate_file(self, filename, statements, excluded, missing, directory=None):

   718         source = open(filename, 'r')

   719         if directory:

   720             dest_file = os.path.join(directory,

   721                                      os.path.basename(filename)

   722                                      + ',cover')

   723         else:

   724             dest_file = filename + ',cover'

   725         dest = open(dest_file, 'w')

   726         lineno = 0

   727         i = 0

   728         j = 0

   729         covered = 1

   730         while 1:

   731             line = source.readline()

   732             if line == '':

   733                 break

   734             lineno = lineno + 1

   735             while i < len(statements) and statements[i] < lineno:

   736                 i = i + 1

   737             while j < len(missing) and missing[j] < lineno:

   738                 j = j + 1

   739             if i < len(statements) and statements[i] == lineno:

   740                 covered = j >= len(missing) or missing[j] > lineno

   741             if self.blank_re.match(line):

   742                 dest.write('  ')

   743             elif self.else_re.match(line):

   744                 # Special logic for lines containing only 'else:'.  

   745                 # See [GDR 2001-12-04b, 3.2].

   746                 if i >= len(statements) and j >= len(missing):

   747                     dest.write('! ')

   748                 elif i >= len(statements) or j >= len(missing):

   749                     dest.write('> ')

   750                 elif statements[i] == missing[j]:

   751                     dest.write('! ')

   752                 else:

   753                     dest.write('> ')

   754             elif lineno in excluded:

   755                 dest.write('- ')

   756             elif covered:

   757                 dest.write('> ')

   758             else:

   759                 dest.write('! ')

   760             dest.write(line)

   761         source.close()

   762         dest.close()

   763 

   764 # Singleton object.

   765 the_coverage = coverage()

   766 

   767 # Module functions call methods in the singleton object.

   768 def use_cache(*args, **kw): return the_coverage.use_cache(*args, **kw)

   769 def start(*args, **kw): return the_coverage.start(*args, **kw)

   770 def stop(*args, **kw): return the_coverage.stop(*args, **kw)

   771 def erase(*args, **kw): return the_coverage.erase(*args, **kw)

   772 def begin_recursive(*args, **kw): return the_coverage.begin_recursive(*args, **kw)

   773 def end_recursive(*args, **kw): return the_coverage.end_recursive(*args, **kw)

   774 def exclude(*args, **kw): return the_coverage.exclude(*args, **kw)

   775 def analysis(*args, **kw): return the_coverage.analysis(*args, **kw)

   776 def analysis2(*args, **kw): return the_coverage.analysis2(*args, **kw)

   777 def report(*args, **kw): return the_coverage.report(*args, **kw)

   778 def annotate(*args, **kw): return the_coverage.annotate(*args, **kw)

   779 def annotate_file(*args, **kw): return the_coverage.annotate_file(*args, **kw)

   780 

   781 # Save coverage data when Python exits.  (The atexit module wasn't

   782 # introduced until Python 2.0, so use sys.exitfunc when it's not

   783 # available.)

   784 try:

   785     import atexit

   786     atexit.register(the_coverage.save)

   787 except ImportError:

   788     sys.exitfunc = the_coverage.save

   789 

   790 # Command-line interface.

   791 if __name__ == '__main__':

   792     the_coverage.command_line()

   793 

   794 

   795 # A. REFERENCES

   796 #

   797 # [GDR 2001-12-04a] "Statement coverage for Python"; Gareth Rees;

   798 # Ravenbrook Limited; 2001-12-04;

   799 # <http://www.nedbatchelder.com/code/modules/rees-coverage.html>.

   800 #

   801 # [GDR 2001-12-04b] "Statement coverage for Python: design and

   802 # analysis"; Gareth Rees; Ravenbrook Limited; 2001-12-04;

   803 # <http://www.nedbatchelder.com/code/modules/rees-design.html>.

   804 #

   805 # [van Rossum 2001-07-20a] "Python Reference Manual (releae 2.1.1)";

   806 # Guide van Rossum; 2001-07-20;

   807 # <http://www.python.org/doc/2.1.1/ref/ref.html>.

   808 #

   809 # [van Rossum 2001-07-20b] "Python Library Reference"; Guido van Rossum;

   810 # 2001-07-20; <http://www.python.org/doc/2.1.1/lib/lib.html>.

   811 #

   812 #

   813 # B. DOCUMENT HISTORY

   814 #

   815 # 2001-12-04 GDR Created.

   816 #

   817 # 2001-12-06 GDR Added command-line interface and source code

   818 # annotation.

   819 #

   820 # 2001-12-09 GDR Moved design and interface to separate documents.

   821 #

   822 # 2001-12-10 GDR Open cache file as binary on Windows.  Allow

   823 # simultaneous -e and -x, or -a and -r.

   824 #

   825 # 2001-12-12 GDR Added command-line help.  Cache analysis so that it

   826 # only needs to be done once when you specify -a and -r.

   827 #

   828 # 2001-12-13 GDR Improved speed while recording.  Portable between

   829 # Python 1.5.2 and 2.1.1.

   830 #

   831 # 2002-01-03 GDR Module-level functions work correctly.

   832 #

   833 # 2002-01-07 GDR Update sys.path when running a file with the -x option,

   834 # so that it matches the value the program would get if it were run on

   835 # its own.

   836 #

   837 # 2004-12-12 NMB Significant code changes.

   838 # - Finding executable statements has been rewritten so that docstrings and

   839 #   other quirks of Python execution aren't mistakenly identified as missing

   840 #   lines.

   841 # - Lines can be excluded from consideration, even entire suites of lines.

   842 # - The filesystem cache of covered lines can be disabled programmatically.

   843 # - Modernized the code.

   844 #

   845 # 2004-12-14 NMB Minor tweaks.  Return 'analysis' to its original behavior

   846 # and add 'analysis2'.  Add a global for 'annotate', and factor it, adding

   847 # 'annotate_file'.

   848 #

   849 # 2004-12-31 NMB Allow for keyword arguments in the module global functions.

   850 # Thanks, Allen.

   851 #

   852 # 2005-12-02 NMB Call threading.settrace so that all threads are measured.

   853 # Thanks Martin Fuzzey. Add a file argument to report so that reports can be 

   854 # captured to a different destination.

   855 #

   856 # 2005-12-03 NMB coverage.py can now measure itself.

   857 #

   858 # 2005-12-04 NMB Adapted Greg Rogers' patch for using relative filenames,

   859 # and sorting and omitting files to report on.

   860 #

   861 # C. COPYRIGHT AND LICENCE

   862 #

   863 # Copyright 2001 Gareth Rees.  All rights reserved.

   864 # Copyright 2004-2005 Ned Batchelder.  All rights reserved.

   865 #

   866 # Redistribution and use in source and binary forms, with or without

   867 # modification, are permitted provided that the following conditions are

   868 # met:

   869 #

   870 # 1. Redistributions of source code must retain the above copyright

   871 #    notice, this list of conditions and the following disclaimer.

   872 #

   873 # 2. Redistributions in binary form must reproduce the above copyright

   874 #    notice, this list of conditions and the following disclaimer in the

   875 #    documentation and/or other materials provided with the

   876 #    distribution.

   877 #

   878 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

   879 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

   880 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

   881 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

   882 # HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

   883 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

   884 # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS

   885 # OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

   886 # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR

   887 # TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

   888 # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH

   889 # DAMAGE.

   890 #

   891 # $Id: coverage.py 26 2005-12-04 18:42:44Z ned $