| Index: tools/telemetry/third_party/coverage/tests/test_summary.py
|
| diff --git a/tools/telemetry/third_party/coverage/tests/test_summary.py b/tools/telemetry/third_party/coverage/tests/test_summary.py
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..a54d5337fc0c7e09a7aaa7ad67cc868b260529c1
|
| --- /dev/null
|
| +++ b/tools/telemetry/third_party/coverage/tests/test_summary.py
|
| @@ -0,0 +1,618 @@
|
| +# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
|
| +# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
|
| +
|
| +"""Test text-based summary reporting for coverage.py"""
|
| +
|
| +import glob
|
| +import os
|
| +import os.path
|
| +import py_compile
|
| +import re
|
| +import sys
|
| +
|
| +import coverage
|
| +from coverage import env
|
| +from coverage.backward import StringIO
|
| +
|
| +from tests.coveragetest import CoverageTest
|
| +
|
| +HERE = os.path.dirname(__file__)
|
| +
|
| +
|
| +class SummaryTest(CoverageTest):
|
| + """Tests of the text summary reporting for coverage.py."""
|
| +
|
| + def setUp(self):
|
| + super(SummaryTest, self).setUp()
|
| + # Parent class saves and restores sys.path, we can just modify it.
|
| + sys.path.append(self.nice_file(HERE, 'modules'))
|
| +
|
| + def make_mycode(self):
|
| + """Make the mycode.py file when needed."""
|
| + self.make_file("mycode.py", """\
|
| + import covmod1
|
| + import covmodzip1
|
| + a = 1
|
| + print('done')
|
| + """)
|
| +
|
| + def test_report(self):
|
| + self.make_mycode()
|
| + out = self.run_command("coverage run mycode.py")
|
| + self.assertEqual(out, 'done\n')
|
| + report = self.report_from_command("coverage report")
|
| +
|
| + # Name Stmts Miss Cover
|
| + # ------------------------------------------------------------------
|
| + # c:/ned/coverage/tests/modules/covmod1.py 2 0 100%
|
| + # c:/ned/coverage/tests/zipmods.zip/covmodzip1.py 3 0 100%
|
| + # mycode.py 4 0 100%
|
| + # ------------------------------------------------------------------
|
| + # TOTAL 9 0 100%
|
| +
|
| + self.assertNotIn("/coverage/__init__/", report)
|
| + self.assertIn("/tests/modules/covmod1.py ", report)
|
| + self.assertIn("/tests/zipmods.zip/covmodzip1.py ", report)
|
| + self.assertIn("mycode.py ", report)
|
| + self.assertEqual(self.last_line_squeezed(report), "TOTAL 9 0 100%")
|
| +
|
| + def test_report_just_one(self):
|
| + # Try reporting just one module
|
| + self.make_mycode()
|
| + self.run_command("coverage run mycode.py")
|
| + report = self.report_from_command("coverage report mycode.py")
|
| +
|
| + # Name Stmts Miss Cover
|
| + # -------------------------------
|
| + # mycode.py 4 0 100%
|
| +
|
| + self.assertEqual(self.line_count(report), 3)
|
| + self.assertNotIn("/coverage/", report)
|
| + self.assertNotIn("/tests/modules/covmod1.py ", report)
|
| + self.assertNotIn("/tests/zipmods.zip/covmodzip1.py ", report)
|
| + self.assertIn("mycode.py ", report)
|
| + self.assertEqual(self.last_line_squeezed(report), "mycode.py 4 0 100%")
|
| +
|
| + def test_report_wildcard(self):
|
| + # Try reporting using wildcards to get the modules.
|
| + self.make_mycode()
|
| + self.run_command("coverage run mycode.py")
|
| + report = self.report_from_command("coverage report my*.py")
|
| +
|
| + # Name Stmts Miss Cover
|
| + # -------------------------------
|
| + # mycode.py 4 0 100%
|
| +
|
| + self.assertEqual(self.line_count(report), 3)
|
| + self.assertNotIn("/coverage/", report)
|
| + self.assertNotIn("/tests/modules/covmod1.py ", report)
|
| + self.assertNotIn("/tests/zipmods.zip/covmodzip1.py ", report)
|
| + self.assertIn("mycode.py ", report)
|
| + self.assertEqual(self.last_line_squeezed(report), "mycode.py 4 0 100%")
|
| +
|
| + def test_report_omitting(self):
|
| + # Try reporting while omitting some modules
|
| + self.make_mycode()
|
| + self.run_command("coverage run mycode.py")
|
| + report = self.report_from_command("coverage report --omit '%s/*'" % HERE)
|
| +
|
| + # Name Stmts Miss Cover
|
| + # -------------------------------
|
| + # mycode.py 4 0 100%
|
| +
|
| + self.assertEqual(self.line_count(report), 3)
|
| + self.assertNotIn("/coverage/", report)
|
| + self.assertNotIn("/tests/modules/covmod1.py ", report)
|
| + self.assertNotIn("/tests/zipmods.zip/covmodzip1.py ", report)
|
| + self.assertIn("mycode.py ", report)
|
| + self.assertEqual(self.last_line_squeezed(report), "mycode.py 4 0 100%")
|
| +
|
| + def test_report_including(self):
|
| + # Try reporting while including some modules
|
| + self.make_mycode()
|
| + self.run_command("coverage run mycode.py")
|
| + report = self.report_from_command("coverage report --include=mycode*")
|
| +
|
| + # Name Stmts Miss Cover
|
| + # -------------------------------
|
| + # mycode.py 4 0 100%
|
| +
|
| + self.assertEqual(self.line_count(report), 3)
|
| + self.assertNotIn("/coverage/", report)
|
| + self.assertNotIn("/tests/modules/covmod1.py ", report)
|
| + self.assertNotIn("/tests/zipmods.zip/covmodzip1.py ", report)
|
| + self.assertIn("mycode.py ", report)
|
| + self.assertEqual(self.last_line_squeezed(report), "mycode.py 4 0 100%")
|
| +
|
| + def test_report_branches(self):
|
| + self.make_file("mybranch.py", """\
|
| + def branch(x):
|
| + if x:
|
| + print("x")
|
| + return x
|
| + branch(1)
|
| + """)
|
| + out = self.run_command("coverage run --branch mybranch.py")
|
| + self.assertEqual(out, 'x\n')
|
| + report = self.report_from_command("coverage report")
|
| +
|
| + # Name Stmts Miss Branch BrPart Cover
|
| + # -----------------------------------------------
|
| + # mybranch.py 5 0 2 1 85%
|
| +
|
| + self.assertEqual(self.line_count(report), 3)
|
| + self.assertIn("mybranch.py ", report)
|
| + self.assertEqual(self.last_line_squeezed(report), "mybranch.py 5 0 2 1 86%")
|
| +
|
| + def test_report_show_missing(self):
|
| + self.make_file("mymissing.py", """\
|
| + def missing(x, y):
|
| + if x:
|
| + print("x")
|
| + return x
|
| + if y:
|
| + print("y")
|
| + try:
|
| + print("z")
|
| + 1/0
|
| + print("Never!")
|
| + except ZeroDivisionError:
|
| + pass
|
| + return x
|
| + missing(0, 1)
|
| + """)
|
| + out = self.run_command("coverage run mymissing.py")
|
| + self.assertEqual(out, 'y\nz\n')
|
| + report = self.report_from_command("coverage report --show-missing")
|
| +
|
| + # Name Stmts Miss Cover Missing
|
| + # --------------------------------------------
|
| + # mymissing.py 14 3 79% 3-4, 10
|
| +
|
| + self.assertEqual(self.line_count(report), 3)
|
| + self.assertIn("mymissing.py ", report)
|
| + self.assertEqual(self.last_line_squeezed(report),
|
| + "mymissing.py 14 3 79% 3-4, 10")
|
| +
|
| + def test_report_show_missing_branches(self):
|
| + self.make_file("mybranch.py", """\
|
| + def branch(x, y):
|
| + if x:
|
| + print("x")
|
| + if y:
|
| + print("y")
|
| + return x
|
| + branch(1, 1)
|
| + """)
|
| + out = self.run_command("coverage run --branch mybranch.py")
|
| + self.assertEqual(out, 'x\ny\n')
|
| + report = self.report_from_command("coverage report --show-missing")
|
| +
|
| + # Name Stmts Miss Branch BrPart Cover Missing
|
| + # ----------------------------------------------------------
|
| + # mybranch.py 7 0 4 2 82% 2->4, 4->6
|
| +
|
| + self.assertEqual(self.line_count(report), 3)
|
| + self.assertIn("mybranch.py ", report)
|
| + self.assertEqual(self.last_line_squeezed(report),
|
| + "mybranch.py 7 0 4 2 82% 2->4, 4->6")
|
| +
|
| + def test_report_show_missing_branches_and_lines(self):
|
| + self.make_file("main.py", """\
|
| + import mybranch
|
| + """)
|
| + self.make_file("mybranch.py", """\
|
| + def branch(x, y, z):
|
| + if x:
|
| + print("x")
|
| + if y:
|
| + print("y")
|
| + if z:
|
| + if x and y:
|
| + print("z")
|
| + return x
|
| + branch(1, 1, 0)
|
| + """)
|
| + out = self.run_command("coverage run --branch main.py")
|
| + self.assertEqual(out, 'x\ny\n')
|
| + report = self.report_from_command("coverage report --show-missing")
|
| +
|
| + # Name Stmts Miss Branch BrPart Cover Missing
|
| + # -------------------------------------------------------
|
| + # main.py 1 0 0 0 100%
|
| + # mybranch.py 10 2 8 3 61% 7-8, 2->4, 4->6, 6->7
|
| + # -------------------------------------------------------
|
| + # TOTAL 11 2 8 3 63%
|
| +
|
| + self.assertEqual(self.line_count(report), 6)
|
| + squeezed = self.squeezed_lines(report)
|
| + self.assertEqual(
|
| + squeezed[2],
|
| + "main.py 1 0 0 0 100%"
|
| + )
|
| + self.assertEqual(
|
| + squeezed[3],
|
| + "mybranch.py 10 2 8 3 61% 7-8, 2->4, 4->6, 6->7"
|
| + )
|
| + self.assertEqual(
|
| + squeezed[5],
|
| + "TOTAL 11 2 8 3 63%"
|
| + )
|
| +
|
| + def test_report_skip_covered_no_branches(self):
|
| + self.make_file("main.py", """
|
| + import not_covered
|
| +
|
| + def normal():
|
| + print("z")
|
| + normal()
|
| + """)
|
| + self.make_file("not_covered.py", """
|
| + def not_covered():
|
| + print("n")
|
| + """)
|
| + out = self.run_command("coverage run main.py")
|
| + self.assertEqual(out, "z\n")
|
| + report = self.report_from_command("coverage report --skip-covered")
|
| +
|
| + # Name Stmts Miss Cover
|
| + # ------------------------------------
|
| + # not_covered.py 2 1 50%
|
| + #
|
| + # 1 file skipped due to complete coverage.
|
| +
|
| + self.assertEqual(self.line_count(report), 5, report)
|
| + squeezed = self.squeezed_lines(report)
|
| + self.assertEqual(squeezed[2], "not_covered.py 2 1 50%")
|
| +
|
| + def test_report_skip_covered_branches(self):
|
| + self.make_file("main.py", """
|
| + import not_covered, covered
|
| +
|
| + def normal(z):
|
| + if z:
|
| + print("z")
|
| + normal(True)
|
| + normal(False)
|
| + """)
|
| + self.make_file("not_covered.py", """
|
| + def not_covered(n):
|
| + if n:
|
| + print("n")
|
| + not_covered(True)
|
| + """)
|
| + self.make_file("covered.py", """
|
| + def foo():
|
| + pass
|
| + foo()
|
| + """)
|
| + out = self.run_command("coverage run --branch main.py")
|
| + self.assertEqual(out, "n\nz\n")
|
| + report = self.report_from_command("coverage report --skip-covered")
|
| +
|
| + # Name Stmts Miss Branch BrPart Cover
|
| + # --------------------------------------------------
|
| + # not_covered.py 4 0 2 1 83%
|
| + #
|
| + # 2 files skipped due to complete coverage.
|
| +
|
| + self.assertEqual(self.line_count(report), 5, report)
|
| + squeezed = self.squeezed_lines(report)
|
| + self.assertEqual(squeezed[2], "not_covered.py 4 0 2 1 83%")
|
| +
|
| + def test_report_skip_covered_branches_with_totals(self):
|
| + self.make_file("main.py", """
|
| + import not_covered
|
| + import also_not_run
|
| +
|
| + def normal(z):
|
| + if z:
|
| + print("z")
|
| + normal(True)
|
| + normal(False)
|
| + """)
|
| + self.make_file("not_covered.py", """
|
| + def not_covered(n):
|
| + if n:
|
| + print("n")
|
| + not_covered(True)
|
| + """)
|
| + self.make_file("also_not_run.py", """
|
| + def does_not_appear_in_this_film(ni):
|
| + print("Ni!")
|
| + """)
|
| + out = self.run_command("coverage run --branch main.py")
|
| + self.assertEqual(out, "n\nz\n")
|
| + report = self.report_from_command("coverage report --skip-covered")
|
| +
|
| + # Name Stmts Miss Branch BrPart Cover
|
| + # --------------------------------------------------
|
| + # also_not_run.py 2 1 0 0 50%
|
| + # not_covered.py 4 0 2 1 83%
|
| + # --------------------------------------------------
|
| + # TOTAL 6 1 2 1 75%
|
| + #
|
| + # 1 file skipped due to complete coverage.
|
| +
|
| + self.assertEqual(self.line_count(report), 8, report)
|
| + squeezed = self.squeezed_lines(report)
|
| + self.assertEqual(squeezed[2], "also_not_run.py 2 1 0 0 50%")
|
| + self.assertEqual(squeezed[3], "not_covered.py 4 0 2 1 83%")
|
| + self.assertEqual(squeezed[5], "TOTAL 6 1 2 1 75%")
|
| + self.assertEqual(squeezed[7], "1 file skipped due to complete coverage.")
|
| +
|
| + def test_report_skip_covered_all_files_covered(self):
|
| + self.make_file("main.py", """
|
| + def foo():
|
| + pass
|
| + foo()
|
| + """)
|
| + out = self.run_command("coverage run --branch main.py")
|
| + self.assertEqual(out, "")
|
| + report = self.report_from_command("coverage report --skip-covered")
|
| +
|
| + # Name Stmts Miss Branch BrPart Cover
|
| + # -------------------------------------------
|
| + #
|
| + # 1 file skipped due to complete coverage.
|
| +
|
| + self.assertEqual(self.line_count(report), 4, report)
|
| + squeezed = self.squeezed_lines(report)
|
| + self.assertEqual(squeezed[3], "1 file skipped due to complete coverage.")
|
| +
|
| + def test_report_skip_covered_no_data(self):
|
| + report = self.report_from_command("coverage report --skip-covered")
|
| +
|
| + # Name Stmts Miss Branch BrPart Cover
|
| + # -------------------------------------------
|
| + # No data to report.
|
| +
|
| + self.assertEqual(self.line_count(report), 3, report)
|
| + squeezed = self.squeezed_lines(report)
|
| + self.assertEqual(squeezed[2], "No data to report.")
|
| +
|
| + def test_dotpy_not_python(self):
|
| + # We run a .py file, and when reporting, we can't parse it as Python.
|
| + # We should get an error message in the report.
|
| +
|
| + self.make_mycode()
|
| + self.run_command("coverage run mycode.py")
|
| + self.make_file("mycode.py", "This isn't python at all!")
|
| + report = self.report_from_command("coverage report mycode.py")
|
| +
|
| + # Name Stmts Miss Cover
|
| + # ----------------------------
|
| + # mycode NotPython: Couldn't parse '...' as Python source: 'invalid syntax' at line 1
|
| + # No data to report.
|
| +
|
| + last = self.squeezed_lines(report)[-2]
|
| + # The actual file name varies run to run.
|
| + last = re.sub(r"parse '.*mycode.py", "parse 'mycode.py", last)
|
| + # The actual error message varies version to version
|
| + last = re.sub(r": '.*' at", ": 'error' at", last)
|
| + self.assertEqual(
|
| + last,
|
| + "mycode.py NotPython: Couldn't parse 'mycode.py' as Python source: 'error' at line 1"
|
| + )
|
| +
|
| + def test_dotpy_not_python_ignored(self):
|
| + # We run a .py file, and when reporting, we can't parse it as Python,
|
| + # but we've said to ignore errors, so there's no error reported.
|
| + self.make_mycode()
|
| + self.run_command("coverage run mycode.py")
|
| + self.make_file("mycode.py", "This isn't python at all!")
|
| + report = self.report_from_command("coverage report -i mycode.py")
|
| +
|
| + # Name Stmts Miss Cover
|
| + # ----------------------------
|
| +
|
| + self.assertEqual(self.line_count(report), 3)
|
| + self.assertIn('No data to report.', report)
|
| +
|
| + def test_dothtml_not_python(self):
|
| + # We run a .html file, and when reporting, we can't parse it as
|
| + # Python. Since it wasn't .py, no error is reported.
|
| +
|
| + # Run an "html" file
|
| + self.make_file("mycode.html", "a = 1")
|
| + self.run_command("coverage run mycode.html")
|
| + # Before reporting, change it to be an HTML file.
|
| + self.make_file("mycode.html", "<h1>This isn't python at all!</h1>")
|
| + report = self.report_from_command("coverage report mycode.html")
|
| +
|
| + # Name Stmts Miss Cover
|
| + # ----------------------------
|
| + # No data to report.
|
| +
|
| + self.assertEqual(self.line_count(report), 3)
|
| + self.assertIn('No data to report.', report)
|
| +
|
| + def get_report(self, cov):
|
| + """Get the report from `cov`, and canonicalize it."""
|
| + repout = StringIO()
|
| + cov.report(file=repout, show_missing=False)
|
| + report = repout.getvalue().replace('\\', '/')
|
| + report = re.sub(r" +", " ", report)
|
| + return report
|
| +
|
| + def test_bug_156_file_not_run_should_be_zero(self):
|
| + # https://bitbucket.org/ned/coveragepy/issue/156
|
| + self.make_file("mybranch.py", """\
|
| + def branch(x):
|
| + if x:
|
| + print("x")
|
| + return x
|
| + branch(1)
|
| + """)
|
| + self.make_file("main.py", """\
|
| + print("y")
|
| + """)
|
| + cov = coverage.Coverage(branch=True, source=["."])
|
| + cov.start()
|
| + import main # pragma: nested # pylint: disable=import-error,unused-variable
|
| + cov.stop() # pragma: nested
|
| + report = self.get_report(cov).splitlines()
|
| + self.assertIn("mybranch.py 5 5 2 0 0%", report)
|
| +
|
| + def run_TheCode_and_report_it(self):
|
| + """A helper for the next few tests."""
|
| + cov = coverage.Coverage()
|
| + cov.start()
|
| + import TheCode # pragma: nested # pylint: disable=import-error,unused-variable
|
| + cov.stop() # pragma: nested
|
| + return self.get_report(cov)
|
| +
|
| + def test_bug_203_mixed_case_listed_twice_with_rc(self):
|
| + self.make_file("TheCode.py", "a = 1\n")
|
| + self.make_file(".coveragerc", "[run]\nsource = .\n")
|
| +
|
| + report = self.run_TheCode_and_report_it()
|
| +
|
| + self.assertIn("TheCode", report)
|
| + self.assertNotIn("thecode", report)
|
| +
|
| + def test_bug_203_mixed_case_listed_twice(self):
|
| + self.make_file("TheCode.py", "a = 1\n")
|
| +
|
| + report = self.run_TheCode_and_report_it()
|
| +
|
| + self.assertIn("TheCode", report)
|
| + self.assertNotIn("thecode", report)
|
| +
|
| + def test_pyw_files(self):
|
| + if not env.WINDOWS:
|
| + self.skip(".pyw files are only on Windows.")
|
| +
|
| + # https://bitbucket.org/ned/coveragepy/issue/261
|
| + self.make_file("start.pyw", """\
|
| + import mod
|
| + print("In start.pyw")
|
| + """)
|
| + self.make_file("mod.pyw", """\
|
| + print("In mod.pyw")
|
| + """)
|
| + cov = coverage.Coverage()
|
| + cov.start()
|
| + import start # pragma: nested # pylint: disable=import-error,unused-variable
|
| + cov.stop() # pragma: nested
|
| +
|
| + report = self.get_report(cov)
|
| + self.assertNotIn("NoSource", report)
|
| + report = report.splitlines()
|
| + self.assertIn("start.pyw 2 0 100%", report)
|
| + self.assertIn("mod.pyw 1 0 100%", report)
|
| +
|
| + def test_tracing_pyc_file(self):
|
| + # Create two Python files.
|
| + self.make_file("mod.py", "a = 1\n")
|
| + self.make_file("main.py", "import mod\n")
|
| +
|
| + # Make one into a .pyc.
|
| + py_compile.compile("mod.py")
|
| +
|
| + # Run the program.
|
| + cov = coverage.Coverage()
|
| + cov.start()
|
| + import main # pragma: nested # pylint: disable=import-error,unused-variable
|
| + cov.stop() # pragma: nested
|
| +
|
| + report = self.get_report(cov).splitlines()
|
| + self.assertIn("mod.py 1 0 100%", report)
|
| +
|
| + def test_missing_py_file_during_run(self):
|
| + # PyPy2 doesn't run bare .pyc files.
|
| + if env.PYPY and env.PY2:
|
| + self.skip("PyPy2 doesn't run bare .pyc files")
|
| +
|
| + # Create two Python files.
|
| + self.make_file("mod.py", "a = 1\n")
|
| + self.make_file("main.py", "import mod\n")
|
| +
|
| + # Make one into a .pyc, and remove the .py.
|
| + py_compile.compile("mod.py")
|
| + os.remove("mod.py")
|
| +
|
| + # Python 3 puts the .pyc files in a __pycache__ directory, and will
|
| + # not import from there without source. It will import a .pyc from
|
| + # the source location though.
|
| + if not os.path.exists("mod.pyc"):
|
| + pycs = glob.glob("__pycache__/mod.*.pyc")
|
| + self.assertEqual(len(pycs), 1)
|
| + os.rename(pycs[0], "mod.pyc")
|
| +
|
| + # Run the program.
|
| + cov = coverage.Coverage()
|
| + cov.start()
|
| + import main # pragma: nested # pylint: disable=import-error,unused-variable
|
| + cov.stop() # pragma: nested
|
| +
|
| + # Put back the missing Python file.
|
| + self.make_file("mod.py", "a = 1\n")
|
| + report = self.get_report(cov).splitlines()
|
| + self.assertIn("mod.py 1 0 100%", report)
|
| +
|
| +
|
| +class SummaryTest2(CoverageTest):
|
| + """Another bunch of summary tests."""
|
| + # This class exists because tests naturally clump into classes based on the
|
| + # needs of their setUp, rather than the product features they are testing.
|
| + # There's probably a better way to organize these.
|
| +
|
| + run_in_temp_dir = False
|
| +
|
| + def setUp(self):
|
| + super(SummaryTest2, self).setUp()
|
| + # Parent class saves and restores sys.path, we can just modify it.
|
| + sys.path.append(self.nice_file(HERE, 'modules'))
|
| + sys.path.append(self.nice_file(HERE, 'moremodules'))
|
| +
|
| + def test_empty_files(self):
|
| + # Shows that empty files like __init__.py are listed as having zero
|
| + # statements, not one statement.
|
| + cov = coverage.Coverage()
|
| + cov.start()
|
| + import usepkgs # pragma: nested # pylint: disable=import-error,unused-variable
|
| + cov.stop() # pragma: nested
|
| +
|
| + repout = StringIO()
|
| + cov.report(file=repout, show_missing=False)
|
| +
|
| + report = repout.getvalue().replace('\\', '/')
|
| + report = re.sub(r"\s+", " ", report)
|
| + self.assertIn("tests/modules/pkg1/__init__.py 1 0 100%", report)
|
| + self.assertIn("tests/modules/pkg2/__init__.py 0 0 100%", report)
|
| +
|
| +
|
| +class ReportingReturnValueTest(CoverageTest):
|
| + """Tests of reporting functions returning values."""
|
| +
|
| + def run_coverage(self):
|
| + """Run coverage on doit.py and return the coverage object."""
|
| + self.make_file("doit.py", """\
|
| + a = 1
|
| + b = 2
|
| + c = 3
|
| + d = 4
|
| + if a > 10:
|
| + f = 6
|
| + g = 7
|
| + """)
|
| +
|
| + cov = coverage.Coverage()
|
| + self.start_import_stop(cov, "doit")
|
| + return cov
|
| +
|
| + def test_report(self):
|
| + cov = self.run_coverage()
|
| + val = cov.report(include="*/doit.py")
|
| + self.assertAlmostEqual(val, 85.7, 1)
|
| +
|
| + def test_html(self):
|
| + cov = self.run_coverage()
|
| + val = cov.html_report(include="*/doit.py")
|
| + self.assertAlmostEqual(val, 85.7, 1)
|
| +
|
| + def test_xml(self):
|
| + cov = self.run_coverage()
|
| + val = cov.xml_report(include="*/doit.py")
|
| + self.assertAlmostEqual(val, 85.7, 1)
|
|
|
Chromium Code Reviews
