diff --git a/Docs/Status.md b/Docs/Status.md
index de77b21..6c0eb68 100644
--- a/Docs/Status.md
+++ b/Docs/Status.md
@@ -47,7 +47,7 @@
     |------------------------------|-----------------|---------------|--------------------------------------------------------------------------------------------------------------------|
     | `URLAuthenticationChallenge` | Unimplemented   | None          |                                                                                                                    |
     | `URLCache`                   | Unimplemented   | None          |                                                                                                                    |
-    | `URLCredential`              | Mostly Complete | Incomplete    | `NSCoding` and `NSCopying` remain unimplemented                                                                    |
+    | `URLCredential`              | Mostly Complete | Incomplete    | `NSCopying` remains unimplemented                                                                                  |
     | `URLCredentialStorage`       | Unimplemented   | None          |                                                                                                                    |
     | `NSURLError*`                | Complete        | N/A           |                                                                                                                    |
     | `URLProtectionSpace`         | Unimplemented   | None          |                                                                                                                    |
diff --git a/Foundation.xcodeproj/project.pbxproj b/Foundation.xcodeproj/project.pbxproj
index 45e43e4..2af4035 100755
--- a/Foundation.xcodeproj/project.pbxproj
+++ b/Foundation.xcodeproj/project.pbxproj
@@ -308,6 +308,7 @@
 		7900433B1CACD33E00ECCBF1 /* TestNSCompoundPredicate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 790043391CACD33E00ECCBF1 /* TestNSCompoundPredicate.swift */; };
 		7900433C1CACD33E00ECCBF1 /* TestNSPredicate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7900433A1CACD33E00ECCBF1 /* TestNSPredicate.swift */; };
 		AE35A1861CBAC85E0042DB84 /* SwiftFoundation.h in Headers */ = {isa = PBXBuildFile; fileRef = AE35A1851CBAC85E0042DB84 /* SwiftFoundation.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		BF8E65311DC3B3CB005AB5C3 /* TestNotification.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF8E65301DC3B3CB005AB5C3 /* TestNotification.swift */; };
 		CC5249C01D341D23007CB54D /* TestUnitConverter.swift in Sources */ = {isa = PBXBuildFile; fileRef = CC5249BF1D341D23007CB54D /* TestUnitConverter.swift */; };
 		CE19A88C1C23AA2300B4CB6A /* NSStringTestData.txt in Resources */ = {isa = PBXBuildFile; fileRef = CE19A88B1C23AA2300B4CB6A /* NSStringTestData.txt */; };
 		D31302011C30CEA900295652 /* NSConcreteValue.swift in Sources */ = {isa = PBXBuildFile; fileRef = D31302001C30CEA900295652 /* NSConcreteValue.swift */; };
@@ -744,6 +745,7 @@
 		88D28DE61C13AE9000494606 /* TestNSGeometry.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestNSGeometry.swift; sourceTree = "<group>"; };
 		A5A34B551C18C85D00FD972B /* TestNSByteCountFormatter.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestNSByteCountFormatter.swift; sourceTree = "<group>"; };
 		AE35A1851CBAC85E0042DB84 /* SwiftFoundation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SwiftFoundation.h; sourceTree = "<group>"; };
+		BF8E65301DC3B3CB005AB5C3 /* TestNotification.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestNotification.swift; sourceTree = "<group>"; };
 		C2A9D75B1C15C08B00993803 /* TestNSUUID.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestNSUUID.swift; sourceTree = "<group>"; };
 		C93559281C12C49F009FD6A9 /* TestNSAffineTransform.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestNSAffineTransform.swift; sourceTree = "<group>"; };
 		CC5249BF1D341D23007CB54D /* TestUnitConverter.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestUnitConverter.swift; sourceTree = "<group>"; };
@@ -1378,6 +1380,7 @@
 				0383A1741D2E558A0052E5D1 /* TestNSStream.swift */,
 				5B1FD9E21D6D17B80080E83C /* TestNSURLSession.swift */,
 				EA54A6FA1DB16D53009E0809 /* TestObjCRuntime.swift */,
+				BF8E65301DC3B3CB005AB5C3 /* TestNotification.swift */,
 			);
 			name = Tests;
 			sourceTree = "<group>";
@@ -2215,6 +2218,7 @@
 				5B13B34D1C582D4C00651CE2 /* TestNSUUID.swift in Sources */,
 				5B13B3281C582D4C00651CE2 /* TestNSBundle.swift in Sources */,
 				5B13B32A1C582D4C00651CE2 /* TestNSCharacterSet.swift in Sources */,
+				BF8E65311DC3B3CB005AB5C3 /* TestNotification.swift in Sources */,
 				EA01AAEC1DA839C4008F4E07 /* TestProgress.swift in Sources */,
 				5B13B3411C582D4C00651CE2 /* TestNSRegularExpression.swift in Sources */,
 				5B13B3491C582D4C00651CE2 /* TestNSTimeZone.swift in Sources */,
diff --git a/Foundation/CGFloat.swift b/Foundation/CGFloat.swift
index bba73b4..3462d8d 100644
--- a/Foundation/CGFloat.swift
+++ b/Foundation/CGFloat.swift
@@ -145,15 +145,17 @@
     public var native: NativeType
 }
 
-@_transparent extension CGFloat : BinaryFloatingPoint {
+extension CGFloat : BinaryFloatingPoint {
     
     public typealias RawSignificand = UInt
     public typealias Exponent = Int
-    
+
+    @_transparent
     public static var exponentBitCount: Int {
         return NativeType.exponentBitCount
     }
     
+    @_transparent
     public static var significandBitCount: Int {
         return NativeType.significandBitCount
     }
@@ -161,10 +163,12 @@
     //  Conversions to/from integer encoding.  These are not part of the
     //  BinaryFloatingPoint prototype because there's no guarantee that an
     //  integer type of the same size actually exists (e.g. Float80).
+    @_transparent
     public var bitPattern: UInt {
         return UInt(native.bitPattern)
     }
-    
+
+    @_transparent
     public init(bitPattern: UInt) {
 #if arch(i386) || arch(arm)
         native = NativeType(bitPattern: UInt32(bitPattern))
@@ -172,19 +176,23 @@
         native = NativeType(bitPattern: UInt64(bitPattern))
 #endif
     }
-    
+
+    @_transparent
     public var sign: FloatingPointSign {
         return native.sign
     }
-    
+
+    @_transparent
     public var exponentBitPattern: UInt {
         return native.exponentBitPattern
     }
-    
+
+    @_transparent
     public var significandBitPattern: UInt {
         return UInt(native.significandBitPattern)
     }
-    
+
+    @_transparent
     public init(sign: FloatingPointSign,
                 exponentBitPattern: UInt,
                 significandBitPattern: UInt) {
@@ -192,177 +200,217 @@
                             exponentBitPattern: exponentBitPattern,
                             significandBitPattern: NativeType.RawSignificand(significandBitPattern))
     }
-    
+
+    @_transparent
     public init(nan payload: RawSignificand, signaling: Bool) {
         native = NativeType(nan: NativeType.RawSignificand(payload),
                             signaling: signaling)
     }
-    
+
+    @_transparent
     public static var infinity: CGFloat {
         return CGFloat(NativeType.infinity)
     }
-    
+
+    @_transparent
     public static var nan: CGFloat {
         return CGFloat(NativeType.nan)
     }
-    
+
+    @_transparent
     public static var signalingNaN: CGFloat {
         return CGFloat(NativeType.signalingNaN)
     }
-    
+
     @available(*, unavailable, renamed: "nan")
     public static var quietNaN: CGFloat {
         fatalError("unavailable")
     }
-    
+
+    @_transparent
     public static var greatestFiniteMagnitude: CGFloat {
         return CGFloat(NativeType.greatestFiniteMagnitude)
     }
-    
+
+    @_transparent
     public static var pi: CGFloat {
         return CGFloat(NativeType.pi)
     }
-    
+
+    @_transparent
     public var ulp: CGFloat {
         return CGFloat(native.ulp)
     }
-    
+
+    @_transparent
     public static var leastNormalMagnitude: CGFloat {
         return CGFloat(NativeType.leastNormalMagnitude)
     }
-    
+
+    @_transparent
     public static var leastNonzeroMagnitude: CGFloat {
         return CGFloat(NativeType.leastNonzeroMagnitude)
     }
-    
+
+    @_transparent
     public var exponent: Int {
         return native.exponent
     }
-    
+
+    @_transparent
     public var significand: CGFloat {
         return CGFloat(native.significand)
     }
-    
+
+    @_transparent
     public init(sign: FloatingPointSign, exponent: Int, significand: CGFloat) {
         native = NativeType(sign: sign,
                             exponent: exponent, significand: significand.native)
     }
-    
+
+    @_transparent
     public mutating func round(_ rule: FloatingPointRoundingRule) {
         native.round(rule)
     }
-    
+
+    @_transparent
     public var nextUp: CGFloat {
         return CGFloat(native.nextUp)
     }
-    
+
+    @_transparent
     public var magnitude: CGFloat {
         return CGFloat(Swift.abs(native))
     }
-    
+
+    @_transparent
     public mutating func negate() {
         native.negate()
     }
-    
+
+    @_transparent
     public mutating func add(_ other: CGFloat) {
         native.add(other.native)
     }
-    
+
+    @_transparent
     public mutating func subtract(_ other: CGFloat) {
         native.subtract(other.native)
     }
-    
+
+    @_transparent
     public mutating func multiply(by other: CGFloat) {
         native.multiply(by: other.native)
     }
-    
+
+    @_transparent
     public mutating func divide(by other: CGFloat) {
         native.divide(by: other.native)
     }
-    
+
+    @_transparent
     public mutating func formTruncatingRemainder(dividingBy other: CGFloat) {
         native.formTruncatingRemainder(dividingBy: other.native)
     }
-    
+
+    @_transparent
     public mutating func formRemainder(dividingBy other: CGFloat) {
         native.formRemainder(dividingBy: other.native)
     }
-    
+
+    @_transparent
     public mutating func formSquareRoot( ) {
         native.formSquareRoot( )
     }
-    
+
+    @_transparent
     public mutating func addProduct(_ lhs: CGFloat, _ rhs: CGFloat) {
         native.addProduct(lhs.native, rhs.native)
     }
-    
+
+    @_transparent
     public func isEqual(to other: CGFloat) -> Bool {
         return self.native.isEqual(to: other.native)
     }
-    
+
+    @_transparent
     public func isLess(than other: CGFloat) -> Bool {
         return self.native.isLess(than: other.native)
     }
-    
+
+    @_transparent
     public func isLessThanOrEqualTo(_ other: CGFloat) -> Bool {
         return self.native.isLessThanOrEqualTo(other.native)
     }
-    
+
+    @_transparent
     public var isNormal:  Bool {
         return native.isNormal
     }
-    
+
+    @_transparent
     public var isFinite:  Bool {
         return native.isFinite
     }
-    
+
+    @_transparent
     public var isZero:  Bool {
         return native.isZero
     }
-    
+
+    @_transparent
     public var isSubnormal:  Bool {
         return native.isSubnormal
     }
-    
+
+    @_transparent
     public var isInfinite:  Bool {
         return native.isInfinite
     }
-    
+
+    @_transparent
     public var isNaN:  Bool {
         return native.isNaN
     }
-    
+
+    @_transparent
     public var isSignalingNaN: Bool {
         return native.isSignalingNaN
     }
-    
+
     @available(*, unavailable, renamed: "isSignalingNaN")
     public var isSignaling: Bool {
         fatalError("unavailable")
     }
-    
+
+    @_transparent
     public var isCanonical: Bool {
         return true
     }
-    
+
+    @_transparent
     public var floatingPointClass: FloatingPointClassification {
         return native.floatingPointClass
     }
-    
+
+    @_transparent
     public var binade: CGFloat {
         return CGFloat(native.binade)
     }
-    
+
+    @_transparent
     public var significandWidth: Int {
         return native.significandWidth
     }
-    
+
     /// Create an instance initialized to `value`.
+    @_transparent
     public init(floatLiteral value: NativeType) {
         native = value
     }
-    
+
     /// Create an instance initialized to `value`.
+    @_transparent
     public init(integerLiteral value: Int) {
         native = NativeType(value)
     }
@@ -402,14 +450,14 @@
     }
 }
 
