Move the test directory to tests to avoid conflicts with the stdlib test package.

--HG--
rename : test/__init__.py => tests/__init__.py
rename : test/backtest.py => tests/backtest.py
rename : test/backunittest.py => tests/backunittest.py
rename : test/coveragetest.py => tests/coveragetest.py
rename : test/covmodzip1.py => tests/covmodzip1.py
rename : test/eggsrc/egg1/__init__.py => tests/eggsrc/egg1/__init__.py
rename : test/eggsrc/egg1/egg1.py => tests/eggsrc/egg1/egg1.py
rename : test/eggsrc/setup.py => tests/eggsrc/setup.py
rename : test/farm/annotate/annotate_dir.py => tests/farm/annotate/annotate_dir.py
rename : test/farm/annotate/gold/white.py,cover => tests/farm/annotate/gold/white.py,cover
rename : test/farm/annotate/gold_anno_dir/a___init__.py,cover => tests/farm/annotate/gold_anno_dir/a___init__.py,cover
rename : test/farm/annotate/gold_anno_dir/a_a.py,cover => tests/farm/annotate/gold_anno_dir/a_a.py,cover
rename : test/farm/annotate/gold_anno_dir/b___init__.py,cover => tests/farm/annotate/gold_anno_dir/b___init__.py,cover
rename : test/farm/annotate/gold_anno_dir/b_b.py,cover => tests/farm/annotate/gold_anno_dir/b_b.py,cover
rename : test/farm/annotate/gold_anno_dir/multi.py,cover => tests/farm/annotate/gold_anno_dir/multi.py,cover
rename : test/farm/annotate/gold_multi/a/__init__.py,cover => tests/farm/annotate/gold_multi/a/__init__.py,cover
rename : test/farm/annotate/gold_multi/a/a.py,cover => tests/farm/annotate/gold_multi/a/a.py,cover
rename : test/farm/annotate/gold_multi/b/__init__.py,cover => tests/farm/annotate/gold_multi/b/__init__.py,cover
rename : test/farm/annotate/gold_multi/b/b.py,cover => tests/farm/annotate/gold_multi/b/b.py,cover
rename : test/farm/annotate/gold_multi/multi.py,cover => tests/farm/annotate/gold_multi/multi.py,cover
rename : test/farm/annotate/gold_v24/white.py,cover => tests/farm/annotate/gold_v24/white.py,cover
rename : test/farm/annotate/run.py => tests/farm/annotate/run.py
rename : test/farm/annotate/run_multi.py => tests/farm/annotate/run_multi.py
rename : test/farm/annotate/src/a/__init__.py => tests/farm/annotate/src/a/__init__.py
rename : test/farm/annotate/src/a/a.py => tests/farm/annotate/src/a/a.py
rename : test/farm/annotate/src/b/__init__.py => tests/farm/annotate/src/b/__init__.py
rename : test/farm/annotate/src/b/b.py => tests/farm/annotate/src/b/b.py
rename : test/farm/annotate/src/multi.py => tests/farm/annotate/src/multi.py
rename : test/farm/annotate/src/white.py => tests/farm/annotate/src/white.py
rename : test/farm/html/gold_a/a.html => tests/farm/html/gold_a/a.html
rename : test/farm/html/gold_a/index.html => tests/farm/html/gold_a/index.html
rename : test/farm/html/gold_b_branch/b.html => tests/farm/html/gold_b_branch/b.html
rename : test/farm/html/gold_b_branch/index.html => tests/farm/html/gold_b_branch/index.html
rename : test/farm/html/gold_bom/bom.html => tests/farm/html/gold_bom/bom.html
rename : test/farm/html/gold_bom/index.html => tests/farm/html/gold_bom/index.html
rename : test/farm/html/gold_isolatin1/index.html => tests/farm/html/gold_isolatin1/index.html
rename : test/farm/html/gold_isolatin1/isolatin1.html => tests/farm/html/gold_isolatin1/isolatin1.html
rename : test/farm/html/gold_omit_1/index.html => tests/farm/html/gold_omit_1/index.html
rename : test/farm/html/gold_omit_1/m1.html => tests/farm/html/gold_omit_1/m1.html
rename : test/farm/html/gold_omit_1/m2.html => tests/farm/html/gold_omit_1/m2.html
rename : test/farm/html/gold_omit_1/m3.html => tests/farm/html/gold_omit_1/m3.html
rename : test/farm/html/gold_omit_1/main.html => tests/farm/html/gold_omit_1/main.html
rename : test/farm/html/gold_omit_2/index.html => tests/farm/html/gold_omit_2/index.html
rename : test/farm/html/gold_omit_2/m2.html => tests/farm/html/gold_omit_2/m2.html
rename : test/farm/html/gold_omit_2/m3.html => tests/farm/html/gold_omit_2/m3.html
rename : test/farm/html/gold_omit_2/main.html => tests/farm/html/gold_omit_2/main.html
rename : test/farm/html/gold_omit_3/index.html => tests/farm/html/gold_omit_3/index.html
rename : test/farm/html/gold_omit_3/m3.html => tests/farm/html/gold_omit_3/m3.html
rename : test/farm/html/gold_omit_3/main.html => tests/farm/html/gold_omit_3/main.html
rename : test/farm/html/gold_omit_4/index.html => tests/farm/html/gold_omit_4/index.html
rename : test/farm/html/gold_omit_4/m1.html => tests/farm/html/gold_omit_4/m1.html
rename : test/farm/html/gold_omit_4/m3.html => tests/farm/html/gold_omit_4/m3.html
rename : test/farm/html/gold_omit_4/main.html => tests/farm/html/gold_omit_4/main.html
rename : test/farm/html/gold_omit_5/index.html => tests/farm/html/gold_omit_5/index.html
rename : test/farm/html/gold_omit_5/m1.html => tests/farm/html/gold_omit_5/m1.html
rename : test/farm/html/gold_omit_5/main.html => tests/farm/html/gold_omit_5/main.html
rename : test/farm/html/gold_other/blah_blah_other.html => tests/farm/html/gold_other/blah_blah_other.html
rename : test/farm/html/gold_other/here.html => tests/farm/html/gold_other/here.html
rename : test/farm/html/gold_other/index.html => tests/farm/html/gold_other/index.html
rename : test/farm/html/gold_partial/index.html => tests/farm/html/gold_partial/index.html
rename : test/farm/html/gold_partial/partial.html => tests/farm/html/gold_partial/partial.html
rename : test/farm/html/gold_styled/a.html => tests/farm/html/gold_styled/a.html
rename : test/farm/html/gold_styled/extra.css => tests/farm/html/gold_styled/extra.css
rename : test/farm/html/gold_styled/index.html => tests/farm/html/gold_styled/index.html
rename : test/farm/html/gold_styled/style.css => tests/farm/html/gold_styled/style.css
rename : test/farm/html/gold_unicode/index.html => tests/farm/html/gold_unicode/index.html
rename : test/farm/html/gold_unicode/unicode.html => tests/farm/html/gold_unicode/unicode.html
rename : test/farm/html/gold_x_xml/coverage.xml => tests/farm/html/gold_x_xml/coverage.xml
rename : test/farm/html/gold_y_xml_branch/coverage.xml => tests/farm/html/gold_y_xml_branch/coverage.xml
rename : test/farm/html/othersrc/other.py => tests/farm/html/othersrc/other.py
rename : test/farm/html/run_a.py => tests/farm/html/run_a.py
rename : test/farm/html/run_a_xml_1.py => tests/farm/html/run_a_xml_1.py
rename : test/farm/html/run_a_xml_2.py => tests/farm/html/run_a_xml_2.py
rename : test/farm/html/run_b_branch.py => tests/farm/html/run_b_branch.py
rename : test/farm/html/run_bom.py => tests/farm/html/run_bom.py
rename : test/farm/html/run_isolatin1.py => tests/farm/html/run_isolatin1.py
rename : test/farm/html/run_omit_1.py => tests/farm/html/run_omit_1.py
rename : test/farm/html/run_omit_2.py => tests/farm/html/run_omit_2.py
rename : test/farm/html/run_omit_3.py => tests/farm/html/run_omit_3.py
rename : test/farm/html/run_omit_4.py => tests/farm/html/run_omit_4.py
rename : test/farm/html/run_omit_5.py => tests/farm/html/run_omit_5.py
rename : test/farm/html/run_other.py => tests/farm/html/run_other.py
rename : test/farm/html/run_partial.py => tests/farm/html/run_partial.py
rename : test/farm/html/run_styled.py => tests/farm/html/run_styled.py
rename : test/farm/html/run_tabbed.py => tests/farm/html/run_tabbed.py
rename : test/farm/html/run_unicode.py => tests/farm/html/run_unicode.py
rename : test/farm/html/run_y_xml_branch.py => tests/farm/html/run_y_xml_branch.py
rename : test/farm/html/src/a.py => tests/farm/html/src/a.py
rename : test/farm/html/src/b.py => tests/farm/html/src/b.py
rename : test/farm/html/src/bom.py => tests/farm/html/src/bom.py
rename : test/farm/html/src/coverage.xml => tests/farm/html/src/coverage.xml
rename : test/farm/html/src/extra.css => tests/farm/html/src/extra.css
rename : test/farm/html/src/here.py => tests/farm/html/src/here.py
rename : test/farm/html/src/isolatin1.py => tests/farm/html/src/isolatin1.py
rename : test/farm/html/src/m1.py => tests/farm/html/src/m1.py
rename : test/farm/html/src/m2.py => tests/farm/html/src/m2.py
rename : test/farm/html/src/m3.py => tests/farm/html/src/m3.py
rename : test/farm/html/src/main.py => tests/farm/html/src/main.py
rename : test/farm/html/src/omit4.ini => tests/farm/html/src/omit4.ini
rename : test/farm/html/src/omit5.ini => tests/farm/html/src/omit5.ini
rename : test/farm/html/src/partial.py => tests/farm/html/src/partial.py
rename : test/farm/html/src/run_a_xml_2.ini => tests/farm/html/src/run_a_xml_2.ini
rename : test/farm/html/src/tabbed.py => tests/farm/html/src/tabbed.py
rename : test/farm/html/src/unicode.py => tests/farm/html/src/unicode.py
rename : test/farm/html/src/y.py => tests/farm/html/src/y.py
rename : test/farm/run/run_chdir.py => tests/farm/run/run_chdir.py
rename : test/farm/run/run_timid.py => tests/farm/run/run_timid.py
rename : test/farm/run/run_xxx.py => tests/farm/run/run_xxx.py
rename : test/farm/run/src/chdir.py => tests/farm/run/src/chdir.py
rename : test/farm/run/src/showtrace.py => tests/farm/run/src/showtrace.py
rename : test/farm/run/src/subdir/placeholder => tests/farm/run/src/subdir/placeholder
rename : test/farm/run/src/xxx => tests/farm/run/src/xxx
rename : test/js/index.html => tests/js/index.html
rename : test/js/tests.js => tests/js/tests.js
rename : test/modules/aa/__init__.py => tests/modules/aa/__init__.py
rename : test/modules/aa/afile.odd.py => tests/modules/aa/afile.odd.py
rename : test/modules/aa/afile.py => tests/modules/aa/afile.py
rename : test/modules/aa/bb.odd/bfile.py => tests/modules/aa/bb.odd/bfile.py
rename : test/modules/aa/bb/__init__.py => tests/modules/aa/bb/__init__.py
rename : test/modules/aa/bb/bfile.odd.py => tests/modules/aa/bb/bfile.odd.py
rename : test/modules/aa/bb/bfile.py => tests/modules/aa/bb/bfile.py
rename : test/modules/aa/bb/cc/__init__.py => tests/modules/aa/bb/cc/__init__.py
rename : test/modules/aa/bb/cc/cfile.py => tests/modules/aa/bb/cc/cfile.py
rename : test/modules/aa/zfile.py => tests/modules/aa/zfile.py
rename : test/modules/covmod1.py => tests/modules/covmod1.py
rename : test/modules/pkg1/__init__.py => tests/modules/pkg1/__init__.py
rename : test/modules/pkg1/__main__.py => tests/modules/pkg1/__main__.py
rename : test/modules/pkg1/p1a.py => tests/modules/pkg1/p1a.py
rename : test/modules/pkg1/p1b.py => tests/modules/pkg1/p1b.py
rename : test/modules/pkg1/p1c.py => tests/modules/pkg1/p1c.py
rename : test/modules/pkg1/runmod2.py => tests/modules/pkg1/runmod2.py
rename : test/modules/pkg1/sub/__init__.py => tests/modules/pkg1/sub/__init__.py
rename : test/modules/pkg1/sub/__main__.py => tests/modules/pkg1/sub/__main__.py
rename : test/modules/pkg1/sub/ps1a.py => tests/modules/pkg1/sub/ps1a.py
rename : test/modules/pkg1/sub/runmod3.py => tests/modules/pkg1/sub/runmod3.py
rename : test/modules/pkg2/__init__.py => tests/modules/pkg2/__init__.py
rename : test/modules/pkg2/p2a.py => tests/modules/pkg2/p2a.py
rename : test/modules/pkg2/p2b.py => tests/modules/pkg2/p2b.py
rename : test/modules/runmod1.py => tests/modules/runmod1.py
rename : test/modules/usepkgs.py => tests/modules/usepkgs.py
rename : test/moremodules/othermods/__init__.py => tests/moremodules/othermods/__init__.py
rename : test/moremodules/othermods/othera.py => tests/moremodules/othermods/othera.py
rename : test/moremodules/othermods/otherb.py => tests/moremodules/othermods/otherb.py
rename : test/moremodules/othermods/sub/__init__.py => tests/moremodules/othermods/sub/__init__.py
rename : test/moremodules/othermods/sub/osa.py => tests/moremodules/othermods/sub/osa.py
rename : test/moremodules/othermods/sub/osb.py => tests/moremodules/othermods/sub/osb.py
rename : test/osinfo.py => tests/osinfo.py
rename : test/qunit/jquery.tmpl.min.js => tests/qunit/jquery.tmpl.min.js
rename : test/qunit/qunit.css => tests/qunit/qunit.css
rename : test/qunit/qunit.js => tests/qunit/qunit.js
rename : test/stress_phystoken.tok => tests/stress_phystoken.tok
rename : test/stress_phystoken_dos.tok => tests/stress_phystoken_dos.tok
rename : test/test_api.py => tests/test_api.py
rename : test/test_arcs.py => tests/test_arcs.py
rename : test/test_cmdline.py => tests/test_cmdline.py
rename : test/test_codeunit.py => tests/test_codeunit.py
rename : test/test_config.py => tests/test_config.py
rename : test/test_coverage.py => tests/test_coverage.py
rename : test/test_data.py => tests/test_data.py
rename : test/test_execfile.py => tests/test_execfile.py
rename : test/test_farm.py => tests/test_farm.py
rename : test/test_files.py => tests/test_files.py
rename : test/test_html.py => tests/test_html.py
rename : test/test_misc.py => tests/test_misc.py
rename : test/test_oddball.py => tests/test_oddball.py
rename : test/test_parser.py => tests/test_parser.py
rename : test/test_phystokens.py => tests/test_phystokens.py
rename : test/test_process.py => tests/test_process.py
rename : test/test_results.py => tests/test_results.py
rename : test/test_summary.py => tests/test_summary.py
rename : test/test_templite.py => tests/test_templite.py
rename : test/test_testing.py => tests/test_testing.py
rename : test/test_xml.py => tests/test_xml.py
rename : test/try_execfile.py => tests/try_execfile.py

