OLD | NEW |
1 import unittest | 1 import unittest |
2 from test import support | 2 from test import support |
3 | 3 |
4 import posixpath, os | 4 import posixpath, os |
5 from posixpath import realpath, abspath, join, dirname, basename, relpath | 5 from posixpath import realpath, abspath, join, dirname, basename, relpath |
6 | 6 |
7 # An absolute path to a temporary filename for testing. We can't rely on TESTFN | 7 # An absolute path to a temporary filename for testing. We can't rely on TESTFN |
8 # being an absolute path, so we need this. | 8 # being an absolute path, so we need this. |
9 | 9 |
10 ABSTFN = abspath(support.TESTFN) | 10 ABSTFN = abspath(support.TESTFN) |
(...skipping 13 matching lines...) Expand all Loading... |
24 for suffix in ["", "1", "2"]: | 24 for suffix in ["", "1", "2"]: |
25 support.unlink(support.TESTFN + suffix) | 25 support.unlink(support.TESTFN + suffix) |
26 safe_rmdir(support.TESTFN + suffix) | 26 safe_rmdir(support.TESTFN + suffix) |
27 | 27 |
28 def assertIs(self, a, b): | 28 def assertIs(self, a, b): |
29 self.assert_(a is b) | 29 self.assert_(a is b) |
30 | 30 |
31 def test_normcase(self): | 31 def test_normcase(self): |
32 # Check that normcase() is idempotent | 32 # Check that normcase() is idempotent |
33 p = "FoO/./BaR" | 33 p = "FoO/./BaR" |
34 p = posixpath.normcase(p) | 34 self.assertEqual(p, posixpath.normcase(p)) |
| 35 |
| 36 p = b"FoO/./BaR" |
35 self.assertEqual(p, posixpath.normcase(p)) | 37 self.assertEqual(p, posixpath.normcase(p)) |
36 | 38 |
37 self.assertRaises(TypeError, posixpath.normcase) | 39 self.assertRaises(TypeError, posixpath.normcase) |
38 | 40 |
39 def test_join(self): | 41 def test_join(self): |
40 self.assertEqual(posixpath.join("/foo", "bar", "/bar", "baz"), "/bar/baz
") | 42 self.assertEqual(posixpath.join("/foo", "bar", "/bar", "baz"), "/bar/baz
") |
41 self.assertEqual(posixpath.join("/foo", "bar", "baz"), "/foo/bar/baz") | 43 self.assertEqual(posixpath.join("/foo", "bar", "baz"), "/foo/bar/baz") |
42 self.assertEqual(posixpath.join("/foo/", "bar/", "baz/"), "/foo/bar/baz/
") | 44 self.assertEqual(posixpath.join("/foo/", "bar/", "baz/"), "/foo/bar/baz/
") |
43 | 45 |
| 46 self.assertEqual(posixpath.join(b"/foo", b"bar", b"/bar", b"baz"), b"/ba
r/baz") |
| 47 self.assertEqual(posixpath.join(b"/foo", b"bar", b"baz"), b"/foo/bar/baz
") |
| 48 self.assertEqual(posixpath.join(b"/foo/", b"bar/", b"baz/"), b"/foo/bar/
baz/") |
| 49 |
44 self.assertRaises(TypeError, posixpath.join) | 50 self.assertRaises(TypeError, posixpath.join) |
| 51 self.assertRaises(TypeError, posixpath.join, b"bytes", "str") |
| 52 self.assertRaises(TypeError, posixpath.join, "str", b"bytes") |
45 | 53 |
46 def test_splitdrive(self): | 54 def test_splitdrive(self): |
47 self.assertEqual(posixpath.splitdrive("/foo/bar"), ("", "/foo/bar")) | 55 self.assertEqual(posixpath.splitdrive("/foo/bar"), ("", "/foo/bar")) |
| 56 self.assertEqual(posixpath.splitdrive(b"/foo/bar"), (b"", b"/foo/bar")) |
48 | 57 |
49 self.assertRaises(TypeError, posixpath.splitdrive) | 58 self.assertRaises(TypeError, posixpath.splitdrive) |
50 | 59 |
51 def test_split(self): | 60 def test_split(self): |
52 self.assertEqual(posixpath.split("/foo/bar"), ("/foo", "bar")) | 61 self.assertEqual(posixpath.split("/foo/bar"), ("/foo", "bar")) |
53 self.assertEqual(posixpath.split("/"), ("/", "")) | 62 self.assertEqual(posixpath.split("/"), ("/", "")) |
54 self.assertEqual(posixpath.split("foo"), ("", "foo")) | 63 self.assertEqual(posixpath.split("foo"), ("", "foo")) |
55 self.assertEqual(posixpath.split("////foo"), ("////", "foo")) | 64 self.assertEqual(posixpath.split("////foo"), ("////", "foo")) |
56 self.assertEqual(posixpath.split("//foo//bar"), ("//foo", "bar")) | 65 self.assertEqual(posixpath.split("//foo//bar"), ("//foo", "bar")) |
57 | 66 |
| 67 self.assertEqual(posixpath.split(b"/foo/bar"), (b"/foo", b"bar")) |
| 68 self.assertEqual(posixpath.split(b"/"), (b"/", b"")) |
| 69 self.assertEqual(posixpath.split(b"foo"), (b"", b"foo")) |
| 70 self.assertEqual(posixpath.split(b"////foo"), (b"////", b"foo")) |
| 71 self.assertEqual(posixpath.split(b"//foo//bar"), (b"//foo", b"bar")) |
| 72 |
58 self.assertRaises(TypeError, posixpath.split) | 73 self.assertRaises(TypeError, posixpath.split) |
59 | 74 |
60 def splitextTest(self, path, filename, ext): | 75 def splitextTest(self, path, filename, ext): |
61 self.assertEqual(posixpath.splitext(path), (filename, ext)) | 76 self.assertEqual(posixpath.splitext(path), (filename, ext)) |
62 self.assertEqual(posixpath.splitext("/" + path), ("/" + filename, ext)) | 77 self.assertEqual(posixpath.splitext("/" + path), ("/" + filename, ext)) |
63 self.assertEqual(posixpath.splitext("abc/" + path), ("abc/" + filename,
ext)) | 78 self.assertEqual(posixpath.splitext("abc/" + path), ("abc/" + filename,
ext)) |
64 self.assertEqual(posixpath.splitext("abc.def/" + path), ("abc.def/" + fi
lename, ext)) | 79 self.assertEqual(posixpath.splitext("abc.def/" + path), ("abc.def/" + fi
lename, ext)) |
65 self.assertEqual(posixpath.splitext("/abc.def/" + path), ("/abc.def/" +
filename, ext)) | 80 self.assertEqual(posixpath.splitext("/abc.def/" + path), ("/abc.def/" +
filename, ext)) |
66 self.assertEqual(posixpath.splitext(path + "/"), (filename + ext + "/",
"")) | 81 self.assertEqual(posixpath.splitext(path + "/"), (filename + ext + "/",
"")) |
67 | 82 |
(...skipping 12 matching lines...) Expand all Loading... |
80 self.splitextTest("", "", "") | 95 self.splitextTest("", "", "") |
81 self.assertRaises(TypeError, posixpath.splitext) | 96 self.assertRaises(TypeError, posixpath.splitext) |
82 | 97 |
83 def test_isabs(self): | 98 def test_isabs(self): |
84 self.assertIs(posixpath.isabs(""), False) | 99 self.assertIs(posixpath.isabs(""), False) |
85 self.assertIs(posixpath.isabs("/"), True) | 100 self.assertIs(posixpath.isabs("/"), True) |
86 self.assertIs(posixpath.isabs("/foo"), True) | 101 self.assertIs(posixpath.isabs("/foo"), True) |
87 self.assertIs(posixpath.isabs("/foo/bar"), True) | 102 self.assertIs(posixpath.isabs("/foo/bar"), True) |
88 self.assertIs(posixpath.isabs("foo/bar"), False) | 103 self.assertIs(posixpath.isabs("foo/bar"), False) |
89 | 104 |
| 105 self.assertIs(posixpath.isabs(b""), False) |
| 106 self.assertIs(posixpath.isabs(b"/"), True) |
| 107 self.assertIs(posixpath.isabs(b"/foo"), True) |
| 108 self.assertIs(posixpath.isabs(b"/foo/bar"), True) |
| 109 self.assertIs(posixpath.isabs(b"foo/bar"), False) |
| 110 |
90 self.assertRaises(TypeError, posixpath.isabs) | 111 self.assertRaises(TypeError, posixpath.isabs) |
91 | 112 |
92 def test_splitdrive(self): | |
93 self.assertEqual(posixpath.splitdrive("/foo/bar"), ("", "/foo/bar")) | |
94 | |
95 self.assertRaises(TypeError, posixpath.splitdrive) | |
96 | |
97 def test_basename(self): | 113 def test_basename(self): |
98 self.assertEqual(posixpath.basename("/foo/bar"), "bar") | 114 self.assertEqual(posixpath.basename("/foo/bar"), "bar") |
99 self.assertEqual(posixpath.basename("/"), "") | 115 self.assertEqual(posixpath.basename("/"), "") |
100 self.assertEqual(posixpath.basename("foo"), "foo") | 116 self.assertEqual(posixpath.basename("foo"), "foo") |
101 self.assertEqual(posixpath.basename("////foo"), "foo") | 117 self.assertEqual(posixpath.basename("////foo"), "foo") |
102 self.assertEqual(posixpath.basename("//foo//bar"), "bar") | 118 self.assertEqual(posixpath.basename("//foo//bar"), "bar") |
103 | 119 |
| 120 self.assertEqual(posixpath.basename(b"/foo/bar"), b"bar") |
| 121 self.assertEqual(posixpath.basename(b"/"), b"") |
| 122 self.assertEqual(posixpath.basename(b"foo"), b"foo") |
| 123 self.assertEqual(posixpath.basename(b"////foo"), b"foo") |
| 124 self.assertEqual(posixpath.basename(b"//foo//bar"), b"bar") |
| 125 |
104 self.assertRaises(TypeError, posixpath.basename) | 126 self.assertRaises(TypeError, posixpath.basename) |
105 | 127 |
106 def test_dirname(self): | 128 def test_dirname(self): |
107 self.assertEqual(posixpath.dirname("/foo/bar"), "/foo") | 129 self.assertEqual(posixpath.dirname("/foo/bar"), "/foo") |
108 self.assertEqual(posixpath.dirname("/"), "/") | 130 self.assertEqual(posixpath.dirname("/"), "/") |
109 self.assertEqual(posixpath.dirname("foo"), "") | 131 self.assertEqual(posixpath.dirname("foo"), "") |
110 self.assertEqual(posixpath.dirname("////foo"), "////") | 132 self.assertEqual(posixpath.dirname("////foo"), "////") |
111 self.assertEqual(posixpath.dirname("//foo//bar"), "//foo") | 133 self.assertEqual(posixpath.dirname("//foo//bar"), "//foo") |
112 | 134 |
| 135 self.assertEqual(posixpath.dirname(b"/foo/bar"), b"/foo") |
| 136 self.assertEqual(posixpath.dirname(b"/"), b"/") |
| 137 self.assertEqual(posixpath.dirname(b"foo"), b"") |
| 138 self.assertEqual(posixpath.dirname(b"////foo"), b"////") |
| 139 self.assertEqual(posixpath.dirname(b"//foo//bar"), b"//foo") |
| 140 |
113 self.assertRaises(TypeError, posixpath.dirname) | 141 self.assertRaises(TypeError, posixpath.dirname) |
114 | 142 |
115 def test_commonprefix(self): | 143 def test_commonprefix(self): |
116 self.assertEqual( | 144 self.assertEqual( |
117 posixpath.commonprefix([]), | 145 posixpath.commonprefix([]), |
118 "" | 146 "" |
119 ) | 147 ) |
120 self.assertEqual( | 148 self.assertEqual( |
121 posixpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"]), | 149 posixpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"]), |
122 "/home/swen" | 150 "/home/swen" |
123 ) | 151 ) |
124 self.assertEqual( | 152 self.assertEqual( |
125 posixpath.commonprefix(["/home/swen/spam", "/home/swen/eggs"]), | 153 posixpath.commonprefix(["/home/swen/spam", "/home/swen/eggs"]), |
126 "/home/swen/" | 154 "/home/swen/" |
127 ) | 155 ) |
128 self.assertEqual( | 156 self.assertEqual( |
129 posixpath.commonprefix(["/home/swen/spam", "/home/swen/spam"]), | 157 posixpath.commonprefix(["/home/swen/spam", "/home/swen/spam"]), |
130 "/home/swen/spam" | 158 "/home/swen/spam" |
131 ) | 159 ) |
132 | 160 |
| 161 self.assertEqual( |
| 162 posixpath.commonprefix([b"/home/swenson/spam", b"/home/swen/spam"]), |
| 163 b"/home/swen" |
| 164 ) |
| 165 self.assertEqual( |
| 166 posixpath.commonprefix([b"/home/swen/spam", b"/home/swen/eggs"]), |
| 167 b"/home/swen/" |
| 168 ) |
| 169 self.assertEqual( |
| 170 posixpath.commonprefix([b"/home/swen/spam", b"/home/swen/spam"]), |
| 171 b"/home/swen/spam" |
| 172 ) |
| 173 |
133 testlist = ['', 'abc', 'Xbcd', 'Xb', 'XY', 'abcd', 'aXc', 'abd', 'ab', '
aX', 'abcX'] | 174 testlist = ['', 'abc', 'Xbcd', 'Xb', 'XY', 'abcd', 'aXc', 'abd', 'ab', '
aX', 'abcX'] |
134 for s1 in testlist: | 175 for s1 in testlist: |
135 for s2 in testlist: | 176 for s2 in testlist: |
136 p = posixpath.commonprefix([s1, s2]) | 177 p = posixpath.commonprefix([s1, s2]) |
137 self.assert_(s1.startswith(p)) | 178 self.assert_(s1.startswith(p)) |
138 self.assert_(s2.startswith(p)) | 179 self.assert_(s2.startswith(p)) |
139 if s1 != s2: | 180 if s1 != s2: |
140 n = len(p) | 181 n = len(p) |
141 self.assertNotEqual(s1[n:n+1], s2[n:n+1]) | 182 self.assertNotEqual(s1[n:n+1], s2[n:n+1]) |
142 | 183 |
(...skipping 180 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
323 | 364 |
324 self.assertRaises(TypeError, posixpath.samestat) | 365 self.assertRaises(TypeError, posixpath.samestat) |
325 | 366 |
326 def test_ismount(self): | 367 def test_ismount(self): |
327 self.assertIs(posixpath.ismount("/"), True) | 368 self.assertIs(posixpath.ismount("/"), True) |
328 | 369 |
329 self.assertRaises(TypeError, posixpath.ismount) | 370 self.assertRaises(TypeError, posixpath.ismount) |
330 | 371 |
331 def test_expanduser(self): | 372 def test_expanduser(self): |
332 self.assertEqual(posixpath.expanduser("foo"), "foo") | 373 self.assertEqual(posixpath.expanduser("foo"), "foo") |
| 374 self.assertEqual(posixpath.expanduser(b"foo"), b"foo") |
333 try: | 375 try: |
334 import pwd | 376 import pwd |
335 except ImportError: | 377 except ImportError: |
336 pass | 378 pass |
337 else: | 379 else: |
338 self.assert_(isinstance(posixpath.expanduser("~/"), str)) | 380 self.assert_(isinstance(posixpath.expanduser("~/"), str)) |
| 381 self.assert_(isinstance(posixpath.expanduser(b"~/"), bytes)) |
339 # if home directory == root directory, this test makes no sense | 382 # if home directory == root directory, this test makes no sense |
340 if posixpath.expanduser("~") != '/': | 383 if posixpath.expanduser("~") != '/': |
341 self.assertEqual( | 384 self.assertEqual( |
342 posixpath.expanduser("~") + "/", | 385 posixpath.expanduser("~") + "/", |
343 posixpath.expanduser("~/") | 386 posixpath.expanduser("~/") |
344 ) | 387 ) |
| 388 self.assertEqual( |
| 389 posixpath.expanduser(b"~") + b"/", |
| 390 posixpath.expanduser(b"~/") |
| 391 ) |
345 self.assert_(isinstance(posixpath.expanduser("~root/"), str)) | 392 self.assert_(isinstance(posixpath.expanduser("~root/"), str)) |
346 self.assert_(isinstance(posixpath.expanduser("~foo/"), str)) | 393 self.assert_(isinstance(posixpath.expanduser("~foo/"), str)) |
| 394 self.assert_(isinstance(posixpath.expanduser(b"~root/"), bytes)) |
| 395 self.assert_(isinstance(posixpath.expanduser(b"~foo/"), bytes)) |
347 | 396 |
348 self.assertRaises(TypeError, posixpath.expanduser) | 397 self.assertRaises(TypeError, posixpath.expanduser) |
349 | 398 |
350 def test_expandvars(self): | 399 def test_expandvars(self): |
351 oldenv = os.environ.copy() | 400 oldenv = os.environ.copy() |
352 try: | 401 try: |
353 os.environ.clear() | 402 os.environ.clear() |
354 os.environ["foo"] = "bar" | 403 os.environ["foo"] = "bar" |
355 os.environ["{foo"] = "baz1" | 404 os.environ["{foo"] = "baz1" |
356 os.environ["{foo}"] = "baz2" | 405 os.environ["{foo}"] = "baz2" |
357 self.assertEqual(posixpath.expandvars("foo"), "foo") | 406 self.assertEqual(posixpath.expandvars("foo"), "foo") |
358 self.assertEqual(posixpath.expandvars("$foo bar"), "bar bar") | 407 self.assertEqual(posixpath.expandvars("$foo bar"), "bar bar") |
359 self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar") | 408 self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar") |
360 self.assertEqual(posixpath.expandvars("$[foo]bar"), "$[foo]bar") | 409 self.assertEqual(posixpath.expandvars("$[foo]bar"), "$[foo]bar") |
361 self.assertEqual(posixpath.expandvars("$bar bar"), "$bar bar") | 410 self.assertEqual(posixpath.expandvars("$bar bar"), "$bar bar") |
362 self.assertEqual(posixpath.expandvars("$?bar"), "$?bar") | 411 self.assertEqual(posixpath.expandvars("$?bar"), "$?bar") |
363 self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar") | 412 self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar") |
364 self.assertEqual(posixpath.expandvars("$foo}bar"), "bar}bar") | 413 self.assertEqual(posixpath.expandvars("$foo}bar"), "bar}bar") |
365 self.assertEqual(posixpath.expandvars("${foo"), "${foo") | 414 self.assertEqual(posixpath.expandvars("${foo"), "${foo") |
366 self.assertEqual(posixpath.expandvars("${{foo}}"), "baz1}") | 415 self.assertEqual(posixpath.expandvars("${{foo}}"), "baz1}") |
367 self.assertEqual(posixpath.expandvars("$foo$foo"), "barbar") | 416 self.assertEqual(posixpath.expandvars("$foo$foo"), "barbar") |
368 self.assertEqual(posixpath.expandvars("$bar$bar"), "$bar$bar") | 417 self.assertEqual(posixpath.expandvars("$bar$bar"), "$bar$bar") |
| 418 |
| 419 self.assertEqual(posixpath.expandvars(b"foo"), b"foo") |
| 420 self.assertEqual(posixpath.expandvars(b"$foo bar"), b"bar bar") |
| 421 self.assertEqual(posixpath.expandvars(b"${foo}bar"), b"barbar") |
| 422 self.assertEqual(posixpath.expandvars(b"$[foo]bar"), b"$[foo]bar") |
| 423 self.assertEqual(posixpath.expandvars(b"$bar bar"), b"$bar bar") |
| 424 self.assertEqual(posixpath.expandvars(b"$?bar"), b"$?bar") |
| 425 self.assertEqual(posixpath.expandvars(b"${foo}bar"), b"barbar") |
| 426 self.assertEqual(posixpath.expandvars(b"$foo}bar"), b"bar}bar") |
| 427 self.assertEqual(posixpath.expandvars(b"${foo"), b"${foo") |
| 428 self.assertEqual(posixpath.expandvars(b"${{foo}}"), b"baz1}") |
| 429 self.assertEqual(posixpath.expandvars(b"$foo$foo"), b"barbar") |
| 430 self.assertEqual(posixpath.expandvars(b"$bar$bar"), b"$bar$bar") |
369 finally: | 431 finally: |
370 os.environ.clear() | 432 os.environ.clear() |
371 os.environ.update(oldenv) | 433 os.environ.update(oldenv) |
372 | 434 |
373 self.assertRaises(TypeError, posixpath.expandvars) | 435 self.assertRaises(TypeError, posixpath.expandvars) |
374 | 436 |
375 def test_normpath(self): | 437 def test_normpath(self): |
376 self.assertEqual(posixpath.normpath(""), ".") | 438 self.assertEqual(posixpath.normpath(""), ".") |
377 self.assertEqual(posixpath.normpath("/"), "/") | 439 self.assertEqual(posixpath.normpath("/"), "/") |
378 self.assertEqual(posixpath.normpath("//"), "//") | 440 self.assertEqual(posixpath.normpath("//"), "//") |
379 self.assertEqual(posixpath.normpath("///"), "/") | 441 self.assertEqual(posixpath.normpath("///"), "/") |
380 self.assertEqual(posixpath.normpath("///foo/.//bar//"), "/foo/bar") | 442 self.assertEqual(posixpath.normpath("///foo/.//bar//"), "/foo/bar") |
381 self.assertEqual(posixpath.normpath("///foo/.//bar//.//..//.//baz"), "/f
oo/baz") | 443 self.assertEqual(posixpath.normpath("///foo/.//bar//.//..//.//baz"), "/f
oo/baz") |
382 self.assertEqual(posixpath.normpath("///..//./foo/.//bar"), "/foo/bar") | 444 self.assertEqual(posixpath.normpath("///..//./foo/.//bar"), "/foo/bar") |
383 | 445 |
| 446 self.assertEqual(posixpath.normpath(b""), b".") |
| 447 self.assertEqual(posixpath.normpath(b"/"), b"/") |
| 448 self.assertEqual(posixpath.normpath(b"//"), b"//") |
| 449 self.assertEqual(posixpath.normpath(b"///"), b"/") |
| 450 self.assertEqual(posixpath.normpath(b"///foo/.//bar//"), b"/foo/bar") |
| 451 self.assertEqual(posixpath.normpath(b"///foo/.//bar//.//..//.//baz"), b"
/foo/baz") |
| 452 self.assertEqual(posixpath.normpath(b"///..//./foo/.//bar"), b"/foo/bar"
) |
| 453 |
384 self.assertRaises(TypeError, posixpath.normpath) | 454 self.assertRaises(TypeError, posixpath.normpath) |
385 | 455 |
386 def test_abspath(self): | 456 def test_abspath(self): |
387 self.assert_("foo" in posixpath.abspath("foo")) | 457 self.assert_("foo" in posixpath.abspath("foo")) |
| 458 self.assert_(b"foo" in posixpath.abspath(b"foo")) |
388 | 459 |
389 self.assertRaises(TypeError, posixpath.abspath) | 460 self.assertRaises(TypeError, posixpath.abspath) |
390 | 461 |
391 def test_realpath(self): | 462 def test_realpath(self): |
392 self.assert_("foo" in realpath("foo")) | 463 self.assert_("foo" in realpath("foo")) |
| 464 self.assert_(b"foo" in realpath(b"foo")) |
393 self.assertRaises(TypeError, posixpath.realpath) | 465 self.assertRaises(TypeError, posixpath.realpath) |
394 | 466 |
395 if hasattr(os, "symlink"): | 467 if hasattr(os, "symlink"): |
396 def test_realpath_basic(self): | 468 def test_realpath_basic(self): |
397 # Basic operation. | 469 # Basic operation. |
398 try: | 470 try: |
399 os.symlink(ABSTFN+"1", ABSTFN) | 471 os.symlink(ABSTFN+"1", ABSTFN) |
400 self.assertEqual(realpath(ABSTFN), ABSTFN+"1") | 472 self.assertEqual(realpath(ABSTFN), ABSTFN+"1") |
401 finally: | 473 finally: |
402 support.unlink(ABSTFN) | 474 support.unlink(ABSTFN) |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
498 self.assertEqual(posixpath.relpath(posixpath.abspath("a")), "a") | 570 self.assertEqual(posixpath.relpath(posixpath.abspath("a")), "a") |
499 self.assertEqual(posixpath.relpath("a/b"), "a/b") | 571 self.assertEqual(posixpath.relpath("a/b"), "a/b") |
500 self.assertEqual(posixpath.relpath("../a/b"), "../a/b") | 572 self.assertEqual(posixpath.relpath("../a/b"), "../a/b") |
501 self.assertEqual(posixpath.relpath("a", "../b"), "../"+curdir+"/a") | 573 self.assertEqual(posixpath.relpath("a", "../b"), "../"+curdir+"/a") |
502 self.assertEqual(posixpath.relpath("a/b", "../c"), "../"+curdir+"/a/
b") | 574 self.assertEqual(posixpath.relpath("a/b", "../c"), "../"+curdir+"/a/
b") |
503 self.assertEqual(posixpath.relpath("a", "b/c"), "../../a") | 575 self.assertEqual(posixpath.relpath("a", "b/c"), "../../a") |
504 self.assertEqual(posixpath.relpath("a", "a"), ".") | 576 self.assertEqual(posixpath.relpath("a", "a"), ".") |
505 finally: | 577 finally: |
506 os.getcwd = real_getcwd | 578 os.getcwd = real_getcwd |
507 | 579 |
| 580 def test_relpath_bytes(self): |
| 581 (real_getcwdb, os.getcwdb) = (os.getcwdb, lambda: br"/home/user/bar") |
| 582 try: |
| 583 curdir = os.path.split(os.getcwdb())[-1] |
| 584 self.assertRaises(ValueError, posixpath.relpath, b"") |
| 585 self.assertEqual(posixpath.relpath(b"a"), b"a") |
| 586 self.assertEqual(posixpath.relpath(posixpath.abspath(b"a")), b"a") |
| 587 self.assertEqual(posixpath.relpath(b"a/b"), b"a/b") |
| 588 self.assertEqual(posixpath.relpath(b"../a/b"), b"../a/b") |
| 589 self.assertEqual(posixpath.relpath(b"a", b"../b"), b"../"+curdir+b"/
a") |
| 590 self.assertEqual(posixpath.relpath(b"a/b", b"../c"), b"../"+curdir+b
"/a/b") |
| 591 self.assertEqual(posixpath.relpath(b"a", b"b/c"), b"../../a") |
| 592 self.assertEqual(posixpath.relpath(b"a", b"a"), b".") |
| 593 |
| 594 self.assertRaises(TypeError, posixpath.relpath, b"bytes", "str") |
| 595 self.assertRaises(TypeError, posixpath.relpath, "str", b"bytes") |
| 596 finally: |
| 597 os.getcwdb = real_getcwdb |
| 598 |
508 def test_main(): | 599 def test_main(): |
509 support.run_unittest(PosixPathTest) | 600 support.run_unittest(PosixPathTest) |
510 | 601 |
511 if __name__=="__main__": | 602 if __name__=="__main__": |
512 test_main() | 603 test_main() |
OLD | NEW |