[6.2] swift-testing test fixes (swiftlang#1441)

jmschonfeld · web-flow · commit d707b2fc4a5f · 2025-07-17T10:42:30.000-07:00
* Prevent decimal_withFormat_localeDependent from relying on the current locale (swiftlang#1428) * Update stringshims to always use clocale (swiftlang#1427)
diff --git a/Sources/FoundationEssentials/JSON/JSON5Scanner.swift b/Sources/FoundationEssentials/JSON/JSON5Scanner.swift
@@ -1081,7 +1081,7 @@ extension JSON5Scanner {
             jsonBytes.formIndex(after: &index)
         }
 
-        let cmp = jsonBytes[index..<endIndex].prefix(2).withUnsafePointer({ _stringshims_strncasecmp_l($0, "0x", $1, nil) })
+        let cmp = jsonBytes[index..<endIndex].prefix(2).withUnsafePointer({ _stringshims_strncasecmp_clocale($0, "0x", $1) })
         if cmp == 0 {
             jsonBytes.formIndex(&index, offsetBy: 2)
 
diff --git a/Sources/FoundationEssentials/JSON/JSONScanner.swift b/Sources/FoundationEssentials/JSON/JSONScanner.swift
@@ -1179,7 +1179,7 @@ extension Double : PrevalidatedJSONNumberBufferConvertible {
     init?(prevalidatedBuffer buffer: BufferView<UInt8>) {
         let decodedValue = buffer.withUnsafePointer { nptr, count -> Double? in
             var endPtr: UnsafeMutablePointer<CChar>? = nil
-            let decodedValue = _stringshims_strtod_l(nptr, &endPtr, nil)
+            let decodedValue = _stringshims_strtod_clocale(nptr, &endPtr)
             if let endPtr, nptr.advanced(by: count) == endPtr {
                 return decodedValue
             } else {
@@ -1195,7 +1195,7 @@ extension Float : PrevalidatedJSONNumberBufferConvertible {
     init?(prevalidatedBuffer buffer: BufferView<UInt8>) {
         let decodedValue = buffer.withUnsafePointer { nptr, count -> Float? in
             var endPtr: UnsafeMutablePointer<CChar>? = nil
-            let decodedValue = _stringshims_strtof_l(nptr, &endPtr, nil)
+            let decodedValue = _stringshims_strtof_clocale(nptr, &endPtr)
             if let endPtr, nptr.advanced(by: count) == endPtr {
                 return decodedValue
             } else {
diff --git a/Sources/FoundationEssentials/PropertyList/PlistDecoder.swift b/Sources/FoundationEssentials/PropertyList/PlistDecoder.swift
@@ -231,7 +231,7 @@ open class PropertyListDecoder {
         }
         
         return try buffer[unchecked: baseIdx..<idx].withUnsafePointer { ptr, encodingLength in
-            if encodingLength == 5, _stringshims_strncasecmp_l(ptr, "utf-8", 5, nil) == 0 {
+            if encodingLength == 5, _stringshims_strncasecmp_clocale(ptr, "utf-8", 5) == 0 {
                 return .utf8
             }
             
diff --git a/Sources/FoundationEssentials/PropertyList/XMLPlistScanner.swift b/Sources/FoundationEssentials/PropertyList/XMLPlistScanner.swift
@@ -645,7 +645,7 @@ extension XMLPlistMap.Value {
                     return .nan
                 }
             case (UInt8(ascii: "+"), 9):
-                if _stringshims_strncasecmp_l(buf.baseAddress, "+infinity", 9, nil) == 0 {
+                if _stringshims_strncasecmp_clocale(buf.baseAddress, "+infinity", 9) == 0 {
                     return .infinity
                 }
             case (UInt8(ascii: "+"), 4):
@@ -655,7 +655,7 @@ extension XMLPlistMap.Value {
                     return .infinity
                 }
             case (UInt8(ascii: "-"), 9):
-                if _stringshims_strncasecmp_l(buf.baseAddress, "-infinity", 9, nil) == 0 {
+                if _stringshims_strncasecmp_clocale(buf.baseAddress, "-infinity", 9) == 0 {
                     return .infinity * -1
                 }
             case (UInt8(ascii: "-"), 4):
@@ -665,7 +665,7 @@ extension XMLPlistMap.Value {
                     return .infinity * -1
                 }
             case (UInt8(ascii: "i"), 8), (UInt8(ascii: "I"), 8):
-                if _stringshims_strncasecmp_l(buf.baseAddress, "infinity", 8, nil) == 0 {
+                if _stringshims_strncasecmp_clocale(buf.baseAddress, "infinity", 8) == 0 {
                     return .infinity
                 }
             case (.none, 0):
@@ -728,9 +728,9 @@ extension XMLPlistMap.Value {
                 var parseEndPtr : UnsafeMutablePointer<CChar>?
                 let res : T
                 if MemoryLayout<T>.size == MemoryLayout<Float>.size {
-                    res = T(_stringshims_strtof_l(ptr, &parseEndPtr, nil))
+                    res = T(_stringshims_strtof_clocale(ptr, &parseEndPtr))
                 } else if MemoryLayout<T>.size == MemoryLayout<Double>.size {
-                    res = T(_stringshims_strtod_l(ptr, &parseEndPtr, nil))
+                    res = T(_stringshims_strtod_clocale(ptr, &parseEndPtr))
                 } else {
                     preconditionFailure("Only Float and Double are currently supported by PropertyListDecoder, not \(type))")
                 }
diff --git a/Sources/_FoundationCShims/include/string_shims.h b/Sources/_FoundationCShims/include/string_shims.h
@@ -37,11 +37,11 @@ extern "C" {
 #define locale_t void *
 #endif
 
-INTERNAL int _stringshims_strncasecmp_l(const char * _Nullable s1, const char * _Nullable s2, size_t n, locale_t _Nullable loc);
+INTERNAL int _stringshims_strncasecmp_clocale(const char * _Nullable s1, const char * _Nullable s2, size_t n);
 
-INTERNAL double _stringshims_strtod_l(const char * _Nullable __restrict nptr, char * _Nullable * _Nullable __restrict endptr, locale_t _Nullable loc);
+INTERNAL double _stringshims_strtod_clocale(const char * _Nullable __restrict nptr, char * _Nullable * _Nullable __restrict endptr);
 
-INTERNAL float _stringshims_strtof_l(const char * _Nullable __restrict nptr, char * _Nullable * _Nullable __restrict endptr, locale_t _Nullable loc);
+INTERNAL float _stringshims_strtof_clocale(const char * _Nullable __restrict nptr, char * _Nullable * _Nullable __restrict endptr);
 
 #define _STRINGSHIMS_MACROMAN_MAP_SIZE 129
 INTERNAL const uint8_t _stringshims_macroman_mapping[_STRINGSHIMS_MACROMAN_MAP_SIZE][3];
diff --git a/Sources/_FoundationCShims/string_shims.c b/Sources/_FoundationCShims/string_shims.c
@@ -23,80 +23,75 @@
 #include <strings.h>
 #endif
 
-int _stringshims_strncasecmp_l(const char * _Nullable s1,
-                      const char * _Nullable s2,
-                      size_t n,
-                      locale_t _Nullable loc)
-{
 #if TARGET_OS_WINDOWS
-  static _locale_t storage;
-  static _locale_t *cloc = NULL;
-  if (cloc == NULL) {
-    storage = _create_locale(LC_ALL, "C");
-    cloc = &storage;
-  }
-  return _strnicmp_l(s1, s2, n, loc ? loc : *cloc);
-#else
-    if (loc != NULL) {
-#if (defined(TARGET_OS_EXCLAVEKIT) && TARGET_OS_EXCLAVEKIT) || \
-      (defined(TARGET_OS_ANDROID) && TARGET_OS_ANDROID && __ANDROID_API__ < 23)
-        abort();
+#define FOUNDATION_C_LOCALE (_clocale())
+static _locale_t _clocale() {
+    static _locale_t storage;
+    static bool once = false;
+    if (!once) {
+        storage = _create_locale(LC_ALL, "C");
+        once = true;
+    }
+    return storage;
+}
+#elif TARGET_OS_MAC
+#define FOUNDATION_C_LOCALE LC_C_LOCALE
 #else
-        return strncasecmp_l(s1, s2, n, loc);
-#endif
+#define FOUNDATION_C_LOCALE (_clocale())
+static locale_t _clocale() {
+    static locale_t storage;
+    static bool once = false;
+    if (!once) {
+        storage = newlocale(LC_ALL_MASK, "C", (locale_t)0);
+        once = true;
     }
-    // On Darwin, NULL loc means unlocalized compare.
-    // Uses the standard C locale for Linux in this case
-#if (defined(TARGET_OS_EXCLAVEKIT) && TARGET_OS_EXCLAVEKIT) || \
+    return storage;
+}
+#endif
+
+
+int _stringshims_strncasecmp_clocale(const char * _Nullable s1,
+                      const char * _Nullable s2,
+                      size_t n)
+{
+#if TARGET_OS_WINDOWS
+    return _strnicmp_l(s1, s2, n, FOUNDATION_C_LOCALE);
+#elif (defined(TARGET_OS_EXCLAVEKIT) && TARGET_OS_EXCLAVEKIT) || \
       (defined(TARGET_OS_ANDROID) && TARGET_OS_ANDROID && __ANDROID_API__ < 23)
     return strncasecmp(s1, s2, n);
-#elif TARGET_OS_MAC
-    return strncasecmp_l(s1, s2, n, NULL);
 #else
-    locale_t clocale = newlocale(LC_ALL_MASK, "C", (locale_t)0);
-    return strncasecmp_l(s1, s2, n, clocale);
-#endif // TARGET_OS_MAC
-#endif // TARGET_OS_WINDOWS
+    return strncasecmp_l(s1, s2, n, FOUNDATION_C_LOCALE);
+#endif
 }
 
-double _stringshims_strtod_l(const char * _Nullable restrict nptr,
-                 char * _Nullable * _Nullable restrict endptr,
-                 locale_t _Nullable loc)
+double _stringshims_strtod_clocale(const char * _Nullable restrict nptr,
+                 char * _Nullable * _Nullable restrict endptr)
 {
-#if defined(TARGET_OS_EXCLAVEKIT) && TARGET_OS_EXCLAVEKIT
-    assert(loc == NULL);
-    return strtod_l(nptr, endptr, NULL);
-#elif TARGET_OS_MAC
-    return strtod_l(nptr, endptr, loc);
+#if TARGET_OS_MAC
+    return strtod_l(nptr, endptr, FOUNDATION_C_LOCALE);
 #elif TARGET_OS_WINDOWS
-    return _strtod_l(nptr, endptr, loc);
+    return _strtod_l(nptr, endptr, FOUNDATION_C_LOCALE);
 #else
     // Use the C locale
-    locale_t clocale = newlocale(LC_ALL_MASK, "C", (locale_t)0);
-    locale_t oldLocale = uselocale(clocale);
+    locale_t oldLocale = uselocale(FOUNDATION_C_LOCALE);
     double result = strtod(nptr, endptr);
     // Restore locale
     uselocale(oldLocale);
     return result;
 #endif
 }
 
-float _stringshims_strtof_l(const char * _Nullable restrict nptr,
-                 char * _Nullable * _Nullable restrict endptr,
-                 locale_t _Nullable loc)
+float _stringshims_strtof_clocale(const char * _Nullable restrict nptr,
+                 char * _Nullable * _Nullable restrict endptr)
 {
-#if defined(TARGET_OS_EXCLAVEKIT) && TARGET_OS_EXCLAVEKIT
-    assert(loc == NULL);
-    return strtof_l(nptr, endptr, NULL);
-#elif TARGET_OS_MAC
-    return strtof_l(nptr, endptr, loc);
+#if TARGET_OS_MAC
+    return strtof_l(nptr, endptr, FOUNDATION_C_LOCALE);
 #elif TARGET_OS_WINDOWS
-    return _strtof_l(nptr, endptr, loc);
+    return _strtof_l(nptr, endptr, FOUNDATION_C_LOCALE);
 #else
     // Use the C locale
-    locale_t clocale = newlocale(LC_ALL_MASK, "C", (locale_t)0);
-    locale_t oldLocale = uselocale(clocale);
-    float result = strtof(nptr, endptr);
+    locale_t oldLocale = uselocale(FOUNDATION_C_LOCALE);
+    double result = strtof(nptr, endptr);
     // Restore locale
     uselocale(oldLocale);
     return result;
diff --git a/Tests/FoundationInternationalizationTests/Formatting/NumberParseStrategyTests.swift b/Tests/FoundationInternationalizationTests/Formatting/NumberParseStrategyTests.swift
@@ -430,24 +430,21 @@ private struct NumberExtensionParseStrategyTests {
     }
 
     @Test func decimal_withFormat_localeDependent() throws {
-        guard Locale.autoupdatingCurrent.identifier == "en_US" else {
-            print("Your current locale is \(Locale.autoupdatingCurrent). Set it to en_US to run this test")
-            return
-        }
-        #expect(try Decimal("-3,000.14159", format: .number) == Decimal(-3000.14159))
-        #expect(try Decimal("-3.14159", format: .number) == Decimal(-3.14159))
-        #expect(try Decimal("12,345.678", format: .number) == Decimal(12345.678))
-        #expect(try Decimal("0.00", format: .number) == 0)
-
-        #expect(try Decimal("-3,000.14159%", format: .percent) == Decimal(-30.0014159))
-        #expect(try Decimal("-314.159%", format: .percent) == Decimal(-3.14159))
-        #expect(try Decimal("12,345.678%", format: .percent) == Decimal(123.45678))
-        #expect(try Decimal("0.00%", format: .percent) == 0)
-
-        #expect(try Decimal("$12,345.00", format: .currency(code: "USD")) == Decimal(12345))
-        #expect(try Decimal("$12345.68", format: .currency(code: "USD")) == Decimal(12345.68))
-        #expect(try Decimal("$0.00", format: .currency(code: "USD")) == Decimal(0))
-        #expect(try Decimal("-$3000.0000014", format: .currency(code: "USD")) == Decimal(string: "-3000.0000014")!)
+        let locale = Locale(identifier: "en_US")
+        #expect(try Decimal("-3,000.14159", format: .number.locale(locale)) == Decimal(-3000.14159))
+        #expect(try Decimal("-3.14159", format: .number.locale(locale)) == Decimal(-3.14159))
+        #expect(try Decimal("12,345.678", format: .number.locale(locale)) == Decimal(12345.678))
+        #expect(try Decimal("0.00", format: .number.locale(locale)) == 0)
+
+        #expect(try Decimal("-3,000.14159%", format: .percent.locale(locale)) == Decimal(-30.0014159))
+        #expect(try Decimal("-314.159%", format: .percent.locale(locale)) == Decimal(-3.14159))
+        #expect(try Decimal("12,345.678%", format: .percent.locale(locale)) == Decimal(123.45678))
+        #expect(try Decimal("0.00%", format: .percent.locale(locale)) == 0)
+
+        #expect(try Decimal("$12,345.00", format: .currency(code: "USD").locale(locale)) == Decimal(12345))
+        #expect(try Decimal("$12345.68", format: .currency(code: "USD").locale(locale)) == Decimal(12345.68))
+        #expect(try Decimal("$0.00", format: .currency(code: "USD").locale(locale)) == Decimal(0))
+        #expect(try Decimal("-$3000.0000014", format: .currency(code: "USD").locale(locale)) == Decimal(string: "-3000.0000014")!)
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1081,7 +1081,7 @@ extension JSON5Scanner {`
`1081`	`1081`	`jsonBytes.formIndex(after: &index)`
`1082`	`1082`	`}`
`1083`	`1083`
`1084`		`- let cmp = jsonBytes[index..<endIndex].prefix(2).withUnsafePointer({ _stringshims_strncasecmp_l($0, "0x", $1, nil) })`
	`1084`	`+ let cmp = jsonBytes[index..<endIndex].prefix(2).withUnsafePointer({ _stringshims_strncasecmp_clocale($0, "0x", $1) })`
`1085`	`1085`	`if cmp == 0 {`
`1086`	`1086`	`jsonBytes.formIndex(&index, offsetBy: 2)`
`1087`	`1087`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ open class PropertyListDecoder {`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`return try buffer[unchecked: baseIdx..<idx].withUnsafePointer { ptr, encodingLength in`
`234`		`- if encodingLength == 5, _stringshims_strncasecmp_l(ptr, "utf-8", 5, nil) == 0 {`
	`234`	`+ if encodingLength == 5, _stringshims_strncasecmp_clocale(ptr, "utf-8", 5) == 0 {`
`235`	`235`	`return .utf8`
`236`	`236`	`}`
`237`	`237`
Original file line number	Diff line number	Diff line change
`@@ -645,7 +645,7 @@ extension XMLPlistMap.Value {`
`645`	`645`	`return .nan`
`646`	`646`	`}`
`647`	`647`	`case (UInt8(ascii: "+"), 9):`
`648`		`- if _stringshims_strncasecmp_l(buf.baseAddress, "+infinity", 9, nil) == 0 {`
	`648`	`+ if _stringshims_strncasecmp_clocale(buf.baseAddress, "+infinity", 9) == 0 {`
`649`	`649`	`return .infinity`
`650`	`650`	`}`
`651`	`651`	`case (UInt8(ascii: "+"), 4):`
`@@ -655,7 +655,7 @@ extension XMLPlistMap.Value {`
`655`	`655`	`return .infinity`
`656`	`656`	`}`
`657`	`657`	`case (UInt8(ascii: "-"), 9):`
`658`		`- if _stringshims_strncasecmp_l(buf.baseAddress, "-infinity", 9, nil) == 0 {`
	`658`	`+ if _stringshims_strncasecmp_clocale(buf.baseAddress, "-infinity", 9) == 0 {`
`659`	`659`	`return .infinity * -1`
`660`	`660`	`}`
`661`	`661`	`case (UInt8(ascii: "-"), 4):`
`@@ -665,7 +665,7 @@ extension XMLPlistMap.Value {`
`665`	`665`	`return .infinity * -1`
`666`	`666`	`}`
`667`	`667`	`case (UInt8(ascii: "i"), 8), (UInt8(ascii: "I"), 8):`
`668`		`- if _stringshims_strncasecmp_l(buf.baseAddress, "infinity", 8, nil) == 0 {`
	`668`	`+ if _stringshims_strncasecmp_clocale(buf.baseAddress, "infinity", 8) == 0 {`
`669`	`669`	`return .infinity`
`670`	`670`	`}`
`671`	`671`	`case (.none, 0):`
`@@ -728,9 +728,9 @@ extension XMLPlistMap.Value {`
`728`	`728`	`var parseEndPtr : UnsafeMutablePointer<CChar>?`
`729`	`729`	`let res : T`
`730`	`730`	`if MemoryLayout<T>.size == MemoryLayout<Float>.size {`
`731`		`- res = T(_stringshims_strtof_l(ptr, &parseEndPtr, nil))`
	`731`	`+ res = T(_stringshims_strtof_clocale(ptr, &parseEndPtr))`
`732`	`732`	`} else if MemoryLayout<T>.size == MemoryLayout<Double>.size {`
`733`		`- res = T(_stringshims_strtod_l(ptr, &parseEndPtr, nil))`
	`733`	`+ res = T(_stringshims_strtod_clocale(ptr, &parseEndPtr))`
`734`	`734`	`} else {`
`735`	`735`	`preconditionFailure("Only Float and Double are currently supported by PropertyListDecoder, not \(type))")`
`736`	`736`	`}`