python.coverage.Coverage Class Reference

Collaboration diagram for python.coverage.Coverage:

Public Member Functions
	__init__ (self, modname, toplev_name='main')
	trace (self, frame, why, arg)
	analyze (self)
	doctest_cover (self, *args, **kw)

Public Attributes
	modname = modname
	toplev_name = toplev_name
dict	counts = {}
self.mutex.acquire()	mutex = None
	trace

Detailed Description

Definition at line 144 of file coverage.py.

Constructor & Destructor Documentation

__init__()

python.coverage.Coverage.__init__	(		self,
			modname,
			toplev_name = 'main' )

Definition at line 145 of file coverage.py.

    def __init__(self, modname, toplev_name = 'main'):
        global running_coverage
        running_coverage = 1
        self.modname = modname
        self.toplev_name = toplev_name
        self.counts = {}   # keys are linenumber
        self.mutex = None
        if 'NOCOVER' not in os.environ:
            #self.save_import = __builtin__.__import__
            #__builtin__.__import__ = self.import_hook
            sys.settrace (self.trace)
        return
 
 

Member Function Documentation

analyze()

python.coverage.Coverage.analyze

(

self

)

Definition at line 222 of file coverage.py.

    def analyze (self):
        filename = sys.modules[self.modname].__file__
        if filename[-4:] == ".pyc" or filename[-4:] == ".pyo":
            orig_filename = filename[:-4] + '.py'
        else:
            orig_filename = filename
 
        # Get the original lines from the .py file
        try:
            lines = open(orig_filename, 'r').readlines()
        except IOError as err:
            sys.stderr.write(
                "%s: Could not open %s for reading because: %s - skipping\n" %
\
                ("trace", repr(filename), err.strerror))
            return
 
        # there are many places where this is insufficient, like a blank
        # line embedded in a multiline string.
        blank = re.compile(r'^\s*(#.*)?$')
 
        executable_linenos = find_executable_linenos(orig_filename)
 
        lines_hit = self.counts
        uncovered = 0
        outlines = []
        for i in range(len(lines)):
            line = lines[i]
 
            # do the blank/comment match to try to mark more lines
            # (help the reader find stuff that hasn't been covered)
            if (i+1) in lines_hit:
                # count precedes the lines that we captured
                prefix = '%5d: ' % lines_hit[i+1]
            elif blank.match(line):
                # blank lines and comments are preceded by dots
                prefix = '    . '
            else:
                # lines preceded by no marks weren't hit
                # Highlight them if so indicated, unless the line contains
                # '#pragma: NO COVER' (it is possible to embed this into
                # the text as a non-comment; no easy fix)
                if (i+1) in executable_linenos and \
                   lines[i].find('#pragma: NO COVER') == -1:
                    prefix = '>>>>>> '
                    uncovered = uncovered + 1
                else:
                    prefix = ' '*7
            outlines.append (prefix + line.expandtabs(8))
 
        if uncovered:
            print("*** There were %d uncovered lines." % uncovered)
        else:
            return
 
        # build list file name by appending a ".cover" to the module name
        # and sticking it into the specified directory
        listfilename = self.modname + ".cover"
        try:
            outfile = open(listfilename, 'w')
        except IOError as err:
            sys.stderr.write(
                '%s: Could not open %s for writing because: %s - skipping\n' %
                ("trace", repr(listfilename), err.strerror))
            return
 
        for l in outlines:
            outfile.write (l)
 
        outfile.close()
        
        return
 
 

doctest_cover()

python.coverage.Coverage.doctest_cover	(		self,
		*	args,
		**	kw )

Definition at line 296 of file coverage.py.

    def doctest_cover (self, *args, **kw):
        import doctest
        m = __import__ (self.modname)
 
        # Note a peculiarity of __import__: if modname is like A.B,
        # then it returns A not B...
        mm = self.modname.split ('.')
        if len(mm) > 1:
            m = getattr (m, mm[-1])
 
        oldrun = doctest.DocTestRunner.run
        def xrun (xself, *args, **kw):
            sys.settrace (self.trace)
            return oldrun (xself, *args, **kw)
        doctest.DocTestRunner.run = xrun
 
        import bdb
        old_set_continue = bdb.Bdb.set_continue
        def xcontinue (xself):
            old_set_continue (xself)
            sys.settrace (self.trace)
            return
        bdb.Bdb.set_continue = xcontinue
 
        doctest.testmod (m, *args, **kw)
 
        main = sys.modules['__main__']
        if m != main:
            doctest.testmod (main, *args, **kw)
 
        self.analyze()
        return

trace()

python.coverage.Coverage.trace	(		self,
			frame,
			why,
			arg )

Definition at line 193 of file coverage.py.

    def trace(self, frame, why, arg):
        # something is fishy about getting the file name
        modulename = frame.f_globals.get ("__name__")
        if why == 'call':
            # Don't bother tracing if we're not in one of these modules.
            if not (modulename == self.modname or
                    (modulename == '__main__' and
                     frame.f_code.co_name == self.toplev_name)):
                return None
        if why == 'line':
            if modulename == self.modname:
                lineno = frame.f_lineno
 
                # record the file name and line number of every trace
                if self.mutex: self.mutex.acquire ()
                self.counts[lineno] = self.counts.get(lineno, 0) + 1
                if self.mutex: self.mutex.release ()
 
        elif why == 'return':
            if frame.f_code.co_name == self.toplev_name:
                sys.settrace (None)
                if self.mutex: self.mutex.acquire ()
                self.analyze ()
                m = self.mutex
                self.mutex = None
                if m: m.release ()
 
        return self.trace
 

Member Data Documentation

counts

dict python.coverage.Coverage.counts = {}

Definition at line 150 of file coverage.py.

modname

python.coverage.Coverage.modname = modname

Definition at line 148 of file coverage.py.

mutex

self.mutex.acquire () python.coverage.Coverage.mutex = None

Definition at line 151 of file coverage.py.

toplev_name

python.coverage.Coverage.toplev_name = toplev_name

Definition at line 149 of file coverage.py.

trace

python.coverage.Coverage.trace

Definition at line 155 of file coverage.py.

---

The documentation for this class was generated from the following file:

• coverage.py