Upgraded vendored Python dependencies to the latest versions and removed the unused dependencies.v1.0.3-beta.16

30 files changed, 0 insertions, 1046 deletions

diff --git a/libs/importlib_resources/tests/__init__.py b/libs/importlib_resources/tests/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/libs/importlib_resources/tests/__init__.py
+++ /dev/null
diff --git a/libs/importlib_resources/tests/_compat.py b/libs/importlib_resources/tests/_compat.py
deleted file mode 100644
index 4c99cffd0..000000000
--- a/libs/importlib_resources/tests/_compat.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import os
-
-
-try:
-    from test.support import import_helper  # type: ignore
-except ImportError:
-    # Python 3.9 and earlier
-    class import_helper:  # type: ignore
-        from test.support import modules_setup, modules_cleanup
-
-
-try:
-    # Python 3.10
-    from test.support.os_helper import unlink
-except ImportError:
-    from test.support import unlink as _unlink
-
-    def unlink(target):
-        return _unlink(os.fspath(target))
diff --git a/libs/importlib_resources/tests/data01/__init__.py b/libs/importlib_resources/tests/data01/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/libs/importlib_resources/tests/data01/__init__.py
+++ /dev/null
diff --git a/libs/importlib_resources/tests/data01/binary.file b/libs/importlib_resources/tests/data01/binary.file
deleted file mode 100644
index eaf36c1da..000000000
--- a/libs/importlib_resources/tests/data01/binary.file
+++ /dev/null
diff --git a/libs/importlib_resources/tests/data01/subdirectory/__init__.py b/libs/importlib_resources/tests/data01/subdirectory/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/libs/importlib_resources/tests/data01/subdirectory/__init__.py
+++ /dev/null
diff --git a/libs/importlib_resources/tests/data01/subdirectory/binary.file b/libs/importlib_resources/tests/data01/subdirectory/binary.file
deleted file mode 100644
index eaf36c1da..000000000
--- a/libs/importlib_resources/tests/data01/subdirectory/binary.file
+++ /dev/null
diff --git a/libs/importlib_resources/tests/data01/utf-16.file b/libs/importlib_resources/tests/data01/utf-16.file
deleted file mode 100644
index 2cb772295..000000000
--- a/libs/importlib_resources/tests/data01/utf-16.file
+++ /dev/null
diff --git a/libs/importlib_resources/tests/data01/utf-8.file b/libs/importlib_resources/tests/data01/utf-8.file
deleted file mode 100644
index 1c0132ad9..000000000
--- a/libs/importlib_resources/tests/data01/utf-8.file
+++ /dev/null
@@ -1 +0,0 @@
-Hello, UTF-8 world!
diff --git a/libs/importlib_resources/tests/data02/__init__.py b/libs/importlib_resources/tests/data02/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/libs/importlib_resources/tests/data02/__init__.py
+++ /dev/null
diff --git a/libs/importlib_resources/tests/data02/one/__init__.py b/libs/importlib_resources/tests/data02/one/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/libs/importlib_resources/tests/data02/one/__init__.py
+++ /dev/null
diff --git a/libs/importlib_resources/tests/data02/one/resource1.txt b/libs/importlib_resources/tests/data02/one/resource1.txt
deleted file mode 100644
index 61a813e40..000000000
--- a/libs/importlib_resources/tests/data02/one/resource1.txt
+++ /dev/null
@@ -1 +0,0 @@
-one resource
diff --git a/libs/importlib_resources/tests/data02/two/__init__.py b/libs/importlib_resources/tests/data02/two/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/libs/importlib_resources/tests/data02/two/__init__.py
+++ /dev/null
diff --git a/libs/importlib_resources/tests/data02/two/resource2.txt b/libs/importlib_resources/tests/data02/two/resource2.txt
deleted file mode 100644
index a80ce46ea..000000000
--- a/libs/importlib_resources/tests/data02/two/resource2.txt
+++ /dev/null
@@ -1 +0,0 @@
-two resource
diff --git a/libs/importlib_resources/tests/namespacedata01/binary.file b/libs/importlib_resources/tests/namespacedata01/binary.file
deleted file mode 100644
index eaf36c1da..000000000
--- a/libs/importlib_resources/tests/namespacedata01/binary.file
+++ /dev/null
diff --git a/libs/importlib_resources/tests/namespacedata01/utf-16.file b/libs/importlib_resources/tests/namespacedata01/utf-16.file
deleted file mode 100644
index 2cb772295..000000000
--- a/libs/importlib_resources/tests/namespacedata01/utf-16.file
+++ /dev/null
diff --git a/libs/importlib_resources/tests/namespacedata01/utf-8.file b/libs/importlib_resources/tests/namespacedata01/utf-8.file
deleted file mode 100644
index 1c0132ad9..000000000
--- a/libs/importlib_resources/tests/namespacedata01/utf-8.file
+++ /dev/null
@@ -1 +0,0 @@
-Hello, UTF-8 world!
diff --git a/libs/importlib_resources/tests/test_compatibilty_files.py b/libs/importlib_resources/tests/test_compatibilty_files.py
deleted file mode 100644
index d92c7c56c..000000000
--- a/libs/importlib_resources/tests/test_compatibilty_files.py
+++ /dev/null
@@ -1,102 +0,0 @@
-import io
-import unittest
-
-import importlib_resources as resources
-
-from importlib_resources._adapters import (
-    CompatibilityFiles,
-    wrap_spec,
-)
-
-from . import util
-
-
-class CompatibilityFilesTests(unittest.TestCase):
-    @property
-    def package(self):
-        bytes_data = io.BytesIO(b'Hello, world!')
-        return util.create_package(
-            file=bytes_data,
-            path='some_path',
-            contents=('a', 'b', 'c'),
-        )
-
-    @property
-    def files(self):
-        return resources.files(self.package)
-
-    def test_spec_path_iter(self):
-        self.assertEqual(
-            sorted(path.name for path in self.files.iterdir()),
-            ['a', 'b', 'c'],
-        )
-
-    def test_child_path_iter(self):
-        self.assertEqual(list((self.files / 'a').iterdir()), [])
-
-    def test_orphan_path_iter(self):
-        self.assertEqual(list((self.files / 'a' / 'a').iterdir()), [])
-        self.assertEqual(list((self.files / 'a' / 'a' / 'a').iterdir()), [])
-
-    def test_spec_path_is(self):
-        self.assertFalse(self.files.is_file())
-        self.assertFalse(self.files.is_dir())
-
-    def test_child_path_is(self):
-        self.assertTrue((self.files / 'a').is_file())
-        self.assertFalse((self.files / 'a').is_dir())
-
-    def test_orphan_path_is(self):
-        self.assertFalse((self.files / 'a' / 'a').is_file())
-        self.assertFalse((self.files / 'a' / 'a').is_dir())
-        self.assertFalse((self.files / 'a' / 'a' / 'a').is_file())
-        self.assertFalse((self.files / 'a' / 'a' / 'a').is_dir())
-
-    def test_spec_path_name(self):
-        self.assertEqual(self.files.name, 'testingpackage')
-
-    def test_child_path_name(self):
-        self.assertEqual((self.files / 'a').name, 'a')
-
-    def test_orphan_path_name(self):
-        self.assertEqual((self.files / 'a' / 'b').name, 'b')
-        self.assertEqual((self.files / 'a' / 'b' / 'c').name, 'c')
-
-    def test_spec_path_open(self):
-        self.assertEqual(self.files.read_bytes(), b'Hello, world!')
-        self.assertEqual(self.files.read_text(), 'Hello, world!')
-
-    def test_child_path_open(self):
-        self.assertEqual((self.files / 'a').read_bytes(), b'Hello, world!')
-        self.assertEqual((self.files / 'a').read_text(), 'Hello, world!')
-
-    def test_orphan_path_open(self):
-        with self.assertRaises(FileNotFoundError):
-            (self.files / 'a' / 'b').read_bytes()
-        with self.assertRaises(FileNotFoundError):
-            (self.files / 'a' / 'b' / 'c').read_bytes()
-
-    def test_open_invalid_mode(self):
-        with self.assertRaises(ValueError):
-            self.files.open('0')
-
-    def test_orphan_path_invalid(self):
-        with self.assertRaises(ValueError):
-            CompatibilityFiles.OrphanPath()
-
-    def test_wrap_spec(self):
-        spec = wrap_spec(self.package)
-        self.assertIsInstance(spec.loader.get_resource_reader(None), CompatibilityFiles)
-
-
-class CompatibilityFilesNoReaderTests(unittest.TestCase):
-    @property
-    def package(self):
-        return util.create_package_from_loader(None)
-
-    @property
-    def files(self):
-        return resources.files(self.package)
-
-    def test_spec_path_joinpath(self):
-        self.assertIsInstance(self.files / 'a', CompatibilityFiles.OrphanPath)
diff --git a/libs/importlib_resources/tests/test_contents.py b/libs/importlib_resources/tests/test_contents.py
deleted file mode 100644
index 525568e8c..000000000
--- a/libs/importlib_resources/tests/test_contents.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import unittest
-import importlib_resources as resources
-
-from . import data01
-from . import util
-
-
-class ContentsTests:
-    expected = {
-        '__init__.py',
-        'binary.file',
-        'subdirectory',
-        'utf-16.file',
-        'utf-8.file',
-    }
-
-    def test_contents(self):
-        contents = {path.name for path in resources.files(self.data).iterdir()}
-        assert self.expected <= contents
-
-
-class ContentsDiskTests(ContentsTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
-
-
-class ContentsZipTests(ContentsTests, util.ZipSetup, unittest.TestCase):
-    pass
-
-
-class ContentsNamespaceTests(ContentsTests, unittest.TestCase):
-    expected = {
-        # no __init__ because of namespace design
-        # no subdirectory as incidental difference in fixture
-        'binary.file',
-        'utf-16.file',
-        'utf-8.file',
-    }
-
-    def setUp(self):
-        from . import namespacedata01
-
-        self.data = namespacedata01
diff --git a/libs/importlib_resources/tests/test_files.py b/libs/importlib_resources/tests/test_files.py
deleted file mode 100644
index 2676b49e7..000000000
--- a/libs/importlib_resources/tests/test_files.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import typing
-import unittest
-
-import importlib_resources as resources
-from importlib_resources.abc import Traversable
-from . import data01
-from . import util
-
-
-class FilesTests:
-    def test_read_bytes(self):
-        files = resources.files(self.data)
-        actual = files.joinpath('utf-8.file').read_bytes()
-        assert actual == b'Hello, UTF-8 world!\n'
-
-    def test_read_text(self):
-        files = resources.files(self.data)
-        actual = files.joinpath('utf-8.file').read_text(encoding='utf-8')
-        assert actual == 'Hello, UTF-8 world!\n'
-
-    @unittest.skipUnless(
-        hasattr(typing, 'runtime_checkable'),
-        "Only suitable when typing supports runtime_checkable",
-    )
-    def test_traversable(self):
-        assert isinstance(resources.files(self.data), Traversable)
-
-
-class OpenDiskTests(FilesTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
-
-
-class OpenZipTests(FilesTests, util.ZipSetup, unittest.TestCase):
-    pass
-
-
-class OpenNamespaceTests(FilesTests, unittest.TestCase):
-    def setUp(self):
-        from . import namespacedata01
-
-        self.data = namespacedata01
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/libs/importlib_resources/tests/test_open.py b/libs/importlib_resources/tests/test_open.py
deleted file mode 100644
index 87b42c3d3..000000000
--- a/libs/importlib_resources/tests/test_open.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import unittest
-
-import importlib_resources as resources
-from . import data01
-from . import util
-
-
-class CommonBinaryTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        target = resources.files(package).joinpath(path)
-        with target.open('rb'):
-            pass
-
-
-class CommonTextTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        target = resources.files(package).joinpath(path)
-        with target.open():
-            pass
-
-
-class OpenTests:
-    def test_open_binary(self):
-        target = resources.files(self.data) / 'binary.file'
-        with target.open('rb') as fp:
-            result = fp.read()
-            self.assertEqual(result, b'\x00\x01\x02\x03')
-
-    def test_open_text_default_encoding(self):
-        target = resources.files(self.data) / 'utf-8.file'
-        with target.open() as fp:
-            result = fp.read()
-            self.assertEqual(result, 'Hello, UTF-8 world!\n')
-
-    def test_open_text_given_encoding(self):
-        target = resources.files(self.data) / 'utf-16.file'
-        with target.open(encoding='utf-16', errors='strict') as fp:
-            result = fp.read()
-        self.assertEqual(result, 'Hello, UTF-16 world!\n')
-
-    def test_open_text_with_errors(self):
-        # Raises UnicodeError without the 'errors' argument.
-        target = resources.files(self.data) / 'utf-16.file'
-        with target.open(encoding='utf-8', errors='strict') as fp:
-            self.assertRaises(UnicodeError, fp.read)
-        with target.open(encoding='utf-8', errors='ignore') as fp:
-            result = fp.read()
-        self.assertEqual(
-            result,
-            'H\x00e\x00l\x00l\x00o\x00,\x00 '
-            '\x00U\x00T\x00F\x00-\x001\x006\x00 '
-            '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00',
-        )
-
-    def test_open_binary_FileNotFoundError(self):
-        target = resources.files(self.data) / 'does-not-exist'
-        self.assertRaises(FileNotFoundError, target.open, 'rb')
-
-    def test_open_text_FileNotFoundError(self):
-        target = resources.files(self.data) / 'does-not-exist'
-        self.assertRaises(FileNotFoundError, target.open)
-
-
-class OpenDiskTests(OpenTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
-
-
-class OpenDiskNamespaceTests(OpenTests, unittest.TestCase):
-    def setUp(self):
-        from . import namespacedata01
-
-        self.data = namespacedata01
-
-
-class OpenZipTests(OpenTests, util.ZipSetup, unittest.TestCase):
-    pass
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/libs/importlib_resources/tests/test_path.py b/libs/importlib_resources/tests/test_path.py
deleted file mode 100644
index 4f4d3943b..000000000
--- a/libs/importlib_resources/tests/test_path.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import io
-import unittest
-
-import importlib_resources as resources
-from . import data01
-from . import util
-
-
-class CommonTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        with resources.as_file(resources.files(package).joinpath(path)):
-            pass
-
-
-class PathTests:
-    def test_reading(self):
-        # Path should be readable.
-        # Test also implicitly verifies the returned object is a pathlib.Path
-        # instance.
-        target = resources.files(self.data) / 'utf-8.file'
-        with resources.as_file(target) as path:
-            self.assertTrue(path.name.endswith("utf-8.file"), repr(path))
-            # pathlib.Path.read_text() was introduced in Python 3.5.
-            with path.open('r', encoding='utf-8') as file:
-                text = file.read()
-            self.assertEqual('Hello, UTF-8 world!\n', text)
-
-
-class PathDiskTests(PathTests, unittest.TestCase):
-    data = data01
-
-    def test_natural_path(self):
-        """
-        Guarantee the internal implementation detail that
-        file-system-backed resources do not get the tempdir
-        treatment.
-        """
-        target = resources.files(self.data) / 'utf-8.file'
-        with resources.as_file(target) as path:
-            assert 'data' in str(path)
-
-
-class PathMemoryTests(PathTests, unittest.TestCase):
-    def setUp(self):
-        file = io.BytesIO(b'Hello, UTF-8 world!\n')
-        self.addCleanup(file.close)
-        self.data = util.create_package(
-            file=file, path=FileNotFoundError("package exists only in memory")
-        )
-        self.data.__spec__.origin = None
-        self.data.__spec__.has_location = False
-
-
-class PathZipTests(PathTests, util.ZipSetup, unittest.TestCase):
-    def test_remove_in_context_manager(self):
-        # It is not an error if the file that was temporarily stashed on the
-        # file system is removed inside the `with` stanza.
-        target = resources.files(self.data) / 'utf-8.file'
-        with resources.as_file(target) as path:
-            path.unlink()
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/libs/importlib_resources/tests/test_read.py b/libs/importlib_resources/tests/test_read.py
deleted file mode 100644
index 41dd6db5f..000000000
--- a/libs/importlib_resources/tests/test_read.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import unittest
-import importlib_resources as resources
-
-from . import data01
-from . import util
-from importlib import import_module
-
-
-class CommonBinaryTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        resources.files(package).joinpath(path).read_bytes()
-
-
-class CommonTextTests(util.CommonTests, unittest.TestCase):
-    def execute(self, package, path):
-        resources.files(package).joinpath(path).read_text()
-
-
-class ReadTests:
-    def test_read_bytes(self):
-        result = resources.files(self.data).joinpath('binary.file').read_bytes()
-        self.assertEqual(result, b'\0\1\2\3')
-
-    def test_read_text_default_encoding(self):
-        result = resources.files(self.data).joinpath('utf-8.file').read_text()
-        self.assertEqual(result, 'Hello, UTF-8 world!\n')
-
-    def test_read_text_given_encoding(self):
-        result = (
-            resources.files(self.data)
-            .joinpath('utf-16.file')
-            .read_text(encoding='utf-16')
-        )
-        self.assertEqual(result, 'Hello, UTF-16 world!\n')
-
-    def test_read_text_with_errors(self):
-        # Raises UnicodeError without the 'errors' argument.
-        target = resources.files(self.data) / 'utf-16.file'
-        self.assertRaises(UnicodeError, target.read_text, encoding='utf-8')
-        result = target.read_text(encoding='utf-8', errors='ignore')
-        self.assertEqual(
-            result,
-            'H\x00e\x00l\x00l\x00o\x00,\x00 '
-            '\x00U\x00T\x00F\x00-\x001\x006\x00 '
-            '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00',
-        )
-
-
-class ReadDiskTests(ReadTests, unittest.TestCase):
-    data = data01
-
-
-class ReadZipTests(ReadTests, util.ZipSetup, unittest.TestCase):
-    def test_read_submodule_resource(self):
-        submodule = import_module('ziptestdata.subdirectory')
-        result = resources.files(submodule).joinpath('binary.file').read_bytes()
-        self.assertEqual(result, b'\0\1\2\3')
-
-    def test_read_submodule_resource_by_name(self):
-        result = (
-            resources.files('ziptestdata.subdirectory')
-            .joinpath('binary.file')
-            .read_bytes()
-        )
-        self.assertEqual(result, b'\0\1\2\3')
-
-
-class ReadNamespaceTests(ReadTests, unittest.TestCase):
-    def setUp(self):
-        from . import namespacedata01
-
-        self.data = namespacedata01
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/libs/importlib_resources/tests/test_reader.py b/libs/importlib_resources/tests/test_reader.py
deleted file mode 100644
index 16841a508..000000000
--- a/libs/importlib_resources/tests/test_reader.py
+++ /dev/null
@@ -1,128 +0,0 @@
-import os.path
-import sys
-import pathlib
-import unittest
-
-from importlib import import_module
-from importlib_resources.readers import MultiplexedPath, NamespaceReader
-
-
-class MultiplexedPathTest(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        path = pathlib.Path(__file__).parent / 'namespacedata01'
-        cls.folder = str(path)
-
-    def test_init_no_paths(self):
-        with self.assertRaises(FileNotFoundError):
-            MultiplexedPath()
-
-    def test_init_file(self):
-        with self.assertRaises(NotADirectoryError):
-            MultiplexedPath(os.path.join(self.folder, 'binary.file'))
-
-    def test_iterdir(self):
-        contents = {path.name for path in MultiplexedPath(self.folder).iterdir()}
-        try:
-            contents.remove('__pycache__')
-        except (KeyError, ValueError):
-            pass
-        self.assertEqual(contents, {'binary.file', 'utf-16.file', 'utf-8.file'})
-
-    def test_iterdir_duplicate(self):
-        data01 = os.path.abspath(os.path.join(__file__, '..', 'data01'))
-        contents = {
-            path.name for path in MultiplexedPath(self.folder, data01).iterdir()
-        }
-        for remove in ('__pycache__', '__init__.pyc'):
-            try:
-                contents.remove(remove)
-            except (KeyError, ValueError):
-                pass
-        self.assertEqual(
-            contents,
-            {'__init__.py', 'binary.file', 'subdirectory', 'utf-16.file', 'utf-8.file'},
-        )
-
-    def test_is_dir(self):
-        self.assertEqual(MultiplexedPath(self.folder).is_dir(), True)
-
-    def test_is_file(self):
-        self.assertEqual(MultiplexedPath(self.folder).is_file(), False)
-
-    def test_open_file(self):
-        path = MultiplexedPath(self.folder)
-        with self.assertRaises(FileNotFoundError):
-            path.read_bytes()
-        with self.assertRaises(FileNotFoundError):
-            path.read_text()
-        with self.assertRaises(FileNotFoundError):
-            path.open()
-
-    def test_join_path(self):
-        prefix = os.path.abspath(os.path.join(__file__, '..'))
-        data01 = os.path.join(prefix, 'data01')
-        path = MultiplexedPath(self.folder, data01)
-        self.assertEqual(
-            str(path.joinpath('binary.file'))[len(prefix) + 1 :],
-            os.path.join('namespacedata01', 'binary.file'),
-        )
-        self.assertEqual(
-            str(path.joinpath('subdirectory'))[len(prefix) + 1 :],
-            os.path.join('data01', 'subdirectory'),
-        )
-        self.assertEqual(
-            str(path.joinpath('imaginary'))[len(prefix) + 1 :],
-            os.path.join('namespacedata01', 'imaginary'),
-        )
-
-    def test_repr(self):
-        self.assertEqual(
-            repr(MultiplexedPath(self.folder)),
-            f"MultiplexedPath('{self.folder}')",
-        )
-
-    def test_name(self):
-        self.assertEqual(
-            MultiplexedPath(self.folder).name,
-            os.path.basename(self.folder),
-        )
-
-
-class NamespaceReaderTest(unittest.TestCase):
-    site_dir = str(pathlib.Path(__file__).parent)
-
-    @classmethod
-    def setUpClass(cls):
-        sys.path.append(cls.site_dir)
-
-    @classmethod
-    def tearDownClass(cls):
-        sys.path.remove(cls.site_dir)
-
-    def test_init_error(self):
-        with self.assertRaises(ValueError):
-            NamespaceReader(['path1', 'path2'])
-
-    def test_resource_path(self):
-        namespacedata01 = import_module('namespacedata01')
-        reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations)
-
-        root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01'))
-        self.assertEqual(
-            reader.resource_path('binary.file'), os.path.join(root, 'binary.file')
-        )
-        self.assertEqual(
-            reader.resource_path('imaginary'), os.path.join(root, 'imaginary')
-        )
-
-    def test_files(self):
-        namespacedata01 = import_module('namespacedata01')
-        reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations)
-        root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01'))
-        self.assertIsInstance(reader.files(), MultiplexedPath)
-        self.assertEqual(repr(reader.files()), f"MultiplexedPath('{root}')")
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/libs/importlib_resources/tests/test_resource.py b/libs/importlib_resources/tests/test_resource.py
deleted file mode 100644
index 5affd8b0d..000000000
--- a/libs/importlib_resources/tests/test_resource.py
+++ /dev/null
@@ -1,252 +0,0 @@
-import sys
-import unittest
-import importlib_resources as resources
-import uuid
-import pathlib
-
-from . import data01
-from . import zipdata01, zipdata02
-from . import util
-from importlib import import_module
-from ._compat import import_helper, unlink
-
-
-class ResourceTests:
-    # Subclasses are expected to set the `data` attribute.
-
-    def test_is_file_exists(self):
-        target = resources.files(self.data) / 'binary.file'
-        self.assertTrue(target.is_file())
-
-    def test_is_file_missing(self):
-        target = resources.files(self.data) / 'not-a-file'
-        self.assertFalse(target.is_file())
-
-    def test_is_dir(self):
-        target = resources.files(self.data) / 'subdirectory'
-        self.assertFalse(target.is_file())
-        self.assertTrue(target.is_dir())
-
-
-class ResourceDiskTests(ResourceTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
-
-
-class ResourceZipTests(ResourceTests, util.ZipSetup, unittest.TestCase):
-    pass
-
-
-def names(traversable):
-    return {item.name for item in traversable.iterdir()}
-
-
-class ResourceLoaderTests(unittest.TestCase):
-    def test_resource_contents(self):
-        package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C']
-        )
-        self.assertEqual(names(resources.files(package)), {'A', 'B', 'C'})
-
-    def test_is_file(self):
-        package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
-        )
-        self.assertTrue(resources.files(package).joinpath('B').is_file())
-
-    def test_is_dir(self):
-        package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
-        )
-        self.assertTrue(resources.files(package).joinpath('D').is_dir())
-
-    def test_resource_missing(self):
-        package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
-        )
-        self.assertFalse(resources.files(package).joinpath('Z').is_file())
-
-
-class ResourceCornerCaseTests(unittest.TestCase):
-    def test_package_has_no_reader_fallback(self):
-        # Test odd ball packages which:
-        # 1. Do not have a ResourceReader as a loader
-        # 2. Are not on the file system
-        # 3. Are not in a zip file
-        module = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C']
-        )
-        # Give the module a dummy loader.
-        module.__loader__ = object()
-        # Give the module a dummy origin.
-        module.__file__ = '/path/which/shall/not/be/named'
-        module.__spec__.loader = module.__loader__
-        module.__spec__.origin = module.__file__
-        self.assertFalse(resources.files(module).joinpath('A').is_file())
-
-
-class ResourceFromZipsTest01(util.ZipSetupBase, unittest.TestCase):
-    ZIP_MODULE = zipdata01  # type: ignore
-
-    def test_is_submodule_resource(self):
-        submodule = import_module('ziptestdata.subdirectory')
-        self.assertTrue(resources.files(submodule).joinpath('binary.file').is_file())
-
-    def test_read_submodule_resource_by_name(self):
-        self.assertTrue(
-            resources.files('ziptestdata.subdirectory')
-            .joinpath('binary.file')
-            .is_file()
-        )
-
-    def test_submodule_contents(self):
-        submodule = import_module('ziptestdata.subdirectory')
-        self.assertEqual(
-            names(resources.files(submodule)), {'__init__.py', 'binary.file'}
-        )
-
-    def test_submodule_contents_by_name(self):
-        self.assertEqual(
-            names(resources.files('ziptestdata.subdirectory')),
-            {'__init__.py', 'binary.file'},
-        )
-
-
-class ResourceFromZipsTest02(util.ZipSetupBase, unittest.TestCase):
-    ZIP_MODULE = zipdata02  # type: ignore
-
-    def test_unrelated_contents(self):
-        """
-        Test thata zip with two unrelated subpackages return
-        distinct resources. Ref python/importlib_resources#44.
-        """
-        self.assertEqual(
-            names(resources.files('ziptestdata.one')),
-            {'__init__.py', 'resource1.txt'},
-        )
-        self.assertEqual(
-            names(resources.files('ziptestdata.two')),
-            {'__init__.py', 'resource2.txt'},
-        )
-
-
-class DeletingZipsTest(unittest.TestCase):
-    """Having accessed resources in a zip file should not keep an open
-    reference to the zip.
-    """
-
-    ZIP_MODULE = zipdata01
-
-    def setUp(self):
-        modules = import_helper.modules_setup()
-        self.addCleanup(import_helper.modules_cleanup, *modules)
-
-        data_path = pathlib.Path(self.ZIP_MODULE.__file__)
-        data_dir = data_path.parent
-        self.source_zip_path = data_dir / 'ziptestdata.zip'
-        self.zip_path = pathlib.Path(f'{uuid.uuid4()}.zip').absolute()
-        self.zip_path.write_bytes(self.source_zip_path.read_bytes())
-        sys.path.append(str(self.zip_path))
-        self.data = import_module('ziptestdata')
-
-    def tearDown(self):
-        try:
-            sys.path.remove(str(self.zip_path))
-        except ValueError:
-            pass
-
-        try:
-            del sys.path_importer_cache[str(self.zip_path)]
-            del sys.modules[self.data.__name__]
-        except KeyError:
-            pass
-
-        try:
-            unlink(self.zip_path)
-        except OSError:
-            # If the test fails, this will probably fail too
-            pass
-
-    def test_iterdir_does_not_keep_open(self):
-        c = [item.name for item in resources.files('ziptestdata').iterdir()]
-        self.zip_path.unlink()
-        del c
-
-    def test_is_file_does_not_keep_open(self):
-        c = resources.files('ziptestdata').joinpath('binary.file').is_file()
-        self.zip_path.unlink()
-        del c
-
-    def test_is_file_failure_does_not_keep_open(self):
-        c = resources.files('ziptestdata').joinpath('not-present').is_file()
-        self.zip_path.unlink()
-        del c
-
-    @unittest.skip("Desired but not supported.")
-    def test_as_file_does_not_keep_open(self):  # pragma: no cover
-        c = resources.as_file(resources.files('ziptestdata') / 'binary.file')
-        self.zip_path.unlink()
-        del c
-
-    def test_entered_path_does_not_keep_open(self):
-        # This is what certifi does on import to make its bundle
-        # available for the process duration.
-        c = resources.as_file(
-            resources.files('ziptestdata') / 'binary.file'
-        ).__enter__()
-        self.zip_path.unlink()
-        del c
-
-    def test_read_binary_does_not_keep_open(self):
-        c = resources.files('ziptestdata').joinpath('binary.file').read_bytes()
-        self.zip_path.unlink()
-        del c
-
-    def test_read_text_does_not_keep_open(self):
-        c = resources.files('ziptestdata').joinpath('utf-8.file').read_text()
-        self.zip_path.unlink()
-        del c
-
-
-class ResourceFromNamespaceTest01(unittest.TestCase):
-    site_dir = str(pathlib.Path(__file__).parent)
-
-    @classmethod
-    def setUpClass(cls):
-        sys.path.append(cls.site_dir)
-
-    @classmethod
-    def tearDownClass(cls):
-        sys.path.remove(cls.site_dir)
-
-    def test_is_submodule_resource(self):
-        self.assertTrue(
-            resources.files(import_module('namespacedata01'))
-            .joinpath('binary.file')
-            .is_file()
-        )
-
-    def test_read_submodule_resource_by_name(self):
-        self.assertTrue(
-            resources.files('namespacedata01').joinpath('binary.file').is_file()
-        )
-
-    def test_submodule_contents(self):
-        contents = names(resources.files(import_module('namespacedata01')))
-        try:
-            contents.remove('__pycache__')
-        except KeyError:
-            pass
-        self.assertEqual(contents, {'binary.file', 'utf-8.file', 'utf-16.file'})
-
-    def test_submodule_contents_by_name(self):
-        contents = names(resources.files('namespacedata01'))
-        try:
-            contents.remove('__pycache__')
-        except KeyError:
-            pass
-        self.assertEqual(contents, {'binary.file', 'utf-8.file', 'utf-16.file'})
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/libs/importlib_resources/tests/update-zips.py b/libs/importlib_resources/tests/update-zips.py
deleted file mode 100755
index 9ef0224ca..000000000
--- a/libs/importlib_resources/tests/update-zips.py
+++ /dev/null
@@ -1,53 +0,0 @@
-"""
-Generate the zip test data files.
-
-Run to build the tests/zipdataNN/ziptestdata.zip files from
-files in tests/dataNN.
-
-Replaces the file with the working copy, but does commit anything
-to the source repo.
-"""
-
-import contextlib
-import os
-import pathlib
-import zipfile
-
-
-def main():
-    """
-    >>> from unittest import mock
-    >>> monkeypatch = getfixture('monkeypatch')
-    >>> monkeypatch.setattr(zipfile, 'ZipFile', mock.MagicMock())
-    >>> print(); main()  # print workaround for bpo-32509
-    <BLANKLINE>
-    ...data01... -> ziptestdata/...
-    ...
-    ...data02... -> ziptestdata/...
-    ...
-    """
-    suffixes = '01', '02'
-    tuple(map(generate, suffixes))
-
-
-def generate(suffix):
-    root = pathlib.Path(__file__).parent.relative_to(os.getcwd())
-    zfpath = root / f'zipdata{suffix}/ziptestdata.zip'
-    with zipfile.ZipFile(zfpath, 'w') as zf:
-        for src, rel in walk(root / f'data{suffix}'):
-            dst = 'ziptestdata' / pathlib.PurePosixPath(rel.as_posix())
-            print(src, '->', dst)
-            zf.write(src, dst)
-
-
-def walk(datapath):
-    for dirpath, dirnames, filenames in os.walk(datapath):
-        with contextlib.suppress(KeyError):
-            dirnames.remove('__pycache__')
-        for filename in filenames:
-            res = pathlib.Path(dirpath) / filename
-            rel = res.relative_to(datapath)
-            yield res, rel
-
-
-__name__ == '__main__' and main()
diff --git a/libs/importlib_resources/tests/util.py b/libs/importlib_resources/tests/util.py
deleted file mode 100644
index c6d83e4bd..000000000
--- a/libs/importlib_resources/tests/util.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import abc
-import importlib
-import io
-import sys
-import types
-from pathlib import Path, PurePath
-
-from . import data01
-from . import zipdata01
-from ..abc import ResourceReader
-from ._compat import import_helper
-
-
-from importlib.machinery import ModuleSpec
-
-
-class Reader(ResourceReader):
-    def __init__(self, **kwargs):
-        vars(self).update(kwargs)
-
-    def get_resource_reader(self, package):
-        return self
-
-    def open_resource(self, path):
-        self._path = path
-        if isinstance(self.file, Exception):
-            raise self.file
-        return self.file
-
-    def resource_path(self, path_):
-        self._path = path_
-        if isinstance(self.path, Exception):
-            raise self.path
-        return self.path
-
-    def is_resource(self, path_):
-        self._path = path_
-        if isinstance(self.path, Exception):
-            raise self.path
-
-        def part(entry):
-            return entry.split('/')
-
-        return any(
-            len(parts) == 1 and parts[0] == path_ for parts in map(part, self._contents)
-        )
-
-    def contents(self):
-        if isinstance(self.path, Exception):
-            raise self.path
-        yield from self._contents
-
-
-def create_package_from_loader(loader, is_package=True):
-    name = 'testingpackage'
-    module = types.ModuleType(name)
-    spec = ModuleSpec(name, loader, origin='does-not-exist', is_package=is_package)
-    module.__spec__ = spec
-    module.__loader__ = loader
-    return module
-
-
-def create_package(file=None, path=None, is_package=True, contents=()):
-    return create_package_from_loader(
-        Reader(file=file, path=path, _contents=contents),
-        is_package,
-    )
-
-
-class CommonTests(metaclass=abc.ABCMeta):
-    """
-    Tests shared by test_open, test_path, and test_read.
-    """
-
-    @abc.abstractmethod
-    def execute(self, package, path):
-        """
-        Call the pertinent legacy API function (e.g. open_text, path)
-        on package and path.
-        """
-
-    def test_package_name(self):
-        # Passing in the package name should succeed.
-        self.execute(data01.__name__, 'utf-8.file')
-
-    def test_package_object(self):
-        # Passing in the package itself should succeed.
-        self.execute(data01, 'utf-8.file')
-
-    def test_string_path(self):
-        # Passing in a string for the path should succeed.
-        path = 'utf-8.file'
-        self.execute(data01, path)
-
-    def test_pathlib_path(self):
-        # Passing in a pathlib.PurePath object for the path should succeed.
-        path = PurePath('utf-8.file')
-        self.execute(data01, path)
-
-    def test_importing_module_as_side_effect(self):
-        # The anchor package can already be imported.
-        del sys.modules[data01.__name__]
-        self.execute(data01.__name__, 'utf-8.file')
-
-    def test_non_package_by_name(self):
-        # The anchor package cannot be a module.
-        with self.assertRaises(TypeError):
-            self.execute(__name__, 'utf-8.file')
-
-    def test_non_package_by_package(self):
-        # The anchor package cannot be a module.
-        with self.assertRaises(TypeError):
-            module = sys.modules['importlib_resources.tests.util']
-            self.execute(module, 'utf-8.file')
-
-    def test_missing_path(self):
-        # Attempting to open or read or request the path for a
-        # non-existent path should succeed if open_resource
-        # can return a viable data stream.
-        bytes_data = io.BytesIO(b'Hello, world!')
-        package = create_package(file=bytes_data, path=FileNotFoundError())
-        self.execute(package, 'utf-8.file')
-        self.assertEqual(package.__loader__._path, 'utf-8.file')
-
-    def test_extant_path(self):
-        # Attempting to open or read or request the path when the
-        # path does exist should still succeed. Does not assert
-        # anything about the result.
-        bytes_data = io.BytesIO(b'Hello, world!')
-        # any path that exists
-        path = __file__
-        package = create_package(file=bytes_data, path=path)
-        self.execute(package, 'utf-8.file')
-        self.assertEqual(package.__loader__._path, 'utf-8.file')
-
-    def test_useless_loader(self):
-        package = create_package(file=FileNotFoundError(), path=FileNotFoundError())
-        with self.assertRaises(FileNotFoundError):
-            self.execute(package, 'utf-8.file')
-
-
-class ZipSetupBase:
-    ZIP_MODULE = None
-
-    @classmethod
-    def setUpClass(cls):
-        data_path = Path(cls.ZIP_MODULE.__file__)
-        data_dir = data_path.parent
-        cls._zip_path = str(data_dir / 'ziptestdata.zip')
-        sys.path.append(cls._zip_path)
-        cls.data = importlib.import_module('ziptestdata')
-
-    @classmethod
-    def tearDownClass(cls):
-        try:
-            sys.path.remove(cls._zip_path)
-        except ValueError:
-            pass
-
-        try:
-            del sys.path_importer_cache[cls._zip_path]
-            del sys.modules[cls.data.__name__]
-        except KeyError:
-            pass
-
-        try:
-            del cls.data
-            del cls._zip_path
-        except AttributeError:
-            pass
-
-    def setUp(self):
-        modules = import_helper.modules_setup()
-        self.addCleanup(import_helper.modules_cleanup, *modules)
-
-
-class ZipSetup(ZipSetupBase):
-    ZIP_MODULE = zipdata01  # type: ignore
diff --git a/libs/importlib_resources/tests/zipdata01/__init__.py b/libs/importlib_resources/tests/zipdata01/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/libs/importlib_resources/tests/zipdata01/__init__.py
+++ /dev/null
diff --git a/libs/importlib_resources/tests/zipdata01/ziptestdata.zip b/libs/importlib_resources/tests/zipdata01/ziptestdata.zip
deleted file mode 100644
index 9a3bb0739..000000000
--- a/libs/importlib_resources/tests/zipdata01/ziptestdata.zip
+++ /dev/null
diff --git a/libs/importlib_resources/tests/zipdata02/__init__.py b/libs/importlib_resources/tests/zipdata02/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/libs/importlib_resources/tests/zipdata02/__init__.py
+++ /dev/null
diff --git a/libs/importlib_resources/tests/zipdata02/ziptestdata.zip b/libs/importlib_resources/tests/zipdata02/ziptestdata.zip
deleted file mode 100644
index d63ff512d..000000000
--- a/libs/importlib_resources/tests/zipdata02/ziptestdata.zip
+++ /dev/null