Add coverage

tools/telemetry/third_party/coverage/tests/test_config.py

Index: tools/telemetry/third_party/coverage/tests/test_config.py
diff --git a/tools/telemetry/third_party/coverage/tests/test_config.py b/tools/telemetry/third_party/coverage/tests/test_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..93a7bbf6c332e13a5e5f8d522ff0000820a6f0a8
--- /dev/null
+++ b/tools/telemetry/third_party/coverage/tests/test_config.py
@@ -0,0 +1,405 @@
+# coding: utf-8
+# 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 the config file handling for coverage.py"""
+
+import sys
+import os
+
+import coverage
+from coverage.misc import CoverageException
+
+from tests.coveragetest import CoverageTest
+
+
+class ConfigTest(CoverageTest):
+    """Tests of the different sources of configuration settings."""
+
+    def test_default_config(self):
+        # Just constructing a coverage() object gets the right defaults.
+        cov = coverage.Coverage()
+        self.assertFalse(cov.config.timid)
+        self.assertFalse(cov.config.branch)
+        self.assertEqual(cov.config.data_file, ".coverage")
+
+    def test_arguments(self):
+        # Arguments to the constructor are applied to the configuration.
+        cov = coverage.Coverage(timid=True, data_file="fooey.dat")
+        self.assertTrue(cov.config.timid)
+        self.assertFalse(cov.config.branch)
+        self.assertEqual(cov.config.data_file, "fooey.dat")
+
+    def test_config_file(self):
+        # A .coveragerc file will be read into the configuration.
+        self.make_file(".coveragerc", """\
+            # This is just a bogus .rc file for testing.
+            [run]
+            timid =         True
+            data_file =     .hello_kitty.data
+            """)
+        cov = coverage.Coverage()
+        self.assertTrue(cov.config.timid)
+        self.assertFalse(cov.config.branch)
+        self.assertEqual(cov.config.data_file, ".hello_kitty.data")
+
+    def test_named_config_file(self):
+        # You can name the config file what you like.
+        self.make_file("my_cov.ini", """\
+            [run]
+            timid = True
+            ; I wouldn't really use this as a data file...
+            data_file = delete.me
+            """)
+        cov = coverage.Coverage(config_file="my_cov.ini")
+        self.assertTrue(cov.config.timid)
+        self.assertFalse(cov.config.branch)
+        self.assertEqual(cov.config.data_file, "delete.me")
+
+    def test_ignored_config_file(self):
+        # You can disable reading the .coveragerc file.
+        self.make_file(".coveragerc", """\
+            [run]
+            timid = True
+            data_file = delete.me
+            """)
+        cov = coverage.Coverage(config_file=False)
+        self.assertFalse(cov.config.timid)
+        self.assertFalse(cov.config.branch)
+        self.assertEqual(cov.config.data_file, ".coverage")
+
+    def test_config_file_then_args(self):
+        # The arguments override the .coveragerc file.
+        self.make_file(".coveragerc", """\
+            [run]
+            timid = True
+            data_file = weirdo.file
+            """)
+        cov = coverage.Coverage(timid=False, data_file=".mycov")
+        self.assertFalse(cov.config.timid)
+        self.assertFalse(cov.config.branch)
+        self.assertEqual(cov.config.data_file, ".mycov")
+
+    def test_data_file_from_environment(self):
+        # There's an environment variable for the data_file.
+        self.make_file(".coveragerc", """\
+            [run]
+            timid = True
+            data_file = weirdo.file
+            """)
+        self.set_environ("COVERAGE_FILE", "fromenv.dat")
+        cov = coverage.Coverage()
+        self.assertEqual(cov.config.data_file, "fromenv.dat")
+        # But the constructor arguments override the environment variable.
+        cov = coverage.Coverage(data_file="fromarg.dat")
+        self.assertEqual(cov.config.data_file, "fromarg.dat")
+
+    def test_parse_errors(self):
+        # Im-parsable values raise CoverageException, with details.
+        bad_configs_and_msgs = [
+            ("[run]\ntimid = maybe?\n", r"maybe[?]"),
+            ("timid = 1\n", r"timid = 1"),
+            ("[run\n", r"\[run"),
+            ("[report]\nexclude_lines = foo(\n",
+                r"Invalid \[report\].exclude_lines value 'foo\(': "
+                r"(unbalanced parenthesis|missing \))"),
+            ("[report]\npartial_branches = foo[\n",
+                r"Invalid \[report\].partial_branches value 'foo\[': "
+                r"(unexpected end of regular expression|unterminated character set)"),
+            ("[report]\npartial_branches_always = foo***\n",
+                r"Invalid \[report\].partial_branches_always value "
+                r"'foo\*\*\*': "
+                r"multiple repeat"),
+        ]
+
+        for bad_config, msg in bad_configs_and_msgs:
+            print("Trying %r" % bad_config)
+            self.make_file(".coveragerc", bad_config)
+            with self.assertRaisesRegex(CoverageException, msg):
+                coverage.Coverage()
+
+    def test_environment_vars_in_config(self):
+        # Config files can have $envvars in them.
+        self.make_file(".coveragerc", """\
+            [run]
+            data_file = $DATA_FILE.fooey
+            branch = $OKAY
+            [report]
+            exclude_lines =
+                the_$$one
+                another${THING}
+                x${THING}y
+                x${NOTHING}y
+                huh$${X}what
+            """)
+        self.set_environ("DATA_FILE", "hello-world")
+        self.set_environ("THING", "ZZZ")
+        self.set_environ("OKAY", "yes")
+        cov = coverage.Coverage()
+        self.assertEqual(cov.config.data_file, "hello-world.fooey")
+        self.assertEqual(cov.config.branch, True)
+        self.assertEqual(
+            cov.config.exclude_list,
+            ["the_$one", "anotherZZZ", "xZZZy", "xy", "huh${X}what"]
+        )
+
+    def test_tweaks_after_constructor(self):
+        # Arguments to the constructor are applied to the configuration.
+        cov = coverage.Coverage(timid=True, data_file="fooey.dat")
+        cov.set_option("run:timid", False)
+
+        self.assertFalse(cov.config.timid)
+        self.assertFalse(cov.config.branch)
+        self.assertEqual(cov.config.data_file, "fooey.dat")
+
+        self.assertFalse(cov.get_option("run:timid"))
+        self.assertFalse(cov.get_option("run:branch"))
+        self.assertEqual(cov.get_option("run:data_file"), "fooey.dat")
+
+    def test_tweak_error_checking(self):
+        # Trying to set an unknown config value raises an error.
+        cov = coverage.Coverage()
+        with self.assertRaises(CoverageException):
+            cov.set_option("run:xyzzy", 12)
+        with self.assertRaises(CoverageException):
+            cov.set_option("xyzzy:foo", 12)
+        with self.assertRaises(CoverageException):
+            _ = cov.get_option("run:xyzzy")
+        with self.assertRaises(CoverageException):
+            _ = cov.get_option("xyzzy:foo")
+
+    def test_tweak_plugin_options(self):
+        # Plugin options have a more flexible syntax.
+        cov = coverage.Coverage()
+        cov.set_option("run:plugins", ["fooey.plugin", "xyzzy.coverage.plugin"])
+        cov.set_option("fooey.plugin:xyzzy", 17)
+        cov.set_option("xyzzy.coverage.plugin:plugh", ["a", "b"])
+        with self.assertRaises(CoverageException):
+            cov.set_option("no_such.plugin:foo", 23)
+
+        self.assertEqual(cov.get_option("fooey.plugin:xyzzy"), 17)
+        self.assertEqual(cov.get_option("xyzzy.coverage.plugin:plugh"), ["a", "b"])
+        with self.assertRaises(CoverageException):
+            _ = cov.get_option("no_such.plugin:foo")
+
+    def test_unknown_option(self):
+        self.make_file(".coveragerc", """\
+            [run]
+            xyzzy = 17
+            """)
+        msg = r"Unrecognized option '\[run\] xyzzy=' in config file .coveragerc"
+        with self.assertRaisesRegex(CoverageException, msg):
+            _ = coverage.Coverage()
+
+    def test_misplaced_option(self):
+        self.make_file(".coveragerc", """\
+            [report]
+            branch = True
+            """)
+        msg = r"Unrecognized option '\[report\] branch=' in config file .coveragerc"
+        with self.assertRaisesRegex(CoverageException, msg):
+            _ = coverage.Coverage()
+
+    def test_unknown_option_in_other_ini_file(self):
+        self.make_file("setup.cfg", """\
+            [coverage:run]
+            huh = what?
+            """)
+        msg = r"Unrecognized option '\[coverage:run\] huh=' in config file setup.cfg"
+        with self.assertRaisesRegex(CoverageException, msg):
+            _ = coverage.Coverage()
+
+
+class ConfigFileTest(CoverageTest):
+    """Tests of the config file settings in particular."""
+
+    def setUp(self):
+        super(ConfigFileTest, self).setUp()
+        # Parent class saves and restores sys.path, we can just modify it.
+        # Add modules to the path so we can import plugins.
+        sys.path.append(self.nice_file(os.path.dirname(__file__), 'modules'))
+
+    # This sample file tries to use lots of variation of syntax...
+    # The {section} placeholder lets us nest these settings in another file.
+    LOTSA_SETTINGS = """\
+        # This is a settings file for coverage.py
+        [{section}run]
+        timid = yes
+        data_file = something_or_other.dat
+        branch = 1
+        cover_pylib = TRUE
+        parallel = on
+        include = a/   ,    b/
+        concurrency = thread
+        plugins =
+            plugins.a_plugin
+            plugins.another
+
+        [{section}report]
+        ; these settings affect reporting.
+        exclude_lines =
+            if 0:
+
+            pragma:?\\s+no cover
+                another_tab
+
+        ignore_errors = TRUE
+        omit =
+            one, another, some_more,
+                yet_more
+        precision = 3
+
+        partial_branches =
+            pragma:?\\s+no branch
+        partial_branches_always =
+            if 0:
+            while True:
+
+        show_missing= TruE
+        skip_covered = TruE
+
+        [{section}html]
+
+        directory    =     c:\\tricky\\dir.somewhere
+        extra_css=something/extra.css
+        title = Title & nums # nums!
+        [{section}xml]
+        output=mycov.xml
+        package_depth          =                                17
+
+        [{section}paths]
+        source =
+            .
+            /home/ned/src/
+
+        other = other, /home/ned/other, c:\\Ned\\etc
+
+        [{section}plugins.a_plugin]
+        hello = world
+        ; comments still work.
+        names = Jane/John/Jenny
+        """
+
+    # Just some sample setup.cfg text from the docs.
+    SETUP_CFG = """\
+        [bdist_rpm]
+        release = 1
+        packager = Jane Packager <janep@pysoft.com>
+        doc_files = CHANGES.txt
+                    README.txt
+                    USAGE.txt
+                    doc/
+                    examples/
+        """
+
+    def assert_config_settings_are_correct(self, cov):
+        """Check that `cov` has all the settings from LOTSA_SETTINGS."""
+        self.assertTrue(cov.config.timid)
+        self.assertEqual(cov.config.data_file, "something_or_other.dat")
+        self.assertTrue(cov.config.branch)
+        self.assertTrue(cov.config.cover_pylib)
+        self.assertTrue(cov.config.parallel)
+        self.assertEqual(cov.config.concurrency, "thread")
+
+        self.assertEqual(cov.get_exclude_list(), ["if 0:", r"pragma:?\s+no cover", "another_tab"])
+        self.assertTrue(cov.config.ignore_errors)
+        self.assertEqual(cov.config.include, ["a/", "b/"])
+        self.assertEqual(cov.config.omit, ["one", "another", "some_more", "yet_more"])
+        self.assertEqual(cov.config.precision, 3)
+
+        self.assertEqual(cov.config.partial_list, [r"pragma:?\s+no branch"])
+        self.assertEqual(cov.config.partial_always_list, ["if 0:", "while True:"])
+        self.assertEqual(cov.config.plugins, ["plugins.a_plugin", "plugins.another"])
+        self.assertTrue(cov.config.show_missing)
+        self.assertTrue(cov.config.skip_covered)
+        self.assertEqual(cov.config.html_dir, r"c:\tricky\dir.somewhere")
+        self.assertEqual(cov.config.extra_css, "something/extra.css")
+        self.assertEqual(cov.config.html_title, "Title & nums # nums!")
+
+        self.assertEqual(cov.config.xml_output, "mycov.xml")
+        self.assertEqual(cov.config.xml_package_depth, 17)
+
+        self.assertEqual(cov.config.paths, {
+            'source': ['.', '/home/ned/src/'],
+            'other': ['other', '/home/ned/other', 'c:\\Ned\\etc']
+        })
+
+        self.assertEqual(cov.config.get_plugin_options("plugins.a_plugin"), {
+            'hello': 'world',
+            'names': 'Jane/John/Jenny',
+        })
+        self.assertEqual(cov.config.get_plugin_options("plugins.another"), {})
+
+    def test_config_file_settings(self):
+        self.make_file(".coveragerc", self.LOTSA_SETTINGS.format(section=""))
+        cov = coverage.Coverage()
+        self.assert_config_settings_are_correct(cov)
+
+    def test_config_file_settings_in_setupcfg(self):
+        # Configuration will be read from setup.cfg from sections prefixed with
+        # "coverage:"
+        nested = self.LOTSA_SETTINGS.format(section="coverage:")
+        self.make_file("setup.cfg", nested + "\n" + self.SETUP_CFG)
+        cov = coverage.Coverage()
+        self.assert_config_settings_are_correct(cov)
+
+    def test_config_file_settings_in_setupcfg_if_coveragerc_specified(self):
+        # Configuration will be read from setup.cfg from sections prefixed with
+        # "coverage:", even if the API said to read from a (non-existent)
+        # .coveragerc file.
+        nested = self.LOTSA_SETTINGS.format(section="coverage:")
+        self.make_file("setup.cfg", nested + "\n" + self.SETUP_CFG)
+        cov = coverage.Coverage(config_file=".coveragerc")
+        self.assert_config_settings_are_correct(cov)
+
+    def test_setupcfg_only_if_not_coveragerc(self):
+        self.make_file(".coveragerc", """\
+            [run]
+            include = foo
+            """)
+        self.make_file("setup.cfg", """\
+            [coverage:run]
+            omit = bar
+            branch = true
+            """)
+        cov = coverage.Coverage()
+        self.assertEqual(cov.config.include, ["foo"])
+        self.assertEqual(cov.config.omit, None)
+        self.assertEqual(cov.config.branch, False)
+
+    def test_setupcfg_only_if_prefixed(self):
+        self.make_file("setup.cfg", """\
+            [run]
+            omit = bar
+            branch = true
+            """)
+        cov = coverage.Coverage()
+        self.assertEqual(cov.config.omit, None)
+        self.assertEqual(cov.config.branch, False)
+
+    def test_non_ascii(self):
+        self.make_file(".coveragerc", """\
+            [html]
+            title = tabblo & «ταБЬℓσ» # numbers
+            """)
+        cov = coverage.Coverage()
+
+        self.assertEqual(cov.config.html_title, "tabblo & «ταБЬℓσ» # numbers")
+
+    def test_unreadable_config(self):
+        # If a config file is explicitly specified, then it is an error for it
+        # to not be readable.
+        bad_files = [
+            "nosuchfile.txt",
+            ".",
+        ]
+        for bad_file in bad_files:
+            msg = "Couldn't read %r as a config file" % bad_file
+            with self.assertRaisesRegex(CoverageException, msg):
+                coverage.Coverage(config_file=bad_file)
+
+    def test_nocoveragerc_file_when_specified(self):
+        cov = coverage.Coverage(config_file=".coveragerc")
+        self.assertFalse(cov.config.timid)
+        self.assertFalse(cov.config.branch)
+        self.assertEqual(cov.config.data_file, ".coverage")