python.coverage.Coverage Class Reference

Collaboration diagram for python.coverage.Coverage:

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

Public Attributes
	modname
	toplev_name
	counts
	mutex

Detailed Description

Definition at line 149 of file coverage.py.

Constructor & Destructor Documentation

__init__()

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

Definition at line 150 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()

def python.coverage.Coverage.analyze

(

self

)

Definition at line 227 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()

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

Definition at line 301 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()

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

Definition at line 198 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

python.coverage.Coverage.counts

Definition at line 155 of file coverage.py.

modname

python.coverage.Coverage.modname

Definition at line 153 of file coverage.py.

mutex

python.coverage.Coverage.mutex

Definition at line 156 of file coverage.py.

toplev_name

python.coverage.Coverage.toplev_name

Definition at line 154 of file coverage.py.

---

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

• coverage.py