test_pathlib.py - OpenGrok cross reference for /third_party/python/Lib/test/test

Lines Matching refs:self
28     def _check_parse_parts(self, arg, expected):
29         f = self.flavour.parse_parts
30         sep = self.flavour.sep
31         altsep = self.flavour.altsep
33         self.assertEqual(actual, expected)
36             self.assertEqual(actual, expected)
38     def test_parse_parts_common(self):
39         check = self._check_parse_parts
40         sep = self.flavour.sep
70     def test_parse_parts(self):
71         check = self._check_parse_parts
82     def test_splitroot(self):
83         f = self.flavour.splitroot
84         self.assertEqual(f(''), ('', '', ''))
85         self.assertEqual(f('a'), ('', '', 'a'))
86         self.assertEqual(f('a/b'), ('', '', 'a/b'))
87         self.assertEqual(f('a/b/'), ('', '', 'a/b/'))
88         self.assertEqual(f('/a'), ('', '/', 'a'))
89         self.assertEqual(f('/a/b'), ('', '/', 'a/b'))
90         self.assertEqual(f('/a/b/'), ('', '/', 'a/b/'))
94         self.assertEqual(f('//a'), ('', '//', 'a'))
95         self.assertEqual(f('///a'), ('', '/', 'a'))
96         self.assertEqual(f('///a/b'), ('', '/', 'a/b'))
98         self.assertEqual(f('c:/a/b'), ('', '', 'c:/a/b'))
99         self.assertEqual(f('\\/a/b'), ('', '', '\\/a/b'))
100         self.assertEqual(f('\\a\\b'), ('', '', '\\a\\b'))
106     def test_parse_parts(self):
107         check = self._check_parse_parts
140     def test_splitroot(self):
141         f = self.flavour.splitroot
142         self.assertEqual(f(''), ('', '', ''))
143         self.assertEqual(f('a'), ('', '', 'a'))
144         self.assertEqual(f('a\\b'), ('', '', 'a\\b'))
145         self.assertEqual(f('\\a'), ('', '\\', 'a'))
146         self.assertEqual(f('\\a\\b'), ('', '\\', 'a\\b'))
147         self.assertEqual(f('c:a\\b'), ('c:', '', 'a\\b'))
148         self.assertEqual(f('c:\\a\\b'), ('c:', '\\', 'a\\b'))
150         self.assertEqual(f('\\\\a'), ('', '\\', 'a'))
151         self.assertEqual(f('\\\\\\a/b'), ('', '\\', 'a/b'))
152         self.assertEqual(f('c:\\\\a'), ('c:', '\\', 'a'))
153         self.assertEqual(f('c:\\\\\\a/b'), ('c:', '\\', 'a/b'))
155         self.assertEqual(f('\\\\a\\b'), ('\\\\a\\b', '\\', ''))
156         self.assertEqual(f('\\\\a\\b\\'), ('\\\\a\\b', '\\', ''))
157         self.assertEqual(f('\\\\a\\b\\c\\d'), ('\\\\a\\b', '\\', 'c\\d'))
161         self.assertEqual(f('\\\\\\a\\b'), ('', '\\', 'a\\b'))
162         self.assertEqual(f('\\\\a'), ('', '\\', 'a'))
188     def setUp(self):
189         p = self.cls('a')
190         self.flavour = p._flavour
191         self.sep = self.flavour.sep
192         self.altsep = self.flavour.altsep
194     def test_constructor_common(self):
195         P = self.cls
197         self.assertIsInstance(p, P)
203         self.assertEqual(P(P('a')), P('a'))
204         self.assertEqual(P(P('a'), 'b'), P('a/b'))
205         self.assertEqual(P(P('a'), P('b')), P('a/b'))
206         self.assertEqual(P(P('a'), P('b'), P('c')), P(FakePath("a/b/c")))
208     def _check_str_subclass(self, *args):
214         P = self.cls
216         self.assertEqual(p, P(*args))
218             self.assertIs(type(part), str)
220     def test_str_subclass_common(self):
221         self._check_str_subclass('')
222         self._check_str_subclass('.')
223         self._check_str_subclass('a')
224         self._check_str_subclass('a/b.txt')
225         self._check_str_subclass('/a/b.txt')
227     def test_join_common(self):
228         P = self.cls
231         self.assertEqual(pp, P('a/b/c'))
232         self.assertIs(type(pp), type(p))
234         self.assertEqual(pp, P('a/b/c/d'))
236         self.assertEqual(pp, P('a/b/c'))
238         self.assertEqual(pp, P('/c'))
240     def test_div_common(self):
242         P = self.cls
245         self.assertEqual(pp, P('a/b/c'))
246         self.assertIs(type(pp), type(p))
248         self.assertEqual(pp, P('a/b/c/d'))
250         self.assertEqual(pp, P('a/b/c/d'))
252         self.assertEqual(pp, P('c/a/b/d'))
254         self.assertEqual(pp, P('a/b/c'))
256         self.assertEqual(pp, P('/c'))
258     def _check_str(self, expected, args):
259         p = self.cls(*args)
260         self.assertEqual(str(p), expected.replace('/', self.sep))
262     def test_str_common(self):
265             self._check_str(pathstr, (pathstr,))
267         self._check_str('.', ('',))
270     def test_as_posix_common(self):
271         P = self.cls
273             self.assertEqual(P(pathstr).as_posix(), pathstr)
276     def test_as_bytes_common(self):
277         sep = os.fsencode(self.sep)
278         P = self.cls
279         self.assertEqual(bytes(P('a/b')), b'a' + sep + b'b')
281     def test_as_uri_common(self):
282         P = self.cls
283         with self.assertRaises(ValueError):
285         with self.assertRaises(ValueError):
288     def test_repr_common(self):
290             p = self.cls(pathstr)
294             self.assertTrue(r.startswith(clsname + '('), r)
295             self.assertTrue(r.endswith(')'), r)
297             self.assertEqual(eval(inner), p.as_posix())
300             self.assertIs(q.__class__, p.__class__)
301             self.assertEqual(q, p)
302             self.assertEqual(repr(q), r)
304     def test_eq_common(self):
305         P = self.cls
306         self.assertEqual(P('a/b'), P('a/b'))
307         self.assertEqual(P('a/b'), P('a', 'b'))
308         self.assertNotEqual(P('a/b'), P('a'))
309         self.assertNotEqual(P('a/b'), P('/a/b'))
310         self.assertNotEqual(P('a/b'), P())
311         self.assertNotEqual(P('/a/b'), P('/'))
312         self.assertNotEqual(P(), P('/'))
313         self.assertNotEqual(P(), "")
314         self.assertNotEqual(P(), {})
315         self.assertNotEqual(P(), int)
317     def test_match_common(self):
318         P = self.cls
319         self.assertRaises(ValueError, P('a').match, '')
320         self.assertRaises(ValueError, P('a').match, '.')
322         self.assertTrue(P('b.py').match('b.py'))
323         self.assertTrue(P('a/b.py').match('b.py'))
324         self.assertTrue(P('/a/b.py').match('b.py'))
325         self.assertFalse(P('a.py').match('b.py'))
326         self.assertFalse(P('b/py').match('b.py'))
327         self.assertFalse(P('/a.py').match('b.py'))
328         self.assertFalse(P('b.py/c').match('b.py'))
330         self.assertTrue(P('b.py').match('*.py'))
331         self.assertTrue(P('a/b.py').match('*.py'))
332         self.assertTrue(P('/a/b.py').match('*.py'))
333         self.assertFalse(P('b.pyc').match('*.py'))
334         self.assertFalse(P('b./py').match('*.py'))
335         self.assertFalse(P('b.py/c').match('*.py'))
337         self.assertTrue(P('ab/c.py').match('a*/*.py'))
338         self.assertTrue(P('/d/ab/c.py').match('a*/*.py'))
339         self.assertFalse(P('a.py').match('a*/*.py'))
340         self.assertFalse(P('/dab/c.py').match('a*/*.py'))
341         self.assertFalse(P('ab/c.py/d').match('a*/*.py'))
343         self.assertTrue(P('/b.py').match('/*.py'))
344         self.assertFalse(P('b.py').match('/*.py'))
345         self.assertFalse(P('a/b.py').match('/*.py'))
346         self.assertFalse(P('/a/b.py').match('/*.py'))
348         self.assertTrue(P('/a/b.py').match('/a/*.py'))
349         self.assertFalse(P('/ab.py').match('/a/*.py'))
350         self.assertFalse(P('/a/b/c.py').match('/a/*.py'))
352         self.assertFalse(P('/a/b/c.py').match('/**/*.py'))
353         self.assertTrue(P('/a/b/c.py').match('/a/**/*.py'))
355     def test_ordering_common(self):
358             self.assertLess(a, b)
359             self.assertGreater(b, a)
360         P = self.cls
370         P = self.cls
380         with self.assertRaises(TypeError):
383     def test_parts_common(self):
385         sep = self.sep
386         P = self.cls
389         self.assertEqual(parts, ('a', 'b'))
391         self.assertIs(parts, p.parts)
395         self.assertEqual(parts, (sep, 'a', 'b'))
397     def test_fspath_common(self):
398         P = self.cls
400         self._check_str(p.__fspath__(), ('a/b',))
401         self._check_str(os.fspath(p), ('a/b',))
403     def test_equivalences(self):
404         for k, tuples in self.equivalences.items():
405             canon = k.replace('/', self.sep)
406             posix = k.replace(self.sep, '/')
409                     tuple(part.replace('/', self.sep) for part in t)
413             pcanon = self.cls(canon)
415                 p = self.cls(*t)
416                 self.assertEqual(p, pcanon, "failed with args {}".format(t))
417                 self.assertEqual(hash(p), hash(pcanon))
418                 self.assertEqual(str(p), canon)
419                 self.assertEqual(p.as_posix(), posix)
421     def test_parent_common(self):
423         P = self.cls
425         self.assertEqual(p.parent, P('a/b'))
426         self.assertEqual(p.parent.parent, P('a'))
427         self.assertEqual(p.parent.parent.parent, P())
428         self.assertEqual(p.parent.parent.parent.parent, P())
431         self.assertEqual(p.parent, P('/a/b'))
432         self.assertEqual(p.parent.parent, P('/a'))
433         self.assertEqual(p.parent.parent.parent, P('/'))
434         self.assertEqual(p.parent.parent.parent.parent, P('/'))
436     def test_parents_common(self):
438         P = self.cls
441         self.assertEqual(len(par), 3)
442         self.assertEqual(par[0], P('a/b'))
443         self.assertEqual(par[1], P('a'))
444         self.assertEqual(par[2], P('.'))
445         self.assertEqual(par[-1], P('.'))
446         self.assertEqual(par[-2], P('a'))
447         self.assertEqual(par[-3], P('a/b'))
448         self.assertEqual(par[0:1], (P('a/b'),))
449         self.assertEqual(par[:2], (P('a/b'), P('a')))
450         self.assertEqual(par[:-1], (P('a/b'), P('a')))
451         self.assertEqual(par[1:], (P('a'), P('.')))
452         self.assertEqual(par[::2], (P('a/b'), P('.')))
453         self.assertEqual(par[::-1], (P('.'), P('a'), P('a/b')))
454         self.assertEqual(list(par), [P('a/b'), P('a'), P('.')])
455         with self.assertRaises(IndexError):
457         with self.assertRaises(IndexError):
459         with self.assertRaises(TypeError):
464         self.assertEqual(len(par), 3)
465         self.assertEqual(par[0], P('/a/b'))
466         self.assertEqual(par[1], P('/a'))
467         self.assertEqual(par[2], P('/'))
468         self.assertEqual(par[-1], P('/'))
469         self.assertEqual(par[-2], P('/a'))
470         self.assertEqual(par[-3], P('/a/b'))
471         self.assertEqual(par[0:1], (P('/a/b'),))
472         self.assertEqual(par[:2], (P('/a/b'), P('/a')))
473         self.assertEqual(par[:-1], (P('/a/b'), P('/a')))
474         self.assertEqual(par[1:], (P('/a'), P('/')))
475         self.assertEqual(par[::2], (P('/a/b'), P('/')))
476         self.assertEqual(par[::-1], (P('/'), P('/a'), P('/a/b')))
477         self.assertEqual(list(par), [P('/a/b'), P('/a'), P('/')])
478         with self.assertRaises(IndexError):
480         with self.assertRaises(IndexError):
483     def test_drive_common(self):
484         P = self.cls
485         self.assertEqual(P('a/b').drive, '')
486         self.assertEqual(P('/a/b').drive, '')
487         self.assertEqual(P('').drive, '')
489     def test_root_common(self):
490         P = self.cls
491         sep = self.sep
492         self.assertEqual(P('').root, '')
493         self.assertEqual(P('a/b').root, '')
494         self.assertEqual(P('/').root, sep)
495         self.assertEqual(P('/a/b').root, sep)
497     def test_anchor_common(self):
498         P = self.cls
499         sep = self.sep
500         self.assertEqual(P('').anchor, '')
501         self.assertEqual(P('a/b').anchor, '')
502         self.assertEqual(P('/').anchor, sep)
503         self.assertEqual(P('/a/b').anchor, sep)
505     def test_name_common(self):
506         P = self.cls
507         self.assertEqual(P('').name, '')
508         self.assertEqual(P('.').name, '')
509         self.assertEqual(P('/').name, '')
510         self.assertEqual(P('a/b').name, 'b')
511         self.assertEqual(P('/a/b').name, 'b')
512         self.assertEqual(P('/a/b/.').name, 'b')
513         self.assertEqual(P('a/b.py').name, 'b.py')
514         self.assertEqual(P('/a/b.py').name, 'b.py')
516     def test_suffix_common(self):
517         P = self.cls
518         self.assertEqual(P('').suffix, '')
519         self.assertEqual(P('.').suffix, '')
520         self.assertEqual(P('..').suffix, '')
521         self.assertEqual(P('/').suffix, '')
522         self.assertEqual(P('a/b').suffix, '')
523         self.assertEqual(P('/a/b').suffix, '')
524         self.assertEqual(P('/a/b/.').suffix, '')
525         self.assertEqual(P('a/b.py').suffix, '.py')
526         self.assertEqual(P('/a/b.py').suffix, '.py')
527         self.assertEqual(P('a/.hgrc').suffix, '')
528         self.assertEqual(P('/a/.hgrc').suffix, '')
529         self.assertEqual(P('a/.hg.rc').suffix, '.rc')
530         self.assertEqual(P('/a/.hg.rc').suffix, '.rc')
531         self.assertEqual(P('a/b.tar.gz').suffix, '.gz')
532         self.assertEqual(P('/a/b.tar.gz').suffix, '.gz')
533         self.assertEqual(P('a/Some name. Ending with a dot.').suffix, '')
534         self.assertEqual(P('/a/Some name. Ending with a dot.').suffix, '')
536     def test_suffixes_common(self):
537         P = self.cls
538         self.assertEqual(P('').suffixes, [])
539         self.assertEqual(P('.').suffixes, [])
540         self.assertEqual(P('/').suffixes, [])
541         self.assertEqual(P('a/b').suffixes, [])
542         self.assertEqual(P('/a/b').suffixes, [])
543         self.assertEqual(P('/a/b/.').suffixes, [])
544         self.assertEqual(P('a/b.py').suffixes, ['.py'])
545         self.assertEqual(P('/a/b.py').suffixes, ['.py'])
546         self.assertEqual(P('a/.hgrc').suffixes, [])
547         self.assertEqual(P('/a/.hgrc').suffixes, [])
548         self.assertEqual(P('a/.hg.rc').suffixes, ['.rc'])
549         self.assertEqual(P('/a/.hg.rc').suffixes, ['.rc'])
550         self.assertEqual(P('a/b.tar.gz').suffixes, ['.tar', '.gz'])
551         self.assertEqual(P('/a/b.tar.gz').suffixes, ['.tar', '.gz'])
552         self.assertEqual(P('a/Some name. Ending with a dot.').suffixes, [])
553         self.assertEqual(P('/a/Some name. Ending with a dot.').suffixes, [])
555     def test_stem_common(self):
556         P = self.cls
557         self.assertEqual(P('').stem, '')
558         self.assertEqual(P('.').stem, '')
559         self.assertEqual(P('..').stem, '..')
560         self.assertEqual(P('/').stem, '')
561         self.assertEqual(P('a/b').stem, 'b')
562         self.assertEqual(P('a/b.py').stem, 'b')
563         self.assertEqual(P('a/.hgrc').stem, '.hgrc')
564         self.assertEqual(P('a/.hg.rc').stem, '.hg')
565         self.assertEqual(P('a/b.tar.gz').stem, 'b.tar')
566         self.assertEqual(P('a/Some name. Ending with a dot.').stem,
569     def test_with_name_common(self):
570         P = self.cls
571         self.assertEqual(P('a/b').with_name('d.xml'), P('a/d.xml'))
572         self.assertEqual(P('/a/b').with_name('d.xml'), P('/a/d.xml'))
573         self.assertEqual(P('a/b.py').with_name('d.xml'), P('a/d.xml'))
574         self.assertEqual(P('/a/b.py').with_name('d.xml'), P('/a/d.xml'))
575         self.assertEqual(P('a/Dot ending.').with_name('d.xml'), P('a/d.xml'))
576         self.assertEqual(P('/a/Dot ending.').with_name('d.xml'), P('/a/d.xml'))
577         self.assertRaises(ValueError, P('').with_name, 'd.xml')
578         self.assertRaises(ValueError, P('.').with_name, 'd.xml')
579         self.assertRaises(ValueError, P('/').with_name, 'd.xml')
580         self.assertRaises(ValueError, P('a/b').with_name, '')
581         self.assertRaises(ValueError, P('a/b').with_name, '/c')
582         self.assertRaises(ValueError, P('a/b').with_name, 'c/')
583         self.assertRaises(ValueError, P('a/b').with_name, 'c/d')
585     def test_with_stem_common(self):
586         P = self.cls
587         self.assertEqual(P('a/b').with_stem('d'), P('a/d'))
588         self.assertEqual(P('/a/b').with_stem('d'), P('/a/d'))
589         self.assertEqual(P('a/b.py').with_stem('d'), P('a/d.py'))
590         self.assertEqual(P('/a/b.py').with_stem('d'), P('/a/d.py'))
591         self.assertEqual(P('/a/b.tar.gz').with_stem('d'), P('/a/d.gz'))
592         self.assertEqual(P('a/Dot ending.').with_stem('d'), P('a/d'))
593         self.assertEqual(P('/a/Dot ending.').with_stem('d'), P('/a/d'))
594         self.assertRaises(ValueError, P('').with_stem, 'd')
595         self.assertRaises(ValueError, P('.').with_stem, 'd')
596         self.assertRaises(ValueError, P('/').with_stem, 'd')
597         self.assertRaises(ValueError, P('a/b').with_stem, '')
598         self.assertRaises(ValueError, P('a/b').with_stem, '/c')
599         self.assertRaises(ValueError, P('a/b').with_stem, 'c/')
600         self.assertRaises(ValueError, P('a/b').with_stem, 'c/d')
602     def test_with_suffix_common(self):
603         P = self.cls
604         self.assertEqual(P('a/b').with_suffix('.gz'), P('a/b.gz'))
605         self.assertEqual(P('/a/b').with_suffix('.gz'), P('/a/b.gz'))
606         self.assertEqual(P('a/b.py').with_suffix('.gz'), P('a/b.gz'))
607         self.assertEqual(P('/a/b.py').with_suffix('.gz'), P('/a/b.gz'))
609         self.assertEqual(P('a/b.py').with_suffix(''), P('a/b'))
610         self.assertEqual(P('/a/b').with_suffix(''), P('/a/b'))
612         self.assertRaises(ValueError, P('').with_suffix, '.gz')
613         self.assertRaises(ValueError, P('.').with_suffix, '.gz')
614         self.assertRaises(ValueError, P('/').with_suffix, '.gz')
616         self.assertRaises(ValueError, P('a/b').with_suffix, 'gz')
617         self.assertRaises(ValueError, P('a/b').with_suffix, '/')
618         self.assertRaises(ValueError, P('a/b').with_suffix, '.')
619         self.assertRaises(ValueError, P('a/b').with_suffix, '/.gz')
620         self.assertRaises(ValueError, P('a/b').with_suffix, 'c/d')
621         self.assertRaises(ValueError, P('a/b').with_suffix, '.c/.d')
622         self.assertRaises(ValueError, P('a/b').with_suffix, './.d')
623         self.assertRaises(ValueError, P('a/b').with_suffix, '.d/.')
624         self.assertRaises(ValueError, P('a/b').with_suffix,
625                           (self.flavour.sep, 'd'))
627     def test_relative_to_common(self):
628         P = self.cls
630         self.assertRaises(TypeError, p.relative_to)
631         self.assertRaises(TypeError, p.relative_to, b'a')
632         self.assertEqual(p.relative_to(P()), P('a/b'))
633         self.assertEqual(p.relative_to(''), P('a/b'))
634         self.assertEqual(p.relative_to(P('a')), P('b'))
635         self.assertEqual(p.relative_to('a'), P('b'))
636         self.assertEqual(p.relative_to('a/'), P('b'))
637         self.assertEqual(p.relative_to(P('a/b')), P())
638         self.assertEqual(p.relative_to('a/b'), P())
640         self.assertEqual(p.relative_to('a', 'b'), P())
642         self.assertRaises(ValueError, p.relative_to, P('c'))
643         self.assertRaises(ValueError, p.relative_to, P('a/b/c'))
644         self.assertRaises(ValueError, p.relative_to, P('a/c'))
645         self.assertRaises(ValueError, p.relative_to, P('/a'))
647         self.assertEqual(p.relative_to(P('/')), P('a/b'))
648         self.assertEqual(p.relative_to('/'), P('a/b'))
649         self.assertEqual(p.relative_to(P('/a')), P('b'))
650         self.assertEqual(p.relative_to('/a'), P('b'))
651         self.assertEqual(p.relative_to('/a/'), P('b'))
652         self.assertEqual(p.relative_to(P('/a/b')), P())
653         self.assertEqual(p.relative_to('/a/b'), P())
655         self.assertRaises(ValueError, p.relative_to, P('/c'))
656         self.assertRaises(ValueError, p.relative_to, P('/a/b/c'))
657         self.assertRaises(ValueError, p.relative_to, P('/a/c'))
658         self.assertRaises(ValueError, p.relative_to, P())
659         self.assertRaises(ValueError, p.relative_to, '')
660         self.assertRaises(ValueError, p.relative_to, P('a'))
662     def test_is_relative_to_common(self):
663         P = self.cls
665         self.assertRaises(TypeError, p.is_relative_to)
666         self.assertRaises(TypeError, p.is_relative_to, b'a')
667         self.assertTrue(p.is_relative_to(P()))
668         self.assertTrue(p.is_relative_to(''))
669         self.assertTrue(p.is_relative_to(P('a')))
670         self.assertTrue(p.is_relative_to('a/'))
671         self.assertTrue(p.is_relative_to(P('a/b')))
672         self.assertTrue(p.is_relative_to('a/b'))
674         self.assertTrue(p.is_relative_to('a', 'b'))
676         self.assertFalse(p.is_relative_to(P('c')))
677         self.assertFalse(p.is_relative_to(P('a/b/c')))
678         self.assertFalse(p.is_relative_to(P('a/c')))
679         self.assertFalse(p.is_relative_to(P('/a')))
681         self.assertTrue(p.is_relative_to(P('/')))
682         self.assertTrue(p.is_relative_to('/'))
683         self.assertTrue(p.is_relative_to(P('/a')))
684         self.assertTrue(p.is_relative_to('/a'))
685         self.assertTrue(p.is_relative_to('/a/'))
686         self.assertTrue(p.is_relative_to(P('/a/b')))
687         self.assertTrue(p.is_relative_to('/a/b'))
689         self.assertFalse(p.is_relative_to(P('/c')))
690         self.assertFalse(p.is_relative_to(P('/a/b/c')))
691         self.assertFalse(p.is_relative_to(P('/a/c')))
692         self.assertFalse(p.is_relative_to(P()))
693         self.assertFalse(p.is_relative_to(''))
694         self.assertFalse(p.is_relative_to(P('a')))
696     def test_pickling_common(self):
697         P = self.cls
702             self.assertIs(pp.__class__, p.__class__)
703             self.assertEqual(pp, p)
704             self.assertEqual(hash(pp), hash(p))
705             self.assertEqual(str(pp), str(p))
711     def test_root(self):
712         P = self.cls
713         self.assertEqual(P('/a/b').root, '/')
714         self.assertEqual(P('///a/b').root, '/')
716         self.assertEqual(P('//a/b').root, '//')
718     def test_eq(self):
719         P = self.cls
720         self.assertNotEqual(P('a/b'), P('A/b'))
721         self.assertEqual(P('/a'), P('///a'))
722         self.assertNotEqual(P('/a'), P('//a'))
724     def test_as_uri(self):
725         P = self.cls
726         self.assertEqual(P('/').as_uri(), 'file:///')
727         self.assertEqual(P('/a/b.c').as_uri(), 'file:///a/b.c')
728         self.assertEqual(P('/a/b%#c').as_uri(), 'file:///a/b%25%23c')
730     def test_as_uri_non_ascii(self):
732         P = self.cls
736             self.skipTest("\\xe9 cannot be encoded to the filesystem encoding")
737         self.assertEqual(P('/a/b\xe9').as_uri(),
740     def test_match(self):
741         P = self.cls
742         self.assertFalse(P('A.py').match('a.PY'))
744     def test_is_absolute(self):
745         P = self.cls
746         self.assertFalse(P().is_absolute())
747         self.assertFalse(P('a').is_absolute())
748         self.assertFalse(P('a/b/').is_absolute())
749         self.assertTrue(P('/').is_absolute())
750         self.assertTrue(P('/a').is_absolute())
751         self.assertTrue(P('/a/b/').is_absolute())
752         self.assertTrue(P('//a').is_absolute())
753         self.assertTrue(P('//a/b').is_absolute())
755     def test_is_reserved(self):
756         P = self.cls
757         self.assertIs(False, P('').is_reserved())
758         self.assertIs(False, P('/').is_reserved())
759         self.assertIs(False, P('/foo/bar').is_reserved())
760         self.assertIs(False, P('/dev/con/PRN/NUL').is_reserved())
762     def test_join(self):
763         P = self.cls
766         self.assertEqual(pp, P('//a/b'))
768         self.assertEqual(pp, P('//c'))
770         self.assertEqual(pp, P('/c'))
772     def test_div(self):
774         P = self.cls
777         self.assertEqual(pp, P('//a/b'))
779         self.assertEqual(pp, P('//c'))
781         self.assertEqual(pp, P('/c'))
800     def test_str(self):
801         p = self.cls('a/b/c')
802         self.assertEqual(str(p), 'a\\b\\c')
803         p = self.cls('c:/a/b/c')
804         self.assertEqual(str(p), 'c:\\a\\b\\c')
805         p = self.cls('//a/b')
806         self.assertEqual(str(p), '\\\\a\\b\\')
807         p = self.cls('//a/b/c')
808         self.assertEqual(str(p), '\\\\a\\b\\c')
809         p = self.cls('//a/b/c/d')
810         self.assertEqual(str(p), '\\\\a\\b\\c\\d')
812     def test_str_subclass(self):
813         self._check_str_subclass('c:')
814         self._check_str_subclass('c:a')
815         self._check_str_subclass('c:a\\b.txt')
816         self._check_str_subclass('c:\\')
817         self._check_str_subclass('c:\\a')
818         self._check_str_subclass('c:\\a\\b.txt')
819         self._check_str_subclass('\\\\some\\share')
820         self._check_str_subclass('\\\\some\\share\\a')
821         self._check_str_subclass('\\\\some\\share\\a\\b.txt')
823     def test_eq(self):
824         P = self.cls
825         self.assertEqual(P('c:a/b'), P('c:a/b'))
826         self.assertEqual(P('c:a/b'), P('c:', 'a', 'b'))
827         self.assertNotEqual(P('c:a/b'), P('d:a/b'))
828         self.assertNotEqual(P('c:a/b'), P('c:/a/b'))
829         self.assertNotEqual(P('/a/b'), P('c:/a/b'))
831         self.assertEqual(P('a/B'), P('A/b'))
832         self.assertEqual(P('C:a/B'), P('c:A/b'))
833         self.assertEqual(P('//Some/SHARE/a/B'), P('//somE/share/A/b'))
835     def test_as_uri(self):
836         P = self.cls
837         with self.assertRaises(ValueError):
839         with self.assertRaises(ValueError):
841         self.assertEqual(P('c:/').as_uri(), 'file:///c:/')
842         self.assertEqual(P('c:/a/b.c').as_uri(), 'file:///c:/a/b.c')
843         self.assertEqual(P('c:/a/b%#c').as_uri(), 'file:///c:/a/b%25%23c')
844         self.assertEqual(P('c:/a/b\xe9').as_uri(), 'file:///c:/a/b%C3%A9')
845         self.assertEqual(P('//some/share/').as_uri(), 'file://some/share/')
846         self.assertEqual(P('//some/share/a/b.c').as_uri(),
848         self.assertEqual(P('//some/share/a/b%#c\xe9').as_uri(),
851     def test_match_common(self):
852         P = self.cls
854         self.assertTrue(P('c:/b.py').match('/*.py'))
855         self.assertTrue(P('c:/b.py').match('c:*.py'))
856         self.assertTrue(P('c:/b.py').match('c:/*.py'))
857         self.assertFalse(P('d:/b.py').match('c:/*.py'))  # wrong drive
858         self.assertFalse(P('b.py').match('/*.py'))
859         self.assertFalse(P('b.py').match('c:*.py'))
860         self.assertFalse(P('b.py').match('c:/*.py'))
861         self.assertFalse(P('c:b.py').match('/*.py'))
862         self.assertFalse(P('c:b.py').match('c:/*.py'))
863         self.assertFalse(P('/b.py').match('c:*.py'))
864         self.assertFalse(P('/b.py').match('c:/*.py'))
866         self.assertTrue(P('//some/share/a.py').match('/*.py'))
867         self.assertTrue(P('//some/share/a.py').match('//some/share/*.py'))
868         self.assertFalse(P('//other/share/a.py').match('//some/share/*.py'))
869         self.assertFalse(P('//some/share/a/b.py').match('//some/share/*.py'))
871         self.assertTrue(P('B.py').match('b.PY'))
872         self.assertTrue(P('c:/a/B.Py').match('C:/A/*.pY'))
873         self.assertTrue(P('//Some/Share/B.Py').match('//somE/sharE/*.pY'))
875     def test_ordering_common(self):
878             self.assertLessEqual(a, b)
879             self.assertGreaterEqual(b, a)
880         P = self.cls
884         self.assertFalse(p < q)
885         self.assertFalse(p > q)
889         self.assertFalse(p < q)
890         self.assertFalse(p > q)
892     def test_parts(self):
893         P = self.cls
896         self.assertEqual(parts, ('c:', 'a', 'b'))
899         self.assertEqual(parts, ('c:\\', 'a', 'b'))
902         self.assertEqual(parts, ('\\\\a\\b\\', 'c', 'd'))
904     def test_parent(self):
906         P = self.cls
908         self.assertEqual(p.parent, P('z:a/b'))
909         self.assertEqual(p.parent.parent, P('z:a'))
910         self.assertEqual(p.parent.parent.parent, P('z:'))
911         self.assertEqual(p.parent.parent.parent.parent, P('z:'))
913         self.assertEqual(p.parent, P('z:/a/b'))
914         self.assertEqual(p.parent.parent, P('z:/a'))
915         self.assertEqual(p.parent.parent.parent, P('z:/'))
916         self.assertEqual(p.parent.parent.parent.parent, P('z:/'))
918         self.assertEqual(p.parent, P('//a/b/c'))
919         self.assertEqual(p.parent.parent, P('//a/b'))
920         self.assertEqual(p.parent.parent.parent, P('//a/b'))
922     def test_parents(self):
924         P = self.cls
927         self.assertEqual(len(par), 2)
928         self.assertEqual(par[0], P('z:a'))
929         self.assertEqual(par[1], P('z:'))
930         self.assertEqual(par[0:1], (P('z:a'),))
931         self.assertEqual(par[:-1], (P('z:a'),))
932         self.assertEqual(par[:2], (P('z:a'), P('z:')))
933         self.assertEqual(par[1:], (P('z:'),))
934         self.assertEqual(par[::2], (P('z:a'),))
935         self.assertEqual(par[::-1], (P('z:'), P('z:a')))
936         self.assertEqual(list(par), [P('z:a'), P('z:')])
937         with self.assertRaises(IndexError):
941         self.assertEqual(len(par), 2)
942         self.assertEqual(par[0], P('z:/a'))
943         self.assertEqual(par[1], P('z:/'))
944         self.assertEqual(par[0:1], (P('z:/a'),))
945         self.assertEqual(par[0:-1], (P('z:/a'),))
946         self.assertEqual(par[:2], (P('z:/a'), P('z:/')))
947         self.assertEqual(par[1:], (P('z:/'),))
948         self.assertEqual(par[::2], (P('z:/a'),))
949         self.assertEqual(par[::-1], (P('z:/'), P('z:/a'),))
950         self.assertEqual(list(par), [P('z:/a'), P('z:/')])
951         with self.assertRaises(IndexError):
955         self.assertEqual(len(par), 2)
956         self.assertEqual(par[0], P('//a/b/c'))
957         self.assertEqual(par[1], P('//a/b'))
958         self.assertEqual(par[0:1], (P('//a/b/c'),))
959         self.assertEqual(par[0:-1], (P('//a/b/c'),))
960         self.assertEqual(par[:2], (P('//a/b/c'), P('//a/b')))
961         self.assertEqual(par[1:], (P('//a/b'),))
962         self.assertEqual(par[::2], (P('//a/b/c'),))
963         self.assertEqual(par[::-1], (P('//a/b'), P('//a/b/c')))
964         self.assertEqual(list(par), [P('//a/b/c'), P('//a/b')])
965         with self.assertRaises(IndexError):
968     def test_drive(self):
969         P = self.cls
970         self.assertEqual(P('c:').drive, 'c:')
971         self.assertEqual(P('c:a/b').drive, 'c:')
972         self.assertEqual(P('c:/').drive, 'c:')
973         self.assertEqual(P('c:/a/b/').drive, 'c:')
974         self.assertEqual(P('//a/b').drive, '\\\\a\\b')
975         self.assertEqual(P('//a/b/').drive, '\\\\a\\b')
976         self.assertEqual(P('//a/b/c/d').drive, '\\\\a\\b')
978     def test_root(self):
979         P = self.cls
980         self.assertEqual(P('c:').root, '')
981         self.assertEqual(P('c:a/b').root, '')
982         self.assertEqual(P('c:/').root, '\\')
983         self.assertEqual(P('c:/a/b/').root, '\\')
984         self.assertEqual(P('//a/b').root, '\\')
985         self.assertEqual(P('//a/b/').root, '\\')
986         self.assertEqual(P('//a/b/c/d').root, '\\')
988     def test_anchor(self):
989         P = self.cls
990         self.assertEqual(P('c:').anchor, 'c:')
991         self.assertEqual(P('c:a/b').anchor, 'c:')
992         self.assertEqual(P('c:/').anchor, 'c:\\')
993         self.assertEqual(P('c:/a/b/').anchor, 'c:\\')
994         self.assertEqual(P('//a/b').anchor, '\\\\a\\b\\')
995         self.assertEqual(P('//a/b/').anchor, '\\\\a\\b\\')
996         self.assertEqual(P('//a/b/c/d').anchor, '\\\\a\\b\\')
998     def test_name(self):
999         P = self.cls
1000         self.assertEqual(P('c:').name, '')
1001         self.assertEqual(P('c:/').name, '')
1002         self.assertEqual(P('c:a/b').name, 'b')
1003         self.assertEqual(P('c:/a/b').name, 'b')
1004         self.assertEqual(P('c:a/b.py').name, 'b.py')
1005         self.assertEqual(P('c:/a/b.py').name, 'b.py')
1006         self.assertEqual(P('//My.py/Share.php').name, '')
1007         self.assertEqual(P('//My.py/Share.php/a/b').name, 'b')
1009     def test_suffix(self):
1010         P = self.cls
1011         self.assertEqual(P('c:').suffix, '')
1012         self.assertEqual(P('c:/').suffix, '')
1013         self.assertEqual(P('c:a/b').suffix, '')
1014         self.assertEqual(P('c:/a/b').suffix, '')
1015         self.assertEqual(P('c:a/b.py').suffix, '.py')
1016         self.assertEqual(P('c:/a/b.py').suffix, '.py')
1017         self.assertEqual(P('c:a/.hgrc').suffix, '')
1018         self.assertEqual(P('c:/a/.hgrc').suffix, '')
1019         self.assertEqual(P('c:a/.hg.rc').suffix, '.rc')
1020         self.assertEqual(P('c:/a/.hg.rc').suffix, '.rc')
1021         self.assertEqual(P('c:a/b.tar.gz').suffix, '.gz')
1022         self.assertEqual(P('c:/a/b.tar.gz').suffix, '.gz')
1023         self.assertEqual(P('c:a/Some name. Ending with a dot.').suffix, '')
1024         self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffix, '')
1025         self.assertEqual(P('//My.py/Share.php').suffix, '')
1026         self.assertEqual(P('//My.py/Share.php/a/b').suffix, '')
1028     def test_suffixes(self):
1029         P = self.cls
1030         self.assertEqual(P('c:').suffixes, [])
1031         self.assertEqual(P('c:/').suffixes, [])
1032         self.assertEqual(P('c:a/b').suffixes, [])
1033         self.assertEqual(P('c:/a/b').suffixes, [])
1034         self.assertEqual(P('c:a/b.py').suffixes, ['.py'])
1035         self.assertEqual(P('c:/a/b.py').suffixes, ['.py'])
1036         self.assertEqual(P('c:a/.hgrc').suffixes, [])
1037         self.assertEqual(P('c:/a/.hgrc').suffixes, [])
1038         self.assertEqual(P('c:a/.hg.rc').suffixes, ['.rc'])
1039         self.assertEqual(P('c:/a/.hg.rc').suffixes, ['.rc'])
1040         self.assertEqual(P('c:a/b.tar.gz').suffixes, ['.tar', '.gz'])
1041         self.assertEqual(P('c:/a/b.tar.gz').suffixes, ['.tar', '.gz'])
1042         self.assertEqual(P('//My.py/Share.php').suffixes, [])
1043         self.assertEqual(P('//My.py/Share.php/a/b').suffixes, [])
1044         self.assertEqual(P('c:a/Some name. Ending with a dot.').suffixes, [])
1045         self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffixes, [])
1047     def test_stem(self):
1048         P = self.cls
1049         self.assertEqual(P('c:').stem, '')
1050         self.assertEqual(P('c:.').stem, '')
1051         self.assertEqual(P('c:..').stem, '..')
1052         self.assertEqual(P('c:/').stem, '')
1053         self.assertEqual(P('c:a/b').stem, 'b')
1054         self.assertEqual(P('c:a/b.py').stem, 'b')
1055         self.assertEqual(P('c:a/.hgrc').stem, '.hgrc')
1056         self.assertEqual(P('c:a/.hg.rc').stem, '.hg')
1057         self.assertEqual(P('c:a/b.tar.gz').stem, 'b.tar')
1058         self.assertEqual(P('c:a/Some name. Ending with a dot.').stem,
1061     def test_with_name(self):
1062         P = self.cls
1063         self.assertEqual(P('c:a/b').with_name('d.xml'), P('c:a/d.xml'))
1064         self.assertEqual(P('c:/a/b').with_name('d.xml'), P('c:/a/d.xml'))
1065         self.assertEqual(P('c:a/Dot ending.').with_name('d.xml'), P('c:a/d.xml'))
1066         self.assertEqual(P('c:/a/Dot ending.').with_name('d.xml'), P('c:/a/d.xml'))
1067         self.assertRaises(ValueError, P('c:').with_name, 'd.xml')
1068         self.assertRaises(ValueError, P('c:/').with_name, 'd.xml')
1069         self.assertRaises(ValueError, P('//My/Share').with_name, 'd.xml')
1070         self.assertRaises(ValueError, P('c:a/b').with_name, 'd:')
1071         self.assertRaises(ValueError, P('c:a/b').with_name, 'd:e')
1072         self.assertRaises(ValueError, P('c:a/b').with_name, 'd:/e')
1073         self.assertRaises(ValueError, P('c:a/b').with_name, '//My/Share')
1075     def test_with_stem(self):
1076         P = self.cls
1077         self.assertEqual(P('c:a/b').with_stem('d'), P('c:a/d'))
1078         self.assertEqual(P('c:/a/b').with_stem('d'), P('c:/a/d'))
1079         self.assertEqual(P('c:a/Dot ending.').with_stem('d'), P('c:a/d'))
1080         self.assertEqual(P('c:/a/Dot ending.').with_stem('d'), P('c:/a/d'))
1081         self.assertRaises(ValueError, P('c:').with_stem, 'd')
1082         self.assertRaises(ValueError, P('c:/').with_stem, 'd')
1083         self.assertRaises(ValueError, P('//My/Share').with_stem, 'd')
1084         self.assertRaises(ValueError, P('c:a/b').with_stem, 'd:')
1085         self.assertRaises(ValueError, P('c:a/b').with_stem, 'd:e')
1086         self.assertRaises(ValueError, P('c:a/b').with_stem, 'd:/e')
1087         self.assertRaises(ValueError, P('c:a/b').with_stem, '//My/Share')
1089     def test_with_suffix(self):
1090         P = self.cls
1091         self.assertEqual(P('c:a/b').with_suffix('.gz'), P('c:a/b.gz'))
1092         self.assertEqual(P('c:/a/b').with_suffix('.gz'), P('c:/a/b.gz'))
1093         self.assertEqual(P('c:a/b.py').with_suffix('.gz'), P('c:a/b.gz'))
1094         self.assertEqual(P('c:/a/b.py').with_suffix('.gz'), P('c:/a/b.gz'))
1096         self.assertRaises(ValueError, P('').with_suffix, '.gz')
1097         self.assertRaises(ValueError, P('.').with_suffix, '.gz')
1098         self.assertRaises(ValueError, P('/').with_suffix, '.gz')
1099         self.assertRaises(ValueError, P('//My/Share').with_suffix, '.gz')
1101         self.assertRaises(ValueError, P('c:a/b').with_suffix, 'gz')
1102         self.assertRaises(ValueError, P('c:a/b').with_suffix, '/')
1103         self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\')
1104         self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:')
1105         self.assertRaises(ValueError, P('c:a/b').with_suffix, '/.gz')
1106         self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\.gz')
1107         self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:.gz')
1108         self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c/d')
1109         self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c\\d')
1110         self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c/d')
1111         self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c\\d')
1113     def test_relative_to(self):
1114         P = self.cls
1116         self.assertEqual(p.relative_to(P('c:')), P('Foo/Bar'))
1117         self.assertEqual(p.relative_to('c:'), P('Foo/Bar'))
1118         self.assertEqual(p.relative_to(P('c:foO')), P('Bar'))
1119         self.assertEqual(p.relative_to('c:foO'), P('Bar'))
1120         self.assertEqual(p.relative_to('c:foO/'), P('Bar'))
1121         self.assertEqual(p.relative_to(P('c:foO/baR')), P())
1122         self.assertEqual(p.relative_to('c:foO/baR'), P())
1124         self.assertRaises(ValueError, p.relative_to, P())
1125         self.assertRaises(ValueError, p.relative_to, '')
1126         self.assertRaises(ValueError, p.relative_to, P('d:'))
1127         self.assertRaises(ValueError, p.relative_to, P('/'))
1128         self.assertRaises(ValueError, p.relative_to, P('Foo'))
1129         self.assertRaises(ValueError, p.relative_to, P('/Foo'))
1130         self.assertRaises(ValueError, p.relative_to, P('C:/Foo'))
1131         self.assertRaises(ValueError, p.relative_to, P('C:Foo/Bar/Baz'))
1132         self.assertRaises(ValueError, p.relative_to, P('C:Foo/Baz'))
1134         self.assertEqual(p.relative_to(P('c:')), P('/Foo/Bar'))
1135         self.assertEqual(p.relative_to('c:'), P('/Foo/Bar'))
1136         self.assertEqual(str(p.relative_to(P('c:'))), '\\Foo\\Bar')
1137         self.assertEqual(str(p.relative_to('c:')), '\\Foo\\Bar')
1138         self.assertEqual(p.relative_to(P('c:/')), P('Foo/Bar'))
1139         self.assertEqual(p.relative_to('c:/'), P('Foo/Bar'))
1140         self.assertEqual(p.relative_to(P('c:/foO')), P('Bar'))
1141         self.assertEqual(p.relative_to('c:/foO'), P('Bar'))
1142         self.assertEqual(p.relative_to('c:/foO/'), P('Bar'))
1143         self.assertEqual(p.relative_to(P('c:/foO/baR')), P())
1144         self.assertEqual(p.relative_to('c:/foO/baR'), P())
1146         self.assertRaises(ValueError, p.relative_to, P('C:/Baz'))
1147         self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Bar/Baz'))
1148         self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Baz'))
1149         self.assertRaises(ValueError, p.relative_to, P('C:Foo'))
1150         self.assertRaises(ValueError, p.relative_to, P('d:'))
1151         self.assertRaises(ValueError, p.relative_to, P('d:/'))
1152         self.assertRaises(ValueError, p.relative_to, P('/'))
1153         self.assertRaises(ValueError, p.relative_to, P('/Foo'))
1154         self.assertRaises(ValueError, p.relative_to, P('//C/Foo'))
1157         self.assertEqual(p.relative_to(P('//sErver/sHare')), P('Foo/Bar'))
1158         self.assertEqual(p.relative_to('//sErver/sHare'), P('Foo/Bar'))
1159         self.assertEqual(p.relative_to('//sErver/sHare/'), P('Foo/Bar'))
1160         self.assertEqual(p.relative_to(P('//sErver/sHare/Foo')), P('Bar'))
1161         self.assertEqual(p.relative_to('//sErver/sHare/Foo'), P('Bar'))
1162         self.assertEqual(p.relative_to('//sErver/sHare/Foo/'), P('Bar'))
1163         self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar')), P())
1164         self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar'), P())
1166         self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'))
1167         self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'))
1168         self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'))
1169         self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'))
1171     def test_is_relative_to(self):
1172         P = self.cls
1174         self.assertTrue(p.is_relative_to(P('c:')))
1175         self.assertTrue(p.is_relative_to('c:'))
1176         self.assertTrue(p.is_relative_to(P('c:foO')))
1177         self.assertTrue(p.is_relative_to('c:foO'))
1178         self.assertTrue(p.is_relative_to('c:foO/'))
1179         self.assertTrue(p.is_relative_to(P('c:foO/baR')))
1180         self.assertTrue(p.is_relative_to('c:foO/baR'))
1182         self.assertFalse(p.is_relative_to(P()))
1183         self.assertFalse(p.is_relative_to(''))
1184         self.assertFalse(p.is_relative_to(P('d:')))
1185         self.assertFalse(p.is_relative_to(P('/')))
1186         self.assertFalse(p.is_relative_to(P('Foo')))
1187         self.assertFalse(p.is_relative_to(P('/Foo')))
1188         self.assertFalse(p.is_relative_to(P('C:/Foo')))
1189         self.assertFalse(p.is_relative_to(P('C:Foo/Bar/Baz')))
1190         self.assertFalse(p.is_relative_to(P('C:Foo/Baz')))
1192         self.assertTrue(p.is_relative_to('c:'))
1193         self.assertTrue(p.is_relative_to(P('c:/')))
1194         self.assertTrue(p.is_relative_to(P('c:/foO')))
1195         self.assertTrue(p.is_relative_to('c:/foO/'))
1196         self.assertTrue(p.is_relative_to(P('c:/foO/baR')))
1197         self.assertTrue(p.is_relative_to('c:/foO/baR'))
1199         self.assertFalse(p.is_relative_to(P('C:/Baz')))
1200         self.assertFalse(p.is_relative_to(P('C:/Foo/Bar/Baz')))
1201         self.assertFalse(p.is_relative_to(P('C:/Foo/Baz')))
1202         self.assertFalse(p.is_relative_to(P('C:Foo')))
1203         self.assertFalse(p.is_relative_to(P('d:')))
1204         self.assertFalse(p.is_relative_to(P('d:/')))
1205         self.assertFalse(p.is_relative_to(P('/')))
1206         self.assertFalse(p.is_relative_to(P('/Foo')))
1207         self.assertFalse(p.is_relative_to(P('//C/Foo')))
1210         self.assertTrue(p.is_relative_to(P('//sErver/sHare')))
1211         self.assertTrue(p.is_relative_to('//sErver/sHare'))
1212         self.assertTrue(p.is_relative_to('//sErver/sHare/'))
1213         self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo')))
1214         self.assertTrue(p.is_relative_to('//sErver/sHare/Foo'))
1215         self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/'))
1216         self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo/Bar')))
1217         self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/Bar'))
1219         self.assertFalse(p.is_relative_to(P('/Server/Share/Foo')))
1220         self.assertFalse(p.is_relative_to(P('c:/Server/Share/Foo')))
1221         self.assertFalse(p.is_relative_to(P('//z/Share/Foo')))
1222         self.assertFalse(p.is_relative_to(P('//Server/z/Foo')))
1224     def test_is_absolute(self):
1225         P = self.cls
1227         self.assertFalse(P().is_absolute())
1228         self.assertFalse(P('a').is_absolute())
1229         self.assertFalse(P('a/b/').is_absolute())
1230         self.assertFalse(P('/').is_absolute())
1231         self.assertFalse(P('/a').is_absolute())
1232         self.assertFalse(P('/a/b/').is_absolute())
1233         self.assertFalse(P('c:').is_absolute())
1234         self.assertFalse(P('c:a').is_absolute())
1235         self.assertFalse(P('c:a/b/').is_absolute())
1236         self.assertTrue(P('c:/').is_absolute())
1237         self.assertTrue(P('c:/a').is_absolute())
1238         self.assertTrue(P('c:/a/b/').is_absolute())
1240         self.assertTrue(P('//a/b').is_absolute())
1241         self.assertTrue(P('//a/b/').is_absolute())
1242         self.assertTrue(P('//a/b/c').is_absolute())
1243         self.assertTrue(P('//a/b/c/d').is_absolute())
1245     def test_join(self):
1246         P = self.cls
1249         self.assertEqual(pp, P('C:/a/b/x/y'))
1251         self.assertEqual(pp, P('C:/x/y'))
1255         self.assertEqual(pp, P('D:x/y'))
1257         self.assertEqual(pp, P('D:/x/y'))
1259         self.assertEqual(pp, P('//host/share/x/y'))
1263         self.assertEqual(pp, P('C:/a/b/x/y'))
1265         self.assertEqual(pp, P('C:/x/y'))
1267     def test_div(self):
1269         P = self.cls
1271         self.assertEqual(p / 'x/y', P('C:/a/b/x/y'))
1272         self.assertEqual(p / 'x' / 'y', P('C:/a/b/x/y'))
1273         self.assertEqual(p / '/x/y', P('C:/x/y'))
1274         self.assertEqual(p / '/x' / 'y', P('C:/x/y'))
1277         self.assertEqual(p / 'D:x/y', P('D:x/y'))
1278         self.assertEqual(p / 'D:' / 'x/y', P('D:x/y'))
1279         self.assertEqual(p / 'D:/x/y', P('D:/x/y'))
1280         self.assertEqual(p / 'D:' / '/x/y', P('D:/x/y'))
1281         self.assertEqual(p / '//host/share/x/y', P('//host/share/x/y'))
1284         self.assertEqual(p / 'c:x/y', P('C:/a/b/x/y'))
1285         self.assertEqual(p / 'c:/x/y', P('C:/x/y'))
1287     def test_is_reserved(self):
1288         P = self.cls
1289         self.assertIs(False, P('').is_reserved())
1290         self.assertIs(False, P('/').is_reserved())
1291         self.assertIs(False, P('/foo/bar').is_reserved())
1293         self.assertIs(False, P('//my/share/nul/con/aux').is_reserved())
1295         self.assertIs(True, P('nul').is_reserved())
1296         self.assertIs(True, P('aux').is_reserved())
1297         self.assertIs(True, P('prn').is_reserved())
1298         self.assertIs(True, P('con').is_reserved())
1299         self.assertIs(True, P('conin$').is_reserved())
1300         self.assertIs(True, P('conout$').is_reserved())
1302         self.assertIs(True, P('COM1').is_reserved())
1303         self.assertIs(True, P('LPT9').is_reserved())
1304         self.assertIs(True, P('com\xb9').is_reserved())
1305         self.assertIs(True, P('com\xb2').is_reserved())
1306         self.assertIs(True, P('lpt\xb3').is_reserved())
1309         self.assertIs(True, P('NUL.txt').is_reserved())
1310         self.assertIs(True, P('PRN  ').is_reserved())
1311         self.assertIs(True, P('AUX  .txt').is_reserved())
1312         self.assertIs(True, P('COM1:bar').is_reserved())
1313         self.assertIs(True, P('LPT9   :bar').is_reserved())
1316         self.assertIs(False, P('bar.com9').is_reserved())
1317         self.assertIs(False, P('bar.lpt9').is_reserved())
1319         self.assertIs(True, P('c:/baz/con/NUL').is_reserved())
1320         self.assertIs(False, P('c:/NUL/con/baz').is_reserved())
1325     def test_concrete_class(self):
1326         p = self.cls('a')
1327         self.assertIs(type(p),
1330     def test_different_flavours_unequal(self):
1333         self.assertNotEqual(p, q)
1335     def test_different_flavours_unordered(self):
1338         with self.assertRaises(TypeError):
1340         with self.assertRaises(TypeError):
1342         with self.assertRaises(TypeError):
1344         with self.assertRaises(TypeError):
1370     def test_owner(self):
1371         P = self.cls
1372         with self.assertRaises(NotImplementedError):
1375     def test_group(self):
1376         P = self.cls
1377         with self.assertRaises(NotImplementedError):
1404     def setUp(self):
1408         self.addCleanup(cleanup)
1430             self.dirlink('dirB', join('linkB'))
1431             self.dirlink(os.path.join('..', 'dirB'), join('dirA', 'linkC'))
1433             self.dirlink(os.path.join('..', 'dirB'), join('dirB', 'linkD'))
1439         def dirlink(self, src, dest):
1442         def dirlink(self, src, dest):
1445     def assertSame(self, path_a, path_b):
1446         self.assertTrue(os.path.samefile(str(path_a), str(path_b)),
1450     def assertFileNotFound(self, func, *args, **kwargs):
1451         with self.assertRaises(FileNotFoundError) as cm:
1453         self.assertEqual(cm.exception.errno, errno.ENOENT)
1455     def assertEqualNormCase(self, path_a, path_b):
1456         self.assertEqual(os.path.normcase(path_a), os.path.normcase(path_b))
1458     def _test_cwd(self, p):
1459         q = self.cls(os.getcwd())
1460         self.assertEqual(p, q)
1461         self.assertEqualNormCase(str(p), str(q))
1462         self.assertIs(type(p), type(q))
1463         self.assertTrue(p.is_absolute())
1465     def test_cwd(self):
1466         p = self.cls.cwd()
1467         self._test_cwd(p)
1469     def test_absolute_common(self):
1470         P = self.cls
1476             self.assertEqual(str(P().absolute()), BASE)
1477             self.assertEqual(str(P('.').absolute()), BASE)
1478             self.assertEqual(str(P('a').absolute()), os.path.join(BASE, 'a'))
1479             self.assertEqual(str(P('a', 'b', 'c').absolute()), os.path.join(BASE, 'a', 'b', 'c'))
1482             self.assertEqual(str(P('linkB', 'fileB').absolute()), os.path.join(BASE, 'linkB', 'fileB'))
1483             self.assertEqual(str(P('brokenLink').absolute()), os.path.join(BASE, 'brokenLink'))
1484             self.assertEqual(str(P('brokenLinkLoop').absolute()), os.path.join(BASE, 'brokenLinkLoop'))
1487             self.assertEqual(str(P('..').absolute()), os.path.join(BASE, '..'))
1488             self.assertEqual(str(P('a', '..').absolute()), os.path.join(BASE, 'a', '..'))
1489             self.assertEqual(str(P('..', 'b').absolute()), os.path.join(BASE, '..', 'b'))
1491     def _test_home(self, p):
1492         q = self.cls(os.path.expanduser('~'))
1493         self.assertEqual(p, q)
1494         self.assertEqualNormCase(str(p), str(q))
1495         self.assertIs(type(p), type(q))
1496         self.assertTrue(p.is_absolute())
1501     def test_home(self):
1503             self._test_home(self.cls.home())
1507             self._test_home(self.cls.home())
1511             self._test_home(self.cls.home())
1513     def test_samefile(self):
1516         p = self.cls(fileA_path)
1517         pp = self.cls(fileA_path)
1518         q = self.cls(fileB_path)
1519         self.assertTrue(p.samefile(fileA_path))
1520         self.assertTrue(p.samefile(pp))
1521         self.assertFalse(p.samefile(fileB_path))
1522         self.assertFalse(p.samefile(q))
1525         r = self.cls(non_existent)
1526         self.assertRaises(FileNotFoundError, p.samefile, r)
1527         self.assertRaises(FileNotFoundError, p.samefile, non_existent)
1528         self.assertRaises(FileNotFoundError, r.samefile, p)
1529         self.assertRaises(FileNotFoundError, r.samefile, non_existent)
1530         self.assertRaises(FileNotFoundError, r.samefile, r)
1531         self.assertRaises(FileNotFoundError, r.samefile, non_existent)
1533     def test_empty_path(self):
1535         p = self.cls('')
1536         self.assertEqual(p.stat(), os.stat('.'))
1539     def test_expanduser_common(self):
1540         P = self.cls
1542         self.assertEqual(p.expanduser(), P(os.path.expanduser('~')))
1544         self.assertEqual(p.expanduser(), p)
1546         self.assertEqual(p.expanduser(), p)
1548         self.assertEqual(p.expanduser(), p)
1550         self.assertEqual(p.expanduser(), p)
1552     def test_exists(self):
1553         P = self.cls
1555         self.assertIs(True, p.exists())
1556         self.assertIs(True, (p / 'dirA').exists())
1557         self.assertIs(True, (p / 'fileA').exists())
1558         self.assertIs(False, (p / 'fileA' / 'bah').exists())
1560             self.assertIs(True, (p / 'linkA').exists())
1561             self.assertIs(True, (p / 'linkB').exists())
1562             self.assertIs(True, (p / 'linkB' / 'fileB').exists())
1563             self.assertIs(False, (p / 'linkA' / 'bah').exists())
1564         self.assertIs(False, (p / 'foo').exists())
1565         self.assertIs(False, P('/xyzzy').exists())
1566         self.assertIs(False, P(BASE + '\udfff').exists())
1567         self.assertIs(False, P(BASE + '\x00').exists())
1569     def test_open_common(self):
1570         p = self.cls(BASE)
1572             self.assertIsInstance(f, io.TextIOBase)
1573             self.assertEqual(f.read(), "this is file A\n")
1575             self.assertIsInstance(f, io.BufferedIOBase)
1576             self.assertEqual(f.read().strip(), b"this is file A")
1578             self.assertIsInstance(f, io.RawIOBase)
1579             self.assertEqual(f.read().strip(), b"this is file A")
1581     def test_read_write_bytes(self):
1582         p = self.cls(BASE)
1584         self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
1586         self.assertRaises(TypeError, (p / 'fileA').write_bytes, 'somestr')
1587         self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
1589     def test_read_write_text(self):
1590         p = self.cls(BASE)
1592         self.assertEqual((p / 'fileA').read_text(
1595         self.assertRaises(TypeError, (p / 'fileA').write_text, b'somebytes')
1596         self.assertEqual((p / 'fileA').read_text(encoding='latin-1'), 'äbcdefg')
1598     def test_write_text_with_newlines(self):
1599         p = self.cls(BASE)
1602         self.assertEqual((p / 'fileA').read_bytes(),
1606         self.assertEqual((p / 'fileA').read_bytes(),
1610         self.assertEqual((p / 'fileA').read_bytes(),
1615         self.assertEqual((p / 'fileA').read_bytes(),
1618     def test_iterdir(self):
1619         P = self.cls
1626         self.assertEqual(paths, { P(BASE, q) for q in expected })
1629     def test_iterdir_symlink(self):
1631         P = self.cls
1635         self.assertEqual(paths, expected)
1637     def test_iterdir_nodir(self):
1639         p = self.cls(BASE, 'fileA')
1640         with self.assertRaises(OSError) as cm:
1644         self.assertIn(cm.exception.errno, (errno.ENOTDIR,
1647     def test_glob_common(self):
1649             self.assertEqual(set(glob), { P(BASE, q) for q in expected })
1650         P = self.cls
1653         self.assertIsInstance(it, collections.abc.Iterator)
1676     def test_rglob_common(self):
1678             self.assertEqual(set(glob), { P(BASE, q) for q in expected })
1679         P = self.cls
1682         self.assertIsInstance(it, collections.abc.Iterator)
1716     def test_rglob_symlink_loop(self):
1718         P = self.cls
1732         self.assertEqual(given, {p / x for x in expect})
1734     def test_glob_many_open_files(self):
1736         P = self.cls
1743             self.assertEqual(next(it), p)
1749                 self.assertEqual(next(it), p)
1751     def test_glob_dotdot(self):
1753         P = self.cls
1755         self.assertEqual(set(p.glob("..")), { P(BASE, "..") })
1756         self.assertEqual(set(p.glob("dirA/../file*")), { P(BASE, "dirA/../fileA") })
1757         self.assertEqual(set(p.glob("../xyzzy")), set())
1760     def test_glob_permissions(self):
1762         P = self.cls
1787             self.assertEqual(len(set(base.glob("*"))), 3)
1789             self.assertEqual(len(set(base.glob("*"))), 4)
1791             self.assertEqual(len(set(base.glob("*"))), 4)
1794     def test_glob_long_symlink(self):
1796         base = self.cls(BASE) / 'long_symlink'
1800         self.assertEqual(sorted(base.glob('**/*')), [bad_link])
1802     def _check_resolve(self, p, expected, strict=True):
1804         self.assertEqual(q, expected)
1810     def test_resolve_common(self):
1811         P = self.cls
1813         with self.assertRaises(OSError) as cm:
1815         self.assertEqual(cm.exception.errno, errno.ENOENT)
1817         self.assertEqualNormCase(str(p.resolve(strict=False)),
1820         self.assertEqualNormCase(str(p.resolve(strict=False)),
1823         self.assertEqualNormCase(str(p.resolve(strict=False)),
1827         self._check_resolve_relative(p, p)
1829         self._check_resolve_relative(p, P(BASE, 'fileA'))
1831         self._check_resolve_relative(p, P(BASE, 'dirB', 'fileB'))
1833         self._check_resolve_relative(p, P(BASE, 'dirB', 'fileB'))
1836         self._check_resolve_relative(p, P(BASE, 'dirB', 'fileB', 'foo', 'in',
1842             self._check_resolve_relative(p, P(BASE, 'dirA', 'foo', 'in',
1847             self._check_resolve_relative(p, P(BASE, 'foo', 'in', 'spam'), False)
1851         self.addCleanup(os_helper.rmtree, d)
1855         self._check_resolve_absolute(p, P(BASE, 'dirB', 'fileB'))
1858         self._check_resolve_relative(p, P(BASE, 'dirB', 'foo', 'in', 'spam'),
1864             self._check_resolve_relative(p, P(d, 'foo', 'in', 'spam'), False)
1868             self._check_resolve_relative(p, P(BASE, 'foo', 'in', 'spam'), False)
1871     def test_resolve_dot(self):
1873         p = self.cls(BASE)
1874         self.dirlink('.', join('0'))
1875         self.dirlink(os.path.join('0', '0'), join('1'))
1876         self.dirlink(os.path.join('1', '1'), join('2'))
1878         self.assertEqual(q.resolve(strict=True), p)
1880         self.assertRaises(FileNotFoundError, r.resolve, strict=True)
1882         self.assertEqual(r.resolve(strict=False), p / '3' / '4')
1884     def test_resolve_nonexist_relative_issue38671(self):
1885         p = self.cls('non', 'exist')
1890             self.assertEqual(p.resolve(), self.cls(BASE, p))
1894     def test_with(self):
1895         p = self.cls(BASE)
1900         with self.assertWarns(DeprecationWarning):
1910         with self.assertWarns(DeprecationWarning):
1915     def test_chmod(self):
1916         p = self.cls(BASE) / 'fileA'
1921         self.assertEqual(p.stat().st_mode, new_mode)
1925         self.assertEqual(p.stat().st_mode, new_mode)
1930     def test_chmod_follow_symlinks_true(self):
1931         p = self.cls(BASE) / 'linkA'
1937         self.assertEqual(q.stat().st_mode, new_mode)
1941         self.assertEqual(q.stat().st_mode, new_mode)
1946     def test_stat(self):
1947         p = self.cls(BASE) / 'fileA'
1949         self.assertEqual(p.stat(), st)
1952         self.addCleanup(p.chmod, st.st_mode)
1953         self.assertNotEqual(p.stat(), st)
1956     def test_stat_no_follow_symlinks(self):
1957         p = self.cls(BASE) / 'linkA'
1959         self.assertNotEqual(st, p.stat(follow_symlinks=False))
1961     def test_stat_no_follow_symlinks_nosymlink(self):
1962         p = self.cls(BASE) / 'fileA'
1964         self.assertEqual(st, p.stat(follow_symlinks=False))
1967     def test_lstat(self):
1968         p = self.cls(BASE)/ 'linkA'
1970         self.assertNotEqual(st, p.lstat())
1972     def test_lstat_nosymlink(self):
1973         p = self.cls(BASE) / 'fileA'
1975         self.assertEqual(st, p.lstat())
1978     def test_owner(self):
1979         p = self.cls(BASE) / 'fileA'
1984             self.skipTest(
1986         self.assertEqual(name, p.owner())
1989     def test_group(self):
1990         p = self.cls(BASE) / 'fileA'
1995             self.skipTest(
1997         self.assertEqual(name, p.group())
1999     def test_unlink(self):
2000         p = self.cls(BASE) / 'fileA'
2002         self.assertFileNotFound(p.stat)
2003         self.assertFileNotFound(p.unlink)
2005     def test_unlink_missing_ok(self):
2006         p = self.cls(BASE) / 'fileAAA'
2007         self.assertFileNotFound(p.unlink)
2010     def test_rmdir(self):
2011         p = self.cls(BASE) / 'dirA'
2015         self.assertFileNotFound(p.stat)
2016         self.assertFileNotFound(p.unlink)
2019     def test_link_to(self):
2020         P = self.cls(BASE)
2026             with self.assertWarns(DeprecationWarning):
2029             self.skipTest('os.link(): %s' % e)
2030         self.assertEqual(q.stat().st_size, size)
2031         self.assertEqual(os.path.samefile(p, q), True)
2032         self.assertTrue(p.stat)
2035         with self.assertWarns(DeprecationWarning):
2037         self.assertEqual(os.stat(r).st_size, size)
2038         self.assertTrue(q.stat)
2041     def test_hardlink_to(self):
2042         P = self.cls(BASE)
2048         self.assertEqual(link.stat().st_size, size)
2049         self.assertTrue(os.path.samefile(target, link))
2050         self.assertTrue(target.exists())
2055         self.assertEqual(os.stat(target2).st_size, size)
2056         self.assertTrue(link2.exists())
2059     def test_link_to_not_implemented(self):
2060         P = self.cls(BASE)
2064         with self.assertRaises(NotImplementedError):
2067     def test_rename(self):
2068         P = self.cls(BASE)
2074         self.assertEqual(renamed_p, q)
2075         self.assertEqual(q.stat().st_size, size)
2076         self.assertFileNotFound(p.stat)
2080         self.assertEqual(renamed_q, self.cls(r))
2081         self.assertEqual(os.stat(r).st_size, size)
2082         self.assertFileNotFound(q.stat)
2084     def test_replace(self):
2085         P = self.cls(BASE)
2091         self.assertEqual(replaced_p, q)
2092         self.assertEqual(q.stat().st_size, size)
2093         self.assertFileNotFound(p.stat)
2097         self.assertEqual(replaced_q, self.cls(r))
2098         self.assertEqual(os.stat(r).st_size, size)
2099         self.assertFileNotFound(q.stat)
2102     def test_readlink(self):
2103         P = self.cls(BASE)
2104         self.assertEqual((P / 'linkA').readlink(), self.cls('fileA'))
2105         self.assertEqual((P / 'brokenLink').readlink(),
2106                          self.cls('non-existing'))
2107         self.assertEqual((P / 'linkB').readlink(), self.cls('dirB'))
2108         with self.assertRaises(OSError):
2111     def test_touch_common(self):
2112         P = self.cls(BASE)
2114         self.assertFalse(p.exists())
2116         self.assertTrue(p.exists())
2126         self.assertGreaterEqual(st.st_mtime_ns, old_mtime_ns)
2127         self.assertGreaterEqual(st.st_mtime, old_mtime)
2130         self.assertFalse(p.exists())
2132         self.assertTrue(p.exists())
2133         self.assertRaises(OSError, p.touch, exist_ok=False)
2135     def test_touch_nochange(self):
2136         P = self.cls(BASE)
2140             self.assertEqual(f.read().strip(), b"this is file A")
2142     def test_mkdir(self):
2143         P = self.cls(BASE)
2145         self.assertFalse(p.exists())
2147         self.assertTrue(p.exists())
2148         self.assertTrue(p.is_dir())
2149         with self.assertRaises(OSError) as cm:
2151         self.assertEqual(cm.exception.errno, errno.EEXIST)
2153     def test_mkdir_parents(self):
2155         p = self.cls(BASE, 'newdirB', 'newdirC')
2156         self.assertFalse(p.exists())
2157         with self.assertRaises(OSError) as cm:
2159         self.assertEqual(cm.exception.errno, errno.ENOENT)
2161         self.assertTrue(p.exists())
2162         self.assertTrue(p.is_dir())
2163         with self.assertRaises(OSError) as cm:
2165         self.assertEqual(cm.exception.errno, errno.EEXIST)
2168         p = self.cls(BASE, 'newdirD', 'newdirE')
2170         self.assertTrue(p.exists())
2171         self.assertTrue(p.is_dir())
2174             self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o7555 & mode)
2176         self.assertEqual(stat.S_IMODE(p.parent.stat().st_mode), mode)
2178     def test_mkdir_exist_ok(self):
2179         p = self.cls(BASE, 'dirB')
2181         self.assertTrue(p.exists())
2182         self.assertTrue(p.is_dir())
2183         with self.assertRaises(FileExistsError) as cm:
2185         self.assertEqual(cm.exception.errno, errno.EEXIST)
2187         self.assertTrue(p.exists())
2188         self.assertEqual(p.stat().st_ctime, st_ctime_first)
2190     def test_mkdir_exist_ok_with_parent(self):
2191         p = self.cls(BASE, 'dirC')
2192         self.assertTrue(p.exists())
2193         with self.assertRaises(FileExistsError) as cm:
2195         self.assertEqual(cm.exception.errno, errno.EEXIST)
2199         self.assertTrue(p.exists())
2200         with self.assertRaises(FileExistsError) as cm:
2202         self.assertEqual(cm.exception.errno, errno.EEXIST)
2204         self.assertTrue(p.exists())
2205         self.assertEqual(p.stat().st_ctime, st_ctime_first)
2208     def test_mkdir_exist_ok_root(self):
2210         self.cls('/').resolve().mkdir(exist_ok=True)
2211         self.cls('/').resolve().mkdir(parents=True, exist_ok=True)
2214     def test_mkdir_with_unknown_drive(self):
2216             p = self.cls(d + ':\\')
2220             self.skipTest("cannot find a drive that doesn't exist")
2221         with self.assertRaises(OSError):
2224     def test_mkdir_with_child_file(self):
2225         p = self.cls(BASE, 'dirB', 'fileB')
2226         self.assertTrue(p.exists())
2229         with self.assertRaises(FileExistsError) as cm:
2231         self.assertEqual(cm.exception.errno, errno.EEXIST)
2232         with self.assertRaises(FileExistsError) as cm:
2234         self.assertEqual(cm.exception.errno, errno.EEXIST)
2236     def test_mkdir_no_parents_file(self):
2237         p = self.cls(BASE, 'fileA')
2238         self.assertTrue(p.exists())
2241         with self.assertRaises(FileExistsError) as cm:
2243         self.assertEqual(cm.exception.errno, errno.EEXIST)
2244         with self.assertRaises(FileExistsError) as cm:
2246         self.assertEqual(cm.exception.errno, errno.EEXIST)
2248     def test_mkdir_concurrent_parent_creation(self):
2250             p = self.cls(BASE, 'dirCPC%d' % pattern_num)
2251             self.assertFalse(p.exists())
2273                 self.assertIn(str(p12), concurrently_created)
2275                 self.assertNotIn(str(p12), concurrently_created)
2276             self.assertTrue(p.exists())
2279     def test_symlink_to(self):
2280         P = self.cls(BASE)
2285         self.assertEqual(link.stat(), target.stat())
2286         self.assertNotEqual(link.lstat(), target.stat())
2290         self.assertEqual(link.stat(), target.stat())
2291         self.assertNotEqual(link.lstat(), target.stat())
2292         self.assertFalse(link.is_dir())
2297         self.assertEqual(link.stat(), target.stat())
2298         self.assertNotEqual(link.lstat(), target.stat())
2299         self.assertTrue(link.is_dir())
2300         self.assertTrue(list(link.iterdir()))
2302     def test_is_dir(self):
2303         P = self.cls(BASE)
2304         self.assertTrue((P / 'dirA').is_dir())
2305         self.assertFalse((P / 'fileA').is_dir())
2306         self.assertFalse((P / 'non-existing').is_dir())
2307         self.assertFalse((P / 'fileA' / 'bah').is_dir())
2309             self.assertFalse((P / 'linkA').is_dir())
2310             self.assertTrue((P / 'linkB').is_dir())
2311             self.assertFalse((P/ 'brokenLink').is_dir(), False)
2312         self.assertIs((P / 'dirA\udfff').is_dir(), False)
2313         self.assertIs((P / 'dirA\x00').is_dir(), False)
2315     def test_is_file(self):
2316         P = self.cls(BASE)
2317         self.assertTrue((P / 'fileA').is_file())
2318         self.assertFalse((P / 'dirA').is_file())
2319         self.assertFalse((P / 'non-existing').is_file())
2320         self.assertFalse((P / 'fileA' / 'bah').is_file())
2322             self.assertTrue((P / 'linkA').is_file())
2323             self.assertFalse((P / 'linkB').is_file())
2324             self.assertFalse((P/ 'brokenLink').is_file())
2325         self.assertIs((P / 'fileA\udfff').is_file(), False)
2326         self.assertIs((P / 'fileA\x00').is_file(), False)
2329     def test_is_mount(self):
2330         P = self.cls(BASE)
2331         R = self.cls('/')  # TODO: Work out Windows.
2332         self.assertFalse((P / 'fileA').is_mount())
2333         self.assertFalse((P / 'dirA').is_mount())
2334         self.assertFalse((P / 'non-existing').is_mount())
2335         self.assertFalse((P / 'fileA' / 'bah').is_mount())
2336         self.assertTrue(R.is_mount())
2338             self.assertFalse((P / 'linkA').is_mount())
2339         self.assertIs(self.cls('/\udfff').is_mount(), False)
2340         self.assertIs(self.cls('/\x00').is_mount(), False)
2342     def test_is_symlink(self):
2343         P = self.cls(BASE)
2344         self.assertFalse((P / 'fileA').is_symlink())
2345         self.assertFalse((P / 'dirA').is_symlink())
2346         self.assertFalse((P / 'non-existing').is_symlink())
2347         self.assertFalse((P / 'fileA' / 'bah').is_symlink())
2349             self.assertTrue((P / 'linkA').is_symlink())
2350             self.assertTrue((P / 'linkB').is_symlink())
2351             self.assertTrue((P/ 'brokenLink').is_symlink())
2352         self.assertIs((P / 'fileA\udfff').is_file(), False)
2353         self.assertIs((P / 'fileA\x00').is_file(), False)
2355             self.assertIs((P / 'linkA\udfff').is_file(), False)
2356             self.assertIs((P / 'linkA\x00').is_file(), False)
2358     def test_is_fifo_false(self):
2359         P = self.cls(BASE)
2360         self.assertFalse((P / 'fileA').is_fifo())
2361         self.assertFalse((P / 'dirA').is_fifo())
2362         self.assertFalse((P / 'non-existing').is_fifo())
2363         self.assertFalse((P / 'fileA' / 'bah').is_fifo())
2364         self.assertIs((P / 'fileA\udfff').is_fifo(), False)
2365         self.assertIs((P / 'fileA\x00').is_fifo(), False)
2370     def test_is_fifo_true(self):
2371         P = self.cls(BASE, 'myfifo')
2375             self.skipTest('os.mkfifo(): %s' % e)
2376         self.assertTrue(P.is_fifo())
2377         self.assertFalse(P.is_socket())
2378         self.assertFalse(P.is_file())
2379         self.assertIs(self.cls(BASE, 'myfifo\udfff').is_fifo(), False)
2380         self.assertIs(self.cls(BASE, 'myfifo\x00').is_fifo(), False)
2382     def test_is_socket_false(self):
2383         P = self.cls(BASE)
2384         self.assertFalse((P / 'fileA').is_socket())
2385         self.assertFalse((P / 'dirA').is_socket())
2386         self.assertFalse((P / 'non-existing').is_socket())
2387         self.assertFalse((P / 'fileA' / 'bah').is_socket())
2388         self.assertIs((P / 'fileA\udfff').is_socket(), False)
2389         self.assertIs((P / 'fileA\x00').is_socket(), False)
2398     def test_is_socket_true(self):
2399         P = self.cls(BASE, 'mysock')
2401         self.addCleanup(sock.close)
2407                 self.skipTest("cannot bind Unix socket: " + str(e))
2408         self.assertTrue(P.is_socket())
2409         self.assertFalse(P.is_fifo())
2410         self.assertFalse(P.is_file())
2411         self.assertIs(self.cls(BASE, 'mysock\udfff').is_socket(), False)
2412         self.assertIs(self.cls(BASE, 'mysock\x00').is_socket(), False)
2414     def test_is_block_device_false(self):
2415         P = self.cls(BASE)
2416         self.assertFalse((P / 'fileA').is_block_device())
2417         self.assertFalse((P / 'dirA').is_block_device())
2418         self.assertFalse((P / 'non-existing').is_block_device())
2419         self.assertFalse((P / 'fileA' / 'bah').is_block_device())
2420         self.assertIs((P / 'fileA\udfff').is_block_device(), False)
2421         self.assertIs((P / 'fileA\x00').is_block_device(), False)
2423     def test_is_char_device_false(self):
2424         P = self.cls(BASE)
2425         self.assertFalse((P / 'fileA').is_char_device())
2426         self.assertFalse((P / 'dirA').is_char_device())
2427         self.assertFalse((P / 'non-existing').is_char_device())
2428         self.assertFalse((P / 'fileA' / 'bah').is_char_device())
2429         self.assertIs((P / 'fileA\udfff').is_char_device(), False)
2430         self.assertIs((P / 'fileA\x00').is_char_device(), False)
2432     def test_is_char_device_true(self):
2434         P = self.cls('/dev/null')
2436             self.skipTest("/dev/null required")
2437         self.assertTrue(P.is_char_device())
2438         self.assertFalse(P.is_block_device())
2439         self.assertFalse(P.is_file())
2440         self.assertIs(self.cls('/dev/null\udfff').is_char_device(), False)
2441         self.assertIs(self.cls('/dev/null\x00').is_char_device(), False)
2443     def test_pickling_common(self):
2444         p = self.cls(BASE, 'fileA')
2448             self.assertEqual(pp.stat(), p.stat())
2450     def test_parts_interning(self):
2451         P = self.cls
2455         self.assertIs(p.parts[1], q.parts[1])
2457         self.assertIs(p.parts[2], q.parts[3])
2459     def _check_complex_symlinks(self, link0_target):
2461         P = self.cls(BASE)
2462         self.dirlink(os.path.join('link0', 'link0'), join('link1'))
2463         self.dirlink(os.path.join('link1', 'link1'), join('link2'))
2464         self.dirlink(os.path.join('link2', 'link2'), join('link3'))
2465         self.dirlink(link0_target, join('link0'))
2469         self.assertEqual(p, P)
2470         self.assertEqualNormCase(str(p), BASE)
2472         self.assertEqual(p, P)
2473         self.assertEqualNormCase(str(p), BASE)
2475         self.assertEqual(p, P)
2476         self.assertEqualNormCase(str(p), BASE)
2478         self.assertEqual(p, P)
2479         self.assertEqualNormCase(str(p), BASE)
2485             p = self.cls('link0').resolve()
2486             self.assertEqual(p, P)
2487             self.assertEqualNormCase(str(p), BASE)
2488             p = self.cls('link1').resolve()
2489             self.assertEqual(p, P)
2490             self.assertEqualNormCase(str(p), BASE)
2491             p = self.cls('link2').resolve()
2492             self.assertEqual(p, P)
2493             self.assertEqualNormCase(str(p), BASE)
2494             p = self.cls('link3').resolve()
2495             self.assertEqual(p, P)
2496             self.assertEqualNormCase(str(p), BASE)
2501     def test_complex_symlinks_absolute(self):
2502         self._check_complex_symlinks(BASE)
2505     def test_complex_symlinks_relative(self):
2506         self._check_complex_symlinks('.')
2509     def test_complex_symlinks_relative_dot_dot(self):
2510         self._check_complex_symlinks(os.path.join('dirA', '..'))
2516     def test_concrete_class(self):
2517         p = self.cls('a')
2518         self.assertIs(type(p),
2521     def test_unsupported_flavour(self):
2523             self.assertRaises(NotImplementedError, pathlib.PosixPath)
2525             self.assertRaises(NotImplementedError, pathlib.WindowsPath)
2527     def test_glob_empty_pattern(self):
2528         p = self.cls()
2529         with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
2537     def test_absolute(self):
2538         P = self.cls
2539         self.assertEqual(str(P('/').absolute()), '/')
2540         self.assertEqual(str(P('/a').absolute()), '/a')
2541         self.assertEqual(str(P('/a/b').absolute()), '/a/b')
2544         self.assertEqual(str(P('//').absolute()), '//')
2545         self.assertEqual(str(P('//a').absolute()), '//a')
2546         self.assertEqual(str(P('//a/b').absolute()), '//a/b')
2548     def _check_symlink_loop(self, *args, strict=True):
2549         path = self.cls(*args)
2550         with self.assertRaises(RuntimeError):
2557     def test_open_mode(self):
2559         self.addCleanup(os.umask, old_mask)
2560         p = self.cls(BASE)
2564         self.assertEqual(stat.S_IMODE(st.st_mode), 0o666)
2569         self.assertEqual(stat.S_IMODE(st.st_mode), 0o644)
2571     def test_resolve_root(self):
2575             p = self.cls('spam')
2576             self.assertEqual(str(p.resolve()), '/spam')
2584     def test_touch_mode(self):
2586         self.addCleanup(os.umask, old_mask)
2587         p = self.cls(BASE)
2590         self.assertEqual(stat.S_IMODE(st.st_mode), 0o666)
2594         self.assertEqual(stat.S_IMODE(st.st_mode), 0o644)
2597         self.assertEqual(stat.S_IMODE(st.st_mode), 0o750)
2600     def test_resolve_loop(self):
2603         self._check_symlink_loop(BASE, 'linkX')
2605         self._check_symlink_loop(BASE, 'linkY')
2607         self._check_symlink_loop(BASE, 'linkZ')
2609         self._check_symlink_loop(BASE, 'linkZ', 'foo', strict=False)
2612         self._check_symlink_loop(BASE, 'linkU')
2614         self._check_symlink_loop(BASE, 'linkV')
2616         self._check_symlink_loop(BASE, 'linkW')
2618         self._check_symlink_loop(BASE, 'linkW', 'foo', strict=False)
2620     def test_glob(self):
2621         P = self.cls
2625         self.assertEqual(given, expect)
2626         self.assertEqual(set(p.glob("FILEa*")), set())
2628     def test_rglob(self):
2629         P = self.cls
2633         self.assertEqual(given, expect)
2634         self.assertEqual(set(p.rglob("FILEd*")), set())
2640     def test_expanduser(self):
2641         P = self.cls
2676             self.assertEqual(p1.expanduser(), P(userhome) / 'Documents')
2677             self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
2678             self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
2679             self.assertEqual(p4.expanduser(), p4)
2680             self.assertEqual(p5.expanduser(), p5)
2681             self.assertEqual(p6.expanduser(), p6)
2682             self.assertRaises(RuntimeError, p7.expanduser)
2685             self.assertEqual(p1.expanduser(), P('/tmp/Documents'))
2686             self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
2687             self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
2688             self.assertEqual(p4.expanduser(), p4)
2689             self.assertEqual(p5.expanduser(), p5)
2690             self.assertEqual(p6.expanduser(), p6)
2691             self.assertRaises(RuntimeError, p7.expanduser)
2695     def test_handling_bad_descriptor(self):
2699                 self.skipTest("no file descriptors - issue was not reproduced")
2713                 self.fail("Bad file descriptor not handled.")
2721     def test_absolute(self):
2722         P = self.cls
2725         self.assertEqual(str(P('c:\\').absolute()), 'c:\\')
2726         self.assertEqual(str(P('c:\\a').absolute()), 'c:\\a')
2727         self.assertEqual(str(P('c:\\a\\b').absolute()), 'c:\\a\\b')
2731         self.assertEqual(str(P(share).absolute()), share)
2732         self.assertEqual(str(P(share + 'a').absolute()), share + 'a')
2733         self.assertEqual(str(P(share + 'a\\b').absolute()), share + 'a\\b')
2739             self.assertEqual(str(P().absolute()), share)
2740             self.assertEqual(str(P('.').absolute()), share)
2741             self.assertEqual(str(P('a').absolute()), os.path.join(share, 'a'))
2742             self.assertEqual(str(P('a', 'b', 'c').absolute()),
2746     def test_glob(self):
2747         P = self.cls
2749         self.assertEqual(set(p.glob("FILEa")), { P(BASE, "fileA") })
2750         self.assertEqual(set(p.glob("*a\\")), { P(BASE, "dirA") })
2751         self.assertEqual(set(p.glob("F*a")), { P(BASE, "fileA") })
2752         self.assertEqual(set(map(str, p.glob("FILEa"))), {f"{p}\\FILEa"})
2753         self.assertEqual(set(map(str, p.glob("F*a"))), {f"{p}\\fileA"})
2755     def test_rglob(self):
2756         P = self.cls
2758         self.assertEqual(set(p.rglob("FILEd")), { P(BASE, "dirC/dirD/fileD") })
2759         self.assertEqual(set(p.rglob("*\\")), { P(BASE, "dirC/dirD") })
2760         self.assertEqual(set(map(str, p.rglob("FILEd"))), {f"{p}\\dirD\\FILEd"})
2762     def test_expanduser(self):
2763         P = self.cls
2778             self.assertRaises(RuntimeError, p1.expanduser)
2779             self.assertRaises(RuntimeError, p2.expanduser)
2780             self.assertRaises(RuntimeError, p3.expanduser)
2781             self.assertEqual(p4.expanduser(), p4)
2782             self.assertEqual(p5.expanduser(), p5)
2783             self.assertEqual(p6.expanduser(), p6)
2787                 self.assertEqual(p1.expanduser(),
2789                 self.assertRaises(RuntimeError, p2.expanduser)
2791                 self.assertEqual(p2.expanduser(),
2793                 self.assertEqual(p3.expanduser(),
2795                 self.assertEqual(p4.expanduser(), p4)
2796                 self.assertEqual(p5.expanduser(), p5)
2797                 self.assertEqual(p6.expanduser(), p6)
2829         def __init__(self, string):
2830             self.string = string
2832         def __truediv__(self, other):
2833             return type(self)(f"{self.string}/{other}")
2835         def __rtruediv__(self, other):
2836             return type(self)(f"{other}/{self.string}")
2838     def test_truediv(self):
2839         result = pathlib.PurePath("test") / self.CompatPath("right")
2840         self.assertIsInstance(result, self.CompatPath)
2841         self.assertEqual(result.string, "test/right")
2843         with self.assertRaises(TypeError):
2847     def test_rtruediv(self):
2848         result = self.CompatPath("left") / pathlib.PurePath("test")
2849         self.assertIsInstance(result, self.CompatPath)
2850         self.assertEqual(result.string, "left/test")
2852         with self.assertRaises(TypeError):