Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython3 / 455122a0094c8cfdf7e062eccc5e5b5885c75e8b / . / Lib / test / test_ntpath.py
blob: c5c96e32d7473cfbda70a6bfee0ad791aad15241 [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
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]403 def test_expandvars(self):
Walter Dörwald155374d2009-05-01 19:58:58 +0000[diff] [blame]404 with support.EnvironmentVarGuard() as env:
405 env.clear()
406 env["foo"] = "bar"
407 env["{foo"] = "baz1"
408 env["{foo}"] = "baz2"
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]409 tester('ntpath.expandvars("foo")', "foo")
410 tester('ntpath.expandvars("$foo bar")', "bar bar")
411 tester('ntpath.expandvars("${foo}bar")', "barbar")
412 tester('ntpath.expandvars("$[foo]bar")', "$[foo]bar")
413 tester('ntpath.expandvars("$bar bar")', "$bar bar")
414 tester('ntpath.expandvars("$?bar")', "$?bar")
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]415 tester('ntpath.expandvars("$foo}bar")', "bar}bar")
416 tester('ntpath.expandvars("${foo")', "${foo")
417 tester('ntpath.expandvars("${{foo}}")', "baz1}")
418 tester('ntpath.expandvars("$foo$foo")', "barbar")
419 tester('ntpath.expandvars("$bar$bar")', "$bar$bar")
420 tester('ntpath.expandvars("%foo% bar")', "bar bar")
421 tester('ntpath.expandvars("%foo%bar")', "barbar")
422 tester('ntpath.expandvars("%foo%%foo%")', "barbar")
423 tester('ntpath.expandvars("%%foo%%foo%foo%")', "%foo%foobar")
424 tester('ntpath.expandvars("%?bar%")', "%?bar%")
425 tester('ntpath.expandvars("%foo%%bar")', "bar%bar")
426 tester('ntpath.expandvars("\'%foo%\'%bar")', "\'%foo%\'%bar")
Serhiy Storchaka1b87ae02015-03-25 16:40:15 +0200[diff] [blame]427 tester('ntpath.expandvars("bar\'%foo%")', "bar\'%foo%")
Guido van Rossumd8faa362007-04-27 19:54:29 +0000[diff] [blame]428
Serhiy Storchakadbb10192014-02-13 10:13:53 +0200[diff] [blame]429 @unittest.skipUnless(support.FS_NONASCII, 'need support.FS_NONASCII')
430 def test_expandvars_nonascii(self):
431 def check(value, expected):
432 tester('ntpath.expandvars(%r)' % value, expected)
433 with support.EnvironmentVarGuard() as env:
434 env.clear()
435 nonascii = support.FS_NONASCII
436 env['spam'] = nonascii
437 env[nonascii] = 'ham' + nonascii
438 check('$spam bar', '%s bar' % nonascii)
439 check('$%s bar' % nonascii, '$%s bar' % nonascii)
440 check('${spam}bar', '%sbar' % nonascii)
441 check('${%s}bar' % nonascii, 'ham%sbar' % nonascii)
442 check('$spam}bar', '%s}bar' % nonascii)
443 check('$%s}bar' % nonascii, '$%s}bar' % nonascii)
444 check('%spam% bar', '%s bar' % nonascii)
445 check('%{}% bar'.format(nonascii), 'ham%s bar' % nonascii)
446 check('%spam%bar', '%sbar' % nonascii)
447 check('%{}%bar'.format(nonascii), 'ham%sbar' % nonascii)
448
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]449 def test_expanduser(self):
450 tester('ntpath.expanduser("test")', 'test')
451
452 with support.EnvironmentVarGuard() as env:
453 env.clear()
454 tester('ntpath.expanduser("~test")', '~test')
455
456 env['HOMEPATH'] = 'eric\\idle'
457 env['HOMEDRIVE'] = 'C:\\'
458 tester('ntpath.expanduser("~test")', 'C:\\eric\\test')
459 tester('ntpath.expanduser("~")', 'C:\\eric\\idle')
460
461 del env['HOMEDRIVE']
462 tester('ntpath.expanduser("~test")', 'eric\\test')
463 tester('ntpath.expanduser("~")', 'eric\\idle')
464
465 env.clear()
466 env['USERPROFILE'] = 'C:\\eric\\idle'
467 tester('ntpath.expanduser("~test")', 'C:\\eric\\test')
468 tester('ntpath.expanduser("~")', 'C:\\eric\\idle')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]469 tester('ntpath.expanduser("~test\\foo\\bar")',
Anthony Sottile25ec4a42019-03-12 08:39:57 -0700[diff] [blame]470 'C:\\eric\\test\\foo\\bar')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]471 tester('ntpath.expanduser("~test/foo/bar")',
Anthony Sottile25ec4a42019-03-12 08:39:57 -0700[diff] [blame]472 'C:\\eric\\test/foo/bar')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]473 tester('ntpath.expanduser("~\\foo\\bar")',
Anthony Sottile25ec4a42019-03-12 08:39:57 -0700[diff] [blame]474 'C:\\eric\\idle\\foo\\bar')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]475 tester('ntpath.expanduser("~/foo/bar")',
Anthony Sottile25ec4a42019-03-12 08:39:57 -0700[diff] [blame]476 'C:\\eric\\idle/foo/bar')
477
478 # bpo-36264: ignore `HOME` when set on windows
479 env.clear()
480 env['HOME'] = 'F:\\'
481 env['USERPROFILE'] = 'C:\\eric\\idle'
482 tester('ntpath.expanduser("~test")', 'C:\\eric\\test')
483 tester('ntpath.expanduser("~")', 'C:\\eric\\idle')
Serhiy Storchakaffc1e6d2014-05-28 18:11:29 +0300[diff] [blame]484
Steve Dower23ad6d02018-02-22 10:39:10 -0800[diff] [blame]485 @unittest.skipUnless(nt, "abspath requires 'nt' module")
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]486 def test_abspath(self):
Steve Dower23ad6d02018-02-22 10:39:10 -0800[diff] [blame]487 tester('ntpath.abspath("C:\\")', "C:\\")
Franz Wöllertd2e902e2018-07-29 14:47:09 +0200[diff] [blame]488 with support.temp_cwd(support.TESTFN) as cwd_dir: # bpo-31047
489 tester('ntpath.abspath("")', cwd_dir)
490 tester('ntpath.abspath(" ")', cwd_dir + "\\ ")
491 tester('ntpath.abspath("?")', cwd_dir + "\\?")
Tim Grahamd03b7752018-10-25 11:26:38 -0400[diff] [blame]492 drive, _ = ntpath.splitdrive(cwd_dir)
493 tester('ntpath.abspath("/abc/")', drive + "\\abc")
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]494
495 def test_relpath(self):
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]496 tester('ntpath.relpath("a")', 'a')
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]497 tester('ntpath.relpath(ntpath.abspath("a"))', 'a')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]498 tester('ntpath.relpath("a/b")', 'a\\b')
499 tester('ntpath.relpath("../a/b")', '..\\a\\b')
Serhiy Storchaka5106d042015-01-26 10:26:14 +0200[diff] [blame]500 with support.temp_cwd(support.TESTFN) as cwd_dir:
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]501 currentdir = ntpath.basename(cwd_dir)
Serhiy Storchaka5106d042015-01-26 10:26:14 +0200[diff] [blame]502 tester('ntpath.relpath("a", "../b")', '..\\'+currentdir+'\\a')
503 tester('ntpath.relpath("a/b", "../c")', '..\\'+currentdir+'\\a\\b')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]504 tester('ntpath.relpath("a", "b/c")', '..\\..\\a')
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]505 tester('ntpath.relpath("c:/foo/bar/bat", "c:/x/y")', '..\\..\\foo\\bar\\bat')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]506 tester('ntpath.relpath("//conky/mountpoint/a", "//conky/mountpoint/b/c")', '..\\..\\a')
507 tester('ntpath.relpath("a", "a")', '.')
Mark Hammond5a607a32009-05-06 08:04:54 +0000[diff] [blame]508 tester('ntpath.relpath("/foo/bar/bat", "/x/y/z")', '..\\..\\..\\foo\\bar\\bat')
509 tester('ntpath.relpath("/foo/bar/bat", "/foo/bar")', 'bat')
510 tester('ntpath.relpath("/foo/bar/bat", "/")', 'foo\\bar\\bat')
511 tester('ntpath.relpath("/", "/foo/bar/bat")', '..\\..\\..')
512 tester('ntpath.relpath("/foo/bar/bat", "/x")', '..\\foo\\bar\\bat')
513 tester('ntpath.relpath("/x", "/foo/bar/bat")', '..\\..\\..\\x')
514 tester('ntpath.relpath("/", "/")', '.')
515 tester('ntpath.relpath("/a", "/a")', '.')
516 tester('ntpath.relpath("/a/b", "/a/b")', '.')
Hirokazu Yamamotob08820a2010-10-18 12:13:18 +0000[diff] [blame]517 tester('ntpath.relpath("c:/foo", "C:/FOO")', '.')
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]518
Serhiy Storchaka38220932015-03-31 15:31:53 +0300[diff] [blame]519 def test_commonpath(self):
520 def check(paths, expected):
521 tester(('ntpath.commonpath(%r)' % paths).replace('\\\\', '\\'),
522 expected)
523 def check_error(exc, paths):
524 self.assertRaises(exc, ntpath.commonpath, paths)
525 self.assertRaises(exc, ntpath.commonpath,
526 [os.fsencode(p) for p in paths])
527
528 self.assertRaises(ValueError, ntpath.commonpath, [])
529 check_error(ValueError, ['C:\\Program Files', 'Program Files'])
530 check_error(ValueError, ['C:\\Program Files', 'C:Program Files'])
531 check_error(ValueError, ['\\Program Files', 'Program Files'])
532 check_error(ValueError, ['Program Files', 'C:\\Program Files'])
533 check(['C:\\Program Files'], 'C:\\Program Files')
534 check(['C:\\Program Files', 'C:\\Program Files'], 'C:\\Program Files')
535 check(['C:\\Program Files\\', 'C:\\Program Files'],
536 'C:\\Program Files')
537 check(['C:\\Program Files\\', 'C:\\Program Files\\'],
538 '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:\\', 'C:\\bin'], 'C:\\')
544 check(['C:\\Program Files', 'C:\\bin'], 'C:\\')
545 check(['C:\\Program Files', 'C:\\Program Files\\Bar'],
546 'C:\\Program Files')
547 check(['C:\\Program Files\\Foo', 'C:\\Program Files\\Bar'],
548 'C:\\Program Files')
549 check(['C:\\Program Files', 'C:\\Projects'], 'C:\\')
550 check(['C:\\Program Files\\', 'C:\\Projects'], 'C:\\')
551
552 check(['C:\\Program Files\\Foo', 'C:/Program Files/Bar'],
553 'C:\\Program Files')
554 check(['C:\\Program Files\\Foo', 'c:/program files/bar'],
555 'C:\\Program Files')
556 check(['c:/program files/bar', 'C:\\Program Files\\Foo'],
557 'c:\\program files')
558
559 check_error(ValueError, ['C:\\Program Files', 'D:\\Program Files'])
560
561 check(['spam'], 'spam')
562 check(['spam', 'spam'], 'spam')
563 check(['spam', 'alot'], '')
564 check(['and\\jam', 'and\\spam'], 'and')
565 check(['and\\\\jam', 'and\\spam\\\\'], 'and')
566 check(['and\\.\\jam', '.\\and\\spam'], 'and')
567 check(['and\\jam', 'and\\spam', 'alot'], '')
568 check(['and\\jam', 'and\\spam', 'and'], 'and')
569 check(['C:and\\jam', 'C:and\\spam'], 'C:and')
570
571 check([''], '')
572 check(['', 'spam\\alot'], '')
573 check_error(ValueError, ['', '\\spam\\alot'])
574
575 self.assertRaises(TypeError, ntpath.commonpath,
576 [b'C:\\Program Files', 'C:\\Program Files\\Foo'])
577 self.assertRaises(TypeError, ntpath.commonpath,
578 [b'C:\\Program Files', 'Program Files\\Foo'])
579 self.assertRaises(TypeError, ntpath.commonpath,
580 [b'Program Files', 'C:\\Program Files\\Foo'])
581 self.assertRaises(TypeError, ntpath.commonpath,
582 ['C:\\Program Files', b'C:\\Program Files\\Foo'])
583 self.assertRaises(TypeError, ntpath.commonpath,
584 ['C:\\Program Files', b'Program Files\\Foo'])
585 self.assertRaises(TypeError, ntpath.commonpath,
586 ['Program Files', b'C:\\Program Files\\Foo'])
587
Brian Curtin62857742010-09-06 17:07:27 +0000[diff] [blame]588 def test_sameopenfile(self):
589 with TemporaryFile() as tf1, TemporaryFile() as tf2:
590 # Make sure the same file is really the same
591 self.assertTrue(ntpath.sameopenfile(tf1.fileno(), tf1.fileno()))
592 # Make sure different files are really different
593 self.assertFalse(ntpath.sameopenfile(tf1.fileno(), tf2.fileno()))
Brian Curtin13a0db52010-09-06 19:46:17 +0000[diff] [blame]594 # Make sure invalid values don't cause issues on win32
595 if sys.platform == "win32":
Hirokazu Yamamoto26253bb2010-12-05 04:16:47 +0000[diff] [blame]596 with self.assertRaises(OSError):
Brian Curtin13a0db52010-09-06 19:46:17 +0000[diff] [blame]597 # Invalid file descriptors shouldn't display assert
598 # dialogs (#4804)
599 ntpath.sameopenfile(-1, -1)
Brian Curtin62857742010-09-06 17:07:27 +0000[diff] [blame]600
Tim Golden6b528062013-08-01 12:44:00 +0100[diff] [blame]601 def test_ismount(self):
602 self.assertTrue(ntpath.ismount("c:\\"))
603 self.assertTrue(ntpath.ismount("C:\\"))
604 self.assertTrue(ntpath.ismount("c:/"))
605 self.assertTrue(ntpath.ismount("C:/"))
606 self.assertTrue(ntpath.ismount("\\\\.\\c:\\"))
607 self.assertTrue(ntpath.ismount("\\\\.\\C:\\"))
608
609 self.assertTrue(ntpath.ismount(b"c:\\"))
610 self.assertTrue(ntpath.ismount(b"C:\\"))
611 self.assertTrue(ntpath.ismount(b"c:/"))
612 self.assertTrue(ntpath.ismount(b"C:/"))
613 self.assertTrue(ntpath.ismount(b"\\\\.\\c:\\"))
614 self.assertTrue(ntpath.ismount(b"\\\\.\\C:\\"))
615
616 with support.temp_dir() as d:
617 self.assertFalse(ntpath.ismount(d))
618
Tim Goldenb2fcebb2013-08-01 13:58:58 +0100[diff] [blame]619 if sys.platform == "win32":
620 #
621 # Make sure the current folder isn't the root folder
622 # (or any other volume root). The drive-relative
623 # locations below cannot then refer to mount points
624 #
625 drive, path = ntpath.splitdrive(sys.executable)
Steve Dower75e06492019-08-21 13:43:06 -0700[diff] [blame]626 with support.change_cwd(ntpath.dirname(sys.executable)):
Tim Goldenb2fcebb2013-08-01 13:58:58 +0100[diff] [blame]627 self.assertFalse(ntpath.ismount(drive.lower()))
628 self.assertFalse(ntpath.ismount(drive.upper()))
Tim Golden6b528062013-08-01 12:44:00 +0100[diff] [blame]629
Tim Goldenb2fcebb2013-08-01 13:58:58 +0100[diff] [blame]630 self.assertTrue(ntpath.ismount("\\\\localhost\\c$"))
631 self.assertTrue(ntpath.ismount("\\\\localhost\\c$\\"))
Tim Golden6b528062013-08-01 12:44:00 +0100[diff] [blame]632
Tim Goldenb2fcebb2013-08-01 13:58:58 +0100[diff] [blame]633 self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$"))
634 self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$\\"))
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]635
Tim Goldenff64add2018-07-25 14:36:54 +0100[diff] [blame]636 def assertEqualCI(self, s1, s2):
637 """Assert that two strings are equal ignoring case differences."""
638 self.assertEqual(s1.lower(), s2.lower())
639
Steve Dower23ad6d02018-02-22 10:39:10 -0800[diff] [blame]640 @unittest.skipUnless(nt, "OS helpers require 'nt' module")
641 def test_nt_helpers(self):
642 # Trivial validation that the helpers do not break, and support both
643 # unicode and bytes (UTF-8) paths
644
Tim Goldenff64add2018-07-25 14:36:54 +0100[diff] [blame]645 executable = nt._getfinalpathname(sys.executable)
646
647 for path in executable, os.fsencode(executable):
648 volume_path = nt._getvolumepathname(path)
649 path_drive = ntpath.splitdrive(path)[0]
650 volume_path_drive = ntpath.splitdrive(volume_path)[0]
651 self.assertEqualCI(path_drive, volume_path_drive)
Steve Dower23ad6d02018-02-22 10:39:10 -0800[diff] [blame]652
653 cap, free = nt._getdiskusage(sys.exec_prefix)
654 self.assertGreater(cap, 0)
655 self.assertGreater(free, 0)
656 b_cap, b_free = nt._getdiskusage(sys.exec_prefix.encode())
657 # Free space may change, so only test the capacity is equal
658 self.assertEqual(b_cap, cap)
659 self.assertGreater(b_free, 0)
660
661 for path in [sys.prefix, sys.executable]:
662 final_path = nt._getfinalpathname(path)
663 self.assertIsInstance(final_path, str)
664 self.assertGreater(len(final_path), 0)
665
666 b_final_path = nt._getfinalpathname(path.encode())
667 self.assertIsInstance(b_final_path, bytes)
668 self.assertGreater(len(b_final_path), 0)
669
Ezio Melottid0dfe9a2013-01-10 03:12:50 +0200[diff] [blame]670class NtCommonTest(test_genericpath.CommonTest, unittest.TestCase):
Florent Xiclunac9c79782010-03-08 12:24:53 +0000[diff] [blame]671 pathmodule = ntpath
Serhiy Storchaka9ed707e2017-01-13 20:55:05 +0200[diff] [blame]672 attributes = ['relpath']
Florent Xiclunac9c79782010-03-08 12:24:53 +0000[diff] [blame]673
674
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]675class PathLikeTests(NtpathTestCase):
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]676
677 path = ntpath
678
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]679 def setUp(self):
680 self.file_name = support.TESTFN.lower()
Serhiy Storchakab21d1552018-03-02 11:53:51 +0200[diff] [blame]681 self.file_path = FakePath(support.TESTFN)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]682 self.addCleanup(support.unlink, self.file_name)
683 with open(self.file_name, 'xb', 0) as file:
684 file.write(b"test_ntpath.PathLikeTests")
685
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]686 def _check_function(self, func):
687 self.assertPathEqual(func(self.file_path), func(self.file_name))
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]688
689 def test_path_normcase(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]690 self._check_function(self.path.normcase)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]691
692 def test_path_isabs(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]693 self._check_function(self.path.isabs)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]694
695 def test_path_join(self):
Serhiy Storchakab21d1552018-03-02 11:53:51 +0200[diff] [blame]696 self.assertEqual(self.path.join('a', FakePath('b'), 'c'),
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]697 self.path.join('a', 'b', 'c'))
698
699 def test_path_split(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]700 self._check_function(self.path.split)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]701
702 def test_path_splitext(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]703 self._check_function(self.path.splitext)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]704
705 def test_path_splitdrive(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]706 self._check_function(self.path.splitdrive)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]707
708 def test_path_basename(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]709 self._check_function(self.path.basename)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]710
711 def test_path_dirname(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]712 self._check_function(self.path.dirname)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]713
714 def test_path_islink(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]715 self._check_function(self.path.islink)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]716
717 def test_path_lexists(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]718 self._check_function(self.path.lexists)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]719
720 def test_path_ismount(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]721 self._check_function(self.path.ismount)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]722
723 def test_path_expanduser(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]724 self._check_function(self.path.expanduser)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]725
726 def test_path_expandvars(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]727 self._check_function(self.path.expandvars)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]728
729 def test_path_normpath(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]730 self._check_function(self.path.normpath)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]731
732 def test_path_abspath(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]733 self._check_function(self.path.abspath)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]734
735 def test_path_realpath(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]736 self._check_function(self.path.realpath)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]737
738 def test_path_relpath(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]739 self._check_function(self.path.relpath)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]740
741 def test_path_commonpath(self):
742 common_path = self.path.commonpath([self.file_path, self.file_name])
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]743 self.assertPathEqual(common_path, self.file_name)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]744
745 def test_path_isdir(self):
Steve Dower97d79062019-09-10 14:52:48 +0100[diff] [blame]746 self._check_function(self.path.isdir)
Brett Cannon3f9183b2016-08-26 14:44:48 -0700[diff] [blame]747
748
Christian Heimesf6cd9672008-03-26 13:45:42 +0000[diff] [blame]749if __name__ == "__main__":
750 unittest.main()