Windows test fixes

Author: barneygale

Lib/glob.py

@@ -320,11 +320,11 @@ def translate(pat, *, recursive=False, include_hidden=False, seps=None):
 
 
 @functools.lru_cache(maxsize=512)
-def _compile_pattern(pat, sep, case_sensitive, recursive=True):
+def _compile_pattern(pat, seps, case_sensitive, recursive=True):
     """Compile given glob pattern to a re.Pattern object (observing case
     sensitivity)."""
     flags = re.NOFLAG if case_sensitive else re.IGNORECASE
-    regex = translate(pat, recursive=recursive, include_hidden=True, seps=sep)
+    regex = translate(pat, recursive=recursive, include_hidden=True, seps=seps)
     return re.compile(regex, flags=flags).match
 
 
@@ -360,8 +360,9 @@ def concat_path(path, text):
 
     # High-level methods
 
-    def compile(self, pat):
-        return _compile_pattern(pat, self.sep, self.case_sensitive, self.recursive)
+    def compile(self, pat, altsep=None):
+        seps = (self.sep, altsep) if altsep else self.sep
+        return _compile_pattern(pat, seps, self.case_sensitive, self.recursive)
 
     def selector(self, parts):
         """Returns a function that selects from a given path, walking and

Lib/pathlib/types.py

@@ -135,7 +135,10 @@ def with_name(self, name):
         split = self.parser.split
         if split(name)[0]:
             raise ValueError(f"Invalid name {name!r}")
-        return self.with_segments(split(str(self))[0], name)
+        path = str(self)
+        old_name = split(path)[1]
+        path = path[:len(path) - len(old_name)] + name
+        return self.with_segments(path)
 
     def with_stem(self, stem):
         """Return a new path with the stem changed."""
@@ -223,7 +226,7 @@ def full_match(self, pattern, *, case_sensitive=None):
         if case_sensitive is None:
             case_sensitive = self.parser.normcase('Aa') == 'Aa'
         globber = _PathGlobber(pattern.parser.sep, case_sensitive, recursive=True)
-        match = globber.compile(str(pattern))
+        match = globber.compile(str(pattern), altsep=self.parser.altsep)
         return match(str(self)) is not None
 
 

Lib/test/test_pathlib/test_join.py

@@ -49,30 +49,32 @@ def with_segments(self, *pathsegments):
 
     def test_join(self):
         P = self.cls
-        p = P('a/b')
+        sep = self.cls.parser.sep
+        p = P(f'a{sep}b')
         pp = p.joinpath('c')
-        self.assertEqual(pp, P('a/b/c'))
+        self.assertEqual(pp, P(f'a{sep}b{sep}c'))
         self.assertIs(type(pp), type(p))
         pp = p.joinpath('c', 'd')
-        self.assertEqual(pp, P('a/b/c/d'))
-        pp = p.joinpath('/c')
-        self.assertEqual(pp, P('/c'))
+        self.assertEqual(pp, P(f'a{sep}b{sep}c{sep}d'))
+        pp = p.joinpath(f'{sep}c')
+        self.assertEqual(pp, P(f'{sep}c'))
 
     def test_div(self):
         # Basically the same as joinpath().
         P = self.cls
-        p = P('a/b')
+        sep = self.cls.parser.sep
+        p = P(f'a{sep}b')
         pp = p / 'c'
-        self.assertEqual(pp, P('a/b/c'))
+        self.assertEqual(pp, P(f'a{sep}b{sep}c'))
         self.assertIs(type(pp), type(p))
-        pp = p / 'c/d'
-        self.assertEqual(pp, P('a/b/c/d'))
+        pp = p / f'c{sep}d'
+        self.assertEqual(pp, P(f'a{sep}b{sep}c{sep}d'))
         pp = p / 'c' / 'd'
-        self.assertEqual(pp, P('a/b/c/d'))
+        self.assertEqual(pp, P(f'a{sep}b{sep}c{sep}d'))
         pp = 'c' / p / 'd'
-        self.assertEqual(pp, P('c/a/b/d'))
-        pp = p/ '/c'
-        self.assertEqual(pp, P('/c'))
+        self.assertEqual(pp, P(f'c{sep}a{sep}b{sep}d'))
+        pp = p/ f'{sep}c'
+        self.assertEqual(pp, P(f'{sep}c'))
 
     def test_full_match(self):
         P = self.cls
@@ -149,11 +151,11 @@ def test_parts(self):
         # `parts` returns a tuple.
         sep = self.cls.parser.sep
         P = self.cls
-        p = P('a/b')
+        p = P(f'a{sep}b')
         parts = p.parts
         self.assertEqual(parts, ('a', 'b'))
         # When the path is absolute, the anchor is a separate part.
-        p = P('/a/b')
+        p = P(f'{sep}a{sep}b')
         parts = p.parts
         self.assertEqual(parts, (sep, 'a', 'b'))
 
@@ -223,9 +225,9 @@ def test_anchor(self):
         P = self.cls
         sep = self.cls.parser.sep
         self.assertEqual(P('').anchor, '')
-        self.assertEqual(P('a/b').anchor, '')
-        self.assertEqual(P('/').anchor, sep)
-        self.assertEqual(P('/a/b').anchor, sep)
+        self.assertEqual(P(f'a{sep}b').anchor, '')
+        self.assertEqual(P(sep).anchor, sep)
+        self.assertEqual(P(f'{sep}a{sep}b').anchor, sep)
 
     def test_name(self):
         P = self.cls