✅ Test normalize_windows_separators

Lift the helper out of symlink::inner so the #[cfg(test)] module can
reach it, then cover: Cow::Borrowed fast path, basic/mixed conversion,
empty path, single slash, \\?\ extended-length paths, lone-surrogate
WTF-16 round-trip, and Unicode preservation. Production behavior
unchanged.

Author: ChanTsune

pna/src/fs.rs

@@ -28,29 +28,6 @@ pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Resu
     }
     #[cfg(windows)]
     fn inner(original: &Path, link: &Path) -> io::Result<()> {
-        use std::borrow::Cow;
-        use std::ffi::OsString;
-        use std::os::windows::ffi::{OsStrExt, OsStringExt};
-        use std::path::PathBuf;
-
-        fn normalize_windows_separators(path: &Path) -> Cow<'_, Path> {
-            let wide: Vec<u16> = path.as_os_str().encode_wide().collect();
-            if !wide.iter().any(|&unit| unit == u16::from(b'/')) {
-                return Cow::Borrowed(path);
-            }
-            let normalized = wide
-                .into_iter()
-                .map(|unit| {
-                    if unit == u16::from(b'/') {
-                        u16::from(b'\\')
-                    } else {
-                        unit
-                    }
-                })
-                .collect::<Vec<_>>();
-            Cow::Owned(PathBuf::from(OsString::from_wide(&normalized)))
-        }
-
         let original = normalize_windows_separators(original);
         let link = normalize_windows_separators(link);
         // Symlink targets are resolved relative to the link's parent directory,
@@ -77,6 +54,37 @@ pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Resu
     inner(original.as_ref(), link.as_ref())
 }
 
+/// Replaces forward-slash separators with backslashes for Windows path APIs.
+///
+/// Windows symlink reparse points store the target verbatim; non-canonical
+/// `/` separators break resolution under `\\?\` extended-length paths and
+/// confuse downstream tools that read the reparse buffer (e.g. bsdtar,
+/// GNU tar, 7-Zip all normalize on extract). Goes through UTF-16 to preserve
+/// non-UTF-8 OsString sequences (WTF-16) byte-for-byte.
+#[cfg(windows)]
+fn normalize_windows_separators(path: &Path) -> std::borrow::Cow<'_, Path> {
+    use std::borrow::Cow;
+    use std::ffi::OsString;
+    use std::os::windows::ffi::{OsStrExt, OsStringExt};
+    use std::path::PathBuf;
+
+    let wide: Vec<u16> = path.as_os_str().encode_wide().collect();
+    if !wide.iter().any(|&unit| unit == u16::from(b'/')) {
+        return Cow::Borrowed(path);
+    }
+    let normalized = wide
+        .into_iter()
+        .map(|unit| {
+            if unit == u16::from(b'/') {
+                u16::from(b'\\')
+            } else {
+                unit
+            }
+        })
+        .collect::<Vec<_>>();
+    Cow::Owned(PathBuf::from(OsString::from_wide(&normalized)))
+}
+
 /// Removes a path by dispatching based on file type.
 ///
 /// - Symlinks: removed via `remove_file` (or `remove_dir` for directory symlinks on Windows)
@@ -170,3 +178,78 @@ pub fn remove_path_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
 pub fn remove_path<P: AsRef<Path>>(path: P) -> io::Result<()> {
     remove_path_with(path.as_ref(), fs::remove_dir)
 }
+
+#[cfg(all(test, windows))]
+mod windows_tests {
+    use super::normalize_windows_separators;
+    use std::borrow::Cow;
+    use std::ffi::OsString;
+    use std::os::windows::ffi::{OsStrExt, OsStringExt};
+    use std::path::{Path, PathBuf};
+
+    fn wide_units_of(path: &Path) -> Vec<u16> {
+        path.as_os_str().encode_wide().collect()
+    }
+
+    #[test]
+    fn returns_borrowed_when_no_forward_slash() {
+        let input = Path::new(r"foo\bar\baz");
+        let result = normalize_windows_separators(input);
+        assert!(matches!(result, Cow::Borrowed(_)));
+        assert_eq!(result.as_ref(), input);
+    }
+
+    #[test]
+    fn converts_basic_forward_slash_to_backslash() {
+        let result = normalize_windows_separators(Path::new("foo/bar"));
+        assert!(matches!(result, Cow::Owned(_)));
+        assert_eq!(result.as_ref(), Path::new(r"foo\bar"));
+    }
+
+    #[test]
+    fn preserves_existing_backslashes_in_mixed_input() {
+        let result = normalize_windows_separators(Path::new(r"a/b\c/d"));
+        assert_eq!(result.as_ref(), Path::new(r"a\b\c\d"));
+    }
+
+    #[test]
+    fn empty_path_returns_borrowed() {
+        let input = Path::new("");
+        let result = normalize_windows_separators(input);
+        assert!(matches!(result, Cow::Borrowed(_)));
+        assert_eq!(result.as_ref(), input);
+    }
+
+    #[test]
+    fn single_forward_slash_is_converted() {
+        let result = normalize_windows_separators(Path::new("/"));
+        assert_eq!(result.as_ref(), Path::new(r"\"));
+    }
+
+    #[test]
+    fn extended_length_path_with_forward_slashes_is_normalized() {
+        // \\?\ prefix rejects forward slashes at resolution time; this is the
+        // headline regression case the caller relies on this helper to fix.
+        let result = normalize_windows_separators(Path::new(r"\\?\C:/foo/bar"));
+        assert_eq!(result.as_ref(), Path::new(r"\\?\C:\foo\bar"));
+    }
+
+    #[test]
+    fn lone_surrogate_is_preserved_while_slash_is_converted() {
+        // 0xD800 is a lone high surrogate (valid only in WTF-16). The helper
+        // must round-trip it byte-for-byte while still rewriting U+002F.
+        let units: [u16; 3] = [0xD800, u16::from(b'/'), u16::from(b'a')];
+        let input = PathBuf::from(OsString::from_wide(&units));
+        let result = normalize_windows_separators(&input);
+        assert_eq!(
+            wide_units_of(result.as_ref()),
+            vec![0xD800, u16::from(b'\\'), u16::from(b'a')]
+        );
+    }
+
+    #[test]
+    fn unicode_characters_are_preserved() {
+        let result = normalize_windows_separators(Path::new("日本語/フォルダ"));
+        assert_eq!(result.as_ref(), Path::new(r"日本語\フォルダ"));
+    }
+}