Re-implement the 'warnings' module in C. This allows for usage of the

'warnings' code in places where it was previously not possible (e.g., the
parser). It could also potentially lead to a speed-up in interpreter start-up
if the C version of the code (_warnings) is imported over the use of the
Python version in key places.

Closes issue #1631171.

1 files changed, 323 insertions, 75 deletions

diff --git a/Lib/test/test_warnings.py b/Lib/test/test_warnings.py
index 417a743674..4c92593ccf 100644
--- a/Lib/test/test_warnings.py
+++ b/Lib/test/test_warnings.py
@@ -1,4 +1,4 @@
-import warnings
+from contextlib import contextmanager
 import linecache
 import os
 import StringIO
@@ -8,112 +8,338 @@ from test import test_support
 
 import warning_tests
 
-class TestModule(unittest.TestCase):
+sys.modules['_warnings'] = 0
+if 'warnings' in sys.modules:
+    del sys.modules['warnings']
+
+import warnings as py_warnings
+
+del sys.modules['_warnings']
+del sys.modules['warnings']
+
+import warnings as c_warnings
+
+@contextmanager
+def warnings_state(module):
+    """Use a specific warnings implementation in warning_tests."""
+    global __warningregistry__
+    for to_clear in (sys, warning_tests):
+        try:
+            to_clear.__warningregistry__.clear()
+        except AttributeError:
+            pass
+    try:
+        __warningregistry__.clear()
+    except NameError:
+        pass
+    original_warnings = warning_tests.warnings
+    try:
+        warning_tests.warnings = module
+        yield
+    finally:
+        warning_tests.warnings = original_warnings
+
+
+class FilterTests(unittest.TestCase):
+
+    """Testing the filtering functionality."""
+
     def setUp(self):
-        self.ignored = [w[2].__name__ for w in warnings.filters
-            if w[0]=='ignore' and w[1] is None and w[3] is None]
+        global __warningregistry__
+        try:
+            __warningregistry__.clear()
+        except NameError:
+            pass
 
