mercurial: comparison tests/coverage.py

equal deleted inserted replaced

-:a5603ad915c5
+:53e843840349
 compiler.visitor.ASTVisitor.__init__(self)
 self.statements = statements
 self.excluded = excluded
 self.suite_spots = suite_spots
 self.excluding_suite = 0
 def doRecursive(self, node):
 self.recordNodeLine(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.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 = visitDiscard = visitPrint = \
 visitPrintnl = visitRaise = visitSubscript = visitDecorators = \
 doStatement
 def recordNodeLine(self, node):
 return self.recordLine(node.lineno)
 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)
 def visitIf(self, node):
 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 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.nesting = 0
 self.cstack = []
 self.xstack = []
 self.relative_dir = os.path.normcase(os.path.abspath(os.curdir)+os.path.sep)
 # 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, a):                                   #pragma: no cover
 #print w, f.f_code.co_filename, f.f_lineno
 if w == 'line':
 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):
 if error:
 print error
 print
 print __doc__
 action = settings.get('erase') or args_needed
 if not action:
 self.help("You must specify at least one of -e, -x, -r, or -a.")
 if not args_needed and args:
 self.help("Unexpected arguments %s." % args)
 self.get_ready()
 self.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')
 if settings.get('erase'):
 self.erase()
 if settings.get('annotate'):
 self.annotate(args, directory, ignore_errors, omit_prefixes=omit)
 def use_cache(self, usecache):
 self.usecache = usecache
 def get_ready(self):
 if self.usecache and not self.cache:
 self.cache = os.path.abspath(os.environ.get(self.cache_env,
 self.cache_default))
 self.restore()
 self.analysis_cache = {}
 def start(self):
 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():
 f = self.canonical_filename(filename)
 excluded[i+1] = 1
 import parser
 tree = parser.suite(text+'\n\n').totuple(1)
 self.get_suite_spots(tree, 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)
 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('> ')
 #
 # 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 3223	53e843840349
parent 2144	d3bddedfdbd0
child 4122	306055f5b65c