Windows test fixes

python · barneygale · Mar 9, 2025 · Mar 8, 2025 · Mar 8, 2025 · Mar 8, 2025
commit 771aeb92908cd5a5b75a05c5742c4dfe0abe25ae
diff --git a/Lib/glob.py b/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

diff --git a/Lib/pathlib/types.py b/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



@@ -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