GH-130614: pathlib ABCs: delete vestigial `test_pathlib_abc` module (#131215)

Remove the `test.test_pathlib.test_pathlib_abc` test module, which was
hollowed out in previous commits. Its few remaining tests are most relevant
to `PurePath` and `Path`, so we move them into `test_pathlib`.

2 files changed, 115 insertions, 395 deletions

diff --git a/Lib/test/test_pathlib/test_pathlib.py b/Lib/test/test_pathlib/test_pathlib.py
index 51814ae970d..36fb62e53e1 100644
--- a/Lib/test/test_pathlib/test_pathlib.py
+++ b/Lib/test/test_pathlib/test_pathlib.py
@@ -20,9 +20,6 @@ from test.support import is_emscripten, is_wasi
 from test.support import infinite_recursion
 from test.support import os_helper
 from test.support.os_helper import TESTFN, FakePath
-from test.test_pathlib import test_pathlib_abc
-from test.test_pathlib.test_pathlib_abc import needs_posix, needs_windows
-
 try:
     import fcntl
 except ImportError:
@@ -56,7 +53,20 @@ def patch_replace(old_test):
     return new_test
 
 
+_tests_needing_posix = set()
+_tests_needing_windows = set()
 _tests_needing_symlinks = set()
+
+def needs_posix(fn):
+    """Decorator that marks a test as requiring a POSIX-flavoured path class."""
+    _tests_needing_posix.add(fn.__name__)
+    return fn
+
+def needs_windows(fn):
+    """Decorator that marks a test as requiring a Windows-flavoured path class."""
+    _tests_needing_windows.add(fn.__name__)
+    return fn
+
 def needs_symlinks(fn):
     """Decorator that marks a test as requiring a path class that supports symlinks."""
     _tests_needing_symlinks.add(fn.__name__)
@@ -74,7 +84,7 @@ class UnsupportedOperationTest(unittest.TestCase):
 # Tests for the pure classes.
 #
 
-class PurePathTest(test_pathlib_abc.JoinablePathTest):
+class PurePathTest(unittest.TestCase):
     cls = pathlib.PurePath
 
     # Make sure any symbolic links in the base test path are resolved.
@@ -96,6 +106,72 @@ class PurePathTest(test_pathlib_abc.JoinablePathTest):
             ],
     }
 
+    def setUp(self):
+        name = self.id().split('.')[-1]
+        if name in _tests_needing_posix and self.cls.parser is not posixpath:
+            self.skipTest('requires POSIX-flavoured path class')
+        if name in _tests_needing_windows and self.cls.parser is posixpath:
+            self.skipTest('requires Windows-flavoured path class')
+        p = self.cls('a')
+        self.parser = p.parser
+        self.sep = self.parser.sep
+        self.altsep = self.parser.altsep
+
+    def _check_str_subclass(self, *args):
+        # Issue #21127: it should be possible to construct a PurePath object
+        # from a str subclass instance, and it then gets converted to
+        # a pure str object.
+        class StrSubclass(str):
+            pass
+        P = self.cls
+        p = P(*(StrSubclass(x) for x in args))
+        self.assertEqual(p, P(*args))
+        for part in p.parts:
+            self.assertIs(type(part), str)
+
+    def test_str_subclass_common(self):
+        self._check_str_subclass('')
+        self._check_str_subclass('.')
+        self._check_str_subclass('a')
+        self._check_str_subclass('a/b.txt')
+        self._check_str_subclass('/a/b.txt')
+
+    @needs_windows
+    def test_str_subclass_windows(self):
+        self._check_str_subclass('.\\a:b')
+        self._check_str_subclass('c:')
+        self._check_str_subclass('c:a')
+        self._check_str_subclass('c:a\\b.txt')
+        self._check_str_subclass('c:\\')
+        self._check_str_subclass('c:\\a')
+        self._check_str_subclass('c:\\a\\b.txt')
+        self._check_str_subclass('\\\\some\\share')
+        self._check_str_subclass('\\\\some\\share\\a')
+        self._check_str_subclass('\\\\some\\share\\a\\b.txt')
+
+    def _check_str(self, expected, args):
+        p = self.cls(*args)
+        self.assertEqual(str(p), expected.replace('/', self.sep))
+
+    def test_str_common(self):
+        # Canonicalized paths roundtrip.
+        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
+            self._check_str(pathstr, (pathstr,))
+        # Other tests for str() are in test_equivalences().
+
+    @needs_windows
+    def test_str_windows(self):
+        p = self.cls('a/b/c')
+        self.assertEqual(str(p), 'a\\b\\c')
+        p = self.cls('c:/a/b/c')
+        self.assertEqual(str(p), 'c:\\a\\b\\c')
+        p = self.cls('//a/b')
+        self.assertEqual(str(p), '\\\\a\\b\\')
+        p = self.cls('//a/b/c')
+        self.assertEqual(str(p), '\\\\a\\b\\c')
+        p = self.cls('//a/b/c/d')
+        self.assertEqual(str(p), '\\\\a\\b\\c\\d')
+
     def test_concrete_class(self):
         if self.cls is pathlib.PurePath:
             expected = pathlib.PureWindowsPath if os.name == 'nt' else pathlib.PurePosixPath