-@_transparent extension CGFloat : CustomStringConvertible {
+extension CGFloat : CustomStringConvertible {
     /// A textual representation of `self`.
     public var description: String {
         return native.description
     }
 }
 
-@_transparent extension CGFloat : Hashable {
+extension CGFloat : Hashable {
     /// The hash value.
     ///
     /// **Axiom:** `x == y` implies `x.hashValue == y.hashValue`
@@ -417,78 +465,91 @@
     /// - Note: the hash value is not guaranteed to be stable across
     ///   different invocations of the same program.  Do not persist the
     ///   hash value across program runs.
+    @_transparent
     public var hashValue: Int {
         return native.hashValue
     }
 }
 
-@_transparent extension UInt8 {
+extension UInt8 {
+    @_transparent
     public init(_ value: CGFloat) {
         self = UInt8(value.native)
     }
 }
 
-@_transparent extension Int8 {
+extension Int8 {
+    @_transparent
     public init(_ value: CGFloat) {
         self = Int8(value.native)
     }
 }
 
-@_transparent extension UInt16 {
+extension UInt16 {
+    @_transparent
     public init(_ value: CGFloat) {
         self = UInt16(value.native)
     }
 }
 
-@_transparent extension Int16 {
+extension Int16 {
+    @_transparent
     public init(_ value: CGFloat) {
         self = Int16(value.native)
     }
 }
 
-@_transparent extension UInt32 {
+extension UInt32 {
+    @_transparent
     public init(_ value: CGFloat) {
         self = UInt32(value.native)
     }
 }
 
-@_transparent extension Int32 {
+extension Int32 {
+    @_transparent
     public init(_ value: CGFloat) {
         self = Int32(value.native)
     }
 }
 
-@_transparent extension UInt64 {
+extension UInt64 {
+    @_transparent
     public init(_ value: CGFloat) {
         self = UInt64(value.native)
     }
 }
 
-@_transparent extension Int64 {
+extension Int64 {
+    @_transparent
     public init(_ value: CGFloat) {
         self = Int64(value.native)
     }
 }
 
-@_transparent extension UInt {
+extension UInt {
+    @_transparent
     public init(_ value: CGFloat) {
         self = UInt(value.native)
     }
 }
 
-@_transparent extension Int {
+extension Int {
+    @_transparent
     public init(_ value: CGFloat) {
         self = Int(value.native)
     }
 }
 
-@_transparent extension Double {
+extension Double {
+    @_transparent
     public init(_ value: CGFloat) {
         self = Double(value.native)
     }
 }
 
-@_transparent extension Float {
+extension Float {
+    @_transparent
     public init(_ value: CGFloat) {
         self = Float(value.native)
     }
@@ -547,7 +608,7 @@
 // Strideable Conformance
 //===----------------------------------------------------------------------===//
 
-@_transparent extension CGFloat : Strideable {
+extension CGFloat : Strideable {
     /// Returns a stride `x` such that `self.advanced(by: x)` approximates
     /// `other`.
     ///
@@ -571,41 +632,35 @@
 // Deprecated operators
 //===----------------------------------------------------------------------===//
 
-@_transparent
 @available(*, unavailable, message: "use += 1")
 @discardableResult
 public prefix func ++(rhs: inout CGFloat) -> CGFloat {
     fatalError("++ is not available")
 }
 
-@_transparent
 @available(*, unavailable, message: "use -= 1")
 @discardableResult
 public prefix func --(rhs: inout CGFloat) -> CGFloat {
     fatalError("-- is not available")
 }
 
-@_transparent
 @available(*, unavailable, message: "use += 1")
 @discardableResult
 public postfix func ++(lhs: inout CGFloat) -> CGFloat {
     fatalError("++ is not available")
 }
 
-@_transparent
 @available(*, unavailable, message: "use -= 1")
 @discardableResult
 public postfix func --(lhs: inout CGFloat) -> CGFloat {
     fatalError("-- is not available")
 }
 
-@_transparent
 @available(*, unavailable, message: "Use truncatingRemainder instead")
 public func %(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
     fatalError("% is not available.")
 }
 
-@_transparent
 @available(*, unavailable, message: "Use formTruncatingRemainder instead")
 public func %=(lhs: inout CGFloat, rhs: CGFloat) {
     fatalError("%= is not available.")
@@ -880,16 +935,17 @@
     return CGFloat(yn(n, Double(x.native)))
 }
 
-@_transparent
 extension CGFloat : _CVarArgPassedAsDouble, _CVarArgAligned {
     /// Transform `self` into a series of machine words that can be
     /// appropriately interpreted by C varargs
+    @_transparent
     public var _cVarArgEncoding: [Int] {
         return native._cVarArgEncoding
     }
     
     /// Return the required alignment in bytes of 
     /// the value returned by `_cVarArgEncoding`.
+    @_transparent
     public var _cVarArgAlignment: Int { 
         return native._cVarArgAlignment
     }
diff --git a/Foundation/CharacterSet.swift b/Foundation/CharacterSet.swift
index 4babf01..35fbe72 100644
--- a/Foundation/CharacterSet.swift
+++ b/Foundation/CharacterSet.swift
@@ -13,6 +13,10 @@
 private func _utfRangeToNSRange(_ inRange : Range<UnicodeScalar>) -> NSRange {
     return NSMakeRange(Int(inRange.lowerBound.value), Int(inRange.upperBound.value - inRange.lowerBound.value))
 }
+ 
+private func _utfRangeToNSRange(_ inRange : ClosedRange<UnicodeScalar>) -> NSRange {
+    return NSMakeRange(Int(inRange.lowerBound.value), Int(inRange.upperBound.value - inRange.lowerBound.value + 1))
+}
 
 internal final class _SwiftNSCharacterSet : NSCharacterSet, _SwiftNativeFoundationType {
     internal typealias ImmutableType = NSCharacterSet
@@ -129,8 +133,7 @@
     ///
     /// It is the caller's responsibility to ensure that the values represent valid `UnicodeScalar` values, if that is what is desired.
     public init(charactersIn range: ClosedRange<UnicodeScalar>) {
-        let halfOpenRange = range.lowerBound..<UnicodeScalar(range.upperBound.value + 1)!
-        _wrapped = _SwiftNSCharacterSet(immutableObject: NSCharacterSet(range: _utfRangeToNSRange(halfOpenRange)))
+        _wrapped = _SwiftNSCharacterSet(immutableObject: NSCharacterSet(range: _utfRangeToNSRange(range)))
     }
     
     /// Initialize with the characters in the given string.
@@ -320,8 +323,7 @@
     ///
     /// It is the caller's responsibility to ensure that the values represent valid `UnicodeScalar` values, if that is what is desired.
     public mutating func insert(charactersIn range: ClosedRange<UnicodeScalar>) {
-        let halfOpenRange = range.lowerBound..<UnicodeScalar(range.upperBound.value + 1)!
-        let nsRange = _utfRangeToNSRange(halfOpenRange)
+        let nsRange = _utfRangeToNSRange(range)
         _applyUnmanagedMutation {
             $0.addCharacters(in: nsRange)
         }
@@ -337,8 +339,7 @@
     
     /// Remove a closed range of integer values from the `CharacterSet`.
     public mutating func remove(charactersIn range: ClosedRange<UnicodeScalar>) {
-        let halfOpenRange = range.lowerBound..<UnicodeScalar(range.upperBound.value + 1)!
-        let nsRange = _utfRangeToNSRange(halfOpenRange)
+        let nsRange = _utfRangeToNSRange(range)
         _applyUnmanagedMutation {
             $0.removeCharacters(in: nsRange)
         }
diff --git a/Foundation/Locale.swift b/Foundation/Locale.swift
index ffe584a..46642ac 100644
--- a/Foundation/Locale.swift
+++ b/Foundation/Locale.swift
@@ -69,7 +69,7 @@
     
     /// Returns a localized string for a specified identifier.
     ///
-    /// For example, in the "en" locale, the result for `"en"` is `"Spanish"`.
+    /// For example, in the "en" locale, the result for `"es"` is `"Spanish"`.
     public func localizedString(forIdentifier identifier: String) -> String? {
         return _wrapped.displayName(forKey: .identifier, value: identifier)
     }
@@ -83,7 +83,7 @@
     
     /// Returns a localized string for a specified region code.
     ///
-    /// For example, in the "en" locale, the result for `"fr"` is `"French"`.
+    /// For example, in the "en" locale, the result for `"fr"` is `"France"`.
     public func localizedString(forRegionCode regionCode: String) -> String? {
         return _wrapped.displayName(forKey: .countryCode, value: regionCode)
     }
diff --git a/Foundation/NSCFString.swift b/Foundation/NSCFString.swift
index e12e0fa..4558549 100644
--- a/Foundation/NSCFString.swift
+++ b/Foundation/NSCFString.swift
@@ -140,19 +140,18 @@
 }
 
 internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncoding, range: CFRange, buffer: UnsafeMutablePointer<UInt8>?, maxBufLen: CFIndex, usedBufLen: UnsafeMutablePointer<CFIndex>?) -> CFIndex {
+    let convertedLength: CFIndex
     switch encoding {
         // TODO: Don't treat many encodings like they are UTF8
     case CFStringEncoding(kCFStringEncodingUTF8), CFStringEncoding(kCFStringEncodingISOLatin1), CFStringEncoding(kCFStringEncodingMacRoman), CFStringEncoding(kCFStringEncodingASCII), CFStringEncoding(kCFStringEncodingNonLossyASCII):
-        let encodingView = (str as! NSString)._swiftObject.utf8
-        let start = encodingView.startIndex
+        let encodingView = (str as! NSString).substring(with: NSRange(range)).utf8
         if let buffer = buffer {
-            for idx in 0..<range.length {
-                let characterIndex = encodingView.index(start, offsetBy: idx + range.location)
-                let character = encodingView[characterIndex]
+            for (idx, character) in encodingView.enumerated() {
                 buffer.advanced(by: idx).initialize(to: character)
             }
         }
-        usedBufLen?.pointee = range.length
+        usedBufLen?.pointee = encodingView.count
+        convertedLength = encodingView.count
         
     case CFStringEncoding(kCFStringEncodingUTF16):
         let encodingView = (str as! NSString)._swiftObject.utf16
@@ -169,13 +168,13 @@
         }
         // Every character was 2 bytes
         usedBufLen?.pointee = range.length * 2
-
+        convertedLength = range.length
 
     default:
         fatalError("Attempted to get bytes of a Swift string using an unsupported encoding")
     }
     
-    return range.length
+    return convertedLength
 }
 
 internal func _CFSwiftStringCreateWithSubstring(_ str: AnyObject, range: CFRange) -> Unmanaged<AnyObject> {
diff --git a/Foundation/NSDecimal.swift b/Foundation/NSDecimal.swift
index c5a999f..dcba6f4 100644
--- a/Foundation/NSDecimal.swift
+++ b/Foundation/NSDecimal.swift
@@ -33,6 +33,9 @@
             return UInt32((__lengthAndFlags & 0b0000_1111))
         }
         set {
+            guard newValue <= maxMantissaLength else {
+                fatalError("Attempt to set a length greater than capacity \(newValue) > \(maxMantissaLength)")
+            }
             __lengthAndFlags =
                 (__lengthAndFlags & 0b1111_0000) |
                 UInt8(newValue & 0b0000_1111)
@@ -88,9 +91,8 @@
     public init(_exponent: Int32, _length: UInt32, _isNegative: UInt32, _isCompact: UInt32, _reserved: UInt32, _mantissa: (UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16)){
         self._mantissa = _mantissa
         self.__exponent = Int8(truncatingBitPattern: _exponent)
-        self.__lengthAndFlags = 0
+        self.__lengthAndFlags = UInt8(_length & 0b1111)
         self.__reserved = 0
-        self._length = _length
         self._isNegative = _isNegative
         self._isCompact = _isCompact
         self._reserved = _reserved
@@ -564,9 +566,7 @@
         d[i] = UInt16(accumulator / UInt32(divisor))
         carry = accumulator % UInt32(divisor)
     }
-    while d._length != 0 && d[d._length - 1] == 0 {
-        d._length -= 1
-    }
+    d.trimTrailingZeros()
     return (UInt16(carry),.noError)
 }
 
@@ -674,7 +674,7 @@
     var previousRemainder: Bool = false
 
     // Divide by 10 as much as possible
-    while big._length >= Decimal.maxSize {
+    while big._length > Decimal.maxSize + 1 {
         if remainder != 0 {
             previousRemainder = true
         }
@@ -727,21 +727,19 @@
     return .lossOfPrecision;
 }
 
-fileprivate func integerMultiply(_ big: inout WideDecimal,
-                                 _ left: WideDecimal,
-                                 _ right: WideDecimal) -> NSDecimalNumber.CalculationError {
+fileprivate func integerMultiply<T:VariableLengthNumber>(_ big: inout T,
+                                 _ left: T,
+                                 _ right: Decimal) -> NSDecimalNumber.CalculationError {
     if left._length == 0 || right._length == 0 {
         big._length = 0
         return .noError
     }
 
-    if big._length > left._length + right._length {
-        big._length = left._length + right._length
+    if big._length == 0 || big._length > left._length + right._length {
+        big._length = min(big.maxMantissaLength,left._length + right._length)
     }
 
-    for i in 0..<big._length {
-        big[i] = 0
-    }
+    big.zeroMantissa()
 
     var carry: UInt16 = 0
 
@@ -769,16 +767,14 @@
         }
     }
 
-    while big._length != 0 && big[big._length - 1] == 0 {
-        big._length -= 1
-    }
+    big.trimTrailingZeros()
 
     return .noError
 }
 
-fileprivate func integerDivide(_ r: inout WideDecimal,
-                               _ cu: WideDecimal,
-                               _ cv: WideDecimal) -> NSDecimalNumber.CalculationError {
+fileprivate func integerDivide<T:VariableLengthNumber>(_ r: inout T,
+                               _ cu: T,
+                               _ cv: Decimal) -> NSDecimalNumber.CalculationError {
     // Calculate result = a / b.
     // Result could NOT be a pointer to same space as a or b.
     // resultLen must be >= aLen - bLen.
@@ -792,17 +788,19 @@
     var u = WideDecimal(true)
     var v = WideDecimal(true) // divisor
 
-    var v1:UInt16, v2:UInt16
-
     // Simple case
     if cv.isZero {
         return .divideByZero;
     }
 
     // If u < v, the result is approximately 0...
-    if cu < cv {
-        r._length = 0
-        return .noError;
+    if cu._length < cv._length {
+        for i in 0..<cv._length {
+            if cu[i] < cv[i] {
+                r._length = 0
+                return .noError;
+            }
+        }
     }
 
     // Fast algorithm
@@ -812,6 +810,9 @@
         return error
     }
 
+    u.copyMantissa(from: cu)
+    v.copyMantissa(from: cv)
+
     u._length = cu._length + 1
     v._length = cv._length + 1
 
@@ -826,9 +827,12 @@
     _ = multiplyByShort(&u, UInt16(d))
     _ = multiplyByShort(&v, UInt16(d))
 
+    u.trimTrailingZeros()
+    v.trimTrailingZeros()
+
     // Set a zero at the leftmost u position if the multiplication
-    // do not have a carry.
-    if(u._length == cu._length) {
+    // does not have a carry.
+    if u._length == cu._length {
         u[u._length] = 0
         u._length += 1
     }
@@ -845,22 +849,20 @@
     // It's used to determine the quotient digit as fast as possible
     // The test vl > 1 is probably useless, since optimizations
     // up there are taking over this case. I'll keep it, just in case.
-    v1 = v[v._length-1]
-    v2 = v._length > 1 ? v[v._length-2] : 0
+    let v1:UInt16 = v[v._length-1]
+    let v2:UInt16 = v._length > 1 ? v[v._length-2] : 0
 
     // D2: initialize j
     // On each pass, build a single value for the quotient.
     for j in 0..<ql {
-        var q: UInt32 // Quotient digit. could be a short.
 
         // D3: calculate q^
         // This formula and test for q gives at most q+1; See Knuth for proof.
 
         let ul = u._length
-        let uu = u // work around compiler bug
-        let tmp: UInt32 = UInt32(uu[ul - UInt32(j) - UInt32(1)] << 16 + uu[ul - UInt32(j) - UInt32(2)])
-        q = tmp / UInt32(v1)
-        var rtmp: UInt32 = tmp % UInt32(v1)
+        let tmp:UInt32 = UInt32(u[ul - UInt32(j) - UInt32(1)]) << 16 + UInt32(u[ul - UInt32(j) - UInt32(2)])
+        var q:UInt32 = tmp / UInt32(v1) // Quotient digit. could be a short.
+        var rtmp:UInt32 = tmp % UInt32(v1)
 
         // This test catches all cases where q is really q+2 and
         // most where it is q+1
@@ -888,8 +890,7 @@
             acc = q * UInt32(v[i]) + mk     // multiply
             mk = acc >> 16                  // multiplication carry
             acc = acc & 0xffff;
-            let uu = u // work around compiler bug
-            acc = 0xffff + UInt32(uu[ul - vl + i - UInt32(j) - UInt32(1)]) - acc + sk; // subtract
+            acc = 0xffff + UInt32(u[ul - vl + i - UInt32(j) - UInt32(1)]) - acc + sk; // subtract
             sk = acc >> 16;
             u[ul - vl + i - UInt32(j) - UInt32(1)] = UInt16(truncatingBitPattern:acc)
         }
@@ -905,9 +906,7 @@
             for i in 0...v._length {
                 let ul = u._length
                 let vl = v._length
-                let vv = v // work around compiler bug
-                let uu = u // work around compiler bug
-                acc = UInt32(vv[i]) + UInt32(uu[UInt32(ul) - UInt32(vl) + UInt32(i) - UInt32(j) - UInt32(1)]) + k
+                acc = UInt32(v[i]) + UInt32(u[UInt32(ul) - UInt32(vl) + UInt32(i) - UInt32(j) - UInt32(1)]) + k
                 k = acc >> 16;
                 u[UInt32(ul) - UInt32(vl) + UInt32(i) - UInt32(j) - UInt32(1)] = UInt16(truncatingBitPattern:acc)
             }
@@ -920,14 +919,12 @@
 
     r._length = UInt32(ql);
 
-    while r._length != 0 && r[r._length - 1] == 0 {
-        r._length -= 1
-    }
+    r.trimTrailingZeros()
 
     return .noError;
 }
 
-fileprivate func integerMultiplyByPowerOf10(_ result: inout WideDecimal, _ left: WideDecimal, _ p: Int) -> NSDecimalNumber.CalculationError {
+fileprivate func integerMultiplyByPowerOf10<T:VariableLengthNumber>(_ result: inout T, _ left: T, _ p: Int) -> NSDecimalNumber.CalculationError {
     var power = p
     if power == 0 {
         result = left
@@ -943,10 +940,10 @@
     var error:NSDecimalNumber.CalculationError = .noError
 
     while power > maxpow10 {
-        var big = WideDecimal()
+        var big = T()
 
         power -= maxpow10
-        let p10 = WideDecimal(pow10[maxpow10])
+        let p10 = pow10[maxpow10]
 
         if !isNegative {
             error = integerMultiply(&big,result,p10)
@@ -965,9 +962,10 @@
         result._length = big._length
     }
 
-    var big = WideDecimal()
+    var big = T()
+
     // Handle the rest of the power (<= maxpow10)
-    let p10 = WideDecimal(pow10[Int(power)])
+    let p10 = pow10[Int(power)]
 
     if !isNegative {
         error = integerMultiply(&big, result, p10)
@@ -994,7 +992,7 @@
 
 public func NSDecimalNormalize(_ a: UnsafeMutablePointer<Decimal>, _ b: UnsafeMutablePointer<Decimal>, _ roundingMode: NSDecimalNumber.RoundingMode) -> NSDecimalNumber.CalculationError {
     var diffexp = a.pointee.__exponent - b.pointee.__exponent
-    var result = WideDecimal()
+    var result = Decimal()
 
     //
     // If the two numbers share the same exponents,
@@ -1030,19 +1028,49 @@
     // Try to multiply aa to reach the same exponent level than bb
     //
 
-    if integerMultiplyByPowerOf10(&result, WideDecimal(aa.pointee), Int(diffexp)) == .noError {
+    if integerMultiplyByPowerOf10(&result, aa.pointee, Int(diffexp)) == .noError {
         // Succeed. Adjust the length/exponent info
         // and return no errorNSDecimalNormalize
-        aa.pointee._length = result._length
-        for i in 0..<result._length {
-            aa.pointee[i] = result[i]
-        }
-        aa.pointee._isCompact = 0
+        aa.pointee.copyMantissa(from: result)
         aa.pointee._exponent = bb.pointee._exponent
         return .noError;
     }
 
-    NSUnimplemented() // work in progress
+    //
+    // Failed, restart from scratch
+    //
+    NSDecimalCopy(aa, &backup);
+
+    //
+    // What is the maximum pow10 we can apply to aa ?
+    //
+    let logBase10of2to16 = 4.81647993
+    let aaLength = aa.pointee._length
+    let maxpow10 = Int8(floor(Double(Decimal.maxSize - aaLength) * logBase10of2to16))
+
+    //
+    // Divide bb by this value
+    //
+    _ = integerMultiplyByPowerOf10(&result, bb.pointee, maxpow10 - diffexp)
+
+    bb.pointee.copyMantissa(from: result)
+    bb.pointee._exponent -= maxpow10 - diffexp;
+
+    //
+    // If bb > 0 multiply aa by the same value
+    //
+    if !bb.pointee.isZero {
+        _ = integerMultiplyByPowerOf10(&result, aa.pointee, Int(maxpow10))
+        aa.pointee.copyMantissa(from: result)
+        aa.pointee._exponent -= Int32(maxpow10)
+    } else {
+        bb.pointee._exponent = aa.pointee._exponent;
+    }
+
+    //
+    // the two exponents are now identical, but we've lost some digits in the operation.
+    //
+    return .lossOfPrecision;
 }
 
 public func NSDecimalAdd(_ result: UnsafeMutablePointer<Decimal>, _ leftOperand: UnsafePointer<Decimal>, _ rightOperand: UnsafePointer<Decimal>, _ roundingMode: NSDecimalNumber.RoundingMode) -> NSDecimalNumber.CalculationError {
@@ -1233,9 +1261,7 @@
     }
     result._length = i;
 
-    while result._length != 0 && result[result._length - 1] == 0 {
-        result._length -= 1
-    }
+    result.trimTrailingZeros()
 
     return .noError;
 }
@@ -1265,7 +1291,7 @@
     var big = WideDecimal()
     var calculationError:NSDecimalNumber.CalculationError = .noError
 
-    calculationError = integerMultiply(&big,WideDecimal(leftOperand.pointee),WideDecimal(rightOperand.pointee))
+    calculationError = integerMultiply(&big,WideDecimal(leftOperand.pointee),rightOperand.pointee)
 
     result.pointee._isNegative = (leftOperand.pointee._isNegative + rightOperand.pointee._isNegative) % 2
 
@@ -1340,7 +1366,7 @@
     }
 
     _ = integerMultiplyByPowerOf10(&big, WideDecimal(a), 38) // Trust me, it's 38 !
-    _ = integerDivide(&big, big, WideDecimal(b))
+    _ = integerDivide(&big, big, b)
     _ = fitMantissa(&big, &exponent, .down)
 
     let length = min(big._length,Decimal.maxSize)
@@ -1386,23 +1412,84 @@
 
 public func NSDecimalString(_ dcm: UnsafePointer<Decimal>, _ locale: AnyObject?) -> String {
     guard locale == nil else {
-        fatalError("Locale not supported: \(locale)")
+        fatalError("Locale not supported: \(locale!)")
     }
     return dcm.pointee.description
 }
 
 fileprivate protocol VariableLengthNumber {
     var _length: UInt32 { get set }
+    init()
     subscript(index:UInt32) -> UInt16 { get set }
     var isZero:Bool { get }
+    mutating func copyMantissa<T:VariableLengthNumber>(from other:T)
+    mutating func zeroMantissa()
+    mutating func trimTrailingZeros()
+    var maxMantissaLength: UInt32 { get }
 }
 
 extension Decimal: VariableLengthNumber {
-
+    var maxMantissaLength:UInt32 {
+        return Decimal.maxSize
+    }
+    fileprivate mutating func zeroMantissa() {
+        for i in 0..<Decimal.maxSize {
+            self[i] = 0
+        }
+    }
+    internal mutating func trimTrailingZeros() {
+        if _length > Decimal.maxSize {
+            _length = Decimal.maxSize
+        }
+        while _length != 0 && self[_length - 1] == 0 {
+            _length -= 1
+        }
+    }
+    fileprivate mutating func copyMantissa<T : VariableLengthNumber>(from other: T) {
+        if other._length > maxMantissaLength {
+            for i in maxMantissaLength..<other._length {
+                guard other[i] == 0 else {
+                    fatalError("Loss of precision during copy other[\(i)] \(other[i]) != 0")
+                }
+            }
+        }
+        let length = min(other._length, maxMantissaLength)
+        for i in 0..<length {
+            self[i] = other[i]
+        }
+        self._length = length
+        self._isCompact = 0
+    }
 }
 
 // Provides a way with dealing with extra-length decimals, used for calculations
 fileprivate struct WideDecimal : VariableLengthNumber {
+    var maxMantissaLength:UInt32 {
+        return _extraWide ? 17 : 16
+    }
+
+    fileprivate mutating func zeroMantissa() {
+        for i in 0..<maxMantissaLength {
+            self[i] = 0
+        }
+    }
+    fileprivate mutating func trimTrailingZeros() {
+        while _length != 0 && self[_length - 1] == 0 {
+            _length -= 1
+        }
+    }
+    init() {
+        self.init(false)
+    }
+
+    fileprivate mutating func copyMantissa<T : VariableLengthNumber>(from other: T) {
+        let length = other is Decimal ? min(other._length,Decimal.maxSize) : other._length
+        for i in 0..<length {
+            self[i] = other[i]
+        }
+        self._length = length
+    }
+
     var isZero: Bool {
         return _length == 0
     }
@@ -1417,14 +1504,14 @@
             return UInt32(__length)
         }
         set {
-            guard newValue <= Decimal.maxSize * 2 + 1 else {
-                fatalError("Cannot set size to \(newValue)")
+            guard newValue <= maxMantissaLength else {
+                fatalError("Attempt to set a length greater than capacity \(newValue) > \(maxMantissaLength)")
             }
             __length = UInt16(newValue)
         }
     }
     init(_ extraWide:Bool = false) {
-        __length = UInt16(Decimal.maxSize * 2)
+        __length = 0
         _mantissa = (UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0),UInt16(0))
         _extraWide = extraWide
     }
@@ -1479,26 +1566,6 @@
             }
         }
     }
-    public func compare(to rhs: WideDecimal) -> ComparisonResult {
-        if self._length > rhs._length {
-            return .orderedDescending
-        }
-        if self._length < rhs._length {
-            return .orderedAscending
-        }
-        for i in (0..<self._length).reversed() {
-            if self[i] > rhs[i] {
-                return .orderedDescending
-            }
-            if self[i] < rhs[i] {
-                return .orderedAscending
-            }
-        }
-        return .orderedSame
-    }
-    public static func <(lhs: WideDecimal, rhs: WideDecimal) -> Bool {
-        return lhs.compare(to:rhs) == .orderedAscending
-    }
     func toDecimal() -> Decimal {
         var result = Decimal()
         result._length = self._length
@@ -1630,7 +1697,7 @@
         _exponent = newExponent;
         self.compact();
     }
-    fileprivate func compare(to other:Decimal) -> ComparisonResult {
+    internal func compare(to other:Decimal) -> ComparisonResult {
         // NaN is a special case and is arbitrary ordered before everything else
         // Conceptually comparing with NaN is bogus anyway but raising or
         // always returning the same answer will confuse the sorting algorithms
diff --git a/Foundation/NSDecimalNumber.swift b/Foundation/NSDecimalNumber.swift
index 759dc28..46b9b20 100644
--- a/Foundation/NSDecimalNumber.swift
+++ b/Foundation/NSDecimalNumber.swift
@@ -75,29 +75,86 @@
 
 // Receiver can raise, return a new value, or return nil to ignore the exception.
 
+fileprivate func handle(_ error: NSDecimalNumber.CalculationError, _ handler: NSDecimalNumberBehaviors) {
+    // handle the error condition, such as throwing an error for over/underflow
+}
 
 /***************	NSDecimalNumber: the class		***********/
 open class NSDecimalNumber : NSNumber {
-    
-    public convenience init(mantissa: UInt64, exponent: Int16, isNegative flag: Bool) { NSUnimplemented() }
-    public init(decimal dcm: Decimal) { NSUnimplemented() }
-    public convenience init(string numberValue: String?) { NSUnimplemented() }
-    public convenience init(string numberValue: String?, locale: AnyObject?) { NSUnimplemented() }
 
-    public required init?(coder aDecoder: NSCoder) {
-        NSUnimplemented()
+    fileprivate let decimal: Decimal
+    public convenience init(mantissa: UInt64, exponent: Int16, isNegative: Bool) {
+        var d = Decimal()
+        d._exponent = Int32(exponent)
+        d._isNegative = isNegative ? 1 : 0
+        var man = mantissa
+        d._mantissa.0 = UInt16(man & 0xffff)
+        man >>= 4
+        d._mantissa.1 = UInt16(man & 0xffff)
+        man >>= 4
+        d._mantissa.2 = UInt16(man & 0xffff)
+        man >>= 4
+        d._mantissa.3 = UInt16(man & 0xffff)
+        d._length = 4
+        d.trimTrailingZeros()
+        // TODO more parts of the mantissa...
+        self.init(decimal: d)
+    }
+    public init(decimal dcm: Decimal) {
+        self.decimal = dcm
+        super.init()
+    }
+    public convenience init(string numberValue: String?) {
+        self.init(decimal: Decimal(string: numberValue ?? "") ?? Decimal.nan)
+    }
+    public convenience init(string numberValue: String?, locale: AnyObject?) {
+        self.init(decimal: Decimal(string: numberValue ?? "", locale: locale as? Locale) ?? Decimal.nan)
+    }
+
+    public required init?(coder: NSCoder) {
+        guard coder.allowsKeyedCoding else {
+            preconditionFailure("Unkeyed coding is unsupported.")
+        }
+        let exponent:Int32 = coder.decodeInt32(forKey: "NS.exponent")
+        let length:UInt32 = UInt32(coder.decodeInt32(forKey: "NS.length"))
+        let isNegative:UInt32 = UInt32(coder.decodeBool(forKey: "NS.negative") ? 1 : 0)
+        let isCompact:UInt32 = UInt32(coder.decodeBool(forKey: "NS.compact") ? 1 : 0)
+        // let byteOrder:UInt32 = UInt32(coder.decodeInt32(forKey: "NS.bo"))
+        guard let mantissaData: Data = coder.decodeObject(forKey: "NS.mantissa") as? Data else {
+            return nil // raise "Critical NSDecimalNumber archived data is missing"
+        }
+        guard mantissaData.count == Int(NSDecimalMaxSize * 2) else {
+            return nil  // raise "Critical NSDecimalNumber archived data is wrong size"
+        }
+        // Byte order?
+        let mantissa:(UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16) = (
+            UInt16(mantissaData[0]) << 8 & UInt16(mantissaData[1]),
+            UInt16(mantissaData[2]) << 8 & UInt16(mantissaData[3]),
+            UInt16(mantissaData[4]) << 8 & UInt16(mantissaData[5]),
+            UInt16(mantissaData[6]) << 8 & UInt16(mantissaData[7]),
+            UInt16(mantissaData[8]) << 8 & UInt16(mantissaData[9]),
+            UInt16(mantissaData[10]) << 8 & UInt16(mantissaData[11]),
+            UInt16(mantissaData[12]) << 8 & UInt16(mantissaData[13]),
+            UInt16(mantissaData[14]) << 8 & UInt16(mantissaData[15])
+        )
+        self.decimal = Decimal(_exponent: exponent, _length: length, _isNegative: isNegative, _isCompact: isCompact, _reserved: 0, _mantissa: mantissa)
+        super.init()
     }
 
     public required convenience init(floatLiteral value: Double) {
-        NSUnimplemented()
+        self.init(decimal:Decimal(value))
     }
 
     public required convenience init(booleanLiteral value: Bool) {
-        NSUnimplemented()
+        if value {
+            self.init(integerLiteral: 1)
+        } else {
+            self.init(integerLiteral: 0)
+        }
     }
 
     public required convenience init(integerLiteral value: Int) {
-        NSUnimplemented()
+        self.init(decimal:Decimal(value))
     }
     
     public required convenience init(bytes buffer: UnsafeRawPointer, objCType type: UnsafePointer<Int8>) {
@@ -105,52 +162,180 @@
     }
     
     open override func description(withLocale locale: Locale?) -> String { NSUnimplemented() }
+
+    open class var zero: NSDecimalNumber {
+        return NSDecimalNumber(integerLiteral: 0)
+    }
+    open class var one: NSDecimalNumber {
+        return NSDecimalNumber(integerLiteral: 1)
+    }
+    open class var minimum: NSDecimalNumber {
+        return NSDecimalNumber(decimal:Decimal.leastFiniteMagnitude)
+    }
+    open class var maximum: NSDecimalNumber {
+        return NSDecimalNumber(decimal:Decimal.greatestFiniteMagnitude)
+
+    }
+    open class var notANumber: NSDecimalNumber {
+        return NSDecimalNumber(decimal: Decimal.nan)
+    }
     
-    // TODO: "declarations from extensions cannot be overridden yet"
-    // Although it's not clear we actually need to redeclare this here when the extension adds it to the superclass of this class
-    // open var decimalValue: Decimal { NSUnimplemented() }
+    open func adding(_ other: NSDecimalNumber) -> NSDecimalNumber {
+        return adding(other, withBehavior: nil)
+    }
+    open func adding(_ other: NSDecimalNumber, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
+        var result = Decimal()
+        var left = self.decimal
+        var right = other.decimal
+        let behavior = b ?? NSDecimalNumber.defaultBehavior
+        let roundingMode = behavior.roundingMode()
+        let error = NSDecimalAdd(&result, &left, &right, roundingMode)
+        handle(error,behavior)
+        return NSDecimalNumber(decimal: result)
+    }
+
+    open func subtracting(_ other: NSDecimalNumber) -> NSDecimalNumber {
+        return subtracting(other, withBehavior: nil)
+    }
+    open func subtracting(_ other: NSDecimalNumber, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
+        var result = Decimal()
+        var left = self.decimal
+        var right = other.decimal
+        let behavior = b ?? NSDecimalNumber.defaultBehavior
+        let roundingMode = behavior.roundingMode()
+        let error = NSDecimalSubtract(&result, &left, &right, roundingMode)
+        handle(error,behavior)
+        return NSDecimalNumber(decimal: result)
+    }
+    open func multiplying(by other: NSDecimalNumber) -> NSDecimalNumber {
+        return multiplying(by: other, withBehavior: nil)
+    }
+    open func multiplying(by other: NSDecimalNumber, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
+        var result = Decimal()
+        var left = self.decimal
+        var right = other.decimal
+        let behavior = b ?? NSDecimalNumber.defaultBehavior
+        let roundingMode = behavior.roundingMode()
+        let error = NSDecimalMultiply(&result, &left, &right, roundingMode)
+        handle(error,behavior)
+        return NSDecimalNumber(decimal: result)
+    }
     
-    open class var zero: NSDecimalNumber { NSUnimplemented() }
-    open class var one: NSDecimalNumber { NSUnimplemented() }
-    open class var minimum: NSDecimalNumber { NSUnimplemented() }
-    open class var maximum: NSDecimalNumber { NSUnimplemented() }
-    open class var notANumber: NSDecimalNumber { NSUnimplemented() }
+    open func dividing(by other: NSDecimalNumber) -> NSDecimalNumber {
+        return dividing(by: other, withBehavior: nil)
+    }
+    open func dividing(by other: NSDecimalNumber, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
+        var result = Decimal()
+        var left = self.decimal
+        var right = other.decimal
+        let behavior = b ?? NSDecimalNumber.defaultBehavior
+        let roundingMode = behavior.roundingMode()
+        let error = NSDecimalDivide(&result, &left, &right, roundingMode)
+        handle(error,behavior)
+        return NSDecimalNumber(decimal: result)
+    }
     
-    open func adding(_ decimalNumber: NSDecimalNumber) -> NSDecimalNumber { NSUnimplemented() }
-    open func adding(_ decimalNumber: NSDecimalNumber, withBehavior behavior: NSDecimalNumberBehaviors?) -> NSDecimalNumber { NSUnimplemented() }
-    
-    open func subtracting(_ decimalNumber: NSDecimalNumber) -> NSDecimalNumber { NSUnimplemented() }
-    open func subtracting(_ decimalNumber: NSDecimalNumber, withBehavior behavior: NSDecimalNumberBehaviors?) -> NSDecimalNumber { NSUnimplemented() }
-    
-    open func multiplying(by decimalNumber: NSDecimalNumber) -> NSDecimalNumber { NSUnimplemented() }
-    open func multiplying(by decimalNumber: NSDecimalNumber, withBehavior behavior: NSDecimalNumberBehaviors?) -> NSDecimalNumber { NSUnimplemented() }
-    
-    open func dividing(by decimalNumber: NSDecimalNumber) -> NSDecimalNumber { NSUnimplemented() }
-    open func dividing(by decimalNumber: NSDecimalNumber, withBehavior behavior: NSDecimalNumberBehaviors?) -> NSDecimalNumber { NSUnimplemented() }
-    
-    open func raising(toPower power: Int) -> NSDecimalNumber { NSUnimplemented() }
-    open func raising(toPower power: Int, withBehavior behavior: NSDecimalNumberBehaviors?) -> NSDecimalNumber { NSUnimplemented() }
-    
-    open func multiplying(byPowerOf10 power: Int16) -> NSDecimalNumber { NSUnimplemented() }
-    open func multiplying(byPowerOf10 power: Int16, withBehavior behavior: NSDecimalNumberBehaviors?) -> NSDecimalNumber { NSUnimplemented() }
+    open func raising(toPower power: Int) -> NSDecimalNumber {
+        return raising(toPower:power, withBehavior: nil)
+    }
+    open func raising(toPower power: Int, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
+        var result = Decimal()
+        var input = self.decimal
+        let behavior = b ?? NSDecimalNumber.defaultBehavior
+        let roundingMode = behavior.roundingMode()
+        let error = NSDecimalPower(&result, &input, power, roundingMode)
+        handle(error,behavior)
+        return NSDecimalNumber(decimal: result)
+    }
+
+    open func multiplying(byPowerOf10 power: Int16) -> NSDecimalNumber {
+        return multiplying(byPowerOf10: power, withBehavior: nil)
+    }
+    open func multiplying(byPowerOf10 power: Int16, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
+        var result = Decimal()
+        var input = self.decimal
+        let behavior = b ?? NSDecimalNumber.defaultBehavior
+        let roundingMode = behavior.roundingMode()
+        let error = NSDecimalPower(&result, &input, Int(power), roundingMode)
+        handle(error,behavior)
+        return NSDecimalNumber(decimal: result)
+    }
     
     open func rounding(accordingToBehavior behavior: NSDecimalNumberBehaviors?) -> NSDecimalNumber { NSUnimplemented() }
     // Round to the scale of the behavior.
     
-    open override func compare(_ decimalNumber: NSNumber) -> ComparisonResult { NSUnimplemented() }
     // compare two NSDecimalNumbers
-    
-    open class var defaultBehavior: NSDecimalNumberBehaviors { NSUnimplemented() }
+    open override func compare(_ decimalNumber: NSNumber) -> ComparisonResult {
+        if let num = decimalNumber as? NSDecimalNumber {
+            return decimal.compare(to:num.decimal)
+        } else {
+            return decimal.compare(to:Decimal(decimalNumber.doubleValue))
+        }
+    }
+
+    open class var defaultBehavior: NSDecimalNumberBehaviors {
+        return NSDecimalNumberHandler.defaultBehavior
+    }
     // One behavior per thread - The default behavior is
     //   rounding mode: NSRoundPlain
     //   scale: No defined scale (full precision)
     //   ignore exactnessException
     //   raise on overflow, underflow and divide by zero.
-    
-    open override var objCType: UnsafePointer<Int8> { NSUnimplemented() }
+    static let OBJC_TYPE = "d".utf8CString
+
+    open override var objCType: UnsafePointer<Int8> {
+        return NSDecimalNumber.OBJC_TYPE.withUnsafeBufferPointer{ $0.baseAddress! }
+    }
     // return 'd' for double
     
-    open override var doubleValue: Double { NSUnimplemented() }
+    open override var int8Value: Int8 {
+        return Int8(decimal.doubleValue)
+    }
+    open override var uint8Value: UInt8 {
+        return UInt8(decimal.doubleValue)
+    }
+    open override var int16Value: Int16 {
+        return Int16(decimal.doubleValue)
+    }
+    open override var uint16Value: UInt16 {
+        return UInt16(decimal.doubleValue)
+    }
+    open override var int32Value: Int32 {
+        return Int32(decimal.doubleValue)
+    }
+    open override var uint32Value: UInt32 {
+        return UInt32(decimal.doubleValue)
+    }
+    open override var int64Value: Int64 {
+        return Int64(decimal.doubleValue)
+    }
+    open override var uint64Value: UInt64 {
+        return UInt64(decimal.doubleValue)
+    }
+    open override var floatValue: Float {
+        return Float(decimal.doubleValue)
+    }
+    open override var doubleValue: Double {
+        return decimal.doubleValue
+    }
+    open override var boolValue: Bool {
+        return !decimal.isZero
+    }
+    open override var intValue: Int {
+        return Int(decimal.doubleValue)
+    }
+    open override var uintValue: UInt {
+        return UInt(decimal.doubleValue)
+    }
+
+    open override func isEqual(_ value: Any?) -> Bool {
+        if let number = value as? NSDecimalNumber {
+            return self.decimal == number.decimal
+        } else {
+            return false
+        }
+    }
+
 }
 
 // return an approximate double value
@@ -158,33 +343,103 @@
 
 /***********	A class for defining common behaviors		*******/
 open class NSDecimalNumberHandler : NSObject, NSDecimalNumberBehaviors, NSCoding {
-    
-    public required init?(coder aDecoder: NSCoder) {
-        NSUnimplemented()
+
+    static let defaultBehavior = NSDecimalNumberHandler()
+
+    let _roundingMode: NSDecimalNumber.RoundingMode
+    let _scale:Int16
+
+    let _raiseOnExactness: Bool
+    let _raiseOnOverflow: Bool
+    let _raiseOnUnderflow: Bool
+    let _raiseOnDivideByZero: Bool
+
+    public override init() {
+        _roundingMode = .plain
+        _scale = Int16(NSDecimalNoScale)
+
+        _raiseOnExactness = false
+        _raiseOnOverflow = true
+        _raiseOnUnderflow = true
+        _raiseOnDivideByZero = true
+    }
+    public required init?(coder: NSCoder) {
+        guard coder.allowsKeyedCoding else {
+            preconditionFailure("Unkeyed coding is unsupported.")
+        }
+        _roundingMode = NSDecimalNumber.RoundingMode(rawValue: UInt(coder.decodeInteger(forKey: "NS.roundingMode")))!
+        if coder.containsValue(forKey: "NS.scale") {
+            _scale = Int16(coder.decodeInteger(forKey: "NS.scale"))
+        } else {
+            _scale = Int16(NSDecimalNoScale)
+        }
+        _raiseOnExactness = coder.decodeBool(forKey: "NS.raise.exactness")
+        _raiseOnOverflow = coder.decodeBool(forKey: "NS.raise.overflow")
+        _raiseOnUnderflow = coder.decodeBool(forKey: "NS.raise.underflow")
+        _raiseOnDivideByZero = coder.decodeBool(forKey: "NS.raise.dividebyzero")
     }
     
-    open func encode(with aCoder: NSCoder) {
-        NSUnimplemented()
+    open func encode(with coder: NSCoder) {
+        guard coder.allowsKeyedCoding else {
+            preconditionFailure("Unkeyed coding is unsupported.")
+        }
+        if _roundingMode != .plain {
+            coder.encode(Int(_roundingMode.rawValue), forKey: "NS.roundingmode")
+        }
+        if _scale != Int16(NSDecimalNoScale) {
+            coder.encode(_scale, forKey:"NS.scale")
+        }
+        if _raiseOnExactness {
+            coder.encode(_raiseOnExactness, forKey:"NS.raise.exactness")
+        }
+        if _raiseOnOverflow {
+            coder.encode(_raiseOnOverflow, forKey:"NS.raise.overflow")
+        }
+        if _raiseOnUnderflow {
+            coder.encode(_raiseOnUnderflow, forKey:"NS.raise.underflow")
+        }
+        if _raiseOnDivideByZero {
+            coder.encode(_raiseOnDivideByZero, forKey:"NS.raise.dividebyzero")
+        }
     }
     
-    open class func `default`() -> NSDecimalNumberHandler { NSUnimplemented() }
+    open class func `default`() -> NSDecimalNumberHandler {
+        return defaultBehavior
+    }
     // rounding mode: NSRoundPlain
     // scale: No defined scale (full precision)
     // ignore exactnessException (return nil)
     // raise on overflow, underflow and divide by zero.
     
-    public init(roundingMode: NSDecimalNumber.RoundingMode, scale: Int16, raiseOnExactness exact: Bool, raiseOnOverflow overflow: Bool, raiseOnUnderflow underflow: Bool, raiseOnDivideByZero divideByZero: Bool) { NSUnimplemented() }
+    public init(roundingMode: NSDecimalNumber.RoundingMode, scale: Int16, raiseOnExactness exact: Bool, raiseOnOverflow overflow: Bool, raiseOnUnderflow underflow: Bool, raiseOnDivideByZero divideByZero: Bool) {
+        _roundingMode = roundingMode
+        _scale = scale
+        _raiseOnExactness = exact
+        _raiseOnOverflow = overflow
+        _raiseOnUnderflow = underflow
+        _raiseOnDivideByZero = divideByZero
+    }
     
-    open func roundingMode() -> NSDecimalNumber.RoundingMode { NSUnimplemented() }
+    open func roundingMode() -> NSDecimalNumber.RoundingMode {
+        return _roundingMode
+    }
     
-    open func scale() -> Int16 { NSUnimplemented() }
-    // The scale could return NO_SCALE for no defined scale.
+    // The scale could return NoScale for no defined scale.
+    open func scale() -> Int16 {
+        return _scale
+    }
 }
 
 
 extension NSNumber {
     
-    public var decimalValue: Decimal { NSUnimplemented() }
+    public var decimalValue: Decimal {
+        if let d = self as? NSDecimalNumber {
+            return d.decimal
+        } else {
+            return Decimal(self.doubleValue)
+        }
+    }
 }
 
 // Could be silently inexact for float and double.
diff --git a/Foundation/NSKeyedArchiver.swift b/Foundation/NSKeyedArchiver.swift
index 003dc15..f9b473b 100644
--- a/Foundation/NSKeyedArchiver.swift
+++ b/Foundation/NSKeyedArchiver.swift
@@ -270,7 +270,9 @@
             return NSKeyedArchiveNullObjectReference
         }
         
-        uid = self._objRefMap[objv as! AnyHashable]
+        let value = _SwiftValue.store(objv)!
+        
+        uid = self._objRefMap[value]
         if uid == nil {
             if conditional {
                 return nil // object has not been unconditionally encoded
@@ -278,7 +280,7 @@
             
             uid = UInt32(self._objects.count)
             
-            self._objRefMap[objv as! AnyHashable] = uid
+            self._objRefMap[value] = uid
             self._objects.insert(NSKeyedArchiveNullObjectReferenceName, at: Int(uid!))
         }
 
@@ -292,7 +294,7 @@
         if objv == nil {
             return true // always have a null reference
         } else {
-            return self._objRefMap[objv as! AnyHashable] != nil
+            return self._objRefMap[_SwiftValue.store(objv)] != nil
         }
     }
     
@@ -361,10 +363,10 @@
      */
     private func replaceObject(_ object: Any, withObject replacement: Any?) {
         if let unwrappedDelegate = self.delegate {
-            unwrappedDelegate.archiver(self, willReplace: object as! AnyHashable, with: replacement)
+            unwrappedDelegate.archiver(self, willReplace: object, with: replacement)
         }
         
-        self._replacementMap[object as! AnyHashable] = replacement
+        self._replacementMap[_SwiftValue.store(object)] = replacement
     }
    
     /**
@@ -476,9 +478,8 @@
         
         // object replaced by NSObject.replacementObjectForKeyedArchiver
         // if it is replaced with nil, it cannot be further replaced
-        if objectToEncode == nil {
-            let ns = object as? NSObject
-            objectToEncode = ns?.replacementObjectForKeyedArchiver(self)
+        if let ns = objectToEncode as? NSObject {
+            objectToEncode = ns.replacementObjectForKeyedArchiver(self)
             if objectToEncode == nil {
                 replaceObject(object!, withObject: nil)
                 return nil
@@ -510,7 +511,12 @@
 
         haveVisited = _haveVisited(objv)
         object = _replacementObject(objv)
-
+        
+        // bridge value types
+        if let bridgedObject = object as? _ObjectBridgeable {
+            object = bridgedObject._bridgeToAnyObject()
+        }
+        
         objectRef = _referenceObject(object, conditional: conditional)
         guard let unwrappedObjectRef = objectRef else {
             // we can return nil if the object is being conditionally encoded
@@ -531,12 +537,9 @@
                 _pushEncodingContext(innerEncodingContext)
                 codable.encode(with: self)
 
-                guard let ns = object as? NSObject else {
-                    fatalError("Attempt to encode non-NSObject");
-                }
-
-                let cls : AnyClass = ns.classForKeyedArchiver ?? type(of: object) as! AnyClass
-
+                let ns = object as? NSObject
+                let cls : AnyClass = ns?.classForKeyedArchiver ?? type(of: object!) as! AnyClass
+                
                 _setObjectInCurrentEncodingContext(_classReference(cls), forKey: "$class", escape: false)
                 _popEncodingContext()
                 encodedObject = innerEncodingContext.dict
diff --git a/Foundation/NSKeyedUnarchiver.swift b/Foundation/NSKeyedUnarchiver.swift
index d9c691e..b3dfc8e 100644
--- a/Foundation/NSKeyedUnarchiver.swift
+++ b/Foundation/NSKeyedUnarchiver.swift
@@ -375,7 +375,7 @@
             unwrappedDelegate.unarchiver(self, willReplace: object, with: replacement)
         }
         
-        self._replacementMap[object as! AnyHashable] = replacement
+        self._replacementMap[_SwiftValue.store(object)] = replacement
     }
     
     private func _decodingError(_ code: CocoaError.Code, withDescription description: String) -> NSError {
@@ -392,7 +392,7 @@
         }
         
         // check replacement cache
-        object = self._replacementMap[decodedObject as! AnyHashable]
+        object = self._replacementMap[_SwiftValue.store(decodedObject)]
         if object != nil {
             return object
         }
@@ -489,9 +489,8 @@
             }
         } else {
             // reference to a non-container object
-            // FIXME remove these special cases
-            if let str = dereferencedObject as? String {
-                object = str._bridgeToObjectiveC()
+            if let bridgedObject = dereferencedObject as? _ObjectBridgeable {
+                object = bridgedObject._bridgeToAnyObject()
             } else {
                 object = dereferencedObject
             }
diff --git a/Foundation/NSLock.swift b/Foundation/NSLock.swift
index c4a9f68..e166b80 100644
--- a/Foundation/NSLock.swift
+++ b/Foundation/NSLock.swift
@@ -115,7 +115,7 @@
 
     open func lock(before limit: Date) -> Bool {
         _cond.lock()
-        while _thread == nil {
+        while _thread != nil {
             if !_cond.wait(until: limit) {
                 _cond.unlock()
                 return false
diff --git a/Foundation/NSNumber.swift b/Foundation/NSNumber.swift
index 724cc02..14bec84 100644
--- a/Foundation/NSNumber.swift
+++ b/Foundation/NSNumber.swift
@@ -290,7 +290,11 @@
         super.init()
         _CFNumberInitBool(_cfObject, value)
     }
-    
+
+    override internal init() {
+        super.init()
+    }
+
     public required convenience init(bytes buffer: UnsafeRawPointer, objCType: UnsafePointer<Int8>) {
         guard let type = _NSSimpleObjCType(UInt8(objCType.pointee)) else {
             fatalError("NSNumber.init: unsupported type encoding spec '\(String(cString: objCType))'")
diff --git a/Foundation/NSString.swift b/Foundation/NSString.swift
index 32455e9..95f5e6c 100644
--- a/Foundation/NSString.swift
+++ b/Foundation/NSString.swift
@@ -817,7 +817,7 @@
 
             return data
         }
-        return nil
+        return Data()
     }
     
     public func data(using encoding: UInt) -> Data? {
@@ -1008,8 +1008,10 @@
     open func trimmingCharacters(in set: CharacterSet) -> String {
         let len = length
         var buf = _NSStringBuffer(string: self, start: 0, end: len)
-        while !buf.isAtEnd && set.contains(UnicodeScalar(buf.currentCharacter)!) {
-            buf.advance()
+        while !buf.isAtEnd,
+            let character = UnicodeScalar(buf.currentCharacter),
+            set.contains(character) {
+                buf.advance()
         }
         
         let startOfNonTrimmedRange = buf.location // This points at the first char not in the set
@@ -1018,8 +1020,10 @@
             return ""
         } else if startOfNonTrimmedRange < len - 1 {
             buf.location = len - 1
-            while set.contains(UnicodeScalar(buf.currentCharacter)!) && buf.location >= startOfNonTrimmedRange {
-                buf.rewind()
+            while let character = UnicodeScalar(buf.currentCharacter),
+                set.contains(character),
+                buf.location >= startOfNonTrimmedRange {
+                    buf.rewind()
             }
             let endOfNonTrimmedRange = buf.location
             return substring(with: NSMakeRange(startOfNonTrimmedRange, endOfNonTrimmedRange + 1 - startOfNonTrimmedRange))
diff --git a/Foundation/NSURLCredential.swift b/Foundation/NSURLCredential.swift
index 300126a..32cd075 100644
--- a/Foundation/NSURLCredential.swift
+++ b/Foundation/NSURLCredential.swift
@@ -65,11 +65,32 @@
      */
     
     public required init?(coder aDecoder: NSCoder) {
-        NSUnimplemented()
+        guard aDecoder.allowsKeyedCoding else {
+            preconditionFailure("Unkeyed coding is unsupported.")
+        }
+        
+        func bridgeString(_ value: NSString) -> String? {
+            return String._unconditionallyBridgeFromObjectiveC(value)
+        }
+        
+        let encodedUser = aDecoder.decodeObject(forKey: "NS._user") as! NSString
+        self._user = bridgeString(encodedUser)!
+        
+        let encodedPassword = aDecoder.decodeObject(forKey: "NS._password") as! NSString
+        self._password = bridgeString(encodedPassword)!
+        
+        let encodedPersistence = aDecoder.decodeObject(forKey: "NS._persistence") as! NSNumber
+        self._persistence = Persistence(rawValue: encodedPersistence.uintValue)!
     }
     
     open func encode(with aCoder: NSCoder) {
-        NSUnimplemented()
+        guard aCoder.allowsKeyedCoding else {
+            preconditionFailure("Unkeyed coding is unsupported.")
+        }
+        
+        aCoder.encode(self._user._bridgeToObjectiveC(), forKey: "NS._user")
+        aCoder.encode(self._password._bridgeToObjectiveC(), forKey: "NS._password")
+        aCoder.encode(self._persistence.rawValue._bridgeToObjectiveC(), forKey: "NS._persistence")
     }
     
     static public var supportsSecureCoding: Bool {
@@ -84,6 +105,17 @@
         return self 
     }
     
+    open override func isEqual(_ object: Any?) -> Bool {
+        if let other = object as? URLCredential {
+            return other === self
+                || (other._user == self._user
+                    && other._password == self._password
+                    && other._persistence == self._persistence)
+        }
+        
+        return false
+    }
+    
     /*!
         @method persistence
         @abstract Determine whether this credential is or should be stored persistently
diff --git a/Foundation/NSURLSession/HTTPMessage.swift b/Foundation/NSURLSession/HTTPMessage.swift
index 4f41eef..6598d06 100644
--- a/Foundation/NSURLSession/HTTPMessage.swift
+++ b/Foundation/NSURLSession/HTTPMessage.swift
@@ -143,7 +143,12 @@
     var headersAsDictionary: [String: String] {
         var result: [String: String] = [:]
         headers.forEach {
-            result[$0.name] = $0.value
+            if result[$0.name] == nil {
+                result[$0.name] = $0.value
+            }
+            else {
+                result[$0.name]! += (", " + $0.value)
+            }
         }
         return result
     }
@@ -287,8 +292,13 @@
         var value: String?
         let line = headView[headView.index(after: nameRange.upperBound)..<headView.endIndex]
         if !line.isEmpty {
-            guard let v = line.trimSPHTPrefix else { return nil }
-            value = String(v)
+            if line.hasSPHTPrefix && line.count == 1 {
+                // to handle empty headers i.e header without value
+                value = String("")
+            } else {
+                guard let v = line.trimSPHTPrefix else { return nil }
+                value = String(v)
+            }
         }
         do {
             var t = tail
diff --git a/Foundation/NSURLSession/NSURLSessionTask.swift b/Foundation/NSURLSession/NSURLSessionTask.swift
index f8b9569..27ad59f 100644
--- a/Foundation/NSURLSession/NSURLSessionTask.swift
+++ b/Foundation/NSURLSession/NSURLSessionTask.swift
@@ -88,7 +88,7 @@
         originalRequest = nil
         body = .none
         workQueue = DispatchQueue(label: "URLSessionTask.notused.0")
-        taskAttributesIsolation = DispatchQueue(label: "URLSessionTask.notused.1")
+        taskAttributesIsolation = DispatchQueue(label: "URLSessionTask.notused.1", attributes: DispatchQueue.Attributes.concurrent)
         let fileName = NSTemporaryDirectory() + NSUUID().uuidString + ".tmp"
         _ = FileManager.default.createFile(atPath: fileName, contents: nil)
         self.tempFileURL = URL(fileURLWithPath: fileName)
@@ -145,7 +145,7 @@
             return r
         }
         //TODO: dispatch_barrier_async
-        set { taskAttributesIsolation.async { self._currentRequest = newValue } }
+        set { taskAttributesIsolation.async(flags: .barrier) { self._currentRequest = newValue } }
     }
     fileprivate var _currentRequest: URLRequest? = nil
     /*@NSCopying*/ open fileprivate(set) var response: URLResponse? {
@@ -154,7 +154,7 @@
             taskAttributesIsolation.sync { r = self._response }
             return r
         }
-        set { taskAttributesIsolation.async { self._response = newValue } }
+        set { taskAttributesIsolation.async(flags: .barrier) { self._response = newValue } }
     }
     fileprivate var _response: URLResponse? = nil
     
@@ -170,7 +170,7 @@
             taskAttributesIsolation.sync { r = self._countOfBytesReceived }
             return r
         }
-        set { taskAttributesIsolation.async { self._countOfBytesReceived = newValue } }
+        set { taskAttributesIsolation.async(flags: .barrier) { self._countOfBytesReceived = newValue } }
     }
     fileprivate var _countOfBytesReceived: Int64 = 0
     
@@ -181,7 +181,7 @@
             taskAttributesIsolation.sync { r = self._countOfBytesSent }
             return r
         }
-        set { taskAttributesIsolation.async { self._countOfBytesSent = newValue } }
+        set { taskAttributesIsolation.async(flags: .barrier) { self._countOfBytesSent = newValue } }
     }
 
     fileprivate var _countOfBytesSent: Int64 = 0
@@ -213,7 +213,7 @@
             taskAttributesIsolation.sync { r = self._state }
             return r
         }
-        set { taskAttributesIsolation.async { self._state = newValue } }
+        set { taskAttributesIsolation.async(flags: .barrier) { self._state = newValue } }
     }
     fileprivate var _state: URLSessionTask.State = .suspended
     
@@ -298,7 +298,7 @@
             return r
         }
         set {
-            taskAttributesIsolation.async { self._priority = newValue }
+            taskAttributesIsolation.async(flags: .barrier) { self._priority = newValue }
         }
     }
     fileprivate var _priority: Float = URLSessionTaskPriorityDefault
@@ -791,7 +791,7 @@
         // to the delegate. But in case of redirects etc. we might send another
         // request.
         guard case .transferInProgress(let ts) = internalState else { fatalError("Transfer completed, but it wasn't in progress.") }
-        guard let request = currentRequest else { fatalError("Transfer completed, but there's no currect request.") }
+        guard let request = currentRequest else { fatalError("Transfer completed, but there's no current request.") }
         guard errorCode == nil else {
             internalState = .transferFailed
             failWith(errorCode: errorCode!, request: request)
diff --git a/Foundation/Notification.swift b/Foundation/Notification.swift
index 2ed74d0..d929dbe 100644
--- a/Foundation/Notification.swift
+++ b/Foundation/Notification.swift
@@ -76,7 +76,17 @@
 
 extension Notification : CustomReflectable {
     public var customMirror: Mirror {
-        NSUnimplemented()
+        var children: [(label: String?, value: Any)] = [(label: "name", self.name.rawValue)]
+
+        if let object = self.object {
+            children.append((label: "object", object))
+        }
+
+        if let info = self.userInfo {
+            children.append((label: "userInfo", info))
+        }
+
+        return Mirror(self, children: children, displayStyle: .class)
     }
 }
 
diff --git a/TestFoundation/TestNSCharacterSet.swift b/TestFoundation/TestNSCharacterSet.swift
index 71ff177..7bd9d62 100644
--- a/TestFoundation/TestNSCharacterSet.swift
+++ b/TestFoundation/TestNSCharacterSet.swift
@@ -28,7 +28,7 @@
             ("testRanges", testRanges),
             ("testInsertAndRemove", testInsertAndRemove),
             ("testBasics", testBasics),
-            
+            ("testClosedRanges_SR_2988", testClosedRanges_SR_2988),
             ("test_Predefines", test_Predefines),
             ("test_Range", test_Range),
             ("test_String", test_String),
@@ -223,6 +223,18 @@
         }
     }
     
+    func testClosedRanges_SR_2988() {
+        // "CharacterSet.insert(charactersIn: ClosedRange) crashes on a closed ClosedRange<UnicodeScalar> containing U+D7FF"
+        let problematicChar = UnicodeScalar(0xD7FF)!
+        let range = capitalA...problematicChar
+        var characters = CharacterSet(charactersIn: range) // this should not crash
+        XCTAssertTrue(characters.contains(problematicChar))
+        characters.remove(charactersIn: range) // this should not crash
+        XCTAssertTrue(!characters.contains(problematicChar))
+        characters.insert(charactersIn: range) // this should not crash
+        XCTAssertTrue(characters.contains(problematicChar))
+    }
+    
     func test_Bitmap() {
         
     }
diff --git a/TestFoundation/TestNSData.swift b/TestFoundation/TestNSData.swift
index 9705c15..44daab7 100644
--- a/TestFoundation/TestNSData.swift
+++ b/TestFoundation/TestNSData.swift
@@ -89,6 +89,7 @@
             ("test_replaceBytes", test_replaceBytes),
             ("test_initDataWithCapacity", test_initDataWithCapacity),
             ("test_initDataWithCount", test_initDataWithCount),
+            ("test_emptyStringToData", test_emptyStringToData),
         ]
     }
     
@@ -438,6 +439,11 @@
             return
         }
     }
+
+    func test_emptyStringToData() {
+        let data = "".data(using: .utf8)!
+        XCTAssertEqual(0, data.count, "data from empty string is empty")
+    }
 }
 
 // Tests from Swift SDK Overlay
diff --git a/TestFoundation/TestNSDecimal.swift b/TestFoundation/TestNSDecimal.swift
index 72f33f4..ffddd40 100644
--- a/TestFoundation/TestNSDecimal.swift
+++ b/TestFoundation/TestNSDecimal.swift
@@ -19,18 +19,92 @@
 
     static var allTests : [(String, (TestNSDecimal) -> () throws -> Void)] {
         return [
+            ("test_AdditionWithNormalization", test_AdditionWithNormalization),
             ("test_BasicConstruction", test_BasicConstruction),
             ("test_Constants", test_Constants),
             ("test_Description", test_Description),
             ("test_ExplicitConstruction", test_ExplicitConstruction),
             ("test_Maths", test_Maths),
             ("test_Misc", test_Misc),
+            ("test_MultiplicationOverflow", test_MultiplicationOverflow),
+            ("test_NaNInput", test_NaNInput),
+            ("test_NegativeAndZeroMultiplication", test_NegativeAndZeroMultiplication),
             ("test_Normalise", test_Normalise),
-            ("test_Round", test_Round),
             ("test_NSDecimal", test_NSDecimal),
+            ("test_PositivePowers", test_PositivePowers),
+            ("test_RepeatingDivision", test_RepeatingDivision),
+            ("test_Round", test_Round),
+            ("test_SimpleMultiplication", test_SimpleMultiplication),
+            ("test_SmallerNumbers", test_SmallerNumbers),
+            ("test_ZeroPower", test_ZeroPower),
         ]
     }
 
+    func test_AdditionWithNormalization() {
+
+        let biggie = Decimal(65536)
+        let smallee = Decimal(65536)
+        let answer = biggie/smallee
+        XCTAssertEqual(Decimal(1),answer)
+
+        var one = Decimal(1)
+        var addend = Decimal(1)
+        var expected = Decimal()
+        var result = Decimal()
+
+        expected._isNegative = 0;
+        expected._isCompact = 0;
+
+        // 2 digits -- certain to work
+        addend._exponent = -1;
+        XCTAssertEqual(.noError, NSDecimalAdd(&result, &one, &addend, .plain), "1 + 0.1")
+        expected._exponent = -1;
+        expected._length = 1;
+        expected._mantissa.0 = 11;
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&expected, &result), "1.1 == 1 + 0.1")
+
+        // 38 digits -- guaranteed by NSDecimal to work
+        addend._exponent = -37;
+        XCTAssertEqual(.noError, NSDecimalAdd(&result, &one, &addend, .plain), "1 + 1e-37")
+        expected._exponent = -37;
+        expected._length = 8;
+        expected._mantissa.0 = 0x0001;
+        expected._mantissa.1 = 0x0000;
+        expected._mantissa.2 = 0x36a0;
+        expected._mantissa.3 = 0x00f4;
+        expected._mantissa.4 = 0x46d9;
+        expected._mantissa.5 = 0xd5da;
+        expected._mantissa.6 = 0xee10;
+        expected._mantissa.7 = 0x0785;
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&expected, &result), "1 + 1e-37")
+
+        // 39 digits -- not guaranteed to work but it happens to, so we make the test work either way
+        addend._exponent = -38;
+        let error = NSDecimalAdd(&result, &one, &addend, .plain)
+        XCTAssertTrue(error == .noError || error == .lossOfPrecision, "1 + 1e-38")
+        if error == .noError {
+            expected._exponent = -38;
+            expected._length = 8;
+            expected._mantissa.0 = 0x0001;
+            expected._mantissa.1 = 0x0000;
+            expected._mantissa.2 = 0x2240;
+            expected._mantissa.3 = 0x098a;
+            expected._mantissa.4 = 0xc47a;
+            expected._mantissa.5 = 0x5a86;
+            expected._mantissa.6 = 0x4ca8;
+            expected._mantissa.7 = 0x4b3b;
+            XCTAssertEqual(.orderedSame, NSDecimalCompare(&expected, &result), "1 + 1e-38")
+        } else {
+            XCTAssertEqual(.orderedSame, NSDecimalCompare(&one, &result), "1 + 1e-38")
+        }
+
+        // 40 digits -- doesn't work; need to make sure it's rounding for us
+        addend._exponent = -39;
+        XCTAssertEqual(.lossOfPrecision, NSDecimalAdd(&result, &one, &addend, .plain), "1 + 1e-39")
+        XCTAssertEqual("1", result.description)
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&one, &result), "1 + 1e-39")
+    }
+
     func test_BasicConstruction() {
         let zero = Decimal()
         XCTAssertEqual(20, MemoryLayout<Decimal>.size)
@@ -39,7 +113,7 @@
         XCTAssertEqual(0, zero._isNegative)
         XCTAssertEqual(0, zero._isCompact)
         XCTAssertEqual(0, zero._reserved)
-        let (m0,m1,m2,m3,m4,m5,m6,m7) = zero._mantissa
+        let (m0, m1, m2, m3, m4, m5, m6, m7) = zero._mantissa
         XCTAssertEqual(0, m0)
         XCTAssertEqual(0, m1)
         XCTAssertEqual(0, m2)
@@ -59,47 +133,47 @@
         XCTAssertFalse(zero.isSignaling)
     }
     func test_Constants() {
-        XCTAssertEqual(8,NSDecimalMaxSize)
-        XCTAssertEqual(32767,NSDecimalNoScale)
+        XCTAssertEqual(8, NSDecimalMaxSize)
+        XCTAssertEqual(32767, NSDecimalNoScale)
         let smallest = Decimal(_exponent: 127, _length: 8, _isNegative: 1, _isCompact: 1, _reserved: 0, _mantissa: (UInt16.max, UInt16.max, UInt16.max, UInt16.max, UInt16.max, UInt16.max, UInt16.max, UInt16.max))
         XCTAssertEqual(smallest, Decimal.leastFiniteMagnitude)
         let biggest = Decimal(_exponent: 127, _length: 8, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (UInt16.max, UInt16.max, UInt16.max, UInt16.max, UInt16.max, UInt16.max, UInt16.max, UInt16.max))
         XCTAssertEqual(biggest, Decimal.greatestFiniteMagnitude)
-        let leastNormal = Decimal(_exponent: -127, _length: 1, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (1,0,0,0,0,0,0,0))
+        let leastNormal = Decimal(_exponent: -127, _length: 1, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (1, 0, 0, 0, 0, 0, 0, 0))
         XCTAssertEqual(leastNormal, Decimal.leastNormalMagnitude)
-        let leastNonzero = Decimal(_exponent: -127, _length: 1, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (1,0,0,0,0,0,0,0))
+        let leastNonzero = Decimal(_exponent: -127, _length: 1, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (1, 0, 0, 0, 0, 0, 0, 0))
         XCTAssertEqual(leastNonzero, Decimal.leastNonzeroMagnitude)
         let pi = Decimal(_exponent: -38, _length: 8, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (0x6623, 0x7d57, 0x16e7, 0xad0d, 0xaf52, 0x4641, 0xdfa7, 0xec58))
-        XCTAssertEqual(pi,Decimal.pi)
-        XCTAssertEqual(10,Decimal.radix)
+        XCTAssertEqual(pi, Decimal.pi)
+        XCTAssertEqual(10, Decimal.radix)
         XCTAssertTrue(Decimal().isCanonical)
         XCTAssertFalse(Decimal().isSignalingNaN)
         XCTAssertFalse(Decimal.nan.isSignalingNaN)
         XCTAssertTrue(Decimal.nan.isNaN)
-        XCTAssertEqual(.quietNaN,Decimal.nan.floatingPointClass)
-        XCTAssertEqual(.positiveZero,Decimal().floatingPointClass)
-        XCTAssertEqual(.negativeNormal,smallest.floatingPointClass)
-        XCTAssertEqual(.positiveNormal,biggest.floatingPointClass)
+        XCTAssertEqual(.quietNaN, Decimal.nan.floatingPointClass)
+        XCTAssertEqual(.positiveZero, Decimal().floatingPointClass)
+        XCTAssertEqual(.negativeNormal, smallest.floatingPointClass)
+        XCTAssertEqual(.positiveNormal, biggest.floatingPointClass)
         XCTAssertFalse(Double.nan.isFinite)
         XCTAssertFalse(Double.nan.isInfinite)
     }
 
     func test_Description() {
-        XCTAssertEqual("0",Decimal().description)
-        XCTAssertEqual("0",Decimal(0).description)
-        XCTAssertEqual("10",Decimal(_exponent: 1, _length: 1, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (1,0,0,0,0,0,0,0)).description)
-        XCTAssertEqual("10",Decimal(10).description)
-        XCTAssertEqual("123.458",Decimal(_exponent: -3, _length: 2, _isNegative: 0, _isCompact:1, _reserved: 0, _mantissa: (57922,1,0,0,0,0,0,0)).description)
-        XCTAssertEqual("123.458",Decimal(123.458).description)
-        XCTAssertEqual("123",Decimal(UInt8(123)).description)
-        XCTAssertEqual("45",Decimal(Int8(45)).description)
-        XCTAssertEqual("3.14159265358979323846264338327950288419",Decimal.pi.description)
-        XCTAssertEqual("-30000000000",Decimal(sign: .minus, exponent: 10, significand: Decimal(3)).description)
-        XCTAssertEqual("300000",Decimal(sign: .plus, exponent: 5, significand: Decimal(3)).description)
-        XCTAssertEqual("5",Decimal(signOf: Decimal(3), magnitudeOf: Decimal(5)).description)
-        XCTAssertEqual("-5",Decimal(signOf: Decimal(-3), magnitudeOf: Decimal(5)).description)
-        XCTAssertEqual("5",Decimal(signOf: Decimal(3), magnitudeOf: Decimal(-5)).description)
-        XCTAssertEqual("-5",Decimal(signOf: Decimal(-3), magnitudeOf: Decimal(-5)).description)
+        XCTAssertEqual("0", Decimal().description)
+        XCTAssertEqual("0", Decimal(0).description)
+        XCTAssertEqual("10", Decimal(_exponent: 1, _length: 1, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (1, 0, 0, 0, 0, 0, 0, 0)).description)
+        XCTAssertEqual("10", Decimal(10).description)
+        XCTAssertEqual("123.458", Decimal(_exponent: -3, _length: 2, _isNegative: 0, _isCompact:1, _reserved: 0, _mantissa: (57922, 1, 0, 0, 0, 0, 0, 0)).description)
+        XCTAssertEqual("123.458", Decimal(123.458).description)
+        XCTAssertEqual("123", Decimal(UInt8(123)).description)
+        XCTAssertEqual("45", Decimal(Int8(45)).description)
+        XCTAssertEqual("3.14159265358979323846264338327950288419", Decimal.pi.description)
+        XCTAssertEqual("-30000000000", Decimal(sign: .minus, exponent: 10, significand: Decimal(3)).description)
+        XCTAssertEqual("300000", Decimal(sign: .plus, exponent: 5, significand: Decimal(3)).description)
+        XCTAssertEqual("5", Decimal(signOf: Decimal(3), magnitudeOf: Decimal(5)).description)
+        XCTAssertEqual("-5", Decimal(signOf: Decimal(-3), magnitudeOf: Decimal(5)).description)
+        XCTAssertEqual("5", Decimal(signOf: Decimal(3), magnitudeOf: Decimal(-5)).description)
+        XCTAssertEqual("-5", Decimal(signOf: Decimal(-3), magnitudeOf: Decimal(-5)).description)
     }
 
     func test_ExplicitConstruction() {
@@ -109,7 +183,7 @@
             _isNegative: 3,
             _isCompact: 4,
             _reserved: UInt32(1<<18 + 1<<17 + 1),
-            _mantissa: (6,7,8,9,10,11,12,13)
+            _mantissa: (6, 7, 8, 9, 10, 11, 12, 13)
         )
         XCTAssertEqual(0x7f, explicit._exponent)
         XCTAssertEqual(0x7f, explicit.exponent)
@@ -119,7 +193,7 @@
         XCTAssertTrue(explicit.isSignMinus)
         XCTAssertEqual(0, explicit._isCompact)
         XCTAssertEqual(UInt32(1<<17 + 1), explicit._reserved)
-        let (m0,m1,m2,m3,m4,m5,m6,m7) = explicit._mantissa
+        let (m0, m1, m2, m3, m4, m5, m6, m7) = explicit._mantissa
         XCTAssertEqual(6, m0)
         XCTAssertEqual(7, m1)
         XCTAssertEqual(8, m2)
@@ -143,7 +217,7 @@
         XCTAssertEqual(0, significand._isNegative)
         XCTAssertEqual(1, significand._isCompact)
         XCTAssertEqual(0, significand._reserved)
-        let (sm0,sm1,sm2,sm3,sm4,sm5,sm6,sm7) = significand._mantissa
+        let (sm0, sm1, sm2, sm3, sm4, sm5, sm6, sm7) = significand._mantissa
         XCTAssertEqual(6, sm0)
         XCTAssertEqual(7, sm1)
         XCTAssertEqual(8, sm2)
@@ -204,14 +278,14 @@
     }
 
     func test_Misc() {
-        XCTAssertEqual(.minus,Decimal(-5.2).sign)
-        XCTAssertEqual(.plus,Decimal(5.2).sign)
+        XCTAssertEqual(.minus, Decimal(-5.2).sign)
+        XCTAssertEqual(.plus, Decimal(5.2).sign)
         var d = Decimal(5.2)
-        XCTAssertEqual(.plus,d.sign)
+        XCTAssertEqual(.plus, d.sign)
         d.negate()
-        XCTAssertEqual(.minus,d.sign)
+        XCTAssertEqual(.minus, d.sign)
         d.negate()
-        XCTAssertEqual(.plus,d.sign)
+        XCTAssertEqual(.plus, d.sign)
         XCTAssertTrue(Decimal(3.5).isEqual(to: Decimal(3.5)))
         XCTAssertTrue(Decimal.nan.isEqual(to: Decimal.nan))
         XCTAssertTrue(Decimal(1.28).isLess(than: Decimal(2.24)))
@@ -228,46 +302,226 @@
         XCTAssertFalse(Decimal.nan.isTotallyOrdered(belowOrEqualTo: Decimal(2.3)))
         XCTAssertTrue(Decimal(2) < Decimal(3))
         XCTAssertTrue(Decimal(3) > Decimal(2))
-        XCTAssertEqual(3275573729074,Decimal(1234).hashValue)
+        XCTAssertEqual(3275573729074, Decimal(1234).hashValue)
         XCTAssertEqual(Decimal(-9), Decimal(1) - Decimal(10))
-        XCTAssertEqual(Decimal(3),Decimal(2).nextUp)
-        XCTAssertEqual(Decimal(2),Decimal(3).nextDown)
-        XCTAssertEqual(Decimal(-476),Decimal(1024).distance(to: Decimal(1500)))
-        XCTAssertEqual(Decimal(68040),Decimal(386).advanced(by: Decimal(67654)))
-        XCTAssertEqual(Decimal(1.234),abs(Decimal(1.234)))
-        XCTAssertEqual(Decimal(1.234),abs(Decimal(-1.234)))
+        XCTAssertEqual(Decimal(3), Decimal(2).nextUp)
+        XCTAssertEqual(Decimal(2), Decimal(3).nextDown)
+        XCTAssertEqual(Decimal(-476), Decimal(1024).distance(to: Decimal(1500)))
+        XCTAssertEqual(Decimal(68040), Decimal(386).advanced(by: Decimal(67654)))
+        XCTAssertEqual(Decimal(1.234), abs(Decimal(1.234)))
+        XCTAssertEqual(Decimal(1.234), abs(Decimal(-1.234)))
         var a = Decimal(1234)
-        XCTAssertEqual(.noError,NSDecimalMultiplyByPowerOf10(&a,&a,1,.plain))
-        XCTAssertEqual(Decimal(12340),a)
+        XCTAssertEqual(.noError, NSDecimalMultiplyByPowerOf10(&a, &a, 1, .plain))
+        XCTAssertEqual(Decimal(12340), a)
         a = Decimal(1234)
-        XCTAssertEqual(.noError,NSDecimalMultiplyByPowerOf10(&a,&a,2,.plain))
-        XCTAssertEqual(Decimal(123400),a)
-        XCTAssertEqual(.overflow,NSDecimalMultiplyByPowerOf10(&a,&a,128,.plain))
+        XCTAssertEqual(.noError, NSDecimalMultiplyByPowerOf10(&a, &a, 2, .plain))
+        XCTAssertEqual(Decimal(123400), a)
+        XCTAssertEqual(.overflow, NSDecimalMultiplyByPowerOf10(&a, &a, 128, .plain))
         XCTAssertTrue(a.isNaN)
         a = Decimal(1234)
-        XCTAssertEqual(.noError,NSDecimalMultiplyByPowerOf10(&a,&a,-2,.plain))
-        XCTAssertEqual(Decimal(12.34),a)
-        XCTAssertEqual(.underflow,NSDecimalMultiplyByPowerOf10(&a,&a,-128,.plain))
+        XCTAssertEqual(.noError, NSDecimalMultiplyByPowerOf10(&a, &a, -2, .plain))
+        XCTAssertEqual(Decimal(12.34), a)
+        XCTAssertEqual(.underflow, NSDecimalMultiplyByPowerOf10(&a, &a, -128, .plain))
         XCTAssertTrue(a.isNaN)
         a = Decimal(1234)
-        XCTAssertEqual(.noError,NSDecimalPower(&a,&a,0,.plain))
-        XCTAssertEqual(Decimal(1),a)
+        XCTAssertEqual(.noError, NSDecimalPower(&a, &a, 0, .plain))
+        XCTAssertEqual(Decimal(1), a)
         a = Decimal(8)
-        XCTAssertEqual(.noError,NSDecimalPower(&a,&a,2,.plain))
-        XCTAssertEqual(Decimal(64),a)
+        XCTAssertEqual(.noError, NSDecimalPower(&a, &a, 2, .plain))
+        XCTAssertEqual(Decimal(64), a)
         a = Decimal(-2)
-        XCTAssertEqual(.noError,NSDecimalPower(&a,&a,3,.plain))
-        XCTAssertEqual(Decimal(-8),a)
+        XCTAssertEqual(.noError, NSDecimalPower(&a, &a, 3, .plain))
+        XCTAssertEqual(Decimal(-8), a)
         for i in -2...10 {
             for j in 0...5 {
                 var actual = Decimal(i)
-                XCTAssertEqual(.noError,NSDecimalPower(&actual,&actual,j,.plain))
-                let expected = Decimal(pow(Double(i),Double(j)))
+                XCTAssertEqual(.noError, NSDecimalPower(&actual, &actual, j, .plain))
+                let expected = Decimal(pow(Double(i), Double(j)))
                 XCTAssertEqual(expected, actual, "\(actual) == \(i)^\(j)")
             }
         }
     }
 
+    func test_MultiplicationOverflow() {
+        var multiplicand = Decimal(_exponent: 0, _length: 8, _isNegative: 0, _isCompact: 0, _reserved: 0, _mantissa: ( 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff ))
+
+        var result = Decimal()
+        var multiplier = Decimal(1)
+
+        multiplier._mantissa.0 = 2
+
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &multiplicand, &multiplier, .plain), "2 * max mantissa")
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &multiplier, &multiplicand, .plain), "max mantissa * 2")
+
+        multiplier._exponent = 0x7f
+        XCTAssertEqual(.overflow, NSDecimalMultiply(&result, &multiplicand, &multiplier, .plain), "2e127 * max mantissa")
+        XCTAssertEqual(.overflow, NSDecimalMultiply(&result, &multiplier, &multiplicand, .plain), "max mantissa * 2e127")
+    }
+
+    func test_NaNInput() {
+        var NaN = Decimal.nan
+        var one = Decimal(1)
+        var result = Decimal()
+
+        XCTAssertNotEqual(.noError, NSDecimalAdd(&result, &NaN, &one, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN + 1")
+        XCTAssertNotEqual(.noError, NSDecimalAdd(&result, &one, &NaN, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "1 + NaN")
+
+        XCTAssertNotEqual(.noError, NSDecimalSubtract(&result, &NaN, &one, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN - 1")
+        XCTAssertNotEqual(.noError, NSDecimalSubtract(&result, &one, &NaN, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "1 - NaN")
+
+        XCTAssertNotEqual(.noError, NSDecimalMultiply(&result, &NaN, &one, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN * 1")
+        XCTAssertNotEqual(.noError, NSDecimalMultiply(&result, &one, &NaN, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "1 * NaN")
+
+        XCTAssertNotEqual(.noError, NSDecimalDivide(&result, &NaN, &one, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN / 1")
+        XCTAssertNotEqual(.noError, NSDecimalDivide(&result, &one, &NaN, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "1 / NaN")
+
+        XCTAssertNotEqual(.noError, NSDecimalPower(&result, &NaN, 0, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN ^ 0")
+        XCTAssertNotEqual(.noError, NSDecimalPower(&result, &NaN, 4, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN ^ 4")
+        XCTAssertNotEqual(.noError, NSDecimalPower(&result, &NaN, 5, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN ^ 5")
+
+        XCTAssertNotEqual(.noError, NSDecimalMultiplyByPowerOf10(&result, &NaN, 0, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN e0")
+        XCTAssertNotEqual(.noError, NSDecimalMultiplyByPowerOf10(&result, &NaN, 4, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN e4")
+        XCTAssertNotEqual(.noError, NSDecimalMultiplyByPowerOf10(&result, &NaN, 5, .plain))
+        XCTAssertTrue(NSDecimalIsNotANumber(&result), "NaN e5")
+    }
+
+    func test_NegativeAndZeroMultiplication() {
+        var one = Decimal(1)
+        var zero = Decimal(0)
+        var negativeOne = Decimal(-1)
+
+        var result = Decimal()
+
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &one, &one, .plain), "1 * 1")
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&one, &result), "1 * 1")
+
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &one, &negativeOne, .plain), "1 * -1")
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&negativeOne, &result), "1 * -1")
+
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &negativeOne, &one, .plain), "-1 * 1")
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&negativeOne, &result), "-1 * 1")
+
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &negativeOne, &negativeOne, .plain), "-1 * -1")
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&one, &result), "-1 * -1")
+
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &one, &zero, .plain), "1 * 0")
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&zero, &result), "1 * 0")
+        XCTAssertEqual(0, result._isNegative, "1 * 0")
+
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &zero, &one, .plain), "0 * 1")
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&zero, &result), "0 * 1")
+        XCTAssertEqual(0, result._isNegative, "0 * 1")
+
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &negativeOne, &zero, .plain), "-1 * 0")
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&zero, &result), "-1 * 0")
+        XCTAssertEqual(0, result._isNegative, "-1 * 0")
+
+        XCTAssertEqual(.noError, NSDecimalMultiply(&result, &zero, &negativeOne, .plain), "0 * -1")
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&zero, &result), "0 * -1")
+        XCTAssertEqual(0, result._isNegative, "0 * -1")
+    }
+
+    func test_Normalise() {
+        var one = Decimal(1)
+        var ten = Decimal(-10)
+        XCTAssertEqual(.noError, NSDecimalNormalize(&one, &ten, .plain))
+        XCTAssertEqual(Decimal(1), one)
+        XCTAssertEqual(Decimal(-10), ten)
+        XCTAssertEqual(1, one._length)
+        XCTAssertEqual(1, ten._length)
+        one = Decimal(1)
+        ten = Decimal(10)
+        XCTAssertEqual(.noError, NSDecimalNormalize(&one, &ten, .plain))
+        XCTAssertEqual(Decimal(1), one)
+        XCTAssertEqual(Decimal(10), ten)
+        XCTAssertEqual(1, one._length)
+        XCTAssertEqual(1, ten._length)
+    }
+
+    func test_NSDecimal() {
+        var nan = Decimal.nan
+        XCTAssertTrue(NSDecimalIsNotANumber(&nan))
+        var zero = Decimal()
+        XCTAssertFalse(NSDecimalIsNotANumber(&zero))
+        var three = Decimal(3)
+        var guess = Decimal()
+        NSDecimalCopy(&guess, &three)
+        XCTAssertEqual(three, guess)
+
+        var f = Decimal(_exponent: 0, _length: 2, _isNegative: 0, _isCompact: 0, _reserved: 0, _mantissa: (0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000))
+        let before = f.description
+        XCTAssertEqual(0, f._isCompact)
+        NSDecimalCompact(&f)
+        XCTAssertEqual(1, f._isCompact)
+        let after = f.description
+        XCTAssertEqual(before, after)
+    }
+
+    func test_PositivePowers() {
+        let six = NSDecimalNumber(integerLiteral: 6)
+
+        XCTAssertEqual(6, six.raising(toPower:1).intValue)
+        XCTAssertEqual(36, six.raising(toPower:2).intValue)
+        XCTAssertEqual(216, six.raising(toPower:3).intValue)
+        XCTAssertEqual(1296, six.raising(toPower:4).intValue)
+        XCTAssertEqual(7776, six.raising(toPower:5).intValue)
+        XCTAssertEqual(46656, six.raising(toPower:6).intValue)
+        XCTAssertEqual(279936, six.raising(toPower:7).intValue)
+        XCTAssertEqual(1679616, six.raising(toPower:8).intValue)
+        XCTAssertEqual(10077696, six.raising(toPower:9).intValue)
+
+        let negativeSix = NSDecimalNumber(integerLiteral: -6)
+
+        XCTAssertEqual(-6, negativeSix.raising(toPower:1).intValue)
+        XCTAssertEqual(36, negativeSix.raising(toPower:2).intValue)
+        XCTAssertEqual(-216, negativeSix.raising(toPower:3).intValue)
+        XCTAssertEqual(1296, negativeSix.raising(toPower:4).intValue)
+        XCTAssertEqual(-7776, negativeSix.raising(toPower:5).intValue)
+        XCTAssertEqual(46656, negativeSix.raising(toPower:6).intValue)
+        XCTAssertEqual(-279936, negativeSix.raising(toPower:7).intValue)
+        XCTAssertEqual(1679616, negativeSix.raising(toPower:8).intValue)
+        XCTAssertEqual(-10077696, negativeSix.raising(toPower:9).intValue)
+    }
+
+    func test_RepeatingDivision()  {
+        let repeatingNumerator = Decimal(16)
+        let repeatingDenominator = Decimal(9)
+        let repeating = repeatingNumerator / repeatingDenominator
+
+        let numerator = Decimal(1010)
+        var result = numerator / repeating
+
+        var expected = Decimal()
+        expected._exponent = -35;
+        expected._length = 8;
+        expected._isNegative = 0;
+        expected._isCompact = 1;
+        expected._reserved = 0;
+        expected._mantissa.0 = 51946;
+        expected._mantissa.1 = 3;
+        expected._mantissa.2 = 15549;
+        expected._mantissa.3 = 55864;
+        expected._mantissa.4 = 57984;
+        expected._mantissa.5 = 55436;
+        expected._mantissa.6 = 45186;
+        expected._mantissa.7 = 10941;
+
+        XCTAssertEqual(.orderedSame, NSDecimalCompare(&expected, &result), "568.12500000000000000000000000000248554: \(expected.description) != \(result.description)");
+    }
+
     func test_Round() {
         let testCases = [
             // expected, start, scale, round
@@ -290,48 +544,65 @@
             ( -5.5, -5.5, 1, Decimal.RoundingMode.up ),
             ( -6.5, -6.5, 1, Decimal.RoundingMode.plain ),
             ( -7.5, -7.5, 1, Decimal.RoundingMode.bankers ),
-        ]
+            ]
         for testCase in testCases {
             let (expected, start, scale, mode) = testCase
             var num = Decimal(start)
-            NSDecimalRound(&num,&num,scale,mode)
+            NSDecimalRound(&num, &num, scale, mode)
             XCTAssertEqual(Decimal(expected), num)
         }
     }
 
