mirror of
https://github.com/python/cpython.git
synced 2026-01-06 15:32:22 +00:00
GH-127381: pathlib ABCs: remove uncommon PurePathBase methods (#127853)
Remove `PurePathBase.relative_to()` and `is_relative_to()` because they don't account for *other* being an entirely different kind of path, and they can't use `__eq__()` because it's not on the `PurePathBase` interface. Remove `PurePathBase.drive`, `root`, `is_absolute()` and `as_posix()`. These are all too specific to local filesystems.
This commit is contained in:
Barney Gale
GitHub
parent
c78729f2df
commit
ef63cca494
5 changed files with 365 additions and 433 deletions
|
|
@ -205,21 +205,6 @@ def __str__(self):
|
|||
passing to system calls."""
|
||||
raise NotImplementedError
|
||||
|
||||
def as_posix(self):
|
||||
"""Return the string representation of the path with forward (/)
|
||||
slashes."""
|
||||
return str(self).replace(self.parser.sep, '/')
|
||||
|
||||
@property
|
||||
def drive(self):
|
||||
"""The drive prefix (letter or UNC path), if any."""
|
||||
return self.parser.splitdrive(self.anchor)[0]
|
||||
|
||||
@property
|
||||
def root(self):
|
||||
"""The root of the path, if any."""
|
||||
return self.parser.splitdrive(self.anchor)[1]
|
||||
|
||||
@property
|
||||
def anchor(self):
|
||||
"""The concatenation of the drive and root, or ''."""
|
||||
|
|
@ -291,51 +276,6 @@ def with_suffix(self, suffix):
|
|||
else:
|
||||
return self.with_name(stem + suffix)
|
||||
|
||||
def relative_to(self, other, *, walk_up=False):
|
||||
"""Return the relative path to another path identified by the passed
|
||||
arguments. If the operation is not possible (because this is not
|
||||
related to the other path), raise ValueError.
|
||||
|
||||
The *walk_up* parameter controls whether `..` may be used to resolve
|
||||
the path.
|
||||
"""
|
||||
if not isinstance(other, PurePathBase):
|
||||
other = self.with_segments(other)
|
||||
anchor0, parts0 = _explode_path(self)
|
||||
anchor1, parts1 = _explode_path(other)
|
||||
if anchor0 != anchor1:
|
||||
raise ValueError(f"{str(self)!r} and {str(other)!r} have different anchors")
|
||||
while parts0 and parts1 and parts0[-1] == parts1[-1]:
|
||||
parts0.pop()
|
||||
parts1.pop()
|
||||
for part in parts1:
|
||||
if not part or part == '.':
|
||||
pass
|
||||
elif not walk_up:
|
||||
raise ValueError(f"{str(self)!r} is not in the subpath of {str(other)!r}")
|
||||
elif part == '..':
|
||||
raise ValueError(f"'..' segment in {str(other)!r} cannot be walked")
|
||||
else:
|
||||
parts0.append('..')
|
||||
return self.with_segments(*reversed(parts0))
|
||||
|
||||
def is_relative_to(self, other):
|
||||
"""Return True if the path is relative to another path or False.
|
||||
"""
|
||||
if not isinstance(other, PurePathBase):
|
||||
other = self.with_segments(other)
|
||||
anchor0, parts0 = _explode_path(self)
|
||||
anchor1, parts1 = _explode_path(other)
|
||||
if anchor0 != anchor1:
|
||||
return False
|
||||
while parts0 and parts1 and parts0[-1] == parts1[-1]:
|
||||
parts0.pop()
|
||||
parts1.pop()
|
||||
for part in parts1:
|
||||
if part and part != '.':
|
||||
return False
|
||||
return True
|
||||
|
||||
@property
|
||||
def parts(self):
|
||||
"""An object providing sequence-like access to the
|
||||
|
|
@ -387,11 +327,6 @@ def parents(self):
|
|||
parent = split(path)[0]
|
||||
return tuple(parents)
|
||||
|
||||
def is_absolute(self):
|
||||
"""True if the path is absolute (has both a root and, if applicable,
|
||||
a drive)."""
|
||||
return self.parser.isabs(str(self))
|
||||
|
||||
def match(self, path_pattern, *, case_sensitive=None):
|
||||
"""
|
||||
Return True if this path matches the given pattern. If the pattern is
|
||||
|
|
|
|||
|
|
@ -437,6 +437,11 @@ def _parse_pattern(cls, pattern):
|
|||
parts.append('')
|
||||
return parts
|
||||
|
||||
def as_posix(self):
|
||||
"""Return the string representation of the path with forward (/)
|
||||
slashes."""
|
||||
return str(self).replace(self.parser.sep, '/')
|
||||
|
||||
@property
|
||||
def _raw_path(self):
|
||||
paths = self._raw_paths
|
||||
|
|
|
|||
|
|
@ -15,7 +15,5 @@ class Parser(Protocol):
|
|||
|
||||
sep: str
|
||||
def split(self, path: str) -> tuple[str, str]: ...
|
||||
def splitdrive(self, path: str) -> tuple[str, str]: ...
|
||||
def splitext(self, path: str) -> tuple[str, str]: ...
|
||||
def normcase(self, path: str) -> str: ...
|
||||
def isabs(self, path: str) -> bool: ...
|
||||
|
|
|
|||
|
|
@ -270,6 +270,12 @@ def test_as_bytes_common(self):
|
|||
P = self.cls
|
||||
self.assertEqual(bytes(P('a/b')), b'a' + sep + b'b')
|
||||
|
||||
def test_as_posix_common(self):
|
||||
P = self.cls
|
||||
for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
|
||||
self.assertEqual(P(pathstr).as_posix(), pathstr)
|
||||
# Other tests for as_posix() are in test_equivalences().
|
||||
|
||||
def test_eq_common(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('a/b'), P('a/b'))
|
||||
|
|
@ -349,6 +355,51 @@ def test_repr_roundtrips(self):
|
|||
self.assertEqual(q, p)
|
||||
self.assertEqual(repr(q), r)
|
||||
|
||||
def test_drive_common(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('a/b').drive, '')
|
||||
self.assertEqual(P('/a/b').drive, '')
|
||||
self.assertEqual(P('').drive, '')
|
||||
|
||||
@needs_windows
|
||||
def test_drive_windows(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('c:').drive, 'c:')
|
||||
self.assertEqual(P('c:a/b').drive, 'c:')
|
||||
self.assertEqual(P('c:/').drive, 'c:')
|
||||
self.assertEqual(P('c:/a/b/').drive, 'c:')
|
||||
self.assertEqual(P('//a/b').drive, '\\\\a\\b')
|
||||
self.assertEqual(P('//a/b/').drive, '\\\\a\\b')
|
||||
self.assertEqual(P('//a/b/c/d').drive, '\\\\a\\b')
|
||||
self.assertEqual(P('./c:a').drive, '')
|
||||
|
||||
|
||||
def test_root_common(self):
|
||||
P = self.cls
|
||||
sep = self.sep
|
||||
self.assertEqual(P('').root, '')
|
||||
self.assertEqual(P('a/b').root, '')
|
||||
self.assertEqual(P('/').root, sep)
|
||||
self.assertEqual(P('/a/b').root, sep)
|
||||
|
||||
@needs_posix
|
||||
def test_root_posix(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('/a/b').root, '/')
|
||||
# POSIX special case for two leading slashes.
|
||||
self.assertEqual(P('//a/b').root, '//')
|
||||
|
||||
@needs_windows
|
||||
def test_root_windows(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('c:').root, '')
|
||||
self.assertEqual(P('c:a/b').root, '')
|
||||
self.assertEqual(P('c:/').root, '\\')
|
||||
self.assertEqual(P('c:/a/b/').root, '\\')
|
||||
self.assertEqual(P('//a/b').root, '\\')
|
||||
self.assertEqual(P('//a/b/').root, '\\')
|
||||
self.assertEqual(P('//a/b/c/d').root, '\\')
|
||||
|
||||
def test_name_empty(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('').name, '')
|
||||
|
|
@ -547,6 +598,311 @@ def assertOrderedEqual(a, b):
|
|||
self.assertFalse(p < q)
|
||||
self.assertFalse(p > q)
|
||||
|
||||
@needs_posix
|
||||
def test_is_absolute_posix(self):
|
||||
P = self.cls
|
||||
self.assertFalse(P('').is_absolute())
|
||||
self.assertFalse(P('a').is_absolute())
|
||||
self.assertFalse(P('a/b/').is_absolute())
|
||||
self.assertTrue(P('/').is_absolute())
|
||||
self.assertTrue(P('/a').is_absolute())
|
||||
self.assertTrue(P('/a/b/').is_absolute())
|
||||
self.assertTrue(P('//a').is_absolute())
|
||||
self.assertTrue(P('//a/b').is_absolute())
|
||||
|
||||
@needs_windows
|
||||
def test_is_absolute_windows(self):
|
||||
P = self.cls
|
||||
# Under NT, only paths with both a drive and a root are absolute.
|
||||
self.assertFalse(P().is_absolute())
|
||||
self.assertFalse(P('a').is_absolute())
|
||||
self.assertFalse(P('a/b/').is_absolute())
|
||||
self.assertFalse(P('/').is_absolute())
|
||||
self.assertFalse(P('/a').is_absolute())
|
||||
self.assertFalse(P('/a/b/').is_absolute())
|
||||
self.assertFalse(P('c:').is_absolute())
|
||||
self.assertFalse(P('c:a').is_absolute())
|
||||
self.assertFalse(P('c:a/b/').is_absolute())
|
||||
self.assertTrue(P('c:/').is_absolute())
|
||||
self.assertTrue(P('c:/a').is_absolute())
|
||||
self.assertTrue(P('c:/a/b/').is_absolute())
|
||||
# UNC paths are absolute by definition.
|
||||
self.assertTrue(P('//').is_absolute())
|
||||
self.assertTrue(P('//a').is_absolute())
|
||||
self.assertTrue(P('//a/b').is_absolute())
|
||||
self.assertTrue(P('//a/b/').is_absolute())
|
||||
self.assertTrue(P('//a/b/c').is_absolute())
|
||||
self.assertTrue(P('//a/b/c/d').is_absolute())
|
||||
self.assertTrue(P('//?/UNC/').is_absolute())
|
||||
self.assertTrue(P('//?/UNC/spam').is_absolute())
|
||||
|
||||
def test_relative_to_common(self):
|
||||
P = self.cls
|
||||
p = P('a/b')
|
||||
self.assertRaises(TypeError, p.relative_to)
|
||||
self.assertRaises(TypeError, p.relative_to, b'a')
|
||||
self.assertEqual(p.relative_to(P('')), P('a/b'))
|
||||
self.assertEqual(p.relative_to(''), P('a/b'))
|
||||
self.assertEqual(p.relative_to(P('a')), P('b'))
|
||||
self.assertEqual(p.relative_to('a'), P('b'))
|
||||
self.assertEqual(p.relative_to('a/'), P('b'))
|
||||
self.assertEqual(p.relative_to(P('a/b')), P(''))
|
||||
self.assertEqual(p.relative_to('a/b'), P(''))
|
||||
self.assertEqual(p.relative_to(P(''), walk_up=True), P('a/b'))
|
||||
self.assertEqual(p.relative_to('', walk_up=True), P('a/b'))
|
||||
self.assertEqual(p.relative_to(P('a'), walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to('a', walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to('a/', walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to(P('a/b'), walk_up=True), P(''))
|
||||
self.assertEqual(p.relative_to('a/b', walk_up=True), P(''))
|
||||
self.assertEqual(p.relative_to(P('a/c'), walk_up=True), P('../b'))
|
||||
self.assertEqual(p.relative_to('a/c', walk_up=True), P('../b'))
|
||||
self.assertEqual(p.relative_to(P('a/b/c'), walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to('a/b/c', walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to(P('c'), walk_up=True), P('../a/b'))
|
||||
self.assertEqual(p.relative_to('c', walk_up=True), P('../a/b'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, P('c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('a/b/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('a/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/a'))
|
||||
self.assertRaises(ValueError, p.relative_to, P("../a"))
|
||||
self.assertRaises(ValueError, p.relative_to, P("a/.."))
|
||||
self.assertRaises(ValueError, p.relative_to, P("/a/.."))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/a'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
|
||||
p = P('/a/b')
|
||||
self.assertEqual(p.relative_to(P('/')), P('a/b'))
|
||||
self.assertEqual(p.relative_to('/'), P('a/b'))
|
||||
self.assertEqual(p.relative_to(P('/a')), P('b'))
|
||||
self.assertEqual(p.relative_to('/a'), P('b'))
|
||||
self.assertEqual(p.relative_to('/a/'), P('b'))
|
||||
self.assertEqual(p.relative_to(P('/a/b')), P(''))
|
||||
self.assertEqual(p.relative_to('/a/b'), P(''))
|
||||
self.assertEqual(p.relative_to(P('/'), walk_up=True), P('a/b'))
|
||||
self.assertEqual(p.relative_to('/', walk_up=True), P('a/b'))
|
||||
self.assertEqual(p.relative_to(P('/a'), walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to('/a', walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to('/a/', walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to(P('/a/b'), walk_up=True), P(''))
|
||||
self.assertEqual(p.relative_to('/a/b', walk_up=True), P(''))
|
||||
self.assertEqual(p.relative_to(P('/a/c'), walk_up=True), P('../b'))
|
||||
self.assertEqual(p.relative_to('/a/c', walk_up=True), P('../b'))
|
||||
self.assertEqual(p.relative_to(P('/a/b/c'), walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to('/a/b/c', walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to(P('/c'), walk_up=True), P('../a/b'))
|
||||
self.assertEqual(p.relative_to('/c', walk_up=True), P('../a/b'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, P('/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/a/b/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/a/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P(''))
|
||||
self.assertRaises(ValueError, p.relative_to, '')
|
||||
self.assertRaises(ValueError, p.relative_to, P('a'))
|
||||
self.assertRaises(ValueError, p.relative_to, P("../a"))
|
||||
self.assertRaises(ValueError, p.relative_to, P("a/.."))
|
||||
self.assertRaises(ValueError, p.relative_to, P("/a/.."))
|
||||
self.assertRaises(ValueError, p.relative_to, P(''), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('a'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
|
||||
|
||||
@needs_windows
|
||||
def test_relative_to_windows(self):
|
||||
P = self.cls
|
||||
p = P('C:Foo/Bar')
|
||||
self.assertEqual(p.relative_to(P('c:')), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('c:'), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:foO')), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:foO'), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:foO/'), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:foO/baR')), P())
|
||||
self.assertEqual(p.relative_to('c:foO/baR'), P())
|
||||
self.assertEqual(p.relative_to(P('c:'), walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('c:', walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:foO'), walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:foO', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:foO/', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:foO/baR'), walk_up=True), P())
|
||||
self.assertEqual(p.relative_to('c:foO/baR', walk_up=True), P())
|
||||
self.assertEqual(p.relative_to(P('C:Foo/Bar/Baz'), walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to(P('C:Foo/Baz'), walk_up=True), P('../Bar'))
|
||||
self.assertEqual(p.relative_to(P('C:Baz/Bar'), walk_up=True), P('../../Foo/Bar'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, P())
|
||||
self.assertRaises(ValueError, p.relative_to, '')
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:Foo/Bar/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:Foo/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P(), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, '', walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Foo'), walk_up=True)
|
||||
p = P('C:/Foo/Bar')
|
||||
self.assertEqual(p.relative_to(P('c:/')), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('c:/'), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:/foO')), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:/foO'), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:/foO/'), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:/foO/baR')), P())
|
||||
self.assertEqual(p.relative_to('c:/foO/baR'), P())
|
||||
self.assertEqual(p.relative_to(P('c:/'), walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('c:/', walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:/foO'), walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:/foO', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:/foO/', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:/foO/baR'), walk_up=True), P())
|
||||
self.assertEqual(p.relative_to('c:/foO/baR', walk_up=True), P())
|
||||
self.assertEqual(p.relative_to('C:/Baz', walk_up=True), P('../Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('C:/Foo/Bar/Baz', walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to('C:/Foo/Baz', walk_up=True), P('../Bar'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, 'c:')
|
||||
self.assertRaises(ValueError, p.relative_to, P('c:'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Bar/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:/'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('//C/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, 'c:', walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('c:'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:/'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('//C/Foo'), walk_up=True)
|
||||
# UNC paths.
|
||||
p = P('//Server/Share/Foo/Bar')
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare')), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare'), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/'), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/Foo')), P('Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo'), P('Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo/'), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar')), P())
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar'), P())
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare'), walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare', walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/', walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/Foo'), walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo/', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar'), walk_up=True), P())
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar', walk_up=True), P())
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/bar'), walk_up=True), P('../Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/bar', walk_up=True), P('../Foo/Bar'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'), walk_up=True)
|
||||
|
||||
def test_is_relative_to_common(self):
|
||||
P = self.cls
|
||||
p = P('a/b')
|
||||
self.assertRaises(TypeError, p.is_relative_to)
|
||||
self.assertRaises(TypeError, p.is_relative_to, b'a')
|
||||
self.assertTrue(p.is_relative_to(P('')))
|
||||
self.assertTrue(p.is_relative_to(''))
|
||||
self.assertTrue(p.is_relative_to(P('a')))
|
||||
self.assertTrue(p.is_relative_to('a/'))
|
||||
self.assertTrue(p.is_relative_to(P('a/b')))
|
||||
self.assertTrue(p.is_relative_to('a/b'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to(P('c')))
|
||||
self.assertFalse(p.is_relative_to(P('a/b/c')))
|
||||
self.assertFalse(p.is_relative_to(P('a/c')))
|
||||
self.assertFalse(p.is_relative_to(P('/a')))
|
||||
p = P('/a/b')
|
||||
self.assertTrue(p.is_relative_to(P('/')))
|
||||
self.assertTrue(p.is_relative_to('/'))
|
||||
self.assertTrue(p.is_relative_to(P('/a')))
|
||||
self.assertTrue(p.is_relative_to('/a'))
|
||||
self.assertTrue(p.is_relative_to('/a/'))
|
||||
self.assertTrue(p.is_relative_to(P('/a/b')))
|
||||
self.assertTrue(p.is_relative_to('/a/b'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to(P('/c')))
|
||||
self.assertFalse(p.is_relative_to(P('/a/b/c')))
|
||||
self.assertFalse(p.is_relative_to(P('/a/c')))
|
||||
self.assertFalse(p.is_relative_to(P('')))
|
||||
self.assertFalse(p.is_relative_to(''))
|
||||
self.assertFalse(p.is_relative_to(P('a')))
|
||||
|
||||
@needs_windows
|
||||
def test_is_relative_to_windows(self):
|
||||
P = self.cls
|
||||
p = P('C:Foo/Bar')
|
||||
self.assertTrue(p.is_relative_to(P('c:')))
|
||||
self.assertTrue(p.is_relative_to('c:'))
|
||||
self.assertTrue(p.is_relative_to(P('c:foO')))
|
||||
self.assertTrue(p.is_relative_to('c:foO'))
|
||||
self.assertTrue(p.is_relative_to('c:foO/'))
|
||||
self.assertTrue(p.is_relative_to(P('c:foO/baR')))
|
||||
self.assertTrue(p.is_relative_to('c:foO/baR'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to(P()))
|
||||
self.assertFalse(p.is_relative_to(''))
|
||||
self.assertFalse(p.is_relative_to(P('d:')))
|
||||
self.assertFalse(p.is_relative_to(P('/')))
|
||||
self.assertFalse(p.is_relative_to(P('Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('C:/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('C:Foo/Bar/Baz')))
|
||||
self.assertFalse(p.is_relative_to(P('C:Foo/Baz')))
|
||||
p = P('C:/Foo/Bar')
|
||||
self.assertTrue(p.is_relative_to(P('c:/')))
|
||||
self.assertTrue(p.is_relative_to(P('c:/foO')))
|
||||
self.assertTrue(p.is_relative_to('c:/foO/'))
|
||||
self.assertTrue(p.is_relative_to(P('c:/foO/baR')))
|
||||
self.assertTrue(p.is_relative_to('c:/foO/baR'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to('c:'))
|
||||
self.assertFalse(p.is_relative_to(P('C:/Baz')))
|
||||
self.assertFalse(p.is_relative_to(P('C:/Foo/Bar/Baz')))
|
||||
self.assertFalse(p.is_relative_to(P('C:/Foo/Baz')))
|
||||
self.assertFalse(p.is_relative_to(P('C:Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('d:')))
|
||||
self.assertFalse(p.is_relative_to(P('d:/')))
|
||||
self.assertFalse(p.is_relative_to(P('/')))
|
||||
self.assertFalse(p.is_relative_to(P('/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('//C/Foo')))
|
||||
# UNC paths.
|
||||
p = P('//Server/Share/Foo/Bar')
|
||||
self.assertTrue(p.is_relative_to(P('//sErver/sHare')))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare'))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare/'))
|
||||
self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo')))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare/Foo'))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/'))
|
||||
self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo/Bar')))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/Bar'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to(P('/Server/Share/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('c:/Server/Share/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('//z/Share/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('//Server/z/Foo')))
|
||||
|
||||
|
||||
class PurePosixPathTest(PurePathTest):
|
||||
cls = pathlib.PurePosixPath
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ def __hash__(self):
|
|||
return hash(str(self))
|
||||
|
||||
def __repr__(self):
|
||||
return "{}({!r})".format(self.__class__.__name__, self.as_posix())
|
||||
return "{}({!r})".format(self.__class__.__name__, str(self))
|
||||
|
||||
def with_segments(self, *pathsegments):
|
||||
return type(self)(*pathsegments)
|
||||
|
|
@ -107,12 +107,6 @@ def test_constructor_common(self):
|
|||
P('a/b/c')
|
||||
P('/a/b/c')
|
||||
|
||||
def test_fspath_common(self):
|
||||
self.assertRaises(TypeError, os.fspath, self.cls(''))
|
||||
|
||||
def test_as_bytes_common(self):
|
||||
self.assertRaises(TypeError, bytes, self.cls(''))
|
||||
|
||||
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
|
||||
|
|
@ -161,7 +155,6 @@ def with_segments(self, *pathsegments):
|
|||
self.assertEqual(42, p.with_stem('foo').session_id)
|
||||
self.assertEqual(42, p.with_suffix('.foo').session_id)
|
||||
self.assertEqual(42, p.with_segments('foo').session_id)
|
||||
self.assertEqual(42, p.relative_to('foo').session_id)
|
||||
self.assertEqual(42, p.parent.session_id)
|
||||
for parent in p.parents:
|
||||
self.assertEqual(42, parent.session_id)
|
||||
|
|
@ -303,12 +296,6 @@ def test_str_windows(self):
|
|||
p = self.cls('//a/b/c/d')
|
||||
self.assertEqual(str(p), '\\\\a\\b\\c\\d')
|
||||
|
||||
def test_as_posix_common(self):
|
||||
P = self.cls
|
||||
for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
|
||||
self.assertEqual(P(pathstr).as_posix(), pathstr)
|
||||
# Other tests for as_posix() are in test_equivalences().
|
||||
|
||||
def test_match_empty(self):
|
||||
P = self.cls
|
||||
self.assertRaises(ValueError, P('a').match, '')
|
||||
|
|
@ -615,50 +602,6 @@ def test_parents_windows(self):
|
|||
with self.assertRaises(IndexError):
|
||||
par[2]
|
||||
|
||||
def test_drive_common(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('a/b').drive, '')
|
||||
self.assertEqual(P('/a/b').drive, '')
|
||||
self.assertEqual(P('').drive, '')
|
||||
|
||||
@needs_windows
|
||||
def test_drive_windows(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('c:').drive, 'c:')
|
||||
self.assertEqual(P('c:a/b').drive, 'c:')
|
||||
self.assertEqual(P('c:/').drive, 'c:')
|
||||
self.assertEqual(P('c:/a/b/').drive, 'c:')
|
||||
self.assertEqual(P('//a/b').drive, '\\\\a\\b')
|
||||
self.assertEqual(P('//a/b/').drive, '\\\\a\\b')
|
||||
self.assertEqual(P('//a/b/c/d').drive, '\\\\a\\b')
|
||||
self.assertEqual(P('./c:a').drive, '')
|
||||
|
||||
def test_root_common(self):
|
||||
P = self.cls
|
||||
sep = self.sep
|
||||
self.assertEqual(P('').root, '')
|
||||
self.assertEqual(P('a/b').root, '')
|
||||
self.assertEqual(P('/').root, sep)
|
||||
self.assertEqual(P('/a/b').root, sep)
|
||||
|
||||
@needs_posix
|
||||
def test_root_posix(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('/a/b').root, '/')
|
||||
# POSIX special case for two leading slashes.
|
||||
self.assertEqual(P('//a/b').root, '//')
|
||||
|
||||
@needs_windows
|
||||
def test_root_windows(self):
|
||||
P = self.cls
|
||||
self.assertEqual(P('c:').root, '')
|
||||
self.assertEqual(P('c:a/b').root, '')
|
||||
self.assertEqual(P('c:/').root, '\\')
|
||||
self.assertEqual(P('c:/a/b/').root, '\\')
|
||||
self.assertEqual(P('//a/b').root, '\\')
|
||||
self.assertEqual(P('//a/b/').root, '\\')
|
||||
self.assertEqual(P('//a/b/c/d').root, '\\')
|
||||
|
||||
def test_anchor_common(self):
|
||||
P = self.cls
|
||||
sep = self.sep
|
||||
|
|
@ -967,311 +910,6 @@ def test_with_suffix_invalid(self):
|
|||
self.assertRaises(ValueError, P('a/b').with_suffix, '.d/.')
|
||||
self.assertRaises(TypeError, P('a/b').with_suffix, None)
|
||||
|
||||
def test_relative_to_common(self):
|
||||
P = self.cls
|
||||
p = P('a/b')
|
||||
self.assertRaises(TypeError, p.relative_to)
|
||||
self.assertRaises(TypeError, p.relative_to, b'a')
|
||||
self.assertEqual(p.relative_to(P('')), P('a/b'))
|
||||
self.assertEqual(p.relative_to(''), P('a/b'))
|
||||
self.assertEqual(p.relative_to(P('a')), P('b'))
|
||||
self.assertEqual(p.relative_to('a'), P('b'))
|
||||
self.assertEqual(p.relative_to('a/'), P('b'))
|
||||
self.assertEqual(p.relative_to(P('a/b')), P(''))
|
||||
self.assertEqual(p.relative_to('a/b'), P(''))
|
||||
self.assertEqual(p.relative_to(P(''), walk_up=True), P('a/b'))
|
||||
self.assertEqual(p.relative_to('', walk_up=True), P('a/b'))
|
||||
self.assertEqual(p.relative_to(P('a'), walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to('a', walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to('a/', walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to(P('a/b'), walk_up=True), P(''))
|
||||
self.assertEqual(p.relative_to('a/b', walk_up=True), P(''))
|
||||
self.assertEqual(p.relative_to(P('a/c'), walk_up=True), P('../b'))
|
||||
self.assertEqual(p.relative_to('a/c', walk_up=True), P('../b'))
|
||||
self.assertEqual(p.relative_to(P('a/b/c'), walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to('a/b/c', walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to(P('c'), walk_up=True), P('../a/b'))
|
||||
self.assertEqual(p.relative_to('c', walk_up=True), P('../a/b'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, P('c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('a/b/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('a/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/a'))
|
||||
self.assertRaises(ValueError, p.relative_to, P("../a"))
|
||||
self.assertRaises(ValueError, p.relative_to, P("a/.."))
|
||||
self.assertRaises(ValueError, p.relative_to, P("/a/.."))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/a'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
|
||||
p = P('/a/b')
|
||||
self.assertEqual(p.relative_to(P('/')), P('a/b'))
|
||||
self.assertEqual(p.relative_to('/'), P('a/b'))
|
||||
self.assertEqual(p.relative_to(P('/a')), P('b'))
|
||||
self.assertEqual(p.relative_to('/a'), P('b'))
|
||||
self.assertEqual(p.relative_to('/a/'), P('b'))
|
||||
self.assertEqual(p.relative_to(P('/a/b')), P(''))
|
||||
self.assertEqual(p.relative_to('/a/b'), P(''))
|
||||
self.assertEqual(p.relative_to(P('/'), walk_up=True), P('a/b'))
|
||||
self.assertEqual(p.relative_to('/', walk_up=True), P('a/b'))
|
||||
self.assertEqual(p.relative_to(P('/a'), walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to('/a', walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to('/a/', walk_up=True), P('b'))
|
||||
self.assertEqual(p.relative_to(P('/a/b'), walk_up=True), P(''))
|
||||
self.assertEqual(p.relative_to('/a/b', walk_up=True), P(''))
|
||||
self.assertEqual(p.relative_to(P('/a/c'), walk_up=True), P('../b'))
|
||||
self.assertEqual(p.relative_to('/a/c', walk_up=True), P('../b'))
|
||||
self.assertEqual(p.relative_to(P('/a/b/c'), walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to('/a/b/c', walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to(P('/c'), walk_up=True), P('../a/b'))
|
||||
self.assertEqual(p.relative_to('/c', walk_up=True), P('../a/b'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, P('/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/a/b/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/a/c'))
|
||||
self.assertRaises(ValueError, p.relative_to, P(''))
|
||||
self.assertRaises(ValueError, p.relative_to, '')
|
||||
self.assertRaises(ValueError, p.relative_to, P('a'))
|
||||
self.assertRaises(ValueError, p.relative_to, P("../a"))
|
||||
self.assertRaises(ValueError, p.relative_to, P("a/.."))
|
||||
self.assertRaises(ValueError, p.relative_to, P("/a/.."))
|
||||
self.assertRaises(ValueError, p.relative_to, P(''), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('a'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
|
||||
|
||||
@needs_windows
|
||||
def test_relative_to_windows(self):
|
||||
P = self.cls
|
||||
p = P('C:Foo/Bar')
|
||||
self.assertEqual(p.relative_to(P('c:')), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('c:'), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:foO')), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:foO'), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:foO/'), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:foO/baR')), P())
|
||||
self.assertEqual(p.relative_to('c:foO/baR'), P())
|
||||
self.assertEqual(p.relative_to(P('c:'), walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('c:', walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:foO'), walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:foO', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:foO/', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:foO/baR'), walk_up=True), P())
|
||||
self.assertEqual(p.relative_to('c:foO/baR', walk_up=True), P())
|
||||
self.assertEqual(p.relative_to(P('C:Foo/Bar/Baz'), walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to(P('C:Foo/Baz'), walk_up=True), P('../Bar'))
|
||||
self.assertEqual(p.relative_to(P('C:Baz/Bar'), walk_up=True), P('../../Foo/Bar'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, P())
|
||||
self.assertRaises(ValueError, p.relative_to, '')
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:Foo/Bar/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:Foo/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P(), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, '', walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Foo'), walk_up=True)
|
||||
p = P('C:/Foo/Bar')
|
||||
self.assertEqual(p.relative_to(P('c:/')), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('c:/'), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:/foO')), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:/foO'), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:/foO/'), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:/foO/baR')), P())
|
||||
self.assertEqual(p.relative_to('c:/foO/baR'), P())
|
||||
self.assertEqual(p.relative_to(P('c:/'), walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('c:/', walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:/foO'), walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:/foO', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('c:/foO/', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('c:/foO/baR'), walk_up=True), P())
|
||||
self.assertEqual(p.relative_to('c:/foO/baR', walk_up=True), P())
|
||||
self.assertEqual(p.relative_to('C:/Baz', walk_up=True), P('../Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('C:/Foo/Bar/Baz', walk_up=True), P('..'))
|
||||
self.assertEqual(p.relative_to('C:/Foo/Baz', walk_up=True), P('../Bar'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, 'c:')
|
||||
self.assertRaises(ValueError, p.relative_to, P('c:'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Bar/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Baz'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:/'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('//C/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, 'c:', walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('c:'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('C:Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('d:/'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('//C/Foo'), walk_up=True)
|
||||
# UNC paths.
|
||||
p = P('//Server/Share/Foo/Bar')
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare')), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare'), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/'), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/Foo')), P('Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo'), P('Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo/'), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar')), P())
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar'), P())
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare'), walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare', walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/', walk_up=True), P('Foo/Bar'))
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/Foo'), walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo/', walk_up=True), P('Bar'))
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar'), walk_up=True), P())
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar', walk_up=True), P())
|
||||
self.assertEqual(p.relative_to(P('//sErver/sHare/bar'), walk_up=True), P('../Foo/Bar'))
|
||||
self.assertEqual(p.relative_to('//sErver/sHare/bar', walk_up=True), P('../Foo/Bar'))
|
||||
# Unrelated paths.
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'))
|
||||
self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'), walk_up=True)
|
||||
self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'), walk_up=True)
|
||||
|
||||
def test_is_relative_to_common(self):
|
||||
P = self.cls
|
||||
p = P('a/b')
|
||||
self.assertRaises(TypeError, p.is_relative_to)
|
||||
self.assertRaises(TypeError, p.is_relative_to, b'a')
|
||||
self.assertTrue(p.is_relative_to(P('')))
|
||||
self.assertTrue(p.is_relative_to(''))
|
||||
self.assertTrue(p.is_relative_to(P('a')))
|
||||
self.assertTrue(p.is_relative_to('a/'))
|
||||
self.assertTrue(p.is_relative_to(P('a/b')))
|
||||
self.assertTrue(p.is_relative_to('a/b'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to(P('c')))
|
||||
self.assertFalse(p.is_relative_to(P('a/b/c')))
|
||||
self.assertFalse(p.is_relative_to(P('a/c')))
|
||||
self.assertFalse(p.is_relative_to(P('/a')))
|
||||
p = P('/a/b')
|
||||
self.assertTrue(p.is_relative_to(P('/')))
|
||||
self.assertTrue(p.is_relative_to('/'))
|
||||
self.assertTrue(p.is_relative_to(P('/a')))
|
||||
self.assertTrue(p.is_relative_to('/a'))
|
||||
self.assertTrue(p.is_relative_to('/a/'))
|
||||
self.assertTrue(p.is_relative_to(P('/a/b')))
|
||||
self.assertTrue(p.is_relative_to('/a/b'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to(P('/c')))
|
||||
self.assertFalse(p.is_relative_to(P('/a/b/c')))
|
||||
self.assertFalse(p.is_relative_to(P('/a/c')))
|
||||
self.assertFalse(p.is_relative_to(P('')))
|
||||
self.assertFalse(p.is_relative_to(''))
|
||||
self.assertFalse(p.is_relative_to(P('a')))
|
||||
|
||||
@needs_windows
|
||||
def test_is_relative_to_windows(self):
|
||||
P = self.cls
|
||||
p = P('C:Foo/Bar')
|
||||
self.assertTrue(p.is_relative_to(P('c:')))
|
||||
self.assertTrue(p.is_relative_to('c:'))
|
||||
self.assertTrue(p.is_relative_to(P('c:foO')))
|
||||
self.assertTrue(p.is_relative_to('c:foO'))
|
||||
self.assertTrue(p.is_relative_to('c:foO/'))
|
||||
self.assertTrue(p.is_relative_to(P('c:foO/baR')))
|
||||
self.assertTrue(p.is_relative_to('c:foO/baR'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to(P()))
|
||||
self.assertFalse(p.is_relative_to(''))
|
||||
self.assertFalse(p.is_relative_to(P('d:')))
|
||||
self.assertFalse(p.is_relative_to(P('/')))
|
||||
self.assertFalse(p.is_relative_to(P('Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('C:/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('C:Foo/Bar/Baz')))
|
||||
self.assertFalse(p.is_relative_to(P('C:Foo/Baz')))
|
||||
p = P('C:/Foo/Bar')
|
||||
self.assertTrue(p.is_relative_to(P('c:/')))
|
||||
self.assertTrue(p.is_relative_to(P('c:/foO')))
|
||||
self.assertTrue(p.is_relative_to('c:/foO/'))
|
||||
self.assertTrue(p.is_relative_to(P('c:/foO/baR')))
|
||||
self.assertTrue(p.is_relative_to('c:/foO/baR'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to('c:'))
|
||||
self.assertFalse(p.is_relative_to(P('C:/Baz')))
|
||||
self.assertFalse(p.is_relative_to(P('C:/Foo/Bar/Baz')))
|
||||
self.assertFalse(p.is_relative_to(P('C:/Foo/Baz')))
|
||||
self.assertFalse(p.is_relative_to(P('C:Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('d:')))
|
||||
self.assertFalse(p.is_relative_to(P('d:/')))
|
||||
self.assertFalse(p.is_relative_to(P('/')))
|
||||
self.assertFalse(p.is_relative_to(P('/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('//C/Foo')))
|
||||
# UNC paths.
|
||||
p = P('//Server/Share/Foo/Bar')
|
||||
self.assertTrue(p.is_relative_to(P('//sErver/sHare')))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare'))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare/'))
|
||||
self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo')))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare/Foo'))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/'))
|
||||
self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo/Bar')))
|
||||
self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/Bar'))
|
||||
# Unrelated paths.
|
||||
self.assertFalse(p.is_relative_to(P('/Server/Share/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('c:/Server/Share/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('//z/Share/Foo')))
|
||||
self.assertFalse(p.is_relative_to(P('//Server/z/Foo')))
|
||||
|
||||
@needs_posix
|
||||
def test_is_absolute_posix(self):
|
||||
P = self.cls
|
||||
self.assertFalse(P('').is_absolute())
|
||||
self.assertFalse(P('a').is_absolute())
|
||||
self.assertFalse(P('a/b/').is_absolute())
|
||||
self.assertTrue(P('/').is_absolute())
|
||||
self.assertTrue(P('/a').is_absolute())
|
||||
self.assertTrue(P('/a/b/').is_absolute())
|
||||
self.assertTrue(P('//a').is_absolute())
|
||||
self.assertTrue(P('//a/b').is_absolute())
|
||||
|
||||
@needs_windows
|
||||
def test_is_absolute_windows(self):
|
||||
P = self.cls
|
||||
# Under NT, only paths with both a drive and a root are absolute.
|
||||
self.assertFalse(P().is_absolute())
|
||||
self.assertFalse(P('a').is_absolute())
|
||||
self.assertFalse(P('a/b/').is_absolute())
|
||||
self.assertFalse(P('/').is_absolute())
|
||||
self.assertFalse(P('/a').is_absolute())
|
||||
self.assertFalse(P('/a/b/').is_absolute())
|
||||
self.assertFalse(P('c:').is_absolute())
|
||||
self.assertFalse(P('c:a').is_absolute())
|
||||
self.assertFalse(P('c:a/b/').is_absolute())
|
||||
self.assertTrue(P('c:/').is_absolute())
|
||||
self.assertTrue(P('c:/a').is_absolute())
|
||||
self.assertTrue(P('c:/a/b/').is_absolute())
|
||||
# UNC paths are absolute by definition.
|
||||
self.assertTrue(P('//').is_absolute())
|
||||
self.assertTrue(P('//a').is_absolute())
|
||||
self.assertTrue(P('//a/b').is_absolute())
|
||||
self.assertTrue(P('//a/b/').is_absolute())
|
||||
self.assertTrue(P('//a/b/c').is_absolute())
|
||||
self.assertTrue(P('//a/b/c/d').is_absolute())
|
||||
self.assertTrue(P('//?/UNC/').is_absolute())
|
||||
self.assertTrue(P('//?/UNC/spam').is_absolute())
|
||||
|
||||
|
||||
#
|
||||
# Tests for the virtual classes.
|
||||
|
|
@ -1320,7 +958,7 @@ def __hash__(self):
|
|||
return hash(str(self))
|
||||
|
||||
def __repr__(self):
|
||||
return "{}({!r})".format(self.__class__.__name__, self.as_posix())
|
||||
return "{}({!r})".format(self.__class__.__name__, str(self))
|
||||
|
||||
def with_segments(self, *pathsegments):
|
||||
return type(self)(*pathsegments)
|
||||
|
|
@ -1631,8 +1269,8 @@ def ordered_walk(path):
|
|||
source_walk = ordered_walk(source)
|
||||
target_walk = ordered_walk(target)
|
||||
for source_item, target_item in zip(source_walk, target_walk, strict=True):
|
||||
self.assertEqual(source_item[0].relative_to(source),
|
||||
target_item[0].relative_to(target)) # dirpath
|
||||
self.assertEqual(source_item[0].parts[len(source.parts):],
|
||||
target_item[0].parts[len(target.parts):]) # dirpath
|
||||
self.assertEqual(source_item[1], target_item[1]) # dirnames
|
||||
self.assertEqual(source_item[2], target_item[2]) # filenames
|
||||
# Compare files and symlinks
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue