Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 1 | """ |
| 2 | Tests common to genericpath, macpath, ntpath and posixpath |
| 3 | """ |
| 4 | |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 5 | import genericpath |
Victor Stinner | 1ab6c2d | 2011-11-15 22:27:41 +0100 | [diff] [blame] | 6 | import os |
Victor Stinner | 1efde67 | 2010-04-18 08:23:42 +0000 | [diff] [blame] | 7 | import sys |
Victor Stinner | 1ab6c2d | 2011-11-15 22:27:41 +0100 | [diff] [blame] | 8 | import unittest |
| 9 | import warnings |
| 10 | from test import support |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 11 | |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 12 | |
| 13 | def safe_rmdir(dirname): |
| 14 | try: |
| 15 | os.rmdir(dirname) |
| 16 | except OSError: |
| 17 | pass |
| 18 | |
| 19 | |
Ezio Melotti | d0dfe9a | 2013-01-10 03:12:50 +0200 | [diff] [blame] | 20 | class GenericTest: |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 21 | common_attributes = ['commonprefix', 'getsize', 'getatime', 'getctime', |
| 22 | 'getmtime', 'exists', 'isdir', 'isfile'] |
| 23 | attributes = [] |
| 24 | |
| 25 | def test_no_argument(self): |
| 26 | for attr in self.common_attributes + self.attributes: |
| 27 | with self.assertRaises(TypeError): |
| 28 | getattr(self.pathmodule, attr)() |
| 29 | raise self.fail("{}.{}() did not raise a TypeError" |
| 30 | .format(self.pathmodule.__name__, attr)) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 31 | |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 32 | def test_commonprefix(self): |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 33 | commonprefix = self.pathmodule.commonprefix |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 34 | self.assertEqual( |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 35 | commonprefix([]), |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 36 | "" |
| 37 | ) |
| 38 | self.assertEqual( |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 39 | commonprefix(["/home/swenson/spam", "/home/swen/spam"]), |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 40 | "/home/swen" |
| 41 | ) |
| 42 | self.assertEqual( |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 43 | commonprefix(["/home/swen/spam", "/home/swen/eggs"]), |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 44 | "/home/swen/" |
| 45 | ) |
| 46 | self.assertEqual( |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 47 | commonprefix(["/home/swen/spam", "/home/swen/spam"]), |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 48 | "/home/swen/spam" |
| 49 | ) |
Florent Xicluna | e3ed2e0 | 2010-03-08 12:42:20 +0000 | [diff] [blame] | 50 | self.assertEqual( |
| 51 | commonprefix(["home:swenson:spam", "home:swen:spam"]), |
| 52 | "home:swen" |
| 53 | ) |
| 54 | self.assertEqual( |
| 55 | commonprefix([":home:swen:spam", ":home:swen:eggs"]), |
| 56 | ":home:swen:" |
| 57 | ) |
| 58 | self.assertEqual( |
| 59 | commonprefix([":home:swen:spam", ":home:swen:spam"]), |
| 60 | ":home:swen:spam" |
| 61 | ) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 62 | |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 63 | self.assertEqual( |
| 64 | commonprefix([b"/home/swenson/spam", b"/home/swen/spam"]), |
| 65 | b"/home/swen" |
| 66 | ) |
| 67 | self.assertEqual( |
| 68 | commonprefix([b"/home/swen/spam", b"/home/swen/eggs"]), |
| 69 | b"/home/swen/" |
| 70 | ) |
| 71 | self.assertEqual( |
| 72 | commonprefix([b"/home/swen/spam", b"/home/swen/spam"]), |
| 73 | b"/home/swen/spam" |
| 74 | ) |
Florent Xicluna | e3ed2e0 | 2010-03-08 12:42:20 +0000 | [diff] [blame] | 75 | self.assertEqual( |
| 76 | commonprefix([b"home:swenson:spam", b"home:swen:spam"]), |
| 77 | b"home:swen" |
| 78 | ) |
| 79 | self.assertEqual( |
| 80 | commonprefix([b":home:swen:spam", b":home:swen:eggs"]), |
| 81 | b":home:swen:" |
| 82 | ) |
| 83 | self.assertEqual( |
| 84 | commonprefix([b":home:swen:spam", b":home:swen:spam"]), |
| 85 | b":home:swen:spam" |
| 86 | ) |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 87 | |
| 88 | testlist = ['', 'abc', 'Xbcd', 'Xb', 'XY', 'abcd', |
| 89 | 'aXc', 'abd', 'ab', 'aX', 'abcX'] |
| 90 | for s1 in testlist: |
| 91 | for s2 in testlist: |
| 92 | p = commonprefix([s1, s2]) |
| 93 | self.assertTrue(s1.startswith(p)) |
| 94 | self.assertTrue(s2.startswith(p)) |
| 95 | if s1 != s2: |
| 96 | n = len(p) |
| 97 | self.assertNotEqual(s1[n:n+1], s2[n:n+1]) |
| 98 | |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 99 | def test_getsize(self): |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 100 | f = open(support.TESTFN, "wb") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 101 | try: |
Guido van Rossum | 199fc75 | 2007-08-27 23:38:12 +0000 | [diff] [blame] | 102 | f.write(b"foo") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 103 | f.close() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 104 | self.assertEqual(self.pathmodule.getsize(support.TESTFN), 3) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 105 | finally: |
| 106 | if not f.closed: |
| 107 | f.close() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 108 | support.unlink(support.TESTFN) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 109 | |
| 110 | def test_time(self): |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 111 | f = open(support.TESTFN, "wb") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 112 | try: |
Guido van Rossum | 199fc75 | 2007-08-27 23:38:12 +0000 | [diff] [blame] | 113 | f.write(b"foo") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 114 | f.close() |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 115 | f = open(support.TESTFN, "ab") |
Guido van Rossum | 199fc75 | 2007-08-27 23:38:12 +0000 | [diff] [blame] | 116 | f.write(b"bar") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 117 | f.close() |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 118 | f = open(support.TESTFN, "rb") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 119 | d = f.read() |
| 120 | f.close() |
Guido van Rossum | dc12288 | 2007-07-10 12:09:13 +0000 | [diff] [blame] | 121 | self.assertEqual(d, b"foobar") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 122 | |
Ezio Melotti | a11865b | 2010-02-20 09:47:55 +0000 | [diff] [blame] | 123 | self.assertLessEqual( |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 124 | self.pathmodule.getctime(support.TESTFN), |
| 125 | self.pathmodule.getmtime(support.TESTFN) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 126 | ) |
| 127 | finally: |
| 128 | if not f.closed: |
| 129 | f.close() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 130 | support.unlink(support.TESTFN) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 131 | |
| 132 | def test_exists(self): |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 133 | self.assertIs(self.pathmodule.exists(support.TESTFN), False) |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 134 | f = open(support.TESTFN, "wb") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 135 | try: |
Guido van Rossum | 199fc75 | 2007-08-27 23:38:12 +0000 | [diff] [blame] | 136 | f.write(b"foo") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 137 | f.close() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 138 | self.assertIs(self.pathmodule.exists(support.TESTFN), True) |
| 139 | if not self.pathmodule == genericpath: |
| 140 | self.assertIs(self.pathmodule.lexists(support.TESTFN), |
| 141 | True) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 142 | finally: |
| 143 | if not f.close(): |
| 144 | f.close() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 145 | support.unlink(support.TESTFN) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 146 | |
Richard Oudkerk | 2240ac1 | 2012-07-06 12:05:32 +0100 | [diff] [blame] | 147 | @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()") |
| 148 | def test_exists_fd(self): |
| 149 | r, w = os.pipe() |
| 150 | try: |
| 151 | self.assertTrue(self.pathmodule.exists(r)) |
| 152 | finally: |
| 153 | os.close(r) |
| 154 | os.close(w) |
| 155 | self.assertFalse(self.pathmodule.exists(r)) |
| 156 | |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 157 | def test_isdir(self): |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 158 | self.assertIs(self.pathmodule.isdir(support.TESTFN), False) |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 159 | f = open(support.TESTFN, "wb") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 160 | try: |
Guido van Rossum | 199fc75 | 2007-08-27 23:38:12 +0000 | [diff] [blame] | 161 | f.write(b"foo") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 162 | f.close() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 163 | self.assertIs(self.pathmodule.isdir(support.TESTFN), False) |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 164 | os.remove(support.TESTFN) |
| 165 | os.mkdir(support.TESTFN) |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 166 | self.assertIs(self.pathmodule.isdir(support.TESTFN), True) |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 167 | os.rmdir(support.TESTFN) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 168 | finally: |
| 169 | if not f.close(): |
| 170 | f.close() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 171 | support.unlink(support.TESTFN) |
| 172 | safe_rmdir(support.TESTFN) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 173 | |
| 174 | def test_isfile(self): |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 175 | self.assertIs(self.pathmodule.isfile(support.TESTFN), False) |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 176 | f = open(support.TESTFN, "wb") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 177 | try: |
Guido van Rossum | 199fc75 | 2007-08-27 23:38:12 +0000 | [diff] [blame] | 178 | f.write(b"foo") |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 179 | f.close() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 180 | self.assertIs(self.pathmodule.isfile(support.TESTFN), True) |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 181 | os.remove(support.TESTFN) |
| 182 | os.mkdir(support.TESTFN) |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 183 | self.assertIs(self.pathmodule.isfile(support.TESTFN), False) |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 184 | os.rmdir(support.TESTFN) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 185 | finally: |
| 186 | if not f.close(): |
| 187 | f.close() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 188 | support.unlink(support.TESTFN) |
| 189 | safe_rmdir(support.TESTFN) |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 190 | |
Ezio Melotti | d0dfe9a | 2013-01-10 03:12:50 +0200 | [diff] [blame] | 191 | class TestGenericTest(GenericTest, unittest.TestCase): |
| 192 | # Issue 16852: GenericTest can't inherit from unittest.TestCase |
| 193 | # for test discovery purposes; CommonTest inherits from GenericTest |
| 194 | # and is only meant to be inherited by others. |
| 195 | pathmodule = genericpath |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 196 | |
Florent Xicluna | 87082ee | 2010-08-09 17:18:05 +0000 | [diff] [blame] | 197 | # Following TestCase is not supposed to be run from test_genericpath. |
| 198 | # It is inherited by other test modules (macpath, ntpath, posixpath). |
| 199 | |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 200 | class CommonTest(GenericTest): |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 201 | common_attributes = GenericTest.common_attributes + [ |
| 202 | # Properties |
| 203 | 'curdir', 'pardir', 'extsep', 'sep', |
| 204 | 'pathsep', 'defpath', 'altsep', 'devnull', |
| 205 | # Methods |
| 206 | 'normcase', 'splitdrive', 'expandvars', 'normpath', 'abspath', |
| 207 | 'join', 'split', 'splitext', 'isabs', 'basename', 'dirname', |
| 208 | 'lexists', 'islink', 'ismount', 'expanduser', 'normpath', 'realpath', |
| 209 | ] |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 210 | |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 211 | def test_normcase(self): |
Ezio Melotti | 5a3ef5b | 2010-06-25 10:56:11 +0000 | [diff] [blame] | 212 | normcase = self.pathmodule.normcase |
| 213 | # check that normcase() is idempotent |
| 214 | for p in ["FoO/./BaR", b"FoO/./BaR"]: |
| 215 | p = normcase(p) |
| 216 | self.assertEqual(p, normcase(p)) |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 217 | |
Ezio Melotti | 5a3ef5b | 2010-06-25 10:56:11 +0000 | [diff] [blame] | 218 | self.assertEqual(normcase(''), '') |
| 219 | self.assertEqual(normcase(b''), b'') |
| 220 | |
| 221 | # check that normcase raises a TypeError for invalid types |
| 222 | for path in (None, True, 0, 2.5, [], bytearray(b''), {'o','o'}): |
| 223 | self.assertRaises(TypeError, normcase, path) |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 224 | |
| 225 | def test_splitdrive(self): |
| 226 | # splitdrive for non-NT paths |
| 227 | splitdrive = self.pathmodule.splitdrive |
| 228 | self.assertEqual(splitdrive("/foo/bar"), ("", "/foo/bar")) |
| 229 | self.assertEqual(splitdrive("foo:bar"), ("", "foo:bar")) |
| 230 | self.assertEqual(splitdrive(":foo:bar"), ("", ":foo:bar")) |
| 231 | |
| 232 | self.assertEqual(splitdrive(b"/foo/bar"), (b"", b"/foo/bar")) |
| 233 | self.assertEqual(splitdrive(b"foo:bar"), (b"", b"foo:bar")) |
| 234 | self.assertEqual(splitdrive(b":foo:bar"), (b"", b":foo:bar")) |
| 235 | |
| 236 | def test_expandvars(self): |
| 237 | if self.pathmodule.__name__ == 'macpath': |
| 238 | self.skipTest('macpath.expandvars is a stub') |
| 239 | expandvars = self.pathmodule.expandvars |
| 240 | with support.EnvironmentVarGuard() as env: |
| 241 | env.clear() |
| 242 | env["foo"] = "bar" |
| 243 | env["{foo"] = "baz1" |
| 244 | env["{foo}"] = "baz2" |
| 245 | self.assertEqual(expandvars("foo"), "foo") |
| 246 | self.assertEqual(expandvars("$foo bar"), "bar bar") |
| 247 | self.assertEqual(expandvars("${foo}bar"), "barbar") |
| 248 | self.assertEqual(expandvars("$[foo]bar"), "$[foo]bar") |
| 249 | self.assertEqual(expandvars("$bar bar"), "$bar bar") |
| 250 | self.assertEqual(expandvars("$?bar"), "$?bar") |
| 251 | self.assertEqual(expandvars("${foo}bar"), "barbar") |
| 252 | self.assertEqual(expandvars("$foo}bar"), "bar}bar") |
| 253 | self.assertEqual(expandvars("${foo"), "${foo") |
| 254 | self.assertEqual(expandvars("${{foo}}"), "baz1}") |
| 255 | self.assertEqual(expandvars("$foo$foo"), "barbar") |
| 256 | self.assertEqual(expandvars("$bar$bar"), "$bar$bar") |
| 257 | |
| 258 | self.assertEqual(expandvars(b"foo"), b"foo") |
| 259 | self.assertEqual(expandvars(b"$foo bar"), b"bar bar") |
| 260 | self.assertEqual(expandvars(b"${foo}bar"), b"barbar") |
| 261 | self.assertEqual(expandvars(b"$[foo]bar"), b"$[foo]bar") |
| 262 | self.assertEqual(expandvars(b"$bar bar"), b"$bar bar") |
| 263 | self.assertEqual(expandvars(b"$?bar"), b"$?bar") |
| 264 | self.assertEqual(expandvars(b"${foo}bar"), b"barbar") |
| 265 | self.assertEqual(expandvars(b"$foo}bar"), b"bar}bar") |
| 266 | self.assertEqual(expandvars(b"${foo"), b"${foo") |
| 267 | self.assertEqual(expandvars(b"${{foo}}"), b"baz1}") |
| 268 | self.assertEqual(expandvars(b"$foo$foo"), b"barbar") |
| 269 | self.assertEqual(expandvars(b"$bar$bar"), b"$bar$bar") |
| 270 | |
| 271 | def test_abspath(self): |
| 272 | self.assertIn("foo", self.pathmodule.abspath("foo")) |
Victor Stinner | 1ab6c2d | 2011-11-15 22:27:41 +0100 | [diff] [blame] | 273 | with warnings.catch_warnings(): |
| 274 | warnings.simplefilter("ignore", DeprecationWarning) |
| 275 | self.assertIn(b"foo", self.pathmodule.abspath(b"foo")) |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 276 | |
| 277 | # Abspath returns bytes when the arg is bytes |
Victor Stinner | f7c5ae2 | 2011-11-16 23:43:07 +0100 | [diff] [blame] | 278 | with warnings.catch_warnings(): |
| 279 | warnings.simplefilter("ignore", DeprecationWarning) |
| 280 | for path in (b'', b'foo', b'f\xf2\xf2', b'/foo', b'C:\\'): |
| 281 | self.assertIsInstance(self.pathmodule.abspath(path), bytes) |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 282 | |
| 283 | def test_realpath(self): |
| 284 | self.assertIn("foo", self.pathmodule.realpath("foo")) |
Victor Stinner | 1ab6c2d | 2011-11-15 22:27:41 +0100 | [diff] [blame] | 285 | with warnings.catch_warnings(): |
| 286 | warnings.simplefilter("ignore", DeprecationWarning) |
| 287 | self.assertIn(b"foo", self.pathmodule.realpath(b"foo")) |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 288 | |
| 289 | def test_normpath_issue5827(self): |
| 290 | # Make sure normpath preserves unicode |
| 291 | for path in ('', '.', '/', '\\', '///foo/.//bar//'): |
| 292 | self.assertIsInstance(self.pathmodule.normpath(path), str) |
| 293 | |
| 294 | def test_abspath_issue3426(self): |
| 295 | # Check that abspath returns unicode when the arg is unicode |
| 296 | # with both ASCII and non-ASCII cwds. |
| 297 | abspath = self.pathmodule.abspath |
| 298 | for path in ('', 'fuu', 'f\xf9\xf9', '/fuu', 'U:\\'): |
| 299 | self.assertIsInstance(abspath(path), str) |
| 300 | |
| 301 | unicwd = '\xe7w\xf0' |
| 302 | try: |
Victor Stinner | 7c7ea62 | 2012-08-01 20:03:49 +0200 | [diff] [blame] | 303 | os.fsencode(unicwd) |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 304 | except (AttributeError, UnicodeEncodeError): |
| 305 | # FS encoding is probably ASCII |
| 306 | pass |
| 307 | else: |
| 308 | with support.temp_cwd(unicwd): |
| 309 | for path in ('', 'fuu', 'f\xf9\xf9', '/fuu', 'U:\\'): |
| 310 | self.assertIsInstance(abspath(path), str) |
| 311 | |
Victor Stinner | 1efde67 | 2010-04-18 08:23:42 +0000 | [diff] [blame] | 312 | def test_nonascii_abspath(self): |
Victor Stinner | 0af71aa | 2013-01-03 01:50:30 +0100 | [diff] [blame] | 313 | if (support.TESTFN_UNDECODABLE |
| 314 | # Mac OS X denies the creation of a directory with an invalid |
| 315 | # UTF-8 name. Windows allows to create a directory with an |
| 316 | # arbitrary bytes name, but fails to enter this directory |
| 317 | # (when the bytes name is used). |
| 318 | and sys.platform not in ('win32', 'darwin')): |
| 319 | name = support.TESTFN_UNDECODABLE |
| 320 | elif support.TESTFN_NONASCII: |
| 321 | name = support.TESTFN_NONASCII |
| 322 | else: |
| 323 | self.skipTest("need support.TESTFN_NONASCII") |
Victor Stinner | 7c7ea62 | 2012-08-01 20:03:49 +0200 | [diff] [blame] | 324 | |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 325 | # Test non-ASCII, non-UTF8 bytes in the path. |
Victor Stinner | 1ab6c2d | 2011-11-15 22:27:41 +0100 | [diff] [blame] | 326 | with warnings.catch_warnings(): |
| 327 | warnings.simplefilter("ignore", DeprecationWarning) |
Victor Stinner | 7c7ea62 | 2012-08-01 20:03:49 +0200 | [diff] [blame] | 328 | with support.temp_cwd(name): |
Victor Stinner | 1ab6c2d | 2011-11-15 22:27:41 +0100 | [diff] [blame] | 329 | self.test_abspath() |
Florent Xicluna | c9c7978 | 2010-03-08 12:24:53 +0000 | [diff] [blame] | 330 | |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 331 | |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 332 | if __name__=="__main__": |
Ezio Melotti | d0dfe9a | 2013-01-10 03:12:50 +0200 | [diff] [blame] | 333 | unittest.main() |