Replace catch_warnings with check_warnings when it makes sense. Use...

Replace catch_warnings with check_warnings when it makes sense.  Use assertRaises context manager to simplify some tests.

Lib/test/test___all__.py

@@ -4,7 +4,6 @@ import unittest
 from test import test_support as support
 import os
 import sys
-import warnings
 
 
 class NoAll(RuntimeError):
@@ -18,9 +17,8 @@ class AllTest(unittest.TestCase):
 
     def check_all(self, modname):
         names = {}
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", ".* (module|package)",
-                                    DeprecationWarning)
+        with support.check_warnings((".* (module|package)",
+                                     DeprecationWarning), quiet=True):
             try:
                 exec "import %s" % modname in names
             except:

Lib/test/test_argparse.py

@@ -7,7 +7,6 @@ import sys
 import textwrap
 import tempfile
 import unittest
-import warnings
 import argparse
 
 from StringIO import StringIO
@@ -4160,21 +4159,12 @@ class TestImportStar(TestCase):
             self.assertTrue(hasattr(argparse, name))
 
 def test_main():
-    with warnings.catch_warnings():
     # silence warnings about version argument - these are expected
-        warnings.filterwarnings(
-            action='ignore',
-            message='The "version" argument to ArgumentParser is deprecated.',
-            category=DeprecationWarning)
-        warnings.filterwarnings(
-            action='ignore',
-            message='The format_version method is deprecated',
-            category=DeprecationWarning)
-        warnings.filterwarnings(
-            action='ignore',
-            message='The print_version method is deprecated',
-            category=DeprecationWarning)
-
+    with test_support.check_warnings(
+            ('The "version" argument to ArgumentParser is deprecated.',
+             DeprecationWarning),
+            ('The (format|print)_version method is deprecated',
+             DeprecationWarning)):
         test_support.run_unittest(__name__)
     # Remove global references to avoid looking like we have refleaks.
     RFile.seen = {}

Lib/test/test_coercion.py

 import copy
-import warnings
 import unittest
-from test.test_support import run_unittest, TestFailed
+from test.test_support import run_unittest, TestFailed, check_warnings
 
 # Fake a number that implements numeric methods through __coerce__
 class CoerceNumber:
@@ -223,12 +222,6 @@ def process_infix_results():
             infix_results[key] = res
 
 
-with warnings.catch_warnings():
-    warnings.filterwarnings("ignore", "classic int division",
-                            DeprecationWarning)
-    process_infix_results()
-# now infix_results has two lists of results for every pairing.
-
 prefix_binops = [ 'divmod' ]
 prefix_results = [
     [(1,0), (1L,0L), (0.0,2.0), ((1+0j),0j), TE, TE, TE, TE, (1,0)],
@@ -339,11 +332,13 @@ class CoercionTest(unittest.TestCase):
             raise exc
 
 def test_main():
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore", "complex divmod.., // and % "
-                                "are deprecated", DeprecationWarning)
-        warnings.filterwarnings("ignore", "classic (int|long) division",
-                                DeprecationWarning)
+    with check_warnings(("complex divmod.., // and % are deprecated",
+                         DeprecationWarning),
+                        ("classic (int|long) division", DeprecationWarning),
+                        quiet=True):
+        process_infix_results()
+        # now infix_results has two lists of results for every pairing.
+
         run_unittest(CoercionTest)
 
 if __name__ == "__main__":

Lib/test/test_commands.py

@@ -4,12 +4,9 @@
 '''
 import unittest
 import os, tempfile, re
-import warnings
 
-warnings.filterwarnings('ignore', r".*commands.getstatus.. is deprecated",
-                        DeprecationWarning)
-
-from test.test_support import run_unittest, reap_children, import_module
+from test.test_support import run_unittest, reap_children, import_module, \
+                              check_warnings
 
 # Silence Py3k warning
 commands = import_module('commands', deprecated=True)
@@ -59,6 +56,8 @@ class CommandTests(unittest.TestCase):
                   /\.          # and end with the name of the file.
                '''
 
+        with check_warnings((".*commands.getstatus.. is deprecated",
+                             DeprecationWarning)):
             self.assertTrue(re.match(pat, commands.getstatus("/."), re.VERBOSE))
 
 

