fix(ls): use GetACP to detect UTF-8 encoding on Windows

On Windows, locale environment variables (LC_ALL, LC_COLLATE, LANG)
are typically unset, causing get_locale_from_env() to default to
UEncoding::Ascii. This makes non-ASCII filenames display as octal
escape sequences or `?` characters in ls output.

Fix by querying the system ANSI code page via GetACP() when no locale
variables are set. If the active code page is 65001 (UTF-8), use
UEncoding::Utf8. This aligns with GNU coreutils' approach
which calls locale_charset() -> GetACP() on Windows.

Fixes: #11103

Author: mattsu2020

src/uucore/src/lib/features/i18n/mod.rs

@@ -120,3 +120,112 @@ pub fn get_numeric_locale() -> &'static (Locale, UEncoding) {
 pub fn get_locale_encoding() -> UEncoding {
     get_collating_locale().1
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    /// Serialize env var access to prevent race conditions between parallel tests.
+    static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+    fn lock_env() -> std::sync::MutexGuard<'static, ()> {
+        ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner())
+    }
+
+    /// Helper to run a test with a specific env var set, restoring it afterwards.
+    fn with_env_var(key: &str, value: &str, f: impl FnOnce()) {
+        let _lock = lock_env();
+        let original = std::env::var(key).ok();
+        unsafe { std::env::set_var(key, value) };
+        f();
+        match original {
+            Some(v) => unsafe { std::env::set_var(key, v) },
+            None => unsafe { std::env::remove_var(key) },
+        }
+    }
+
+    #[test]
+    fn test_locale_c_returns_ascii() {
+        with_env_var("LC_ALL", "C", || {
+            let (_, encoding) = get_locale_from_env("LC_COLLATE");
+            assert_eq!(encoding, UEncoding::Ascii);
+        });
+    }
+
+    #[test]
+    fn test_locale_posix_returns_ascii() {
+        with_env_var("LC_ALL", "POSIX", || {
+            let (_, encoding) = get_locale_from_env("LC_COLLATE");
+            assert_eq!(encoding, UEncoding::Ascii);
+        });
+    }
+
+    #[test]
+    fn test_locale_utf8_suffix_returns_utf8() {
+        with_env_var("LC_ALL", "en_US.UTF-8", || {
+            let (_, encoding) = get_locale_from_env("LC_COLLATE");
+            assert_eq!(encoding, UEncoding::Utf8);
+        });
+    }
+
+    #[test]
+    fn test_locale_utf8_lowercase_suffix() {
+        with_env_var("LC_ALL", "en_US.utf8", || {
+            let (_, encoding) = get_locale_from_env("LC_COLLATE");
+            assert_eq!(encoding, UEncoding::Utf8);
+        });
+    }
+
+    #[test]
+    fn test_locale_non_utf8_encoding_returns_ascii() {
+        with_env_var("LC_ALL", "en_US.ISO-8859-1", || {
+            let (_, encoding) = get_locale_from_env("LC_COLLATE");
+            assert_eq!(encoding, UEncoding::Ascii);
+        });
+    }
+
+    #[test]
+    fn test_locale_no_encoding_suffix_returns_ascii() {
+        with_env_var("LC_ALL", "en_US", || {
+            let (_, encoding) = get_locale_from_env("LC_COLLATE");
+            assert_eq!(encoding, UEncoding::Ascii);
+        });
+    }
+
+    #[test]
+    fn test_lang_fallback_when_lc_all_unset() {
+        let _lock = lock_env();
+        let orig_lc_all = std::env::var("LC_ALL").ok();
+        let orig_lc_collate = std::env::var("LC_COLLATE").ok();
+        let orig_lang = std::env::var("LANG").ok();
+        unsafe { std::env::remove_var("LC_ALL") };
+        unsafe { std::env::remove_var("LC_COLLATE") };
+        unsafe { std::env::set_var("LANG", "en_US.UTF-8") };
+        let (_, encoding) = get_locale_from_env("LC_COLLATE");
+        assert_eq!(encoding, UEncoding::Utf8);
+        // Restore
+        match orig_lc_all {
+            Some(v) => unsafe { std::env::set_var("LC_ALL", v) },
+            None => unsafe { std::env::remove_var("LC_ALL") },
+        }
+        match orig_lc_collate {
+            Some(v) => unsafe { std::env::set_var("LC_COLLATE", v) },
+            None => unsafe { std::env::remove_var("LC_COLLATE") },
+        }
+        match orig_lang {
+            Some(v) => unsafe { std::env::set_var("LANG", v) },
+            None => unsafe { std::env::remove_var("LANG") },
+        }
+    }
+
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn test_windows_encoding_returns_valid_variant() {
+        let encoding = get_windows_encoding();
+        assert!(
+            encoding == UEncoding::Ascii || encoding == UEncoding::Utf8,
+            "get_windows_encoding should return either Ascii or Utf8"
+        );
+    }
+}