-    def test_warn_default_category(self):
-        with test_support.catch_warning() as w:
-            for i in range(4):
-                text = 'multi %d' %i    # Different text on each call
-                warnings.warn(text)
-                self.assertEqual(str(w.message), text)
-                self.assert_(w.category is UserWarning)
+    def test_error(self):
+        with test_support.catch_warning(self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("error", category=UserWarning)
+            self.assertRaises(UserWarning, self.module.warn,
+                                "FilterTests.test_error")
+
+    def test_ignore(self):
+        with test_support.catch_warning(self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("ignore", category=UserWarning)
+            self.module.warn("FilterTests.test_ignore", UserWarning)
+            self.assert_(not w.message)
+
+    def test_always(self):
+        with test_support.catch_warning(self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("always", category=UserWarning)
+            message = "FilterTests.test_always"
+            self.module.warn(message, UserWarning)
+            self.assert_(message, w.message)
+            w.message = None  # Reset.
+            self.module.warn(message, UserWarning)
+            self.assert_(w.message, message)
 
-    def test_warn_specific_category(self):
-        with test_support.catch_warning() as w:
-            text = 'None'
-            for category in [DeprecationWarning, FutureWarning,
-                        PendingDeprecationWarning, RuntimeWarning,
-                        SyntaxWarning, UserWarning, Warning]:
-                if category.__name__ in self.ignored:
-                    text = 'filtered out' + category.__name__
-                    warnings.warn(text, category)
-                    self.assertNotEqual(w.message, text)
+    def test_default(self):
+        with test_support.catch_warning(self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("default", category=UserWarning)
+            message = UserWarning("FilterTests.test_default")
+            for x in xrange(2):
+                self.module.warn(message, UserWarning)
+                if x == 0:
+                    self.assertEquals(w.message, message)
+                    w.reset()
+                elif x == 1:
+                    self.assert_(not w.message, "unexpected warning: " + str(w))
                 else:
-                    text = 'unfiltered %s' % category.__name__
-                    warnings.warn(text, category)
-                    self.assertEqual(str(w.message), text)
-                    self.assert_(w.category is category)
+                    raise ValueError("loop variant unhandled")
 
-    def test_filtering(self):
+    def test_module(self):
+        with test_support.catch_warning(self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("module", category=UserWarning)
+            message = UserWarning("FilterTests.test_module")
+            self.module.warn(message, UserWarning)
+            self.assertEquals(w.message, message)
+            w.reset()
+            self.module.warn(message, UserWarning)
+            self.assert_(not w.message, "unexpected message: " + str(w))
+
+    def test_once(self):
+        with test_support.catch_warning(self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("once", category=UserWarning)
+            message = UserWarning("FilterTests.test_once")
+            self.module.warn_explicit(message, UserWarning, "test_warnings.py",
+                                    42)
+            self.assertEquals(w.message, message)
+            w.reset()
+            self.module.warn_explicit(message, UserWarning, "test_warnings.py",
+                                    13)
+            self.assert_(not w.message)
+            self.module.warn_explicit(message, UserWarning, "test_warnings2.py",
+                                    42)
+            self.assert_(not w.message)
+
+    def test_inheritance(self):
+        with test_support.catch_warning(self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("error", category=Warning)
+            self.assertRaises(UserWarning, self.module.warn,
+                                "FilterTests.test_inheritance", UserWarning)
+
+    def test_ordering(self):
+        with test_support.catch_warning(self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("ignore", category=UserWarning)
+            self.module.filterwarnings("error", category=UserWarning,
+                                        append=True)
+            w.reset()
+            try:
+                self.module.warn("FilterTests.test_ordering", UserWarning)
+            except UserWarning:
+                self.fail("order handling for actions failed")
+            self.assert_(not w.message)
+
+    def test_filterwarnings(self):
         # Test filterwarnings().
         # Implicitly also tests resetwarnings().
-        with test_support.catch_warning() as w:
-            warnings.filterwarnings("error", "", Warning, "", 0)
-            self.assertRaises(UserWarning, warnings.warn, 'convert to error')
+        with test_support.catch_warning(self.module) as w:
+            self.module.filterwarnings("error", "", Warning, "", 0)
+            self.assertRaises(UserWarning, self.module.warn, 'convert to error')
 
-            warnings.resetwarnings()
+            self.module.resetwarnings()
             text = 'handle normally'
-            warnings.warn(text)
+            self.module.warn(text)
             self.assertEqual(str(w.message), text)
             self.assert_(w.category is UserWarning)
 
-            warnings.filterwarnings("ignore", "", Warning, "", 0)
+            self.module.filterwarnings("ignore", "", Warning, "", 0)
             text = 'filtered out'
-            warnings.warn(text)
+            self.module.warn(text)
             self.assertNotEqual(str(w.message), text)
 
-            warnings.resetwarnings()
-            warnings.filterwarnings("error", "hex*", Warning, "", 0)
-            self.assertRaises(UserWarning, warnings.warn, 'hex/oct')
+            self.module.resetwarnings()
+            self.module.filterwarnings("error", "hex*", Warning, "", 0)
+            self.assertRaises(UserWarning, self.module.warn, 'hex/oct')
             text = 'nonmatching text'
-            warnings.warn(text)
+            self.module.warn(text)
             self.assertEqual(str(w.message), text)
             self.assert_(w.category is UserWarning)
 
-    def test_options(self):
-        # Uses the private _setoption() function to test the parsing
-        # of command-line warning arguments
-        with test_support.catch_warning():
-            self.assertRaises(warnings._OptionError,
-                              warnings._setoption, '1:2:3:4:5:6')
-            self.assertRaises(warnings._OptionError,
-                              warnings._setoption, 'bogus::Warning')
-            self.assertRaises(warnings._OptionError,
-                              warnings._setoption, 'ignore:2::4:-5')
-            warnings._setoption('error::Warning::0')
-            self.assertRaises(UserWarning, warnings.warn, 'convert to error')
+class CFilterTests(FilterTests):
+    module = c_warnings
+
+class PyFilterTests(FilterTests):
+    module = py_warnings
+
+
+class WarnTests(unittest.TestCase):
+
+    """Test warnings.warn() and warnings.warn_explicit()."""
+
+    def test_message(self):
+        with test_support.catch_warning(self.module) as w:
+            for i in range(4):
+                text = 'multi %d' %i  # Different text on each call.
+                self.module.warn(text)
+                self.assertEqual(str(w.message), text)
+                self.assert_(w.category is UserWarning)
 
     def test_filename(self):
-        with test_support.catch_warning() as w:
-            warning_tests.inner("spam1")
-            self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
-            warning_tests.outer("spam2")
-            self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
+        with warnings_state(self.module):
+            with test_support.catch_warning(self.module) as w:
+                warning_tests.inner("spam1")
+                self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
+                warning_tests.outer("spam2")
+                self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
 
     def test_stacklevel(self):
         # Test stacklevel argument
         # make sure all messages are different, so the warning won't be skipped
-        with test_support.catch_warning() as w:
-            warning_tests.inner("spam3", stacklevel=1)
-            self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
-            warning_tests.outer("spam4", stacklevel=1)
-            self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
+        with warnings_state(self.module):
+            with test_support.catch_warning(self.module) as w:
+                warning_tests.inner("spam3", stacklevel=1)
+                self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
+                warning_tests.outer("spam4", stacklevel=1)
+                self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
+
+                warning_tests.inner("spam5", stacklevel=2)
+                self.assertEqual(os.path.basename(w.filename), "test_warnings.py")
+                warning_tests.outer("spam6", stacklevel=2)
+                self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
+
+                warning_tests.inner("spam7", stacklevel=9999)
+                self.assertEqual(os.path.basename(w.filename), "sys")
+
+
+class CWarnTests(WarnTests):
+    module = c_warnings
+
+class PyWarnTests(WarnTests):
+    module = py_warnings
+
+
+class WCmdLineTests(unittest.TestCase):
+
+    def test_improper_input(self):
+        # Uses the private _setoption() function to test the parsing
+        # of command-line warning arguments
+        with test_support.catch_warning(self.module):
+            self.assertRaises(self.module._OptionError,
+                              self.module._setoption, '1:2:3:4:5:6')
+            self.assertRaises(self.module._OptionError,
+                              self.module._setoption, 'bogus::Warning')
+            self.assertRaises(self.module._OptionError,
+                              self.module._setoption, 'ignore:2::4:-5')
+            self.module._setoption('error::Warning::0')
+            self.assertRaises(UserWarning, self.module.warn, 'convert to error')
+
+class CWCmdLineTests(WCmdLineTests):
+    module = c_warnings
+
+class PyWCmdLineTests(WCmdLineTests):
+    module = py_warnings
 
-            warning_tests.inner("spam5", stacklevel=2)
-            self.assertEqual(os.path.basename(w.filename), "test_warnings.py")
-            warning_tests.outer("spam6", stacklevel=2)
-            self.assertEqual(os.path.basename(w.filename), "warning_tests.py")
 
-            warning_tests.inner("spam7", stacklevel=9999)
-            self.assertEqual(os.path.basename(w.filename), "sys")
+class _WarningsTests(unittest.TestCase):
+
+    """Tests specific to the _warnings module."""
+
+    module = c_warnings
+
+    def test_filter(self):
+        # Everything should function even if 'filters' is not in warnings.
+        with test_support.catch_warning(self.module) as w:
+            self.module.filterwarnings("error", "", Warning, "", 0)
+            self.assertRaises(UserWarning, self.module.warn,
+                                'convert to error')
+            del self.module.filters
+            self.assertRaises(UserWarning, self.module.warn,
+                                'convert to error')
+
+    def test_onceregistry(self):
+        # Replacing or removing the onceregistry should be okay.
+        global __warningregistry__
+        message = UserWarning('onceregistry test')
+        try:
+            original_registry = self.module.onceregistry
+            __warningregistry__ = {}
+            with test_support.catch_warning(self.module) as w:
+                self.module.resetwarnings()
+                self.module.filterwarnings("once", category=UserWarning)
+                self.module.warn_explicit(message, UserWarning, "file", 42)
+                self.failUnlessEqual(w.message, message)
+                w.reset()
+                self.module.warn_explicit(message, UserWarning, "file", 42)
+                self.assert_(not w.message)
+                # Test the resetting of onceregistry.
+                self.module.onceregistry = {}
+                __warningregistry__ = {}
+                self.module.warn('onceregistry test')
+                self.failUnlessEqual(w.message.args, message.args)
+                # Removal of onceregistry is okay.
+                w.reset()
+                del self.module.onceregistry
+                __warningregistry__ = {}
+                self.module.warn_explicit(message, UserWarning, "file", 42)
+                self.failUnless(not w.message)
+        finally:
+            self.module.onceregistry = original_registry
+
+    def test_showwarning_missing(self):
+        # Test that showwarning() missing is okay.
+        text = 'del showwarning test'
+        with test_support.catch_warning(self.module):
+            self.module.filterwarnings("always", category=UserWarning)
+            del self.module.showwarning
+            with test_support.captured_output('stderr') as stream:
+                self.module.warn(text)
+                result = stream.getvalue()
+        self.failUnless(text in result)
+
+    def test_show_warning_output(self):
+        # With showarning() missing, make sure that output is okay.
+        text = 'test show_warning'
+        with test_support.catch_warning(self.module):
+            self.module.filterwarnings("always", category=UserWarning)
+            del self.module.showwarning
+            with test_support.captured_output('stderr') as stream:
+                warning_tests.inner(text)
+                result = stream.getvalue()
+        self.failUnlessEqual(result.count('\n'), 2,
+                             "Too many newlines in %r" % result)
+        first_line, second_line = result.split('\n', 1)
+        expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py'
+        path, line, warning_class, message = first_line.split(':')
+        line = int(line)
+        self.failUnlessEqual(expected_file, path)
+        self.failUnlessEqual(warning_class, ' ' + UserWarning.__name__)
+        self.failUnlessEqual(message, ' ' + text)
+        expected_line = '  ' + linecache.getline(path, line).strip() + '\n'
+        assert expected_line
+        self.failUnlessEqual(second_line, expected_line)
 
 
 class WarningsDisplayTests(unittest.TestCase):
 
+    """Test the displaying of warnings and the ability to overload functions
+    related to displaying warnings."""
+
     def test_formatwarning(self):
         message = "msg"
         category = Warning
         file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
         line_num = 3
         file_line = linecache.getline(file_name, line_num).strip()
-        expect = "%s:%s: %s: %s\n  %s\n" % (file_name, line_num, category.__name__,
-                                         message, file_line)
-        self.failUnlessEqual(warnings.formatwarning(message, category,
-                                                    file_name, line_num),
-                             expect)
+        format = "%s:%s: %s: %s\n  %s\n"
+        expect = format % (file_name, line_num, category.__name__, message,
+                            file_line)
+        self.failUnlessEqual(expect, self.module.formatwarning(message,
+                                                category, file_name, line_num))
+        # Test the 'line' argument.
+        file_line += " for the win!"
+        expect = format % (file_name, line_num, category.__name__, message,
+                            file_line)
+        self.failUnlessEqual(expect, self.module.formatwarning(message,
+                                    category, file_name, line_num, file_line))
 
     def test_showwarning(self):
         file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
@@ -122,13 +348,28 @@ class WarningsDisplayTests(unittest.TestCase):
         message = 'msg'
         category = Warning
         file_object = StringIO.StringIO()
-        expect = warnings.formatwarning(message, category, file_name, line_num)
-        warnings.showwarning(message, category, file_name, line_num,
+        expect = self.module.formatwarning(message, category, file_name,
+                                            line_num)
+        self.module.showwarning(message, category, file_name, line_num,
                                 file_object)
         self.failUnlessEqual(file_object.getvalue(), expect)
+        # Test 'line' argument.
+        expected_file_line += "for the win!"
+        expect = self.module.formatwarning(message, category, file_name,
+                                            line_num, expected_file_line)
+        file_object = StringIO.StringIO()
+        self.module.showwarning(message, category, file_name, line_num,
+                                file_object, expected_file_line)
+        self.failUnlessEqual(expect, file_object.getvalue())
+
+class CWarningsDisplayTests(WarningsDisplayTests):
+    module = c_warnings
 
+class PyWarningsDisplayTests(WarningsDisplayTests):
+    module = py_warnings
 
-def test_main(verbose=None):
+
+def test_main():
     # Obscure hack so that this test passes after reloads or repeated calls
     # to test_main (regrtest -R).
     if '__warningregistry__' in globals():
@@ -137,7 +378,14 @@ def test_main(verbose=None):
         del warning_tests.__warningregistry__
     if hasattr(sys, '__warningregistry__'):
         del sys.__warningregistry__
-    test_support.run_unittest(TestModule, WarningsDisplayTests)
+    test_support.run_unittest(CFilterTests, PyFilterTests,
+                                CWarnTests, PyWarnTests,
+                                CWCmdLineTests, PyWCmdLineTests,
+                                _WarningsTests,
+                                CWarningsDisplayTests, PyWarningsDisplayTests,
+                             )
+
+
 
 if __name__ == "__main__":
-    test_main(verbose=True)
+    test_main()