Implement CachedURLResponse.

Simple implementation for CachedURLResponse. The type seems to mostly be
a data container with little behaviour.

Implement the missing equality and hashing for URLResponse, which is
used by CachedURLResponse.

Implement tests for CachedURLResponse and the missing tests for
equality and hashing in URLResponse.

Author: drodriguez

CMakeLists.txt

@@ -432,6 +432,7 @@ if(ENABLE_TESTING)
                          TestFoundation/TestAffineTransform.swift
                          TestFoundation/TestBundle.swift
                          TestFoundation/TestByteCountFormatter.swift
+                         TestFoundation/TestCachedURLResponse.swift
                          TestFoundation/TestCalendar.swift
                          TestFoundation/TestCharacterSet.swift
                          TestFoundation/TestCodable.swift

Foundation/URLCache.swift

@@ -45,11 +45,42 @@ extension URLCache {
 open class CachedURLResponse : NSObject, NSSecureCoding, NSCopying {
 
     public required init?(coder aDecoder: NSCoder) {
-        NSUnimplemented()
+        guard aDecoder.allowsKeyedCoding else {
+            /* Unkeyed unarchiving is not supported. */
+            return nil
+        }
+
+        guard let data = aDecoder.decodeObject(of: NSData.self, forKey: "Data") else {
+            return nil
+        }
+        guard let response = aDecoder.decodeObject(of: URLResponse.self, forKey: "URLResponse") else {
+            return nil
+        }
+        guard let storagePolicyValue = aDecoder.decodeObject(of: NSNumber.self, forKey: "StoragePolicy") else {
+            return nil
+        }
+        guard let storagePolicy = URLCache.StoragePolicy(rawValue: storagePolicyValue.uintValue) else {
+            return nil
+        }
+        let userInfo = aDecoder.decodeObject(of: NSDictionary.self, forKey: "UserInfo")
+
+        self.data = data as Data
+        self.response = response
+        self.storagePolicy = storagePolicy
+        self.userInfo = userInfo?._swiftObject
     }
 
     open func encode(with aCoder: NSCoder) {
-        NSUnimplemented()
+        guard aCoder.allowsKeyedCoding else {
+            fatalError("We do not support saving to a non-keyed coder.")
+        }
+
+        aCoder.encode(data as NSData, forKey: "Data")
+        aCoder.encode(response, forKey: "URLResponse")
+        aCoder.encode(NSNumber(value: storagePolicy.rawValue), forKey: "StoragePolicy")
+        if let userInfo = userInfo {
+            aCoder.encode(userInfo._nsObject, forKey: "UserInfo")
+        }
     }
 
     static public var supportsSecureCoding: Bool {
@@ -61,7 +92,7 @@ open class CachedURLResponse : NSObject, NSSecureCoding, NSCopying {
     }
 
     open func copy(with zone: NSZone? = nil) -> Any {
-        NSUnimplemented()
+        return self
     }
 
     /*!
@@ -76,7 +107,12 @@ open class CachedURLResponse : NSObject, NSSecureCoding, NSCopying {
         corresponding to the given response.
         @result an initialized CachedURLResponse.
     */
-    public init(response: URLResponse, data: Data) { NSUnimplemented() }
+    public init(response: URLResponse, data: Data) {
+        self.response = response.copy() as! URLResponse
+        self.data = data
+        self.userInfo = nil
+        self.storagePolicy = .allowed
+    }
 
     /*! 
         @method initWithResponse:data:userInfo:storagePolicy:
@@ -90,35 +126,69 @@ open class CachedURLResponse : NSObject, NSSecureCoding, NSCopying {
         @param storagePolicy an URLCache.StoragePolicy constant.
         @result an initialized CachedURLResponse.
     */
-    public init(response: URLResponse, data: Data, userInfo: [AnyHashable : Any]? = [:], storagePolicy: URLCache.StoragePolicy) { NSUnimplemented() }
+    public init(response: URLResponse, data: Data, userInfo: [AnyHashable : Any]? = nil, storagePolicy: URLCache.StoragePolicy) {
+        self.response = response.copy() as! URLResponse
+        self.data = data
+        self.userInfo = userInfo
+        self.storagePolicy = storagePolicy
+    }
 
     /*! 
         @method response
         @abstract Returns the response wrapped by this instance. 
         @result The response wrapped by this instance. 
     */
-    /*@NSCopying*/ open var response: URLResponse { NSUnimplemented() }
+    /*@NSCopying*/ open private(set) var response: URLResponse
 
     /*! 
         @method data
         @abstract Returns the data of the receiver. 
         @result The data of the receiver. 
     */
-    /*@NSCopying*/ open var data: Data { NSUnimplemented() }
+    /*@NSCopying*/ open private(set) var data: Data
 
     /*! 
         @method userInfo
         @abstract Returns the userInfo dictionary of the receiver. 
         @result The userInfo dictionary of the receiver. 
     */
-    open var userInfo: [AnyHashable : Any]? { NSUnimplemented() }
+    open private(set) var userInfo: [AnyHashable : Any]?
 
     /*! 
         @method storagePolicy
         @abstract Returns the URLCache.StoragePolicy constant of the receiver.
         @result The URLCache.StoragePolicy constant of the receiver.
     */
-    open var storagePolicy: URLCache.StoragePolicy { NSUnimplemented() }
+    open private(set) var storagePolicy: URLCache.StoragePolicy
+
+    open override func isEqual(_ value: Any?) -> Bool {
+        switch value {
+        case let other as CachedURLResponse:
+            return self.isEqual(to: other)
+        default:
+            return false
+        }
+    }
+
+    private func isEqual(to other: CachedURLResponse) -> Bool {
+        if self === other {
+            return true
+        }
+
+        // We cannot compare userInfo because of the values are Any, which
+        // doesn't conform to Equatable.
+        return self.response == other.response &&
+                self.data == other.data &&
+                self.storagePolicy == other.storagePolicy
+    }
+
+    open override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(response)
+        hasher.combine(data)
+        hasher.combine(storagePolicy)
+        return hasher.finalize()
+    }
 }
 
 open class URLCache : NSObject {

Foundation/URLResponse.swift

@@ -133,6 +133,35 @@ open class URLResponse : NSObject, NSSecureCoding, NSCopying {
     ///
     /// This method always returns a valid filename.
     open fileprivate(set) var suggestedFilename: String?
+
+    open override func isEqual(_ value: Any?) -> Bool {
+        switch value {
+        case let other as URLResponse:
+            return self.isEqual(to: other)
+        default:
+            return false
+        }
+    }
+
+    private func isEqual(to other: URLResponse) -> Bool {
+        if self === other {
+            return true
+        }
+
+        return self.url == other.url &&
+                self.expectedContentLength == other.expectedContentLength &&
+                self.mimeType == other.mimeType &&
+                self.textEncodingName == other.textEncodingName
+    }
+
+    open override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(url)
+        hasher.combine(expectedContentLength)
+        hasher.combine(mimeType)
+        hasher.combine(textEncodingName)
+        return hasher.finalize()
+    }
 }
 
 /// A Response to an HTTP URL load.