Lib/test/test_complex.py

-import unittest, os
+import unittest
 from test import test_support
 
-import warnings
-warnings.filterwarnings(
-    "ignore",
-    category=DeprecationWarning,
-    message=".*complex divmod.*are deprecated"
-)
-
 from random import random
 from math import atan2, isnan, copysign
 
@@ -464,10 +457,7 @@ class ComplexTest(unittest.TestCase):
         finally:
             if (fo is not None) and (not fo.closed):
                 fo.close()
-            try:
-                os.remove(test_support.TESTFN)
-            except (OSError, IOError):
-                pass
+            test_support.unlink(test_support.TESTFN)
 
     def test_getnewargs(self):
         self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0))
@@ -613,6 +603,8 @@ class ComplexTest(unittest.TestCase):
         self.assertEqual('{0:F}'.format(complex(NAN, NAN)), 'NAN+NANj')
 
 def test_main():
+    with test_support.check_warnings(("complex divmod.., // and % are "
+                                      "deprecated", DeprecationWarning)):
         test_support.run_unittest(ComplexTest)
 
 if __name__ == "__main__":

Lib/test/test_contextlib.py

 """Unit tests for contextlib.py, and other context managers."""
 
-
-import os
 import sys
 import tempfile
 import unittest
 import threading
 from contextlib import *  # Tests __all__
 from test import test_support
-import warnings
+
 
 class ContextManagerTestCase(unittest.TestCase):
 
@@ -34,16 +32,12 @@ class ContextManagerTestCase(unittest.TestCase):
                 yield 42
             finally:
                 state.append(999)
-        try:
+        with self.assertRaises(ZeroDivisionError):
             with woohoo() as x:
                 self.assertEqual(state, [1])
                 self.assertEqual(x, 42)
                 state.append(x)
                 raise ZeroDivisionError()
-        except ZeroDivisionError:
-            pass
-        else:
-            self.fail("Expected ZeroDivisionError")
         self.assertEqual(state, [1, 42, 999])
 
     def test_contextmanager_no_reraise(self):
@@ -144,15 +138,12 @@ class NestedTestCase(unittest.TestCase):
                 yield 5
             finally:
                 state.append(6)
-        try:
+        with self.assertRaises(ZeroDivisionError):
             with nested(a(), b()) as (x, y):
                 state.append(x)
                 state.append(y)
-                1/0
-        except ZeroDivisionError:
+                1 // 0
         self.assertEqual(state, [1, 4, 2, 5, 6, 3])
-        else:
-            self.fail("Didn't raise ZeroDivisionError")
 
     def test_nested_right_exception(self):
         @contextmanager
@@ -166,15 +157,10 @@ class NestedTestCase(unittest.TestCase):
                     raise Exception()
                 except:
                     pass
-        try:
+        with self.assertRaises(ZeroDivisionError):
             with nested(a(), b()) as (x, y):
-                1/0
-        except ZeroDivisionError:
+                1 // 0
         self.assertEqual((x, y), (1, 2))
-        except Exception:
-            self.fail("Reraised wrong exception")
-        else:
-            self.fail("Didn't raise ZeroDivisionError")
 
     def test_nested_b_swallows(self):
         @contextmanager
@@ -189,7 +175,7 @@ class NestedTestCase(unittest.TestCase):
                 pass
         try:
             with nested(a(), b()):
-                1/0
+                1 // 0
         except ZeroDivisionError:
             self.fail("Didn't swallow ZeroDivisionError")
 
@@ -252,14 +238,11 @@ class ClosingTestCase(unittest.TestCase):
                 state.append(1)
         x = C()
         self.assertEqual(state, [])
-        try:
+        with self.assertRaises(ZeroDivisionError):
             with closing(x) as y:
                 self.assertEqual(x, y)
-                1/0
-        except ZeroDivisionError:
+                1 // 0
         self.assertEqual(state, [1])
-        else:
-            self.fail("Didn't raise ZeroDivisionError")
 
 class FileContextTestCase(unittest.TestCase):
 
@@ -272,20 +255,14 @@ class FileContextTestCase(unittest.TestCase):
                 f.write("Booh\n")
             self.assertTrue(f.closed)
             f = None
-            try:
+            with self.assertRaises(ZeroDivisionError):
                 with open(tfn, "r") as f:
                     self.assertFalse(f.closed)
                     self.assertEqual(f.read(), "Booh\n")
-                    1/0
-            except ZeroDivisionError:
+                    1 // 0
             self.assertTrue(f.closed)
-            else:
-                self.fail("Didn't raise ZeroDivisionError")
         finally:
-            try:
-                os.remove(tfn)
-            except os.error:
-                pass
+            test_support.unlink(tfn)
 
 class LockContextTestCase(unittest.TestCase):
 
@@ -294,14 +271,11 @@ class LockContextTestCase(unittest.TestCase):
         with lock:
             self.assertTrue(locked())
         self.assertFalse(locked())
-        try:
+        with self.assertRaises(ZeroDivisionError):
             with lock:
                 self.assertTrue(locked())
-                1/0
-        except ZeroDivisionError:
+                1 // 0
         self.assertFalse(locked())
-        else:
-            self.fail("Didn't raise ZeroDivisionError")
 
     def testWithLock(self):
         lock = threading.Lock()
@@ -339,8 +313,9 @@ class LockContextTestCase(unittest.TestCase):
 
 # This is needed to make the test actually run under regrtest.py!
 def test_main():
-    with warnings.catch_warnings():
-        warnings.simplefilter('ignore')
+    with test_support.check_warnings(("With-statements now directly support "
+                                      "multiple context managers",
+                                      DeprecationWarning)):
         test_support.run_unittest(__name__)
 
 if __name__ == "__main__":

Lib/test/test_cookie.py

 # Simple test suite for Cookie.py
 
-from test.test_support import run_unittest, run_doctest
+from test.test_support import run_unittest, run_doctest, check_warnings
 import unittest
 import Cookie
 
-import warnings
-warnings.filterwarnings("ignore",
-                        ".* class is insecure.*",
-                        DeprecationWarning)
 
 class CookieTests(unittest.TestCase):
     # Currently this only tests SimpleCookie
@@ -76,6 +72,8 @@ class CookieTests(unittest.TestCase):
 
 def test_main():
     run_unittest(CookieTests)
+    with check_warnings(('.+Cookie class is insecure; do not use it',
+                         DeprecationWarning)):
         run_doctest(Cookie)
 
 if __name__ == '__main__':

Lib/test/test_descr.py

@@ -2,7 +2,6 @@ import __builtin__
 import sys
 import types
 import unittest
-import warnings
 
 from copy import deepcopy
 from test import test_support
@@ -59,15 +58,6 @@ class OperatorsTest(unittest.TestCase):
                 expr = '%s a' % expr
             self.unops[name] = expr
 
-    def setUp(self):
-        self.original_filters = warnings.filters[:]
-        warnings.filterwarnings("ignore",
-                 r'complex divmod\(\), // and % are deprecated$',
-                 DeprecationWarning, r'(<string>|%s)$' % __name__)
-
-    def tearDown(self):
-        warnings.filters = self.original_filters
-
     def unop_test(self, a, res, expr="len(a)", meth="__len__"):
         d = {'a': a}
         self.assertEqual(eval(expr, d), res)
@@ -4622,11 +4612,15 @@ class PTypesLongInitTest(unittest.TestCase):
 
 
 def test_main():
-    with test_support.check_py3k_warnings(
+    deprecations = [(r'complex divmod\(\), // and % are deprecated$',
+                     DeprecationWarning)]
+    if sys.py3kwarning:
+        deprecations += [
             ("classic (int|long) division", DeprecationWarning),
             ("coerce.. not supported", DeprecationWarning),
             ("Overriding __cmp__ ", DeprecationWarning),
-            (".+__(get|set|del)slice__ has been removed", DeprecationWarning)):
+            (".+__(get|set|del)slice__ has been removed", DeprecationWarning)]
+    with test_support.check_warnings(*deprecations):
         # Run all local test cases, with PTypesLongInitTest first.
         test_support.run_unittest(PTypesLongInitTest, OperatorsTest,
                                   ClassPropertiesAndMethods, DictProxyTests)

Lib/test/test_doctest.py

@@ -3,9 +3,9 @@
 Test script for doctest.
 """
 
+import sys
 from test import test_support
 import doctest
-import warnings
 
 # NOTE: There are some additional tests relating to interaction with
 #       zipimport in the test_zipimport_support test module.
@@ -2458,12 +2458,13 @@ def test_main():
     test_support.run_doctest(doctest, verbosity=True)
 
     from test import test_doctest
-    with test_support.check_py3k_warnings(
-            ("backquote not supported", SyntaxWarning),
-            ("execfile.. not supported", DeprecationWarning)):
+
     # Ignore all warnings about the use of class Tester in this module.
-        warnings.filterwarnings("ignore", "class Tester is deprecated",
-                                DeprecationWarning)
+    deprecations = [("class Tester is deprecated", DeprecationWarning)]
+    if sys.py3kwarning:
+        deprecations += [("backquote not supported", SyntaxWarning),
+                         ("execfile.. not supported", DeprecationWarning)]
+    with test_support.check_warnings(*deprecations):
         # Check the doctest cases defined here:
         test_support.run_doctest(test_doctest, verbosity=True)
 

Lib/test/test_exceptions.py

@@ -4,9 +4,9 @@ import os
 import sys
 import unittest
 import pickle, cPickle
-import warnings
 
-from test.test_support import TESTFN, unlink, run_unittest, captured_output
+from test.test_support import (TESTFN, unlink, run_unittest, captured_output,
+                               check_warnings)
 from test.test_pep352 import ignore_deprecation_warnings
 
 # XXX This is not really enough, each *operation* should be tested!
@@ -308,24 +308,19 @@ class ExceptionTests(unittest.TestCase):
         # Accessing BaseException.message and relying on its value set by
         # BaseException.__init__ triggers a deprecation warning.
         exc = BaseException("foo")
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('default')
-            self.assertEquals(exc.message, "foo")
-        self.assertEquals(len(w), 1)
-        self.assertEquals(w[0].category, DeprecationWarning)
-        self.assertEquals(
-            str(w[0].message),
-            "BaseException.message has been deprecated as of Python 2.6")
-
+        with check_warnings(("BaseException.message has been deprecated "
+                             "as of Python 2.6", DeprecationWarning)) as w:
+            self.assertEqual(exc.message, "foo")
+        self.assertEqual(len(w.warnings), 1)
 
     def testRegularMessageAttribute(self):
         # Accessing BaseException.message after explicitly setting a value
         # for it does not trigger a deprecation warning.
         exc = BaseException("foo")
         exc.message = "bar"
-        with warnings.catch_warnings(record=True) as w:
-            self.assertEquals(exc.message, "bar")
-        self.assertEquals(len(w), 0)
+        with check_warnings(quiet=True) as w:
+            self.assertEqual(exc.message, "bar")
+        self.assertEqual(len(w.warnings), 0)
         # Deleting the message is supported, too.
         del exc.message
         with self.assertRaises(AttributeError):

Lib/test/test_global.py

@@ -2,9 +2,8 @@
 
 from test.test_support import run_unittest, check_syntax_error
 import unittest
-
 import warnings
-warnings.filterwarnings("error", module="<test string>")
+
 
 class GlobalTests(unittest.TestCase):
 
@@ -45,6 +44,8 @@ x = 2
 
 
 def test_main():
+    with warnings.catch_warnings():
+        warnings.filterwarnings("error", module="<test string>")
         run_unittest(GlobalTests)
 
 if __name__ == "__main__":

Lib/test/test_hmac.py

@@ -213,19 +213,13 @@ class TestVectorsTestCase(unittest.TestCase):
 
         with warnings.catch_warnings():
             warnings.simplefilter('error', RuntimeWarning)
-            try:
+            with self.assertRaises(RuntimeWarning):
                 hmac.HMAC('a', 'b', digestmod=MockCrazyHash)
-            except RuntimeWarning:
-                pass
-            else:
                 self.fail('Expected warning about missing block_size')
 
             MockCrazyHash.block_size = 1
-            try:
+            with self.assertRaises(RuntimeWarning):
                 hmac.HMAC('a', 'b', digestmod=MockCrazyHash)
-            except RuntimeWarning:
-                pass
-            else:
                 self.fail('Expected warning about small block_size')
 
 

Lib/test/test_int_literal.py

@@ -6,9 +6,6 @@ This is complex because of changes due to PEP 237.
 import unittest
 from test import test_support
 
-import warnings
-warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning,
-                        "<string>")
 
 class TestHexOctBin(unittest.TestCase):
 

Lib/test/test_io.py

@@ -29,7 +29,6 @@ import array
 import threading
 import random
 import unittest
-import warnings
 import weakref
 import abc
 from itertools import cycle, count

Lib/test/test_macostools.py

@@ -23,14 +23,8 @@ class TestMacostools(unittest.TestCase):
         rfp.close()
 
     def tearDown(self):
-        try:
-            os.unlink(test_support.TESTFN)
-        except:
-            pass
-        try:
-            os.unlink(TESTFN2)
-        except:
-            pass
+        test_support.unlink(test_support.TESTFN)
+        test_support.unlink(TESTFN2)
 
     def compareData(self):
         fp = open(test_support.TESTFN, 'r')
@@ -53,36 +47,25 @@ class TestMacostools(unittest.TestCase):
 
     def test_touched(self):
         # This really only tests that nothing unforeseen happens.
-        import warnings
-        with warnings.catch_warnings():
-            warnings.filterwarnings('ignore', 'macostools.touched*',
-                                    DeprecationWarning)
+        with test_support.check_warnings(('macostools.touched*',
+                                          DeprecationWarning), quiet=True):
             macostools.touched(test_support.TESTFN)
 
     if sys.maxint < 2**32:
         def test_copy(self):
-            try:
-                os.unlink(TESTFN2)
-            except:
-                pass
+            test_support.unlink(TESTFN2)
             macostools.copy(test_support.TESTFN, TESTFN2)
             self.assertEqual(self.compareData(), '')
 
     if sys.maxint < 2**32:
         def test_mkalias(self):
-            try:
-                os.unlink(TESTFN2)
-            except:
-                pass
+            test_support.unlink(TESTFN2)
             macostools.mkalias(test_support.TESTFN, TESTFN2)
             fss, _, _ = Carbon.File.ResolveAliasFile(TESTFN2, 0)
             self.assertEqual(fss.as_pathname(), os.path.realpath(test_support.TESTFN))
 
         def test_mkalias_relative(self):
-            try:
-                os.unlink(TESTFN2)
-            except:
-                pass
+            test_support.unlink(TESTFN2)
             # If the directory doesn't exist, then chances are this is a new
             # install of Python so don't create it since the user might end up
             # running ``sudo make install`` and creating the directory here won't

Lib/test/test_pep352.py

@@ -2,7 +2,7 @@ import unittest
 import __builtin__
 import exceptions
 import warnings
-from test.test_support import run_unittest
+from test.test_support import run_unittest, check_warnings
 import os
 import sys
 from platform import system as platform_system
@@ -15,14 +15,13 @@ if sys.py3kwarning:
          "catching classes that don't inherit from BaseException is not allowed",
          "__get(item|slice)__ not supported for exception classes"])
 
+_deprecations = [(msg, DeprecationWarning) for msg in DEPRECATION_WARNINGS]
+
 # Silence Py3k and other deprecation warnings
 def ignore_deprecation_warnings(func):
     """Ignore the known DeprecationWarnings."""
     def wrapper(*args, **kw):
-        with warnings.catch_warnings():
-            warnings.resetwarnings()
-            for text in DEPRECATION_WARNINGS:
-                warnings.filterwarnings("ignore", text, DeprecationWarning)
+        with check_warnings(*_deprecations, quiet=True):
             return func(*args, **kw)
     return wrapper
 
@@ -139,16 +138,8 @@ class ExceptionClassTests(unittest.TestCase):
 
     def test_message_deprecation(self):
         # As of Python 2.6, BaseException.message is deprecated.
-        with warnings.catch_warnings():
-            warnings.resetwarnings()
-            warnings.filterwarnings('error')
-
-            try:
+        with check_warnings(("", DeprecationWarning)):
             BaseException().message
-            except DeprecationWarning:
-                pass
-            else:
-                self.fail("BaseException.message not deprecated")
 
 
 class UsageTests(unittest.TestCase):
@@ -224,28 +215,19 @@ class UsageTests(unittest.TestCase):
             warnings.resetwarnings()
             warnings.filterwarnings("error")
             str_exc = "spam"
-            try:
+            with self.assertRaises(DeprecationWarning):
                 try:
                     raise StandardError
                 except str_exc:
                     pass
-            except DeprecationWarning:
-                pass
-            except StandardError:
-                self.fail("catching a string exception did not raise "
-                            "DeprecationWarning")
+
             # Make sure that even if the string exception is listed in a tuple
             # that a warning is raised.
-            try:
+            with self.assertRaises(DeprecationWarning):
                 try:
                     raise StandardError
                 except (AssertionError, str_exc):
                     pass
-            except DeprecationWarning:
-                pass
-            except StandardError:
-                self.fail("catching a string exception specified in a tuple did "
-                            "not raise DeprecationWarning")
 
 
 def test_main():

Lib/test/test_re.py

-from test.test_support import verbose, run_unittest
+from test.test_support import verbose, run_unittest, import_module
 import re
 from re import Scanner
 import sys, traceback
@@ -447,10 +447,7 @@ class ReTests(unittest.TestCase):
         import cPickle
         self.pickle_test(cPickle)
         # old pickles expect the _compile() reconstructor in sre module
-        import warnings
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "The sre module is deprecated",
-                                    DeprecationWarning)
+        import_module("sre", deprecated=True)
         from sre import _compile
 
     def pickle_test(self, pickle):

Lib/test/test_sundry.py

@@ -3,13 +3,11 @@
 from test import test_support
 import sys
 import unittest
-import warnings
 
 
 class TestUntestedModules(unittest.TestCase):
     def test_at_least_import_untested_modules(self):
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
+        with test_support.check_warnings(quiet=True):
             import CGIHTTPServer
             import audiodev
             import bdb

Lib/test/test_symtable.py

@@ -3,7 +3,6 @@ Test the API of the symtable module.
 """
 import symtable
 import unittest
