Issue 19713: Add PEP 451-related deprecations.

9 files changed, 180 insertions, 59 deletions

diff --git a/Lib/test/test_importlib/extension/test_finder.py b/Lib/test/test_importlib/extension/test_finder.py
index d0c8bb0..990f29c 100644
--- a/Lib/test/test_importlib/extension/test_finder.py
+++ b/Lib/test/test_importlib/extension/test_finder.py
@@ -5,6 +5,7 @@ from . import util
 machinery = test_util.import_importlib('importlib.machinery')
 
 import unittest
+import warnings
 
 # XXX find_spec tests
 
@@ -16,7 +17,9 @@ class FinderTests(abc.FinderTests):
         importer = self.machinery.FileFinder(util.PATH,
                                             (self.machinery.ExtensionFileLoader,
                                              self.machinery.EXTENSION_SUFFIXES))
-        return importer.find_module(fullname)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            return importer.find_module(fullname)
 
     def test_module(self):
         self.assertTrue(self.find_module(util.NAME))
diff --git a/Lib/test/test_importlib/frozen/test_loader.py b/Lib/test/test_importlib/frozen/test_loader.py
index 2abbe92..7c01464 100644
--- a/Lib/test/test_importlib/frozen/test_loader.py
+++ b/Lib/test/test_importlib/frozen/test_loader.py
@@ -8,6 +8,7 @@ import sys
 from test.support import captured_stdout
 import types
 import unittest
+import warnings
 
 
 class ExecModuleTests(abc.LoaderTests):
@@ -60,10 +61,18 @@ class ExecModuleTests(abc.LoaderTests):
                                  expected=value))
             self.assertEqual(output, 'Hello world!\n')
 
-
     def test_module_repr(self):
         name = '__hello__'
         module, output = self.exec_module(name)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            repr_str = self.machinery.FrozenImporter.module_repr(module)
+        self.assertEqual(repr_str,
+                         "<module '__hello__' (frozen)>")
+
+    def test_module_repr_indirect(self):
+        name = '__hello__'
+        module, output = self.exec_module(name)
         self.assertEqual(repr(module),
                          "<module '__hello__' (frozen)>")
 
@@ -84,7 +93,9 @@ class LoaderTests(abc.LoaderTests):
 
     def test_module(self):
         with util.uncache('__hello__'), captured_stdout() as stdout:
