Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython3 / 92521fea5d0d4aeb9b6a3c3fdd4654af700ad5c8 / . / Lib / test / test_ntpath.py
blob: 2f0faf94726fd2742b2d8a256af67614242b5279 [file] [log] [blame]
Guido van Rossumead9d8d1999-02-03 17:21:21 +0000[diff] [blame]1import ntpath
Mark Hammond673c6cf2000-08-14 06:21:26 +0000[diff] [blame]2import os
Brian Curtin13a0db52010-09-06 19:46:17 +0000[diff] [blame]3import sys
Victor Stinner1ab6c2d2011-11-15 22:27:41 +0100[diff] [blame]4import unittest
5import warnings
Serhiy Storchakab21d1552018-03-02 11:53:51 +0200[diff] [blame]6from test.support import TestFailed, FakePath
Florent Xiclunac9c79782010-03-08 12:24:53 +0000[diff] [blame]7from test import support, test_genericpath
Brian Curtin62857742010-09-06 17:07:27 +0000[diff] [blame]8from tempfile import TemporaryFile
Guido van Rossumead9d8d1999-02-03 17:21:21 +0000[diff] [blame]9
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]10
Steve Dower23ad6d02018-02-22 10:39:10 -0800[diff] [blame]11try:
12 import nt
13except ImportError:
14 # Most tests can complete without the nt module,
15 # but for those that require it we import here.
16 nt = None
Guido van Rossumead9d8d1999-02-03 17:21:21 +0000[diff] [blame]17
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]18try:
19 ntpath._getfinalpathname
20except AttributeError:
21 HAVE_GETFINALPATHNAME = False
22else:
23 HAVE_GETFINALPATHNAME = True
24
25
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]26def _norm(path):
27 if isinstance(path, (bytes, str, os.PathLike)):
28 return ntpath.normcase(os.fsdecode(path))
29 elif hasattr(path, "__iter__"):
30 return tuple(ntpath.normcase(os.fsdecode(p)) for p in path)
31 return path
32
33
Guido van Rossumead9d8d1999-02-03 17:21:21 +0000[diff] [blame]34def tester(fn, wantResult):
Eric S. Raymondfc170b12001-02-09 11:51:27 +0000[diff] [blame]35 fn = fn.replace("\\", "\\\\")
Fred Drake004d5e62000-10-23 17:22:08 +0000[diff] [blame]36 gotResult = eval(fn)
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]37 if wantResult != gotResult and _norm(wantResult) != _norm(gotResult):
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]38 raise TestFailed("%s should return: %s but returned: %s" \
39 %(str(fn), str(wantResult), str(gotResult)))
Tim Peters6578dc92002-12-24 18:31:27 +0000[diff] [blame]40
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000[diff] [blame]41 # then with bytes
42 fn = fn.replace("('", "(b'")
43 fn = fn.replace('("', '(b"')
44 fn = fn.replace("['", "[b'")
45 fn = fn.replace('["', '[b"')
46 fn = fn.replace(", '", ", b'")
47 fn = fn.replace(', "', ', b"')
Serhiy Storchakadbb10192014-02-13 10:13:53 +0200[diff] [blame]48 fn = os.fsencode(fn).decode('latin1')
49 fn = fn.encode('ascii', 'backslashreplace').decode('ascii')
Victor Stinner1ab6c2d2011-11-15 22:27:41 +0100[diff] [blame]50 with warnings.catch_warnings():
51 warnings.simplefilter("ignore", DeprecationWarning)
52 gotResult = eval(fn)
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]53 if _norm(wantResult) != _norm(gotResult):
Amaury Forgeot d'Arcc72ef8b2008-10-03 18:38:26 +0000[diff] [blame]54 raise TestFailed("%s should return: %s but returned: %s" \
55 %(str(fn), str(wantResult), repr(gotResult)))
Guido van Rossumead9d8d1999-02-03 17:21:21 +0000[diff] [blame]56
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]57
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]58class NtpathTestCase(unittest.TestCase):
59 def assertPathEqual(self, path1, path2):
60 if path1 == path2 or _norm(path1) == _norm(path2):
61 return
62 self.assertEqual(path1, path2)
63
64 def assertPathIn(self, path, pathset):
65 self.assertIn(_norm(path), _norm(pathset))
66
67
68class TestNtpath(NtpathTestCase):
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]69 def test_splitext(self):
70 tester('ntpath.splitext("foo.ext")', ('foo', '.ext'))
71 tester('ntpath.splitext("/foo/foo.ext")', ('/foo/foo', '.ext'))
72 tester('ntpath.splitext(".ext")', ('.ext', ''))
73 tester('ntpath.splitext("\\foo.ext\\foo")', ('\\foo.ext\\foo', ''))
74 tester('ntpath.splitext("foo.ext\\")', ('foo.ext\\', ''))
75 tester('ntpath.splitext("")', ('', ''))
76 tester('ntpath.splitext("foo.bar.ext")', ('foo.bar', '.ext'))
77 tester('ntpath.splitext("xx/foo.bar.ext")', ('xx/foo.bar', '.ext'))
78 tester('ntpath.splitext("xx\\foo.bar.ext")', ('xx\\foo.bar', '.ext'))
79 tester('ntpath.splitext("c:a/b\\c.d")', ('c:a/b\\c', '.d'))
Guido van Rossumead9d8d1999-02-03 17:21:21 +0000[diff] [blame]80
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]81 def test_splitdrive(self):
82 tester('ntpath.splitdrive("c:\\foo\\bar")',
83 ('c:', '\\foo\\bar'))
84 tester('ntpath.splitdrive("c:/foo/bar")',
85 ('c:', '/foo/bar'))
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]86 tester('ntpath.splitdrive("\\\\conky\\mountpoint\\foo\\bar")',
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]87 ('\\\\conky\\mountpoint', '\\foo\\bar'))
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]88 tester('ntpath.splitdrive("//conky/mountpoint/foo/bar")',
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]89 ('//conky/mountpoint', '/foo/bar'))
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]90 tester('ntpath.splitdrive("\\\\\\conky\\mountpoint\\foo\\bar")',
91 ('', '\\\\\\conky\\mountpoint\\foo\\bar'))
92 tester('ntpath.splitdrive("///conky/mountpoint/foo/bar")',
93 ('', '///conky/mountpoint/foo/bar'))
94 tester('ntpath.splitdrive("\\\\conky\\\\mountpoint\\foo\\bar")',
95 ('', '\\\\conky\\\\mountpoint\\foo\\bar'))
96 tester('ntpath.splitdrive("//conky//mountpoint/foo/bar")',
97 ('', '//conky//mountpoint/foo/bar'))
Serhiy Storchaka3d7e1152013-12-16 14:34:55 +0200[diff] [blame]98 # Issue #19911: UNC part containing U+0130
99 self.assertEqual(ntpath.splitdrive('//conky/MOUNTPOİNT/foo/bar'),
100 ('//conky/MOUNTPOİNT', '/foo/bar'))
Guido van Rossumead9d8d1999-02-03 17:21:21 +0000[diff] [blame]101
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]102 def test_split(self):
103 tester('ntpath.split("c:\\foo\\bar")', ('c:\\foo', 'bar'))
104 tester('ntpath.split("\\\\conky\\mountpoint\\foo\\bar")',
105 ('\\\\conky\\mountpoint\\foo', 'bar'))
Guido van Rossumead9d8d1999-02-03 17:21:21 +0000[diff] [blame]106
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]107 tester('ntpath.split("c:\\")', ('c:\\', ''))
108 tester('ntpath.split("\\\\conky\\mountpoint\\")',
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]109 ('\\\\conky\\mountpoint\\', ''))
Guido van Rossumead9d8d1999-02-03 17:21:21 +0000[diff] [blame]110
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]111 tester('ntpath.split("c:/")', ('c:/', ''))
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]112 tester('ntpath.split("//conky/mountpoint/")', ('//conky/mountpoint/', ''))
Mark Hammond673c6cf2000-08-14 06:21:26 +0000[diff] [blame]113
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]114 def test_isabs(self):
115 tester('ntpath.isabs("c:\\")', 1)
116 tester('ntpath.isabs("\\\\conky\\mountpoint\\")', 1)
117 tester('ntpath.isabs("\\foo")', 1)
118 tester('ntpath.isabs("\\foo\\bar")', 1)
Tim Petersd4f7f602001-07-19 19:11:41 +0000[diff] [blame]119
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]120 def test_commonprefix(self):
121 tester('ntpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"])',
122 "/home/swen")
123 tester('ntpath.commonprefix(["\\home\\swen\\spam", "\\home\\swen\\eggs"])',
124 "\\home\\swen\\")
125 tester('ntpath.commonprefix(["/home/swen/spam", "/home/swen/spam"])',
126 "/home/swen/spam")
Tim Peters6a3e5f12001-11-05 21:25:02 +0000[diff] [blame]127
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]128 def test_join(self):
129 tester('ntpath.join("")', '')
130 tester('ntpath.join("", "", "")', '')
131 tester('ntpath.join("a")', 'a')
132 tester('ntpath.join("/a")', '/a')
133 tester('ntpath.join("\\a")', '\\a')
134 tester('ntpath.join("a:")', 'a:')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]135 tester('ntpath.join("a:", "\\b")', 'a:\\b')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]136 tester('ntpath.join("a", "\\b")', '\\b')
137 tester('ntpath.join("a", "b", "c")', 'a\\b\\c')
138 tester('ntpath.join("a\\", "b", "c")', 'a\\b\\c')
139 tester('ntpath.join("a", "b\\", "c")', 'a\\b\\c')
140 tester('ntpath.join("a", "b", "\\c")', '\\c')
141 tester('ntpath.join("d:\\", "\\pleep")', 'd:\\pleep')
142 tester('ntpath.join("d:\\", "a", "b")', 'd:\\a\\b')
Tim Peters54a14a32001-08-30 22:05:26 +0000[diff] [blame]143
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]144 tester("ntpath.join('', 'a')", 'a')
145 tester("ntpath.join('', '', '', '', 'a')", 'a')
146 tester("ntpath.join('a', '')", 'a\\')
147 tester("ntpath.join('a', '', '', '', '')", 'a\\')
148 tester("ntpath.join('a\\', '')", 'a\\')
149 tester("ntpath.join('a\\', '', '', '', '')", 'a\\')
Serhiy Storchakac369c2c2014-01-27 23:15:14 +0200[diff] [blame]150 tester("ntpath.join('a/', '')", 'a/')
Tim Peters54a14a32001-08-30 22:05:26 +0000[diff] [blame]151
Serhiy Storchakac369c2c2014-01-27 23:15:14 +0200[diff] [blame]152 tester("ntpath.join('a/b', 'x/y')", 'a/b\\x/y')
153 tester("ntpath.join('/a/b', 'x/y')", '/a/b\\x/y')
154 tester("ntpath.join('/a/b/', 'x/y')", '/a/b/x/y')
155 tester("ntpath.join('c:', 'x/y')", 'c:x/y')
156 tester("ntpath.join('c:a/b', 'x/y')", 'c:a/b\\x/y')
157 tester("ntpath.join('c:a/b/', 'x/y')", 'c:a/b/x/y')
158 tester("ntpath.join('c:/', 'x/y')", 'c:/x/y')
159 tester("ntpath.join('c:/a/b', 'x/y')", 'c:/a/b\\x/y')
160 tester("ntpath.join('c:/a/b/', 'x/y')", 'c:/a/b/x/y')
161 tester("ntpath.join('//computer/share', 'x/y')", '//computer/share\\x/y')
162 tester("ntpath.join('//computer/share/', 'x/y')", '//computer/share/x/y')
163 tester("ntpath.join('//computer/share/a/b', 'x/y')", '//computer/share/a/b\\x/y')
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]164
Serhiy Storchakac369c2c2014-01-27 23:15:14 +0200[diff] [blame]165 tester("ntpath.join('a/b', '/x/y')", '/x/y')
166 tester("ntpath.join('/a/b', '/x/y')", '/x/y')
167 tester("ntpath.join('c:', '/x/y')", 'c:/x/y')
168 tester("ntpath.join('c:a/b', '/x/y')", 'c:/x/y')
169 tester("ntpath.join('c:/', '/x/y')", 'c:/x/y')
170 tester("ntpath.join('c:/a/b', '/x/y')", 'c:/x/y')
171 tester("ntpath.join('//computer/share', '/x/y')", '//computer/share/x/y')
172 tester("ntpath.join('//computer/share/', '/x/y')", '//computer/share/x/y')
173 tester("ntpath.join('//computer/share/a', '/x/y')", '//computer/share/x/y')
174
175 tester("ntpath.join('c:', 'C:x/y')", 'C:x/y')
176 tester("ntpath.join('c:a/b', 'C:x/y')", 'C:a/b\\x/y')
177 tester("ntpath.join('c:/', 'C:x/y')", 'C:/x/y')
178 tester("ntpath.join('c:/a/b', 'C:x/y')", 'C:/a/b\\x/y')
179
180 for x in ('', 'a/b', '/a/b', 'c:', 'c:a/b', 'c:/', 'c:/a/b',
181 '//computer/share', '//computer/share/', '//computer/share/a/b'):
182 for y in ('d:', 'd:x/y', 'd:/', 'd:/x/y',
183 '//machine/common', '//machine/common/', '//machine/common/x/y'):
184 tester("ntpath.join(%r, %r)" % (x, y), y)
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]185
186 tester("ntpath.join('\\\\computer\\share\\', 'a', 'b')", '\\\\computer\\share\\a\\b')
187 tester("ntpath.join('\\\\computer\\share', 'a', 'b')", '\\\\computer\\share\\a\\b')
188 tester("ntpath.join('\\\\computer\\share', 'a\\b')", '\\\\computer\\share\\a\\b')
189 tester("ntpath.join('//computer/share/', 'a', 'b')", '//computer/share/a\\b')
190 tester("ntpath.join('//computer/share', 'a', 'b')", '//computer/share\\a\\b')
191 tester("ntpath.join('//computer/share', 'a/b')", '//computer/share\\a/b')
192
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]193 def test_normpath(self):
194 tester("ntpath.normpath('A//////././//.//B')", r'A\B')
195 tester("ntpath.normpath('A/./B')", r'A\B')
196 tester("ntpath.normpath('A/foo/../B')", r'A\B')
197 tester("ntpath.normpath('C:A//B')", r'C:A\B')
198 tester("ntpath.normpath('D:A/./B')", r'D:A\B')
199 tester("ntpath.normpath('e:A/foo/../B')", r'e:A\B')
Tim Peters54a14a32001-08-30 22:05:26 +0000[diff] [blame]200
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]201 tester("ntpath.normpath('C:///A//B')", r'C:\A\B')
202 tester("ntpath.normpath('D:///A/./B')", r'D:\A\B')
203 tester("ntpath.normpath('e:///A/foo/../B')", r'e:\A\B')
Thomas Woutersb2137042007-02-01 18:02:27 +0000[diff] [blame]204
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]205 tester("ntpath.normpath('..')", r'..')
206 tester("ntpath.normpath('.')", r'.')
207 tester("ntpath.normpath('')", r'.')
208 tester("ntpath.normpath('/')", '\\')
209 tester("ntpath.normpath('c:/')", 'c:\\')
210 tester("ntpath.normpath('/../.././..')", '\\')
211 tester("ntpath.normpath('c:/../../..')", 'c:\\')
212 tester("ntpath.normpath('../.././..')", r'..\..\..')
213 tester("ntpath.normpath('K:../.././..')", r'K:..\..\..')
214 tester("ntpath.normpath('C:////a/b')", r'C:\a\b')
215 tester("ntpath.normpath('//machine/share//a/b')", r'\\machine\share\a\b')
Fred Drake5e997312002-01-15 03:46:43 +0000[diff] [blame]216
Georg Brandlcfb68212010-07-31 21:40:15 +0000[diff] [blame]217 tester("ntpath.normpath('\\\\.\\NUL')", r'\\.\NUL')
218 tester("ntpath.normpath('\\\\?\\D:/XY\\Z')", r'\\?\D:/XY\Z')
219
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]220 def test_realpath_curdir(self):
221 expected = ntpath.normpath(os.getcwd())
222 tester("ntpath.realpath('.')", expected)
223 tester("ntpath.realpath('./.')", expected)
224 tester("ntpath.realpath('/'.join(['.'] * 100))", expected)
225 tester("ntpath.realpath('.\\.')", expected)
226 tester("ntpath.realpath('\\'.join(['.'] * 100))", expected)
227
228 def test_realpath_pardir(self):
229 expected = ntpath.normpath(os.getcwd())
230 tester("ntpath.realpath('..')", ntpath.dirname(expected))
231 tester("ntpath.realpath('../..')",
232 ntpath.dirname(ntpath.dirname(expected)))
233 tester("ntpath.realpath('/'.join(['..'] * 50))",
234 ntpath.splitdrive(expected)[0] + '\\')
235 tester("ntpath.realpath('..\\..')",
236 ntpath.dirname(ntpath.dirname(expected)))
237 tester("ntpath.realpath('\\'.join(['..'] * 50))",
238 ntpath.splitdrive(expected)[0] + '\\')
239
240 @support.skip_unless_symlink
241 @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
242 def test_realpath_basic(self):
243 ABSTFN = ntpath.abspath(support.TESTFN)
244 open(ABSTFN, "wb").close()
245 self.addCleanup(support.unlink, ABSTFN)
246 self.addCleanup(support.unlink, ABSTFN + "1")
247
248 os.symlink(ABSTFN, ABSTFN + "1")
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]249 self.assertPathEqual(ntpath.realpath(ABSTFN + "1"), ABSTFN)
250 self.assertPathEqual(ntpath.realpath(os.fsencode(ABSTFN + "1")),
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]251 os.fsencode(ABSTFN))
252
253 @support.skip_unless_symlink
254 @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
255 def test_realpath_relative(self):
256 ABSTFN = ntpath.abspath(support.TESTFN)
257 open(ABSTFN, "wb").close()
258 self.addCleanup(support.unlink, ABSTFN)
259 self.addCleanup(support.unlink, ABSTFN + "1")
260
261 os.symlink(ABSTFN, ntpath.relpath(ABSTFN + "1"))
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]262 self.assertPathEqual(ntpath.realpath(ABSTFN + "1"), ABSTFN)
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]263
264 @support.skip_unless_symlink
265 @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
266 def test_realpath_broken_symlinks(self):
267 ABSTFN = ntpath.abspath(support.TESTFN)
268 os.mkdir(ABSTFN)
269 self.addCleanup(support.rmtree, ABSTFN)
270
271 with support.change_cwd(ABSTFN):
272 os.mkdir("subdir")
273 os.chdir("subdir")
274 os.symlink(".", "recursive")
275 os.symlink("..", "parent")
276 os.chdir("..")
277 os.symlink(".", "self")
278 os.symlink("missing", "broken")
279 os.symlink(r"broken\bar", "broken1")
280 os.symlink(r"self\self\broken", "broken2")
281 os.symlink(r"subdir\parent\subdir\parent\broken", "broken3")
282 os.symlink(ABSTFN + r"\broken", "broken4")
283 os.symlink(r"recursive\..\broken", "broken5")
284
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]285 self.assertPathEqual(ntpath.realpath("broken"),
286 ABSTFN + r"\missing")
287 self.assertPathEqual(ntpath.realpath(r"broken\foo"),
288 ABSTFN + r"\missing\foo")
289 self.assertPathEqual(ntpath.realpath(r"broken1"),
290 ABSTFN + r"\missing\bar")
291 self.assertPathEqual(ntpath.realpath(r"broken1\baz"),
292 ABSTFN + r"\missing\bar\baz")
293 self.assertPathEqual(ntpath.realpath("broken2"),
294 ABSTFN + r"\missing")
295 self.assertPathEqual(ntpath.realpath("broken3"),
296 ABSTFN + r"\missing")
297 self.assertPathEqual(ntpath.realpath("broken4"),
298 ABSTFN + r"\missing")
299 self.assertPathEqual(ntpath.realpath("broken5"),
300 ABSTFN + r"\missing")
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]301
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]302 self.assertPathEqual(ntpath.realpath(b"broken"),
303 os.fsencode(ABSTFN + r"\missing"))
304 self.assertPathEqual(ntpath.realpath(rb"broken\foo"),
305 os.fsencode(ABSTFN + r"\missing\foo"))
306 self.assertPathEqual(ntpath.realpath(rb"broken1"),
307 os.fsencode(ABSTFN + r"\missing\bar"))
308 self.assertPathEqual(ntpath.realpath(rb"broken1\baz"),
309 os.fsencode(ABSTFN + r"\missing\bar\baz"))
310 self.assertPathEqual(ntpath.realpath(b"broken2"),
311 os.fsencode(ABSTFN + r"\missing"))
312 self.assertPathEqual(ntpath.realpath(rb"broken3"),
313 os.fsencode(ABSTFN + r"\missing"))
314 self.assertPathEqual(ntpath.realpath(b"broken4"),
315 os.fsencode(ABSTFN + r"\missing"))
316 self.assertPathEqual(ntpath.realpath(b"broken5"),
317 os.fsencode(ABSTFN + r"\missing"))
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]318
319 @support.skip_unless_symlink
320 @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
321 def test_realpath_symlink_loops(self):
322 # Bug #930024, return the path unchanged if we get into an infinite
323 # symlink loop.
324 ABSTFN = ntpath.abspath(support.TESTFN)
325 self.addCleanup(support.unlink, ABSTFN)
326 self.addCleanup(support.unlink, ABSTFN + "1")
327 self.addCleanup(support.unlink, ABSTFN + "2")
328 self.addCleanup(support.unlink, ABSTFN + "y")
329 self.addCleanup(support.unlink, ABSTFN + "c")
330 self.addCleanup(support.unlink, ABSTFN + "a")
331
332 P = "\\\\?\\"
333
334 os.symlink(ABSTFN, ABSTFN)
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]335 self.assertPathEqual(ntpath.realpath(ABSTFN), P + ABSTFN)
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]336
337 # cycles are non-deterministic as to which path is returned, but
338 # it will always be the fully resolved path of one member of the cycle
339 os.symlink(ABSTFN + "1", ABSTFN + "2")
340 os.symlink(ABSTFN + "2", ABSTFN + "1")
341 expected = (P + ABSTFN + "1", P + ABSTFN + "2")
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]342 self.assertPathIn(ntpath.realpath(ABSTFN + "1"), expected)
343 self.assertPathIn(ntpath.realpath(ABSTFN + "2"), expected)
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]344
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]345 self.assertPathIn(ntpath.realpath(ABSTFN + "1\\x"),
346 (ntpath.join(r, "x") for r in expected))
347 self.assertPathEqual(ntpath.realpath(ABSTFN + "1\\.."),
348 ntpath.dirname(ABSTFN))
349 self.assertPathEqual(ntpath.realpath(ABSTFN + "1\\..\\x"),
350 ntpath.dirname(ABSTFN) + "\\x")
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]351 os.symlink(ABSTFN + "x", ABSTFN + "y")
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]352 self.assertPathEqual(ntpath.realpath(ABSTFN + "1\\..\\"
353 + ntpath.basename(ABSTFN) + "y"),
354 ABSTFN + "x")
355 self.assertPathIn(ntpath.realpath(ABSTFN + "1\\..\\"
356 + ntpath.basename(ABSTFN) + "1"),
357 expected)
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]358
359 os.symlink(ntpath.basename(ABSTFN) + "a\\b", ABSTFN + "a")
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]360 self.assertPathEqual(ntpath.realpath(ABSTFN + "a"), P + ABSTFN + "a")
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]361
362 os.symlink("..\\" + ntpath.basename(ntpath.dirname(ABSTFN))
363 + "\\" + ntpath.basename(ABSTFN) + "c", ABSTFN + "c")
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]364 self.assertPathEqual(ntpath.realpath(ABSTFN + "c"), P + ABSTFN + "c")
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]365
366 # Test using relative path as well.
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]367 self.assertPathEqual(ntpath.realpath(ntpath.basename(ABSTFN)), P + ABSTFN)
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]368
369 @support.skip_unless_symlink
370 @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
371 def test_realpath_symlink_prefix(self):
372 ABSTFN = ntpath.abspath(support.TESTFN)
373 self.addCleanup(support.unlink, ABSTFN + "3")
374 self.addCleanup(support.unlink, "\\\\?\\" + ABSTFN + "3.")
375 self.addCleanup(support.unlink, ABSTFN + "3link")
376 self.addCleanup(support.unlink, ABSTFN + "3.link")
377
378 with open(ABSTFN + "3", "wb") as f:
379 f.write(b'0')
380 os.symlink(ABSTFN + "3", ABSTFN + "3link")
381
382 with open("\\\\?\\" + ABSTFN + "3.", "wb") as f:
383 f.write(b'1')
384 os.symlink("\\\\?\\" + ABSTFN + "3.", ABSTFN + "3.link")
385
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]386 self.assertPathEqual(ntpath.realpath(ABSTFN + "3link"),
387 ABSTFN + "3")
388 self.assertPathEqual(ntpath.realpath(ABSTFN + "3.link"),
389 "\\\\?\\" + ABSTFN + "3.")
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]390
391 # Resolved paths should be usable to open target files
392 with open(ntpath.realpath(ABSTFN + "3link"), "rb") as f:
393 self.assertEqual(f.read(), b'0')
394 with open(ntpath.realpath(ABSTFN + "3.link"), "rb") as f:
395 self.assertEqual(f.read(), b'1')
396
397 # When the prefix is included, it is not stripped
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]398 self.assertPathEqual(ntpath.realpath("\\\\?\\" + ABSTFN + "3link"),
399 "\\\\?\\" + ABSTFN + "3")
400 self.assertPathEqual(ntpath.realpath("\\\\?\\" + ABSTFN + "3.link"),
401 "\\\\?\\" + ABSTFN + "3.")
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]402
Steve Dower92521fe2019-09-11 10:48:36 +0100[diff] [blame^]403 @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
404 def test_realpath_nul(self):
405 tester("ntpath.realpath('NUL')", r'\\.\NUL')
406
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]407 def test_expandvars(self):
Walter Dörwald155374d2009-05-01 19:58:58 +0000[diff] [blame]408 with support.EnvironmentVarGuard() as env:
409 env.clear()
410 env["foo"] = "bar"
411 env["{foo"] = "baz1"
412 env["{foo}"] = "baz2"
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]413 tester('ntpath.expandvars("foo")', "foo")
414 tester('ntpath.expandvars("$foo bar")', "bar bar")
415 tester('ntpath.expandvars("${foo}bar")', "barbar")
416 tester('ntpath.expandvars("$[foo]bar")', "$[foo]bar")
417 tester('ntpath.expandvars("$bar bar")', "$bar bar")
418 tester('ntpath.expandvars("$?bar")', "$?bar")
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]419 tester('ntpath.expandvars("$foo}bar")', "bar}bar")
420 tester('ntpath.expandvars("${foo")', "${foo")
421 tester('ntpath.expandvars("${{foo}}")', "baz1}")
422 tester('ntpath.expandvars("$foo$foo")', "barbar")
423 tester('ntpath.expandvars("$bar$bar")', "$bar$bar")
424 tester('ntpath.expandvars("%foo% bar")', "bar bar")
425 tester('ntpath.expandvars("%foo%bar")', "barbar")
426 tester('ntpath.expandvars("%foo%%foo%")', "barbar")
427 tester('ntpath.expandvars("%%foo%%foo%foo%")', "%foo%foobar")
428 tester('ntpath.expandvars("%?bar%")', "%?bar%")
429 tester('ntpath.expandvars("%foo%%bar")', "bar%bar")
430 tester('ntpath.expandvars("\'%foo%\'%bar")', "\'%foo%\'%bar")
Serhiy Storchaka1b87ae02015-03-25 16:40:15 +0200[diff] [blame]431 tester('ntpath.expandvars("bar\'%foo%")', "bar\'%foo%")
Guido van Rossumd8faa362007-04-27 19:54:29 +0000[diff] [blame]432
Serhiy Storchakadbb10192014-02-13 10:13:53 +0200[diff] [blame]433 @unittest.skipUnless(support.FS_NONASCII, 'need support.FS_NONASCII')
434 def test_expandvars_nonascii(self):
435 def check(value, expected):
436 tester('ntpath.expandvars(%r)' % value, expected)
437 with support.EnvironmentVarGuard() as env:
438 env.clear()
439 nonascii = support.FS_NONASCII
440 env['spam'] = nonascii
441 env[nonascii] = 'ham' + nonascii
442 check('$spam bar', '%s bar' % nonascii)
443 check('$%s bar' % nonascii, '$%s bar' % nonascii)
444 check('${spam}bar', '%sbar' % nonascii)
445 check('${%s}bar' % nonascii, 'ham%sbar' % nonascii)
446 check('$spam}bar', '%s}bar' % nonascii)
447 check('$%s}bar' % nonascii, '$%s}bar' % nonascii)
448 check('%spam% bar', '%s bar' % nonascii)
449 check('%{}% bar'.format(nonascii), 'ham%s bar' % nonascii)
450 check('%spam%bar', '%sbar' % nonascii)
451 check('%{}%bar'.format(nonascii), 'ham%sbar' % nonascii)
452
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]453 def test_expanduser(self):
454 tester('ntpath.expanduser("test")', 'test')
455
456 with support.EnvironmentVarGuard() as env:
457 env.clear()
458 tester('ntpath.expanduser("~test")', '~test')
459
460 env['HOMEPATH'] = 'eric\\idle'
461 env['HOMEDRIVE'] = 'C:\\'
462 tester('ntpath.expanduser("~test")', 'C:\\eric\\test')
463 tester('ntpath.expanduser("~")', 'C:\\eric\\idle')
464
465 del env['HOMEDRIVE']
466 tester('ntpath.expanduser("~test")', 'eric\\test')
467 tester('ntpath.expanduser("~")', 'eric\\idle')
468
469 env.clear()
470 env['USERPROFILE'] = 'C:\\eric\\idle'
471 tester('ntpath.expanduser("~test")', 'C:\\eric\\test')
472 tester('ntpath.expanduser("~")', 'C:\\eric\\idle')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]473 tester('ntpath.expanduser("~test\\foo\\bar")',
Anthony Sottile25ec4a42019-03-12 08:39:57 -0700[diff] [blame]474 'C:\\eric\\test\\foo\\bar')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]475 tester('ntpath.expanduser("~test/foo/bar")',
Anthony Sottile25ec4a42019-03-12 08:39:57 -0700[diff] [blame]476 'C:\\eric\\test/foo/bar')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]477 tester('ntpath.expanduser("~\\foo\\bar")',
Anthony Sottile25ec4a42019-03-12 08:39:57 -0700[diff] [blame]478 'C:\\eric\\idle\\foo\\bar')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]479 tester('ntpath.expanduser("~/foo/bar")',
Anthony Sottile25ec4a42019-03-12 08:39:57 -0700[diff] [blame]480 'C:\\eric\\idle/foo/bar')
481
482 # bpo-36264: ignore `HOME` when set on windows
483 env.clear()
484 env['HOME'] = 'F:\\'
485 env['USERPROFILE'] = 'C:\\eric\\idle'
486 tester('ntpath.expanduser("~test")', 'C:\\eric\\test')
487 tester('ntpath.expanduser("~")', 'C:\\eric\\idle')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]488
Steve Dower23ad6d02018-02-22 10:39:10 -0800[diff] [blame]489 @unittest.skipUnless(nt, "abspath requires 'nt' module")
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]490 def test_abspath(self):
Steve Dower23ad6d02018-02-22 10:39:10 -0800[diff] [blame]491 tester('ntpath.abspath("C:\\")', "C:\\")
Franz Wöllertd2e902e2018-07-29 14:47:09 +0200[diff] [blame]492 with support.temp_cwd(support.TESTFN) as cwd_dir: # bpo-31047
493 tester('ntpath.abspath("")', cwd_dir)
494 tester('ntpath.abspath(" ")', cwd_dir + "\\ ")
495 tester('ntpath.abspath("?")', cwd_dir + "\\?")
Tim Grahamd03b7752018-10-25 11:26:38 -0400[diff] [blame]496 drive, _ = ntpath.splitdrive(cwd_dir)
497 tester('ntpath.abspath("/abc/")', drive + "\\abc")
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]498
499 def test_relpath(self):
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]500 tester('ntpath.relpath("a")', 'a')
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]501 tester('ntpath.relpath(ntpath.abspath("a"))', 'a')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]502 tester('ntpath.relpath("a/b")', 'a\\b')
503 tester('ntpath.relpath("../a/b")', '..\\a\\b')
Serhiy Storchaka5106d042015-01-26 10:26:14 +0200[diff] [blame]504 with support.temp_cwd(support.TESTFN) as cwd_dir:
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]505 currentdir = ntpath.basename(cwd_dir)
Serhiy Storchaka5106d042015-01-26 10:26:14 +0200[diff] [blame]506 tester('ntpath.relpath("a", "../b")', '..\\'+currentdir+'\\a')
507 tester('ntpath.relpath("a/b", "../c")', '..\\'+currentdir+'\\a\\b')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]508 tester('ntpath.relpath("a", "b/c")', '..\\..\\a')
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]509 tester('ntpath.relpath("c:/foo/bar/bat", "c:/x/y")', '..\\..\\foo\\bar\\bat')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]510 tester('ntpath.relpath("//conky/mountpoint/a", "//conky/mountpoint/b/c")', '..\\..\\a')
511 tester('ntpath.relpath("a", "a")', '.')
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]512 tester('ntpath.relpath("/foo/bar/bat", "/x/y/z")', '..\\..\\..\\foo\\bar\\bat')
513 tester('ntpath.relpath("/foo/bar/bat", "/foo/bar")', 'bat')
514 tester('ntpath.relpath("/foo/bar/bat", "/")', 'foo\\bar\\bat')
515 tester('ntpath.relpath("/", "/foo/bar/bat")', '..\\..\\..')
516 tester('ntpath.relpath("/foo/bar/bat", "/x")', '..\\foo\\bar\\bat')
517 tester('ntpath.relpath("/x", "/foo/bar/bat")', '..\\..\\..\\x')
518 tester('ntpath.relpath("/", "/")', '.')
519 tester('ntpath.relpath("/a", "/a")', '.')
520 tester('ntpath.relpath("/a/b", "/a/b")', '.')
Hirokazu Yamamotob08820a2010-10-18 12:13:18 +0000[diff] [blame]521 tester('ntpath.relpath("c:/foo", "C:/FOO")', '.')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]522
Serhiy Storchaka38220932015-03-31 15:31:53 +0300[diff] [blame]523 def test_commonpath(self):
524 def check(paths, expected):
525 tester(('ntpath.commonpath(%r)' % paths).replace('\\\\', '\\'),
526 expected)
527 def check_error(exc, paths):
528 self.assertRaises(exc, ntpath.commonpath, paths)
529 self.assertRaises(exc, ntpath.commonpath,
530 [os.fsencode(p) for p in paths])
531
532 self.assertRaises(ValueError, ntpath.commonpath, [])
533 check_error(ValueError, ['C:\\Program Files', 'Program Files'])
534 check_error(ValueError, ['C:\\Program Files', 'C:Program Files'])
535 check_error(ValueError, ['\\Program Files', 'Program Files'])
536 check_error(ValueError, ['Program Files', 'C:\\Program Files'])
537 check(['C:\\Program Files'], 'C:\\Program Files')
538 check(['C:\\Program Files', 'C:\\Program Files'], 'C:\\Program Files')
539 check(['C:\\Program Files\\', 'C:\\Program Files'],
540 'C:\\Program Files')
541 check(['C:\\Program Files\\', 'C:\\Program Files\\'],
542 'C:\\Program Files')
543 check(['C:\\\\Program Files', 'C:\\Program Files\\\\'],
544 'C:\\Program Files')
545 check(['C:\\.\\Program Files', 'C:\\Program Files\\.'],
546 'C:\\Program Files')
547 check(['C:\\', 'C:\\bin'], 'C:\\')
548 check(['C:\\Program Files', 'C:\\bin'], 'C:\\')
549 check(['C:\\Program Files', 'C:\\Program Files\\Bar'],
550 'C:\\Program Files')
551 check(['C:\\Program Files\\Foo', 'C:\\Program Files\\Bar'],
552 'C:\\Program Files')
553 check(['C:\\Program Files', 'C:\\Projects'], 'C:\\')
554 check(['C:\\Program Files\\', 'C:\\Projects'], 'C:\\')
555
556 check(['C:\\Program Files\\Foo', 'C:/Program Files/Bar'],
557 'C:\\Program Files')
558 check(['C:\\Program Files\\Foo', 'c:/program files/bar'],
559 'C:\\Program Files')
560 check(['c:/program files/bar', 'C:\\Program Files\\Foo'],
561 'c:\\program files')
562
563 check_error(ValueError, ['C:\\Program Files', 'D:\\Program Files'])
564
565 check(['spam'], 'spam')
566 check(['spam', 'spam'], 'spam')
567 check(['spam', 'alot'], '')
568 check(['and\\jam', 'and\\spam'], 'and')
569 check(['and\\\\jam', 'and\\spam\\\\'], 'and')
570 check(['and\\.\\jam', '.\\and\\spam'], 'and')
571 check(['and\\jam', 'and\\spam', 'alot'], '')
572 check(['and\\jam', 'and\\spam', 'and'], 'and')
573 check(['C:and\\jam', 'C:and\\spam'], 'C:and')
574
575 check([''], '')
576 check(['', 'spam\\alot'], '')
577 check_error(ValueError, ['', '\\spam\\alot'])
578
579 self.assertRaises(TypeError, ntpath.commonpath,
580 [b'C:\\Program Files', 'C:\\Program Files\\Foo'])
581 self.assertRaises(TypeError, ntpath.commonpath,
582 [b'C:\\Program Files', 'Program Files\\Foo'])
583 self.assertRaises(TypeError, ntpath.commonpath,
584 [b'Program Files', 'C:\\Program Files\\Foo'])
585 self.assertRaises(TypeError, ntpath.commonpath,
586 ['C:\\Program Files', b'C:\\Program Files\\Foo'])
587 self.assertRaises(TypeError, ntpath.commonpath,
588 ['C:\\Program Files', b'Program Files\\Foo'])
589 self.assertRaises(TypeError, ntpath.commonpath,
590 ['Program Files', b'C:\\Program Files\\Foo'])
591
Brian Curtin62857742010-09-06 17:07:27 +0000[diff] [blame]592 def test_sameopenfile(self):
593 with TemporaryFile() as tf1, TemporaryFile() as tf2:
594 # Make sure the same file is really the same
595 self.assertTrue(ntpath.sameopenfile(tf1.fileno(), tf1.fileno()))
596 # Make sure different files are really different
597 self.assertFalse(ntpath.sameopenfile(tf1.fileno(), tf2.fileno()))
Brian Curtin13a0db52010-09-06 19:46:17 +0000[diff] [blame]598 # Make sure invalid values don't cause issues on win32
599 if sys.platform == "win32":
Hirokazu Yamamoto26253bb2010-12-05 04:16:47 +0000[diff] [blame]600 with self.assertRaises(OSError):
Brian Curtin13a0db52010-09-06 19:46:17 +0000[diff] [blame]601 # Invalid file descriptors shouldn't display assert
602 # dialogs (#4804)
603 ntpath.sameopenfile(-1, -1)
Brian Curtin62857742010-09-06 17:07:27 +0000[diff] [blame]604
Tim Golden6b528062013-08-01 12:44:00 +0100[diff] [blame]605 def test_ismount(self):
606 self.assertTrue(ntpath.ismount("c:\\"))
607 self.assertTrue(ntpath.ismount("C:\\"))
608 self.assertTrue(ntpath.ismount("c:/"))
609 self.assertTrue(ntpath.ismount("C:/"))
610 self.assertTrue(ntpath.ismount("\\\\.\\c:\\"))
611 self.assertTrue(ntpath.ismount("\\\\.\\C:\\"))
612
613 self.assertTrue(ntpath.ismount(b"c:\\"))
614 self.assertTrue(ntpath.ismount(b"C:\\"))
615 self.assertTrue(ntpath.ismount(b"c:/"))
616 self.assertTrue(ntpath.ismount(b"C:/"))
617 self.assertTrue(ntpath.ismount(b"\\\\.\\c:\\"))
618 self.assertTrue(ntpath.ismount(b"\\\\.\\C:\\"))
619
620 with support.temp_dir() as d:
621 self.assertFalse(ntpath.ismount(d))
622
Tim Goldenb2fcebb2013-08-01 13:58:58 +0100[diff] [blame]623 if sys.platform == "win32":
624 #
625 # Make sure the current folder isn't the root folder
626 # (or any other volume root). The drive-relative
627 # locations below cannot then refer to mount points
628 #
629 drive, path = ntpath.splitdrive(sys.executable)
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]630 with support.change_cwd(ntpath.dirname(sys.executable)):
Tim Goldenb2fcebb2013-08-01 13:58:58 +0100[diff] [blame]631 self.assertFalse(ntpath.ismount(drive.lower()))
632 self.assertFalse(ntpath.ismount(drive.upper()))
Tim Golden6b528062013-08-01 12:44:00 +0100[diff] [blame]633
Tim Goldenb2fcebb2013-08-01 13:58:58 +0100[diff] [blame]634 self.assertTrue(ntpath.ismount("\\\\localhost\\c$"))
635 self.assertTrue(ntpath.ismount("\\\\localhost\\c$\\"))
Tim Golden6b528062013-08-01 12:44:00 +0100[diff] [blame]636
Tim Goldenb2fcebb2013-08-01 13:58:58 +0100[diff] [blame]637 self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$"))
638 self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$\\"))
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]639
Tim Goldenff64add2018-07-25 14:36:54 +0100[diff] [blame]640 def assertEqualCI(self, s1, s2):
641 """Assert that two strings are equal ignoring case differences."""
642 self.assertEqual(s1.lower(), s2.lower())
643
Steve Dower23ad6d02018-02-22 10:39:10 -0800[diff] [blame]644 @unittest.skipUnless(nt, "OS helpers require 'nt' module")
645 def test_nt_helpers(self):
646 # Trivial validation that the helpers do not break, and support both
647 # unicode and bytes (UTF-8) paths
648
Tim Goldenff64add2018-07-25 14:36:54 +0100[diff] [blame]649 executable = nt._getfinalpathname(sys.executable)
650
651 for path in executable, os.fsencode(executable):
652 volume_path = nt._getvolumepathname(path)
653 path_drive = ntpath.splitdrive(path)[0]
654 volume_path_drive = ntpath.splitdrive(volume_path)[0]
655 self.assertEqualCI(path_drive, volume_path_drive)
Steve Dower23ad6d02018-02-22 10:39:10 -0800[diff] [blame]656
657 cap, free = nt._getdiskusage(sys.exec_prefix)
658 self.assertGreater(cap, 0)
659 self.assertGreater(free, 0)
660 b_cap, b_free = nt._getdiskusage(sys.exec_prefix.encode())
661 # Free space may change, so only test the capacity is equal
662 self.assertEqual(b_cap, cap)
663 self.assertGreater(b_free, 0)
664
665 for path in [sys.prefix, sys.executable]:
666 final_path = nt._getfinalpathname(path)
667 self.assertIsInstance(final_path, str)
668 self.assertGreater(len(final_path), 0)
669
670 b_final_path = nt._getfinalpathname(path.encode())
671 self.assertIsInstance(b_final_path, bytes)
672 self.assertGreater(len(b_final_path), 0)
673
Ezio Melottid0dfe9a2013-01-10 03:12:50 +0200[diff] [blame]674class NtCommonTest(test_genericpath.CommonTest, unittest.TestCase):
Florent Xiclunac9c79782010-03-08 12:24:53 +0000[diff] [blame]675 pathmodule = ntpath
Serhiy Storchaka9ed707e2017-01-13 20:55:05 +0200[diff] [blame]676 attributes = ['relpath']
Florent Xiclunac9c79782010-03-08 12:24:53 +0000[diff] [blame]677
678
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]679class PathLikeTests(NtpathTestCase):
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]680
681 path = ntpath
682
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]683 def setUp(self):
684 self.file_name = support.TESTFN.lower()
Serhiy Storchakab21d1552018-03-02 11:53:51 +0200[diff] [blame]685 self.file_path = FakePath(support.TESTFN)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]686 self.addCleanup(support.unlink, self.file_name)
687 with open(self.file_name, 'xb', 0) as file:
688 file.write(b"test_ntpath.PathLikeTests")
689
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]690 def _check_function(self, func):
691 self.assertPathEqual(func(self.file_path), func(self.file_name))
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]692
693 def test_path_normcase(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]694 self._check_function(self.path.normcase)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]695
696 def test_path_isabs(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]697 self._check_function(self.path.isabs)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]698
699 def test_path_join(self):
Serhiy Storchakab21d1552018-03-02 11:53:51 +0200[diff] [blame]700 self.assertEqual(self.path.join('a', FakePath('b'), 'c'),
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]701 self.path.join('a', 'b', 'c'))
702
703 def test_path_split(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]704 self._check_function(self.path.split)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]705
706 def test_path_splitext(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]707 self._check_function(self.path.splitext)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]708
709 def test_path_splitdrive(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]710 self._check_function(self.path.splitdrive)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]711
712 def test_path_basename(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]713 self._check_function(self.path.basename)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]714
715 def test_path_dirname(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]716 self._check_function(self.path.dirname)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]717
718 def test_path_islink(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]719 self._check_function(self.path.islink)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]720
721 def test_path_lexists(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]722 self._check_function(self.path.lexists)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]723
724 def test_path_ismount(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]725 self._check_function(self.path.ismount)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]726
727 def test_path_expanduser(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]728 self._check_function(self.path.expanduser)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]729
730 def test_path_expandvars(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]731 self._check_function(self.path.expandvars)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]732
733 def test_path_normpath(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]734 self._check_function(self.path.normpath)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]735
736 def test_path_abspath(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]737 self._check_function(self.path.abspath)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]738
739 def test_path_realpath(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]740 self._check_function(self.path.realpath)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]741
742 def test_path_relpath(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]743 self._check_function(self.path.relpath)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]744
745 def test_path_commonpath(self):
746 common_path = self.path.commonpath([self.file_path, self.file_name])
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]747 self.assertPathEqual(common_path, self.file_name)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]748
749 def test_path_isdir(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]750 self._check_function(self.path.isdir)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]751
752
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]753if __name__ == "__main__":
754 unittest.main()