Merge pull request #2080 from millenomi/timezone-local

millenomi · web-flow · commit 44de731d5ebe · 2019-04-11T07:06:29.000-07:00
Parity: TimeZone.local, TimeZone.timeZoneDataVersion
diff --git a/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h b/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h
@@ -393,6 +393,7 @@ CF_EXPORT _Nullable CFErrorRef CFWriteStreamCopyError(CFWriteStreamRef _Null_uns
 
 CF_CROSS_PLATFORM_EXPORT CFStringRef _Nullable _CFBundleCopyExecutablePath(CFBundleRef bundle);
 CF_CROSS_PLATFORM_EXPORT Boolean _CFBundleSupportsFHSBundles(void);
+CF_CROSS_PLATFORM_EXPORT CFStringRef __CFTimeZoneCopyDataVersionString(void);
 
 // https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
 // Version 0.8
diff --git a/CoreFoundation/NumberDate.subproj/CFTimeZone.c b/CoreFoundation/NumberDate.subproj/CFTimeZone.c
@@ -1537,4 +1537,8 @@ static CFDictionaryRef __CFTimeZoneCopyCompatibilityDictionary(void) {
     return dict;
 }
 
-
+CF_CROSS_PLATFORM_EXPORT CFStringRef __CFTimeZoneCopyDataVersionString(void) {
+    UErrorCode err = U_ZERO_ERROR;
+    const char *cstr = ucal_getTZDataVersion(&err);
+    return (U_SUCCESS(err)) ? CFStringCreateWithCString(kCFAllocatorSystemDefault, cstr, kCFStringEncodingUTF8) : CFRetain(CFSTR(""));
+}
diff --git a/Foundation/NSTimeZone.swift b/Foundation/NSTimeZone.swift
@@ -178,9 +178,6 @@ open class NSTimeZone : NSObject, NSCopying, NSSecureCoding, NSCoding {
         }
         return Date(timeIntervalSinceReferenceDate: CFTimeZoneGetNextDaylightSavingTimeTransition(_cfObject, aDate.timeIntervalSinceReferenceDate))
     }