@@ -1032,7 +1108,7 @@ class PurePathSubclassTest(PurePathTest):
 # Tests for the concrete classes.
 #
 
-class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
+class PathTest(PurePathTest):
     """Tests for the FS-accessing functionalities of the Path classes."""
     cls = pathlib.Path
     can_symlink = os_helper.can_symlink()
@@ -1042,8 +1118,6 @@ class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
         if name in _tests_needing_symlinks and not self.can_symlink:
             self.skipTest('requires symlinks')
         super().setUp()
-
-    def createTestHierarchy(self):
         os.mkdir(self.base)
         os.mkdir(os.path.join(self.base, 'dirA'))
         os.mkdir(os.path.join(self.base, 'dirB'))
@@ -1082,6 +1156,15 @@ class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
         os.chmod(os.path.join(self.base, 'dirE'), 0o777)
         os_helper.rmtree(self.base)
 
+    def assertFileNotFound(self, func, *args, **kwargs):
+        with self.assertRaises(FileNotFoundError) as cm:
+            func(*args, **kwargs)
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+
+    def assertEqualNormCase(self, path_a, path_b):
+        normcase = self.parser.normcase
+        self.assertEqual(normcase(path_a), normcase(path_b))
+
     def tempdir(self):
         d = os_helper._longpath(tempfile.mkdtemp(suffix='-dirD',
                                                  dir=os.getcwd()))
@@ -2747,6 +2830,24 @@ class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
         expected = { P(self.base, 'linkB', q) for q in ['fileB', 'linkD'] }
         self.assertEqual(paths, expected)
 
+    @needs_posix
+    def test_glob_posix(self):
+        P = self.cls
+        p = P(self.base)
+        q = p / "FILEa"
+        given = set(p.glob("FILEa"))
+        expect = {q} if q.info.exists() else set()
+        self.assertEqual(given, expect)
+        self.assertEqual(set(p.glob("FILEa*")), set())
+
+    @needs_windows
+    def test_glob_windows(self):
+        P = self.cls
+        p = P(self.base)
+        self.assertEqual(set(p.glob("FILEa")), { P(self.base, "fileA") })
+        self.assertEqual(set(p.glob("*a\\")), { P(self.base, "dirA/") })
+        self.assertEqual(set(p.glob("F*a")), { P(self.base, "fileA") })
+
     def test_glob_empty_pattern(self):
         p = self.cls('')
         with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
@@ -3335,7 +3436,7 @@ class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
             P('c:/').group()
 
 
-class PathWalkTest(test_pathlib_abc.ReadablePathWalkTest):
+class PathWalkTest(unittest.TestCase):
     cls = pathlib.Path
     base = PathTest.base
     can_symlink = PathTest.can_symlink
@@ -3344,9 +3445,13 @@ class PathWalkTest(test_pathlib_abc.ReadablePathWalkTest):
         name = self.id().split('.')[-1]
         if name in _tests_needing_symlinks and not self.can_symlink:
             self.skipTest('requires symlinks')
-        super().setUp()
+        self.walk_path = self.cls(self.base, "TEST1")
+        self.sub1_path = self.walk_path / "SUB1"
+        self.sub11_path = self.sub1_path / "SUB11"
+        self.sub2_path = self.walk_path / "SUB2"
+        self.link_path = self.sub2_path / "link"
+        self.sub2_tree = (self.sub2_path, [], ["tmp3"])
 
-    def createTestHierarchy(self):
         # Build:
         #     TESTFN/
         #       TEST1/              a file kid and two directory kids