-    func test_Normalise() {
-        var one = Decimal(1)
-        var ten = Decimal(-10)
-        XCTAssertEqual(.noError,NSDecimalNormalize(&one,&ten,.plain))
-        XCTAssertEqual(Decimal(1),one)
-        XCTAssertEqual(Decimal(-10),ten)
-        XCTAssertEqual(1,one._length)
-        XCTAssertEqual(1,ten._length)
-        one = Decimal(1)
-        ten = Decimal(10)
-        XCTAssertEqual(.noError,NSDecimalNormalize(&one,&ten,.plain))
-        XCTAssertEqual(Decimal(1),one)
-        XCTAssertEqual(Decimal(10),ten)
-        XCTAssertEqual(1,one._length)
-        XCTAssertEqual(1,ten._length)
+    func test_SimpleMultiplication() {
+        var multiplicand = Decimal()
+        multiplicand._isNegative = 0
+        multiplicand._isCompact = 0
+        multiplicand._length = 1
+        multiplicand._exponent = 1
+
+        var multiplier = multiplicand
+        multiplier._exponent = 2
+
+        var expected = multiplicand
+        expected._isNegative = 0
+        expected._isCompact = 0
+        expected._exponent = 3
+        expected._length = 1
+
+        var result = Decimal()
+
+        for i in 1..<UInt8.max {
+            multiplicand._mantissa.0 = UInt16(i)
+
+            for j in 1..<UInt8.max {
+                multiplier._mantissa.0 = UInt16(j)
+                expected._mantissa.0 = UInt16(i) * UInt16(j)
+
+                XCTAssertEqual(.noError, NSDecimalMultiply(&result, &multiplicand, &multiplier, .plain), "\(i) * \(j)")
+                XCTAssertEqual(.orderedSame, NSDecimalCompare(&expected, &result), "\(expected._mantissa.0) == \(i) * \(j)");
+            }
+        }
     }
 
-    func test_NSDecimal() {
-        var nan = Decimal.nan
-        XCTAssertTrue(NSDecimalIsNotANumber(&nan))
-        var zero = Decimal()
-        XCTAssertFalse(NSDecimalIsNotANumber(&zero))
-        var three = Decimal(3)
-        var guess = Decimal()
-        NSDecimalCopy(&guess,&three)
-        XCTAssertEqual(three,guess)
+    func test_SmallerNumbers() {
+        var number = NSDecimalNumber(booleanLiteral:true)
+        XCTAssertTrue(number.boolValue, "Should have received true")
 
-        var f = Decimal(_exponent: 0, _length: 2, _isNegative: 0, _isCompact: 0, _reserved: 0, _mantissa: (0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000))
-        let before = f.description
-        XCTAssertEqual(0,f._isCompact)
-        NSDecimalCompact(&f)
-        XCTAssertEqual(1,f._isCompact)
-        let after = f.description
-        XCTAssertEqual(before,after)
+        number = NSDecimalNumber(mantissa:0, exponent:0, isNegative:false)
+        XCTAssertFalse(number.boolValue, "Should have received false")
+
+        number = NSDecimalNumber(mantissa:1, exponent:0, isNegative:false)
+        XCTAssertTrue(number.boolValue, "Should have received true")
+
+        XCTAssertEqual(100,number.objCType.pointee, "ObjC type for NSDecimalNumber is 'd'")
     }
+
+    func test_ZeroPower() {
+        let six = NSDecimalNumber(integerLiteral: 6)
+        XCTAssertEqual(1, six.raising(toPower: 0))
+
+        let negativeSix = NSDecimalNumber(integerLiteral: -6)
+        XCTAssertEqual(1, negativeSix.raising(toPower: 0))
+    }
+
 }
diff --git a/TestFoundation/TestNSKeyedArchiver.swift b/TestFoundation/TestNSKeyedArchiver.swift
index 19ba3d0..6e6b529 100644
--- a/TestFoundation/TestNSKeyedArchiver.swift
+++ b/TestFoundation/TestNSKeyedArchiver.swift
@@ -16,7 +16,7 @@
     import SwiftXCTest
 #endif
 
-public class UserClass : NSObject, NSSecureCoding {
+public class NSUserClass : NSObject, NSSecureCoding {
     var ivar : Int
     
     public class var supportsSecureCoding: Bool {
@@ -37,12 +37,12 @@
     
     public override var description: String {
         get {
-            return "UserClass \(ivar)"
+            return "NSUserClass \(ivar)"
         }
     }
     
     public override func isEqual(_ object: Any?) -> Bool {
-        if let custom = object as? UserClass {
+        if let custom = object as? NSUserClass {
             return self.ivar == custom.ivar
         } else {
             return false
@@ -50,6 +50,40 @@
     }
 }
 
+public class UserClass : CustomStringConvertible, Equatable, Hashable, NSSecureCoding {
+    var ivar : Int
+    
+    public class var supportsSecureCoding: Bool {
+        return true
+    }
+    
+    public func encode(with aCoder : NSCoder) {
+        aCoder.encode(ivar, forKey:"$ivar") // also test escaping
+    }
+    
+    init(_ value: Int) {
+        self.ivar = value
+    }
+    
+    public required init?(coder aDecoder: NSCoder) {
+        self.ivar = aDecoder.decodeInteger(forKey: "$ivar")
+    }
+    
+    public var description: String {
+        get {
+            return "UserClass \(ivar)"
+        }
+    }
+    
+    public static func ==(lhs: UserClass, rhs: UserClass) -> Bool {
+        return lhs.ivar == rhs.ivar
+    }
+    
+    public var hashValue: Int {
+        return ivar
+    }
+}
+
 class TestNSKeyedArchiver : XCTestCase {
     static var allTests: [(String, (TestNSKeyedArchiver) -> () throws -> Void)] {
         return [
@@ -62,6 +96,7 @@
             ("test_archive_string", test_archive_string),
             ("test_archive_mutable_array", test_archive_mutable_array),
             ("test_archive_mutable_dictionary", test_archive_mutable_dictionary),
+            ("test_archive_ns_user_class", test_archive_ns_user_class),
             ("test_archive_nspoint", test_archive_nspoint),
             ("test_archive_nsrange", test_archive_nsrange),
             ("test_archive_nsrect", test_archive_nsrect),
@@ -69,7 +104,8 @@
             ("test_archive_set", test_archive_set),
             ("test_archive_url", test_archive_url),
             ("test_archive_user_class", test_archive_user_class),
-            ("test_archive_uuid", test_archive_uuid),
+            ("test_archive_uuid_bvref", test_archive_uuid_byref),
+            ("test_archive_uuid_byvalue", test_archive_uuid_byvalue),
         ]
     }
 
@@ -85,7 +121,7 @@
         XCTAssertTrue(decode(unarchiver))
     }
     
-    private func test_archive(_ object: NSObject, classes: [AnyClass], allowsSecureCoding: Bool = true, outputFormat: PropertyListSerialization.PropertyListFormat) {
+    private func test_archive(_ object: Any, classes: [AnyClass], allowsSecureCoding: Bool = true, outputFormat: PropertyListSerialization.PropertyListFormat) {
         test_archive({ archiver -> Bool in
                 archiver.requiresSecureCoding = allowsSecureCoding
                 archiver.outputFormat = outputFormat
@@ -97,12 +133,12 @@
                 unarchiver.requiresSecureCoding = allowsSecureCoding
                 
                 do {
-                    let rootObj = try unarchiver.decodeTopLevelObject(of: classes, forKey: NSKeyedArchiveRootObjectKey)
-                    guard let root = rootObj as? NSObject else {
+                    guard let rootObj = try unarchiver.decodeTopLevelObject(of: classes, forKey: NSKeyedArchiveRootObjectKey) else {
                         XCTFail("Unable to decode data")
                         return false
                     }
-                    XCTAssertEqual(object, root, "unarchived object \(root) does not match \(object)")
+                
+                    XCTAssertEqual(object as? AnyHashable, rootObj as? AnyHashable, "unarchived object \(rootObj) does not match \(object)")
                 } catch {
                     XCTFail("Error thrown: \(error)")
                 }
@@ -110,13 +146,13 @@
         })
     }
     
-    private func test_archive(_ object: NSObject, classes: [AnyClass], allowsSecureCoding: Bool = true) {
+    private func test_archive(_ object: Any, classes: [AnyClass], allowsSecureCoding: Bool = true) {
         // test both XML and binary encodings
         test_archive(object, classes: classes, allowsSecureCoding: allowsSecureCoding, outputFormat: PropertyListSerialization.PropertyListFormat.xml)
         test_archive(object, classes: classes, allowsSecureCoding: allowsSecureCoding, outputFormat: PropertyListSerialization.PropertyListFormat.binary)
     }
     
-    private func test_archive(_ object: NSObject, allowsSecureCoding: Bool = true) {
+    private func test_archive(_ object: AnyObject, allowsSecureCoding: Bool = true) {
         return test_archive(object, classes: [type(of: object)], allowsSecureCoding: allowsSecureCoding)
     }
     
@@ -252,8 +288,18 @@
         test_archive(userClass)
     }
     
-    func test_archive_uuid() {
+    func test_archive_ns_user_class() {
+        let nsUserClass = NSUserClass(5678)
+        test_archive(nsUserClass)
+    }
+    
+    func test_archive_uuid_byref() {
         let uuid = NSUUID()
         test_archive(uuid)
     }
+    
+    func test_archive_uuid_byvalue() {
+        let uuid = UUID()
+        return test_archive(uuid, classes: [NSUUID.self])
+    }
 }
diff --git a/TestFoundation/TestNSRange.swift b/TestFoundation/TestNSRange.swift
index 5ce2ae4..927e989 100644
--- a/TestFoundation/TestNSRange.swift
+++ b/TestFoundation/TestNSRange.swift
@@ -23,7 +23,13 @@
         return [
             // currently disabled due to pending requirements for NSString
             // ("test_NSRangeFromString", test_NSRangeFromString ),
-            ("test_NSRangeBridging", test_NSRangeBridging)
+            ("test_NSRangeBridging", test_NSRangeBridging),
+            ("test_NSMaxRange", test_NSMaxRange),
+            ("test_NSLocationInRange", test_NSLocationInRange),
+            ("test_NSEqualRanges", test_NSEqualRanges),
+            ("test_NSUnionRange", test_NSUnionRange),
+            ("test_NSIntersectionRange", test_NSIntersectionRange),
+            ("test_NSStringFromRange", test_NSStringFromRange),
         ]
     }
     
@@ -66,4 +72,69 @@
         let swiftRange2 = range.toRange()
         XCTAssertEqual(swiftRange, swiftRange2)
     }
+
+    func test_NSMaxRange() {
+        let ranges = [(NSMakeRange(0, 3), 3),
+                      (NSMakeRange(7, 8), 15),
+                      (NSMakeRange(56, 1), 57)]
+        for (range, result) in ranges {
+            XCTAssertEqual(NSMaxRange(range), result)
+        }
+    }
+
+    func test_NSLocationInRange() {
+        let ranges = [(3, NSMakeRange(0, 5), true),
+                      (10, NSMakeRange(2, 9), true),
+                      (7, NSMakeRange(2, 5), false),
+                      (5, NSMakeRange(5, 1), true)];
+        for (location, range, result) in ranges {
+            XCTAssertEqual(NSLocationInRange(location, range), result);
+        }
+    }
+
+    func test_NSEqualRanges() {
+        let ranges = [(NSMakeRange(0, 3), NSMakeRange(0, 3), true),
+                      (NSMakeRange(0, 4), NSMakeRange(0, 8), false),
+                      (NSMakeRange(3, 6), NSMakeRange(3, 10), false),
+                      (NSMakeRange(0, 5), NSMakeRange(7, 8), false)]
+        for (first, second, result) in ranges {
+            XCTAssertEqual(NSEqualRanges(first, second), result)
+        }
+    }
+
+    
+    func test_NSUnionRange() {
+        let ranges = [(NSMakeRange(0, 5), NSMakeRange(3, 8), NSMakeRange(0, 11)),
+                      (NSMakeRange(6, 10), NSMakeRange(3, 8), NSMakeRange(3, 13)),
+                      (NSMakeRange(3, 8), NSMakeRange(6, 10), NSMakeRange(3, 13)),
+                      (NSMakeRange(0, 5), NSMakeRange(7, 8), NSMakeRange(0, 15)),
+                      (NSMakeRange(0, 3), NSMakeRange(1, 2), NSMakeRange(0, 3))]
+        for (first, second, result) in ranges {
+            XCTAssert(NSEqualRanges(NSUnionRange(first, second), result))
+        }
+    }
+
+    func test_NSIntersectionRange() {
+        let ranges = [(NSMakeRange(0, 5), NSMakeRange(3, 8), NSMakeRange(3, 2)),
+                      (NSMakeRange(6, 10), NSMakeRange(3, 8), NSMakeRange(6, 5)),
+                      (NSMakeRange(3, 8), NSMakeRange(6, 10), NSMakeRange(6, 5)),
+                      (NSMakeRange(0, 5), NSMakeRange(7, 8), NSMakeRange(0, 0)),
+                      (NSMakeRange(0, 3), NSMakeRange(1, 2), NSMakeRange(1, 2))]
+        for (first, second, result) in ranges {
+            XCTAssert(NSEqualRanges(NSIntersectionRange(first, second), result))
+        }
+    }
+
+    func test_NSStringFromRange() {
+        let ranges = ["{0, 0}": NSMakeRange(0, 0),
+                      "{6, 4}": NSMakeRange(6, 4),
+                      "{0, 10}": NSMakeRange(0, 10),
+                      "{10, 200}": NSMakeRange(10, 200),
+                      "{100, 10}": NSMakeRange(100, 10),
+                      "{1000, 100000}": NSMakeRange(1000, 100_000)];
+
+        for (string, range) in ranges {
+            XCTAssertEqual(NSStringFromRange(range), string)
+        }
+    }
 }
diff --git a/TestFoundation/TestNSString.swift b/TestFoundation/TestNSString.swift
index 1767982..ebb8fab 100644
--- a/TestFoundation/TestNSString.swift
+++ b/TestFoundation/TestNSString.swift
@@ -81,7 +81,11 @@
             ("test_resolvingSymlinksInPath", test_resolvingSymlinksInPath),
             ("test_expandingTildeInPath", test_expandingTildeInPath),
             ("test_standardizingPath", test_standardizingPath),
-            ("test_removingPercentEncoding", test_removingPercentEncoding),
+            ("test_addingPercentEncoding", test_addingPercentEncoding),
+            ("test_removingPercentEncodingInLatin", test_removingPercentEncodingInLatin),
+            ("test_removingPercentEncodingInNonLatin", test_removingPercentEncodingInNonLatin),
+            ("test_removingPersentEncodingWithoutEncoding", test_removingPersentEncodingWithoutEncoding),
+            ("test_addingPercentEncodingAndBack", test_addingPercentEncodingAndBack),
             ("test_stringByAppendingPathExtension", test_stringByAppendingPathExtension),
             ("test_deletingPathExtension", test_deletingPathExtension),
             ("test_ExternalRepresentation", test_ExternalRepresentation),
@@ -602,6 +606,9 @@
         let characterSet = CharacterSet.whitespaces
         let string: NSString = " abc   "
         XCTAssertEqual(string.trimmingCharacters(in: characterSet), "abc")
+        
+        let emojiString: NSString = " \u{1F62C}  "
+        XCTAssertEqual(emojiString.trimmingCharacters(in: characterSet), "\u{1F62C}")
     }
     
     func test_initializeWithFormat() {
@@ -864,13 +871,66 @@
         }
     }
 
-    func test_removingPercentEncoding() {
+    func test_addingPercentEncoding() {
+        let s1 = "a b".addingPercentEncoding(withAllowedCharacters: .alphanumerics)
+        XCTAssertEqual(s1, "a%20b")
+        
+        let s2 = "\u{0434}\u{043E}\u{043C}".addingPercentEncoding(withAllowedCharacters: .alphanumerics)
+        XCTAssertEqual(s2, "%D0%B4%D0%BE%D0%BC")
+    }
+    
+    func test_removingPercentEncodingInLatin() {
         let s1 = "a%20b".removingPercentEncoding
         XCTAssertEqual(s1, "a b")
         let s2 = "a%1 b".removingPercentEncoding
         XCTAssertNil(s2, "returns nil for a string with an invalid percent encoding")
     }
     
+    func test_removingPercentEncodingInNonLatin() {
+        let s1 = "\u{043C}\u{043E}\u{0439}%20\u{0434}\u{043E}\u{043C}".removingPercentEncoding
+        XCTAssertEqual(s1, "\u{043C}\u{043E}\u{0439} \u{0434}\u{043E}\u{043C}")
+        
+        let s2 = "%D0%B4%D0%BE%D0%BC".removingPercentEncoding
+        XCTAssertEqual(s2, "\u{0434}\u{043E}\u{043C}")
+        
+        let s3 = "\u{00E0}a%1 b".removingPercentEncoding
+        XCTAssertNil(s3, "returns nil for a string with an invalid percent encoding")
+    }
+    
+    func test_removingPersentEncodingWithoutEncoding() {
+        let cyrillicString = "\u{0434}\u{043E}\u{043C}"
+        let cyrillicEscapedString = cyrillicString.removingPercentEncoding
+        XCTAssertEqual(cyrillicString, cyrillicEscapedString)
+        
+        let chineseString = "\u{623F}\u{5B50}"
+        let chineseEscapedString = chineseString.removingPercentEncoding
+        XCTAssertEqual(chineseString, chineseEscapedString)
+        
+        let arabicString = "\u{0645}\u{0646}\u{0632}\u{0644}"
+        let arabicEscapedString = arabicString.removingPercentEncoding
+        XCTAssertEqual(arabicString, arabicEscapedString)
+        
+        let randomString = "\u{00E0}\u{00E6}"
+        let randomEscapedString = randomString.removingPercentEncoding
+        XCTAssertEqual(randomString, randomEscapedString)
+        
+        let latinString = "home"
+        let latinEscapedString = latinString.removingPercentEncoding
+        XCTAssertEqual(latinString, latinEscapedString)
+    }
+    
+    func test_addingPercentEncodingAndBack() {
+        let latingString = "a b"
+        let escapedLatingString = latingString.addingPercentEncoding(withAllowedCharacters: .alphanumerics)
+        let returnedLatingString = escapedLatingString?.removingPercentEncoding
+        XCTAssertEqual(returnedLatingString, latingString)
+        
+        let cyrillicString = "\u{0434}\u{043E}\u{043C}"
+        let escapedCyrillicString = cyrillicString.addingPercentEncoding(withAllowedCharacters: .alphanumerics)
+        let returnedCyrillicString = escapedCyrillicString?.removingPercentEncoding
+        XCTAssertEqual(returnedCyrillicString, cyrillicString)
+    }
+    
     func test_stringByAppendingPathExtension() {
         let values = [
             NSString(string: "/tmp/scratch.old") : "/tmp/scratch.old.tiff",
diff --git a/TestFoundation/TestNSURLCredential.swift b/TestFoundation/TestNSURLCredential.swift
index 542c857..037b114 100644
--- a/TestFoundation/TestNSURLCredential.swift
+++ b/TestFoundation/TestNSURLCredential.swift
@@ -21,7 +21,8 @@
     static var allTests: [(String, (TestNSURLCredential) -> () throws -> Void)] {
         return [
                    ("test_construction", test_construction),
-                   ("test_copy", test_copy)
+                   ("test_copy", test_copy),
+                   ("test_NSCoding", test_NSCoding)
         ]
     }
     
@@ -39,4 +40,10 @@
         let copy = credential.copy() as! URLCredential
         XCTAssertTrue(copy.isEqual(credential))
     }
+    
+    func test_NSCoding() {
+        let credentialA = URLCredential(user: "swiftUser", password: "swiftPassword", persistence: .forSession)
+        let credentialB = NSKeyedUnarchiver.unarchiveObject(with: NSKeyedArchiver.archivedData(withRootObject: credentialA)) as! URLCredential
+        XCTAssertEqual(credentialA, credentialB, "Archived then unarchived url credential must be equal.")
+    }
 }
diff --git a/TestFoundation/TestNotification.swift b/TestFoundation/TestNotification.swift
new file mode 100644
index 0000000..9c1bd38
--- /dev/null
+++ b/TestFoundation/TestNotification.swift
@@ -0,0 +1,56 @@
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+
+
+
+#if DEPLOYMENT_RUNTIME_OBJC || os(Linux)
+    import Foundation
+    import XCTest
+#else
+    import SwiftFoundation
+    import SwiftXCTest
+#endif
+
+
+
+class TestNotification : XCTestCase {
+
+    static var allTests: [(String, (TestNotification) -> () throws -> Void)] {
+        return [
+            ("test_customReflection", test_customReflection),
+        ]
+    }
+
+    func test_customReflection() {
+        let someName = "somenotifname"
+        let targetObject = NSObject()
+        let userInfo = ["hello": "world", "indexThis": 350] as [AnyHashable: Any]
+        let notif = Notification(name: Notification.Name(rawValue: someName), object: targetObject, userInfo: userInfo)
+        let mirror = notif.customMirror
+
+        XCTAssertEqual(mirror.displayStyle, .class)
+        XCTAssertNil(mirror.superclassMirror)
+
+        var children = Array(mirror.children).makeIterator()
+        let firstChild = children.next()
+        let secondChild = children.next()
+        let thirdChild = children.next()
+        XCTAssertEqual(firstChild?.label, "name")
+        XCTAssertEqual(firstChild?.value as? String, someName)
+
+        XCTAssertEqual(secondChild?.label, "object")
+        XCTAssertEqual(secondChild?.value as? NSObject, targetObject)
+
+        XCTAssertEqual(thirdChild?.label, "userInfo")
+        XCTAssertEqual((thirdChild?.value as? [AnyHashable: Any])?["hello"] as? String, "world")
+        XCTAssertEqual((thirdChild?.value as? [AnyHashable: Any])?["indexThis"] as? Int, 350)
+
+    }
+
+}
diff --git a/TestFoundation/main.swift b/TestFoundation/main.swift
index 517d740..732bf17 100644
--- a/TestFoundation/main.swift
+++ b/TestFoundation/main.swift
@@ -87,4 +87,5 @@
     testCase(TestProgressFraction.allTests),
     testCase(TestProgress.allTests),
     testCase(TestObjCRuntime.allTests),
+    testCase(TestNotification.allTests),
 ])