diff --git a/Foundation/Data.swift b/Foundation/Data.swift
index dcade3c551..f5eab2cfed 100644
--- a/Foundation/Data.swift
+++ b/Foundation/Data.swift
@@ -73,56 +73,15 @@ internal final class _SwiftNSData : NSData, _SwiftNativeFoundationType {
         releaseWrappedObject()
     }
     
-    // Stubs
-    // -----
-    
+    // MARK: - Funnel overrides
     override var length : Int {
         get {
             return _mapUnmanaged { $0.length }
         }
     }
-    
     override var bytes : UnsafeRawPointer {
         return _mapUnmanaged { $0.bytes }
     }
-    
-//    override func subdata(with range: NSRange) -> Data {
-//        return _mapUnmanaged { $0.subdata(with: range) }
-//    }
-//    
-//    override func getBytes(_ buffer: UnsafeMutableRawPointer, length: Int) {
-//        return _mapUnmanaged { $0.getBytes(buffer, length: length) }
-//    }
-//    
-//    override func getBytes(_ buffer: UnsafeMutableRawPointer, range: NSRange) {
-//        return _mapUnmanaged { $0.getBytes(buffer, range: range) }
-//    }
-//    
-//    override func isEqual(to other: Data) -> Bool {
-//        return _mapUnmanaged { return $0.isEqual(to: other) }
-//    }
-//    
-//    override func write(to url: URL, options: Data.WritingOptions) throws {
-//        return try _mapUnmanaged { try $0.write(to: url, options: options) }
-//    }
-//    
-//    override func range(of data: Data, options: Data.SearchOptions, range: NSRange) -> NSRange {
-//        return _mapUnmanaged {
-//            $0.range(of: data, options: options, in: range)
-//        }
-//    }
-//    
-//    override func enumerateByteRanges(using block: (UnsafeRawPointer, NSRange, UnsafeMutablePointer<ObjCBool>) -> Void) {
-//        return _mapUnmanaged { $0.enumerateBytes(block) }
-//    }
-//    
-//    override func base64EncodedString(options: Data.Base64EncodingOptions) -> String {
-//        return _mapUnmanaged { $0.base64EncodedString(options) }
-//    }
-//    
-//    override func base64EncodedData(options: Data.Base64EncodingOptions) -> Data {
-//        return _mapUnmanaged { $0.base64EncodedData(options) }
-//    }
 }
 
 /**
@@ -197,10 +156,17 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
         _wrapped = _SwiftNSData(immutableObject: NSData(bytes: buffer.baseAddress, length: MemoryLayout<SourceType>.stride * buffer.count))
     }
     
+    /// Initialize a `Data` with copied memory content.
+    ///
+    /// - parameter buffer: A buffer pointer to copy. The size is calculated from `SourceType` and `buffer.count`.
+    public init<SourceType>(buffer: UnsafeMutableBufferPointer<SourceType>) {
+        _wrapped = _SwiftNSData(immutableObject: NSData(bytes: UnsafePointer(buffer.baseAddress), length: MemoryLayout<SourceType>.stride * buffer.count))
+    }
+    
     /// Initialize a `Data` with the contents of an Array.
     ///
     /// - parameter bytes: An array of bytes to copy.
-    public init(bytes: Array<UInt8>) {
+    public init(bytes: [UInt8]) {
         _wrapped = bytes.withUnsafeBufferPointer {
             return _SwiftNSData(immutableObject: NSData(bytes: $0.baseAddress, length: $0.count))
         }
@@ -226,7 +192,7 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
     /// - parameter capacity: The size of the data.
     public init(capacity: Int) {
         if let d = NSMutableData(capacity: capacity) {
-            _wrapped = _SwiftNSData(immutableObject: d)
+            _wrapped = _SwiftNSData(mutableObject: d)
         } else {
             fatalError("Unable to allocate data of the requested capacity")
         }
@@ -261,7 +227,7 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
     ///
     /// Returns nil when the input is not recognized as valid Base-64.
     /// - parameter base64String: The string to parse.
-    /// - parameter options: Decoding options. Default value is `[]`.
+    /// - parameter options: Encoding options. Default value is `[]`.
     public init?(base64Encoded base64String: String, options: Data.Base64DecodingOptions = []) {
         if let d = NSData(base64Encoded: base64String, options: Base64DecodingOptions(rawValue: options.rawValue)) {
             _wrapped = _SwiftNSData(immutableObject: d)
@@ -288,16 +254,24 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
     ///
     /// - parameter count: The number of bytes the data initially contains.
     public init(count: Int) {
-        if let memory = calloc(1, count)?.bindMemory(to: UInt8.self, capacity: count) {
-            self.init(bytesNoCopy: memory, count: count, deallocator: .free)
+        if let d = NSMutableData(length: count) {
+            _wrapped = _SwiftNSData(mutableObject: d)
         } else {
             fatalError("Unable to allocate data of the requested count")
         }
     }
+
     
-    internal init(_bridged data: NSData) {
-        // We must copy the input because it might be mutable; just like storing a value type in ObjC
-        _wrapped = _SwiftNSData(immutableObject: data.copy() as! NSObject)
+    /// Initialize a `Data` by adopting a reference type.
+    ///
+    /// You can use this initializer to create a `struct Data` that wraps a `class NSData`. `struct Data` will use the `class NSData` for all operations. Other initializers (including casting using `as Data`) may choose to hold a reference or not, based on a what is the most efficient representation.
+    ///
+    /// If the resulting value is mutated, then `Data` will invoke the `mutableCopy()` function on the reference to copy the contents. You may customize the behavior of that function if you wish to return a specialized mutable subclass.
+    ///
+    /// - parameter reference: The instance of `NSData` that you wish to wrap. This instance will be copied by `struct Data`.
+    public init(referencing reference: NSData) {
+        // NOTE: don't fix this warning on Darwin -- linux will complain
+        _wrapped = _SwiftNSData(immutableObject: reference.copy() as! AnyObject)
     }
     
     // -----------------------------------
@@ -356,7 +330,7 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
         _mapUnmanaged { $0.getBytes(pointer, length: count) }
     }
     
-    private func _copyBytesHelper(to pointer: UnsafeMutableRawPointer, from range: NSRange) {
+    private func _copyBytesHelper(to pointer: UnsafeMutablePointer<UInt8>, from range: NSRange) {
         _mapUnmanaged { $0.getBytes(pointer, range: range) }
     }
     
@@ -366,7 +340,7 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
     /// - parameter range: The range in the `Data` to copy.
     /// - warning: This method does not verify that the contents at pointer have enough space to hold the required number of bytes.
     public func copyBytes(to pointer: UnsafeMutablePointer<UInt8>, from range: Range<Index>) {
-        _copyBytesHelper(to: pointer, from: NSRange(location: range.lowerBound, length: range.upperBound - range.lowerBound))
+        _copyBytesHelper(to: pointer, from: NSRange(range))
     }
     
     /// Copy the contents of the data into a buffer.
@@ -397,8 +371,10 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
         guard !copyRange.isEmpty else { return 0 }
         
         let nsRange = NSMakeRange(copyRange.lowerBound, copyRange.upperBound - copyRange.lowerBound)
-        let pointer = UnsafeMutableRawPointer(buffer.baseAddress!)
-        _copyBytesHelper(to: pointer, from: nsRange)
+        let ptr = buffer.baseAddress!
+        ptr.withMemoryRebound(to: UInt8.self, capacity: buffer.count) {
+            _copyBytesHelper(to: $0, from: nsRange)
+        }
         return copyRange.count
     }
     
@@ -499,10 +475,13 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
     
     /// Replace a region of bytes in the data with new data.
     ///
-    /// - parameter range: The range in the data to replace.
+    /// This will resize the data if required, to fit the entire contents of `data`.
+    ///
+    /// - precondition: The bounds of `subrange` must be valid indices of the collection.
+    /// - parameter subrange: The range in the data to replace. If `subrange.lowerBound == data.count && subrange.count == 0` then this operation is an append.
     /// - parameter data: The replacement data.
-    public mutating func replaceBytes(in range: Range<Index>, with data: Data) {
-        let nsRange = NSMakeRange(range.lowerBound, range.upperBound - range.lowerBound)
+    public mutating func replaceSubrange(_ subrange: Range<Index>, with data: Data) {
+        let nsRange = NSMakeRange(subrange.lowerBound, subrange.upperBound - subrange.lowerBound)
         let cnt = data.count
         let bytes = data._getUnsafeBytesPointer()
         
@@ -511,6 +490,68 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
         }
     }
     
+    /// Replace a region of bytes in the data with new bytes from a buffer.
+    ///
+    /// This will resize the data if required, to fit the entire contents of `buffer`.
+    ///
+    /// - precondition: The bounds of `subrange` must be valid indices of the collection.
+    /// - parameter subrange: The range in the data to replace.
+    /// - parameter buffer: The replacement bytes.
+    public mutating func replaceSubrange<SourceType>(_ subrange: Range<Index>, with buffer: UnsafeBufferPointer<SourceType>) {
+        let nsRange = NSMakeRange(subrange.lowerBound, subrange.upperBound - subrange.lowerBound)
+        let bufferCount = buffer.count * MemoryLayout<SourceType>.stride
+        
+        _applyUnmanagedMutation {
+            $0.replaceBytes(in: nsRange, withBytes: buffer.baseAddress!, length: bufferCount)
+        }
+        
+    }
+    
+    /// Replace a region of bytes in the data with new bytes from a collection.
+    ///
+    /// This will resize the data if required, to fit the entire contents of `newElements`.
+    ///
+    /// - precondition: The bounds of `subrange` must be valid indices of the collection.
+    /// - parameter subrange: The range in the data to replace.
+    /// - parameter newElements: The replacement bytes.
+    public mutating func replaceSubrange<ByteCollection : Collection>(_ subrange: Range<Index>, with newElements: ByteCollection) where ByteCollection.Iterator.Element == Data.Iterator.Element  {
+        
+        // Calculate this once, it may not be O(1)
+        let replacementCount : Int = numericCast(newElements.count)
+        let currentCount = self.count
+        let subrangeCount = subrange.count
+        
+        if currentCount < subrange.lowerBound + subrangeCount {
+            if subrangeCount == 0 {
+                preconditionFailure("location \(subrange.lowerBound) exceeds data count \(currentCount)")
+            } else {
+                preconditionFailure("range \(subrange) exceeds data count \(currentCount)")
+            }
+        }
+        
+        let resultCount = currentCount - subrangeCount + replacementCount
+        if resultCount != currentCount {
+            // This may realloc.
+            // In the future, if we keep the malloced pointer and count inside this struct/ref instead of deferring to NSData, we may be able to do this more efficiently.
+            self.count = resultCount
+        }
+        
+        let shift = resultCount - currentCount
+        let start = subrange.lowerBound
+        
+        self.withUnsafeMutableBytes { (bytes : UnsafeMutablePointer<UInt8>) -> () in
+            if shift != 0 {
+                let destination = bytes + start + replacementCount
+                let source = bytes + start + subrangeCount
+                memmove(destination, source, currentCount - start - subrangeCount)
+            }
+            
+            if replacementCount != 0 {
+                newElements._copyContents(initializing: bytes + start)
+            }
+        }
+    }
+    
     /// Return a new copy of the data in a specified range.
     ///
     /// - parameter range: The range to copy.
@@ -526,16 +567,16 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
     ///
     /// - parameter options: The options to use for the encoding. Default value is `[]`.
     /// - returns: The Base-64 encoded string.
-    public func base64EncodedString(_ options: Data.Base64EncodingOptions = []) -> String {
-        return _mapUnmanaged { $0.base64EncodedString(options) }
+    public func base64EncodedString(options: Data.Base64EncodingOptions = []) -> String {
+        return _mapUnmanaged { $0.base64EncodedString(options: options) }
     }
     
     /// Returns a Base-64 encoded `Data`.
     ///
     /// - parameter options: The options to use for the encoding. Default value is `[]`.
     /// - returns: The Base-64 encoded data.
-    public func base64EncodedData(_ options: Data.Base64EncodingOptions = []) -> Data {
-        return _mapUnmanaged { $0.base64EncodedData(options) }
+    public func base64EncodedData(options: Data.Base64EncodingOptions = []) -> Data {
+        return _mapUnmanaged { $0.base64EncodedData(options: options) }
     }
     
     // MARK: -
@@ -556,7 +597,6 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
         return _mapUnmanaged { $0.debugDescription }
     }
     
-    // MARK: -
     
     // MARK: -
     // MARK: Index and Subscript
@@ -577,20 +617,12 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
         }
     }
     
-    public subscript(bounds: Range<Int>) -> MutableRandomAccessSlice<Data> {
+    public subscript(bounds: Range<Index>) -> MutableRandomAccessSlice<Data> {
         get {
             return MutableRandomAccessSlice(base: self, bounds: bounds)
         }
         set {
-            // Ideally this would be:
-            //   replaceBytes(in: bounds, with: newValue._base)
-            // but we do not have access to _base due to 'internal' protection
-            // TODO: Use a custom Slice type so we have access to the underlying data
-            let arrayOfBytes = newValue.map { $0 }
-            arrayOfBytes.withUnsafeBufferPointer {
-                let otherData = Data(buffer: $0)
-                replaceBytes(in: bounds, with: otherData)
-            }
+            replaceSubrange(bounds, with: newValue.base)
         }
     }
     
@@ -620,12 +652,14 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
     public func makeIterator() -> Data.Iterator {
         return IndexingIterator(_elements: self)
     }
+    
+    /// Returns `true` if the two `Data` arguments are equal.
+    public static func ==(d1 : Data, d2 : Data) -> Bool {
+        return d1._wrapped.isEqual(to: d2)
+    }
 }
 
-/// Returns `true` if the two `Data` arguments are equal.
-public func ==(d1 : Data, d2 : Data) -> Bool {
-    return d1._wrapped.isEqual(to: d2)
-}
+
 
 /// Provides bridging functionality for struct Data to class NSData and vice-versa.
 extension Data : _ObjectTypeBridgeable {
@@ -639,11 +673,11 @@ extension Data : _ObjectTypeBridgeable {
     }
     
     public static func _forceBridgeFromObjectiveC(_ input: NSData, result: inout Data?) {
-        result = Data(_bridged: input)
+        result = Data(referencing: input)
     }
     
     public static func _conditionallyBridgeFromObjectiveC(_ input: NSData, result: inout Data?) -> Bool {
-        result = Data(_bridged: input)
+        result = Data(referencing: input)
         return true
     }
     
diff --git a/Foundation/NSConcreteValue.swift b/Foundation/NSConcreteValue.swift
index e9779a0550..cded14ecb0 100644
--- a/Foundation/NSConcreteValue.swift
+++ b/Foundation/NSConcreteValue.swift
@@ -113,7 +113,8 @@ internal class NSConcreteValue : NSValue {
     }
     
     override var description : String {
-        return Data(bytes: self.value, count: self._size).description
+        let boundBytes = self.value.bindMemory(to: UInt8.self, capacity: self._size)
+        return Data(bytes: boundBytes, count: self._size).description
     }
     
     convenience required init?(coder aDecoder: NSCoder) {
diff --git a/Foundation/NSData.swift b/Foundation/NSData.swift
index bfa91a05a2..df6ebab164 100644
--- a/Foundation/NSData.swift
+++ b/Foundation/NSData.swift
@@ -16,22 +16,21 @@ import Glibc
 #endif
 
 extension NSData {
-
     public struct ReadingOptions : OptionSet {
         public let rawValue : UInt
         public init(rawValue: UInt) { self.rawValue = rawValue }
         
-        public static let dataReadingMappedIfSafe = ReadingOptions(rawValue: UInt(1 << 0))
-        public static let dataReadingUncached = ReadingOptions(rawValue: UInt(1 << 1))
-        public static let dataReadingMappedAlways = ReadingOptions(rawValue: UInt(1 << 2))
+        public static let mappedIfSafe = ReadingOptions(rawValue: UInt(1 << 0))
+        public static let uncached = ReadingOptions(rawValue: UInt(1 << 1))
+        public static let alwaysMapped = ReadingOptions(rawValue: UInt(1 << 2))
     }
 
     public struct WritingOptions : OptionSet {
         public let rawValue : UInt
         public init(rawValue: UInt) { self.rawValue = rawValue }
         
-        public static let dataWritingAtomic = WritingOptions(rawValue: UInt(1 << 0))
-        public static let dataWritingWithoutOverwriting = WritingOptions(rawValue: UInt(1 << 1))
+        public static let atomic = WritingOptions(rawValue: UInt(1 << 0))
+        public static let withoutOverwriting = WritingOptions(rawValue: UInt(1 << 1))
     }
 
     public struct SearchOptions : OptionSet {
@@ -46,10 +45,10 @@ extension NSData {
         public let rawValue : UInt
         public init(rawValue: UInt) { self.rawValue = rawValue }
         
-        public static let encoding64CharacterLineLength = Base64EncodingOptions(rawValue: UInt(1 << 0))
-        public static let encoding76CharacterLineLength = Base64EncodingOptions(rawValue: UInt(1 << 1))
-        public static let encodingEndLineWithCarriageReturn = Base64EncodingOptions(rawValue: UInt(1 << 4))
-        public static let encodingEndLineWithLineFeed = Base64EncodingOptions(rawValue: UInt(1 << 5))
+        public static let lineLength64Characters = Base64EncodingOptions(rawValue: UInt(1 << 0))
+        public static let lineLength76Characters = Base64EncodingOptions(rawValue: UInt(1 << 1))
+        public static let endLineWithCarriageReturn = Base64EncodingOptions(rawValue: UInt(1 << 4))
+        public static let endLineWithLineFeed = Base64EncodingOptions(rawValue: UInt(1 << 5))
     }
 
     public struct Base64DecodingOptions : OptionSet {
@@ -74,6 +73,7 @@ private let __kCFAllocatesCollectable: CFOptionFlags = 0x20
 
 open class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
     typealias CFType = CFData
+    
     private var _base = _CFInfo(typeID: CFDataGetTypeID())
     private var _length: CFIndex = 0
     private var _capacity: CFIndex = 0
@@ -90,23 +90,114 @@ open class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
         }
     }
     
-    public override required convenience init() {
+    override open var _cfTypeID: CFTypeID {
+        return CFDataGetTypeID()
+    }
+
+    // NOTE: the deallocator block here is implicitly @escaping by virtue of it being optional     
+    public init(bytes: UnsafeMutableRawPointer?, length: Int, copy: Bool = false, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)? = nil) {
+        super.init()
+        let options : CFOptionFlags = (type(of: self) == NSMutableData.self) ? __kCFMutable | __kCFGrowable : 0x0
+        let bytePtr = bytes?.bindMemory(to: UInt8.self, capacity: length)
+        if copy {
+            _CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options, length, bytePtr, length, false)
+            if let handler = deallocator {
+                handler(bytes!, length)
+            }
+        } else {
+            if let handler = deallocator {
+                _deallocHandler!.handler = handler
+            }
+            // The data initialization should flag that CF should not deallocate which leaves the handler a chance to deallocate instead
+            _CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options | __kCFDontDeallocate, length, bytePtr, length, true)
+        }
+    }
+    
+    public override convenience init() {
         let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutableRawPointer.self)
         self.init(bytes: dummyPointer, length: 0, copy: false, deallocator: nil)
     }
     
-    open override var hash: Int {
-        return Int(bitPattern: CFHash(_cfObject))
+    public convenience init(bytes: UnsafeRawPointer?, length: Int) {
+        self.init(bytes: UnsafeMutableRawPointer(mutating: bytes), length: length, copy: true, deallocator: nil)
     }
     
-    open override func isEqual(_ object: AnyObject?) -> Bool {
-        if let data = object as? NSData {
-            return self.isEqual(to: data._swiftObject)
+    public convenience init(bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int) {
+        self.init(bytes: bytes, length: length, copy: false, deallocator: nil)
+    }
+    
+    public convenience init(bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int, freeWhenDone b: Bool) {
+        self.init(bytes: bytes, length: length, copy: false) { buffer, length in
+            if b {
+                free(buffer)
+            }
+        }
+    }
+
+    // NOTE: the deallocator block here is implicitly @escaping by virtue of it being optional         
+    public convenience init(bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)? = nil) {
+        self.init(bytes: bytes, length: length, copy: false, deallocator: deallocator)
+    }
+    public convenience init(contentsOfFile path: String, options readOptionsMask: ReadingOptions = []) throws {
+        let readResult = try NSData.readBytesFromFileWithExtendedAttributes(path, options: readOptionsMask)
+        self.init(bytes: readResult.bytes, length: readResult.length, copy: false, deallocator: readResult.deallocator)
+    }
+    
+    public convenience init?(contentsOfFile path: String) {
+        do {
+            let readResult = try NSData.readBytesFromFileWithExtendedAttributes(path, options: [])
+            self.init(bytes: readResult.bytes, length: readResult.length, copy: false, deallocator: readResult.deallocator)
+        } catch {
+            return nil
+        }
+    }
+    
+    public convenience init(data: Data) {
+        self.init(bytes:data._nsObject.bytes, length: data.count)
+    }
+    
+    public convenience init(contentsOf url: URL, options readOptionsMask: ReadingOptions = []) throws {
+        if url.isFileURL {
+            try self.init(contentsOfFile: url.path, options: readOptionsMask)
         } else {
-            return false
+            let session = URLSession(configuration: URLSessionConfiguration.defaultSessionConfiguration())
+            let cond = NSCondition()
+            var resError: NSError?
+            var resData: Data?
+            let task = session.dataTaskWithURL(url, completionHandler: { (data: Data?, response: URLResponse?, error: NSError?) -> Void in
+                resData = data
+                resError = error
+                cond.broadcast()
+            })
+            task.resume()
+            cond.wait()
+            if resData == nil {
+                throw resError!
+            }
+            self.init(data: resData!)
         }
     }
     
+    public convenience init?(base64Encoded base64String: String, options: Base64DecodingOptions = []) {
+        let encodedBytes = Array(base64String.utf8)
+        guard let decodedBytes = NSData.base64DecodeBytes(encodedBytes, options: options) else {
+            return nil
+        }
+        self.init(bytes: decodedBytes, length: decodedBytes.count)
+    }
+    
+    
+    /* Create an NSData from a Base-64, UTF-8 encoded NSData. By default, returns nil when the input is not recognized as valid Base-64.
+     */
+    public convenience init?(base64Encoded base64Data: Data, options: Base64DecodingOptions = []) {
+        var encodedBytes = [UInt8](repeating: 0, count: base64Data.count)
+        base64Data._nsObject.getBytes(&encodedBytes, length: encodedBytes.count)
+        guard let decodedBytes = NSData.base64DecodeBytes(encodedBytes, options: options) else {
+            return nil
+        }
+        self.init(bytes: decodedBytes, length: decodedBytes.count)
+    }
+    
     deinit {
         if let allocatedBytes = _bytes {
             _deallocHandler?.handler(allocatedBytes, _length)
@@ -116,31 +207,39 @@ open class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
         }
     }
     