diff --git a/Lib/test/test_pathlib/test_pathlib_abc.py b/Lib/test/test_pathlib/test_pathlib_abc.py
deleted file mode 100644
index b6e0e36eb87..00000000000
--- a/Lib/test/test_pathlib/test_pathlib_abc.py
+++ /dev/null
@@ -1,385 +0,0 @@
-import io
-import os
-import errno
-import unittest
-
-from pathlib.types import _JoinablePath, _ReadablePath, _WritablePath
-import posixpath
-
-from test.support.os_helper import TESTFN
-
-
-_tests_needing_posix = set()
-_tests_needing_windows = set()
-
-
-def needs_posix(fn):
-    """Decorator that marks a test as requiring a POSIX-flavoured path class."""
-    _tests_needing_posix.add(fn.__name__)
-    return fn
-
-def needs_windows(fn):
-    """Decorator that marks a test as requiring a Windows-flavoured path class."""
-    _tests_needing_windows.add(fn.__name__)
-    return fn
-
-
-#
-# Tests for the pure classes.
-#
-
-
-class DummyJoinablePath(_JoinablePath):
-    __slots__ = ('_segments',)
-
-    parser = posixpath
-
-    def __init__(self, *segments):
-        self._segments = segments
-
-    def __str__(self):
-        if self._segments:
-            return self.parser.join(*self._segments)
-        return ''
-
-    def __eq__(self, other):
-        if not isinstance(other, DummyJoinablePath):
-            return NotImplemented
-        return str(self) == str(other)
-
-    def __hash__(self):
-        return hash(str(self))
-
-    def __repr__(self):
-        return "{}({!r})".format(self.__class__.__name__, str(self))
-
-    def with_segments(self, *pathsegments):
-        return type(self)(*pathsegments)
-
-
-class JoinablePathTest(unittest.TestCase):
-    cls = DummyJoinablePath
-
-    # Use a base path that's unrelated to any real filesystem path.
-    base = f'/this/path/kills/fascists/{TESTFN}'
-
-    def setUp(self):
-        name = self.id().split('.')[-1]
-        if name in _tests_needing_posix and self.cls.parser is not posixpath:
-            self.skipTest('requires POSIX-flavoured path class')
-        if name in _tests_needing_windows and self.cls.parser is posixpath:
-            self.skipTest('requires Windows-flavoured path class')
-        p = self.cls('a')
-        self.parser = p.parser
-        self.sep = self.parser.sep
-        self.altsep = self.parser.altsep
-
-    def _check_str_subclass(self, *args):
-        # Issue #21127: it should be possible to construct a PurePath object
-        # from a str subclass instance, and it then gets converted to
-        # a pure str object.
-        class StrSubclass(str):
-            pass
-        P = self.cls
-        p = P(*(StrSubclass(x) for x in args))
-        self.assertEqual(p, P(*args))
-        for part in p.parts:
-            self.assertIs(type(part), str)
-
-    def test_str_subclass_common(self):
-        self._check_str_subclass('')
-        self._check_str_subclass('.')
-        self._check_str_subclass('a')
-        self._check_str_subclass('a/b.txt')
-        self._check_str_subclass('/a/b.txt')
-
-    @needs_windows
-    def test_str_subclass_windows(self):
-        self._check_str_subclass('.\\a:b')
-        self._check_str_subclass('c:')
-        self._check_str_subclass('c:a')
-        self._check_str_subclass('c:a\\b.txt')
-        self._check_str_subclass('c:\\')
-        self._check_str_subclass('c:\\a')
-        self._check_str_subclass('c:\\a\\b.txt')
-        self._check_str_subclass('\\\\some\\share')
-        self._check_str_subclass('\\\\some\\share\\a')
-        self._check_str_subclass('\\\\some\\share\\a\\b.txt')
-
-    def _check_str(self, expected, args):
-        p = self.cls(*args)
-        self.assertEqual(str(p), expected.replace('/', self.sep))
-
-    def test_str_common(self):
-        # Canonicalized paths roundtrip.
-        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
-            self._check_str(pathstr, (pathstr,))
-        # Other tests for str() are in test_equivalences().
-
-    @needs_windows
-    def test_str_windows(self):
-        p = self.cls('a/b/c')
-        self.assertEqual(str(p), 'a\\b\\c')
-        p = self.cls('c:/a/b/c')
-        self.assertEqual(str(p), 'c:\\a\\b\\c')
-        p = self.cls('//a/b')
-        self.assertEqual(str(p), '\\\\a\\b\\')
-        p = self.cls('//a/b/c')
-        self.assertEqual(str(p), '\\\\a\\b\\c')
-        p = self.cls('//a/b/c/d')
-        self.assertEqual(str(p), '\\\\a\\b\\c\\d')
-
-
-#
-# Tests for the virtual classes.
-#
-
-
-class DummyWritablePathIO(io.BytesIO):
-    """
-    Used by DummyWritablePath to implement `__open_wb__()`
-    """
-
-    def __init__(self, files, path):
-        super().__init__()
-        self.files = files
-        self.path = path
-
-    def close(self):
-        self.files[self.path] = self.getvalue()
-        super().close()
-
-
-class DummyReadablePathInfo:
-    __slots__ = ('_is_dir', '_is_file')
-
-    def __init__(self, is_dir, is_file):
-        self._is_dir = is_dir
-        self._is_file = is_file
-
-    def exists(self, *, follow_symlinks=True):
-        return self._is_dir or self._is_file
-
-    def is_dir(self, *, follow_symlinks=True):
-        return self._is_dir
-
-    def is_file(self, *, follow_symlinks=True):
-        return self._is_file
-
-    def is_symlink(self):
-        return False
-
-
-class DummyReadablePath(_ReadablePath, DummyJoinablePath):
-    """
-    Simple implementation of DummyReadablePath that keeps files and
-    directories in memory.
-    """
-    __slots__ = ('_info')
-
-    _files = {}
-    _directories = {}
-    parser = posixpath
-
-    def __init__(self, *segments):
-        super().__init__(*segments)
-        self._info = None
-
-    @property
-    def info(self):
-        if self._info is None:
-            path_str = str(self)
-            self._info = DummyReadablePathInfo(
-                is_dir=path_str.rstrip('/') in self._directories,
-                is_file=path_str in self._files)
-        return self._info
-
-    def __open_rb__(self, buffering=-1):
-        path = str(self)
-        if path in self._directories:
-            raise IsADirectoryError(errno.EISDIR, "Is a directory", path)
-        elif path not in self._files:
-            raise FileNotFoundError(errno.ENOENT, "File not found", path)
-        return io.BytesIO(self._files[path])
-
-    def iterdir(self):
-        path = str(self).rstrip('/')
-        if path in self._files:
-            raise NotADirectoryError(errno.ENOTDIR, "Not a directory", path)
-        elif path in self._directories:
-            return iter([self / name for name in self._directories[path]])
-        else:
-            raise FileNotFoundError(errno.ENOENT, "File not found", path)
-
-    def readlink(self):
-        raise NotImplementedError
-
-
-class DummyWritablePath(_WritablePath, DummyJoinablePath):
-    __slots__ = ()
-
-    def __open_wb__(self, buffering=-1):
-        path = str(self)
-        if path in self._directories:
-            raise IsADirectoryError(errno.EISDIR, "Is a directory", path)
-        parent, name = posixpath.split(path)
-        if parent not in self._directories:
-            raise FileNotFoundError(errno.ENOENT, "File not found", parent)
-        self._files[path] = b''
-        self._directories[parent].add(name)
-        return DummyWritablePathIO(self._files, path)
-
-    def mkdir(self):
-        path = str(self)
-        parent = str(self.parent)
-        if path in self._directories:
-            raise FileExistsError(errno.EEXIST, "File exists", path)
-        try:
-            if self.name:
-                self._directories[parent].add(self.name)
-            self._directories[path] = set()
-        except KeyError:
-            raise FileNotFoundError(errno.ENOENT, "File not found", parent) from None
-
-    def symlink_to(self, target, target_is_directory=False):
-        raise NotImplementedError
-
-
-class ReadablePathTest(JoinablePathTest):
-    """Tests for ReadablePathTest methods that use stat(), open() and iterdir()."""
-
-    cls = DummyReadablePath
-    can_symlink = False
-
-    # (self.base)
-    #  |
-    #  |-- brokenLink -> non-existing
-    #  |-- dirA
-    #  |   `-- linkC -> ../dirB
-    #  |-- dirB
-    #  |   |-- fileB
-    #  |   `-- linkD -> ../dirB
-    #  |-- dirC
-    #  |   |-- dirD
-    #  |   |   `-- fileD
-    #  |   `-- fileC
-    #  |   `-- novel.txt
-    #  |-- dirE  # No permissions
-    #  |-- fileA
-    #  |-- linkA -> fileA
-    #  |-- linkB -> dirB
-    #  `-- brokenLinkLoop -> brokenLinkLoop
-    #
-
-    def setUp(self):
-        super().setUp()
-        self.createTestHierarchy()
-
-    def createTestHierarchy(self):
-        cls = self.cls
-        cls._files = {
-            f'{self.base}/fileA': b'this is file A\n',
-            f'{self.base}/dirB/fileB': b'this is file B\n',
-            f'{self.base}/dirC/fileC': b'this is file C\n',
-            f'{self.base}/dirC/dirD/fileD': b'this is file D\n',
-            f'{self.base}/dirC/novel.txt': b'this is a novel\n',
-        }
-        cls._directories = {
-            f'{self.base}': {'fileA', 'dirA', 'dirB', 'dirC', 'dirE'},
-            f'{self.base}/dirA': set(),
-            f'{self.base}/dirB': {'fileB'},
-            f'{self.base}/dirC': {'fileC', 'dirD', 'novel.txt'},
-            f'{self.base}/dirC/dirD': {'fileD'},
-            f'{self.base}/dirE': set(),
-        }
-
-    def tearDown(self):
-        cls = self.cls
-        cls._files.clear()
-        cls._directories.clear()
-
-    def tempdir(self):
-        path = self.cls(self.base).with_name('tmp-dirD')
-        path.mkdir()
-        return path
-
-    def assertFileNotFound(self, func, *args, **kwargs):
-        with self.assertRaises(FileNotFoundError) as cm:
-            func(*args, **kwargs)
-        self.assertEqual(cm.exception.errno, errno.ENOENT)
-
-    def assertEqualNormCase(self, path_a, path_b):
-        normcase = self.parser.normcase
-        self.assertEqual(normcase(path_a), normcase(path_b))
-
-    @needs_posix
-    def test_glob_posix(self):
-        P = self.cls
-        p = P(self.base)
-        q = p / "FILEa"
-        given = set(p.glob("FILEa"))
-        expect = {q} if q.info.exists() else set()
-        self.assertEqual(given, expect)
-        self.assertEqual(set(p.glob("FILEa*")), set())
-
-    @needs_windows
-    def test_glob_windows(self):
-        P = self.cls
-        p = P(self.base)
-        self.assertEqual(set(p.glob("FILEa")), { P(self.base, "fileA") })
-        self.assertEqual(set(p.glob("*a\\")), { P(self.base, "dirA/") })
-        self.assertEqual(set(p.glob("F*a")), { P(self.base, "fileA") })
-
-
-class WritablePathTest(JoinablePathTest):
-    cls = DummyWritablePath
-
-
-class DummyRWPath(DummyWritablePath, DummyReadablePath):
-    __slots__ = ()
-
-
-class RWPathTest(WritablePathTest, ReadablePathTest):
-    cls = DummyRWPath
-    can_symlink = False
-
-
-class ReadablePathWalkTest(unittest.TestCase):
-    cls = DummyReadablePath
-    base = ReadablePathTest.base
-    can_symlink = False
-
-    def setUp(self):
-        self.walk_path = self.cls(self.base, "TEST1")
-        self.sub1_path = self.walk_path / "SUB1"
-        self.sub11_path = self.sub1_path / "SUB11"
-        self.sub2_path = self.walk_path / "SUB2"
-        self.link_path = self.sub2_path / "link"
-        self.sub2_tree = (self.sub2_path, [], ["tmp3"])
-        self.createTestHierarchy()
-
-    def createTestHierarchy(self):
-        cls = self.cls
-        cls._files = {
-            f'{self.base}/TEST1/tmp1': b'this is tmp1\n',
-            f'{self.base}/TEST1/SUB1/tmp2': b'this is tmp2\n',
-            f'{self.base}/TEST1/SUB2/tmp3': b'this is tmp3\n',
-            f'{self.base}/TEST2/tmp4': b'this is tmp4\n',
-        }
-        cls._directories = {
-            f'{self.base}': {'TEST1', 'TEST2'},
-            f'{self.base}/TEST1': {'SUB1', 'SUB2', 'tmp1'},
-            f'{self.base}/TEST1/SUB1': {'SUB11', 'tmp2'},
-            f'{self.base}/TEST1/SUB1/SUB11': set(),
-            f'{self.base}/TEST1/SUB2': {'tmp3'},
-            f'{self.base}/TEST2': {'tmp4'},
-        }
-
-    def tearDown(self):
-        cls = self.cls
-        cls._files.clear()
-        cls._directories.clear()
-
-
-if __name__ == "__main__":
-    unittest.main()