[browser] Revert to full NativeName by interop with JS (#99956)

ilonatommy · mkhamoyan · web-flow · commit 0c30a1bd30a2 · 2024-03-26T12:10:59.000+01:00
* Fix NativeName and DisplayName for browser.

* Nit - revert over-renaming.

* Update src/libraries/System.Private.CoreLib/src/System/Globalization/CultureData.Browser.cs

Co-authored-by: Meri Khamoyan &lt;96171496+mkhamoyan@users.noreply.github.com&gt;

* Enable more tests and fix them - initialize english and native names on CultureInfo constructio

* Ubnblock fixed test.

* MT does not work with HG well, revet MT to original way of working.

* Expect fixed version of NativeName in tests with single treaded runtime.

* Assert.Contains does not know that `\u00F1` is same as `ñ` (it does not evaluate the string before comparison) - fix it with string interpolation.

* Windows has problems with comparing utf8 by xunit.

---------

Co-authored-by: Meri Khamoyan &lt;96171496+mkhamoyan@users.noreply.github.com&gt;
diff --git a/src/libraries/Common/src/Interop/Browser/Interop.Locale.cs b/src/libraries/Common/src/Interop/Browser/Interop.Locale.cs
@@ -13,5 +13,7 @@ internal static unsafe partial class JsGlobalization
         internal static extern unsafe int GetFirstDayOfWeek(in string culture, out int exceptionalResult, out object result);
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         internal static extern unsafe int GetFirstWeekOfYear(in string culture, out int exceptionalResult, out object result);
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal static extern unsafe int GetLocaleInfo(in string locale, in string culture, char* buffer, int bufferLength, out int exceptionalResult, out object result);
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/CultureData.Browser.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/CultureData.Browser.cs
@@ -10,13 +10,62 @@ namespace System.Globalization
     internal sealed partial class CultureData
     {
         private const int CULTURE_INFO_BUFFER_LEN = 50;
+        private const int LOCALE_INFO_BUFFER_LEN = 80;
+
+        private void JSInitLocaleInfo()
+        {
+            string? localeName = _sName;
+            if (string.IsNullOrEmpty(localeName))
+            {
+                _sEnglishLanguage = "Invariant Language";
+                _sNativeLanguage = _sEnglishLanguage;
+                _sEnglishCountry = "Invariant Country";
+                _sNativeCountry = _sEnglishCountry;
+                _sEnglishDisplayName = $"{_sEnglishLanguage} ({_sEnglishCountry})";
+                _sNativeDisplayName = _sEnglishDisplayName;
+            }
+            else
+            {
+                // English locale info
+                (_sEnglishLanguage, _sEnglishCountry) = JSGetLocaleInfo("en-US", localeName);
+                _sEnglishDisplayName = string.IsNullOrEmpty(_sEnglishCountry) ?
+                    _sEnglishLanguage :
+                    $"{_sEnglishLanguage} ({_sEnglishCountry})";
+                // Native locale info
+                (_sNativeLanguage, _sNativeCountry) = JSGetLocaleInfo(localeName, localeName);
+                _sNativeDisplayName = string.IsNullOrEmpty(_sNativeCountry) ?
+                    _sNativeLanguage :
+                    $"{_sNativeLanguage} ({_sNativeCountry})";
+            }
+        }
+
+        private unsafe (string, string) JSGetLocaleInfo(string cultureName, string localeName)
+        {
+            char* buffer = stackalloc char[LOCALE_INFO_BUFFER_LEN];
+            int resultLength = Interop.JsGlobalization.GetLocaleInfo(cultureName, localeName, buffer, LOCALE_INFO_BUFFER_LEN, out int exception, out object exResult);
+            if (exception != 0)
+                throw new Exception((string)exResult);
+            string result = new string(buffer, 0, resultLength);
+            string[] subresults = result.Split("##");
+            if (subresults.Length == 0)
+                throw new Exception("LocaleInfo recieved from the Browser is in incorrect format.");
+            if (subresults.Length == 1)
+                return (subresults[0], ""); // Neutral culture
+            return (subresults[0], subresults[1]);
+        }
+
+        private string JSGetNativeDisplayName(string localeName, string cultureName)
+        {
+            (string languageName, string countryName) = JSGetLocaleInfo(localeName, cultureName);
+            return string.IsNullOrEmpty(countryName) ?
+                    languageName :
+                    $"{languageName} ({countryName})";
+        }
 
         private static unsafe CultureData JSLoadCultureInfoFromBrowser(string localeName, CultureData culture)
         {
             char* buffer = stackalloc char[CULTURE_INFO_BUFFER_LEN];
-            int exception;
-            object exResult;
-            int resultLength = Interop.JsGlobalization.GetCultureInfo(localeName, buffer, CULTURE_INFO_BUFFER_LEN, out exception, out exResult);
+            int resultLength = Interop.JsGlobalization.GetCultureInfo(localeName, buffer, CULTURE_INFO_BUFFER_LEN, out int exception, out object exResult);
             if (exception != 0)
                 throw new Exception((string)exResult);
             string result = new string(buffer, 0, resultLength);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/CultureData.Icu.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/CultureData.Icu.cs
@@ -203,6 +203,12 @@ private string IcuGetLocaleInfo(LocaleStringData type, string? uiCultureName = n
             Debug.Assert(!GlobalizationMode.Invariant);
             Debug.Assert(!GlobalizationMode.UseNls);
             Debug.Assert(_sWindowsName != null, "[CultureData.IcuGetLocaleInfo] Expected _sWindowsName to be populated already");
+#if TARGET_BROWSER && !FEATURE_WASM_MANAGED_THREADS
+            if (type == LocaleStringData.NativeDisplayName)
+            {
+                return JSGetNativeDisplayName(_sWindowsName, uiCultureName ?? _sWindowsName);
+            }
+#endif
             return IcuGetLocaleInfo(_sWindowsName, type, uiCultureName);
         }
 
@@ -302,7 +308,14 @@ private unsafe string IcuGetTimeFormatString(bool shortFormat)
         // no support to lookup by region name, other than the hard-coded list in CultureData
         private static CultureData? IcuGetCultureDataFromRegionName() => null;
 
-        private string IcuGetLanguageDisplayName(string cultureName) => IcuGetLocaleInfo(cultureName, LocaleStringData.LocalizedDisplayName, CultureInfo.CurrentUICulture.Name);
+        private string IcuGetLanguageDisplayName(string cultureName)
+        {
+#if TARGET_BROWSER && !FEATURE_WASM_MANAGED_THREADS
+            return JSGetNativeDisplayName(CultureInfo.CurrentUICulture.Name, cultureName);
+#else
+            return IcuGetLocaleInfo(cultureName, LocaleStringData.LocalizedDisplayName, CultureInfo.CurrentUICulture.Name);
+#endif
+        }
 
         // use the fallback which is to return NativeName
         private static string? IcuGetRegionDisplayName() => null;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/CultureData.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/CultureData.cs
@@ -816,12 +816,13 @@ private static string NormalizeCultureName(string name, out bool isNeutralName)
             {
                 return null;
             }
-#if TARGET_BROWSER
+#if TARGET_BROWSER && !FEATURE_WASM_MANAGED_THREADS
             // populate fields for which ICU does not provide data in Hybrid mode
             if (GlobalizationMode.Hybrid && !string.IsNullOrEmpty(culture._sName))
             {
                 culture = JSLoadCultureInfoFromBrowser(culture._sName, culture);
             }
+            culture.JSInitLocaleInfo();
 #endif
 
             // We need _sWindowsName to be initialized to know if we're using overrides.
diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Tests/CultureInfo/CultureInfoEnglishName.cs b/src/libraries/System.Runtime/tests/System.Globalization.Tests/CultureInfo/CultureInfoEnglishName.cs
@@ -9,21 +9,22 @@ namespace System.Globalization.Tests
     public class CultureInfoEnglishName
     {
         // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures
-        public static bool SupportFullGlobalizationData => PlatformDetection.IsNotUsingLimitedCultures || PlatformDetection.IsAndroid;
+        // Browser uses JS to get the NativeName that is missing in ICU (in the singlethreaded runtime only)
+        public static bool SupportFullGlobalizationData =>
+            (!PlatformDetection.IsWasi || PlatformDetection.IsHybridGlobalizationOnApplePlatform) && !PlatformDetection.IsWasmThreadingSupported;
 
         public static IEnumerable<object[]> EnglishName_TestData()
         {
             yield return new object[] { CultureInfo.CurrentCulture.Name, CultureInfo.CurrentCulture.EnglishName };
 
-            if (SupportFullGlobalizationData || PlatformDetection.IsHybridGlobalizationOnApplePlatform)
+            if (SupportFullGlobalizationData)
             {
                 yield return new object[] { "en-US", "English (United States)" };
                 yield return new object[] { "fr-FR", "French (France)" };
                 yield return new object[] { "uz-Cyrl", "Uzbek (Cyrillic)" };
             }
             else
             {
-                // Mobile / Browser ICU doesn't contain CultureInfo.EnglishName
                 yield return new object[] { "en-US", "en (US)" };
                 yield return new object[] { "fr-FR", "fr (FR)" };
             }
@@ -41,12 +42,12 @@ public void EnglishName(string name, string expected)
         public void ChineseNeutralEnglishName()
         {
             CultureInfo ci = new CultureInfo("zh-Hans");
-            Assert.True(ci.EnglishName == "Chinese (Simplified)" || ci.EnglishName == "Chinese, Simplified",
-                        $"'{ci.EnglishName}' not equal to `Chinese (Simplified)` nor `Chinese, Simplified`");
+            Assert.True(ci.EnglishName == "Chinese (Simplified)" || ci.EnglishName == "Chinese, Simplified" || ci.EnglishName == "Simplified Chinese",
+                        $"'{ci.EnglishName}' not equal to `Chinese (Simplified)` nor `Chinese, Simplified` nor `Simplified Chinese`");
 
             ci = new CultureInfo("zh-HanT");
-            Assert.True(ci.EnglishName == "Chinese (Traditional)" || ci.EnglishName == "Chinese, Traditional",
-                        $"'{ci.EnglishName}' not equal to `Chinese (Traditional)` nor `Chinese, Traditional`");
+            Assert.True(ci.EnglishName == "Chinese (Traditional)" || ci.EnglishName == "Chinese, Traditional" || ci.EnglishName == "Traditional Chinese",
+                        $"'{ci.EnglishName}' not equal to `Chinese (Traditional)` nor `Chinese, Traditional` nor `Traditional Chinese`");
         }
     }
 }
diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Tests/CultureInfo/CultureInfoNames.cs b/src/libraries/System.Runtime/tests/System.Globalization.Tests/CultureInfo/CultureInfoNames.cs
@@ -10,19 +10,31 @@ namespace System.Globalization.Tests
 {
     public class CultureInfoNames
     {
-        private static bool SupportFullIcuResources => (PlatformDetection.IsNotMobile && PlatformDetection.IsIcuGlobalization) || PlatformDetection.IsHybridGlobalizationOnApplePlatform;
+        // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures
+        // Browser uses JS to get the NativeName that is missing in ICU (in the singlethreaded runtime only)
+        private static bool SupportFullIcuResources =>
+            !PlatformDetection.IsWasi && !PlatformDetection.IsAndroid && PlatformDetection.IsIcuGlobalization && !PlatformDetection.IsWasmThreadingSupported;
+        
+        public static IEnumerable<object[]> SupportedCultures_TestData()
+        {
+            // Browser does not support all ICU locales but it uses JS to get the correct native name
+            if (!PlatformDetection.IsBrowser)
+            {
+                yield return new object[] { "aa", "aa", "Afar", "Afar" };
+                yield return new object[] { "aa-ER", "aa-ER", "Afar (Eritrea)", "Afar (Eritrea)" };
+            }
+            yield return new object[] { "en", "en", "English", "English" };
+            yield return new object[] { "en", "fr", "English", "anglais" };
+            yield return new object[] { "en-US", "en-US", "English (United States)", "English (United States)" };
+            yield return new object[] { "en-US", "fr-FR", "English (United States)", "anglais (\u00C9tats-Unis)" };
+            yield return new object[] { "en-US", "de-DE", "English (United States)", "Englisch (Vereinigte Staaten)" };
+            yield return new object[] { "", "en-US", "Invariant Language (Invariant Country)", "Invariant Language (Invariant Country)" };
+            yield return new object[] { "", "fr-FR", "Invariant Language (Invariant Country)", "Invariant Language (Invariant Country)" };
+            yield return new object[] { "", "", "Invariant Language (Invariant Country)", "Invariant Language (Invariant Country)" };
+        }
 
         [ConditionalTheory(nameof(SupportFullIcuResources))]
-        [InlineData("en", "en", "English", "English")]
-        [InlineData("en", "fr", "English", "anglais")]
-        [InlineData("aa", "aa", "Afar", "Afar")]
-        [InlineData("en-US", "en-US", "English (United States)", "English (United States)")]
-        [InlineData("en-US", "fr-FR", "English (United States)", "anglais (\u00C9tats-Unis)")]
-        [InlineData("en-US", "de-DE", "English (United States)", "Englisch (Vereinigte Staaten)")]
-        [InlineData("aa-ER", "aa-ER", "Afar (Eritrea)", "Afar (Eritrea)")]
-        [InlineData("", "en-US", "Invariant Language (Invariant Country)", "Invariant Language (Invariant Country)")]
-        [InlineData("", "fr-FR", "Invariant Language (Invariant Country)", "Invariant Language (Invariant Country)")]
-        [InlineData("", "", "Invariant Language (Invariant Country)", "Invariant Language (Invariant Country)")]
+        [MemberData(nameof(SupportedCultures_TestData))]
         public void TestDisplayName(string cultureName, string uiCultureName, string nativeName, string displayName)
         {
             using (new ThreadCultureChange(null, CultureInfo.GetCultureInfo(uiCultureName)))
diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Tests/CultureInfo/CultureInfoNativeName.cs b/src/libraries/System.Runtime/tests/System.Globalization.Tests/CultureInfo/CultureInfoNativeName.cs
@@ -8,20 +8,23 @@ namespace System.Globalization.Tests
 {
     public class CultureInfoNativeName
     {
+        // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures
+        // Browser uses JS to get the NativeName that is missing in ICU (in the singlethreaded runtime only)
+        private static bool SupportFullIcuResources =>
+            (!PlatformDetection.IsWasi || PlatformDetection.IsHybridGlobalizationOnApplePlatform) && !PlatformDetection.IsWasmThreadingSupported;
+
         public static IEnumerable<object[]> NativeName_TestData()
         {
             yield return new object[] { CultureInfo.CurrentCulture.Name, CultureInfo.CurrentCulture.NativeName };
 
-            // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures
-            if (PlatformDetection.IsNotUsingLimitedCultures || PlatformDetection.IsAndroid || PlatformDetection.IsHybridGlobalizationOnApplePlatform)
+            if (SupportFullIcuResources)
             {
                 yield return new object[] { "en-US", "English (United States)" };
                 yield return new object[] { "en-CA", "English (Canada)" };
                 yield return new object[] { "en-GB", "English (United Kingdom)" };
             }
             else
             {
-                // Mobile / Browser ICU doesn't contain CultureInfo.NativeName
                 yield return new object[] { "en-US", "en (US)" };
                 yield return new object[] { "en-CA", "en (CA)" };
             }
diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Tests/System/Globalization/RegionInfoTests.cs b/src/libraries/System.Runtime/tests/System.Globalization.Tests/System/Globalization/RegionInfoTests.cs
@@ -12,6 +12,11 @@ namespace System.Globalization.Tests
 {
     public class RegionInfoPropertyTests
     {
+        // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures
+        // Browser uses JS to get the NativeName that is missing in ICU (in the singlethreaded runtime only)
+        public static bool SupportFullGlobalizationData =>
+            (!PlatformDetection.IsWasi || PlatformDetection.IsHybridGlobalizationOnApplePlatform) && !PlatformDetection.IsWasmThreadingSupported;
+
         [Theory]
         [InlineData("US", "US", "US")]
         [InlineData("IT", "IT", "IT")]
@@ -100,7 +105,6 @@ public void ValidateUsingCasedRegionName(string regionName)
         [Theory]
         [InlineData("en-US", "United States")]
         [OuterLoop("May fail on machines with multiple language packs installed")] // see https://github.com/dotnet/runtime/issues/30132
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/45951", TestPlatforms.Browser)]
         public void DisplayName(string name, string expected)
         {
             using (new ThreadCultureChange(null, new CultureInfo(name)))
@@ -111,16 +115,14 @@ public void DisplayName(string name, string expected)
 
         public static IEnumerable<object[]> NativeName_TestData()
         {
-            // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures
-            if (PlatformDetection.IsNotUsingLimitedCultures || PlatformDetection.IsAndroid || PlatformDetection.IsHybridGlobalizationOnApplePlatform)
+            if (SupportFullGlobalizationData)
             {
                 yield return new object[] { "GB", "United Kingdom" };
                 yield return new object[] { "SE", "Sverige" };
                 yield return new object[] { "FR", "France" };
             }
             else
             {
-                // Browser's ICU doesn't contain RegionInfo.NativeName
                 yield return new object[] { "GB", "GB" };
                 yield return new object[] { "SE", "SE" };
                 yield return new object[] { "FR", "FR" };
@@ -136,8 +138,7 @@ public void NativeName(string name, string expected)
 
         public static IEnumerable<object[]> EnglishName_TestData()
         {
-            // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures
-            if (PlatformDetection.IsNotUsingLimitedCultures || PlatformDetection.IsAndroid || PlatformDetection.IsHybridGlobalizationOnApplePlatform)
+            if (SupportFullGlobalizationData)
             {
                 yield return new object[] { "en-US", new string[] { "United States" } };
                 yield return new object[] { "US", new string[] { "United States" } };
@@ -146,7 +147,6 @@ public static IEnumerable<object[]> EnglishName_TestData()
             }
             else
             {
-                // Browser's ICU doesn't contain RegionInfo.EnglishName
                 yield return new object[] { "en-US", new string[] { "US" } };
                 yield return new object[] { "US", new string[] { "US" } };
                 yield return new object[] { "zh-CN", new string[] { "CN" }};
diff --git a/src/mono/browser/runtime/corebindings.c b/src/mono/browser/runtime/corebindings.c
@@ -64,6 +64,7 @@ extern mono_bool mono_wasm_starts_with (MonoString **culture, const uint16_t* st
 extern mono_bool mono_wasm_ends_with (MonoString **culture, const uint16_t* str1, int32_t str1Length, const uint16_t* str2, int32_t str2Length, int32_t options, int *is_exception, MonoObject** ex_result);
 extern int mono_wasm_index_of (MonoString **culture, const uint16_t* str1, int32_t str1Length, const uint16_t* str2, int32_t str2Length, int32_t options, mono_bool fromBeginning, int *is_exception, MonoObject** ex_result);
 extern int mono_wasm_get_calendar_info (MonoString **culture, int32_t calendarId, const uint16_t* result, int32_t resultLength, int *is_exception, MonoObject** ex_result);
+extern int mono_wasm_get_locale_info (MonoString **locale, MonoString **culture, const uint16_t* result, int32_t resultLength, int *is_exception, MonoObject** ex_result);
 extern int mono_wasm_get_culture_info (MonoString **culture, const uint16_t* result, int32_t resultLength, int *is_exception, MonoObject** ex_result);
 extern int mono_wasm_get_first_day_of_week (MonoString **culture, int *is_exception, MonoObject** ex_result);
 extern int mono_wasm_get_first_week_of_year (MonoString **culture, int *is_exception, MonoObject** ex_result);
@@ -105,6 +106,7 @@ void bindings_initialize_internals (void)
 	mono_add_internal_call ("Interop/JsGlobalization::EndsWith", mono_wasm_ends_with);
 	mono_add_internal_call ("Interop/JsGlobalization::IndexOf", mono_wasm_index_of);
 	mono_add_internal_call ("Interop/JsGlobalization::GetCalendarInfo", mono_wasm_get_calendar_info);
+	mono_add_internal_call ("Interop/JsGlobalization::GetLocaleInfo", mono_wasm_get_locale_info);
 	mono_add_internal_call ("Interop/JsGlobalization::GetCultureInfo", mono_wasm_get_culture_info);
 	mono_add_internal_call ("Interop/JsGlobalization::GetFirstDayOfWeek", mono_wasm_get_first_day_of_week);
 	mono_add_internal_call ("Interop/JsGlobalization::GetFirstWeekOfYear", mono_wasm_get_first_week_of_year);
diff --git a/src/mono/browser/runtime/exports-binding.ts b/src/mono/browser/runtime/exports-binding.ts
@@ -22,7 +22,7 @@ import { mono_wasm_compare_string, mono_wasm_ends_with, mono_wasm_starts_with, m
 import { mono_wasm_get_calendar_info } from "./hybrid-globalization/calendar";
 
 import { mono_wasm_get_culture_info } from "./hybrid-globalization/culture-info";
-import { mono_wasm_get_first_day_of_week, mono_wasm_get_first_week_of_year } from "./hybrid-globalization/locales";
+import { mono_wasm_get_locale_info, mono_wasm_get_first_day_of_week, mono_wasm_get_first_week_of_year } from "./hybrid-globalization/locales";
 import { mono_wasm_browser_entropy } from "./crypto";
 import { mono_wasm_cancel_promise } from "./cancelable-promise";
 
@@ -107,6 +107,7 @@ export const mono_wasm_imports = [
     mono_wasm_index_of,
     mono_wasm_get_calendar_info,
     mono_wasm_get_culture_info,
+    mono_wasm_get_locale_info,
     mono_wasm_get_first_day_of_week,
     mono_wasm_get_first_week_of_year,
 ];
diff --git a/src/mono/browser/runtime/hybrid-globalization/helpers.ts b/src/mono/browser/runtime/hybrid-globalization/helpers.ts
@@ -25,9 +25,9 @@ export function normalizeLocale(locale: string | null)
         const canonicalLocales = (Intl as any).getCanonicalLocales(locale.replace("_", "-"));
         return canonicalLocales.length > 0 ? canonicalLocales[0] : undefined;
     }
-    catch(ex: any)
+    catch
     {
-        throw new Error(`Get culture info failed for culture = ${locale} with error: ${ex}`);
+        return undefined;
     }
 }
 
diff --git a/src/mono/browser/runtime/hybrid-globalization/locales.ts b/src/mono/browser/runtime/hybrid-globalization/locales.ts
diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/WorkloadRequiredTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/WorkloadRequiredTests.cs
diff --git a/src/mono/wasm/Wasm.Build.Tests/InvariantGlobalizationTests.cs b/src/mono/wasm/Wasm.Build.Tests/InvariantGlobalizationTests.cs
diff --git a/src/mono/wasm/testassets/Wasm.Buid.Tests.Programs/InvariantGlobalization.cs b/src/mono/wasm/testassets/Wasm.Buid.Tests.Programs/InvariantGlobalization.cs

Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,7 @@ internal static unsafe partial class JsGlobalization`
`13`	`13`	`internal static extern unsafe int GetFirstDayOfWeek(in string culture, out int exceptionalResult, out object result);`
`14`	`14`	`[MethodImplAttribute(MethodImplOptions.InternalCall)]`
`15`	`15`	`internal static extern unsafe int GetFirstWeekOfYear(in string culture, out int exceptionalResult, out object result);`
	`16`	`+ [MethodImplAttribute(MethodImplOptions.InternalCall)]`
	`17`	`+ internal static extern unsafe int GetLocaleInfo(in string locale, in string culture, char* buffer, int bufferLength, out int exceptionalResult, out object result);`
`16`	`18`	`}`
`17`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -816,12 +816,13 @@ private static string NormalizeCultureName(string name, out bool isNeutralName)`
`816`	`816`	`{`
`817`	`817`	`return null;`
`818`	`818`	`}`
`819`		`-#if TARGET_BROWSER`
	`819`	`+#if TARGET_BROWSER && !FEATURE_WASM_MANAGED_THREADS`
`820`	`820`	`// populate fields for which ICU does not provide data in Hybrid mode`
`821`	`821`	`if (GlobalizationMode.Hybrid && !string.IsNullOrEmpty(culture._sName))`
`822`	`822`	`{`
`823`	`823`	`culture = JSLoadCultureInfoFromBrowser(culture._sName, culture);`
`824`	`824`	`}`
	`825`	`+ culture.JSInitLocaleInfo();`
`825`	`826`	`#endif`
`826`	`827`
`827`	`828`	`// We need _sWindowsName to be initialized to know if we're using overrides.`
Original file line number	Diff line number	Diff line change
`@@ -9,21 +9,22 @@ namespace System.Globalization.Tests`
`9`	`9`	`public class CultureInfoEnglishName`
`10`	`10`	`{`
`11`	`11`	`// Android has its own ICU, which doesn't 100% map to UsingLimitedCultures`
`12`		`- public static bool SupportFullGlobalizationData => PlatformDetection.IsNotUsingLimitedCultures \|\| PlatformDetection.IsAndroid;`
	`12`	`+ // Browser uses JS to get the NativeName that is missing in ICU (in the singlethreaded runtime only)`
	`13`	`+ public static bool SupportFullGlobalizationData =>`
	`14`	`+ (!PlatformDetection.IsWasi \|\| PlatformDetection.IsHybridGlobalizationOnApplePlatform) && !PlatformDetection.IsWasmThreadingSupported;`
`13`	`15`
`14`	`16`	`public static IEnumerable<object[]> EnglishName_TestData()`
`15`	`17`	`{`
`16`	`18`	`yield return new object[] { CultureInfo.CurrentCulture.Name, CultureInfo.CurrentCulture.EnglishName };`
`17`	`19`
`18`		`- if (SupportFullGlobalizationData \|\| PlatformDetection.IsHybridGlobalizationOnApplePlatform)`
	`20`	`+ if (SupportFullGlobalizationData)`
`19`	`21`	`{`
`20`	`22`	`yield return new object[] { "en-US", "English (United States)" };`
`21`	`23`	`yield return new object[] { "fr-FR", "French (France)" };`
`22`	`24`	`yield return new object[] { "uz-Cyrl", "Uzbek (Cyrillic)" };`
`23`	`25`	`}`
`24`	`26`	`else`
`25`	`27`	`{`
`26`		`- // Mobile / Browser ICU doesn't contain CultureInfo.EnglishName`
`27`	`28`	`yield return new object[] { "en-US", "en (US)" };`
`28`	`29`	`yield return new object[] { "fr-FR", "fr (FR)" };`
`29`	`30`	`}`
`@@ -41,12 +42,12 @@ public void EnglishName(string name, string expected)`
`41`	`42`	`public void ChineseNeutralEnglishName()`
`42`	`43`	`{`
`43`	`44`	`CultureInfo ci = new CultureInfo("zh-Hans");`
`44`		`- Assert.True(ci.EnglishName == "Chinese (Simplified)" \|\| ci.EnglishName == "Chinese, Simplified",`
`45`		- $"'{ci.EnglishName}' not equal to `Chinese (Simplified)` nor `Chinese, Simplified`");
	`45`	`+ Assert.True(ci.EnglishName == "Chinese (Simplified)" \|\| ci.EnglishName == "Chinese, Simplified" \|\| ci.EnglishName == "Simplified Chinese",`
	`46`	+ $"'{ci.EnglishName}' not equal to `Chinese (Simplified)` nor `Chinese, Simplified` nor `Simplified Chinese`");
`46`	`47`
`47`	`48`	`ci = new CultureInfo("zh-HanT");`
`48`		`- Assert.True(ci.EnglishName == "Chinese (Traditional)" \|\| ci.EnglishName == "Chinese, Traditional",`
`49`		- $"'{ci.EnglishName}' not equal to `Chinese (Traditional)` nor `Chinese, Traditional`");
	`49`	`+ Assert.True(ci.EnglishName == "Chinese (Traditional)" \|\| ci.EnglishName == "Chinese, Traditional" \|\| ci.EnglishName == "Traditional Chinese",`
	`50`	+ $"'{ci.EnglishName}' not equal to `Chinese (Traditional)` nor `Chinese, Traditional` nor `Traditional Chinese`");
`50`	`51`	`}`
`51`	`52`	`}`
`52`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,20 +8,23 @@ namespace System.Globalization.Tests`
`8`	`8`	`{`
`9`	`9`	`public class CultureInfoNativeName`
`10`	`10`	`{`
	`11`	`+ // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures`
	`12`	`+ // Browser uses JS to get the NativeName that is missing in ICU (in the singlethreaded runtime only)`
	`13`	`+ private static bool SupportFullIcuResources =>`
	`14`	`+ (!PlatformDetection.IsWasi \|\| PlatformDetection.IsHybridGlobalizationOnApplePlatform) && !PlatformDetection.IsWasmThreadingSupported;`
	`15`	`+`
`11`	`16`	`public static IEnumerable<object[]> NativeName_TestData()`
`12`	`17`	`{`
`13`	`18`	`yield return new object[] { CultureInfo.CurrentCulture.Name, CultureInfo.CurrentCulture.NativeName };`
`14`	`19`
`15`		`- // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures`
`16`		`- if (PlatformDetection.IsNotUsingLimitedCultures \|\| PlatformDetection.IsAndroid \|\| PlatformDetection.IsHybridGlobalizationOnApplePlatform)`
	`20`	`+ if (SupportFullIcuResources)`
`17`	`21`	`{`
`18`	`22`	`yield return new object[] { "en-US", "English (United States)" };`
`19`	`23`	`yield return new object[] { "en-CA", "English (Canada)" };`
`20`	`24`	`yield return new object[] { "en-GB", "English (United Kingdom)" };`
`21`	`25`	`}`
`22`	`26`	`else`
`23`	`27`	`{`
`24`		`- // Mobile / Browser ICU doesn't contain CultureInfo.NativeName`
`25`	`28`	`yield return new object[] { "en-US", "en (US)" };`
`26`	`29`	`yield return new object[] { "en-CA", "en (CA)" };`
`27`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,11 @@ namespace System.Globalization.Tests`
`12`	`12`	`{`
`13`	`13`	`public class RegionInfoPropertyTests`
`14`	`14`	`{`
	`15`	`+ // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures`
	`16`	`+ // Browser uses JS to get the NativeName that is missing in ICU (in the singlethreaded runtime only)`
	`17`	`+ public static bool SupportFullGlobalizationData =>`
	`18`	`+ (!PlatformDetection.IsWasi \|\| PlatformDetection.IsHybridGlobalizationOnApplePlatform) && !PlatformDetection.IsWasmThreadingSupported;`
	`19`	`+`
`15`	`20`	`[Theory]`
`16`	`21`	`[InlineData("US", "US", "US")]`
`17`	`22`	`[InlineData("IT", "IT", "IT")]`
`@@ -100,7 +105,6 @@ public void ValidateUsingCasedRegionName(string regionName)`
`100`	`105`	`[Theory]`
`101`	`106`	`[InlineData("en-US", "United States")]`
`102`	`107`	`[OuterLoop("May fail on machines with multiple language packs installed")] // see https://github.com/dotnet/runtime/issues/30132`
`103`		`- [ActiveIssue("https://github.com/dotnet/runtime/issues/45951", TestPlatforms.Browser)]`
`104`	`108`	`public void DisplayName(string name, string expected)`
`105`	`109`	`{`
`106`	`110`	`using (new ThreadCultureChange(null, new CultureInfo(name)))`
`@@ -111,16 +115,14 @@ public void DisplayName(string name, string expected)`
`111`	`115`
`112`	`116`	`public static IEnumerable<object[]> NativeName_TestData()`
`113`	`117`	`{`
`114`		`- // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures`
`115`		`- if (PlatformDetection.IsNotUsingLimitedCultures \|\| PlatformDetection.IsAndroid \|\| PlatformDetection.IsHybridGlobalizationOnApplePlatform)`
	`118`	`+ if (SupportFullGlobalizationData)`
`116`	`119`	`{`
`117`	`120`	`yield return new object[] { "GB", "United Kingdom" };`
`118`	`121`	`yield return new object[] { "SE", "Sverige" };`
`119`	`122`	`yield return new object[] { "FR", "France" };`
`120`	`123`	`}`
`121`	`124`	`else`
`122`	`125`	`{`
`123`		`- // Browser's ICU doesn't contain RegionInfo.NativeName`
`124`	`126`	`yield return new object[] { "GB", "GB" };`
`125`	`127`	`yield return new object[] { "SE", "SE" };`
`126`	`128`	`yield return new object[] { "FR", "FR" };`
`@@ -136,8 +138,7 @@ public void NativeName(string name, string expected)`
`136`	`138`
`137`	`139`	`public static IEnumerable<object[]> EnglishName_TestData()`
`138`	`140`	`{`
`139`		`- // Android has its own ICU, which doesn't 100% map to UsingLimitedCultures`
`140`		`- if (PlatformDetection.IsNotUsingLimitedCultures \|\| PlatformDetection.IsAndroid \|\| PlatformDetection.IsHybridGlobalizationOnApplePlatform)`
	`141`	`+ if (SupportFullGlobalizationData)`
`141`	`142`	`{`
`142`	`143`	`yield return new object[] { "en-US", new string[] { "United States" } };`
`143`	`144`	`yield return new object[] { "US", new string[] { "United States" } };`
`@@ -146,7 +147,6 @@ public static IEnumerable<object[]> EnglishName_TestData()`
`146`	`147`	`}`
`147`	`148`	`else`
`148`	`149`	`{`
`149`		`- // Browser's ICU doesn't contain RegionInfo.EnglishName`
`150`	`150`	`yield return new object[] { "en-US", new string[] { "US" } };`
`151`	`151`	`yield return new object[] { "US", new string[] { "US" } };`
`152`	`152`	`yield return new object[] { "zh-CN", new string[] { "CN" }};`
Original file line number	Diff line number	Diff line change
`@@ -25,9 +25,9 @@ export function normalizeLocale(locale: string \| null)`
`25`	`25`	`const canonicalLocales = (Intl as any).getCanonicalLocales(locale.replace("_", "-"));`
`26`	`26`	`return canonicalLocales.length > 0 ? canonicalLocales[0] : undefined;`
`27`	`27`	`}`
`28`		`- catch(ex: any)`
	`28`	`+ catch`
`29`	`29`	`{`
`30`		- throw new Error(`Get culture info failed for culture = ${locale} with error: ${ex}`);
	`30`	`+ return undefined;`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`