-    internal init(bytes: UnsafeMutableRawPointer?, length: Int, copy: Bool, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)?) {
-        super.init()
-        let options : CFOptionFlags = (type(of: self) == NSMutableData.self) ? __kCFMutable | __kCFGrowable : 0x0
-        let bytePtr = bytes?.bindMemory(to: UInt8.self, capacity: length)
-        if copy {
-            _CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options, length, bytePtr, length, false)
-            if let handler = deallocator {
-                handler(bytes!, length)
-            }
-        } else {
-            if let handler = deallocator {
-                _deallocHandler!.handler = handler
-            }
-            // The data initialization should flag that CF should not deallocate which leaves the handler a chance to deallocate instead
-            _CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options | __kCFDontDeallocate, length, bytePtr, length, true)
-        }
-    }
-    
+    // MARK: - Funnel methods
     open var length: Int {
         return CFDataGetLength(_cfObject)
     }
-
+    
     open var bytes: UnsafeRawPointer {
         return UnsafeRawPointer(CFDataGetBytePtr(_cfObject))
     }
+
+    
+
+    // MARK: - NSObject methods
+    open override var hash: Int {
+        return Int(bitPattern: CFHash(_cfObject))
+    }
+    
+    open override func isEqual(_ object: AnyObject?) -> Bool {
+        if let data = object as? NSData {
+            return self.isEqual(to: data._swiftObject)
+        } else {
+            return false
+        }
+    }
+    open func isEqual(to other: Data) -> Bool {
+        if length != other.count {
+            return false
+        }
+        
+        return other.withUnsafeBytes { (bytes2: UnsafePointer<UInt8>) -> Bool in
+            let bytes1 = bytes
+            return memcmp(bytes1, bytes2, length) == 0
+        }
+    }
     
     open override func copy() -> Any {
         return copy(with: nil)
@@ -157,42 +256,6 @@ open class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
     open func mutableCopy(with zone: NSZone? = nil) -> Any {
         return NSMutableData(bytes: UnsafeMutableRawPointer(mutating: bytes), length: length, copy: true, deallocator: nil)
     }
-
-    open func encode(with aCoder: NSCoder) {
-        if let aKeyedCoder = aCoder as? NSKeyedArchiver {
-            aKeyedCoder._encodePropertyList(self, forKey: "NS.data")
-        } else {
-            let bytePtr = self.bytes.bindMemory(to: UInt8.self, capacity: self.length)
-            aCoder.encodeBytes(bytePtr, length: self.length)
-        }
-    }
-    
-    public required convenience init?(coder aDecoder: NSCoder) {
-        if !aDecoder.allowsKeyedCoding {
-            if let data = aDecoder.decodeData() {
-                self.init(data: data)
-            } else {
-                return nil
-            }
-        } else if type(of: aDecoder) == NSKeyedUnarchiver.self || aDecoder.containsValue(forKey: "NS.data") {
-            guard let data = aDecoder._decodePropertyListForKey("NS.data") as? NSData else {
-                return nil
-            }
-            self.init(data: data._swiftObject)
-        } else {
-            let result : Data? = aDecoder.withDecodedUnsafeBufferPointer(forKey: "NS.bytes") {
-                guard let buffer = $0 else { return nil }
-                return Data(buffer: buffer)
-            }
-
-            guard let r = result else { return nil }
-            self.init(data: r)
-        }
-    }
-    
-    public static var supportsSecureCoding: Bool {
-        return true
-    }
     
     private func byteDescription(limit: Int? = nil) -> String {
         var s = ""
@@ -226,34 +289,45 @@ open class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
         return "<\(byteDescription())>"
     }
     
-    override open var _cfTypeID: CFTypeID {
-        return CFDataGetTypeID()
-    }
-}
-
-extension NSData {
     
-    public convenience init(bytes: UnsafeRawPointer?, length: Int) {
-        self.init(bytes: UnsafeMutableRawPointer(mutating: bytes), length: length, copy: true, deallocator: nil)
-    }
-
-    public convenience init(bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int) {
-        self.init(bytes: bytes, length: length, copy: false, deallocator: nil)
+    // MARK: - NSCoding methods
+    open func encode(with aCoder: NSCoder) {
+        if let aKeyedCoder = aCoder as? NSKeyedArchiver {
+            aKeyedCoder._encodePropertyList(self, forKey: "NS.data")
+        } else {
+            let bytePtr = self.bytes.bindMemory(to: UInt8.self, capacity: self.length)
+            aCoder.encodeBytes(bytePtr, length: self.length)
+        }
     }
     
-    public convenience init(bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int, freeWhenDone b: Bool) {
-        self.init(bytes: bytes, length: length, copy: false) { buffer, length in
-            if b {
-                free(buffer)
+    public required convenience init?(coder aDecoder: NSCoder) {
+        if !aDecoder.allowsKeyedCoding {
+            if let data = aDecoder.decodeData() {
+                self.init(data: data)
+            } else {
+                return nil
+            }
+        } else if type(of: aDecoder) == NSKeyedUnarchiver.self || aDecoder.containsValue(forKey: "NS.data") {
+            guard let data = aDecoder._decodePropertyListForKey("NS.data") as? NSData else {
+                return nil
+            }
+            self.init(data: data._swiftObject)
+        } else {
+            let result : Data? = aDecoder.withDecodedUnsafeBufferPointer(forKey: "NS.bytes") {
+                guard let buffer = $0 else { return nil }
+                return Data(buffer: buffer)
             }
+            
+            guard let r = result else { return nil }
+            self.init(data: r)
         }
     }
-
-    public convenience init(bytesNoCopy bytes: UnsafeMutableRawPointer, length: Int, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)?) {
-        self.init(bytes: bytes, length: length, copy: false, deallocator: deallocator)
-    }
-    
     
+    public static var supportsSecureCoding: Bool {
+        return true
+    }
+
+    // MARK: - IO
     internal struct NSDataReadResult {
         var bytes: UnsafeMutableRawPointer
         var length: Int
@@ -283,7 +357,7 @@ extension NSData {
         
         let length = Int(info.st_size)
         
-        if options.contains(.dataReadingMappedAlways) {
+        if options.contains(.alwaysMapped) {
             let data = mmap(nil, length, PROT_READ, MAP_PRIVATE, fd, 0)
             
             // Swift does not currently expose MAP_FAILURE
@@ -316,90 +390,7 @@ extension NSData {
         }
     }
     
-    public convenience init(contentsOfFile path: String, options readOptionsMask: ReadingOptions) throws {
-        let readResult = try NSData.readBytesFromFileWithExtendedAttributes(path, options: readOptionsMask)
-        self.init(bytes: readResult.bytes, length: readResult.length, copy: false, deallocator: readResult.deallocator)
-    }
-
-    public convenience init?(contentsOfFile path: String) {
-        do {
-            let readResult = try NSData.readBytesFromFileWithExtendedAttributes(path, options: [])
-            self.init(bytes: readResult.bytes, length: readResult.length, copy: false, deallocator: readResult.deallocator)
-        } catch {
-            return nil
-        }
-    }
-
-    public convenience init(data: Data) {
-        self.init(bytes:data._nsObject.bytes, length: data.count)
-    }
-    
-    public convenience init(contentsOf url: URL, options readOptionsMask: ReadingOptions) throws {
-        if url.isFileURL {
-            try self.init(contentsOfFile: url.path, options: readOptionsMask)
-        } else {
-            let session = URLSession(configuration: URLSessionConfiguration.defaultSessionConfiguration())
-            let cond = NSCondition()
-            var resError: NSError?
-            var resData: Data?
-            let task = session.dataTaskWithURL(url, completionHandler: { (data: Data?, response: URLResponse?, error: NSError?) -> Void in
-                resData = data
-                resError = error
-                cond.broadcast()
-            })
-            task.resume()
-            cond.wait()
-            if resData == nil {
-                throw resError!
-            }
-            self.init(data: resData!)
-        }
-    }
-    
-    public convenience init?(contentsOfURL url: URL) {
-        do {
-            try self.init(contentsOf: url, options: [])
-        } catch {
-            return nil
-        }
-    }
-}
-
-extension NSData {
-    public func getBytes(_ buffer: UnsafeMutableRawPointer, length: Int) {
-        let bytePtr = buffer.bindMemory(to: UInt8.self, capacity: length)
-        CFDataGetBytes(_cfObject, CFRangeMake(0, length), bytePtr)
-    }
-    
-    public func getBytes(_ buffer: UnsafeMutableRawPointer, range: NSRange) {
-        let bytePtr = buffer.bindMemory(to: UInt8.self, capacity: range.length)
-        CFDataGetBytes(_cfObject, CFRangeMake(range.location, range.length), bytePtr)
-    }
-    
-    public func isEqual(to other: Data) -> Bool {
-
-        if length != other.count {
-            return false
-        }
-        
-        
-        return other.withUnsafeBytes { (bytes2: UnsafePointer<Void>) -> Bool in
-            let bytes1 = bytes
-            return memcmp(bytes1, bytes2, length) == 0
-        }
-    }
-    
-    public func subdata(with range: NSRange) -> Data {
-        if range.length == 0 {
-            return Data()
-        }
-        if range.location == 0 && range.length == self.length {
-            return Data(_bridged: self)
-        }
-        return Data(bytes: bytes.advanced(by: range.location), count: range.length)
-    }
-
-    internal func makeTemporaryFileInDirectory(_ dirPath: String) throws -> (Int32, String) {
+    internal func makeTemporaryFile(inDirectory dirPath: String) throws -> (Int32, String) {
         let template = dirPath._nsObject.appendingPathComponent("tmp.XXXXXX")
         let maxLength = Int(PATH_MAX) + 1
         var buf = [Int8](repeating: 0, count: maxLength)
@@ -412,7 +403,7 @@ extension NSData {
         return (fd, pathResult)
     }
 
-    internal class func writeToFileDescriptor(_ fd: Int32, path: String? = nil, buf: UnsafeRawPointer, length: Int) throws {
+    internal class func write(toFileDescriptor fd: Int32, path: String? = nil, buf: UnsafeRawPointer, length: Int) throws {
         var bytesRemaining = length
         while bytesRemaining > 0 {
             var bytesWritten : Int
@@ -431,10 +422,10 @@ extension NSData {
         }
     }
     
-    public func write(toFile path: String, options writeOptionsMask: WritingOptions = []) throws {
+    open func write(toFile path: String, options writeOptionsMask: WritingOptions = []) throws {
         var fd : Int32
         var mode : mode_t? = nil
-        let useAuxiliaryFile = writeOptionsMask.contains(.dataWritingAtomic)
+        let useAuxiliaryFile = writeOptionsMask.contains(.atomic)
         var auxFilePath : String? = nil
         if useAuxiliaryFile {
             // Preserve permissions.
@@ -444,13 +435,13 @@ extension NSData {
             } else if errno != ENOENT && errno != ENAMETOOLONG {
                 throw _NSErrorWithErrno(errno, reading: false, path: path)
             }
-            let (newFD, path) = try self.makeTemporaryFileInDirectory(path._nsObject.deletingLastPathComponent)
+            let (newFD, path) = try self.makeTemporaryFile(inDirectory: path._nsObject.deletingLastPathComponent)
             fd = newFD
             auxFilePath = path
             fchmod(fd, 0o666)
         } else {
             var flags = O_WRONLY | O_CREAT | O_TRUNC
-            if writeOptionsMask.contains(.dataWritingWithoutOverwriting) {
+            if writeOptionsMask.contains(.withoutOverwriting) {
                 flags |= O_EXCL
             }
             fd = _CFOpenFileWithMode(path, flags, 0o666)
@@ -465,7 +456,7 @@ extension NSData {
         try self.enumerateByteRangesUsingBlockRethrows { (buf, range, stop) in
             if range.length > 0 {
                 do {
-                    try NSData.writeToFileDescriptor(fd, path: path, buf: buf, length: range.length)
+                    try NSData.write(toFileDescriptor: fd, path: path, buf: buf, length: range.length)
                     if fsync(fd) < 0 {
                         throw _NSErrorWithErrno(errno, reading: false, path: path)
                     }
@@ -492,16 +483,18 @@ extension NSData {
         }
     }
     
-    public func write(toFile path: String, atomically useAuxiliaryFile: Bool) -> Bool {
+    /// NOTE: the 'atomically' flag is ignored if the url is not of a type the supports atomic writes
+    open func write(toFile path: String, atomically useAuxiliaryFile: Bool) -> Bool {
         do {
-            try write(toFile: path, options: useAuxiliaryFile ? .dataWritingAtomic : [])
+            try write(toFile: path, options: useAuxiliaryFile ? .atomic : [])
         } catch {
             return false
         }
         return true
     }
     
-    public func write(to url: URL, atomically: Bool) -> Bool {
+    /// NOTE: the 'atomically' flag is ignored if the url is not of a type the supports atomic writes
+    open func write(to url: URL, atomically: Bool) -> Bool {
         if url.isFileURL {
             return write(toFile: url.path, atomically: atomically)
         }
@@ -516,7 +509,7 @@ extension NSData {
     ///    - throws: This method returns Void and is marked with the `throws` keyword to indicate that it throws an error in the event of failure.
     ///
     ///      This method is invoked in a `try` expression and the caller is responsible for handling any errors in the `catch` clauses of a `do` statement, as described in [Error Handling](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ErrorHandling.html#//apple_ref/doc/uid/TP40014097-CH42) in [The Swift Programming Language](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/index.html#//apple_ref/doc/uid/TP40014097) and [Error Handling](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10) in [Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216).
-    public func write(to url: URL, options writeOptionsMask: WritingOptions = []) throws {
+    open func write(to url: URL, options writeOptionsMask: WritingOptions = []) throws {
         guard url.isFileURL else {
             let userInfo = [NSLocalizedDescriptionKey : "The folder at “\(url)” does not exist or is not a file URL.", // NSLocalizedString() not yet available
                             NSURLErrorKey             : url.absoluteString] as Dictionary<String, Any>
@@ -525,8 +518,31 @@ extension NSData {
         try write(toFile: url.path, options: writeOptionsMask)
     }
     
-    public func range(of searchData: Data, options mask: SearchOptions = [], in searchRange: NSRange) -> NSRange {
-        let dataToFind = searchData._nsObject
+    
+    // MARK: - Bytes
+    open func getBytes(_ buffer: UnsafeMutableRawPointer, length: Int) {
+        let bytePtr = buffer.bindMemory(to: UInt8.self, capacity: length)
+        CFDataGetBytes(_cfObject, CFRangeMake(0, length), bytePtr)
+    }
+    
+    open func getBytes(_ buffer: UnsafeMutableRawPointer, range: NSRange) {
+        let bytePtr = buffer.bindMemory(to: UInt8.self, capacity: range.length)
+        CFDataGetBytes(_cfObject, CFRangeMake(range.location, range.length), bytePtr)
+    }
+    
+    open func subdata(with range: NSRange) -> Data {
+        if range.length == 0 {
+            return Data()
+        }
+        if range.location == 0 && range.length == self.length {
+            return Data(referencing: self)
+        }
+        let p = self.bytes.advanced(by: range.location).bindMemory(to: UInt8.self, capacity: range.length)
+        return Data(bytes: p, count: range.length)
+    }
+    
+    open func range(of dataToFind: Data, options mask: SearchOptions = [], in searchRange: NSRange) -> NSRange {
+        let dataToFind = dataToFind._nsObject
         guard dataToFind.length > 0 else {return NSRange(location: NSNotFound, length: 0)}
         guard let searchRange = searchRange.toRange() else {fatalError("invalid range")}
         
@@ -570,118 +586,37 @@ extension NSData {
         }
     }
 
-    public func enumerateBytes(_ block: (UnsafeRawPointer, NSRange, UnsafeMutablePointer<Bool>) -> Void) {
+    /// 'block' is called once for each contiguous region of memory in the receiver (once total for contiguous NSDatas), until either all bytes have been enumerated, or the 'stop' parameter is set to true.
+    open func enumerateBytes(_ block: (UnsafeRawPointer, NSRange, UnsafeMutablePointer<Bool>) -> Void) {
         var stop = false
         withUnsafeMutablePointer(to: &stop) { stopPointer in
+            if (stopPointer.pointee) {
+                return
+            }
             block(bytes, NSMakeRange(0, length), stopPointer)
         }
     }
-}
-
-extension NSData : _CFBridgable, _SwiftBridgable {
-    typealias SwiftType = Data
-    internal var _swiftObject: SwiftType { return Data(_bridged: self) }
     
-    public func bridge() -> Data {
-        return _swiftObject
-    }
-}
+    // MARK: - Base64 Methods
 
-extension Data : _NSBridgable, _CFBridgable {
-    typealias CFType = CFData
-    typealias NSType = NSData
-    internal var _cfObject: CFType { return _nsObject._cfObject }
-    internal var _nsObject: NSType { return _bridgeToObjectiveC() }
-    
-    public func bridge() -> NSData {
-        return _nsObject
-    }
-}
-
-extension CFData : _NSBridgable, _SwiftBridgable {
-    typealias NSType = NSData
-    typealias SwiftType = Data
-    internal var _nsObject: NSType { return unsafeBitCast(self, to: NSType.self) }
-    internal var _swiftObject: SwiftType { return Data(_bridged: self._nsObject) }
-}
-
-extension NSMutableData {
-    internal var _cfMutableObject: CFMutableData { return unsafeBitCast(self, to: CFMutableData.self) }
-}
-
-open class NSMutableData : NSData {
-
-    public required convenience init() {
-        self.init(bytes: nil, length: 0)
-    }
-    
-    internal override init(bytes: UnsafeMutableRawPointer?, length: Int, copy: Bool, deallocator: ((UnsafeMutableRawPointer, Int) -> Void)?) {
-        super.init(bytes: bytes, length: length, copy: copy, deallocator: deallocator)
-    }
-    
-    open var mutableBytes: UnsafeMutableRawPointer {
-        return UnsafeMutableRawPointer(CFDataGetMutableBytePtr(_cfMutableObject))
-    }
-    
-    open override var length: Int {
-        get {
-            return CFDataGetLength(_cfObject)
-        }
-        set {
-            CFDataSetLength(_cfMutableObject, newValue)
-        }
-    }
-    
-    open override func copy(with zone: NSZone? = nil) -> Any {
-        return NSData(bytes: bytes, length: length)
-    }
-}
-
-extension NSData {
-    
-    /* Create an NSData from a Base-64 encoded NSString using the given options. By default, returns nil when the input is not recognized as valid Base-64.
-    */
-    public convenience init?(base64Encoded base64String: String, options: Base64DecodingOptions) {
-        let encodedBytes = Array(base64String.utf8)
-        guard let decodedBytes = NSData.base64DecodeBytes(encodedBytes, options: options) else {
-            return nil
-        }
-        self.init(bytes: decodedBytes, length: decodedBytes.count)
-    }
-    
-    /* Create a Base-64 encoded NSString from the receiver's contents using the given options.
-    */
-    public func base64EncodedString(_ options: Base64EncodingOptions = []) -> String {
+    /// Create a Base-64 encoded String from the receiver's contents using the given options.
+    open func base64EncodedString(options: Base64EncodingOptions = []) -> String {
         var decodedBytes = [UInt8](repeating: 0, count: self.length)
         getBytes(&decodedBytes, length: decodedBytes.count)
         let encodedBytes = NSData.base64EncodeBytes(decodedBytes, options: options)
         let characters = encodedBytes.map { Character(UnicodeScalar($0)) }
         return String(characters)
     }
-    
-    /* Create an NSData from a Base-64, UTF-8 encoded NSData. By default, returns nil when the input is not recognized as valid Base-64.
-    */
-    public convenience init?(base64Encoded base64Data: Data, options: Base64DecodingOptions) {
-        var encodedBytes = [UInt8](repeating: 0, count: base64Data.count)
-        base64Data._nsObject.getBytes(&encodedBytes, length: encodedBytes.count)
-        guard let decodedBytes = NSData.base64DecodeBytes(encodedBytes, options: options) else {
-            return nil
-        }
-        self.init(bytes: decodedBytes, length: decodedBytes.count)
-    }
-    
-    /* Create a Base-64, UTF-8 encoded NSData from the receiver's contents using the given options.
-    */
-    public func base64EncodedData(_ options: Base64EncodingOptions = []) -> Data {
+
+    /// Create a Base-64, UTF-8 encoded Data from the receiver's contents using the given options.
+    open func base64EncodedData(options: Base64EncodingOptions = []) -> Data {
         var decodedBytes = [UInt8](repeating: 0, count: self.length)
         getBytes(&decodedBytes, length: decodedBytes.count)
         let encodedBytes = NSData.base64EncodeBytes(decodedBytes, options: options)
         return Data(bytes: encodedBytes, count: encodedBytes.count)
     }
-    
-    /**
-      The ranges of ASCII characters that are used to encode data in Base64.
-      */
+
+    /// The ranges of ASCII characters that are used to encode data in Base64.
     private static let base64ByteMappings: [Range<UInt8>] = [
         65 ..< 91,      // A-Z
         97 ..< 123,     // a-z
@@ -695,12 +630,12 @@ extension NSData {
     private static let base64Padding : UInt8 = 61 // =
     
     /**
-        This method takes a byte with a character from Base64-encoded string
-        and gets the binary value that the character corresponds to.
+     This method takes a byte with a character from Base64-encoded string
+     and gets the binary value that the character corresponds to.
      
-        - parameter byte:       The byte with the Base64 character.
-        - returns:              Base64DecodedByte value containing the result (Valid , Invalid, Padding)
-        */
+     - parameter byte:       The byte with the Base64 character.
+     - returns:              Base64DecodedByte value containing the result (Valid , Invalid, Padding)
+     */
     private enum Base64DecodedByte {
         case valid(UInt8)
         case invalid
@@ -720,15 +655,15 @@ extension NSData {
     }
     
     /**
-        This method takes six bits of binary data and encodes it as a character
-        in Base64.
- 
-        The value in the byte must be less than 64, because a Base64 character
-        can only represent 6 bits.
- 
-        - parameter byte:       The byte to encode
-        - returns:              The ASCII value for the encoded character.
-        */
+     This method takes six bits of binary data and encodes it as a character
+     in Base64.
+     
+     The value in the byte must be less than 64, because a Base64 character
+     can only represent 6 bits.
+     
+     - parameter byte:       The byte to encode
+     - returns:              The ASCII value for the encoded character.
+     */
     private static func base64EncodeByte(_ byte: UInt8) -> UInt8 {
         assert(byte < 64)
         var decodedStart: UInt8 = 0
@@ -744,19 +679,19 @@ extension NSData {
     
     
     /**
-        This method decodes Base64-encoded data.
+     This method decodes Base64-encoded data.
+     
+     If the input contains any bytes that are not valid Base64 characters,
+     this will return nil.
      
-        If the input contains any bytes that are not valid Base64 characters,
-        this will return nil.
- 
-        - parameter bytes:      The Base64 bytes
-        - parameter options:    Options for handling invalid input
-        - returns:              The decoded bytes.
-        */
+     - parameter bytes:      The Base64 bytes
+     - parameter options:    Options for handling invalid input
+     - returns:              The decoded bytes.
+     */
     private static func base64DecodeBytes(_ bytes: [UInt8], options: Base64DecodingOptions = []) -> [UInt8]? {
         var decodedBytes = [UInt8]()
         decodedBytes.reserveCapacity((bytes.count/3)*2)
-
+        
         var currentByte : UInt8 = 0
         var validCharacterCount = 0
         var paddingCount = 0
@@ -817,12 +752,12 @@ extension NSData {
     
     
     /**
-        This method encodes data in Base64.
+     This method encodes data in Base64.
      
-        - parameter bytes:      The bytes you want to encode
-        - parameter options:    Options for formatting the result
-        - returns:              The Base64-encoding for those bytes.
-        */
+     - parameter bytes:      The bytes you want to encode
+     - parameter options:    Options for formatting the result
+     - returns:              The Base64-encoding for those bytes.
+     */
     private static func base64EncodeBytes(_ bytes: [UInt8], options: Base64EncodingOptions = []) -> [UInt8] {
         var result = [UInt8]()
         result.reserveCapacity((bytes.count/3)*4)
@@ -830,15 +765,15 @@ extension NSData {
         let lineOptions : (lineLength : Int, separator : [UInt8])? = {
             let lineLength: Int
             
-            if options.contains(.encoding64CharacterLineLength) { lineLength = 64 }
-            else if options.contains(.encoding76CharacterLineLength) { lineLength = 76 }
+            if options.contains(.lineLength64Characters) { lineLength = 64 }
+            else if options.contains(.lineLength76Characters) { lineLength = 76 }
             else {
                 return nil
             }
             
             var separator = [UInt8]()
-            if options.contains(.encodingEndLineWithCarriageReturn) { separator.append(13) }
-            if options.contains(.encodingEndLineWithLineFeed) { separator.append(10) }
+            if options.contains(.endLineWithCarriageReturn) { separator.append(13) }
+            if options.contains(.endLineWithLineFeed) { separator.append(10) }
             
             //if the kind of line ending to insert is not specified, the default line ending is Carriage Return + Line Feed.
             if separator.count == 0 {separator = [13,10]}
@@ -892,16 +827,83 @@ extension NSData {
         }
         return result
     }
+    
 }
 
-extension NSMutableData {
+// MARK: -
+extension NSData : _CFBridgable, _SwiftBridgable {
+    typealias SwiftType = Data
+    internal var _swiftObject: SwiftType { return Data(referencing: self) }
+    
+    public func bridge() -> Data {
+        return _swiftObject
+    }
+}
 
-    public func append(_ bytes: UnsafeRawPointer, length: Int) {
+extension Data : _NSBridgable, _CFBridgable {
+    typealias CFType = CFData
+    typealias NSType = NSData
+    internal var _cfObject: CFType { return _nsObject._cfObject }
+    internal var _nsObject: NSType { return _bridgeToObjectiveC() }
+    
+    public func bridge() -> NSData {
+        return _nsObject
+    }
+}
+
+extension CFData : _NSBridgable, _SwiftBridgable {
+    typealias NSType = NSData
+    typealias SwiftType = Data
+    internal var _nsObject: NSType { return unsafeBitCast(self, to: NSType.self) }
+    internal var _swiftObject: SwiftType { return Data(referencing: self._nsObject) }
+}
+
+// MARK: -
+open class NSMutableData : NSData {
+    internal var _cfMutableObject: CFMutableData { return unsafeBitCast(self, to: CFMutableData.self) }
+    
+    public override init(bytes: UnsafeMutableRawPointer?, length: Int, copy: Bool = false, deallocator: (@escaping (UnsafeMutableRawPointer, Int) -> Void)? = nil) {
+        super.init(bytes: bytes, length: length, copy: copy, deallocator: deallocator)
+    }
+    public init() {
+        self.init(bytes: nil, length: 0)
+    }
+        
+    public convenience init?(capacity: Int) {
+        self.init(bytes: nil, length: 0)
+    }
+    
+    public convenience init?(length: Int) {
+        self.init(bytes: nil, length: 0)
+        self.length = length
+    }
+    
+    // MARK: - Funnel Methods
+    open var mutableBytes: UnsafeMutableRawPointer {
+        return UnsafeMutableRawPointer(CFDataGetMutableBytePtr(_cfMutableObject))
+    }
+    
+    open override var length: Int {
+        get {
+            return CFDataGetLength(_cfObject)
+        }
+        set {
+            CFDataSetLength(_cfMutableObject, newValue)
+        }
+    }
+    
+    // MARK: - NSObject
+    open override func copy(with zone: NSZone? = nil) -> Any {
+        return NSData(bytes: bytes, length: length)
+    }
+
+    // MARK: - Mutability
+    open func append(_ bytes: UnsafeRawPointer, length: Int) {
         let bytePtr = bytes.bindMemory(to: UInt8.self, capacity: length)
         CFDataAppendBytes(_cfMutableObject, bytePtr, length)
     }
     
-    public func append(_ other: Data) {
+    open func append(_ other: Data) {
         let otherLength = other.count
         other.withUnsafeBytes {
             append($0, length: otherLength)
@@ -909,20 +911,20 @@ extension NSMutableData {
         
     }
     
-    public func increaseLength(by extraLength: Int) {
+    open func increaseLength(by extraLength: Int) {
         CFDataSetLength(_cfMutableObject, CFDataGetLength(_cfObject) + extraLength)
     }
     
-    public func replaceBytes(in range: NSRange, withBytes bytes: UnsafeRawPointer) {
+    open func replaceBytes(in range: NSRange, withBytes bytes: UnsafeRawPointer) {
         let bytePtr = bytes.bindMemory(to: UInt8.self, capacity: length)
         CFDataReplaceBytes(_cfMutableObject, CFRangeMake(range.location, range.length), bytePtr, length)
     }
     
-    public func resetBytes(in range: NSRange) {
+    open func resetBytes(in range: NSRange) {
         bzero(mutableBytes.advanced(by: range.location), range.length)
     }
     
-    public func setData(_ data: Data) {
+    open func setData(_ data: Data) {
         length = data.count
         data.withUnsafeBytes {
             replaceBytes(in: NSMakeRange(0, length), withBytes: $0)
@@ -930,21 +932,11 @@ extension NSMutableData {
         
     }
     
-    public func replaceBytes(in range: NSRange, withBytes replacementBytes: UnsafeRawPointer, length replacementLength: Int) {
-        let bytePtr = replacementBytes.bindMemory(to: UInt8.self, capacity: replacementLength)
-        CFDataReplaceBytes(_cfMutableObject, CFRangeMake(range.location, range.length), bytePtr, replacementLength)
-    }
-}
-
-extension NSMutableData {
-    
-    public convenience init?(capacity: Int) {
-        self.init(bytes: nil, length: 0)
-    }
-    
-    public convenience init?(length: Int) {
-        self.init(bytes: nil, length: 0)
-        self.length = length
+    open func replaceBytes(in range: NSRange, withBytes replacementBytes: UnsafeRawPointer?, length replacementLength: Int) {
+        if let replacementBytes = replacementBytes {
+            let bytePtr = replacementBytes.bindMemory(to: UInt8.self, capacity: replacementLength)
+            CFDataReplaceBytes(_cfMutableObject, CFRangeMake(range.location, range.length), bytePtr, replacementLength)
+        }
     }
 }
 
diff --git a/Foundation/NSFileHandle.swift b/Foundation/NSFileHandle.swift
index 5f3667ecc5..8e75b6c485 100644
--- a/Foundation/NSFileHandle.swift
+++ b/Foundation/NSFileHandle.swift
@@ -118,7 +118,7 @@ open class FileHandle : NSObject, NSSecureCoding {
     open func write(_ data: Data) {
         data.enumerateBytes() { (bytes, range, stop) in
             do {
-                try NSData.writeToFileDescriptor(self._fd, path: nil, buf: UnsafeRawPointer(bytes.baseAddress!), length: bytes.count)
+                try NSData.write(toFileDescriptor: self._fd, path: nil, buf: UnsafeRawPointer(bytes.baseAddress!), length: bytes.count)
             } catch {
                 fatalError("Write failure")
             }
diff --git a/Foundation/NSFileManager.swift b/Foundation/NSFileManager.swift
index bd5aaefe9c..6205a5898c 100644
--- a/Foundation/NSFileManager.swift
+++ b/Foundation/NSFileManager.swift
@@ -602,7 +602,7 @@ open class FileManager : NSObject {
     
     open func createFile(atPath path: String, contents data: Data?, attributes attr: [String : Any]? = [:]) -> Bool {
         do {
-            try (data ?? Data()).write(to: URL(fileURLWithPath: path), options: .dataWritingAtomic)
+            try (data ?? Data()).write(to: URL(fileURLWithPath: path), options: .atomic)
             return true
         } catch _ {
             return false
diff --git a/Foundation/NSNotification.swift b/Foundation/NSNotification.swift
index 266b1bf9f6..edefcfaeea 100755
--- a/Foundation/NSNotification.swift
+++ b/Foundation/NSNotification.swift
@@ -7,14 +7,6 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 
-public func ==(lhs: NSNotification.Name, rhs: NSNotification.Name) -> Bool {
-    return lhs.rawValue == rhs.rawValue
-}
-
-public func <(lhs: NSNotification.Name, rhs: NSNotification.Name) -> Bool {
-    return lhs.rawValue < rhs.rawValue
-}
-
 open class NSNotification: NSObject, NSCopying, NSCoding {
     public struct Name : RawRepresentable, Equatable, Hashable, Comparable {
         public private(set) var rawValue: String
@@ -25,6 +17,14 @@ open class NSNotification: NSObject, NSCopying, NSCoding {
         public var hashValue: Int {
             return self.rawValue.hashValue
         }
+        
+        public static func ==(lhs: Name, rhs: Name) -> Bool {
+            return lhs.rawValue == rhs.rawValue
+        }
+        
+        public static func <(lhs: Name, rhs: Name) -> Bool {
+            return lhs.rawValue < rhs.rawValue
+        }
     }
 
     private(set) open var name: Name
@@ -38,7 +38,7 @@ open class NSNotification: NSObject, NSCopying, NSCoding {
         fatalError()
     }
     
-    public init(name: Name, object: Any?, userInfo: [AnyHashable : Any]?) {
+    public init(name: Name, object: Any?, userInfo: [AnyHashable : Any]? = nil) {
         self.name = name
         self.object = object
         self.userInfo = userInfo
@@ -99,12 +99,6 @@ open class NSNotification: NSObject, NSCopying, NSCoding {
     }
 }
 
-extension NSNotification {
-    public convenience init(name aName: Name, object anObject: Any?) {
-        self.init(name: aName, object: anObject, userInfo: nil)
-    }
-}
-
 private class NSNotificationReceiver : NSObject {
     fileprivate weak var object: NSObject?
     fileprivate var name: Notification.Name?
@@ -164,11 +158,11 @@ open class NotificationCenter: NSObject {
         _observers = [NSNotificationReceiver]()
     }
     
-    open class func defaultCenter() -> NotificationCenter {
+    open class var `default`: NotificationCenter {
         return _defaultCenter
     }
     
-    open func postNotification(_ notification: Notification) {
+    open func post(_ notification: Notification) {
 
         let sendTo = _observersLock.synchronized({
             return _observers.observersMatchingName(notification.name, sender: notification.object)
@@ -183,31 +177,26 @@ open class NotificationCenter: NSObject {
         }
     }
 
-    open func postNotificationName(_ aName: Notification.Name, object anObject: AnyObject?) {
-        let notification = Notification(name: aName, object: anObject)
-        postNotification(notification)
-    }
-
-    open func postNotificationName(_ aName: Notification.Name, object anObject: AnyObject?, userInfo aUserInfo: [AnyHashable : Any]?) {
+    open func post(name aName: Notification.Name, object anObject: AnyObject?, userInfo aUserInfo: [AnyHashable : Any]? = nil) {
         let notification = Notification(name: aName, object: anObject, userInfo: aUserInfo)
-        postNotification(notification)
+        post(notification)
     }
 
     open func removeObserver(_ observer: AnyObject) {
         removeObserver(observer, name: nil, object: nil)
     }
 
-    open func removeObserver(_ observer: Any, name: Notification.Name?, object: Any?) {
+    open func removeObserver(_ observer: Any, name aName: NSNotification.Name?, object: Any?) {
         guard let observer = observer as? NSObject else {
             return
         }
 
         _observersLock.synchronized({
-            self._observers = _observers.filterOutObserver(observer, name: name, object: object)
+            self._observers = _observers.filterOutObserver(observer, name: aName, object: object)
         })
     }
     
-    open func addObserverForName(_ name: Notification.Name?, object obj: Any?, queue: OperationQueue?, usingBlock block: @escaping (Notification) -> Void) -> NSObjectProtocol {
+    open func addObserver(forName name: Notification.Name?, object obj: Any?, queue: OperationQueue?, usingBlock block: @escaping (Notification) -> Void) -> NSObjectProtocol {
         if queue != nil {
             NSUnimplemented()
         }
diff --git a/Foundation/NSNotificationQueue.swift b/Foundation/NSNotificationQueue.swift
index da50793ec1..86ff1fce84 100644
--- a/Foundation/NSNotificationQueue.swift
+++ b/Foundation/NSNotificationQueue.swift
@@ -60,7 +60,7 @@ open class NotificationQueue: NSObject {
     private static var _defaultQueue = NSThreadSpecific<NotificationQueue>()
     open class func defaultQueue() -> NotificationQueue {
         return _defaultQueue.get() {
-            return NotificationQueue(notificationCenter: NotificationCenter.defaultCenter())
+            return NotificationQueue(notificationCenter: NotificationCenter.default)
         }
     }
     
@@ -92,9 +92,9 @@ open class NotificationQueue: NSObject {
 
         switch postingStyle {
         case .postNow:
-            let currentMode = RunLoop.current().currentMode
+            let currentMode = RunLoop.current.currentMode
             if currentMode == nil || runloopModes.contains(currentMode!) {
-                self.notificationCenter.postNotification(notification)
+                self.notificationCenter.post(notification)
             }
         case .postASAP: // post at the end of the current notification callout or timer
             addRunloopObserver(self.asapRunloopObserver)
@@ -131,19 +131,19 @@ open class NotificationQueue: NSObject {
     // MARK: Private
 
     private func addRunloopObserver(_ observer: CFRunLoopObserver) {
-        CFRunLoopAddObserver(RunLoop.current()._cfRunLoop, observer, kCFRunLoopDefaultMode)
-        CFRunLoopAddObserver(RunLoop.current()._cfRunLoop, observer, kCFRunLoopCommonModes)
+        CFRunLoopAddObserver(RunLoop.current._cfRunLoop, observer, kCFRunLoopDefaultMode)
+        CFRunLoopAddObserver(RunLoop.current._cfRunLoop, observer, kCFRunLoopCommonModes)
     }
 
     private func removeRunloopObserver(_ observer: CFRunLoopObserver) {
-        CFRunLoopRemoveObserver(RunLoop.current()._cfRunLoop, observer, kCFRunLoopDefaultMode)
-        CFRunLoopRemoveObserver(RunLoop.current()._cfRunLoop, observer, kCFRunLoopCommonModes)
+        CFRunLoopRemoveObserver(RunLoop.current._cfRunLoop, observer, kCFRunLoopDefaultMode)
+        CFRunLoopRemoveObserver(RunLoop.current._cfRunLoop, observer, kCFRunLoopCommonModes)
     }
 
     private func notify(_ currentMode: RunLoopMode?, notificationList: inout NSNotificationList) {
         for (idx, (notification, modes)) in notificationList.enumerated().reversed() {
             if currentMode == nil || modes.contains(currentMode!) {
-                self.notificationCenter.postNotification(notification)
+                self.notificationCenter.post(notification)
                 notificationList.remove(at: idx)
             }
         }
@@ -153,7 +153,7 @@ open class NotificationQueue: NSObject {
      Gets queues from the notificationQueueList and posts all notification from the list related to the postingStyle parameter.
      */
     private func notifyQueues(_ postingStyle: PostingStyle) {
-        let currentMode = RunLoop.current().currentMode
+        let currentMode = RunLoop.current.currentMode
         for queue in NotificationQueue.notificationQueueList {
             let notificationQueue = queue as! NotificationQueue
             if postingStyle == .postWhenIdle {
diff --git a/Foundation/NSPort.swift b/Foundation/NSPort.swift
index 16f0c56c8c..d7bd5ac6aa 100644
--- a/Foundation/NSPort.swift
+++ b/Foundation/NSPort.swift
@@ -10,10 +10,13 @@
 
 public typealias SocketNativeHandle = Int32
 
-public let NSPortDidBecomeInvalidNotification: String = "NSPortDidBecomeInvalidNotification"
+extension Port {
+    public static let didBecomeInvalidNotification  = NSNotification.Name(rawValue:  "NSPortDidBecomeInvalidNotification")
+}
 
 open class Port : NSObject, NSCopying, NSCoding {
     
+    
     public override init() {
         
     }
@@ -34,7 +37,7 @@ open class Port : NSObject, NSCopying, NSCoding {
         NSUnimplemented()
     }
 
-    open var valid: Bool {
+    open var isValid: Bool {
         NSUnimplemented()
     }
     
@@ -70,7 +73,7 @@ open class Port : NSObject, NSCopying, NSCoding {
 }
 
 extension PortDelegate {
-    func handlePortMessage(_ message: PortMessage) { }
+    func handle(_ message: PortMessage) { }
 }
 
 public protocol PortDelegate : class {
@@ -128,7 +131,7 @@ open class SocketPort : Port {
         NSUnimplemented()
     }
     
-    /*@NSCopying*/ open var address: Data {
+    open var address: Data {
         NSUnimplemented()
     }
     
diff --git a/Foundation/NSRunLoop.swift b/Foundation/NSRunLoop.swift
index a75a36b6a5..82f2ccafce 100644
--- a/Foundation/NSRunLoop.swift
+++ b/Foundation/NSRunLoop.swift
@@ -64,11 +64,11 @@ open class RunLoop: NSObject {
         _cfRunLoop = cfObject
     }
 
-    open class func current() -> RunLoop {
+    open class var current: RunLoop {
         return _CFRunLoopGet2(CFRunLoopGetCurrent()) as! RunLoop
     }
 
-    open class func main() -> RunLoop {
+    open class var main: RunLoop {
         return _CFRunLoopGet2(CFRunLoopGetMain()) as! RunLoop
     }
 
@@ -116,7 +116,7 @@ open class RunLoop: NSObject {
         return Date(timeIntervalSinceReferenceDate: nextTimerFireAbsoluteTime)
     }
 
-    open func acceptInputForMode(_ mode: String, before limitDate: Date) {
+    open func acceptInput(forMode mode: String, before limitDate: Date) {
         if _cfRunLoop !== CFRunLoopGetCurrent() {
             return
         }
diff --git a/Foundation/NSStream.swift b/Foundation/NSStream.swift
index 03f3d66cd8..d40d62990f 100644
--- a/Foundation/NSStream.swift
+++ b/Foundation/NSStream.swift
@@ -32,6 +32,14 @@ extension Stream {
         public var hashValue: Int {
             return rawValue.hashValue
         }
+        
+        public static func ==(lhs: Stream.PropertyKey, rhs: Stream.PropertyKey) -> Bool {
+            return lhs.rawValue == rhs.rawValue
+        }
+        
+        public static func <(lhs: Stream.PropertyKey, rhs: Stream.PropertyKey) -> Bool {
+            return lhs.rawValue < rhs.rawValue
+        }
     }
     
     public enum Status : UInt {
@@ -50,6 +58,7 @@ extension Stream {
         public let rawValue : UInt
         public init(rawValue: UInt) { self.rawValue = rawValue }
 
+        // NOTE: on darwin these are vars
         public static let openCompleted = Event(rawValue: 1 << 0)
         public static let hasBytesAvailable = Event(rawValue: 1 << 1)
         public static let hasSpaceAvailable = Event(rawValue: 1 << 2)
@@ -58,13 +67,6 @@ extension Stream {
     }
 }
 
-public func ==(lhs: Stream.PropertyKey, rhs: Stream.PropertyKey) -> Bool {
-    return lhs.rawValue == rhs.rawValue
-}
-
-public func <(lhs: Stream.PropertyKey, rhs: Stream.PropertyKey) -> Bool {
-    return lhs.rawValue < rhs.rawValue
-}
 
 
 // NSStream is an abstract class encapsulating the common API to NSInputStream and NSOutputStream.
@@ -86,11 +88,11 @@ open class Stream: NSObject {
     open weak var delegate: StreamDelegate?
     // By default, a stream is its own delegate, and subclassers of NSInputStream and NSOutputStream must maintain this contract. [someStream setDelegate:nil] must restore this behavior. As usual, delegates are not retained.
     
-    open func propertyForKey(_ key: String) -> AnyObject? {
+    open func property(forKey key: PropertyKey) -> AnyObject? {
         NSUnimplemented()
     }
     
-    open func setProperty(_ property: AnyObject?, forKey key: String) -> Bool {
+    open func setProperty(_ property: AnyObject?, forKey key: PropertyKey) -> Bool {
         NSUnimplemented()
     }
 
@@ -108,7 +110,7 @@ open class Stream: NSObject {
         NSRequiresConcreteImplementation()
     }
     
-    /*@NSCopying */open var streamError: NSError? {
+    open var streamError: NSError? {
         NSUnimplemented()
     }
 }
@@ -175,11 +177,12 @@ open class NSOutputStream : Stream {
     open var hasSpaceAvailable: Bool {
         return CFWriteStreamCanAcceptBytes(_stream)
     }
-    
+    // NOTE: on Darwin this is     'open class func toMemory() -> Self'
     required public init(toMemory: ()) {
         _stream = CFWriteStreamCreateWithAllocatedBuffers(kCFAllocatorDefault, kCFAllocatorDefault)
     }
 
+    // TODO: this should use the real buffer API
     public init(toBuffer buffer: UnsafeMutablePointer<UInt8>, capacity: Int) {
         _stream = CFWriteStreamCreateWithBuffer(kCFAllocatorSystemDefault, buffer, capacity)
     }
@@ -209,12 +212,12 @@ open class NSOutputStream : Stream {
         return self.init(toMemory: ())
     }
     
-    open override func propertyForKey(_ key: String) -> AnyObject? {
-        return CFWriteStreamCopyProperty(_stream, key._cfObject)
+    open override func property(forKey key: PropertyKey) -> AnyObject? {
+        return CFWriteStreamCopyProperty(_stream, key.rawValue._cfObject)
     }
     
-    open  override func setProperty(_ property: AnyObject?, forKey key: String) -> Bool {
-        return CFWriteStreamSetProperty(_stream, key._cfObject, property)
+    open  override func setProperty(_ property: AnyObject?, forKey key: PropertyKey) -> Bool {
+        return CFWriteStreamSetProperty(_stream, key.rawValue._cfObject, property)
     }
 }
 
@@ -241,56 +244,116 @@ public protocol StreamDelegate : class {
     func stream(_ aStream: Stream, handleEvent eventCode: Stream.Event)
 }
 
-// NSString constants for the propertyForKey/setProperty:forKey: API
-// String constants for the setting of the socket security level.
-// use this as the key for setting one of the following values for the security level of the target stream.
-public let NSStreamSocketSecurityLevelKey: String = "kCFStreamPropertySocketSecurityLevel"
-
-public let NSStreamSocketSecurityLevelNone: String = "kCFStreamSocketSecurityLevelNone"
-public let NSStreamSocketSecurityLevelSSLv2: String = "NSStreamSocketSecurityLevelSSLv2"
-public let NSStreamSocketSecurityLevelSSLv3: String = "NSStreamSocketSecurityLevelSSLv3"
-public let NSStreamSocketSecurityLevelTLSv1: String = "kCFStreamSocketSecurityLevelTLSv1"
-public let NSStreamSocketSecurityLevelNegotiatedSSL: String = "kCFStreamSocketSecurityLevelNegotiatedSSL"
-
-public let NSStreamSOCKSProxyConfigurationKey: String  = "kCFStreamPropertySOCKSProxy"
-// Value is an NSDictionary containing the key/value pairs below. The dictionary returned from SystemConfiguration for SOCKS proxies will work without alteration.
-
-public let NSStreamSOCKSProxyHostKey: String = "NSStreamSOCKSProxyKey"
-// Value is an NSString
-public let NSStreamSOCKSProxyPortKey: String = "NSStreamSOCKSPortKey"
-// Value is an NSNumber
-public let NSStreamSOCKSProxyVersionKey: String = "kCFStreamPropertySOCKSVersion"
-// Value is one of NSStreamSOCKSProxyVersion4 or NSStreamSOCKSProxyVersion5
-public let NSStreamSOCKSProxyUserKey: String = "kCFStreamPropertySOCKSUser"
-// Value is an NSString
-public let NSStreamSOCKSProxyPasswordKey: String = "kCFStreamPropertySOCKSPassword"
-// Value is an NSString
-
-public let NSStreamSOCKSProxyVersion4: String = "kCFStreamSocketSOCKSVersion4"
-// Value for NSStreamSOCKProxyVersionKey
-public let NSStreamSOCKSProxyVersion5: String = "kCFStreamSocketSOCKSVersion5"
-// Value for NSStreamSOCKProxyVersionKey
-
-public let NSStreamDataWrittenToMemoryStreamKey: String = "kCFStreamPropertyDataWritten"
-// Key for obtaining the data written to a memory stream.
-
-public let NSStreamFileCurrentOffsetKey: String = "kCFStreamPropertyFileCurrentOffset"
-// Value is an NSNumber representing the current absolute offset of the stream.
+// MARK: -
+extension Stream.PropertyKey {
+    public static let socketSecurityLevelKey = Stream.PropertyKey(rawValue: "kCFStreamPropertySocketSecurityLevel")
+    public static let socksProxyConfigurationKey = Stream.PropertyKey(rawValue: "kCFStreamPropertySOCKSProxy")
+    public static let dataWrittenToMemoryStreamKey = Stream.PropertyKey(rawValue: "kCFStreamPropertyDataWritten")    public static let fileCurrentOffsetKey = Stream.PropertyKey(rawValue: "kCFStreamPropertyFileCurrentOffset")
+    public static let networkServiceType = Stream.PropertyKey(rawValue: "kCFStreamNetworkServiceType")
+}
+
+// MARK: -
+public struct StreamSocketSecurityLevel : RawRepresentable, Equatable, Hashable, Comparable {
+    public let rawValue: String
+    public init(rawValue: String) {
+        self.rawValue = rawValue
+    }
+    public var hashValue: Int {
+        return rawValue.hashValue
+    }
+    public static func ==(lhs: StreamSocketSecurityLevel, rhs: StreamSocketSecurityLevel) -> Bool {
+        return lhs.rawValue == rhs.rawValue
+    }
+    public static func <(lhs: StreamSocketSecurityLevel, rhs: StreamSocketSecurityLevel) -> Bool {
+        return lhs.rawValue < rhs.rawValue
+    }
+}
+extension StreamSocketSecurityLevel {
+    public static let none = StreamSocketSecurityLevel(rawValue: "kCFStreamSocketSecurityLevelNone")
+    public static let ssLv2 = StreamSocketSecurityLevel(rawValue: "NSStreamSocketSecurityLevelSSLv2")
+    public static let ssLv3 = StreamSocketSecurityLevel(rawValue: "NSStreamSocketSecurityLevelSSLv3")
+    public static let tlSv1 = StreamSocketSecurityLevel(rawValue: "kCFStreamSocketSecurityLevelTLSv1")
+    public static let negotiatedSSL = StreamSocketSecurityLevel(rawValue: "kCFStreamSocketSecurityLevelNegotiatedSSL")
+}
+
+
+// MARK: -
+public struct StreamSOCKSProxyConfiguration : RawRepresentable, Equatable, Hashable, Comparable {
+    public let rawValue: String
+    public init(rawValue: String) {
+        self.rawValue = rawValue
+    }
+    public var hashValue: Int {
+        return rawValue.hashValue
+    }
+    public static func ==(lhs: StreamSOCKSProxyConfiguration, rhs: StreamSOCKSProxyConfiguration) -> Bool {
+        return lhs.rawValue == rhs.rawValue
+    }
+    public static func <(lhs: StreamSOCKSProxyConfiguration, rhs: StreamSOCKSProxyConfiguration) -> Bool {
+        return lhs.rawValue < rhs.rawValue
+    }
+}
+extension StreamSOCKSProxyConfiguration {
+    public static let hostKey = StreamSOCKSProxyConfiguration(rawValue: "NSStreamSOCKSProxyKey")
+    public static let portKey = StreamSOCKSProxyConfiguration(rawValue: "NSStreamSOCKSPortKey")
+    public static let versionKey = StreamSOCKSProxyConfiguration(rawValue: "kCFStreamPropertySOCKSVersion")
+    public static let userKey = StreamSOCKSProxyConfiguration(rawValue: "kCFStreamPropertySOCKSUser")
+    public static let passwordKey = StreamSOCKSProxyConfiguration(rawValue: "kCFStreamPropertySOCKSPassword")
+}
+
+
+// MARK: -
+public struct StreamSOCKSProxyVersion : RawRepresentable, Equatable, Hashable, Comparable {
+    public let rawValue: String
+    public init(rawValue: String) {
+        self.rawValue = rawValue
+    }
+    public var hashValue: Int {
+        return rawValue.hashValue
+    }
+    public static func ==(lhs: StreamSOCKSProxyVersion, rhs: StreamSOCKSProxyVersion) -> Bool {
+        return lhs.rawValue == rhs.rawValue
+    }
+    public static func <(lhs: StreamSOCKSProxyVersion, rhs: StreamSOCKSProxyVersion) -> Bool {
+        return lhs.rawValue < rhs.rawValue
+    }
+}
+extension StreamSOCKSProxyVersion {
+    public static let version4 = StreamSOCKSProxyVersion(rawValue: "kCFStreamSocketSOCKSVersion4")
+    public static let version5 = StreamSOCKSProxyVersion(rawValue: "kCFStreamSocketSOCKSVersion5")
+}
+
 
+// MARK: - Supported network service types
+public struct StreamNetworkServiceTypeValue : RawRepresentable, Equatable, Hashable, Comparable {
+    public let rawValue: String
+    public init(rawValue: String) {
+        self.rawValue = rawValue
+    }
+    public var hashValue: Int {
+        return rawValue.hashValue
+    }
+    public static func ==(lhs: StreamNetworkServiceTypeValue, rhs: StreamNetworkServiceTypeValue) -> Bool {
+        return lhs.rawValue == rhs.rawValue
+    }
+    public static func <(lhs: StreamNetworkServiceTypeValue, rhs: StreamNetworkServiceTypeValue) -> Bool {
+        return lhs.rawValue < rhs.rawValue
+    }
+}
+extension StreamNetworkServiceTypeValue {
+    public static let voIP = StreamNetworkServiceTypeValue(rawValue: "kCFStreamNetworkServiceTypeVoIP")
+    public static let video = StreamNetworkServiceTypeValue(rawValue: "kCFStreamNetworkServiceTypeVideo")
+    public static let background = StreamNetworkServiceTypeValue(rawValue: "kCFStreamNetworkServiceTypeBackground")
+    public static let voice = StreamNetworkServiceTypeValue(rawValue: "kCFStreamNetworkServiceTypeVoice")
+    public static let callSignaling = StreamNetworkServiceTypeValue(rawValue: "kCFStreamNetworkServiceTypeVoice")
+}
+
+
+
+
+// MARK: - Error Domains
 // NSString constants for error domains.
 public let NSStreamSocketSSLErrorDomain: String = "NSStreamSocketSSLErrorDomain"
 // SSL errors are to be interpreted via <Security/SecureTransport.h>
 public let NSStreamSOCKSErrorDomain: String = "NSStreamSOCKSErrorDomain"
 
-// Property key to specify the type of service for the stream.  This
-// allows the system to properly handle the request with respect to
-// routing, suspension behavior and other networking related attributes
-// appropriate for the given service type.  The service types supported
-// are documented below.
-public let NSStreamNetworkServiceType: String = "kCFStreamNetworkServiceType"
-// Supported network service types:
-public let NSStreamNetworkServiceTypeVoIP: String = "kCFStreamNetworkServiceTypeVoIP"
-public let NSStreamNetworkServiceTypeVideo: String = "kCFStreamNetworkServiceTypeVideo"
-public let NSStreamNetworkServiceTypeBackground: String = "kCFStreamNetworkServiceTypeBackground"
-public let NSStreamNetworkServiceTypeVoice: String = "kCFStreamNetworkServiceTypeVoice"
-
diff --git a/Foundation/NSString.swift b/Foundation/NSString.swift
index d2a15bbd1f..0cf7b2a561 100644
--- a/Foundation/NSString.swift
+++ b/Foundation/NSString.swift
@@ -791,7 +791,7 @@ extension NSString {
         return String.Encoding.unicode.rawValue
     }
     
-    public func data(using encoding: UInt, allowLossyConversion lossy: Bool) -> Data? {
+    public func data(using encoding: UInt, allowLossyConversion lossy: Bool = false) -> Data? {
         let len = length
         var reqSize = 0
         
@@ -804,7 +804,7 @@ extension NSString {
         if convertedLen != len {
             return nil 	// Not able to do it all...
         }
-                
+        
         if 0 < reqSize {
             var data = Data(count: reqSize)
             data.count = data.withUnsafeMutableBytes { (mutableBytes: UnsafeMutablePointer<UInt8>) -> Int in
@@ -1120,7 +1120,7 @@ extension NSString {
     internal func _writeTo(_ url: URL, _ useAuxiliaryFile: Bool, _ enc: UInt) throws {
         var data = Data()
         try _getExternalRepresentation(&data, url, enc)
-        try data.write(to: url, options: useAuxiliaryFile ? .dataWritingAtomic : [])
+        try data.write(to: url, options: useAuxiliaryFile ? .atomic : [])
     }
     
     open func write(to url: URL, atomically useAuxiliaryFile: Bool, encoding enc: UInt) throws {
diff --git a/Foundation/NSTask.swift b/Foundation/NSTask.swift
index 45c55074c2..5f4248d2d3 100644
--- a/Foundation/NSTask.swift
+++ b/Foundation/NSTask.swift
@@ -100,7 +100,7 @@ open class Task: NSObject {
         Once.lock.synchronized {
             if !Once.done {
                 let thread = Thread {
-                    managerThreadRunLoop = RunLoop.current()
+                    managerThreadRunLoop = RunLoop.current
                     var emptySourceContext = CFRunLoopSourceContext()
                     emptySourceContext.version = 0
                     emptySourceContext.retain = runLoopSourceRetain
@@ -367,7 +367,7 @@ open class Task: NSObject {
 
         close(taskSocketPair[1])
         
-        self.runLoop = RunLoop.current()
+        self.runLoop = RunLoop.current
         self.runLoopSourceContext = CFRunLoopSourceContext(version: 0,
                                                            info: Unmanaged.passUnretained(self).toOpaque(),
                                                            retain: { return runLoopSourceRetain($0) },
@@ -440,7 +440,7 @@ extension Task {
         
         repeat {
             
-        } while( self.running == true && RunLoop.current().run(mode: .defaultRunLoopMode, before: Date(timeIntervalSinceNow: 0.05)) )
+        } while( self.running == true && RunLoop.current.run(mode: .defaultRunLoopMode, before: Date(timeIntervalSinceNow: 0.05)) )
         
         self.runLoop = nil
     }
diff --git a/Foundation/NSXMLDocument.swift b/Foundation/NSXMLDocument.swift
index f7b378907c..ca82b6f065 100644
--- a/Foundation/NSXMLDocument.swift
+++ b/Foundation/NSXMLDocument.swift
@@ -82,7 +82,7 @@ open class XMLDocument : XMLNode {
         @abstract Returns a document created from the contents of an XML or HTML URL. Connection problems such as 404, parse errors are returned in <tt>error</tt>.
     */
     public convenience init(contentsOf url: URL, options: Options) throws {
-        let data = try Data(contentsOf: url, options: .dataReadingMappedIfSafe)
+        let data = try Data(contentsOf: url, options: .mappedIfSafe)
 
         try self.init(data: data, options: options)
     }
diff --git a/Foundation/NSXMLParser.swift b/Foundation/NSXMLParser.swift
index 8e0be0e79c..6da3dae96b 100644
--- a/Foundation/NSXMLParser.swift
+++ b/Foundation/NSXMLParser.swift
@@ -381,7 +381,7 @@ internal func _NSXMLParserProcessingInstruction(_ ctx: _CFXMLInterface, target:
 internal func _NSXMLParserCdataBlock(_ ctx: _CFXMLInterface, value: UnsafePointer<UInt8>, len: Int32) -> Void {
     let parser = ctx.parser
     if let delegate = parser.delegate {
-        delegate.parser(parser, foundCDATA: Data(bytes: UnsafeRawPointer(value), count: Int(len)))
+        delegate.parser(parser, foundCDATA: Data(bytes: value, count: Int(len)))
     }
 }
 
@@ -551,9 +551,9 @@ open class XMLParser : NSObject {
                 _bomChunk = nil
 
                 if (totalLength > 4) {
-                    let remainingData = allExistingData.withUnsafeBytes { (bytes: UnsafePointer<Int8>) -> Data in
+                    let remainingData = allExistingData.withUnsafeMutableBytes { (bytes: UnsafeMutablePointer<UInt8>) -> Data in
                         let ptr = bytes.advanced(by: 4)
-                        return Data(bytesNoCopy: UnsafeMutablePointer(mutating: ptr), count: totalLength - 4, deallocator: .none)
+                        return Data(bytesNoCopy: ptr, count: totalLength - 4, deallocator: .none)
                     }
                     
                     let _ = parseData(remainingData)
diff --git a/Foundation/Notification.swift b/Foundation/Notification.swift
index ed78dd13a5..46cbc64ee3 100644
--- a/Foundation/Notification.swift
+++ b/Foundation/Notification.swift
@@ -51,26 +51,33 @@ public struct Notification : ReferenceConvertible, Equatable, Hashable {
     
     // FIXME: Handle directly via API Notes
     public typealias Name = NSNotification.Name
-}
-
-public func ==(lhs: Notification, rhs: Notification) -> Bool {
-    if lhs.name.rawValue != rhs.name.rawValue {
-        return false
-    }
-    if let lhsObj = lhs.object {
-        if let rhsObj = rhs.object {
-            if _SwiftValue.store(lhsObj) !== _SwiftValue.store(rhsObj) {
+    
+    public static func ==(lhs: Notification, rhs: Notification) -> Bool {
+        if lhs.name.rawValue != rhs.name.rawValue {
+            return false
+        }
+        if let lhsObj = lhs.object {
+            if let rhsObj = rhs.object {
+                if _SwiftValue.store(lhsObj) !== _SwiftValue.store(rhsObj) {
+                    return false
+                }
+            } else {
                 return false
             }
-        } else {
+        } else if rhs.object != nil {
             return false
         }
-    } else if rhs.object != nil {
-        return false
+        return true
     }
-    return true
 }
 
+extension Notification : CustomReflectable {
+    public var customMirror: Mirror {
+        NSUnimplemented()
+    }
+}
+
+
 extension Notification : _ObjectTypeBridgeable {
     public static func _getObjectiveCType() -> Any.Type {
         return NSNotification.self
diff --git a/TestFoundation/TestNSData.swift b/TestFoundation/TestNSData.swift
index e68e0cc8ef..f204388d6e 100644
--- a/TestFoundation/TestNSData.swift
+++ b/TestFoundation/TestNSData.swift
@@ -17,8 +17,53 @@
 
 class TestNSData: XCTestCase {
     
+
+    // MARK: -
+    
+    // String of course has its own way to get data, but this way tests our own data struct
+    func dataFrom(_ string : String) -> Data {
+        // Create a Data out of those bytes
+        return string.utf8CString.withUnsafeBufferPointer { (ptr) in
+            ptr.baseAddress!.withMemoryRebound(to: UInt8.self, capacity: ptr.count) {
+                // Subtract 1 so we don't get the null terminator byte. This matches NSString behavior.
+                return Data(bytes: $0, count: ptr.count - 1)
+            }
+        }
+    }
+    
     static var allTests: [(String, (TestNSData) -> () throws -> Void)] {
         return [
+            ("testBasicConstruction", testBasicConstruction),
+            ("test_base64Data_medium", test_base64Data_medium),
+            ("test_base64Data_small", test_base64Data_small),
+            ("test_basicReadWrite", test_basicReadWrite),
+            ("test_bufferSizeCalculation", test_bufferSizeCalculation),
+            // ("test_dataHash", test_dataHash),   Disabled due to lack of brdiging in swift runtime -- infinite loops
+            ("test_genericBuffers", test_genericBuffers),
+            // ("test_writeFailure", test_writeFailure), segfaults
+            ("testBasicConstruction", testBasicConstruction),
+            ("testBridgingDefault", testBridgingDefault),
+            ("testBridgingMutable", testBridgingMutable),
+            ("testCopyBytes_oversized", testCopyBytes_oversized),
+            ("testCopyBytes_ranges", testCopyBytes_ranges),
+            ("testCopyBytes_undersized", testCopyBytes_undersized),
+            // ("testCopyBytes", testCopyBytes),  Disabled to due failure, we want this passing - but API matching is more important right now
+            ("testCustomDeallocator", testCustomDeallocator),
+            ("testDataInSet", testDataInSet),
+            ("testEquality", testEquality),
+            ("testGenericAlgorithms", testGenericAlgorithms),
+            ("testInitializationWithArray", testInitializationWithArray),
+            ("testInsertData", testInsertData),
+            ("testLoops", testLoops),
+            ("testMutableData", testMutableData),
+            ("testRange", testRange),
+            ("testReplaceSubrange", testReplaceSubrange),
+            ("testReplaceSubrange2", testReplaceSubrange2),
+            ("testReplaceSubrange3", testReplaceSubrange3),
+            ("testReplaceSubrange4", testReplaceSubrange4),
+            ("testReplaceSubrange5", testReplaceSubrange5),
+            
+            
             ("test_description", test_description),
             ("test_emptyDescription", test_emptyDescription),
             ("test_longDescription", test_longDescription),
@@ -51,7 +96,7 @@ class TestNSData: XCTestCase {
         let saveData = try! Data(contentsOf: Bundle.main.url(forResource: "Test", withExtension: "plist")!)
         let savePath = URL(fileURLWithPath: "/var/tmp/Test.plist")
         do {
-            try saveData.write(to: savePath, options: .dataWritingAtomic)
+            try saveData.write(to: savePath, options: .atomic)
             let fileManager = FileManager.default
             XCTAssertTrue(fileManager.fileExists(atPath: savePath.path))
             try! fileManager.removeItem(atPath: savePath.path)
@@ -198,7 +243,7 @@ class TestNSData: XCTestCase {
             XCTFail("Could not encode UTF-8 string")
             return
         }
-        let encodedData = data.base64EncodedData([])
+        let encodedData = data.base64EncodedData()
         guard let encodedTextResult = String(data: encodedData, encoding: String.Encoding.ascii) else {
             XCTFail("Could not convert encoded data to an ASCII String")
             return
@@ -213,7 +258,7 @@ class TestNSData: XCTestCase {
             XCTFail("Could not encode UTF-8 string")
             return
         }
-        let encodedData = data.base64EncodedData([.encoding64CharacterLineLength, .encodingEndLineWithLineFeed])
+        let encodedData = data.base64EncodedData(options: [.lineLength64Characters, .endLineWithLineFeed])
         guard let encodedTextResult = String(data: encodedData, encoding: String.Encoding.ascii) else {
             XCTFail("Could not convert encoded data to an ASCII String")
             return
@@ -228,7 +273,7 @@ class TestNSData: XCTestCase {
             XCTFail("Could not encode UTF-8 string")
             return
         }
-        let encodedData = data.base64EncodedData([.encoding76CharacterLineLength, .encodingEndLineWithCarriageReturn])
+        let encodedData = data.base64EncodedData(options: [.lineLength76Characters, .endLineWithCarriageReturn])
         guard let encodedTextResult = String(data: encodedData, encoding: String.Encoding.ascii) else {
             XCTFail("Could not convert encoded data to an ASCII String")
             return
@@ -243,7 +288,7 @@ class TestNSData: XCTestCase {
             XCTFail("Could not encode UTF-8 string")
             return
         }
-        let encodedData = data.base64EncodedData([.encoding76CharacterLineLength, .encodingEndLineWithCarriageReturn, .encodingEndLineWithLineFeed])
+        let encodedData = data.base64EncodedData(options: [.lineLength76Characters, .endLineWithCarriageReturn, .endLineWithLineFeed])
         guard let encodedTextResult = String(data: encodedData, encoding: String.Encoding.ascii) else {
             XCTFail("Could not convert encoded data to an ASCII String")
             return
@@ -258,7 +303,7 @@ class TestNSData: XCTestCase {
             XCTFail("Could not encode UTF-8 string")
             return
         }
-        let encodedTextResult = data.base64EncodedString([])
+        let encodedTextResult = data.base64EncodedString()
         XCTAssertEqual(encodedTextResult, encodedText)
 
     }
@@ -352,9 +397,9 @@ class TestNSData: XCTestCase {
         var data = Data(bytes: [0, 0, 0, 0, 0])
         let newData = Data(bytes: [1, 2, 3, 4, 5])
 
-        // test Data.replaceBytes(in:with:)
+        // test replaceSubrange(_, with:)
         XCTAssertFalse(data == newData)
-        data.replaceBytes(in: data.startIndex..<data.endIndex, with: newData)
+        data.replaceSubrange(data.startIndex..<data.endIndex, with: newData)
         XCTAssertTrue(data == newData)
 
         // subscript(index:) uses replaceBytes so use it to test edge conditions
@@ -395,3 +440,591 @@ class TestNSData: XCTestCase {
     }
 }
 
+// Tests from Swift SDK Overlay
+extension TestNSData {
+    func testBasicConstruction() throws {
+        
+        // Make sure that we were able to create some data
+        let hello = dataFrom("hello")
+        let helloLength = hello.count
+        XCTAssertEqual(hello[0], 0x68, "Unexpected first byte")
+        
+        let world = dataFrom(" world")
+        var helloWorld = hello
+        world.withUnsafeBytes {
+            helloWorld.append($0, count: world.count)
+        }
+        
+        XCTAssertEqual(hello[0], 0x68, "First byte should not have changed")
+        XCTAssertEqual(hello.count, helloLength, "Length of first data should not have changed")
+        XCTAssertEqual(helloWorld.count, hello.count + world.count, "The total length should include both buffers")
+    }
+    
+    func testInitializationWithArray() {
+        let data = Data(bytes: [1, 2, 3])
+        XCTAssertEqual(3, data.count)
+        
+        let data2 = Data(bytes: [1, 2, 3].filter { $0 >= 2 })
+        XCTAssertEqual(2, data2.count)
+        
+        let data3 = Data(bytes: [1, 2, 3, 4, 5][1..<3])
+        XCTAssertEqual(2, data3.count)
+    }
+    
+    func testMutableData() {
+        let hello = dataFrom("hello")
+        let helloLength = hello.count
+        XCTAssertEqual(hello[0], 0x68, "Unexpected first byte")
+        
+        // Double the length
+        var mutatingHello = hello
+        mutatingHello.count *= 2
+        
+        XCTAssertEqual(hello.count, helloLength, "The length of the initial data should not have changed")
+        XCTAssertEqual(mutatingHello.count, helloLength * 2, "The length should have changed")
+        
+        // Get the underlying data for hello2
+        mutatingHello.withUnsafeMutableBytes { (bytes : UnsafeMutablePointer<UInt8>) in
+            XCTAssertEqual(bytes.pointee, 0x68, "First byte should be 0x68")
+            
+            // Mutate it
+            bytes.pointee = 0x67
+            XCTAssertEqual(bytes.pointee, 0x67, "First byte should be 0x67")
+            XCTAssertEqual(mutatingHello[0], 0x67, "First byte accessed via other method should still be 0x67")
+            
+            // Verify that the first data is still correct
+            XCTAssertEqual(hello[0], 0x68, "The first byte should still be 0x68")
+        }
+    }
+    
+
+    
+    func testBridgingDefault() {
+        let hello = dataFrom("hello")
+        // Convert from struct Data to NSData
+        if let s = NSString(data: hello, encoding: String.Encoding.utf8.rawValue) {
+            XCTAssertTrue(s.isEqual(to: "hello"), "The strings should be equal")
+        }
+        
+        // Convert from NSData to struct Data
+        let goodbye = dataFrom("goodbye")
+        if let resultingData = NSString(string: "goodbye").data(using: String.Encoding.utf8.rawValue) {
+            XCTAssertEqual(resultingData[0], goodbye[0], "First byte should be equal")
+        }
+    }
+    
+    func testBridgingMutable() {
+        // Create a mutable data
+        var helloWorld = dataFrom("hello")
+        helloWorld.append(dataFrom("world"))
+        
+        // Convert from struct Data to NSData
+        if let s = NSString(data: helloWorld, encoding: String.Encoding.utf8.rawValue) {
+            XCTAssertTrue(s.isEqual(to: "helloworld"), "The strings should be equal")
+        }
+        
+    }
+    
+  
+    func testEquality() {
+        let d1 = dataFrom("hello")
+        let d2 = dataFrom("hello")
+        
+        // Use == explicitly here to make sure we're calling the right methods
+        XCTAssertTrue(d1 == d2, "Data should be equal")
+    }
+    
+    func testDataInSet() {
+        let d1 = dataFrom("Hello")
+        let d2 = dataFrom("Hello")
+        let d3 = dataFrom("World")
+        
+        var s = Set<Data>()
+        s.insert(d1)
+        s.insert(d2)
+        s.insert(d3)
+        
+        XCTAssertEqual(s.count, 2, "Expected only two entries in the Set")
+    }
+    
+    func testReplaceSubrange() {
+        var hello = dataFrom("Hello")
+        let world = dataFrom("World")
+        
+        hello[0] = world[0]
+        XCTAssertEqual(hello[0], world[0])
+        
+        var goodbyeWorld = dataFrom("Hello World")
+        let goodbye = dataFrom("Goodbye")
+        let expected = dataFrom("Goodbye World")
+        
+        goodbyeWorld.replaceSubrange(0..<5, with: goodbye)
+        XCTAssertEqual(goodbyeWorld, expected)
+    }
+    
+    func testReplaceSubrange2() {
+        let hello = dataFrom("Hello")
+        let world = dataFrom(" World")
+        let goodbye = dataFrom("Goodbye")
+        let expected = dataFrom("Goodbye World")
+        
+        var mutateMe = hello
+        mutateMe.append(world)
+        
+        if let found = mutateMe.range(of: hello) {
+            mutateMe.replaceSubrange(found, with: goodbye)
+        }
+        XCTAssertEqual(mutateMe, expected)
+    }
+    
+    func testReplaceSubrange3() {
+        // The expected result
+        let expectedBytes : [UInt8] = [1, 2, 9, 10, 11, 12, 13]
+        let expected = expectedBytes.withUnsafeBufferPointer {
+            return Data(buffer: $0)
+        }
+        
+        // The data we'll mutate
+        let someBytes : [UInt8] = [1, 2, 3, 4, 5]
+        var a = someBytes.withUnsafeBufferPointer {
+            return Data(buffer: $0)
+        }
+        
+        // The bytes we'll insert
+        let b : [UInt8] = [9, 10, 11, 12, 13]
+        b.withUnsafeBufferPointer {
+            a.replaceSubrange(2..<5, with: $0)
+        }
+        XCTAssertEqual(expected, a)
+    }
+    
+    func testReplaceSubrange4() {
+        let expectedBytes : [UInt8] = [1, 2, 9, 10, 11, 12, 13]
+        let expected = Data(bytes: expectedBytes)
+        
+        // The data we'll mutate
+        let someBytes : [UInt8] = [1, 2, 3, 4, 5]
+        var a = Data(bytes: someBytes)
+        
+        // The bytes we'll insert
+        let b : [UInt8] = [9, 10, 11, 12, 13]
+        a.replaceSubrange(2..<5, with: b)
+        XCTAssertEqual(expected, a)
+    }
+    
+    func testReplaceSubrange5() {
+        var d = Data(bytes: [1, 2, 3])
+        d.replaceSubrange(0..<0, with: [4])
+        XCTAssertEqual(Data(bytes: [4, 1, 2, 3]), d)
+        
+        d.replaceSubrange(0..<4, with: [9])
+        XCTAssertEqual(Data(bytes: [9]), d)
+        
+        d.replaceSubrange(0..<d.count, with: [])
+        XCTAssertEqual(Data(), d)
+        
+        d.replaceSubrange(0..<0, with: [1, 2, 3, 4])
+        XCTAssertEqual(Data(bytes: [1, 2, 3, 4]), d)
+        
+        d.replaceSubrange(1..<3, with: [9, 8])
+        XCTAssertEqual(Data(bytes: [1, 9, 8, 4]), d)
+        
+        d.replaceSubrange(d.count..<d.count, with: [5])
+        XCTAssertEqual(Data(bytes: [1, 9, 8, 4, 5]), d)
+    }
+    
+    func testRange() {
+        let helloWorld = dataFrom("Hello World")
+        let goodbye = dataFrom("Goodbye")
+        let hello = dataFrom("Hello")
+        
+        do {
+            let found = helloWorld.range(of: goodbye)
+            XCTAssertTrue(found == nil || found!.isEmpty)
+        }
+        
+        do {
+            let found = helloWorld.range(of: goodbye, options: .anchored)
+            XCTAssertTrue(found == nil || found!.isEmpty)
+        }
+        
+        do {
+            let found = helloWorld.range(of: hello, in: 7..<helloWorld.count)
+            XCTAssertTrue(found == nil || found!.isEmpty)
+        }
+    }
+    
+    func testInsertData() {
+        let hello = dataFrom("Hello")
+        let world = dataFrom(" World")
+        let expected = dataFrom("Hello World")
+        var helloWorld = dataFrom("")
+        
+        helloWorld.replaceSubrange(0..<0, with: world)
+        helloWorld.replaceSubrange(0..<0, with: hello)
+        
+        XCTAssertEqual(helloWorld, expected)
+    }
+    
+    func testLoops() {
+        let hello = dataFrom("Hello")
+        var count = 0
+        for _ in hello {
+            count += 1
+        }
+        XCTAssertEqual(count, 5)
+    }
+    
+    func testGenericAlgorithms() {
+        let hello = dataFrom("Hello World")
+        
+        let isCapital = { (byte : UInt8) in byte >= 65 && byte <= 90 }
+        
+        let allCaps = hello.filter(isCapital)
+        XCTAssertEqual(allCaps.count, 2)
+        
+        let capCount = hello.reduce(0) { isCapital($1) ? $0 + 1 : $0 }
+        XCTAssertEqual(capCount, 2)
+        
+        let allLower = hello.map { isCapital($0) ? $0 + 31 : $0 }
+        XCTAssertEqual(allLower.count, hello.count)
+    }
+    
+    func testCustomDeallocator() {
+        var deallocatorCalled = false
+        
+        // Scope the data to a block to control lifecycle
+        do {
+            let buffer = malloc(16)!
+            let bytePtr = buffer.bindMemory(to: UInt8.self, capacity: 16)
+            var data = Data(bytesNoCopy: bytePtr, count: 16, deallocator: .custom({ (ptr, size) in
+                deallocatorCalled = true
+                free(UnsafeMutableRawPointer(ptr))
+            }))
+            // Use the data
+            data[0] = 1
+        }
+        
+        XCTAssertTrue(deallocatorCalled, "Custom deallocator was never called")
+    }
+    
+    func testCopyBytes() {
+        let c = 10
+        let underlyingBuffer = malloc(c * MemoryLayout<UInt16>.stride)!
+        let u16Ptr = underlyingBuffer.bindMemory(to: UInt16.self, capacity: c)
+        let buffer = UnsafeMutableBufferPointer<UInt16>(start: u16Ptr, count: c)
+        
+        buffer[0] = 0
+        buffer[1] = 0
+        
+        var data = Data(capacity: c * MemoryLayout<UInt16>.stride)
+        data.resetBytes(in: 0..<c * MemoryLayout<UInt16>.stride)
+        data[0] = 0xFF
+        data[1] = 0xFF
+        let copiedCount = data.copyBytes(to: buffer)
+        XCTAssertEqual(copiedCount, c * MemoryLayout<UInt16>.stride)
+        
+        XCTAssertEqual(buffer[0], 0xFFFF)
+        free(underlyingBuffer)
+    }
+    
+    func testCopyBytes_undersized() {
+        let a : [UInt8] = [1, 2, 3, 4, 5]
+        var data = a.withUnsafeBufferPointer {
+            return Data(buffer: $0)
+        }
+        let expectedSize = MemoryLayout<UInt8>.stride * a.count
+        XCTAssertEqual(expectedSize, data.count)
+        
+        let underlyingBuffer = unsafeBitCast(malloc(expectedSize - 1)!, to: UnsafeMutablePointer<UInt8>.self)
+        let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: expectedSize - 1)
+        
+        // We should only copy in enough bytes that can fit in the buffer
+        let copiedCount = data.copyBytes(to: buffer)
+        XCTAssertEqual(expectedSize - 1, copiedCount)
+        
+        var index = 0
+        for v in a[0..<expectedSize-1] {
+            XCTAssertEqual(v, buffer[index])
+            index += 1
+        }
+        
+        free(underlyingBuffer)
+    }
+    
+    func testCopyBytes_oversized() {
+        let a : [Int32] = [1, 0, 1, 0, 1]
+        var data = a.withUnsafeBufferPointer {
+            return Data(buffer: $0)
+        }
+        let expectedSize = MemoryLayout<Int32>.stride * a.count
+        XCTAssertEqual(expectedSize, data.count)
+        
+        let underlyingBuffer = unsafeBitCast(malloc(expectedSize + 1)!, to: UnsafeMutablePointer<UInt8>.self)
+        let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: expectedSize + 1)
+        
+        let copiedCount = data.copyBytes(to: buffer)
+        XCTAssertEqual(expectedSize, copiedCount)
+        
+        free(underlyingBuffer)
+    }
+    
+    func testCopyBytes_ranges() {
+        
+        do {
+            // Equal sized buffer, data
+            let a : [UInt8] = [1, 2, 3, 4, 5]
+            var data = a.withUnsafeBufferPointer {
+                return Data(buffer: $0)
+            }
+            
+            let underlyingBuffer = unsafeBitCast(malloc(data.count)!, to: UnsafeMutablePointer<UInt8>.self)
+            let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: data.count)
+            
+            var copiedCount : Int
+            
+            copiedCount = data.copyBytes(to: buffer, from: 0..<0)
+            XCTAssertEqual(0, copiedCount)
+            
+            copiedCount = data.copyBytes(to: buffer, from: 1..<1)
+            XCTAssertEqual(0, copiedCount)
+            
+            copiedCount = data.copyBytes(to: buffer, from: 0..<3)
+            XCTAssertEqual((0..<3).count, copiedCount)
+            
+            var index = 0
+            for v in a[0..<3] {
+                XCTAssertEqual(v, buffer[index])
+                index += 1
+            }
+            free(underlyingBuffer)
+        }
+        
+        do {
+            // Larger buffer than data
+            let a : [UInt8] = [1, 2, 3, 4]
+            let data = a.withUnsafeBufferPointer {
+                return Data(buffer: $0)
+            }
+            
+            let underlyingBuffer = unsafeBitCast(malloc(10)!, to: UnsafeMutablePointer<UInt8>.self)
+            let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: 10)
+            
+            var copiedCount : Int
+            
+            copiedCount = data.copyBytes(to: buffer, from: 0..<3)
+            XCTAssertEqual((0..<3).count, copiedCount)
+            
+            var index = 0
+            for v in a[0..<3] {
+                XCTAssertEqual(v, buffer[index])
+                index += 1
+            }
+            free(underlyingBuffer)
+        }
+        
+        do {
+            // Larger data than buffer
+            let a : [UInt8] = [1, 2, 3, 4, 5, 6]
+            let data = a.withUnsafeBufferPointer {
+                return Data(buffer: $0)
+            }
+            
+            let underlyingBuffer = unsafeBitCast(malloc(4)!, to: UnsafeMutablePointer<UInt8>.self)
+            let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: 4)
+            
+            var copiedCount : Int
+            
+            copiedCount = data.copyBytes(to: buffer, from: 0..<data.index(before: data.endIndex))
+            XCTAssertEqual(4, copiedCount)
+            
+            var index = 0
+            for v in a[0..<4] {
+                XCTAssertEqual(v, buffer[index])
+                index += 1
+            }
+            free(underlyingBuffer)
+            
+        }
+    }
+    
+    func test_base64Data_small() {
+        let data = "Hello World".data(using: .utf8)!
+        let base64 = data.base64EncodedString()
+        XCTAssertEqual("SGVsbG8gV29ybGQ=", base64, "trivial base64 conversion should work")
+    }
+    
+    func test_dataHash() {
+        let dataStruct = "Hello World".data(using: .utf8)!
+        let dataObj = dataStruct.bridge()
+        XCTAssertEqual(dataObj.hashValue, dataStruct.hashValue, "Data and NSData should have the same hash value")
+    }
+    
+    func test_base64Data_medium() {
+        let data = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut at tincidunt arcu. Suspendisse nec sodales erat, sit amet imperdiet ipsum. Etiam sed ornare felis. Nunc mauris turpis, bibendum non lectus quis, malesuada placerat turpis. Nam adipiscing non massa et semper. Nulla convallis semper bibendum. Aliquam dictum nulla cursus mi ultricies, at tincidunt mi sagittis. Nulla faucibus at dui quis sodales. Morbi rutrum, dui id ultrices venenatis, arcu urna egestas felis, vel suscipit mauris arcu quis risus. Nunc venenatis ligula at orci tristique, et mattis purus pulvinar. Etiam ultricies est odio. Nunc eleifend malesuada justo, nec euismod sem ultrices quis. Etiam nec nibh sit amet lorem faucibus dapibus quis nec leo. Praesent sit amet mauris vel lacus hendrerit porta mollis consectetur mi. Donec eget tortor dui. Morbi imperdiet, arcu sit amet elementum interdum, quam nisl tempor quam, vitae feugiat augue purus sed lacus. In ac urna adipiscing purus venenatis volutpat vel et metus. Nullam nec auctor quam. Phasellus porttitor felis ac nibh gravida suscipit tempus at ante. Nunc pellentesque iaculis sapien a mattis. Aenean eleifend dolor non nunc laoreet, non dictum massa aliquam. Aenean quis turpis augue. Praesent augue lectus, mollis nec elementum eu, dignissim at velit. Ut congue neque id ullamcorper pellentesque. Maecenas euismod in elit eu vehicula. Nullam tristique dui nulla, nec convallis metus suscipit eget. Cras semper augue nec cursus blandit. Nulla rhoncus et odio quis blandit. Praesent lobortis dignissim velit ut pulvinar. Duis interdum quam adipiscing dolor semper semper. Nunc bibendum convallis dui, eget mollis magna hendrerit et. Morbi facilisis, augue eu fringilla convallis, mauris est cursus dolor, eu posuere odio nunc quis orci. Ut eu justo sem. Phasellus ut erat rhoncus, faucibus arcu vitae, vulputate erat. Aliquam nec magna viverra, interdum est vitae, rhoncus sapien. Duis tincidunt tempor ipsum ut dapibus. Nullam commodo varius metus, sed sollicitudin eros. Etiam nec odio et dui tempor blandit posuere.".data(using: .utf8)!
+        let base64 = data.base64EncodedString()
+        XCTAssertEqual("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", base64, "medium base64 conversion should work")
+    }
+    
+    func test_basicReadWrite() {
+        let url = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true).appendingPathComponent("testfile")
+        let count = 1 << 24
+        let randomMemory = malloc(count)!
+        let ptr = randomMemory.bindMemory(to: UInt8.self, capacity: count)
+        let data = Data(bytesNoCopy: ptr, count: count, deallocator: .free)
+        do {
+            try data.write(to: url)
+            let readData = try Data(contentsOf: url)
+            XCTAssertEqual(data, readData)
+        } catch {
+            XCTFail("Should not have thrown")
+        }
+        
+        do {
+            try FileManager.default.removeItem(at: url)
+        } catch {
+            // ignore
+        }
+    }
+    
+    func test_writeFailure() {
+        let url = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true).appendingPathComponent("testfile")
+        
+        let data = Data()
+        do {
+            try data.write(to: url)
+        } catch let error as NSError {
+            print(error)
+            XCTAssertTrue(false, "Should not have thrown")
+        } catch {
+            XCTFail("unexpected error")
+        }
+        
+        do {
+            try data.write(to: url, options: [.withoutOverwriting])
+            XCTAssertTrue(false, "Should have thrown")
+        } catch let error as NSError {
+            XCTAssertEqual(error.code, NSCocoaError.FileWriteFileExistsError.rawValue)
+        } catch {
+            XCTFail("unexpected error")
+        }
+        
+        
+        do {
+            try FileManager.default.removeItem(at: url)
+        } catch {
+            // ignore
+        }
+        
+        // Make sure clearing the error condition allows the write to succeed
+        do {
+            try data.write(to: url, options: [.withoutOverwriting])
+        } catch {
+            XCTAssertTrue(false, "Should not have thrown")
+        }
+        
+        do {
+            try FileManager.default.removeItem(at: url)
+        } catch {
+            // ignore
+        }
+    }
+    
+    func test_genericBuffers() {
+        let a : [Int32] = [1, 0, 1, 0, 1]
+        var data = a.withUnsafeBufferPointer {
+            return Data(buffer: $0)
+        }
+        
+        var expectedSize = MemoryLayout<Int32>.stride * a.count
+        XCTAssertEqual(expectedSize, data.count)
+        
+        [false, true].withUnsafeBufferPointer {
+            data.append($0)
+        }
+        
+        expectedSize += MemoryLayout<Bool>.stride * 2
+        XCTAssertEqual(expectedSize, data.count)
+        
+        let underlyingBuffer = unsafeBitCast(malloc(expectedSize)!, to: UnsafeMutablePointer<UInt8>.self)
+        
+        let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: expectedSize)
+        let copiedCount = data.copyBytes(to: buffer)
+        XCTAssertEqual(copiedCount, expectedSize)
+        
+        free(underlyingBuffer)
+    }
+    
+    // intentionally structured so sizeof() != strideof()
+    struct MyStruct {
+        var time: UInt64
+        let x: UInt32
+        let y: UInt32
+        let z: UInt32
+        init() {
+            time = 0
+            x = 1
+            y = 2
+            z = 3
+        }
+    }
+    
+    func test_bufferSizeCalculation() {
+        // Make sure that Data is correctly using strideof instead of sizeof.
+        // n.b. if sizeof(MyStruct) == strideof(MyStruct), this test is not as useful as it could be
+        
+        // init
+        let stuff = [MyStruct(), MyStruct(), MyStruct()]
+        var data = stuff.withUnsafeBufferPointer {
+            return Data(buffer: $0)
+        }
+        
+        XCTAssertEqual(data.count, MemoryLayout<MyStruct>.stride * 3)
+        
+        
+        // append
+        stuff.withUnsafeBufferPointer {
+            data.append($0)
+        }
+        
+        XCTAssertEqual(data.count, MemoryLayout<MyStruct>.stride * 6)
+        
+        // copyBytes
+        do {
+            // equal size
+            let underlyingBuffer = malloc(6 * MemoryLayout<MyStruct>.stride)!
+            defer { free(underlyingBuffer) }
+            
+            let ptr = underlyingBuffer.bindMemory(to: MyStruct.self, capacity: 6)
+            let buffer = UnsafeMutableBufferPointer<MyStruct>(start: ptr, count: 6)
+            
+            let byteCount = data.copyBytes(to: buffer)
+            XCTAssertEqual(6 * MemoryLayout<MyStruct>.stride, byteCount)
+        }
+        
+        do {
+            // undersized
+            let underlyingBuffer = malloc(3 * MemoryLayout<MyStruct>.stride)!
+            defer { free(underlyingBuffer) }
+            
+            let ptr = underlyingBuffer.bindMemory(to: MyStruct.self, capacity: 3)
+            let buffer = UnsafeMutableBufferPointer<MyStruct>(start: ptr, count: 3)
+            
+            let byteCount = data.copyBytes(to: buffer)
+            XCTAssertEqual(3 * MemoryLayout<MyStruct>.stride, byteCount)
+        }
+        
+        do {
+            // oversized
+            let underlyingBuffer = malloc(12 * MemoryLayout<MyStruct>.stride)!
+            defer { free(underlyingBuffer) }
+            
+            let ptr = underlyingBuffer.bindMemory(to: MyStruct.self, capacity: 6)
+            let buffer = UnsafeMutableBufferPointer<MyStruct>(start: ptr, count: 6)
+            
+            let byteCount = data.copyBytes(to: buffer)
+            XCTAssertEqual(6 * MemoryLayout<MyStruct>.stride, byteCount)
+        }
+    }
+}
+
diff --git a/TestFoundation/TestNSJSONSerialization.swift b/TestFoundation/TestNSJSONSerialization.swift
index a4f61cdd83..243b490dc1 100644
--- a/TestFoundation/TestNSJSONSerialization.swift
+++ b/TestFoundation/TestNSJSONSerialization.swift
@@ -45,7 +45,10 @@ extension TestNSJSONSerialization {
     }
     
     func test_JSONObjectWithData_emptyObject() {
-        let subject = Data(bytes: UnsafeRawPointer([UInt8]([0x7B, 0x7D])), count: 2)
+        var bytes: [UInt8] = [0x7B, 0x7D]
+        let subject = bytes.withUnsafeMutableBufferPointer {
+            return Data(buffer: $0)
+        }
         
         let object = try! JSONSerialization.jsonObject(with: subject, options: []) as? [String:Any]
         XCTAssertEqual(object?.count, 0)
@@ -75,7 +78,7 @@ extension TestNSJSONSerialization {
         ]
         
         for (description, encoded) in subjects {
-            let result = try? JSONSerialization.jsonObject(with: Data(bytes:UnsafeRawPointer(encoded), count: encoded.count), options: [])
+            let result = try? JSONSerialization.jsonObject(with: Data(bytes:encoded, count: encoded.count), options: [])
             XCTAssertNotNil(result, description)
         }
     }
diff --git a/TestFoundation/TestNSNotificationCenter.swift b/TestFoundation/TestNSNotificationCenter.swift
index ba37d24730..0e75761065 100755
--- a/TestFoundation/TestNSNotificationCenter.swift
+++ b/TestFoundation/TestNSNotificationCenter.swift
@@ -30,9 +30,9 @@ class TestNSNotificationCenter : XCTestCase {
     }
     
     func test_defaultCenter() {
-        let defaultCenter1 = NotificationCenter.defaultCenter()
+        let defaultCenter1 = NotificationCenter.default
         XCTAssertNotNil(defaultCenter1)
-        let defaultCenter2 = NotificationCenter.defaultCenter()
+        let defaultCenter2 = NotificationCenter.default
         XCTAssertEqual(defaultCenter1, defaultCenter2)
     }
     
@@ -49,14 +49,14 @@ class TestNSNotificationCenter : XCTestCase {
         let notificationName = Notification.Name(rawValue: "test_postNotification_name")
         var flag = false
         let dummyObject = NSObject()
-        let observer = notificationCenter.addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
+        let observer = notificationCenter.addObserver(forName: notificationName, object: dummyObject, queue: nil) { notification in
             XCTAssertEqual(notificationName, notification.name)
             XCTAssertTrue(dummyObject === notification.object as? NSObject)
             
             flag = true
         }
         
-        notificationCenter.postNotificationName(notificationName, object: dummyObject)
+        notificationCenter.post(name: notificationName, object: dummyObject)
         XCTAssertTrue(flag)
         
         removeObserver(observer, notificationCenter: notificationCenter)
@@ -68,11 +68,11 @@ class TestNSNotificationCenter : XCTestCase {
         var flag = true
         let dummyObject = NSObject()
         let dummyObject2 = NSObject()
-        let observer = notificationCenter.addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
+        let observer = notificationCenter.addObserver(forName: notificationName, object: dummyObject, queue: nil) { notification in
             flag = false
         }
         
-        notificationCenter.postNotificationName(notificationName, object: dummyObject2)
+        notificationCenter.post(name: notificationName, object: dummyObject2)
         XCTAssertTrue(flag)
         
         removeObserver(observer, notificationCenter: notificationCenter)
@@ -82,23 +82,23 @@ class TestNSNotificationCenter : XCTestCase {
         let notificationCenter = NotificationCenter()
         let notificationName = Notification.Name(rawValue: "test_postMultipleNotifications_name")
         var flag1 = false
-        let observer1 = notificationCenter.addObserverForName(notificationName, object: nil, queue: nil) { _ in
+        let observer1 = notificationCenter.addObserver(forName: notificationName, object: nil, queue: nil) { _ in
             flag1 = true
         }
         
         var flag2 = true
-        let observer2 = notificationCenter.addObserverForName(notificationName, object: nil, queue: nil) { _ in
+        let observer2 = notificationCenter.addObserver(forName: notificationName, object: nil, queue: nil) { _ in
             flag2 = false
         }
         
         var flag3 = false
-        let observer3 = notificationCenter.addObserverForName(notificationName, object: nil, queue: nil) { _ in
+        let observer3 = notificationCenter.addObserver(forName: notificationName, object: nil, queue: nil) { _ in
             flag3 = true
         }
         
         removeObserver(observer2, notificationCenter: notificationCenter)
         
-        notificationCenter.postNotificationName(notificationName, object: nil)
+        notificationCenter.post(name: notificationName, object: nil)
         XCTAssertTrue(flag1)
         XCTAssertTrue(flag2)
         XCTAssertTrue(flag3)
@@ -112,21 +112,21 @@ class TestNSNotificationCenter : XCTestCase {
         let notificationName = Notification.Name(rawValue: "test_addObserverForNilName_name")
         let invalidNotificationName = Notification.Name(rawValue: "test_addObserverForNilName_name_invalid")
         var flag1 = false
-        let observer1 = notificationCenter.addObserverForName(notificationName, object: nil, queue: nil) { _ in
+        let observer1 = notificationCenter.addObserver(forName: notificationName, object: nil, queue: nil) { _ in
             flag1 = true
         }
         
         var flag2 = true
-        let observer2 = notificationCenter.addObserverForName(invalidNotificationName, object: nil, queue: nil) { _ in
+        let observer2 = notificationCenter.addObserver(forName: invalidNotificationName, object: nil, queue: nil) { _ in
             flag2 = false
         }
         
         var flag3 = false
-        let observer3 = notificationCenter.addObserverForName(nil, object: nil, queue: nil) { _ in
+        let observer3 = notificationCenter.addObserver(forName: nil, object: nil, queue: nil) { _ in
             flag3 = true
         }
         
-        notificationCenter.postNotificationName(notificationName, object: nil)
+        notificationCenter.post(name: notificationName, object: nil)
         XCTAssertTrue(flag1)
         XCTAssertTrue(flag2)
         XCTAssertTrue(flag3)
@@ -140,13 +140,13 @@ class TestNSNotificationCenter : XCTestCase {
         let notificationCenter = NotificationCenter()
         let notificationName = Notification.Name(rawValue: "test_removeObserver_name")
         var flag = true
-        let observer = notificationCenter.addObserverForName(notificationName, object: nil, queue: nil) { _ in
+        let observer = notificationCenter.addObserver(forName: notificationName, object: nil, queue: nil) { _ in
             flag = false
         }
 
         removeObserver(observer, notificationCenter: notificationCenter)
 
-        notificationCenter.postNotificationName(notificationName, object: nil)
+        notificationCenter.post(name: notificationName, object: nil)
         XCTAssertTrue(flag)
     }
 
diff --git a/TestFoundation/TestNSNotificationQueue.swift b/TestFoundation/TestNSNotificationQueue.swift
index 094ff08b29..ec39137141 100644
--- a/TestFoundation/TestNSNotificationQueue.swift
+++ b/TestFoundation/TestNSNotificationQueue.swift
@@ -51,13 +51,13 @@ class TestNSNotificationQueue : XCTestCase {
         let dummyObject = NSObject()
         let notification = Notification(name: notificationName, object: dummyObject)
         var numberOfCalls = 0
-        let obs = NotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
+        let obs = NotificationCenter.default.addObserver(forName: notificationName, object: dummyObject, queue: nil) { notification in
             numberOfCalls += 1
         }
         let queue = NotificationQueue.defaultQueue()
         queue.enqueueNotification(notification, postingStyle: .postNow)
         XCTAssertEqual(numberOfCalls, 1)
-        NotificationCenter.defaultCenter().removeObserver(obs)
+        NotificationCenter.default.removeObserver(obs)
     }
 
     func test_postNowToDefaultQueueWithCoalescing() {
@@ -65,7 +65,7 @@ class TestNSNotificationQueue : XCTestCase {
         let dummyObject = NSObject()
         let notification = Notification(name: notificationName, object: dummyObject)
         var numberOfCalls = 0
-        let obs = NotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
+        let obs = NotificationCenter.default.addObserver(forName: notificationName, object: dummyObject, queue: nil) { notification in
             numberOfCalls += 1
         }
         let queue = NotificationQueue.defaultQueue()
@@ -74,7 +74,7 @@ class TestNSNotificationQueue : XCTestCase {
         queue.enqueueNotification(notification, postingStyle: .postNow)
         // Coalescing doesn't work for the NSPostingStyle.PostNow. That is why we expect 3 calls here
         XCTAssertEqual(numberOfCalls, 3)
-        NotificationCenter.defaultCenter().removeObserver(obs)
+        NotificationCenter.default.removeObserver(obs)
     }
 
     func test_postNowToCustomQueue() {
@@ -83,13 +83,13 @@ class TestNSNotificationQueue : XCTestCase {
         let notification = Notification(name: notificationName, object: dummyObject)
         var numberOfCalls = 0
         let notificationCenter = NotificationCenter()
-        let obs = notificationCenter.addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
+        let obs = notificationCenter.addObserver(forName: notificationName, object: dummyObject, queue: nil) { notification in
             numberOfCalls += 1
         }
         let notificationQueue = NotificationQueue(notificationCenter: notificationCenter)
         notificationQueue.enqueueNotification(notification, postingStyle: .postNow)
         XCTAssertEqual(numberOfCalls, 1)
-        NotificationCenter.defaultCenter().removeObserver(obs)
+        NotificationCenter.default.removeObserver(obs)
     }
 
     func test_postNowForDefaultRunLoopMode() {
@@ -97,12 +97,12 @@ class TestNSNotificationQueue : XCTestCase {
         let dummyObject = NSObject()
         let notification = Notification(name: notificationName, object: dummyObject)
         var numberOfCalls = 0
-        let obs = NotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
+        let obs = NotificationCenter.default.addObserver(forName: notificationName, object: dummyObject, queue: nil) { notification in
             numberOfCalls += 1
         }
         let queue = NotificationQueue.defaultQueue()
 
-        let runLoop = RunLoop.current()
+        let runLoop = RunLoop.current
         let endDate = Date(timeInterval: TimeInterval(0.05), since: Date())
 
         let dummyTimer = Timer.scheduledTimer(withTimeInterval: 0.01, repeats: false) { _ in
@@ -120,7 +120,7 @@ class TestNSNotificationQueue : XCTestCase {
         runLoop.add(dummyTimer, forMode: .defaultRunLoopMode)
         let _ = runLoop.run(mode: .defaultRunLoopMode, before: endDate)
         XCTAssertEqual(numberOfCalls, 2)
-        NotificationCenter.defaultCenter().removeObserver(obs)
+        NotificationCenter.default.removeObserver(obs)
     }
 
     func test_postAsapToDefaultQueue() {
@@ -128,7 +128,7 @@ class TestNSNotificationQueue : XCTestCase {
         let dummyObject = NSObject()
         let notification = Notification(name: notificationName, object: dummyObject)
         var numberOfCalls = 0
-        let obs = NotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
+        let obs = NotificationCenter.default.addObserver(forName: notificationName, object: dummyObject, queue: nil) { notification in
             numberOfCalls += 1
         }
         let queue = NotificationQueue.defaultQueue()
@@ -136,7 +136,7 @@ class TestNSNotificationQueue : XCTestCase {
 
         scheduleTimer(withInterval: 0.001) // run timer trigger the notifications
         XCTAssertEqual(numberOfCalls, 1)
-        NotificationCenter.defaultCenter().removeObserver(obs)
+        NotificationCenter.default.removeObserver(obs)
     }
 
     func test_postAsapToDefaultQueueWithCoalescingOnNameAndSender() {
@@ -144,7 +144,7 @@ class TestNSNotificationQueue : XCTestCase {
         let notificationName = Notification.Name(rawValue: "test_postAsapToDefaultQueueWithCoalescingOnNameAndSender")
         let notification = Notification(name: notificationName, object: NSObject())
         var numberOfCalls = 0
-        let obs = NotificationCenter.defaultCenter().addObserverForName(notificationName, object: notification.object, queue: nil) { notification in
+        let obs = NotificationCenter.default.addObserver(forName: notificationName, object: notification.object, queue: nil) { notification in
             numberOfCalls += 1
         }
         let queue = NotificationQueue.defaultQueue()
@@ -154,7 +154,7 @@ class TestNSNotificationQueue : XCTestCase {
 
         scheduleTimer(withInterval: 0.001)
         XCTAssertEqual(numberOfCalls, 1)
-        NotificationCenter.defaultCenter().removeObserver(obs)
+        NotificationCenter.default.removeObserver(obs)
     }
 
     func test_postAsapToDefaultQueueWithCoalescingOnNameOrSender() {
@@ -162,12 +162,12 @@ class TestNSNotificationQueue : XCTestCase {
         let notificationName = Notification.Name(rawValue: "test_postAsapToDefaultQueueWithCoalescingOnNameOrSender")
         let notification1 = Notification(name: notificationName, object: NSObject())
         var numberOfNameCoalescingCalls = 0
-        let obs1 = NotificationCenter.defaultCenter().addObserverForName(notificationName, object: notification1.object, queue: nil) { notification in
+        let obs1 = NotificationCenter.default.addObserver(forName: notificationName, object: notification1.object, queue: nil) { notification in
             numberOfNameCoalescingCalls += 1
         }
         let notification2 = Notification(name: notificationName, object: NSObject())
         var numberOfObjectCoalescingCalls = 0
-        let obs2 = NotificationCenter.defaultCenter().addObserverForName(notificationName, object: notification2.object, queue: nil) { notification in
+        let obs2 = NotificationCenter.default.addObserver(forName: notificationName, object: notification2.object, queue: nil) { notification in
             numberOfObjectCoalescingCalls += 1
         }
 
@@ -186,8 +186,8 @@ class TestNSNotificationQueue : XCTestCase {
         // check that we received notifications #4 and #5
         XCTAssertEqual(numberOfNameCoalescingCalls, 1)
         XCTAssertEqual(numberOfObjectCoalescingCalls, 1)
-        NotificationCenter.defaultCenter().removeObserver(obs1)
-        NotificationCenter.defaultCenter().removeObserver(obs2)
+        NotificationCenter.default.removeObserver(obs1)
+        NotificationCenter.default.removeObserver(obs2)
     }
 
 
@@ -197,14 +197,14 @@ class TestNSNotificationQueue : XCTestCase {
         let notification = Notification(name: notificationName, object: dummyObject)
         var numberOfCalls = 0
 
-        let obs = NotificationCenter.defaultCenter().addObserverForName(notificationName, object: dummyObject, queue: nil) { notification in
+        let obs = NotificationCenter.default.addObserver(forName: notificationName, object: dummyObject, queue: nil) { notification in
             numberOfCalls += 1
         }
         NotificationQueue.defaultQueue().enqueueNotification(notification, postingStyle: .postWhenIdle)
         // add a timer to wakeup the runloop, process the timer and call the observer awaiting for any input sources/timers
         scheduleTimer(withInterval: 0.001)
         XCTAssertEqual(numberOfCalls, 1)
-        NotificationCenter.defaultCenter().removeObserver(obs)
+        NotificationCenter.default.removeObserver(obs)
     }
 
     func test_notificationQueueLifecycle() {
@@ -226,7 +226,7 @@ class TestNSNotificationQueue : XCTestCase {
         let dummyTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { _ in
             e.fulfill()
         }
-        RunLoop.current().add(dummyTimer, forMode: .defaultRunLoopMode)
+        RunLoop.current.add(dummyTimer, forMode: .defaultRunLoopMode)
         waitForExpectations(timeout: 0.1)
     }
 
diff --git a/TestFoundation/TestNSRunLoop.swift b/TestFoundation/TestNSRunLoop.swift
index 012467809d..52c7e262d0 100755
--- a/TestFoundation/TestNSRunLoop.swift
+++ b/TestFoundation/TestNSRunLoop.swift
@@ -36,16 +36,16 @@ class TestNSRunLoop : XCTestCase {
     }
     
     func test_runLoopInit() {
-        let mainRunLoop = RunLoop.main()
+        let mainRunLoop = RunLoop.main
         XCTAssertNotNil(mainRunLoop)
-        let currentRunLoop = RunLoop.current()
+        let currentRunLoop = RunLoop.current
         XCTAssertNotNil(currentRunLoop)
 
-        let secondAccessOfMainLoop = RunLoop.main()
+        let secondAccessOfMainLoop = RunLoop.main
         XCTAssertEqual(mainRunLoop, secondAccessOfMainLoop, "fetching the main loop a second time should be equal")
         XCTAssertTrue(mainRunLoop === secondAccessOfMainLoop, "fetching the main loop a second time should be identical")
         
-        let secondAccessOfCurrentLoop = RunLoop.current()
+        let secondAccessOfCurrentLoop = RunLoop.current
         XCTAssertEqual(currentRunLoop, secondAccessOfCurrentLoop, "fetching the current loop a second time should be equal")
         XCTAssertTrue(currentRunLoop === secondAccessOfCurrentLoop, "fetching the current loop a second time should be identical")
         
@@ -55,7 +55,7 @@ class TestNSRunLoop : XCTestCase {
     }
     
     func test_runLoopRunMode() {
-        let runLoop = RunLoop.current()
+        let runLoop = RunLoop.current
         let timeInterval = TimeInterval(0.05)
         let endDate = Date(timeInterval: timeInterval, since: Date())
         var flag = false
@@ -77,7 +77,7 @@ class TestNSRunLoop : XCTestCase {
     }
     
     func test_runLoopLimitDate() {
-        let runLoop = RunLoop.current()
+        let runLoop = RunLoop.current
         let timeInterval = TimeInterval(1)
         let expectedTimeInterval = Date(timeInterval: timeInterval, since: Date()).timeIntervalSince1970
 
diff --git a/TestFoundation/TestNSStream.swift b/TestFoundation/TestNSStream.swift
index 649166bf74..508f04f42b 100644
--- a/TestFoundation/TestNSStream.swift
+++ b/TestFoundation/TestNSStream.swift
@@ -188,7 +188,7 @@ class TestNSStream : XCTestCase {
         let result: Int? = outputStream.write(encodedData, maxLength: encodedData.count)
         XCTAssertEqual(myString.characters.count, result)
         //verify the data written
-        let dataWritten  = outputStream.propertyForKey(NSStreamDataWrittenToMemoryStreamKey)
+        let dataWritten  = outputStream.property(forKey: Stream.PropertyKey.dataWrittenToMemoryStreamKey)
         if let nsdataWritten = dataWritten as? NSData {
             nsdataWritten.getBytes(UnsafeMutablePointer(mutating: buffer), length: result!)
             XCTAssertEqual(NSString(bytes: &buffer, length: buffer.count, encoding: String.Encoding.utf8.rawValue), NSString(string: myString))
diff --git a/TestFoundation/TestNSTimer.swift b/TestFoundation/TestNSTimer.swift
index 57b3035c74..6715ed0ea4 100755
--- a/TestFoundation/TestNSTimer.swift
+++ b/TestFoundation/TestNSTimer.swift
@@ -42,7 +42,7 @@ class TestNSTimer : XCTestCase {
             timer.invalidate()
         }
 
-        let runLoop = RunLoop.current()
+        let runLoop = RunLoop.current
         runLoop.add(dummyTimer, forMode: .defaultRunLoopMode)
         runLoop.run(until: Date(timeIntervalSinceNow: 0.05))
         
@@ -68,7 +68,7 @@ class TestNSTimer : XCTestCase {
             }
         }
         
-        let runLoop = RunLoop.current()
+        let runLoop = RunLoop.current
         runLoop.add(dummyTimer, forMode: .defaultRunLoopMode)
         runLoop.run(until: Date(timeIntervalSinceNow: interval * Double(numberOfRepeats + 1)))
         
@@ -88,7 +88,7 @@ class TestNSTimer : XCTestCase {
             XCTAssertFalse(timer.isValid)
         }
         
-        let runLoop = RunLoop.current()
+        let runLoop = RunLoop.current
         runLoop.add(dummyTimer, forMode: .defaultRunLoopMode)
         runLoop.run(until: Date(timeIntervalSinceNow: 0.05))
         
diff --git a/TestFoundation/TestNSXMLParser.swift b/TestFoundation/TestNSXMLParser.swift
index 239d27c100..486f23dd92 100644
--- a/TestFoundation/TestNSXMLParser.swift
+++ b/TestFoundation/TestNSXMLParser.swift
@@ -28,7 +28,9 @@ class TestNSXMLParser : XCTestCase {
     func test_data() {
         let xml = Array("<test><foo>bar</foo></test>".utf8CString)
         let data = xml.withUnsafeBufferPointer { (buffer: UnsafeBufferPointer<CChar>) -> Data in
-            return Data(bytes: UnsafeRawPointer(buffer.baseAddress!), count: buffer.count)
+            return buffer.baseAddress!.withMemoryRebound(to: UInt8.self, capacity: buffer.count * MemoryLayout<CChar>.stride) {
+                return Data(bytes: $0, count: buffer.count)
+            }
         }
         let parser = XMLParser(data: data)
         let res = parser.parse()