mercurial-scm/hg: comparison tests/coverage.py

equal deleted inserted replaced

-:027264e720aa
+:0145f9afb0e7
 compiler.visitor.ASTVisitor.__init__(self)
 self.statements = statements
 self.excluded = excluded
 self.suite_spots = suite_spots
 self.excluding_suite = 0
 def doRecursive(self, node):
 for n in node.getChildNodes():
 self.dispatch(n)
 visitStmt = visitModule = doRecursive
 def doCode(self, node):
 if hasattr(node, 'decorators') and node.decorators:
 self.dispatch(node.decorators)
 self.recordAndDispatch(node.code)
 else:
 self.doSuite(node, node.code)
 visitFunction = visitClass = doCode
 def getFirstLine(self, node):
 # Find the first line in the tree node.
 lineno = node.lineno
 # Find the first line in the tree node.
 lineno = node.lineno
 for n in node.getChildNodes():
 lineno = max(lineno, self.getLastLine(n))
 return lineno
 def doStatement(self, node):
 self.recordLine(self.getFirstLine(node))
 visitAssert = visitAssign = visitAssTuple = visitPrint = \
 visitPrintnl = visitRaise = visitSubscript = visitDecorators = \
 doStatement
 def visitPass(self, node):
 # Pass statements have weird interactions with docstrings.  If this
 # pass statement is part of one of those pairs, claim that the statement
 # is on the later of the two lines.
 l = node.lineno
 if l:
 lines = self.suite_spots.get(l, [l,l])
 self.statements[lines[1]] = 1
 def visitDiscard(self, node):
 # Discard nodes are statements that execute an expression, but then
 # discard the results.  This includes function calls, so we can't
 # ignore them all.  But if the expression is a constant, the statement
 # won't be "executed", so don't count it now.
 if node.expr.__class__.__name__ != 'Const':
 self.doStatement(node)
 # like "global a").
 if node.__class__.__name__ != 'Stmt':
 return self.recordLine(self.getFirstLine(node))
 else:
 return 0
 def recordLine(self, lineno):
 # Returns a bool, whether the line is included or excluded.
 if lineno:
 # Multi-line tests introducing suites have to get charged to their
 # keyword.
 # Otherwise, this is an executable line.
 else:
 self.statements[lineno] = 1
 return 1
 return 0
 default = recordNodeLine
 def recordAndDispatch(self, node):
 self.recordNodeLine(node)
 self.dispatch(node)
 def doSuite(self, intro, body, exclude=0):
 exsuite = self.excluding_suite
 if exclude or (intro and not self.recordNodeLine(intro)):
 self.excluding_suite = 1
 self.recordAndDispatch(body)
 self.excluding_suite = exsuite
 def doPlainWordSuite(self, prevsuite, suite):
 # Finding the exclude lines for else's is tricky, because they aren't
 # present in the compiler parse tree.  Look at the previous suite,
 # and find its last line.  If any line between there and the else's
 # first line are excluded, then we exclude the else.
 if self.suite_spots.has_key(l):
 self.doSuite(None, suite, exclude=self.excluded.has_key(l))
 break
 else:
 self.doSuite(None, suite)
 def doElse(self, prevsuite, node):
 if node.else_:
 self.doPlainWordSuite(prevsuite, node.else_)
 def visitFor(self, node):
 self.doSuite(node, node.body)
 self.doElse(node.body, node)
 visitWhile = visitFor
 prev = node.body
 self.doPlainWordSuite(prev, h)
 else:
 self.doSuite(a, h)
 self.doElse(node.handlers[-1][2], node)
 def visitTryFinally(self, node):
 self.doSuite(node, node.body)
 self.doPlainWordSuite(node.body, node.final)
 def visitWith(self, node):
 self.doSuite(node, node.body)
 def visitGlobal(self, node):
 # "global" statements don't execute like others (they don't call the
 # trace function), so don't record their line numbers.
 pass
 cache_env = "COVERAGE_FILE"
 # A dictionary with an entry for (Python source file name, line number
 # in that file) if that line has been executed.
 c = {}
 # A map from canonical Python source file name to a dictionary in
 # which there's an entry for each line number that has been
 # executed.
 cexecuted = {}
 self.cstack = []
 self.xstack = []
 self.relative_dir = os.path.normcase(os.path.abspath(os.curdir)+os.sep)
 self.exclude('# *pragma[: ]*[nN][oO] *[cC][oO][vV][eE][rR]')
 # t(f, x, y).  This method is passed to sys.settrace as a trace function.
 # See [van Rossum 2001-07-20b, 9.2] for an explanation of sys.settrace and
 # the arguments and return value of the trace function.
 # See [van Rossum 2001-07-20a, 3.2] for a description of frame and code
 # objects.
 def t(self, f, w, unused):                                   #pragma: no cover
 if w == 'line':
 #print "Executing %s @ %d" % (f.f_code.co_filename, f.f_lineno)
 self.c[(f.f_code.co_filename, f.f_lineno)] = 1
 for c in self.cstack:
 c[(f.f_code.co_filename, f.f_lineno)] = 1
 return self.t
 def help(self, error=None):     #pragma: no cover
 if error:
 print error
 print
 print __doc__
 "options at the same time." % (i, j))
 args_needed = (settings.get('execute')
 or settings.get('annotate')
 or settings.get('report'))
 action = (settings.get('erase')
 or settings.get('collect')
 or args_needed)
 if not action:
 help_fn("You must specify at least one of -e, -x, -c, -r, or -a.")
 if not args_needed and args:
 help_fn("Unexpected arguments: %s" % " ".join(args))
 self.parallel_mode = settings.get('parallel-mode')
 self.get_ready()
 if settings.get('erase'):
 self.erase()
 execfile(sys.argv[0], __main__.__dict__)
 if settings.get('collect'):
 self.collect()
 if not args:
 args = self.cexecuted.keys()
 ignore_errors = settings.get('ignore-errors')
 show_missing = settings.get('show-missing')
 directory = settings.get('directory=')
 omit = settings.get('omit=')
 def use_cache(self, usecache, cache_file=None):
 self.usecache = usecache
 if cache_file and not self.cache:
 self.cache_default = cache_file
 def get_ready(self, parallel_mode=False):
 if self.usecache and not self.cache:
 self.cache = os.environ.get(self.cache_env, self.cache_default)
 if self.parallel_mode:
 self.cache += "." + gethostname() + "." + str(os.getpid())
 self.restore()
 self.analysis_cache = {}
 def start(self, parallel_mode=False):
 self.get_ready()
 if self.nesting == 0:                               #pragma: no cover
 sys.settrace(self.t)
 if hasattr(threading, 'settrace'):
 threading.settrace(self.t)
 self.nesting += 1
 def stop(self):
 self.nesting -= 1
 if self.nesting == 0:                               #pragma: no cover
 sys.settrace(None)
 if hasattr(threading, 'settrace'):
 self.exclude_re += "(" + re + ")"
 def begin_recursive(self):
 self.cstack.append(self.c)
 self.xstack.append(self.exclude_re)
 def end_recursive(self):
 self.c = self.cstack.pop()
 self.exclude_re = self.xstack.pop()
 # save().  Save coverage data to the coverage cache.
 break
 cf = os.path.normcase(os.path.abspath(f))
 self.canonical_filename_cache[filename] = cf
 return self.canonical_filename_cache[filename]
 # canonicalize_filenames().  Copy results from "c" to "cexecuted",
 # canonicalizing filenames on the way.  Clear the "c" map.
 def canonicalize_filenames(self):
 for filename, lineno in self.c.keys():
 if filename == '<string>':
 # Otherwise, return a tuple of (1) the canonical filename of the
 # source code for the module, (2) a list of lines of statements
 # in the source code, (3) a list of lines of excluded statements,
 # and (4), a map of line numbers to multi-line line number ranges, for
 # statements that cross lines.
 def analyze_morf(self, morf):
 if self.analysis_cache.has_key(morf):
 return self.analysis_cache[morf]
 filename = self.morf_filename(morf)
 ext = os.path.splitext(filename)[1]
 def first_line_of_tree(self, tree):
 while True:
 if len(tree) == 3 and type(tree[2]) == type(1):
 return tree[2]
 tree = tree[1]
 def last_line_of_tree(self, tree):
 while True:
 if len(tree) == 3 and type(tree[2]) == type(1):
 return tree[2]
 tree = tree[-1]
 def find_docstring_pass_pair(self, tree, spots):
 for i in range(1, len(tree)):
 if self.is_string_constant(tree[i]) and self.is_pass_stmt(tree[i+1]):
 first_line = self.first_line_of_tree(tree[i])
 last_line = self.last_line_of_tree(tree[i+1])
 self.record_multiline(spots, first_line, last_line)
 def is_string_constant(self, tree):
 try:
 return tree[0] == symbol.stmt and tree[1][1][1][0] == symbol.expr_stmt
 except:
 return False
 def is_pass_stmt(self, tree):
 try:
 return tree[0] == symbol.stmt and tree[1][1][1][0] == symbol.pass_stmt
 except:
 return False
 def record_multiline(self, spots, i, j):
 for l in range(i, j+1):
 spots[l] = (i, j)
 def get_suite_spots(self, tree, spots):
 """ Analyze a parse tree to find suite introducers which span a number
 of lines.
 """
 for i in range(1, len(tree)):
 # "pass" statements are tricky: different versions of Python
 # treat them differently, especially in the common case of a
 # function with a doc string and a single pass statement.
 self.find_docstring_pass_pair(tree[i], spots)
 elif tree[i][0] == symbol.simple_stmt:
 first_line = self.first_line_of_tree(tree[i])
 last_line = self.last_line_of_tree(tree[i])
 if first_line != last_line:
 self.record_multiline(spots, first_line, last_line)
 # are multiline, and where suites begin and end.
 import parser
 tree = parser.suite(text+'\n\n').totuple(1)
 self.get_suite_spots(tree, suite_spots)
 #print "Suite spots:", suite_spots
 # Use the compiler module to parse the text and find the executable
 # statements.  We add newlines to be impervious to final partial lines.
 statements = {}
 ast = compiler.parse(text+'\n\n')
 visitor = StatementFindingAstVisitor(statements, excluded, suite_spots)
 if isinstance(morf, strclass):
 globbed.extend(glob.glob(morf))
 else:
 globbed.append(morf)
 morfs = globbed
 morfs = self.filter_by_prefix(morfs, omit_prefixes)
 morfs.sort(self.morf_name_compare)
 max_name = max([5,] + map(len, map(self.morf_name, morfs)))
 fmt_name = "%%- %ds  " % max_name
 except KeyboardInterrupt:
 raise
 except:
 if not ignore_errors:
 raise
 def annotate_file(self, filename, statements, excluded, missing, directory=None):
 source = open(filename, 'r')
 if directory:
 dest_file = os.path.join(directory,
 os.path.basename(filename)
 if i < len(statements) and statements[i] == lineno:
 covered = j >= len(missing) or missing[j] > lineno
 if self.blank_re.match(line):
 dest.write('  ')
 elif self.else_re.match(line):
 # Special logic for lines containing only 'else:'.
 # See [GDR 2001-12-04b, 3.2].
 if i >= len(statements) and j >= len(missing):
 dest.write('! ')
 elif i >= len(statements) or j >= len(missing):
 dest.write('> ')
 # Singleton object.
 the_coverage = coverage()
 # Module functions call methods in the singleton object.
 def use_cache(*args, **kw):
 return the_coverage.use_cache(*args, **kw)
 def start(*args, **kw):
 return the_coverage.start(*args, **kw)
 def stop(*args, **kw):
 return the_coverage.stop(*args, **kw)
 def erase(*args, **kw):
 return the_coverage.erase(*args, **kw)
 def begin_recursive(*args, **kw):
 return the_coverage.begin_recursive(*args, **kw)
 def end_recursive(*args, **kw):
 return the_coverage.end_recursive(*args, **kw)
 def exclude(*args, **kw):
 return the_coverage.exclude(*args, **kw)
 def analysis(*args, **kw):
 return the_coverage.analysis(*args, **kw)
 def analysis2(*args, **kw):
 return the_coverage.analysis2(*args, **kw)
 def report(*args, **kw):
 return the_coverage.report(*args, **kw)
 def annotate(*args, **kw):
 return the_coverage.annotate(*args, **kw)
 def annotate_file(*args, **kw):
 return the_coverage.annotate_file(*args, **kw)
 # Save coverage data when Python exits.  (The atexit module wasn't
 # introduced until Python 2.0, so use sys.exitfunc when it's not
 # available.)
 #
 # 2004-12-31 NMB Allow for keyword arguments in the module global functions.
 # Thanks, Allen.
 #
 # 2005-12-02 NMB Call threading.settrace so that all threads are measured.
 # Thanks Martin Fuzzey. Add a file argument to report so that reports can be
 # captured to a different destination.
 #
 # 2005-12-03 NMB coverage.py can now measure itself.
 #
 # 2005-12-04 NMB Adapted Greg Rogers' patch for using relative filenames,

changeset 5760	0145f9afb0e7
parent 5594	8623debad845
child 5915	d0576d065993