Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(697)

Side by Side Diff: Lib/test/test_posixpath.py

Issue 3055: combined patches from http://bugs.python.org/issue3187 (Closed) Base URL: http://svn.python.org/view/*checkout*/python/branches/py3k/
Patch Set: More complete patch from Victor Created 15 years, 6 months ago , Downloaded from: http://bugs.python.org/file11667/python3_bytes_filename-2.patch
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View unified diff | Download patch
OLDNEW
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
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")
GvR 2008/10/01 00:00:31 Please keep line lengths < 80 chars.
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
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
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
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()
OLDNEW
« Lib/io.py ('K') | « Lib/test/test_posix.py ('k') | Lib/test/test_unicode_file.py » ('j') | no next file with comments »

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b