-import warnings
 
 from test import test_support
 
@@ -44,9 +43,8 @@ def find_block(block, name):
 
 class SymtableTest(unittest.TestCase):
 
-    with warnings.catch_warnings():
-        # Ignore warnings about "from blank import *"
-        warnings.simplefilter("ignore", SyntaxWarning)
+    with test_support.check_warnings(
+            ("import \* only allowed at module level", SyntaxWarning)):
         top = symtable.symtable(TEST_CODE, "?", "exec")
     # These correspond to scopes in TEST_CODE
     Mine = find_block(top, "Mine")

Lib/test/test_urllibnet.py

@@ -182,10 +182,8 @@ class urlretrieveNetworkTests(unittest.TestCase):
 
 def test_main():
     test_support.requires('network')
-    from warnings import filterwarnings, catch_warnings
-    with catch_warnings():
-        filterwarnings('ignore', '.*urllib\.urlopen.*Python 3.0',
-                        DeprecationWarning)
+    with test_support.check_py3k_warnings(
+            ("urllib.urlopen.. has been removed", DeprecationWarning)):
         test_support.run_unittest(URLTimeoutTest,
                                   urlopenNetworkTests,
                                   urlretrieveNetworkTests)

Lib/test/test_zipimport_support.py

@@ -168,12 +168,14 @@ class ZipSupportTests(ImportHooksBaseTestCase):
                 test_zipped_doctest.test_unittest_reportflags,
             ]
             # Needed for test_DocTestParser and test_debug
-            with test.test_support.check_py3k_warnings(
-                    ("backquote not supported", SyntaxWarning),
-                    ("execfile.. not supported", DeprecationWarning)):
+            deprecations = [
                 # Ignore all warnings about the use of class Tester in this module.
-                warnings.filterwarnings("ignore", "class Tester is deprecated",
-                                        DeprecationWarning)
+                ("class Tester is deprecated", DeprecationWarning)]
+            if sys.py3kwarning:
+                deprecations += [
+                    ("backquote not supported", SyntaxWarning),
+                    ("execfile.. not supported", DeprecationWarning)]
+            with test.test_support.check_warnings(*deprecations):
                 for obj in known_good_tests:
                     _run_object_doctest(obj, test_zipped_doctest)