[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_warnings.py

from contextlib import contextmanager\r
import linecache\r
import os\r
import StringIO\r
import sys\r
import unittest\r
import subprocess\r
from test import test_support\r
from test.script_helper import assert_python_ok\r
\r
import warning_tests\r
\r
import warnings as original_warnings\r
\r
py_warnings = test_support.import_fresh_module('warnings', blocked=['_warnings'])\r
c_warnings = test_support.import_fresh_module('warnings', fresh=['_warnings'])\r
\r
@contextmanager\r
def warnings_state(module):\r
    """Use a specific warnings implementation in warning_tests."""\r
    global __warningregistry__\r
    for to_clear in (sys, warning_tests):\r
        try:\r
            to_clear.__warningregistry__.clear()\r
        except AttributeError:\r
            pass\r
    try:\r
        __warningregistry__.clear()\r
    except NameError:\r
        pass\r
    original_warnings = warning_tests.warnings\r
    original_filters = module.filters\r
    try:\r
        module.filters = original_filters[:]\r
        module.simplefilter("once")\r
        warning_tests.warnings = module\r
        yield\r
    finally:\r
        warning_tests.warnings = original_warnings\r
        module.filters = original_filters\r
\r
\r
class BaseTest(unittest.TestCase):\r
\r
    """Basic bookkeeping required for testing."""\r
\r
    def setUp(self):\r
        # The __warningregistry__ needs to be in a pristine state for tests\r
        # to work properly.\r
        if '__warningregistry__' in globals():\r
            del globals()['__warningregistry__']\r
        if hasattr(warning_tests, '__warningregistry__'):\r
            del warning_tests.__warningregistry__\r
        if hasattr(sys, '__warningregistry__'):\r
            del sys.__warningregistry__\r
        # The 'warnings' module must be explicitly set so that the proper\r
        # interaction between _warnings and 'warnings' can be controlled.\r
        sys.modules['warnings'] = self.module\r
        super(BaseTest, self).setUp()\r
\r
    def tearDown(self):\r
        sys.modules['warnings'] = original_warnings\r
        super(BaseTest, self).tearDown()\r
\r
\r
class FilterTests(object):\r
\r
    """Testing the filtering functionality."""\r
\r
    def test_error(self):\r
        with original_warnings.catch_warnings(module=self.module) as w:\r
            self.module.resetwarnings()\r
            self.module.filterwarnings("error", category=UserWarning)\r
            self.assertRaises(UserWarning, self.module.warn,\r
                                "FilterTests.test_error")\r
\r
    def test_ignore(self):\r
        with original_warnings.catch_warnings(record=True,\r
                module=self.module) as w:\r
            self.module.resetwarnings()\r
            self.module.filterwarnings("ignore", category=UserWarning)\r
            self.module.warn("FilterTests.test_ignore", UserWarning)\r
            self.assertEqual(len(w), 0)\r
\r
    def test_always(self):\r
        with original_warnings.catch_warnings(record=True,\r
                module=self.module) as w:\r
            self.module.resetwarnings()\r
            self.module.filterwarnings("always", category=UserWarning)\r
            message = "FilterTests.test_always"\r
            self.module.warn(message, UserWarning)\r
            self.assertTrue(message, w[-1].message)\r
            self.module.warn(message, UserWarning)\r
            self.assertTrue(w[-1].message, message)\r
\r
    def test_default(self):\r
        with original_warnings.catch_warnings(record=True,\r
                module=self.module) as w:\r
            self.module.resetwarnings()\r
            self.module.filterwarnings("default", category=UserWarning)\r
            message = UserWarning("FilterTests.test_default")\r
            for x in xrange(2):\r
                self.module.warn(message, UserWarning)\r
                if x == 0:\r
                    self.assertEqual(w[-1].message, message)\r
                    del w[:]\r
                elif x == 1:\r
                    self.assertEqual(len(w), 0)\r
                else:\r
                    raise ValueError("loop variant unhandled")\r
\r
    def test_module(self):\r
        with original_warnings.catch_warnings(record=True,\r
                module=self.module) as w:\r
            self.module.resetwarnings()\r
            self.module.filterwarnings("module", category=UserWarning)\r
            message = UserWarning("FilterTests.test_module")\r
            self.module.warn(message, UserWarning)\r
            self.assertEqual(w[-1].message, message)\r
            del w[:]\r
            self.module.warn(message, UserWarning)\r
            self.assertEqual(len(w), 0)\r
\r
    def test_once(self):\r
        with original_warnings.catch_warnings(record=True,\r
                module=self.module) as w:\r
            self.module.resetwarnings()\r
            self.module.filterwarnings("once", category=UserWarning)\r
            message = UserWarning("FilterTests.test_once")\r
            self.module.warn_explicit(message, UserWarning, "test_warnings.py",\r
                                    42)\r
            self.assertEqual(w[-1].message, message)\r
            del w[:]\r
            self.module.warn_explicit(message, UserWarning, "test_warnings.py",\r
                                    13)\r
            self.assertEqual(len(w), 0)\r
            self.module.warn_explicit(message, UserWarning, "test_warnings2.py",\r
                                    42)\r
            self.assertEqual(len(w), 0)\r
\r
    def test_inheritance(self):\r
        with original_warnings.catch_warnings(module=self.module) as w:\r
            self.module.resetwarnings()\r
            self.module.filterwarnings("error", category=Warning)\r
            self.assertRaises(UserWarning, self.module.warn,\r
                                "FilterTests.test_inheritance", UserWarning)\r
\r
    def test_ordering(self):\r
        with original_warnings.catch_warnings(record=True,\r
                module=self.module) as w:\r
            self.module.resetwarnings()\r
            self.module.filterwarnings("ignore", category=UserWarning)\r
            self.module.filterwarnings("error", category=UserWarning,\r
                                        append=True)\r
            del w[:]\r
            try:\r
                self.module.warn("FilterTests.test_ordering", UserWarning)\r
            except UserWarning:\r
                self.fail("order handling for actions failed")\r
            self.assertEqual(len(w), 0)\r
\r
    def test_filterwarnings(self):\r
        # Test filterwarnings().\r
        # Implicitly also tests resetwarnings().\r
        with original_warnings.catch_warnings(record=True,\r
                module=self.module) as w:\r
            self.module.filterwarnings("error", "", Warning, "", 0)\r
            self.assertRaises(UserWarning, self.module.warn, 'convert to error')\r
\r
            self.module.resetwarnings()\r
            text = 'handle normally'\r
            self.module.warn(text)\r
            self.assertEqual(str(w[-1].message), text)\r
            self.assertTrue(w[-1].category is UserWarning)\r
\r
            self.module.filterwarnings("ignore", "", Warning, "", 0)\r
            text = 'filtered out'\r
            self.module.warn(text)\r
            self.assertNotEqual(str(w[-1].message), text)\r
\r
            self.module.resetwarnings()\r
            self.module.filterwarnings("error", "hex*", Warning, "", 0)\r
            self.assertRaises(UserWarning, self.module.warn, 'hex/oct')\r
            text = 'nonmatching text'\r
            self.module.warn(text)\r
            self.assertEqual(str(w[-1].message), text)\r
            self.assertTrue(w[-1].category is UserWarning)\r
\r
class CFilterTests(BaseTest, FilterTests):\r
    module = c_warnings\r
\r
class PyFilterTests(BaseTest, FilterTests):\r
    module = py_warnings\r
\r
\r
class WarnTests(unittest.TestCase):\r
\r
    """Test warnings.warn() and warnings.warn_explicit()."""\r
\r
    def test_message(self):\r
        with original_warnings.catch_warnings(record=True,\r
                module=self.module) as w:\r
            self.module.simplefilter("once")\r
            for i in range(4):\r
                text = 'multi %d' %i  # Different text on each call.\r
                self.module.warn(text)\r
                self.assertEqual(str(w[-1].message), text)\r
                self.assertTrue(w[-1].category is UserWarning)\r
\r
    def test_filename(self):\r
        with warnings_state(self.module):\r
            with original_warnings.catch_warnings(record=True,\r
                    module=self.module) as w:\r
                warning_tests.inner("spam1")\r
                self.assertEqual(os.path.basename(w[-1].filename),\r
                                    "warning_tests.py")\r
                warning_tests.outer("spam2")\r
                self.assertEqual(os.path.basename(w[-1].filename),\r
                                    "warning_tests.py")\r
\r
    def test_stacklevel(self):\r
        # Test stacklevel argument\r
        # make sure all messages are different, so the warning won't be skipped\r
        with warnings_state(self.module):\r
            with original_warnings.catch_warnings(record=True,\r
                    module=self.module) as w:\r
                warning_tests.inner("spam3", stacklevel=1)\r
                self.assertEqual(os.path.basename(w[-1].filename),\r
                                    "warning_tests.py")\r
                warning_tests.outer("spam4", stacklevel=1)\r
                self.assertEqual(os.path.basename(w[-1].filename),\r
                                    "warning_tests.py")\r
\r
                warning_tests.inner("spam5", stacklevel=2)\r
                self.assertEqual(os.path.basename(w[-1].filename),\r
                                    "test_warnings.py")\r
                warning_tests.outer("spam6", stacklevel=2)\r
                self.assertEqual(os.path.basename(w[-1].filename),\r
                                    "warning_tests.py")\r
                warning_tests.outer("spam6.5", stacklevel=3)\r
                self.assertEqual(os.path.basename(w[-1].filename),\r
                                    "test_warnings.py")\r
\r
                warning_tests.inner("spam7", stacklevel=9999)\r
                self.assertEqual(os.path.basename(w[-1].filename),\r
                                    "sys")\r
\r
    def test_missing_filename_not_main(self):\r
        # If __file__ is not specified and __main__ is not the module name,\r
        # then __file__ should be set to the module name.\r
        filename = warning_tests.__file__\r
        try:\r
            del warning_tests.__file__\r
            with warnings_state(self.module):\r
                with original_warnings.catch_warnings(record=True,\r
                        module=self.module) as w:\r
                    warning_tests.inner("spam8", stacklevel=1)\r
                    self.assertEqual(w[-1].filename, warning_tests.__name__)\r
        finally:\r
            warning_tests.__file__ = filename\r
\r
    def test_missing_filename_main_with_argv(self):\r
        # If __file__ is not specified and the caller is __main__ and sys.argv\r
        # exists, then use sys.argv[0] as the file.\r
        if not hasattr(sys, 'argv'):\r
            return\r
        filename = warning_tests.__file__\r
        module_name = warning_tests.__name__\r
        try:\r
            del warning_tests.__file__\r
            warning_tests.__name__ = '__main__'\r
            with warnings_state(self.module):\r
                with original_warnings.catch_warnings(record=True,\r
                        module=self.module) as w:\r
                    warning_tests.inner('spam9', stacklevel=1)\r
                    self.assertEqual(w[-1].filename, sys.argv[0])\r
        finally:\r
            warning_tests.__file__ = filename\r
            warning_tests.__name__ = module_name\r
\r
    def test_missing_filename_main_without_argv(self):\r
        # If __file__ is not specified, the caller is __main__, and sys.argv\r
        # is not set, then '__main__' is the file name.\r
        filename = warning_tests.__file__\r
        module_name = warning_tests.__name__\r
        argv = sys.argv\r
        try:\r
            del warning_tests.__file__\r
            warning_tests.__name__ = '__main__'\r
            del sys.argv\r
            with warnings_state(self.module):\r
                with original_warnings.catch_warnings(record=True,\r
                        module=self.module) as w:\r
                    warning_tests.inner('spam10', stacklevel=1)\r
                    self.assertEqual(w[-1].filename, '__main__')\r
        finally:\r
            warning_tests.__file__ = filename\r
            warning_tests.__name__ = module_name\r
            sys.argv = argv\r
\r
    def test_missing_filename_main_with_argv_empty_string(self):\r
        # If __file__ is not specified, the caller is __main__, and sys.argv[0]\r
        # is the empty string, then '__main__ is the file name.\r
        # Tests issue 2743.\r
        file_name = warning_tests.__file__\r
        module_name = warning_tests.__name__\r
        argv = sys.argv\r
        try:\r
            del warning_tests.__file__\r
            warning_tests.__name__ = '__main__'\r
            sys.argv = ['']\r
            with warnings_state(self.module):\r
                with original_warnings.catch_warnings(record=True,\r
                        module=self.module) as w:\r
                    warning_tests.inner('spam11', stacklevel=1)\r
                    self.assertEqual(w[-1].filename, '__main__')\r
        finally:\r
            warning_tests.__file__ = file_name\r
            warning_tests.__name__ = module_name\r
            sys.argv = argv\r
\r
    def test_warn_explicit_type_errors(self):\r
        # warn_explicit() should error out gracefully if it is given objects\r
        # of the wrong types.\r
        # lineno is expected to be an integer.\r
        self.assertRaises(TypeError, self.module.warn_explicit,\r
                            None, UserWarning, None, None)\r
        # Either 'message' needs to be an instance of Warning or 'category'\r
        # needs to be a subclass.\r
        self.assertRaises(TypeError, self.module.warn_explicit,\r
                            None, None, None, 1)\r
        # 'registry' must be a dict or None.\r
        self.assertRaises((TypeError, AttributeError),\r
                            self.module.warn_explicit,\r
                            None, Warning, None, 1, registry=42)\r
\r
    def test_bad_str(self):\r
        # issue 6415\r
        # Warnings instance with a bad format string for __str__ should not\r
        # trigger a bus error.\r
        class BadStrWarning(Warning):\r
            """Warning with a bad format string for __str__."""\r
            def __str__(self):\r
                return ("A bad formatted string %(err)" %\r
                        {"err" : "there is no %(err)s"})\r
\r
        with self.assertRaises(ValueError):\r
            self.module.warn(BadStrWarning())\r
\r
\r
class CWarnTests(BaseTest, WarnTests):\r
    module = c_warnings\r
\r
    # As an early adopter, we sanity check the\r
    # test_support.import_fresh_module utility function\r
    def test_accelerated(self):\r
        self.assertFalse(original_warnings is self.module)\r
        self.assertFalse(hasattr(self.module.warn, 'func_code'))\r
\r
class PyWarnTests(BaseTest, WarnTests):\r
    module = py_warnings\r
\r
    # As an early adopter, we sanity check the\r
    # test_support.import_fresh_module utility function\r
    def test_pure_python(self):\r
        self.assertFalse(original_warnings is self.module)\r
        self.assertTrue(hasattr(self.module.warn, 'func_code'))\r
\r
\r
class WCmdLineTests(unittest.TestCase):\r
\r
    def test_improper_input(self):\r
        # Uses the private _setoption() function to test the parsing\r
        # of command-line warning arguments\r
        with original_warnings.catch_warnings(module=self.module):\r
            self.assertRaises(self.module._OptionError,\r
                              self.module._setoption, '1:2:3:4:5:6')\r
            self.assertRaises(self.module._OptionError,\r
                              self.module._setoption, 'bogus::Warning')\r
            self.assertRaises(self.module._OptionError,\r
                              self.module._setoption, 'ignore:2::4:-5')\r
            self.module._setoption('error::Warning::0')\r
            self.assertRaises(UserWarning, self.module.warn, 'convert to error')\r
\r
    def test_improper_option(self):\r
        # Same as above, but check that the message is printed out when\r
        # the interpreter is executed. This also checks that options are\r
        # actually parsed at all.\r
        rc, out, err = assert_python_ok("-Wxxx", "-c", "pass")\r
        self.assertIn(b"Invalid -W option ignored: invalid action: 'xxx'", err)\r
\r
    def test_warnings_bootstrap(self):\r
        # Check that the warnings module does get loaded when -W<some option>\r
        # is used (see issue #10372 for an example of silent bootstrap failure).\r
        rc, out, err = assert_python_ok("-Wi", "-c",\r
            "import sys; sys.modules['warnings'].warn('foo', RuntimeWarning)")\r
        # '-Wi' was observed\r
        self.assertFalse(out.strip())\r
        self.assertNotIn(b'RuntimeWarning', err)\r
\r
class CWCmdLineTests(BaseTest, WCmdLineTests):\r
    module = c_warnings\r
\r
class PyWCmdLineTests(BaseTest, WCmdLineTests):\r
    module = py_warnings\r
\r
\r
class _WarningsTests(BaseTest):\r
\r
    """Tests specific to the _warnings module."""\r
\r
    module = c_warnings\r
\r
    def test_filter(self):\r
        # Everything should function even if 'filters' is not in warnings.\r
        with original_warnings.catch_warnings(module=self.module) as w:\r
            self.module.filterwarnings("error", "", Warning, "", 0)\r
            self.assertRaises(UserWarning, self.module.warn,\r
                                'convert to error')\r
            del self.module.filters\r
            self.assertRaises(UserWarning, self.module.warn,\r
                                'convert to error')\r
\r
    def test_onceregistry(self):\r
        # Replacing or removing the onceregistry should be okay.\r
        global __warningregistry__\r
        message = UserWarning('onceregistry test')\r
        try:\r
            original_registry = self.module.onceregistry\r
            __warningregistry__ = {}\r
            with original_warnings.catch_warnings(record=True,\r
                    module=self.module) as w:\r
                self.module.resetwarnings()\r
                self.module.filterwarnings("once", category=UserWarning)\r
                self.module.warn_explicit(message, UserWarning, "file", 42)\r
                self.assertEqual(w[-1].message, message)\r
                del w[:]\r
                self.module.warn_explicit(message, UserWarning, "file", 42)\r
                self.assertEqual(len(w), 0)\r
                # Test the resetting of onceregistry.\r
                self.module.onceregistry = {}\r
                __warningregistry__ = {}\r
                self.module.warn('onceregistry test')\r
                self.assertEqual(w[-1].message.args, message.args)\r
                # Removal of onceregistry is okay.\r
                del w[:]\r
                del self.module.onceregistry\r
                __warningregistry__ = {}\r
                self.module.warn_explicit(message, UserWarning, "file", 42)\r
                self.assertEqual(len(w), 0)\r
        finally:\r
            self.module.onceregistry = original_registry\r
\r
    def test_default_action(self):\r
        # Replacing or removing defaultaction should be okay.\r
        message = UserWarning("defaultaction test")\r
        original = self.module.defaultaction\r
        try:\r
            with original_warnings.catch_warnings(record=True,\r
                    module=self.module) as w:\r
                self.module.resetwarnings()\r
                registry = {}\r
                self.module.warn_explicit(message, UserWarning, "<test>", 42,\r
                                            registry=registry)\r
                self.assertEqual(w[-1].message, message)\r
                self.assertEqual(len(w), 1)\r
                self.assertEqual(len(registry), 1)\r
                del w[:]\r
                # Test removal.\r
                del self.module.defaultaction\r
                __warningregistry__ = {}\r
                registry = {}\r
                self.module.warn_explicit(message, UserWarning, "<test>", 43,\r
                                            registry=registry)\r
                self.assertEqual(w[-1].message, message)\r
                self.assertEqual(len(w), 1)\r
                self.assertEqual(len(registry), 1)\r
                del w[:]\r
                # Test setting.\r
                self.module.defaultaction = "ignore"\r
                __warningregistry__ = {}\r
                registry = {}\r
                self.module.warn_explicit(message, UserWarning, "<test>", 44,\r
                                            registry=registry)\r
                self.assertEqual(len(w), 0)\r
        finally:\r
            self.module.defaultaction = original\r
\r
    def test_showwarning_missing(self):\r
        # Test that showwarning() missing is okay.\r
        text = 'del showwarning test'\r
        with original_warnings.catch_warnings(module=self.module):\r
            self.module.filterwarnings("always", category=UserWarning)\r
            del self.module.showwarning\r
            with test_support.captured_output('stderr') as stream:\r
                self.module.warn(text)\r
                result = stream.getvalue()\r
        self.assertIn(text, result)\r
\r
    def test_showwarning_not_callable(self):\r
        with original_warnings.catch_warnings(module=self.module):\r
            self.module.filterwarnings("always", category=UserWarning)\r
            old_showwarning = self.module.showwarning\r
            self.module.showwarning = 23\r
            try:\r
                self.assertRaises(TypeError, self.module.warn, "Warning!")\r
            finally:\r
                self.module.showwarning = old_showwarning\r
\r
    def test_show_warning_output(self):\r
        # With showarning() missing, make sure that output is okay.\r
        text = 'test show_warning'\r
        with original_warnings.catch_warnings(module=self.module):\r
            self.module.filterwarnings("always", category=UserWarning)\r
            del self.module.showwarning\r
            with test_support.captured_output('stderr') as stream:\r
                warning_tests.inner(text)\r
                result = stream.getvalue()\r
        self.assertEqual(result.count('\n'), 2,\r
                             "Too many newlines in %r" % result)\r
        first_line, second_line = result.split('\n', 1)\r
        expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py'\r
        first_line_parts = first_line.rsplit(':', 3)\r
        path, line, warning_class, message = first_line_parts\r
        line = int(line)\r
        self.assertEqual(expected_file, path)\r
        self.assertEqual(warning_class, ' ' + UserWarning.__name__)\r
        self.assertEqual(message, ' ' + text)\r
        expected_line = '  ' + linecache.getline(path, line).strip() + '\n'\r
        assert expected_line\r
        self.assertEqual(second_line, expected_line)\r
\r
\r
class WarningsDisplayTests(unittest.TestCase):\r
\r
    """Test the displaying of warnings and the ability to overload functions\r
    related to displaying warnings."""\r
\r
    def test_formatwarning(self):\r
        message = "msg"\r
        category = Warning\r
        file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'\r
        line_num = 3\r
        file_line = linecache.getline(file_name, line_num).strip()\r
        format = "%s:%s: %s: %s\n  %s\n"\r
        expect = format % (file_name, line_num, category.__name__, message,\r
                            file_line)\r
        self.assertEqual(expect, self.module.formatwarning(message,\r
                                                category, file_name, line_num))\r
        # Test the 'line' argument.\r
        file_line += " for the win!"\r
        expect = format % (file_name, line_num, category.__name__, message,\r
                            file_line)\r
        self.assertEqual(expect, self.module.formatwarning(message,\r
                                    category, file_name, line_num, file_line))\r
\r
    def test_showwarning(self):\r
        file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'\r
        line_num = 3\r
        expected_file_line = linecache.getline(file_name, line_num).strip()\r
        message = 'msg'\r
        category = Warning\r
        file_object = StringIO.StringIO()\r
        expect = self.module.formatwarning(message, category, file_name,\r
                                            line_num)\r
        self.module.showwarning(message, category, file_name, line_num,\r
                                file_object)\r
        self.assertEqual(file_object.getvalue(), expect)\r
        # Test 'line' argument.\r
        expected_file_line += "for the win!"\r
        expect = self.module.formatwarning(message, category, file_name,\r
                                            line_num, expected_file_line)\r
        file_object = StringIO.StringIO()\r
        self.module.showwarning(message, category, file_name, line_num,\r
                                file_object, expected_file_line)\r
        self.assertEqual(expect, file_object.getvalue())\r
\r
class CWarningsDisplayTests(BaseTest, WarningsDisplayTests):\r
    module = c_warnings\r
\r
class PyWarningsDisplayTests(BaseTest, WarningsDisplayTests):\r
    module = py_warnings\r
\r
\r
class CatchWarningTests(BaseTest):\r
\r
    """Test catch_warnings()."""\r
\r
    def test_catch_warnings_restore(self):\r
        wmod = self.module\r
        orig_filters = wmod.filters\r
        orig_showwarning = wmod.showwarning\r
        # Ensure both showwarning and filters are restored when recording\r
        with wmod.catch_warnings(module=wmod, record=True):\r
            wmod.filters = wmod.showwarning = object()\r
        self.assertTrue(wmod.filters is orig_filters)\r
        self.assertTrue(wmod.showwarning is orig_showwarning)\r
        # Same test, but with recording disabled\r
        with wmod.catch_warnings(module=wmod, record=False):\r
            wmod.filters = wmod.showwarning = object()\r
        self.assertTrue(wmod.filters is orig_filters)\r
        self.assertTrue(wmod.showwarning is orig_showwarning)\r
\r
    def test_catch_warnings_recording(self):\r
        wmod = self.module\r
        # Ensure warnings are recorded when requested\r
        with wmod.catch_warnings(module=wmod, record=True) as w:\r
            self.assertEqual(w, [])\r
            self.assertTrue(type(w) is list)\r
            wmod.simplefilter("always")\r
            wmod.warn("foo")\r
            self.assertEqual(str(w[-1].message), "foo")\r
            wmod.warn("bar")\r
            self.assertEqual(str(w[-1].message), "bar")\r
            self.assertEqual(str(w[0].message), "foo")\r
            self.assertEqual(str(w[1].message), "bar")\r
            del w[:]\r
            self.assertEqual(w, [])\r
        # Ensure warnings are not recorded when not requested\r
        orig_showwarning = wmod.showwarning\r
        with wmod.catch_warnings(module=wmod, record=False) as w:\r
            self.assertTrue(w is None)\r
            self.assertTrue(wmod.showwarning is orig_showwarning)\r
\r
    def test_catch_warnings_reentry_guard(self):\r
        wmod = self.module\r
        # Ensure catch_warnings is protected against incorrect usage\r
        x = wmod.catch_warnings(module=wmod, record=True)\r
        self.assertRaises(RuntimeError, x.__exit__)\r
        with x:\r
            self.assertRaises(RuntimeError, x.__enter__)\r
        # Same test, but with recording disabled\r
        x = wmod.catch_warnings(module=wmod, record=False)\r
        self.assertRaises(RuntimeError, x.__exit__)\r
        with x:\r
            self.assertRaises(RuntimeError, x.__enter__)\r
\r
    def test_catch_warnings_defaults(self):\r
        wmod = self.module\r
        orig_filters = wmod.filters\r
        orig_showwarning = wmod.showwarning\r
        # Ensure default behaviour is not to record warnings\r
        with wmod.catch_warnings(module=wmod) as w:\r
            self.assertTrue(w is None)\r
            self.assertTrue(wmod.showwarning is orig_showwarning)\r
            self.assertTrue(wmod.filters is not orig_filters)\r
        self.assertTrue(wmod.filters is orig_filters)\r
        if wmod is sys.modules['warnings']:\r
            # Ensure the default module is this one\r
            with wmod.catch_warnings() as w:\r
                self.assertTrue(w is None)\r
                self.assertTrue(wmod.showwarning is orig_showwarning)\r
                self.assertTrue(wmod.filters is not orig_filters)\r
            self.assertTrue(wmod.filters is orig_filters)\r
\r
    def test_check_warnings(self):\r
        # Explicit tests for the test_support convenience wrapper\r
        wmod = self.module\r
        if wmod is not sys.modules['warnings']:\r
            return\r
        with test_support.check_warnings(quiet=False) as w:\r
            self.assertEqual(w.warnings, [])\r
            wmod.simplefilter("always")\r
            wmod.warn("foo")\r
            self.assertEqual(str(w.message), "foo")\r
            wmod.warn("bar")\r
            self.assertEqual(str(w.message), "bar")\r
            self.assertEqual(str(w.warnings[0].message), "foo")\r
            self.assertEqual(str(w.warnings[1].message), "bar")\r
            w.reset()\r
            self.assertEqual(w.warnings, [])\r
\r
        with test_support.check_warnings():\r
            # defaults to quiet=True without argument\r
            pass\r
        with test_support.check_warnings(('foo', UserWarning)):\r
            wmod.warn("foo")\r
\r
        with self.assertRaises(AssertionError):\r
            with test_support.check_warnings(('', RuntimeWarning)):\r
                # defaults to quiet=False with argument\r
                pass\r
        with self.assertRaises(AssertionError):\r
            with test_support.check_warnings(('foo', RuntimeWarning)):\r
                wmod.warn("foo")\r
\r
\r
class CCatchWarningTests(CatchWarningTests):\r
    module = c_warnings\r
\r
class PyCatchWarningTests(CatchWarningTests):\r
    module = py_warnings\r
\r
\r
class EnvironmentVariableTests(BaseTest):\r
\r
    def test_single_warning(self):\r
        newenv = os.environ.copy()\r
        newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning"\r
        p = subprocess.Popen([sys.executable,\r
                "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],\r
                stdout=subprocess.PIPE, env=newenv)\r
        self.assertEqual(p.communicate()[0], "['ignore::DeprecationWarning']")\r
        self.assertEqual(p.wait(), 0)\r
\r
    def test_comma_separated_warnings(self):\r
        newenv = os.environ.copy()\r
        newenv["PYTHONWARNINGS"] = ("ignore::DeprecationWarning,"\r
                                    "ignore::UnicodeWarning")\r
        p = subprocess.Popen([sys.executable,\r
                "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],\r
                stdout=subprocess.PIPE, env=newenv)\r
        self.assertEqual(p.communicate()[0],\r
                "['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")\r
        self.assertEqual(p.wait(), 0)\r
\r
    def test_envvar_and_command_line(self):\r
        newenv = os.environ.copy()\r
        newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning"\r
        p = subprocess.Popen([sys.executable, "-W" "ignore::UnicodeWarning",\r
                "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],\r
                stdout=subprocess.PIPE, env=newenv)\r
        self.assertEqual(p.communicate()[0],\r
                "['ignore::UnicodeWarning', 'ignore::DeprecationWarning']")\r
        self.assertEqual(p.wait(), 0)\r
\r
class CEnvironmentVariableTests(EnvironmentVariableTests):\r
    module = c_warnings\r
\r
class PyEnvironmentVariableTests(EnvironmentVariableTests):\r
    module = py_warnings\r
\r
\r
def test_main():\r
    py_warnings.onceregistry.clear()\r
    c_warnings.onceregistry.clear()\r
    test_support.run_unittest(CFilterTests, PyFilterTests,\r
                                CWarnTests, PyWarnTests,\r
                                CWCmdLineTests, PyWCmdLineTests,\r
                                _WarningsTests,\r
                                CWarningsDisplayTests, PyWarningsDisplayTests,\r
                                CCatchWarningTests, PyCatchWarningTests,\r
                                CEnvironmentVariableTests,\r
                                PyEnvironmentVariableTests\r
                             )\r
\r
\r
if __name__ == "__main__":\r
    test_main()\r