Use the canonicalized name to create ICU timezone object (#1616)

ICU expects time zone identifiers to be IANA identifiers, such as "America/Los_Angeles". Hence names such as "UTC+9" aren't officially supported.

There is a canonicalization function available, but I did not remember to use it when switching to the new ICU `uatimezone` SPI.

Fix this by always using the canonicalized version to initiate an ICU timezone object.

164490980

Author: itingliu

Sources/FoundationInternationalization/TimeZone/TimeZone_ICU.swift

@@ -108,7 +108,8 @@ internal final class _TimeZoneICU: _TimeZoneProtocol, Sendable {
         }
 
         var status = U_ZERO_ERROR
-        let timeZone : UnsafeMutablePointer<UTimeZone?>? = Array(identifier.utf16).withUnsafeBufferPointer {
+        // Use the already canonicalized `name` instead of `identifier` to initiate ICU time zone
+        let timeZone : UnsafeMutablePointer<UTimeZone?>? = Array(name.utf16).withUnsafeBufferPointer {
             let uatimezone = uatimezone_open($0.baseAddress, Int32($0.count), &status)
             guard status.isSuccess else {
                 return nil

Tests/FoundationInternationalizationTests/CalendarTests.swift

@@ -1436,6 +1436,18 @@ private struct CalendarTests {
         try test(Date(timeIntervalSinceReferenceDate: 731154876), Date(timeIntervalSinceReferenceDate: 731842476))
     }
 
+    @Test func testDateComponentsTimeZone() throws {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = try #require(TimeZone(identifier: "America/Los_Angeles"))
+
+        var components = DateComponents(year:2021, month: 6, day: 10, hour: 23, minute: 59, second: 59)
+        let tz = try #require(TimeZone(identifier: "UTC+9"))
+        components.timeZone = tz
+
+        let date = try #require(calendar.date(from: components))
+        #expect(date.timeIntervalSinceReferenceDate == 645029999)
+    }
+
 #if _pointerBitWidth(_64) // These tests assumes Int is Int64
     @Test func dateFromComponentsOverflow() {
         let calendar = Calendar(identifier: .gregorian)

Tests/FoundationInternationalizationTests/TimeZoneTests.swift

@@ -133,6 +133,9 @@ private struct TimeZoneTests {
         try testAbbreviation("GMT+8:00", 28800, "GMT+0800")
         try testAbbreviation("GMT+0800", 28800, "GMT+0800")
         try testAbbreviation("UTC", 0, "GMT")
+        try testAbbreviation("UTC+9", 32400, "GMT+0900")
+        try testAbbreviation("UTC+9:00", 32400, "GMT+0900")
+        try testAbbreviation("UTC+0900", 32400, "GMT+0900")
     }
 
     @Test func secondsFromGMT_RemoteDates() {
@@ -296,6 +299,40 @@ private struct TimeZoneICUTests {
         try test(.init(year: 2023, month: 11, day: 5, hour: 3, minute: 34, second: 52), expectedRawOffset: -28800, expectedDSTOffset: 0)
     }
 
+    @Test func names_rawAndDaylightSavingTimeOffset() throws {
+        var gmt_calendar = Calendar(identifier: .gregorian)
+        gmt_calendar.timeZone = .gmt
+
+        func test(_ identifier: String, _ dateComponent: DateComponents, expectedRawOffset: Int, expectedDSTOffset: TimeInterval, sourceLocation: SourceLocation = #_sourceLocation) throws {
+            let tz = try #require(_TimeZoneICU(identifier: identifier))
+            let d = try #require(gmt_calendar.date(from: dateComponent)) // date in GMT
+            let (rawOffset, dstOffset) = tz.rawAndDaylightSavingTimeOffset(for: d)
+            #expect(rawOffset == expectedRawOffset, sourceLocation: sourceLocation)
+            #expect(dstOffset == expectedDSTOffset, sourceLocation: sourceLocation)
+        }
+
+        // PST
+        // Not in DST
+        try test("PST", .init(year: 2023, month: 3, day: 12, hour: 1, minute: 00, second: 00), expectedRawOffset: -28800, expectedDSTOffset: 0)
+        // These times do not exist; we treat it as if in the previous time zone, i.e. not in DST
+        try test("PST", .init(year: 2023, month: 3, day: 12, hour: 2, minute: 00, second: 00), expectedRawOffset: -28800, expectedDSTOffset: 0)
+        // After DST starts
+        try test("PST", .init(year: 2023, month: 3, day: 12, hour: 3, minute: 00, second: 00), expectedRawOffset: -28800, expectedDSTOffset: 3600)
+        // These times happen twice; we treat it as if in the previous time zone, i.e. still in DST
+        try test("PST", .init(year: 2023, month: 11, day: 5, hour: 1, minute: 00, second: 00), expectedRawOffset: -28800, expectedDSTOffset: 3600)
+        // Clock should turn right back as this moment, so if we insist on being at this point, then we've moved past the transition point -- hence not DST
+        try test("PST", .init(year: 2023, month: 11, day: 5, hour: 2, minute: 00, second: 00), expectedRawOffset: -28800, expectedDSTOffset: 0)
+        // Not in DST
+        try test("PST", .init(year: 2023, month: 11, day: 5, hour: 2, minute: 34, second: 52), expectedRawOffset: -28800, expectedDSTOffset: 0)
+
+        // JST: not in DST
+        let dc = DateComponents(year: 2023, month: 3, day: 12, hour: 1, minute: 00, second: 00)
+        try test("JST", dc, expectedRawOffset: 32400, expectedDSTOffset: 0)
+        try test("UTC+9", dc, expectedRawOffset: 32400, expectedDSTOffset: 0)
+        try test("UTC+0900", dc, expectedRawOffset: 32400, expectedDSTOffset: 0)
+        try test("UTC+9:00", dc, expectedRawOffset: 32400, expectedDSTOffset: 0)
+        try test("GMT+9", dc, expectedRawOffset: 32400, expectedDSTOffset: 0)
+    }
 }
 // MARK: - FoundationPreview disabled tests