| Index: tools/telemetry/third_party/coverage/tests/test_api.py
|
| diff --git a/tools/telemetry/third_party/coverage/tests/test_api.py b/tools/telemetry/third_party/coverage/tests/test_api.py
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..92d3cbc9fd9470500002b881659a7e123af5c429
|
| --- /dev/null
|
| +++ b/tools/telemetry/third_party/coverage/tests/test_api.py
|
| @@ -0,0 +1,515 @@
|
| +# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
|
| +# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
|
| +
|
| +"""Tests for coverage.py's API."""
|
| +
|
| +import fnmatch
|
| +import os
|
| +import sys
|
| +import textwrap
|
| +
|
| +import coverage
|
| +from coverage.backward import StringIO
|
| +from coverage.misc import CoverageException
|
| +
|
| +from tests.coveragetest import CoverageTest
|
| +
|
| +
|
| +class ApiTest(CoverageTest):
|
| + """Api-oriented tests for coverage.py."""
|
| +
|
| + def clean_files(self, files, pats):
|
| + """Remove names matching `pats` from `files`, a list of file names."""
|
| + good = []
|
| + for f in files:
|
| + for pat in pats:
|
| + if fnmatch.fnmatch(f, pat):
|
| + break
|
| + else:
|
| + good.append(f)
|
| + return good
|
| +
|
| + def assertFiles(self, files):
|
| + """Assert that the files here are `files`, ignoring the usual junk."""
|
| + here = os.listdir(".")
|
| + here = self.clean_files(here, ["*.pyc", "__pycache__"])
|
| + self.assertCountEqual(here, files)
|
| +
|
| + def test_unexecuted_file(self):
|
| + cov = coverage.Coverage()
|
| +
|
| + self.make_file("mycode.py", """\
|
| + a = 1
|
| + b = 2
|
| + if b == 3:
|
| + c = 4
|
| + d = 5
|
| + """)
|
| +
|
| + self.make_file("not_run.py", """\
|
| + fooey = 17
|
| + """)
|
| +
|
| + # Import the Python file, executing it.
|
| + self.start_import_stop(cov, "mycode")
|
| +
|
| + _, statements, missing, _ = cov.analysis("not_run.py")
|
| + self.assertEqual(statements, [1])
|
| + self.assertEqual(missing, [1])
|
| +
|
| + def test_filenames(self):
|
| +
|
| + self.make_file("mymain.py", """\
|
| + import mymod
|
| + a = 1
|
| + """)
|
| +
|
| + self.make_file("mymod.py", """\
|
| + fooey = 17
|
| + """)
|
| +
|
| + # Import the Python file, executing it.
|
| + cov = coverage.Coverage()
|
| + self.start_import_stop(cov, "mymain")
|
| +
|
| + filename, _, _, _ = cov.analysis("mymain.py")
|
| + self.assertEqual(os.path.basename(filename), "mymain.py")
|
| + filename, _, _, _ = cov.analysis("mymod.py")
|
| + self.assertEqual(os.path.basename(filename), "mymod.py")
|
| +
|
| + filename, _, _, _ = cov.analysis(sys.modules["mymain"])
|
| + self.assertEqual(os.path.basename(filename), "mymain.py")
|
| + filename, _, _, _ = cov.analysis(sys.modules["mymod"])
|
| + self.assertEqual(os.path.basename(filename), "mymod.py")
|
| +
|
| + # Import the Python file, executing it again, once it's been compiled
|
| + # already.
|
| + cov = coverage.Coverage()
|
| + self.start_import_stop(cov, "mymain")
|
| +
|
| + filename, _, _, _ = cov.analysis("mymain.py")
|
| + self.assertEqual(os.path.basename(filename), "mymain.py")
|
| + filename, _, _, _ = cov.analysis("mymod.py")
|
| + self.assertEqual(os.path.basename(filename), "mymod.py")
|
| +
|
| + filename, _, _, _ = cov.analysis(sys.modules["mymain"])
|
| + self.assertEqual(os.path.basename(filename), "mymain.py")
|
| + filename, _, _, _ = cov.analysis(sys.modules["mymod"])
|
| + self.assertEqual(os.path.basename(filename), "mymod.py")
|
| +
|
| + def test_ignore_stdlib(self):
|
| + self.make_file("mymain.py", """\
|
| + import colorsys
|
| + a = 1
|
| + hls = colorsys.rgb_to_hls(1.0, 0.5, 0.0)
|
| + """)
|
| +
|
| + # Measure without the stdlib.
|
| + cov1 = coverage.Coverage()
|
| + self.assertEqual(cov1.config.cover_pylib, False)
|
| + self.start_import_stop(cov1, "mymain")
|
| +
|
| + # some statements were marked executed in mymain.py
|
| + _, statements, missing, _ = cov1.analysis("mymain.py")
|
| + self.assertNotEqual(statements, missing)
|
| + # but none were in colorsys.py
|
| + _, statements, missing, _ = cov1.analysis("colorsys.py")
|
| + self.assertEqual(statements, missing)
|
| +
|
| + # Measure with the stdlib.
|
| + cov2 = coverage.Coverage(cover_pylib=True)
|
| + self.start_import_stop(cov2, "mymain")
|
| +
|
| + # some statements were marked executed in mymain.py
|
| + _, statements, missing, _ = cov2.analysis("mymain.py")
|
| + self.assertNotEqual(statements, missing)
|
| + # and some were marked executed in colorsys.py
|
| + _, statements, missing, _ = cov2.analysis("colorsys.py")
|
| + self.assertNotEqual(statements, missing)
|
| +
|
| + def test_include_can_measure_stdlib(self):
|
| + self.make_file("mymain.py", """\
|
| + import colorsys, random
|
| + a = 1
|
| + r, g, b = [random.random() for _ in range(3)]
|
| + hls = colorsys.rgb_to_hls(r, g, b)
|
| + """)
|
| +
|
| + # Measure without the stdlib, but include colorsys.
|
| + cov1 = coverage.Coverage(cover_pylib=False, include=["*/colorsys.py"])
|
| + self.start_import_stop(cov1, "mymain")
|
| +
|
| + # some statements were marked executed in colorsys.py
|
| + _, statements, missing, _ = cov1.analysis("colorsys.py")
|
| + self.assertNotEqual(statements, missing)
|
| + # but none were in random.py
|
| + _, statements, missing, _ = cov1.analysis("random.py")
|
| + self.assertEqual(statements, missing)
|
| +
|
| + def test_exclude_list(self):
|
| + cov = coverage.Coverage()
|
| + cov.clear_exclude()
|
| + self.assertEqual(cov.get_exclude_list(), [])
|
| + cov.exclude("foo")
|
| + self.assertEqual(cov.get_exclude_list(), ["foo"])
|
| + cov.exclude("bar")
|
| + self.assertEqual(cov.get_exclude_list(), ["foo", "bar"])
|
| + self.assertEqual(cov._exclude_regex('exclude'), "(?:foo)|(?:bar)")
|
| + cov.clear_exclude()
|
| + self.assertEqual(cov.get_exclude_list(), [])
|
| +
|
| + def test_exclude_partial_list(self):
|
| + cov = coverage.Coverage()
|
| + cov.clear_exclude(which='partial')
|
| + self.assertEqual(cov.get_exclude_list(which='partial'), [])
|
| + cov.exclude("foo", which='partial')
|
| + self.assertEqual(cov.get_exclude_list(which='partial'), ["foo"])
|
| + cov.exclude("bar", which='partial')
|
| + self.assertEqual(cov.get_exclude_list(which='partial'), ["foo", "bar"])
|
| + self.assertEqual(
|
| + cov._exclude_regex(which='partial'), "(?:foo)|(?:bar)"
|
| + )
|
| + cov.clear_exclude(which='partial')
|
| + self.assertEqual(cov.get_exclude_list(which='partial'), [])
|
| +
|
| + def test_exclude_and_partial_are_separate_lists(self):
|
| + cov = coverage.Coverage()
|
| + cov.clear_exclude(which='partial')
|
| + cov.clear_exclude(which='exclude')
|
| + cov.exclude("foo", which='partial')
|
| + self.assertEqual(cov.get_exclude_list(which='partial'), ['foo'])
|
| + self.assertEqual(cov.get_exclude_list(which='exclude'), [])
|
| + cov.exclude("bar", which='exclude')
|
| + self.assertEqual(cov.get_exclude_list(which='partial'), ['foo'])
|
| + self.assertEqual(cov.get_exclude_list(which='exclude'), ['bar'])
|
| + cov.exclude("p2", which='partial')
|
| + cov.exclude("e2", which='exclude')
|
| + self.assertEqual(cov.get_exclude_list(which='partial'), ['foo', 'p2'])
|
| + self.assertEqual(cov.get_exclude_list(which='exclude'), ['bar', 'e2'])
|
| + cov.clear_exclude(which='partial')
|
| + self.assertEqual(cov.get_exclude_list(which='partial'), [])
|
| + self.assertEqual(cov.get_exclude_list(which='exclude'), ['bar', 'e2'])
|
| + cov.clear_exclude(which='exclude')
|
| + self.assertEqual(cov.get_exclude_list(which='partial'), [])
|
| + self.assertEqual(cov.get_exclude_list(which='exclude'), [])
|
| +
|
| + def test_datafile_default(self):
|
| + # Default data file behavior: it's .coverage
|
| + self.make_file("datatest1.py", """\
|
| + fooey = 17
|
| + """)
|
| +
|
| + self.assertFiles(["datatest1.py"])
|
| + cov = coverage.Coverage()
|
| + self.start_import_stop(cov, "datatest1")
|
| + cov.save()
|
| + self.assertFiles(["datatest1.py", ".coverage"])
|
| +
|
| + def test_datafile_specified(self):
|
| + # You can specify the data file name.
|
| + self.make_file("datatest2.py", """\
|
| + fooey = 17
|
| + """)
|
| +
|
| + self.assertFiles(["datatest2.py"])
|
| + cov = coverage.Coverage(data_file="cov.data")
|
| + self.start_import_stop(cov, "datatest2")
|
| + cov.save()
|
| + self.assertFiles(["datatest2.py", "cov.data"])
|
| +
|
| + def test_datafile_and_suffix_specified(self):
|
| + # You can specify the data file name and suffix.
|
| + self.make_file("datatest3.py", """\
|
| + fooey = 17
|
| + """)
|
| +
|
| + self.assertFiles(["datatest3.py"])
|
| + cov = coverage.Coverage(data_file="cov.data", data_suffix="14")
|
| + self.start_import_stop(cov, "datatest3")
|
| + cov.save()
|
| + self.assertFiles(["datatest3.py", "cov.data.14"])
|
| +
|
| + def test_datafile_from_rcfile(self):
|
| + # You can specify the data file name in the .coveragerc file
|
| + self.make_file("datatest4.py", """\
|
| + fooey = 17
|
| + """)
|
| + self.make_file(".coveragerc", """\
|
| + [run]
|
| + data_file = mydata.dat
|
| + """)
|
| +
|
| + self.assertFiles(["datatest4.py", ".coveragerc"])
|
| + cov = coverage.Coverage()
|
| + self.start_import_stop(cov, "datatest4")
|
| + cov.save()
|
| + self.assertFiles(["datatest4.py", ".coveragerc", "mydata.dat"])
|
| +
|
| + def test_empty_reporting(self):
|
| + # empty summary reports raise exception, just like the xml report
|
| + cov = coverage.Coverage()
|
| + cov.erase()
|
| + self.assertRaises(CoverageException, cov.report)
|
| +
|
| + def test_start_stop_start_stop(self):
|
| + self.make_file("code1.py", """\
|
| + code1 = 1
|
| + """)
|
| + self.make_file("code2.py", """\
|
| + code2 = 1
|
| + code2 = 2
|
| + """)
|
| + cov = coverage.Coverage()
|
| + self.start_import_stop(cov, "code1")
|
| + cov.save()
|
| + self.start_import_stop(cov, "code2")
|
| + _, statements, missing, _ = cov.analysis("code1.py")
|
| + self.assertEqual(statements, [1])
|
| + self.assertEqual(missing, [])
|
| + _, statements, missing, _ = cov.analysis("code2.py")
|
| + self.assertEqual(statements, [1, 2])
|
| + self.assertEqual(missing, [])
|
| +
|
| + if 0: # expected failure
|
| + # for https://bitbucket.org/ned/coveragepy/issue/79
|
| + def test_start_save_stop(self):
|
| + self.make_file("code1.py", """\
|
| + code1 = 1
|
| + """)
|
| + self.make_file("code2.py", """\
|
| + code2 = 1
|
| + code2 = 2
|
| + """)
|
| + cov = coverage.Coverage()
|
| + cov.start()
|
| + self.import_local_file("code1")
|
| + cov.save()
|
| + self.import_local_file("code2")
|
| + cov.stop()
|
| +
|
| + _, statements, missing, _ = cov.analysis("code1.py")
|
| + self.assertEqual(statements, [1])
|
| + self.assertEqual(missing, [])
|
| + _, statements, missing, _ = cov.analysis("code2.py")
|
| + self.assertEqual(statements, [1, 2])
|
| + self.assertEqual(missing, [])
|
| +
|
| +
|
| +
|
| +class UsingModulesMixin(object):
|
| + """A mixin for importing modules from test/modules and test/moremodules."""
|
| +
|
| + run_in_temp_dir = False
|
| +
|
| + def setUp(self):
|
| + super(UsingModulesMixin, self).setUp()
|
| +
|
| + old_dir = os.getcwd()
|
| + os.chdir(self.nice_file(os.path.dirname(__file__), 'modules'))
|
| + self.addCleanup(os.chdir, old_dir)
|
| +
|
| + # Parent class saves and restores sys.path, we can just modify it.
|
| + sys.path.append(".")
|
| + sys.path.append("../moremodules")
|
| +
|
| +
|
| +class OmitIncludeTestsMixin(UsingModulesMixin):
|
| + """Test methods for coverage methods taking include and omit."""
|
| +
|
| + def filenames_in(self, summary, filenames):
|
| + """Assert the `filenames` are in the keys of `summary`."""
|
| + for filename in filenames.split():
|
| + self.assertIn(filename, summary)
|
| +
|
| + def filenames_not_in(self, summary, filenames):
|
| + """Assert the `filenames` are not in the keys of `summary`."""
|
| + for filename in filenames.split():
|
| + self.assertNotIn(filename, summary)
|
| +
|
| + def test_nothing_specified(self):
|
| + result = self.coverage_usepkgs()
|
| + self.filenames_in(result, "p1a p1b p2a p2b othera otherb osa osb")
|
| + self.filenames_not_in(result, "p1c")
|
| + # Because there was no source= specified, we don't search for
|
| + # unexecuted files.
|
| +
|
| + def test_include(self):
|
| + result = self.coverage_usepkgs(include=["*/p1a.py"])
|
| + self.filenames_in(result, "p1a")
|
| + self.filenames_not_in(result, "p1b p1c p2a p2b othera otherb osa osb")
|
| +
|
| + def test_include_2(self):
|
| + result = self.coverage_usepkgs(include=["*a.py"])
|
| + self.filenames_in(result, "p1a p2a othera osa")
|
| + self.filenames_not_in(result, "p1b p1c p2b otherb osb")
|
| +
|
| + def test_include_as_string(self):
|
| + result = self.coverage_usepkgs(include="*a.py")
|
| + self.filenames_in(result, "p1a p2a othera osa")
|
| + self.filenames_not_in(result, "p1b p1c p2b otherb osb")
|
| +
|
| + def test_omit(self):
|
| + result = self.coverage_usepkgs(omit=["*/p1a.py"])
|
| + self.filenames_in(result, "p1b p2a p2b")
|
| + self.filenames_not_in(result, "p1a p1c")
|
| +
|
| + def test_omit_2(self):
|
| + result = self.coverage_usepkgs(omit=["*a.py"])
|
| + self.filenames_in(result, "p1b p2b otherb osb")
|
| + self.filenames_not_in(result, "p1a p1c p2a othera osa")
|
| +
|
| + def test_omit_as_string(self):
|
| + result = self.coverage_usepkgs(omit="*a.py")
|
| + self.filenames_in(result, "p1b p2b otherb osb")
|
| + self.filenames_not_in(result, "p1a p1c p2a othera osa")
|
| +
|
| + def test_omit_and_include(self):
|
| + result = self.coverage_usepkgs(include=["*/p1*"], omit=["*/p1a.py"])
|
| + self.filenames_in(result, "p1b")
|
| + self.filenames_not_in(result, "p1a p1c p2a p2b")
|
| +
|
| +
|
| +class SourceOmitIncludeTest(OmitIncludeTestsMixin, CoverageTest):
|
| + """Test using `source`, `omit` and `include` when measuring code."""
|
| +
|
| + def coverage_usepkgs(self, **kwargs):
|
| + """Run coverage on usepkgs and return the line summary.
|
| +
|
| + Arguments are passed to the `coverage.Coverage` constructor.
|
| +
|
| + """
|
| + cov = coverage.Coverage(**kwargs)
|
| + cov.start()
|
| + import usepkgs # pragma: nested # pylint: disable=import-error,unused-variable
|
| + cov.stop() # pragma: nested
|
| + data = cov.get_data()
|
| + summary = data.line_counts()
|
| + for k, v in list(summary.items()):
|
| + assert k.endswith(".py")
|
| + summary[k[:-3]] = v
|
| + return summary
|
| +
|
| + def test_source_package(self):
|
| + lines = self.coverage_usepkgs(source=["pkg1"])
|
| + self.filenames_in(lines, "p1a p1b")
|
| + self.filenames_not_in(lines, "p2a p2b othera otherb osa osb")
|
| + # Because source= was specified, we do search for unexecuted files.
|
| + self.assertEqual(lines['p1c'], 0)
|
| +
|
| + def test_source_package_dotted(self):
|
| + lines = self.coverage_usepkgs(source=["pkg1.p1b"])
|
| + self.filenames_in(lines, "p1b")
|
| + self.filenames_not_in(lines, "p1a p1c p2a p2b othera otherb osa osb")
|
| +
|
| + def test_source_package_part_omitted(self):
|
| + # https://bitbucket.org/ned/coveragepy/issue/218
|
| + # Used to be if you omitted something executed and inside the source,
|
| + # then after it was executed but not recorded, it would be found in
|
| + # the search for unexecuted files, and given a score of 0%.
|
| + lines = self.coverage_usepkgs(source=["pkg1"], omit=["pkg1/p1b.py"])
|
| + self.filenames_in(lines, "p1a")
|
| + self.filenames_not_in(lines, "p1b")
|
| + self.assertEqual(lines['p1c'], 0)
|
| +
|
| +
|
| +class ReportIncludeOmitTest(OmitIncludeTestsMixin, CoverageTest):
|
| + """Tests of the report include/omit functionality."""
|
| +
|
| + def coverage_usepkgs(self, **kwargs):
|
| + """Try coverage.report()."""
|
| + cov = coverage.Coverage()
|
| + cov.start()
|
| + import usepkgs # pragma: nested # pylint: disable=import-error,unused-variable
|
| + cov.stop() # pragma: nested
|
| + report = StringIO()
|
| + cov.report(file=report, **kwargs)
|
| + return report.getvalue()
|
| +
|
| +
|
| +class XmlIncludeOmitTest(OmitIncludeTestsMixin, CoverageTest):
|
| + """Tests of the XML include/omit functionality.
|
| +
|
| + This also takes care of the HTML and annotate include/omit, by virtue
|
| + of the structure of the code.
|
| +
|
| + """
|
| +
|
| + def coverage_usepkgs(self, **kwargs):
|
| + """Try coverage.xml_report()."""
|
| + cov = coverage.Coverage()
|
| + cov.start()
|
| + import usepkgs # pragma: nested # pylint: disable=import-error,unused-variable
|
| + cov.stop() # pragma: nested
|
| + cov.xml_report(outfile="-", **kwargs)
|
| + return self.stdout()
|
| +
|
| +
|
| +class AnalysisTest(CoverageTest):
|
| + """Test the numerical analysis of results."""
|
| + def test_many_missing_branches(self):
|
| + cov = coverage.Coverage(branch=True)
|
| +
|
| + self.make_file("missing.py", """\
|
| + def fun1(x):
|
| + if x == 1:
|
| + print("one")
|
| + else:
|
| + print("not one")
|
| + print("done") # pragma: nocover
|
| +
|
| + def fun2(x):
|
| + print("x")
|
| +
|
| + fun2(3)
|
| + """)
|
| +
|
| + # Import the Python file, executing it.
|
| + self.start_import_stop(cov, "missing")
|
| +
|
| + nums = cov._analyze("missing.py").numbers
|
| + self.assertEqual(nums.n_files, 1)
|
| + self.assertEqual(nums.n_statements, 7)
|
| + self.assertEqual(nums.n_excluded, 1)
|
| + self.assertEqual(nums.n_missing, 3)
|
| + self.assertEqual(nums.n_branches, 2)
|
| + self.assertEqual(nums.n_partial_branches, 0)
|
| + self.assertEqual(nums.n_missing_branches, 2)
|
| +
|
| +
|
| +class PluginTest(CoverageTest):
|
| + """Test that the API works properly the way the plugins call it.
|
| +
|
| + We don't actually use the plugins, but these tests call the API the same
|
| + way they do.
|
| +
|
| + """
|
| + def pretend_to_be_nose_with_cover(self, erase):
|
| + """This is what the nose --with-cover plugin does."""
|
| + cov = coverage.Coverage()
|
| +
|
| + self.make_file("no_biggie.py", """\
|
| + a = 1
|
| + b = 2
|
| + if b == 1:
|
| + c = 4
|
| + """)
|
| +
|
| + if erase:
|
| + cov.combine()
|
| + cov.erase()
|
| + cov.load()
|
| + self.start_import_stop(cov, "no_biggie")
|
| + cov.combine()
|
| + cov.save()
|
| + cov.report(["no_biggie.py"])
|
| + self.assertEqual(self.stdout(), textwrap.dedent("""\
|
| + Name Stmts Miss Cover Missing
|
| + --------------------------------------------
|
| + no_biggie.py 4 1 75% 4
|
| + """))
|
| +
|
| + def test_nose_plugin(self):
|
| + self.pretend_to_be_nose_with_cover(erase=False)
|
| +
|
| + def test_nose_plugin_with_erase(self):
|
| + self.pretend_to_be_nose_with_cover(erase=True)
|
|
|
Chromium Code Reviews
