Version 3.3

-----------

- Fixed a problem with nested loops having their branch possibilities

  mischaracterized: `issue 39`_.

- Added coverage.process_start to enable coverage measurement when Python

  starts.

- Parallel data files combined with "coverage combine" are deleted after

  they're combined, to clean up unneeded files.  Fixes `issue 40`_.

- Added an AUTHORS.txt file.

.. _issue 39: http://bitbucket.org/ned/coveragepy/issue/39

[run]

branch = true

data_file = c:\ned\coverage\trunk\.coverage

[report]

exclude_lines =

        # Do something.

        self.coverage = self.covpkg.coverage(

            cover_pylib = options.pylib,

            timid = options.timid,

            branch = options.branch,

        self.branch = False

        self.cover_pylib = False

        self.data_file = ".coverage"

        self.timid = False

        # Defaults for [report]

            self.cover_pylib = cp.getboolean('run', 'cover_pylib')

        if cp.has_option('run', 'data_file'):

            self.data_file = cp.get('run', 'data_file')

        if cp.has_option('run', 'timid'):

            self.timid = cp.getboolean('run', 'timid')

from coverage.data import CoverageData

from coverage.files import FileLocator

from coverage.html import HtmlReporter

from coverage.results import Analysis

from coverage.summary import SummaryReporter

from coverage.xmlreport import XmlReporter

    """

                auto_data=False, timid=None, branch=None, config_file=True):

        """

        `data_file` is the base name of the data file to use, defaulting to

        `cover_pylib` is a boolean determining whether Python code installed

        with the Python interpreter is measured.  This includes the Python

        # 4: from constructor arguments:

        self.config.from_args(

            data_file=data_file, cover_pylib=cover_pylib, timid=timid,

            )

        self.auto_data = auto_data

            )

        # Create the data file.

            if not isinstance(data_suffix, string_class):

                # if data_suffix=True, use .machinename.pid.random

                    )

        else:

            data_suffix = None

        current measurements.

        """

        self.data.combine_parallel_data()

    def _harvest_data(self):

    """

    cps = os.environ.get("COVERAGE_PROCESS_START")

    if cps:

        if os.environ.get("COVERAGE_COVERAGE"):

            # Measuring coverage within coverage.py takes yet more trickery.

            cov.cover_prefix = "Please measure coverage.py!"

        `suffix` is a suffix to append to the base file name. This can be used

        for multiple or parallel execution, so that many coverage data files

        `collector` is a string describing the coverage measurement software.

        # ever do any file storage.

        self.filename = basename or ".coverage"

        if suffix:

        self.filename = os.path.abspath(self.filename)

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

        """Combine a number of data files together.

        Treat `self.filename` as a file prefix, and combine the data from all

        """

        data_dir, local = os.path.split(self.filename)

        for f in os.listdir(data_dir or '.'):

                full_path = os.path.join(data_dir, f)

                new_lines, new_arcs = self._read_file(full_path)

                for filename, file_data in new_lines.items():

    return _wrapped

class CoverageException(Exception):

    """An exception specific to Coverage."""

    pass

    tracer = os.environ.get('COVERAGE_TEST_TRACER', 'c')

    version = "%s%s" % sys.version_info[:2]

    cov = coverage.coverage(config_file="covcov.ini", data_suffix=suffix)

    # Cheap trick: the coverage code itself is excluded from measurement, but

    cov = coverage.coverage(config_file="covcov.ini")

    cov.combine()

    cov.save()

    cov.html_report(directory=HTML_DIR)

            """)

        self.assertSameElements(os.listdir("."), ["datatest3.py"])

        cov.start()

        self.import_module("datatest3")         # pragma: recursive coverage

        cov.stop()                              # pragma: recursive coverage

"""Test cmdline.py for coverage."""

import mock

import coverage

    run_in_temp_dir = False

    INIT_LOAD = """\

            .load()\n"""

    def model_object(self):

        m2 = self.model_object()

        code_obj = compile(code, "<code>", "exec")

        eval(code_obj, globals(), { 'm2': m2 })

    def cmd_executes_same(self, args1, args2):

        """Assert that the `args1` executes the same as `args2`."""

        m1, r1 = self.mock_command_line(args1)

        m2, r2 = self.mock_command_line(args2)

        self.assertEqual(r1, r2)

    def cmd_help(self, args, help_msg=None, topic=None, ret=ERR):

        """Run a command line, and check that it prints the right help.

    def testErase(self):

        # coverage -e

        self.cmd_executes("-e", """\

            .erase()

            """)

        self.cmd_executes_same("-e", "--erase")

        # -x calls coverage.load first.

        self.cmd_executes("-x foo.py", """\

            .load()

            .start()

            .run_python_file('foo.py', ['foo.py'])

            """)

        # -e -x calls coverage.erase first.

        self.cmd_executes("-e -x foo.py", """\

            .erase()

            .start()

            .run_python_file('foo.py', ['foo.py'])

            """)

        # --timid sets a flag, and program arguments get passed through.

        self.cmd_executes("-x --timid foo.py abc 123", """\

            .load()

            .start()

            .run_python_file('foo.py', ['foo.py', 'abc', '123'])

    def testCombine(self):

        # coverage -c

        self.cmd_executes("-c", """\

            .load()

            .combine()

            .save()

        self.cmd_executes_same("run --timid f.py", "-e -x --timid f.py")

        self.cmd_executes_same("run", "-x")

        self.cmd_executes("run --branch foo.py", """\

            .erase()

            .start()

            .run_python_file('foo.py', ['foo.py'])

            .save()

            """)

        self.cmd_executes("run --rcfile=myrc.rc foo.py", """\

            .erase()

            .start()

            .run_python_file('foo.py', ['foo.py'])

class ProcessTest(CoverageTest):

    """Tests of the per-process behavior of coverage.py."""

    def testSaveOnExit(self):

        self.make_file("mycode.py", """\

            h = "Hello"

        self.assertFalse(os.path.exists(".coverage"))

        # After two -p runs, there should be two .coverage.machine.123 files.

        # Combine the parallel coverage data files into .coverage .

        self.run_command("coverage -c")

        self.assertTrue(os.path.exists(".coverage"))

        # After combining, there should be only the .coverage file.

        # Read the coverage file and see that b_or_c.py has all 7 lines

        # executed.