1 files changed, 1730 insertions, 0 deletions

diff --git a/tests/test_coverage.py b/tests/test_coverage.py
new file mode 100644
index 00000000..0918dfe1
--- /dev/null
+++ b/tests/test_coverage.py
@@ -0,0 +1,1730 @@
+"""Tests for Coverage."""
+# http://nedbatchelder.com/code/coverage
+
+import sys
+import coverage
+from coverage.misc import CoverageException
+from test.coveragetest import CoverageTest
+
+
+class TestCoverageTest(CoverageTest):
+    """Make sure our complex self.check_coverage method works."""
+
+    def test_successful_coverage(self):
+        # The simplest run possible.
+        self.check_coverage("""\
+            a = 1
+            b = 2
+            """,
+            [1,2]
+            )
+        # You can provide a list of possible statement matches.
+        self.check_coverage("""\
+            a = 1
+            b = 2
+            """,
+            ([100], [1,2], [1723,47]),
+            )
+        # You can specify missing lines.
+        self.check_coverage("""\
+            a = 1
+            if a == 2:
+                a = 3
+            """,
+            [1,2,3],
+            missing="3",
+            )
+        # You can specify a list of possible missing lines.
+        self.check_coverage("""\
+            a = 1
+            if a == 2:
+                a = 3
+            """,
+            [1,2,3],
+            missing=("47-49", "3", "100,102")
+            )
+
+    def test_failed_coverage(self):
+        # If the lines are wrong, the message shows right and wrong.
+        self.assertRaisesRegexp(AssertionError,
+            r"\[1, 2] != \[1]",
+            self.check_coverage, """\
+                a = 1
+                b = 2
+                """,
+                [1]
+            )
+        # If the list of lines possibilities is wrong, the msg shows right.
+        self.assertRaisesRegexp(AssertionError,
+            r"None of the lines choices matched \[1, 2]",
+            self.check_coverage, """\
+                a = 1
+                b = 2
+                """,
+                ([1], [2])
+            )
+        # If the missing lines are wrong, the message shows right and wrong.
+        self.assertRaisesRegexp(AssertionError,
+            r"'3' != '37'",
+            self.check_coverage, """\
+                a = 1
+                if a == 2:
+                    a = 3
+                """,
+                [1,2,3],
+                missing="37",
+            )
+        # If the missing lines possibilities are wrong, the msg shows right.
+        self.assertRaisesRegexp(AssertionError,
+            r"None of the missing choices matched '3'",
+            self.check_coverage, """\
+                a = 1
+                if a == 2:
+                    a = 3
+                """,
+                [1,2,3],
+                missing=("37", "4-10"),
+            )
+
+
+class BasicCoverageTest(CoverageTest):
+    """The simplest tests, for quick smoke testing of fundamental changes."""
+
+    def test_simple(self):
+        self.check_coverage("""\
+            a = 1
+            b = 2
+
+            c = 4
+            # Nothing here
+            d = 6
+            """,
+            [1,2,4,6], report="4 0 100%")
+
+    def test_indentation_wackiness(self):
+        # Partial final lines are OK.
+        self.check_coverage("""\
+            import sys
+            if not sys.path:
+                a = 1
+                """,
+            [1,2,3], "3")
+
+    def test_multiline_initializer(self):
+        self.check_coverage("""\
+            d = {
+                'foo': 1+2,
+                'bar': (lambda x: x+1)(1),
+                'baz': str(1),
+            }
+
+            e = { 'foo': 1, 'bar': 2 }
+            """,
+            [1,7], "")
+
+    def test_list_comprehension(self):
+        self.check_coverage("""\
+            l = [
+                2*i for i in range(10)
+                if i > 5
+                ]
+            assert l == [12, 14, 16, 18]
+            """,
+            [1,5], "")
+
+
+class SimpleStatementTest(CoverageTest):
+    """Testing simple single-line statements."""
+
+    def test_expression(self):
+        # Bare expressions as statements are tricky: some implementations
+        # optimize some of them away.  All implementations seem to count
+        # the implicit return at the end as executable.
+        self.check_coverage("""\
+            12
+            23
+            """,
+            ([1,2],[2]), "")
+        self.check_coverage("""\
+            12
+            23
+            a = 3
+            """,
+            ([1,2,3],[3]), "")
+        self.check_coverage("""\
+            1 + 2
+            1 + \\
+                2
+            """,
+            ([1,2], [2]), "")
+        self.check_coverage("""\
+            1 + 2
+            1 + \\
+                2
+            a = 4
+            """,
+            ([1,2,4], [4]), "")
+
+    def test_assert(self):
+        self.check_coverage("""\
+            assert (1 + 2)
+            assert (1 +
+                2)
+            assert (1 + 2), 'the universe is broken'
+            assert (1 +
+                2), \\
+                'something is amiss'
+            """,
+            [1,2,4,5], "")
+
+    def test_assignment(self):
+        # Simple variable assignment
+        self.check_coverage("""\
+            a = (1 + 2)
+            b = (1 +
+                2)
+            c = \\
+                1
+            """,
+            [1,2,4], "")
+
+    def test_assign_tuple(self):
+        self.check_coverage("""\
+            a = 1
+            a,b,c = 7,8,9
+            assert a == 7 and b == 8 and c == 9
+            """,
+            [1,2,3], "")
+
+    def test_attribute_assignment(self):
+        # Attribute assignment
+        self.check_coverage("""\
+            class obj: pass
+            o = obj()
+            o.foo = (1 + 2)
+            o.foo = (1 +
+                2)
+            o.foo = \\
+                1
+            """,
+            [1,2,3,4,6], "")
+
+    def test_list_of_attribute_assignment(self):
+        self.check_coverage("""\
+            class obj: pass
+            o = obj()
+            o.a, o.b = (1 + 2), 3
+            o.a, o.b = (1 +
+                2), (3 +
+                4)
+            o.a, o.b = \\
+                1, \\
+                2
+            """,
+            [1,2,3,4,7], "")
+
+    def test_augmented_assignment(self):
+        self.check_coverage("""\
+            a = 1
+            a += 1
+            a += (1 +
+                2)
+            a += \\
+                1
+            """,
+            [1,2,3,5], "")
+
+    def test_triple_string_stuff(self):
+        self.check_coverage("""\
+            a = '''
+                a multiline
+                string.
+                '''
+            b = '''
+                long expression
+                ''' + '''
+                on many
+                lines.
+                '''
+            c = len('''
+                long expression
+                ''' +
+                '''
+                on many
+                lines.
+                ''')
+            """,
+            [1,5,11], "")
+
+    def test_pass(self):
+        # pass is tricky: if it's the only statement in a block, then it is
+        # "executed". But if it is not the only statement, then it is not.
+        self.check_coverage("""\
+            if 1==1:
+                pass
+            """,
+            [1,2], "")
+        self.check_coverage("""\
+            def foo():
+                pass
+            foo()
+            """,
+            [1,2,3], "")
+        self.check_coverage("""\
+            def foo():
+                "doc"
+                pass
+            foo()
+            """,
+            ([1,3,4], [1,4]), "")
+        self.check_coverage("""\
+            class Foo:
+                def foo(self):
+                    pass
+            Foo().foo()
+            """,
+            [1,2,3,4], "")
+        self.check_coverage("""\
+            class Foo:
+                def foo(self):
+                    "Huh?"
+                    pass
+            Foo().foo()
+            """,
+            ([1,2,4,5], [1,2,5]), "")
+
+    def test_del(self):
+        self.check_coverage("""\
+            d = { 'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1 }
+            del d['a']
+            del d[
+                'b'
+                ]
+            del d['c'], \\
+                d['d'], \\
+                d['e']
+            assert(len(d.keys()) == 0)
+            """,
+            [1,2,3,6,9], "")
+
+    if sys.version_info < (3, 0):   # Print statement is gone in Py3k.
+        def test_print(self):
+            self.check_coverage("""\
+                print "hello, world!"
+                print ("hey: %d" %
+                    17)
+                print "goodbye"
+                print "hello, world!",
+                print ("hey: %d" %
+                    17),
+                print "goodbye",
+                """,
+                [1,2,4,5,6,8], "")
+
+    def test_raise(self):
+        self.check_coverage("""\
+            try:
+                raise Exception(
+                    "hello %d" %
+                    17)
+            except:
+                pass
+            """,
+            [1,2,5,6], "")
+
+    def test_return(self):
+        self.check_coverage("""\
+            def fn():
+                a = 1
+                return a
+
+            x = fn()
+            assert(x == 1)
+            """,
+            [1,2,3,5,6], "")
+        self.check_coverage("""\
+            def fn():
+                a = 1
+                return (
+                    a +
+                    1)
+
+            x = fn()
+            assert(x == 2)
+            """,
+            [1,2,3,7,8], "")
+        self.check_coverage("""\
+            def fn():
+                a = 1
+                return (a,
+                    a + 1,
+                    a + 2)
+
+            x,y,z = fn()
+            assert x == 1 and y == 2 and z == 3
+            """,
+            [1,2,3,7,8], "")
+
+    def test_yield(self):
+        self.check_coverage("""\
+            from __future__ import generators
+            def gen():
+                yield 1
+                yield (2+
+                    3+
+                    4)
+                yield 1, \\
+                    2
+            a,b,c = gen()
+            assert a == 1 and b == 9 and c == (1,2)
+            """,
+            [1,2,3,4,7,9,10], "")
+
+    def test_break(self):
+        self.check_coverage("""\
+            for x in range(10):
+                a = 2 + x
+                break
+                a = 4
+            assert a == 2
+            """,
+            [1,2,3,4,5], "4")
+
+    def test_continue(self):
+        self.check_coverage("""\
+            for x in range(10):
+                a = 2 + x
+                continue
+                a = 4
+            assert a == 11
+            """,
+            [1,2,3,4,5], "4")
+
+    if 0:   # expected failure
+        # Peephole optimization of jumps to jumps can mean that some statements
+        # never hit the line tracer.  The behavior is different in different
+        # versions of Python, so don't run this test:
+        def test_strange_unexecuted_continue(self):
+            self.check_coverage("""\
+                a = b = c = 0
+                for n in range(100):
+                    if n % 2:
+                        if n % 4:
+                            a += 1
+                        continue    # <-- This line may not be hit.
+                    else:
+                        b += 1
+                    c += 1
+                assert a == 50 and b == 50 and c == 50
+
+                a = b = c = 0
+                for n in range(100):
+                    if n % 2:
+                        if n % 3:
+                            a += 1
+                        continue    # <-- This line is always hit.
+                    else:
+                        b += 1
+                    c += 1
+                assert a == 33 and b == 50 and c == 50
+                """,
+                [1,2,3,4,5,6,8,9,10, 12,13,14,15,16,17,19,20,21], "")
+
+    def test_import(self):
+        self.check_coverage("""\
+            import string
+            from sys import path
+            a = 1
+            """,
+            [1,2,3], "")
+        self.check_coverage("""\
+            import string
+            if 1 == 2:
+                from sys import path
+            a = 1
+            """,
+            [1,2,3,4], "3")
+        self.check_coverage("""\
+            import string, \\
+                os, \\
+                re
+            from sys import path, \\
+                stdout
+            a = 1
+            """,
+            [1,4,6], "")
+        self.check_coverage("""\
+            import sys, sys as s
+            assert s.path == sys.path
+            """,
+            [1,2], "")
+        self.check_coverage("""\
+            import sys, \\
+                sys as s
+            assert s.path == sys.path
+            """,
+            [1,3], "")
+        self.check_coverage("""\
+            from sys import path, \\
+                path as p
+            assert p == path
+            """,
+            [1,3], "")
+        self.check_coverage("""\
+            from sys import \\
+                *
+            assert len(path) > 0
+            """,
+            [1,3], "")
+
+    def test_global(self):
+        self.check_coverage("""\
+            g = h = i = 1
+            def fn():
+                global g
+                global h, \\
+                    i
+                g = h = i = 2
+            fn()
+            assert g == 2 and h == 2 and i == 2
+            """,
+            [1,2,6,7,8], "")
+        self.check_coverage("""\
+            g = h = i = 1
+            def fn():
+                global g; g = 2
+            fn()
+            assert g == 2 and h == 1 and i == 1
+            """,
+            [1,2,3,4,5], "")
+
+    if sys.version_info < (3, 0):
+        # In Python 2.x, exec is a statement.
+        def test_exec(self):
+            self.check_coverage("""\
+                a = b = c = 1
+                exec "a = 2"
+                exec ("b = " +
+                    "c = " +
+                    "2")
+                assert a == 2 and b == 2 and c == 2
+                """,
+                [1,2,3,6], "")
+            self.check_coverage("""\
+                vars = {'a': 1, 'b': 1, 'c': 1}
+                exec "a = 2" in vars
+                exec ("b = " +
+                    "c = " +
+                    "2") in vars
+                assert vars['a'] == 2 and vars['b'] == 2 and vars['c'] == 2
+                """,
+                [1,2,3,6], "")
+            self.check_coverage("""\
+                globs = {}
+                locs = {'a': 1, 'b': 1, 'c': 1}
+                exec "a = 2" in globs, locs
+                exec ("b = " +
+                    "c = " +
+                    "2") in globs, locs
+                assert locs['a'] == 2 and locs['b'] == 2 and locs['c'] == 2
+                """,
+                [1,2,3,4,7], "")
+    else:
+        # In Python 3.x, exec is a function.
+        def test_exec(self):
+            self.check_coverage("""\
+                a = b = c = 1
+                exec("a = 2")
+                exec("b = " +
+                    "c = " +
+                    "2")
+                assert a == 2 and b == 2 and c == 2
+                """,
+                [1,2,3,6], "")
+            self.check_coverage("""\
+                vars = {'a': 1, 'b': 1, 'c': 1}
+                exec("a = 2", vars)
+                exec("b = " +
+                    "c = " +
+                    "2", vars)
+                assert vars['a'] == 2 and vars['b'] == 2 and vars['c'] == 2
+                """,
+                [1,2,3,6], "")
+            self.check_coverage("""\
+                globs = {}
+                locs = {'a': 1, 'b': 1, 'c': 1}
+                exec("a = 2", globs, locs)
+                exec("b = " +
+                    "c = " +
+                    "2", globs, locs)
+                assert locs['a'] == 2 and locs['b'] == 2 and locs['c'] == 2
+                """,
+                [1,2,3,4,7], "")
+
+    def test_extra_doc_string(self):
+        self.check_coverage("""\
+            a = 1
+            "An extra docstring, should be a comment."
+            b = 3
+            assert (a,b) == (1,3)
+            """,
+            [1,3,4], "")
+        self.check_coverage("""\
+            a = 1
+            "An extra docstring, should be a comment."
+            b = 3
+            123 # A number for some reason: ignored
+            1+1 # An expression: executed.
+            c = 6
+            assert (a,b,c) == (1,3,6)
+            """,
+            ([1,3,6,7], [1,3,5,6,7], [1,3,4,5,6,7]), "")
+
+
+class CompoundStatementTest(CoverageTest):
+    """Testing coverage of multi-line compound statements."""
+
+    def test_statement_list(self):
+        self.check_coverage("""\
+            a = 1;
+            b = 2; c = 3
+            d = 4; e = 5;
+
+            assert (a,b,c,d,e) == (1,2,3,4,5)
+            """,
+            [1,2,3,5], "")
+
+    def test_if(self):
+        self.check_coverage("""\
+            a = 1
+            if a == 1:
+                x = 3
+            assert x == 3
+            if (a ==
+                1):
+                x = 7
+            assert x == 7
+            """,
+            [1,2,3,4,5,7,8], "")
+        self.check_coverage("""\
+            a = 1
+            if a == 1:
+                x = 3
+            else:
+                y = 5
+            assert x == 3
+            """,
+            [1,2,3,5,6], "5")
+        self.check_coverage("""\
+            a = 1
+            if a != 1:
+                x = 3
+            else:
+                y = 5
+            assert y == 5
+            """,
+            [1,2,3,5,6], "3")
+        self.check_coverage("""\
+            a = 1; b = 2
+            if a == 1:
+                if b == 2:
+                    x = 4
+                else:
+                    y = 6
+            else:
+                z = 8
+            assert x == 4
+            """,
+            [1,2,3,4,6,8,9], "6-8")
+
+    def test_elif(self):
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if a == 1:
+                x = 3
+            elif b == 2:
+                y = 5
+            else:
+                z = 7
+            assert x == 3
+            """,
+            [1,2,3,4,5,7,8], "4-7", report="7 3 57% 4-7")
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if a != 1:
+                x = 3
+            elif b == 2:
+                y = 5
+            else:
+                z = 7
+            assert y == 5
+            """,
+            [1,2,3,4,5,7,8], "3, 7", report="7 2 71% 3, 7")
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if a != 1:
+                x = 3
+            elif b != 2:
+                y = 5
+            else:
+                z = 7
+            assert z == 7
+            """,
+            [1,2,3,4,5,7,8], "3, 5", report="7 2 71% 3, 5")
+
+    def test_elif_no_else(self):
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if a == 1:
+                x = 3
+            elif b == 2:
+                y = 5
+            assert x == 3
+            """,
+            [1,2,3,4,5,6], "4-5", report="6 2 67% 4-5")
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if a != 1:
+                x = 3
+            elif b == 2:
+                y = 5
+            assert y == 5
+            """,
+            [1,2,3,4,5,6], "3", report="6 1 83% 3")
+
+    def test_elif_bizarre(self):
+        self.check_coverage("""\
+            def f(self):
+                if self==1:
+                    x = 3
+                elif self.m('fred'):
+                    x = 5
+                elif (g==1) and (b==2):
+                    x = 7
+                elif self.m('fred')==True:
+                    x = 9
+                elif ((g==1) and (b==2))==True:
+                    x = 11
+                else:
+                    x = 13
+            """,
+            [1,2,3,4,5,6,7,8,9,10,11,13], "2-13")
+
+    def test_split_if(self):
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if \\
+                a == 1:
+                x = 3
+            elif \\
+                b == 2:
+                y = 5
+            else:
+                z = 7
+            assert x == 3
+            """,
+            [1,2,4,5,7,9,10], "5-9")
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if \\
+                a != 1:
+                x = 3
+            elif \\
+                b == 2:
+                y = 5
+            else:
+                z = 7
+            assert y == 5
+            """,
+            [1,2,4,5,7,9,10], "4, 9")
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if \\
+                a != 1:
+                x = 3
+            elif \\
+                b != 2:
+                y = 5
+            else:
+                z = 7
+            assert z == 7
+            """,
+            [1,2,4,5,7,9,10], "4, 7")
+
+    def test_pathological_split_if(self):
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if (
+                a == 1
+                ):
+                x = 3
+            elif (
+                b == 2
+                ):
+                y = 5
+            else:
+                z = 7
+            assert x == 3
+            """,
+            [1,2,5,6,9,11,12], "6-11")
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if (
+                a != 1
+                ):
+                x = 3
+            elif (
+                b == 2
+                ):
+                y = 5
+            else:
+                z = 7
+            assert y == 5
+            """,
+            [1,2,5,6,9,11,12], "5, 11")
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if (
+                a != 1
+                ):
+                x = 3
+            elif (
+                b != 2
+                ):
+                y = 5
+            else:
+                z = 7
+            assert z == 7
+            """,
+            [1,2,5,6,9,11,12], "5, 9")
+
+    def test_absurd_split_if(self):
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if a == 1 \\
+                :
+                x = 3
+            elif b == 2 \\
+                :
+                y = 5
+            else:
+                z = 7
+            assert x == 3
+            """,
+            [1,2,4,5,7,9,10], "5-9")
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if a != 1 \\
+                :
+                x = 3
+            elif b == 2 \\
+                :
+                y = 5
+            else:
+                z = 7
+            assert y == 5
+            """,
+            [1,2,4,5,7,9,10], "4, 9")
+        self.check_coverage("""\
+            a = 1; b = 2; c = 3;
+            if a != 1 \\
+                :
+                x = 3
+            elif b != 2 \\
+                :
+                y = 5
+            else:
+                z = 7
+            assert z == 7
+            """,
+            [1,2,4,5,7,9,10], "4, 7")
+
+    if sys.version_info >= (2, 4):
+        # In 2.4 and up, constant if's were compiled away.
+        def test_constant_if(self):
+            self.check_coverage("""\
+                if 1:
+                    a = 2
+                assert a == 2
+                """,
+                [2,3], "")
+
+    def test_while(self):
+        self.check_coverage("""\
+            a = 3; b = 0
+            while a:
+                b += 1
+                a -= 1
+            assert a == 0 and b == 3
+            """,
+            [1,2,3,4,5], "")
+        self.check_coverage("""\
+            a = 3; b = 0
+            while a:
+                b += 1
+                break
+                b = 99
+            assert a == 3 and b == 1
+            """,
+            [1,2,3,4,5,6], "5")
+
+    def test_while_else(self):
+        # Take the else branch.
+        self.check_coverage("""\
+            a = 3; b = 0
+            while a:
+                b += 1
+                a -= 1
+            else:
+                b = 99
+            assert a == 0 and b == 99
+            """,
+            [1,2,3,4,6,7], "")
+        # Don't take the else branch.
+        self.check_coverage("""\
+            a = 3; b = 0
+            while a:
+                b += 1
+                a -= 1
+                break
+                b = 123
+            else:
+                b = 99
+            assert a == 2 and b == 1
+            """,
+            [1,2,3,4,5,6,8,9], "6-8")
+
+    def test_split_while(self):
+        self.check_coverage("""\
+            a = 3; b = 0
+            while \\
+                a:
+                b += 1
+                a -= 1
+            assert a == 0 and b == 3
+            """,
+            [1,2,4,5,6], "")
+        self.check_coverage("""\
+            a = 3; b = 0
+            while (
+                a
+                ):
+                b += 1
+                a -= 1
+            assert a == 0 and b == 3
+            """,
+            [1,2,5,6,7], "")
+
+    def test_for(self):
+        self.check_coverage("""\
+            a = 0
+            for i in [1,2,3,4,5]:
+                a += i
+            assert a == 15
+            """,
+            [1,2,3,4], "")
+        self.check_coverage("""\
+            a = 0
+            for i in [1,
+                2,3,4,
+                5]:
+                a += i
+            assert a == 15
+            """,
+            [1,2,5,6], "")
+        self.check_coverage("""\
+            a = 0
+            for i in [1,2,3,4,5]:
+                a += i
+                break
+                a = 99
+            assert a == 1
+            """,
+            [1,2,3,4,5,6], "5")
+
+    def test_for_else(self):
+        self.check_coverage("""\
+            a = 0
+            for i in range(5):
+                a += i+1
+            else:
+                a = 99
+            assert a == 99
+            """,
+            [1,2,3,5,6], "")
+        self.check_coverage("""\
+            a = 0
+            for i in range(5):
+                a += i+1
+                break
+                a = 99
+            else:
+                a = 123
+            assert a == 1
+            """,
+            [1,2,3,4,5,7,8], "5-7")
+
+    def test_split_for(self):
+        self.check_coverage("""\
+            a = 0
+            for \\
+                i in [1,2,3,4,5]:
+                a += i
+            assert a == 15
+            """,
+            [1,2,4,5], "")
+        self.check_coverage("""\
+            a = 0
+            for \\
+                i in [1,
+                2,3,4,
+                5]:
+                a += i
+            assert a == 15
+            """,
+            [1,2,6,7], "")
+
+    def test_try_except(self):
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+            except:
+                a = 99
+            assert a == 1
+            """,
+            [1,2,3,4,5,6], "4-5")
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+                raise Exception("foo")
+            except:
+                a = 99
+            assert a == 99
+            """,
+            [1,2,3,4,5,6,7], "")
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+                raise Exception("foo")
+            except ImportError:
+                a = 99
+            except:
+                a = 123
+            assert a == 123
+            """,
+            [1,2,3,4,5,6,7,8,9], "6")
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+                raise IOError("foo")
+            except ImportError:
+                a = 99
+            except IOError:
+                a = 17
+            except:
+                a = 123
+            assert a == 17
+            """,
+            [1,2,3,4,5,6,7,8,9,10,11], "6, 9-10")
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+            except:
+                a = 99
+            else:
+                a = 123
+            assert a == 123
+            """,
+            [1,2,3,4,5,7,8], "4-5")
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+                raise Exception("foo")
+            except:
+                a = 99
+            else:
+                a = 123
+            assert a == 99
+            """,
+            [1,2,3,4,5,6,8,9], "8")
+
+    def test_try_finally(self):
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+            finally:
+                a = 99
+            assert a == 99
+            """,
+            [1,2,3,5,6], "")
+        self.check_coverage("""\
+            a = 0; b = 0
+            try:
+                a = 1
+                try:
+                    raise Exception("foo")
+                finally:
+                    b = 123
+            except:
+                a = 99
+            assert a == 99 and b == 123
+            """,
+            [1,2,3,4,5,7,8,9,10], "")
+
+    def test_function_def(self):
+        self.check_coverage("""\
+            a = 99
+            def foo():
+                ''' docstring
+                '''
+                return 1
+
+            a = foo()
+            assert a == 1
+            """,
+            [1,2,5,7,8], "")
+        self.check_coverage("""\
+            def foo(
+                a,
+                b
+                ):
+                ''' docstring
+                '''
+                return a+b
+
+            x = foo(17, 23)
+            assert x == 40
+            """,
+            [1,7,9,10], "")
+        self.check_coverage("""\
+            def foo(
+                a = (lambda x: x*2)(10),
+                b = (
+                    lambda x:
+                        x+1
+                    )(1)
+                ):
+                ''' docstring
+                '''
+                return a+b
+
+            x = foo()
+            assert x == 22
+            """,
+            [1,10,12,13], "")
+
+    def test_class_def(self):
+        self.check_coverage("""\
+            # A comment.
+            class theClass:
+                ''' the docstring.
+                    Don't be fooled.
+                '''
+                def __init__(self):
+                    ''' Another docstring. '''
+                    self.a = 1
+
+                def foo(self):
+                    return self.a
+
+            x = theClass().foo()
+            assert x == 1
+            """,
+            [2,6,8,10,11,13,14], "")
+
+
+class ExcludeTest(CoverageTest):
+    """Tests of the exclusion feature to mark lines as not covered."""
+
+    def test_default(self):
+        # A number of forms of pragma comment are accepted.
+        self.check_coverage("""\
+            a = 1
+            b = 2   # pragma: no cover
+            c = 3
+            d = 4   #pragma NOCOVER
+            e = 5
+            """,
+            [1,3,5]
+            )
+
+    def test_simple(self):
+        self.check_coverage("""\
+            a = 1; b = 2
+
+            if 0:
+                a = 4   # -cc
+            """,
+            [1,3], "", excludes=['-cc'])
+
+    def test_two_excludes(self):
+        self.check_coverage("""\
+            a = 1; b = 2
+
+            if a == 99:
+                a = 4   # -cc
+                b = 5
+                c = 6   # -xx
+            assert a == 1 and b == 2
+            """,
+            [1,3,5,7], "5", excludes=['-cc', '-xx'])
+
+    def test_excluding_if_suite(self):
+        self.check_coverage("""\
+            a = 1; b = 2
+
+            if 0:
+                a = 4
+                b = 5
+                c = 6
+            assert a == 1 and b == 2
+            """,
+            [1,7], "", excludes=['if 0:'])
+
+    def test_excluding_if_but_not_else_suite(self):
+        self.check_coverage("""\
+            a = 1; b = 2
+
+            if 0:
+                a = 4
+                b = 5
+                c = 6
+            else:
+                a = 8
+                b = 9
+            assert a == 8 and b == 9
+            """,
+            [1,8,9,10], "", excludes=['if 0:'])
+
+    def test_excluding_else_suite(self):
+        self.check_coverage("""\
+            a = 1; b = 2
+
+            if 1==1:
+                a = 4
+                b = 5
+                c = 6
+            else:          #pragma: NO COVER
+                a = 8
+                b = 9
+            assert a == 4 and b == 5 and c == 6
+            """,
+            [1,3,4,5,6,10], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 1; b = 2
+
+            if 1==1:
+                a = 4
+                b = 5
+                c = 6
+
+            # Lots of comments to confuse the else handler.
+            # more.
+
+            else:          #pragma: NO COVER
+
+            # Comments here too.
+
+                a = 8
+                b = 9
+            assert a == 4 and b == 5 and c == 6
+            """,
+            [1,3,4,5,6,17], "", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_elif_suites(self):
+        self.check_coverage("""\
+            a = 1; b = 2
+
+            if 1==1:
+                a = 4
+                b = 5
+                c = 6
+            elif 1==0:          #pragma: NO COVER
+                a = 8
+                b = 9
+            else:
+                a = 11
+                b = 12
+            assert a == 4 and b == 5 and c == 6
+            """,
+            [1,3,4,5,6,11,12,13], "11-12", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_oneline_if(self):
+        self.check_coverage("""\
+            def foo():
+                a = 2
+                if 0: x = 3     # no cover
+                b = 4
+
+            foo()
+            """,
+            [1,2,4,6], "", excludes=["no cover"])
+
+    def test_excluding_a_colon_not_a_suite(self):
+        self.check_coverage("""\
+            def foo():
+                l = list(range(10))
+                a = l[:3]   # no cover
+                b = 4
+
+            foo()
+            """,
+            [1,2,4,6], "", excludes=["no cover"])
+
+    def test_excluding_for_suite(self):
+        self.check_coverage("""\
+            a = 0
+            for i in [1,2,3,4,5]:     #pragma: NO COVER
+                a += i
+            assert a == 15
+            """,
+            [1,4], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 0
+            for i in [1,
+                2,3,4,
+                5]:                #pragma: NO COVER
+                a += i
+            assert a == 15
+            """,
+            [1,6], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 0
+            for i in [1,2,3,4,5
+                ]:                        #pragma: NO COVER
+                a += i
+                break
+                a = 99
+            assert a == 1
+            """,
+            [1,7], "", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_for_else(self):
+        self.check_coverage("""\
+            a = 0
+            for i in range(5):
+                a += i+1
+                break
+                a = 99
+            else:               #pragma: NO COVER
+                a = 123
+            assert a == 1
+            """,
+            [1,2,3,4,5,8], "5", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_while(self):
+        self.check_coverage("""\
+            a = 3; b = 0
+            while a*b:           #pragma: NO COVER
+                b += 1
+                break
+                b = 99
+            assert a == 3 and b == 0
+            """,
+            [1,6], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 3; b = 0
+            while (
+                a*b
+                ):           #pragma: NO COVER
+                b += 1
+                break
+                b = 99
+            assert a == 3 and b == 0
+            """,
+            [1,8], "", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_while_else(self):
+        self.check_coverage("""\
+            a = 3; b = 0
+            while a:
+                b += 1
+                break
+                b = 99
+            else:           #pragma: NO COVER
+                b = 123
+            assert a == 3 and b == 1
+            """,
+            [1,2,3,4,5,8], "5", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_try_except(self):
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+            except:           #pragma: NO COVER
+                a = 99
+            assert a == 1
+            """,
+            [1,2,3,6], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+                raise Exception("foo")
+            except:
+                a = 99
+            assert a == 99
+            """,
+            [1,2,3,4,5,6,7], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+                raise Exception("foo")
+            except ImportError:    #pragma: NO COVER
+                a = 99
+            except:
+                a = 123
+            assert a == 123
+            """,
+            [1,2,3,4,7,8,9], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+            except:       #pragma: NO COVER
+                a = 99
+            else:
+                a = 123
+            assert a == 123
+            """,
+            [1,2,3,7,8], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+                raise Exception("foo")
+            except:
+                a = 99
+            else:              #pragma: NO COVER
+                a = 123
+            assert a == 99
+            """,
+            [1,2,3,4,5,6,9], "", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_try_except_pass(self):
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+            except:           #pragma: NO COVER
+                x = 2
+            assert a == 1
+            """,
+            [1,2,3,6], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+                raise Exception("foo")
+            except ImportError:    #pragma: NO COVER
+                x = 2
+            except:
+                a = 123
+            assert a == 123
+            """,
+            [1,2,3,4,7,8,9], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+            except:       #pragma: NO COVER
+                x = 2
+            else:
+                a = 123
+            assert a == 123
+            """,
+            [1,2,3,7,8], "", excludes=['#pragma: NO COVER'])
+        self.check_coverage("""\
+            a = 0
+            try:
+                a = 1
+                raise Exception("foo")
+            except:
+                a = 99
+            else:              #pragma: NO COVER
+                x = 2
+            assert a == 99
+            """,
+            [1,2,3,4,5,6,9], "", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_if_pass(self):
+        # From a comment on the coverage page by Michael McNeil Forbes:
+        self.check_coverage("""\
+            def f():
+                if False:    # pragma: no cover
+                    pass     # This line still reported as missing
+                if False:    # pragma: no cover
+                    x = 1    # Now it is skipped.
+
+            f()
+            """,
+            [1,7], "", excludes=["no cover"])
+
+    def test_excluding_function(self):
+        self.check_coverage("""\
+            def fn(foo):      #pragma: NO COVER
+                a = 1
+                b = 2
+                c = 3
+
+            x = 1
+            assert x == 1
+            """,
+            [6,7], "", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_method(self):
+        self.check_coverage("""\
+            class Fooey:
+                def __init__(self):
+                    self.a = 1
+
+                def foo(self):     #pragma: NO COVER
+                    return self.a
+
+            x = Fooey()
+            assert x.a == 1
+            """,
+            [1,2,3,8,9], "", excludes=['#pragma: NO COVER'])
+
+    def test_excluding_class(self):
+        self.check_coverage("""\
+            class Fooey:            #pragma: NO COVER
+                def __init__(self):
+                    self.a = 1
+
+                def foo(self):
+                    return self.a
+
+            x = 1
+            assert x == 1
+            """,
+            [8,9], "", excludes=['#pragma: NO COVER'])
+
+
+if sys.version_info >= (2, 4):
+    class Py24Test(CoverageTest):
+        """Tests of new syntax in Python 2.4."""
+
+        def test_function_decorators(self):
+            self.check_coverage("""\
+                def require_int(func):
+                    def wrapper(arg):
+                        assert isinstance(arg, int)
+                        return func(arg)
+
+                    return wrapper
+
+                @require_int
+                def p1(arg):
+                    return arg*2
+
+                assert p1(10) == 20
+                """,
+                [1,2,3,4,6,8,10,12], "")
+
+        def test_function_decorators_with_args(self):
+            self.check_coverage("""\
+                def boost_by(extra):
+                    def decorator(func):
+                        def wrapper(arg):
+                            return extra*func(arg)
+                        return wrapper
+                    return decorator
+
+                @boost_by(10)
+                def boosted(arg):
+                    return arg*2
+
+                assert boosted(10) == 200
+                """,
+                [1,2,3,4,5,6,8,10,12], "")
+
+        def test_double_function_decorators(self):
+            self.check_coverage("""\
+                def require_int(func):
+                    def wrapper(arg):
+                        assert isinstance(arg, int)
+                        return func(arg)
+                    return wrapper
+
+                def boost_by(extra):
+                    def decorator(func):
+                        def wrapper(arg):
+                            return extra*func(arg)
+                        return wrapper
+                    return decorator
+
+                @require_int
+                @boost_by(10)
+                def boosted1(arg):
+                    return arg*2
+
+                assert boosted1(10) == 200
+
+                @boost_by(10)
+                @require_int
+                def boosted2(arg):
+                    return arg*2
+
+                assert boosted2(10) == 200
+                """,
+                ([1,2,3,4,5,7,8,9,10,11,12,14,15,17,19,21,22,24,26],
+                 [1,2,3,4,5,7,8,9,10,11,12,14,   17,19,21,   24,26]), "")
+
+
+if sys.version_info >= (2, 5):
+    class Py25Test(CoverageTest):
+        """Tests of new syntax in Python 2.5."""
+
+        def test_with_statement(self):
+            self.check_coverage("""\
+                from __future__ import with_statement
+
+                class Managed:
+                    def __enter__(self):
+                        desc = "enter"
+
+                    def __exit__(self, type, value, tb):
+                        desc = "exit"
+
+                m = Managed()
+                with m:
+                    desc = "block1a"
+                    desc = "block1b"
+
+                try:
+                    with m:
+                        desc = "block2"
+                        raise Exception("Boo!")
+                except:
+                    desc = "caught"
+                """,
+                [1,3,4,5,7,8,10,11,12,13,15,16,17,18,19,20], "")
+
+        def test_try_except_finally(self):
+            self.check_coverage("""\
+                a = 0; b = 0
+                try:
+                    a = 1
+                except:
+                    a = 99
+                finally:
+                    b = 2
+                assert a == 1 and b == 2
+                """,
+                [1,2,3,4,5,7,8], "4-5")
+            self.check_coverage("""\
+                a = 0; b = 0
+                try:
+                    a = 1
+                    raise Exception("foo")
+                except:
+                    a = 99
+                finally:
+                    b = 2
+                assert a == 99 and b == 2
+                """,
+                [1,2,3,4,5,6,8,9], "")
+            self.check_coverage("""\
+                a = 0; b = 0
+                try:
+                    a = 1
+                    raise Exception("foo")
+                except ImportError:
+                    a = 99
+                except:
+                    a = 123
+                finally:
+                    b = 2
+                assert a == 123 and b == 2
+                """,
+                [1,2,3,4,5,6,7,8,10,11], "6")
+            self.check_coverage("""\
+                a = 0; b = 0
+                try:
+                    a = 1
+                    raise IOError("foo")
+                except ImportError:
+                    a = 99
+                except IOError:
+                    a = 17
+                except:
+                    a = 123
+                finally:
+                    b = 2
+                assert a == 17 and b == 2
+                """,
+                [1,2,3,4,5,6,7,8,9,10,12,13], "6, 9-10")
+            self.check_coverage("""\
+                a = 0; b = 0
+                try:
+                    a = 1
+                except:
+                    a = 99
+                else:
+                    a = 123
+                finally:
+                    b = 2
+                assert a == 123 and b == 2
+                """,
+                [1,2,3,4,5,7,9,10], "4-5")
+            self.check_coverage("""\
+                a = 0; b = 0
+                try:
+                    a = 1
+                    raise Exception("foo")
+                except:
+                    a = 99
+                else:
+                    a = 123
+                finally:
+                    b = 2
+                assert a == 99 and b == 2
+                """,
+                [1,2,3,4,5,6,8,10,11], "8")
+
+
+class ModuleTest(CoverageTest):
+    """Tests for the module-level behavior of the `coverage` module."""
+
+    def test_not_singleton(self):
+        # You *can* create another coverage object.
+        coverage.coverage()
+        coverage.coverage()
+
+
+class ReportingTest(CoverageTest):
+    """Tests of some reporting behavior."""
+
+    def test_no_data_to_report_on_annotate(self):
+        # Reporting with no data produces a nice message and no output dir.
+        self.assertRaisesRegexp(
+            CoverageException, "No data to report.",
+            self.command_line, "annotate -d ann"
+            )
+        self.assert_doesnt_exist("ann")
+
+    def test_no_data_to_report_on_html(self):
+        # Reporting with no data produces a nice message and no output dir.
+        self.assertRaisesRegexp(
+            CoverageException, "No data to report.",
+            self.command_line, "html -d htmlcov"
+            )
+        self.assert_doesnt_exist("htmlcov")
+
+    def test_no_data_to_report_on_xml(self):
+        # Reporting with no data produces a nice message.
+        self.assertRaisesRegexp(
+            CoverageException, "No data to report.",
+            self.command_line, "xml"
+            )
+        # Currently, this leaves an empty coverage.xml file... :(