-            module = self.machinery.FrozenImporter.load_module('__hello__')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.machinery.FrozenImporter.load_module('__hello__')
             check = {'__name__': '__hello__',
                     '__package__': '',
                     '__loader__': self.machinery.FrozenImporter,
@@ -96,7 +107,9 @@ class LoaderTests(abc.LoaderTests):
 
     def test_package(self):
         with util.uncache('__phello__'),  captured_stdout() as stdout:
-            module = self.machinery.FrozenImporter.load_module('__phello__')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.machinery.FrozenImporter.load_module('__phello__')
             check = {'__name__': '__phello__',
                      '__package__': '__phello__',
                      '__path__': [],
@@ -113,7 +126,9 @@ class LoaderTests(abc.LoaderTests):
     def test_lacking_parent(self):
         with util.uncache('__phello__', '__phello__.spam'), \
              captured_stdout() as stdout:
-            module = self.machinery.FrozenImporter.load_module('__phello__.spam')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.machinery.FrozenImporter.load_module('__phello__.spam')
             check = {'__name__': '__phello__.spam',
                     '__package__': '__phello__',
                     '__loader__': self.machinery.FrozenImporter,
@@ -128,18 +143,29 @@ class LoaderTests(abc.LoaderTests):
 
     def test_module_reuse(self):
         with util.uncache('__hello__'), captured_stdout() as stdout:
-            module1 = self.machinery.FrozenImporter.load_module('__hello__')
-            module2 = self.machinery.FrozenImporter.load_module('__hello__')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module1 = self.machinery.FrozenImporter.load_module('__hello__')
+                module2 = self.machinery.FrozenImporter.load_module('__hello__')
             self.assertIs(module1, module2)
             self.assertEqual(stdout.getvalue(),
                              'Hello world!\nHello world!\n')
 
     def test_module_repr(self):
         with util.uncache('__hello__'), captured_stdout():
-            module = self.machinery.FrozenImporter.load_module('__hello__')
-            self.assertEqual(repr(module),
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.machinery.FrozenImporter.load_module('__hello__')
+                repr_str = self.machinery.FrozenImporter.module_repr(module)
+            self.assertEqual(repr_str,
                              "<module '__hello__' (frozen)>")
 
+    def test_module_repr_indirect(self):
+        with util.uncache('__hello__'), captured_stdout():
+            module = self.machinery.FrozenImporter.load_module('__hello__')
+        self.assertEqual(repr(module),
+                         "<module '__hello__' (frozen)>")
+
     # No way to trigger an error in a frozen module.
     test_state_after_failure = None
 
diff --git a/Lib/test/test_importlib/source/test_file_loader.py b/Lib/test/test_importlib/source/test_file_loader.py
index 16e4df2..25a3dae 100644
--- a/Lib/test/test_importlib/source/test_file_loader.py
+++ b/Lib/test/test_importlib/source/test_file_loader.py
@@ -16,6 +16,7 @@ import stat
 import sys
 import types
 import unittest
+import warnings
 
 from test.support import make_legacy_pyc, unload
 
@@ -39,7 +40,9 @@ class SimpleTest(abc.LoaderTests):
 
         loader = Tester('blah', 'blah.py')
         self.addCleanup(unload, 'blah')
-        module = loader.load_module()  # Should not raise an exception.
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            module = loader.load_module()  # Should not raise an exception.
 
     def test_get_filename_API(self):
         # If fullname is not set then assume self.path is desired.
@@ -70,7 +73,9 @@ class SimpleTest(abc.LoaderTests):
     def test_module(self):
         with source_util.create_modules('_temp') as mapping:
             loader = self.machinery.SourceFileLoader('_temp', mapping['_temp'])
-            module = loader.load_module('_temp')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_temp')
             self.assertIn('_temp', sys.modules)
             check = {'__name__': '_temp', '__file__': mapping['_temp'],
                      '__package__': ''}
@@ -81,7 +86,9 @@ class SimpleTest(abc.LoaderTests):
         with source_util.create_modules('_pkg.__init__') as mapping:
             loader = self.machinery.SourceFileLoader('_pkg',
                                                  mapping['_pkg.__init__'])
-            module = loader.load_module('_pkg')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_pkg')
             self.assertIn('_pkg', sys.modules)
             check = {'__name__': '_pkg', '__file__': mapping['_pkg.__init__'],
                      '__path__': [os.path.dirname(mapping['_pkg.__init__'])],
@@ -94,7 +101,9 @@ class SimpleTest(abc.LoaderTests):
         with source_util.create_modules('_pkg.__init__', '_pkg.mod')as mapping:
             loader = self.machinery.SourceFileLoader('_pkg.mod',
                                                     mapping['_pkg.mod'])
-            module = loader.load_module('_pkg.mod')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_pkg.mod')
             self.assertIn('_pkg.mod', sys.modules)
             check = {'__name__': '_pkg.mod', '__file__': mapping['_pkg.mod'],
                      '__package__': '_pkg'}
@@ -108,12 +117,16 @@ class SimpleTest(abc.LoaderTests):
     def test_module_reuse(self):
         with source_util.create_modules('_temp') as mapping:
             loader = self.machinery.SourceFileLoader('_temp', mapping['_temp'])
-            module = loader.load_module('_temp')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_temp')
             module_id = id(module)
             module_dict_id = id(module.__dict__)
             with open(mapping['_temp'], 'w') as file:
                 file.write("testing_var = 42\n")
-            module = loader.load_module('_temp')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = loader.load_module('_temp')
             self.assertIn('testing_var', module.__dict__,
                          "'testing_var' not in "
                             "{0}".format(list(module.__dict__.keys())))
@@ -138,7 +151,9 @@ class SimpleTest(abc.LoaderTests):
             for attr in attributes:
                 self.assertEqual(getattr(orig_module, attr), value)
             with self.assertRaises(SyntaxError):
-                loader.load_module(name)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    loader.load_module(name)
             for attr in attributes:
                 self.assertEqual(getattr(orig_module, attr), value)
 
@@ -149,7 +164,9 @@ class SimpleTest(abc.LoaderTests):
                 file.write('=')
             loader = self.machinery.SourceFileLoader('_temp', mapping['_temp'])
             with self.assertRaises(SyntaxError):
-                loader.load_module('_temp')
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    loader.load_module('_temp')
             self.assertNotIn('_temp', sys.modules)
 
     def test_file_from_empty_string_dir(self):
@@ -161,7 +178,9 @@ class SimpleTest(abc.LoaderTests):
         try:
             with util.uncache('_temp'):
                 loader = self.machinery.SourceFileLoader('_temp', file_path)
-                mod = loader.load_module('_temp')
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    mod = loader.load_module('_temp')
                 self.assertEqual(file_path, mod.__file__)
                 self.assertEqual(self.util.cache_from_source(file_path),
                                  mod.__cached__)
@@ -196,7 +215,9 @@ class SimpleTest(abc.LoaderTests):
             self.assertTrue(os.path.exists(compiled))
             os.unlink(compiled)
             # PEP 302
-            mod = loader.load_module('_temp') # XXX
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                mod = loader.load_module('_temp') # XXX
             # Sanity checks.
             self.assertEqual(mod.__cached__, compiled)
             self.assertEqual(mod.x, 5)
@@ -210,7 +231,9 @@ class SimpleTest(abc.LoaderTests):
         with self.assertRaises(ImportError):
             loader.exec_module(module)
         with self.assertRaises(ImportError):
-            loader.load_module('bad name')
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                loader.load_module('bad name')
 
 Frozen_SimpleTest, Source_SimpleTest = util.test_both(
         SimpleTest, importlib=importlib, machinery=machinery, abc=importlib_abc,
@@ -221,7 +244,10 @@ class BadBytecodeTest:
 
     def import_(self, file, module_name):
         loader = self.loader(module_name, file)
-        module = loader.load_module(module_name)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            # XXX Change to use exec_module().
+            module = loader.load_module(module_name)
         self.assertIn(module_name, sys.modules)
 
     def manipulate_bytecode(self, name, mapping, manipulator, *,
@@ -332,7 +358,9 @@ class BadBytecodeTestPEP302(BadBytecodeTest):
 
     def import_(self, file, module_name):
         loader = self.loader(module_name, file)
-        module = loader.load_module(module_name)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            module = loader.load_module(module_name)
         self.assertIn(module_name, sys.modules)
 
 
diff --git a/Lib/test/test_importlib/source/test_finder.py b/Lib/test/test_importlib/source/test_finder.py
index 36fc3dd..473297b 100644
--- a/Lib/test/test_importlib/source/test_finder.py
+++ b/Lib/test/test_importlib/source/test_finder.py
@@ -46,6 +46,10 @@ class FinderTests(abc.FinderTests):
                             self.machinery.BYTECODE_SUFFIXES)]
         return self.machinery.FileFinder(root, *loader_details)
 
+    def import_(self, root, module):
+        finder = self.get_finder(root)
+        return self._find(finder, module, loader_only=True)
+
     def run_test(self, test, create=None, *, compile_=None, unlink=None):
         """Test the finding of 'test' with the creation of modules listed in
         'create'.
@@ -127,7 +131,7 @@ class FinderTests(abc.FinderTests):
         with open('mod.py', 'w') as file:
             file.write("# test file for importlib")
         try:
-            loader = finder.find_module('mod')
+            loader = self._find(finder, 'mod', loader_only=True)
             self.assertTrue(hasattr(loader, 'load_module'))
         finally:
             os.unlink('mod.py')
@@ -145,8 +149,10 @@ class FinderTests(abc.FinderTests):
         mod = 'mod'
         with source_util.create_modules(mod) as mapping:
             finder = self.get_finder(mapping['.root'])
-            self.assertIsNotNone(finder.find_module(mod))
-        self.assertIsNone(finder.find_module(mod))
+            found = self._find(finder, 'mod', loader_only=True)
+            self.assertIsNotNone(found)
+        found = self._find(finder, 'mod', loader_only=True)
+        self.assertIsNone(found)
 
     @unittest.skipUnless(sys.platform != 'win32',
             'os.chmod() does not support the needed arguments under Windows')
@@ -170,29 +176,52 @@ class FinderTests(abc.FinderTests):
         self.addCleanup(cleanup, tempdir)
         os.chmod(tempdir.name, stat.S_IWUSR | stat.S_IXUSR)
         finder = self.get_finder(tempdir.name)
-        self.assertEqual((None, []), finder.find_loader('doesnotexist'))
+        found = self._find(finder, 'doesnotexist')
+        self.assertEqual(found, self.NOT_FOUND)
 
     def test_ignore_file(self):
         # If a directory got changed to a file from underneath us, then don't
         # worry about looking for submodules.
         with tempfile.NamedTemporaryFile() as file_obj:
             finder = self.get_finder(file_obj.name)
-            self.assertEqual((None, []), finder.find_loader('doesnotexist'))
+            found = self._find(finder, 'doesnotexist')
+            self.assertEqual(found, self.NOT_FOUND)
+
 
 class FinderTestsPEP451(FinderTests):
 
-    def import_(self, root, module):
-        found = self.get_finder(root).find_spec(module)
-        return found.loader if found is not None else found
+    NOT_FOUND = None
+
+    def _find(self, finder, name, loader_only=False):
+        spec = finder.find_spec(name)
+        return spec.loader if spec is not None else spec
 
 Frozen_FinderTestsPEP451, Source_FinderTestsPEP451 = util.test_both(
         FinderTestsPEP451, machinery=machinery)
 
 
+class FinderTestsPEP420(FinderTests):
+
+    NOT_FOUND = (None, [])
+
+    def _find(self, finder, name, loader_only=False):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            loader_portions = finder.find_loader(name)
+            return loader_portions[0] if loader_only else loader_portions
+
+Frozen_FinderTestsPEP420, Source_FinderTestsPEP420 = util.test_both(
+        FinderTestsPEP420, machinery=machinery)
+
+
 class FinderTestsPEP302(FinderTests):
 
-    def import_(self, root, module):
-        return self.get_finder(root).find_module(module)
+    NOT_FOUND = None
+
+    def _find(self, finder, name, loader_only=False):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            return finder.find_module(name)
 
 Frozen_FinderTestsPEP302, Source_FinderTestsPEP302 = util.test_both(
         FinderTestsPEP302, machinery=machinery)
diff --git a/Lib/test/test_importlib/source/test_source_encoding.py b/Lib/test/test_importlib/source/test_source_encoding.py
index aaf0041..c62dfa1 100644
--- a/Lib/test/test_importlib/source/test_source_encoding.py
+++ b/Lib/test/test_importlib/source/test_source_encoding.py
@@ -12,6 +12,7 @@ import types
 # imported for the parser to use.
 import unicodedata
 import unittest
+import warnings
 
 
 CODING_RE = re.compile(r'^[ \t\f]*#.*coding[:=][ \t]*([-\w.]+)', re.ASCII)
@@ -102,7 +103,9 @@ Frozen_EncodingTestPEP451, Source_EncodingTestPEP451 = util.test_both(
 class EncodingTestPEP302(EncodingTest):
 
     def load(self, loader):
-        return loader.load_module(self.module_name)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            return loader.load_module(self.module_name)
 
 Frozen_EncodingTestPEP302, Source_EncodingTestPEP302 = util.test_both(
         EncodingTestPEP302, machinery=machinery)
@@ -121,8 +124,8 @@ class LineEndingTest:
             with open(mapping[module_name], 'wb') as file:
                 file.write(source)
             loader = self.machinery.SourceFileLoader(module_name,
-                                                 mapping[module_name])
-            return loader.load_module(module_name)
+                                                     mapping[module_name])
+            return self.load(loader, module_name)
 
     # [cr]
     def test_cr(self):
@@ -138,9 +141,9 @@ class LineEndingTest:
 
 class LineEndingTestPEP451(LineEndingTest):
 
-    def load(self, loader):
-        module = types.ModuleType(self.module_name)
-        module.__spec__ = importlib.util.spec_from_loader(self.module_name, loader)
+    def load(self, loader, module_name):
+        module = types.ModuleType(module_name)
+        module.__spec__ = importlib.util.spec_from_loader(module_name, loader)
         loader.exec_module(module)
         return module
 
@@ -149,8 +152,10 @@ Frozen_LineEndingTestPEP451, Source_LineEndingTestPEP451 = util.test_both(
 
 class LineEndingTestPEP302(LineEndingTest):
 
-    def load(self, loader):
-        return loader.load_module(self.module_name)
+    def load(self, loader, module_name):
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            return loader.load_module(module_name)
 
 Frozen_LineEndingTestPEP302, Source_LineEndingTestPEP302 = util.test_both(
         LineEndingTestPEP302, machinery=machinery)
diff --git a/Lib/test/test_importlib/test_abc.py b/Lib/test/test_importlib/test_abc.py
index ba8d605..7c8e8fe 100644
--- a/Lib/test/test_importlib/test_abc.py
+++ b/Lib/test/test_importlib/test_abc.py
@@ -8,6 +8,7 @@ from test import support
 import types
 import unittest
 from unittest import mock
+import warnings
 
 from . import util
 
@@ -388,7 +389,9 @@ class InspectLoaderLoadModuleTests:
             mocked_get_code.side_effect = ImportError
             with self.assertRaises(ImportError):
                 loader = self.InspectLoaderSubclass()
-                loader.load_module(self.module_name)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    loader.load_module(self.module_name)
 
     def test_get_code_None(self):
         # If get_code() returns None, raise ImportError.
@@ -631,7 +634,9 @@ class SourceOnlyLoaderTests(SourceLoaderTestHarness):
         # __path__ (for packages), __file__, and __cached__.
         # The module should also be put into sys.modules.
         with util.uncache(self.name):
-            module = self.loader.load_module(self.name)
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.loader.load_module(self.name)
             self.verify_module(module)
             self.assertEqual(module.__path__, [os.path.dirname(self.path)])
             self.assertIn(self.name, sys.modules)
@@ -642,7 +647,9 @@ class SourceOnlyLoaderTests(SourceLoaderTestHarness):
         # Testing the values for a package are covered by test_load_module.
         self.setUp(is_package=False)
         with util.uncache(self.name):
-            module = self.loader.load_module(self.name)
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                module = self.loader.load_module(self.name)
             self.verify_module(module)
             self.assertTrue(not hasattr(module, '__path__'))
 
diff --git a/Lib/test/test_importlib/test_api.py b/Lib/test/test_importlib/test_api.py
index 2a6142a..c3c19f4 100644
--- a/Lib/test/test_importlib/test_api.py
+++ b/Lib/test/test_importlib/test_api.py
@@ -10,6 +10,7 @@ import sys
 from test import support
 import types
 import unittest
+import warnings
 
 
 @contextmanager
@@ -143,7 +144,9 @@ class FindLoaderTests:
             loader = 'a loader!'
             module.__loader__ = loader
             sys.modules[name] = module
-            found = self.init.find_loader(name)
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                found = self.init.find_loader(name)
             self.assertEqual(loader, found)
 
     def test_sys_modules_loader_is_None(self):
@@ -154,7 +157,9 @@ class FindLoaderTests:
             module.__loader__ = None
             sys.modules[name] = module
             with self.assertRaises(ValueError):
-                self.init.find_loader(name)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    self.init.find_loader(name)
 
     def test_sys_modules_loader_is_not_set(self):
         # Should raise ValueError
@@ -168,14 +173,18 @@ class FindLoaderTests:
                 pass
             sys.modules[name] = module
             with self.assertRaises(ValueError):
-                self.init.find_loader(name)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    self.init.find_loader(name)
 
     def test_success(self):
         # Return the loader found on sys.meta_path.
         name = 'some_mod'
         with util.uncache(name):
             with util.import_state(meta_path=[self.FakeMetaFinder]):
-                self.assertEqual((name, None), self.init.find_loader(name))
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    self.assertEqual((name, None), self.init.find_loader(name))
 
     def test_success_path(self):
         # Searching on a path should work.
@@ -183,12 +192,16 @@ class FindLoaderTests:
         path = 'path to some place'
         with util.uncache(name):
             with util.import_state(meta_path=[self.FakeMetaFinder]):
-                self.assertEqual((name, path),
-                                 self.init.find_loader(name, path))
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', DeprecationWarning)
+                    self.assertEqual((name, path),
+                                     self.init.find_loader(name, path))
 
     def test_nothing(self):
         # None is returned upon failure to find a loader.
-        self.assertIsNone(self.init.find_loader('nevergoingtofindthismodule'))
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            self.assertIsNone(self.init.find_loader('nevergoingtofindthismodule'))
 
 class Frozen_FindLoaderTests(FindLoaderTests, unittest.TestCase):
     init = frozen_init
diff --git a/Lib/test/test_importlib/test_spec.py b/Lib/test/test_importlib/test_spec.py
index ae77a28..71541f6 100644
--- a/Lib/test/test_importlib/test_spec.py
+++ b/Lib/test/test_importlib/test_spec.py
@@ -50,7 +50,7 @@ class LegacyLoader(TestLoader):
     HAM = -1
 
     with warnings.catch_warnings():
-        warnings.simplefilter("ignore", PendingDeprecationWarning)
+        warnings.simplefilter("ignore", DeprecationWarning)
 
         @frozen_util.module_for_loader
         def load_module(self, module):
diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py
index 604e44d..b6fe864 100644
--- a/Lib/test/test_importlib/test_util.py
+++ b/Lib/test/test_importlib/test_util.py
@@ -41,14 +41,14 @@ class ModuleForLoaderTests:
     @classmethod
     def module_for_loader(cls, func):
         with warnings.catch_warnings():
-            warnings.simplefilter('ignore', PendingDeprecationWarning)
+            warnings.simplefilter('ignore', DeprecationWarning)
             return cls.util.module_for_loader(func)
 
     def test_warning(self):
         # Should raise a PendingDeprecationWarning when used.
         with warnings.catch_warnings():
-            warnings.simplefilter('error', PendingDeprecationWarning)
-            with self.assertRaises(PendingDeprecationWarning):
+            warnings.simplefilter('error', DeprecationWarning)
+            with self.assertRaises(DeprecationWarning):
                 func = self.util.module_for_loader(lambda x: x)
 
     def return_module(self, name):
@@ -172,7 +172,9 @@ class SetPackageTests:
         passing through set_package."""
         fxn = lambda: module
         wrapped = self.util.set_package(fxn)
-        wrapped()
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            wrapped()
         self.assertTrue(hasattr(module, '__package__'))
         self.assertEqual(expect, module.__package__)
 
@@ -212,7 +214,9 @@ class SetPackageTests:
 
     def test_decorator_attrs(self):
         def fxn(module): pass
-        wrapped = self.util.set_package(fxn)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            wrapped = self.util.set_package(fxn)
         self.assertEqual(wrapped.__name__, fxn.__name__)
         self.assertEqual(wrapped.__qualname__, fxn.__qualname__)
 
@@ -236,19 +240,25 @@ class SetLoaderTests:
             del loader.module.__loader__
         except AttributeError:
             pass
-        self.assertEqual(loader, loader.load_module('blah').__loader__)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            self.assertEqual(loader, loader.load_module('blah').__loader__)
 
     def test_attribute_is_None(self):
         loader = self.DummyLoader()
         loader.module = types.ModuleType('blah')
         loader.module.__loader__ = None
-        self.assertEqual(loader, loader.load_module('blah').__loader__)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            self.assertEqual(loader, loader.load_module('blah').__loader__)
 
     def test_not_reset(self):
         loader = self.DummyLoader()
         loader.module = types.ModuleType('blah')
         loader.module.__loader__ = 42
-        self.assertEqual(42, loader.load_module('blah').__loader__)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            self.assertEqual(42, loader.load_module('blah').__loader__)
 
 class Frozen_SetLoaderTests(SetLoaderTests, unittest.TestCase):
     class DummyLoader: