Reworked test_warnings.py:

* It ran fine under "python regrtest.py test_warnings" but failed under
  "python regrtest.py" presumably because other tests would add to
  filtered warnings and not reset them at the end of the test.

* Converted to a unittest format for better control.  Renamed
  monkey() and unmonkey() to setUp() and tearDown().

* Increased coverage by testing all warnings in __builtin__.

* Increased coverage by testing regex matching of specific messages.

Lib/test/output/test_warnings

-test_warnings
-('ignore', False, 'FutureWarning', False, 0)
-('ignore', True, 'OverflowWarning', True, 0)
-('ignore', True, 'PendingDeprecationWarning', True, 0)
-test_warnings.py:31: UserWarning: hello world
-test_warnings.py:32: UserWarning: hello world
-test_warnings.py:33: DeprecationWarning: hello world
-test_warnings.py:35: UserWarning: hello world
-Caught UserWarning: hello world
-Caught AssertionError: invalid action: 'booh'

Lib/test/test_warnings.py

 import warnings
 import os
+import unittest
+from test import test_support
 
 # The warnings module isn't easily tested, because it relies on module
-# globals to store configuration information.  We need to extract the
-# current settings to avoid bashing them while running tests.
+# globals to store configuration information.  setUp() and tearDown()
+# preserve the current settings to avoid bashing them while running tests.
 
-_filters = []
-_showwarning = None
+# To capture the warning messages, a replacement for showwarning() is
+# used to save warning information in a global variable.
+
+class WarningMessage:
+    "Holds results of latest showwarning() call"
+    pass
 
 def showwarning(message, category, filename, lineno, file=None):
-    filename = os.path.basename(filename)
-    print "%s:%s: %s: %s" % (filename, lineno, category.__name__, message)
+    msg.message = str(message)
+    msg.category = category.__name__
+    msg.filename = os.path.basename(filename)
+    msg.lineno = lineno
+
+class TestModule(unittest.TestCase):
 
-def monkey():
-    global _filters, _showwarning
-    _filters = warnings.filters[:]
-    _showwarning = warnings.showwarning
+    def setUp(self):
+        global msg
+        msg = WarningMessage()
+        self._filters = warnings.filters[:]
+        self._showwarning = warnings.showwarning
         warnings.showwarning = showwarning
+        self.ignored = [w[2].__name__ for w in self._filters
+            if w[0]=='ignore' and w[1] is None and w[3] is None]
 
-def unmonkey():
-    warnings.filters = _filters[:]
-    warnings.showwarning = _showwarning
+    def tearDown(self):
+        warnings.filters = self._filters[:]
+        warnings.showwarning = self._showwarning
 
-def test():
-    for item in warnings.filters:
-        print (item[0], item[1] is None, item[2].__name__, item[3] is None,
-               item[4])
-    hello = "hello world"
+    def test_warn_default_category(self):
         for i in range(4):
-        warnings.warn(hello)
-    warnings.warn(hello, UserWarning)
-    warnings.warn(hello, DeprecationWarning)
-    for i in range(3):
-        warnings.warn(hello)
-    warnings.filterwarnings("error", "", Warning, "", 0)
-    try:
-        warnings.warn(hello)
-    except Exception, msg:
-        print "Caught", msg.__class__.__name__ + ":", msg
+            text = 'multi %d' %i    # Different text on each call
+            warnings.warn(text)
+            self.assertEqual(msg.message, text)
+            self.assertEqual(msg.category, 'UserWarning')
+
+    def test_warn_specific_category(self):
+        text = 'None'
+        for category in [DeprecationWarning, FutureWarning, OverflowWarning,
+                    PendingDeprecationWarning, RuntimeWarning,
+                    SyntaxWarning, UserWarning, Warning]:
+            if category.__name__ in self.ignored:
+                text = 'filtered out' + category.__name__
+                warnings.warn(text, category)
+                self.assertNotEqual(msg.message, text)
             else:
-        print "No exception"
+                text = 'unfiltered %s' % category.__name__
+                warnings.warn(text, category)
+                self.assertEqual(msg.message, text)
+                self.assertEqual(msg.category, category.__name__)
+
+    def test_filtering(self):
+
+        warnings.filterwarnings("error", "", Warning, "", 0)
+        self.assertRaises(UserWarning, warnings.warn, 'convert to error')
+
         warnings.resetwarnings()
-    try:
-        warnings.filterwarnings("booh", "", Warning, "", 0)
-    except Exception, msg:
-        print "Caught", msg.__class__.__name__ + ":", msg
-    else:
-        print "No exception"
+        text = 'handle normally'
+        warnings.warn(text)
+        self.assertEqual(msg.message, text)
+        self.assertEqual(msg.category, 'UserWarning')
+
+        warnings.filterwarnings("ignore", "", Warning, "", 0)
+        text = 'filtered out'
+        warnings.warn(text)
+        self.assertNotEqual(msg.message, text)
+
+        warnings.resetwarnings()
+        warnings.filterwarnings("error", "hex*", Warning, "", 0)
+        self.assertRaises(UserWarning, warnings.warn, 'hex/oct')
+        text = 'nonmatching text'
+        warnings.warn(text)
+        self.assertEqual(msg.message, text)
+        self.assertEqual(msg.category, 'UserWarning')
+
+def test_main(verbose=None):
+    test_support.run_unittest(TestModule)
 
-monkey()
-test()
-unmonkey()
+if __name__ == "__main__":
+    test_main(verbose=True)