Debian Codegraph @

Lib/test/test_pathlib/test_join.py

raw
1 """
2 Tests for pathlib.types._JoinablePath
3 """
4
5 import unittest
6 import threading
7 from test.support import threading_helper
8
9 from .support import is_pypi
10 from .support.lexical_path import LexicalPath
11
12 if is_pypi:
13 from pathlib_abc import _PathParser, _JoinablePath
14 else:
15 from pathlib.types import _PathParser, _JoinablePath
16
17
18 class JoinTestBase:
19 def test_is_joinable(self):
20 p = self.cls()
21 self.assertIsInstance(p, _JoinablePath)
22
23 def test_parser(self):
24 self.assertIsInstance(self.cls.parser, _PathParser)
25
26 def test_constructor(self):
27 P = self.cls
28 p = P('a')
29 self.assertIsInstance(p, P)
30 P()
31 P('a', 'b', 'c')
32 P('/a', 'b', 'c')
33 P('a/b/c')
34 P('/a/b/c')
35
36 def test_with_segments(self):
37 class P(self.cls):
38 def __init__(self, *pathsegments, session_id):
39 super().__init__(*pathsegments)
40 self.session_id = session_id
41
42 def with_segments(self, *pathsegments):
43 return type(self)(*pathsegments, session_id=self.session_id)
44 p = P('foo', 'bar', session_id=42)
45 self.assertEqual(42, (p / 'foo').session_id)
46 self.assertEqual(42, ('foo' / p).session_id)
47 self.assertEqual(42, p.joinpath('foo').session_id)
48 self.assertEqual(42, p.with_name('foo').session_id)
49 self.assertEqual(42, p.with_stem('foo').session_id)
50 self.assertEqual(42, p.with_suffix('.foo').session_id)
51 self.assertEqual(42, p.with_segments('foo').session_id)
52 self.assertEqual(42, p.parent.session_id)
53 for parent in p.parents:
54 self.assertEqual(42, parent.session_id)
55
56 def test_join(self):
57 P = self.cls
58 sep = self.cls.parser.sep
59 p = P(f'a{sep}b')
60 pp = p.joinpath('c')
61 self.assertEqual(pp, P(f'a{sep}b{sep}c'))
62 self.assertIs(type(pp), type(p))
63 pp = p.joinpath('c', 'd')
64 self.assertEqual(pp, P(f'a{sep}b{sep}c{sep}d'))
65 pp = p.joinpath(f'{sep}c')
66 self.assertEqual(pp, P(f'{sep}c'))
67
68 def test_div(self):
69 # Basically the same as joinpath().
70 P = self.cls
71 sep = self.cls.parser.sep
72 p = P(f'a{sep}b')
73 pp = p / 'c'
74 self.assertEqual(pp, P(f'a{sep}b{sep}c'))
75 self.assertIs(type(pp), type(p))
76 pp = p / f'c{sep}d'
77 self.assertEqual(pp, P(f'a{sep}b{sep}c{sep}d'))
78 pp = p / 'c' / 'd'
79 self.assertEqual(pp, P(f'a{sep}b{sep}c{sep}d'))
80 pp = 'c' / p / 'd'
81 self.assertEqual(pp, P(f'c{sep}a{sep}b{sep}d'))
82 pp = p/ f'{sep}c'
83 self.assertEqual(pp, P(f'{sep}c'))
84
85 def test_full_match(self):
86 P = self.cls
87 # Simple relative pattern.
88 self.assertTrue(P('b.py').full_match('b.py'))
89 self.assertFalse(P('a/b.py').full_match('b.py'))
90 self.assertFalse(P('/a/b.py').full_match('b.py'))
91 self.assertFalse(P('a.py').full_match('b.py'))
92 self.assertFalse(P('b/py').full_match('b.py'))
93 self.assertFalse(P('/a.py').full_match('b.py'))
94 self.assertFalse(P('b.py/c').full_match('b.py'))
95 # Wildcard relative pattern.
96 self.assertTrue(P('b.py').full_match('*.py'))
97 self.assertFalse(P('a/b.py').full_match('*.py'))
98 self.assertFalse(P('/a/b.py').full_match('*.py'))
99 self.assertFalse(P('b.pyc').full_match('*.py'))
100 self.assertFalse(P('b./py').full_match('*.py'))
101 self.assertFalse(P('b.py/c').full_match('*.py'))
102 # Multi-part relative pattern.
103 self.assertTrue(P('ab/c.py').full_match('a*/*.py'))
104 self.assertFalse(P('/d/ab/c.py').full_match('a*/*.py'))
105 self.assertFalse(P('a.py').full_match('a*/*.py'))
106 self.assertFalse(P('/dab/c.py').full_match('a*/*.py'))
107 self.assertFalse(P('ab/c.py/d').full_match('a*/*.py'))
108 # Absolute pattern.
109 self.assertTrue(P('/b.py').full_match('/*.py'))
110 self.assertFalse(P('b.py').full_match('/*.py'))
111 self.assertFalse(P('a/b.py').full_match('/*.py'))
112 self.assertFalse(P('/a/b.py').full_match('/*.py'))
113 # Multi-part absolute pattern.
114 self.assertTrue(P('/a/b.py').full_match('/a/*.py'))
115 self.assertFalse(P('/ab.py').full_match('/a/*.py'))
116 self.assertFalse(P('/a/b/c.py').full_match('/a/*.py'))
117 # Multi-part glob-style pattern.
118 self.assertTrue(P('a').full_match('**'))
119 self.assertTrue(P('c.py').full_match('**'))
120 self.assertTrue(P('a/b/c.py').full_match('**'))
121 self.assertTrue(P('/a/b/c.py').full_match('**'))
122 self.assertTrue(P('/a/b/c.py').full_match('/**'))
123 self.assertTrue(P('/a/b/c.py').full_match('/a/**'))
124 self.assertTrue(P('/a/b/c.py').full_match('**/*.py'))
125 self.assertTrue(P('/a/b/c.py').full_match('/**/*.py'))
126 self.assertTrue(P('/a/b/c.py').full_match('/a/**/*.py'))
127 self.assertTrue(P('/a/b/c.py').full_match('/a/b/**/*.py'))
128 self.assertTrue(P('/a/b/c.py').full_match('/**/**/**/**/*.py'))
129 self.assertFalse(P('c.py').full_match('**/a.py'))
130 self.assertFalse(P('c.py').full_match('c/**'))
131 self.assertFalse(P('a/b/c.py').full_match('**/a'))
132 self.assertFalse(P('a/b/c.py').full_match('**/a/b'))
133 self.assertFalse(P('a/b/c.py').full_match('**/a/b/c'))
134 self.assertFalse(P('a/b/c.py').full_match('**/a/b/c.'))
135 self.assertFalse(P('a/b/c.py').full_match('**/a/b/c./**'))
136 self.assertFalse(P('a/b/c.py').full_match('**/a/b/c./**'))
137 self.assertFalse(P('a/b/c.py').full_match('/a/b/c.py/**'))
138 self.assertFalse(P('a/b/c.py').full_match('/**/a/b/c.py'))
139 # Matching against empty path
140 self.assertFalse(P('').full_match('*'))
141 self.assertTrue(P('').full_match('**'))
142 self.assertFalse(P('').full_match('**/*'))
143 # Matching with empty pattern
144 self.assertTrue(P('').full_match(''))
145 self.assertTrue(P('.').full_match('.'))
146 self.assertFalse(P('/').full_match(''))
147 self.assertFalse(P('/').full_match('.'))
148 self.assertFalse(P('foo').full_match(''))
149 self.assertFalse(P('foo').full_match('.'))
150
151 def test_parts(self):
152 # `parts` returns a tuple.
153 sep = self.cls.parser.sep
154 P = self.cls
155 p = P(f'a{sep}b')
156 parts = p.parts
157 self.assertEqual(parts, ('a', 'b'))
158 # When the path is absolute, the anchor is a separate part.
159 p = P(f'{sep}a{sep}b')
160 parts = p.parts
161 self.assertEqual(parts, (sep, 'a', 'b'))
162
163 @threading_helper.requires_working_threading()
164 def test_parts_multithreaded(self):
165 P = self.cls
166
167 NUM_THREADS = 10
168 NUM_ITERS = 10
169
170 for _ in range(NUM_ITERS):
171 b = threading.Barrier(NUM_THREADS)
172 path = P('a') / 'b' / 'c' / 'd' / 'e'
173 expected = ('a', 'b', 'c', 'd', 'e')
174
175 def check_parts():
176 b.wait()
177 self.assertEqual(path.parts, expected)
178
179 threads = [threading.Thread(target=check_parts) for _ in range(NUM_THREADS)]
180 with threading_helper.start_threads(threads):
181 pass
182
183 def test_parent(self):
184 # Relative
185 P = self.cls
186 p = P('a/b/c')
187 self.assertEqual(p.parent, P('a/b'))
188 self.assertEqual(p.parent.parent, P('a'))
189 self.assertEqual(p.parent.parent.parent, P(''))
190 self.assertEqual(p.parent.parent.parent.parent, P(''))
191 # Anchored
192 p = P('/a/b/c')
193 self.assertEqual(p.parent, P('/a/b'))
194 self.assertEqual(p.parent.parent, P('/a'))
195 self.assertEqual(p.parent.parent.parent, P('/'))
196 self.assertEqual(p.parent.parent.parent.parent, P('/'))
197
198 def test_parents(self):
199 # Relative
200 P = self.cls
201 p = P('a/b/c')
202 par = p.parents
203 self.assertEqual(len(par), 3)
204 self.assertEqual(par[0], P('a/b'))
205 self.assertEqual(par[1], P('a'))
206 self.assertEqual(par[2], P(''))
207 self.assertEqual(par[-1], P(''))
208 self.assertEqual(par[-2], P('a'))
209 self.assertEqual(par[-3], P('a/b'))
210 self.assertEqual(par[0:1], (P('a/b'),))
211 self.assertEqual(par[:2], (P('a/b'), P('a')))
212 self.assertEqual(par[:-1], (P('a/b'), P('a')))
213 self.assertEqual(par[1:], (P('a'), P('')))
214 self.assertEqual(par[::2], (P('a/b'), P('')))
215 self.assertEqual(par[::-1], (P(''), P('a'), P('a/b')))
216 self.assertEqual(list(par), [P('a/b'), P('a'), P('')])
217 with self.assertRaises(IndexError):
218 par[-4]
219 with self.assertRaises(IndexError):
220 par[3]
221 with self.assertRaises(TypeError):
222 par[0] = p
223 # Anchored
224 p = P('/a/b/c')
225 par = p.parents
226 self.assertEqual(len(par), 3)
227 self.assertEqual(par[0], P('/a/b'))
228 self.assertEqual(par[1], P('/a'))
229 self.assertEqual(par[2], P('/'))
230 self.assertEqual(par[-1], P('/'))
231 self.assertEqual(par[-2], P('/a'))
232 self.assertEqual(par[-3], P('/a/b'))
233 self.assertEqual(par[0:1], (P('/a/b'),))
234 self.assertEqual(par[:2], (P('/a/b'), P('/a')))
235 self.assertEqual(par[:-1], (P('/a/b'), P('/a')))
236 self.assertEqual(par[1:], (P('/a'), P('/')))
237 self.assertEqual(par[::2], (P('/a/b'), P('/')))
238 self.assertEqual(par[::-1], (P('/'), P('/a'), P('/a/b')))
239 self.assertEqual(list(par), [P('/a/b'), P('/a'), P('/')])
240 with self.assertRaises(IndexError):
241 par[-4]
242 with self.assertRaises(IndexError):
243 par[3]
244
245 def test_anchor(self):
246 P = self.cls
247 sep = self.cls.parser.sep
248 self.assertEqual(P('').anchor, '')
249 self.assertEqual(P(f'a{sep}b').anchor, '')
250 self.assertEqual(P(sep).anchor, sep)
251 self.assertEqual(P(f'{sep}a{sep}b').anchor, sep)
252
253 def test_name(self):
254 P = self.cls
255 self.assertEqual(P('').name, '')
256 self.assertEqual(P('/').name, '')
257 self.assertEqual(P('a/b').name, 'b')
258 self.assertEqual(P('/a/b').name, 'b')
259 self.assertEqual(P('a/b.py').name, 'b.py')
260 self.assertEqual(P('/a/b.py').name, 'b.py')
261
262 def test_suffix(self):
263 P = self.cls
264 self.assertEqual(P('').suffix, '')
265 self.assertEqual(P('.').suffix, '')
266 self.assertEqual(P('..').suffix, '')
267 self.assertEqual(P('/').suffix, '')
268 self.assertEqual(P('a/b').suffix, '')
269 self.assertEqual(P('/a/b').suffix, '')
270 self.assertEqual(P('/a/b/.').suffix, '')
271 self.assertEqual(P('a/b.py').suffix, '.py')
272 self.assertEqual(P('/a/b.py').suffix, '.py')
273 self.assertEqual(P('a/.hgrc').suffix, '')
274 self.assertEqual(P('/a/.hgrc').suffix, '')
275 self.assertEqual(P('a/.hg.rc').suffix, '.rc')
276 self.assertEqual(P('/a/.hg.rc').suffix, '.rc')
277 self.assertEqual(P('a/b.tar.gz').suffix, '.gz')
278 self.assertEqual(P('/a/b.tar.gz').suffix, '.gz')
279 self.assertEqual(P('a/trailing.dot.').suffix, '.')
280 self.assertEqual(P('/a/trailing.dot.').suffix, '.')
281 self.assertEqual(P('a/..d.o.t..').suffix, '.')
282 self.assertEqual(P('a/inn.er..dots').suffix, '.dots')
283 self.assertEqual(P('photo').suffix, '')
284 self.assertEqual(P('photo.jpg').suffix, '.jpg')
285
286 def test_suffixes(self):
287 P = self.cls
288 self.assertEqual(P('').suffixes, [])
289 self.assertEqual(P('.').suffixes, [])
290 self.assertEqual(P('/').suffixes, [])
291 self.assertEqual(P('a/b').suffixes, [])
292 self.assertEqual(P('/a/b').suffixes, [])
293 self.assertEqual(P('/a/b/.').suffixes, [])
294 self.assertEqual(P('a/b.py').suffixes, ['.py'])
295 self.assertEqual(P('/a/b.py').suffixes, ['.py'])
296 self.assertEqual(P('a/.hgrc').suffixes, [])
297 self.assertEqual(P('/a/.hgrc').suffixes, [])
298 self.assertEqual(P('a/.hg.rc').suffixes, ['.rc'])
299 self.assertEqual(P('/a/.hg.rc').suffixes, ['.rc'])
300 self.assertEqual(P('a/b.tar.gz').suffixes, ['.tar', '.gz'])
301 self.assertEqual(P('/a/b.tar.gz').suffixes, ['.tar', '.gz'])
302 self.assertEqual(P('a/trailing.dot.').suffixes, ['.dot', '.'])
303 self.assertEqual(P('/a/trailing.dot.').suffixes, ['.dot', '.'])
304 self.assertEqual(P('a/..d.o.t..').suffixes, ['.o', '.t', '.', '.'])
305 self.assertEqual(P('a/inn.er..dots').suffixes, ['.er', '.', '.dots'])
306 self.assertEqual(P('photo').suffixes, [])
307 self.assertEqual(P('photo.jpg').suffixes, ['.jpg'])
308
309 def test_stem(self):
310 P = self.cls
311 self.assertEqual(P('..').stem, '..')
312 self.assertEqual(P('').stem, '')
313 self.assertEqual(P('/').stem, '')
314 self.assertEqual(P('a/b').stem, 'b')
315 self.assertEqual(P('a/b.py').stem, 'b')
316 self.assertEqual(P('a/.hgrc').stem, '.hgrc')
317 self.assertEqual(P('a/.hg.rc').stem, '.hg')
318 self.assertEqual(P('a/b.tar.gz').stem, 'b.tar')
319 self.assertEqual(P('a/trailing.dot.').stem, 'trailing.dot')
320 self.assertEqual(P('a/..d.o.t..').stem, '..d.o.t.')
321 self.assertEqual(P('a/inn.er..dots').stem, 'inn.er.')
322 self.assertEqual(P('photo').stem, 'photo')
323 self.assertEqual(P('photo.jpg').stem, 'photo')
324
325 def test_with_name(self):
326 P = self.cls
327 self.assertEqual(P('a/b').with_name('d.xml'), P('a/d.xml'))
328 self.assertEqual(P('/a/b').with_name('d.xml'), P('/a/d.xml'))
329 self.assertEqual(P('a/b.py').with_name('d.xml'), P('a/d.xml'))
330 self.assertEqual(P('/a/b.py').with_name('d.xml'), P('/a/d.xml'))
331 self.assertEqual(P('a/Dot ending.').with_name('d.xml'), P('a/d.xml'))
332 self.assertEqual(P('/a/Dot ending.').with_name('d.xml'), P('/a/d.xml'))
333 self.assertRaises(ValueError, P('a/b').with_name, '/c')
334 self.assertRaises(ValueError, P('a/b').with_name, 'c/')
335 self.assertRaises(ValueError, P('a/b').with_name, 'c/d')
336
337 def test_with_stem(self):
338 P = self.cls
339 self.assertEqual(P('a/b').with_stem('d'), P('a/d'))
340 self.assertEqual(P('/a/b').with_stem('d'), P('/a/d'))
341 self.assertEqual(P('a/b.py').with_stem('d'), P('a/d.py'))
342 self.assertEqual(P('/a/b.py').with_stem('d'), P('/a/d.py'))
343 self.assertEqual(P('/a/b.tar.gz').with_stem('d'), P('/a/d.gz'))
344 self.assertEqual(P('a/Dot ending.').with_stem('d'), P('a/d.'))
345 self.assertEqual(P('/a/Dot ending.').with_stem('d'), P('/a/d.'))
346 self.assertRaises(ValueError, P('foo.gz').with_stem, '')
347 self.assertRaises(ValueError, P('/a/b/foo.gz').with_stem, '')
348 self.assertRaises(ValueError, P('a/b').with_stem, '/c')
349 self.assertRaises(ValueError, P('a/b').with_stem, 'c/')
350 self.assertRaises(ValueError, P('a/b').with_stem, 'c/d')
351
352 def test_with_suffix(self):
353 P = self.cls
354 self.assertEqual(P('a/b').with_suffix('.gz'), P('a/b.gz'))
355 self.assertEqual(P('/a/b').with_suffix('.gz'), P('/a/b.gz'))
356 self.assertEqual(P('a/b.py').with_suffix('.gz'), P('a/b.gz'))
357 self.assertEqual(P('/a/b.py').with_suffix('.gz'), P('/a/b.gz'))
358 # Stripping suffix.
359 self.assertEqual(P('a/b.py').with_suffix(''), P('a/b'))
360 self.assertEqual(P('/a/b').with_suffix(''), P('/a/b'))
361 # Single dot
362 self.assertEqual(P('a/b').with_suffix('.'), P('a/b.'))
363 self.assertEqual(P('/a/b').with_suffix('.'), P('/a/b.'))
364 self.assertEqual(P('a/b.py').with_suffix('.'), P('a/b.'))
365 self.assertEqual(P('/a/b.py').with_suffix('.'), P('/a/b.'))
366 # Path doesn't have a "filename" component.
367 self.assertRaises(ValueError, P('').with_suffix, '.gz')
368 self.assertRaises(ValueError, P('/').with_suffix, '.gz')
369 # Invalid suffix.
370 self.assertRaises(ValueError, P('a/b').with_suffix, 'gz')
371 self.assertRaises(ValueError, P('a/b').with_suffix, '/')
372 self.assertRaises(ValueError, P('a/b').with_suffix, '/.gz')
373 self.assertRaises(ValueError, P('a/b').with_suffix, 'c/d')
374 self.assertRaises(ValueError, P('a/b').with_suffix, '.c/.d')
375 self.assertRaises(ValueError, P('a/b').with_suffix, './.d')
376 self.assertRaises(ValueError, P('a/b').with_suffix, '.d/.')
377 self.assertRaises(TypeError, P('a/b').with_suffix, None)
378
379
380 class LexicalPathJoinTest(JoinTestBase, unittest.TestCase):
381 cls = LexicalPath
382
383
384 if not is_pypi:
385 from pathlib import PurePath, Path
386
387 class PurePathJoinTest(JoinTestBase, unittest.TestCase):
388 cls = PurePath
389
390 class PathJoinTest(JoinTestBase, unittest.TestCase):
391 cls = Path
392
393
394 if __name__ == "__main__":
395 unittest.main()