-}
-
-extension NSTimeZone {
 
     open class var system: TimeZone {
         return CFTimeZoneCopySystem()._swiftObject
@@ -199,7 +196,9 @@ extension NSTimeZone {
         }
     }
 
-    open class var local: TimeZone { NSUnimplemented() }
+    open class var local: TimeZone {
+        return TimeZone(adoptingReference: __NSLocalTimeZone.shared, autoupdating: true)
+    }
 
     open class var knownTimeZoneNames: [String] {
         guard let knownNames = CFTimeZoneCopyKnownNames() else { return [] }
@@ -212,12 +211,13 @@ extension NSTimeZone {
             return dictionary._nsObject._bridgeToSwift() as! [String : String]
         }
         set {
-            // CFTimeZoneSetAbbreviationDictionary(newValue._cfObject)
-            NSUnimplemented()
+            CFTimeZoneSetAbbreviationDictionary(newValue._cfObject)
         }
     }
 
-    open class var timeZoneDataVersion: String { NSUnimplemented() }
+    open class var timeZoneDataVersion: String {
+        return __CFTimeZoneCopyDataVersionString()._swiftObject
+    }
 
     open var secondsFromGMT: Int {
         let currentDate = Date()
@@ -296,3 +296,53 @@ extension NSTimeZone {
 extension NSNotification.Name {
     public static let NSSystemTimeZoneDidChange = NSNotification.Name(rawValue: kCFTimeZoneSystemTimeZoneDidChangeNotification._swiftObject)
 }
+
+internal class __NSLocalTimeZone: NSTimeZone {
+    static var shared = __NSLocalTimeZone()
+    
+    private init() {
+        super.init(_name: "GMT+0000")
+    }
+    
+    public convenience required init?(coder aDecoder: NSCoder) {
+        // We do not encode details of the local time zone, merely the placeholder object.
+        self.init()
+    }
+    
+    override func encode(with aCoder: NSCoder) {
+        // We do not encode details of the local time zone, merely the placeholder object.
+    }
+    
+    private var system: NSTimeZone {
+        return NSTimeZone.system._nsObject
+    }
+    
+    override var name: String { return system.name }
+    override var data: Data { return system.data }
+    override func secondsFromGMT(for aDate: Date) -> Int {
+        return system.secondsFromGMT(for: aDate)
+    }
+    override func abbreviation(for aDate: Date) -> String? {
+        return system.abbreviation(for: aDate)
+    }
+    override func isDaylightSavingTime(for aDate: Date) -> Bool {
+        return system.isDaylightSavingTime(for: aDate)
+    }
+    override func daylightSavingTimeOffset(for aDate: Date) -> TimeInterval {
+        return system.daylightSavingTimeOffset(for: aDate)
+    
+    }
+    override func nextDaylightSavingTimeTransition(after aDate: Date) -> Date? {
+        return system.nextDaylightSavingTimeTransition(after: aDate)
+    }
+    override func localizedName(_ style: NSTimeZone.NameStyle, locale: Locale?) -> String? {
+        return system.localizedName(style, locale: locale)
+    }
+    override var description: String {
+        return "Local Time Zone (\(system.description))"
+    }
+    
+    override func copy(with zone: NSZone? = nil) -> Any {
+        return self
+    }
+}
diff --git a/Foundation/TimeZone.swift b/Foundation/TimeZone.swift
@@ -49,8 +49,7 @@ public struct TimeZone : Hashable, Equatable, ReferenceConvertible {
     ///
     /// The autoupdating time zone only compares equal to itself.
     public static var autoupdatingCurrent : TimeZone {
-        // swift-corelibs-foundation does not yet support autoupdating, but we can return the current time zone (which will not change).
-        return TimeZone(adoptingReference: __NSTimeZoneAutoupdating(), autoupdating: true)
+        return NSTimeZone.local
     }
     
     // MARK: -
@@ -118,7 +117,7 @@ public struct TimeZone : Hashable, Equatable, ReferenceConvertible {
         }
     }
     
-    private init(adoptingReference reference: NSTimeZone, autoupdating: Bool) {
+    internal init(adoptingReference reference: NSTimeZone, autoupdating: Bool) {
         // this path is only used for types we do not need to copy (we are adopting the ref)
         _wrapped = reference
         _autoupdating = autoupdating
diff --git a/TestFoundation/TestTimeZone.swift b/TestFoundation/TestTimeZone.swift
@@ -10,33 +10,19 @@
 import CoreFoundation
 
 class TestTimeZone: XCTestCase {
-
-    static var allTests: [(String, (TestTimeZone) -> () throws -> Void)] {
-        var tests: [(String, (TestTimeZone) -> () throws -> Void)] = [
-            ("test_abbreviation", test_abbreviation),
-
-            // Disabled because `CFTimeZoneSetAbbreviationDictionary()` attempts
-            // to release non-CF objects while removing values from
-            // `__CFTimeZoneCache`
-            // ("test_abbreviationDictionary", test_abbreviationDictionary),
-
-            ("test_changingDefaultTimeZone", test_changingDefaultTimeZone),
-            ("test_computedPropertiesMatchMethodReturnValues", test_computedPropertiesMatchMethodReturnValues),
-            ("test_initializingTimeZoneWithOffset", test_initializingTimeZoneWithOffset),
-            ("test_initializingTimeZoneWithAbbreviation", test_initializingTimeZoneWithAbbreviation),
-            ("test_localizedName", test_localizedName),
-            ("test_customMirror", test_tz_customMirror),
-            ("test_knownTimeZones", test_knownTimeZones),
-            ("test_systemTimeZoneName", test_systemTimeZoneName),
-        ]
-
-#if !os(Windows)
-      tests.append(contentsOf: [
-            ("test_systemTimeZoneUsesSystemTime", test_systemTimeZoneUsesSystemTime),
-      ])
-#endif
-
-        return tests
+    
+    var initialDefaultTimeZone: TimeZone?
+    
+    override func setUp() {
+        initialDefaultTimeZone = NSTimeZone.default
+        super.setUp()
+    }
+    
+    override func tearDown() {
+        super.tearDown()
+        if let tz = initialDefaultTimeZone {
+            NSTimeZone.default = tz
+        }
     }
 
     func test_abbreviation() {
@@ -220,4 +206,56 @@ class TestTimeZone: XCTestCase {
         XCTAssertEqual(CFStringGetLength(timeZoneName), TimeZone.current.identifier.count)
         XCTAssertEqual(CFStringGetLength(timeZoneName), createdTimeZone.identifier.count)
     }
+    
+    func test_autoupdatingTimeZone() {
+        let system = NSTimeZone.system
+        let date = Date()
+        
+        for zone in [NSTimeZone.local, TimeZone.autoupdatingCurrent] {
+            XCTAssertEqual(zone.identifier, system.identifier)
+            XCTAssertEqual(zone.secondsFromGMT(for: date), system.secondsFromGMT(for: date))
+            XCTAssertEqual(zone.abbreviation(for: date), system.abbreviation(for: date))
+            XCTAssertEqual(zone.isDaylightSavingTime(for: date), system.isDaylightSavingTime(for: date))
+            XCTAssertEqual(zone.daylightSavingTimeOffset(for: date), system.daylightSavingTimeOffset(for: date))
+            XCTAssertEqual(zone.nextDaylightSavingTimeTransition(after: date), system.nextDaylightSavingTimeTransition(after: date))
+            
+            for style in [NSTimeZone.NameStyle.standard,
+                          NSTimeZone.NameStyle.shortStandard,
+                          NSTimeZone.NameStyle.daylightSaving,
+                          NSTimeZone.NameStyle.shortDaylightSaving,
+                          NSTimeZone.NameStyle.generic,
+                          NSTimeZone.NameStyle.shortGeneric,] {
+                XCTAssertEqual(zone.localizedName(for: style, locale: NSLocale.system), system.localizedName(for: style, locale: NSLocale.system), "For style: \(style)")
+            }
+        }
+    }
+    
+    static var allTests: [(String, (TestTimeZone) -> () throws -> Void)] {
+        var tests: [(String, (TestTimeZone) -> () throws -> Void)] = [
+            ("test_abbreviation", test_abbreviation),
+            
+            // Disabled because `CFTimeZoneSetAbbreviationDictionary()` attempts
+            // to release non-CF objects while removing values from
+            // `__CFTimeZoneCache`
+            // ("test_abbreviationDictionary", test_abbreviationDictionary),
+            
+            ("test_changingDefaultTimeZone", test_changingDefaultTimeZone),
+            ("test_computedPropertiesMatchMethodReturnValues", test_computedPropertiesMatchMethodReturnValues),
+            ("test_initializingTimeZoneWithOffset", test_initializingTimeZoneWithOffset),
+            ("test_initializingTimeZoneWithAbbreviation", test_initializingTimeZoneWithAbbreviation),
+            ("test_localizedName", test_localizedName),
+            ("test_customMirror", test_tz_customMirror),
+            ("test_knownTimeZones", test_knownTimeZones),
+            ("test_systemTimeZoneName", test_systemTimeZoneName),
+            ("test_autoupdatingTimeZone", test_autoupdatingTimeZone),
+        ]
+        
+        #if !os(Windows)
+        tests.append(contentsOf: [
+            ("test_systemTimeZoneUsesSystemTime", test_systemTimeZoneUsesSystemTime),
+            ])
+        #endif
+        
+        return tests
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -1537,4 +1537,8 @@ static CFDictionaryRef __CFTimeZoneCopyCompatibilityDictionary(void) {`
`1537`	`1537`	`return dict;`
`1538`	`1538`	`}`
`1539`	`1539`
`1540`		`-`
	`1540`	`+CF_CROSS_PLATFORM_EXPORT CFStringRef __CFTimeZoneCopyDataVersionString(void) {`
	`1541`	`+ UErrorCode err = U_ZERO_ERROR;`
	`1542`	`+ const char *cstr = ucal_getTZDataVersion(&err);`
	`1543`	`+ return (U_SUCCESS(err)) ? CFStringCreateWithCString(kCFAllocatorSystemDefault, cstr, kCFStringEncodingUTF8) : CFRetain(CFSTR(""));`
	`1544`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -49,8 +49,7 @@ public struct TimeZone : Hashable, Equatable, ReferenceConvertible {`
`49`	`49`	`///`
`50`	`50`	`/// The autoupdating time zone only compares equal to itself.`
`51`	`51`	`public static var autoupdatingCurrent : TimeZone {`
`52`		`- // swift-corelibs-foundation does not yet support autoupdating, but we can return the current time zone (which will not change).`
`53`		`- return TimeZone(adoptingReference: __NSTimeZoneAutoupdating(), autoupdating: true)`
	`52`	`+ return NSTimeZone.local`
`54`	`53`	`}`
`55`	`54`
`56`	`55`	`// MARK: -`
`@@ -118,7 +117,7 @@ public struct TimeZone : Hashable, Equatable, ReferenceConvertible {`
`118`	`117`	`}`
`119`	`118`	`}`
`120`	`119`
`121`		`- private init(adoptingReference reference: NSTimeZone, autoupdating: Bool) {`
	`120`	`+ internal init(adoptingReference reference: NSTimeZone, autoupdating: Bool) {`
`122`	`121`	`// this path is only used for types we do not need to copy (we are adopting the ref)`
`123`	`122`	`_wrapped = reference`
`124`	`123`	`_autoupdating = autoupdating`