Add ErrorType initialization tests

Lib/KeychainAccess.xcodeproj/project.pbxproj

@@ -15,6 +15,8 @@
 		140F196F1A49D79500B0016A /* KeychainAccessTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 140F196E1A49D79500B0016A /* KeychainAccessTests.swift */; };
 		140F197B1A49D89200B0016A /* Keychain.swift in Sources */ = {isa = PBXBuildFile; fileRef = 140F197A1A49D89200B0016A /* Keychain.swift */; };
 		142852A71B1CED3500F27BD9 /* KeychainAccess.h in Headers */ = {isa = PBXBuildFile; fileRef = 140F19611A49D79400B0016A /* KeychainAccess.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		142EDA851BCB505F00A32149 /* ErrorTypeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 142EDA841BCB505F00A32149 /* ErrorTypeTests.swift */; settings = {ASSET_TAGS = (); }; };
+		142EDA861BCB505F00A32149 /* ErrorTypeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 142EDA841BCB505F00A32149 /* ErrorTypeTests.swift */; settings = {ASSET_TAGS = (); }; };
 		148F9D4A1BCB4118006EDF48 /* EnumTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 148F9D491BCB4118006EDF48 /* EnumTests.swift */; settings = {ASSET_TAGS = (); }; };
 		148F9D4B1BCB4118006EDF48 /* EnumTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 148F9D491BCB4118006EDF48 /* EnumTests.swift */; settings = {ASSET_TAGS = (); }; };
 		14FDD4681B49B9EF00C39FE8 /* KeychainAccess.h in Headers */ = {isa = PBXBuildFile; fileRef = 140F19611A49D79400B0016A /* KeychainAccess.h */; settings = {ATTRIBUTES = (Public, ); }; };
@@ -48,6 +50,7 @@
 		140F196D1A49D79500B0016A /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		140F196E1A49D79500B0016A /* KeychainAccessTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = KeychainAccessTests.swift; sourceTree = "<group>"; };
 		140F197A1A49D89200B0016A /* Keychain.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Keychain.swift; sourceTree = "<group>"; };
+		142EDA841BCB505F00A32149 /* ErrorTypeTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ErrorTypeTests.swift; sourceTree = "<group>"; };
 		148F9D491BCB4118006EDF48 /* EnumTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = EnumTests.swift; sourceTree = "<group>"; };
 		14FDD4601B49B9AD00C39FE8 /* KeychainAccess.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = KeychainAccess.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 /* End PBXFileReference section */
@@ -137,6 +140,7 @@
 			children = (
 				140F196E1A49D79500B0016A /* KeychainAccessTests.swift */,
 				148F9D491BCB4118006EDF48 /* EnumTests.swift */,
+				142EDA841BCB505F00A32149 /* ErrorTypeTests.swift */,
 				140F196C1A49D79500B0016A /* Supporting Files */,
 			);
 			path = KeychainAccessTests;
@@ -370,6 +374,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				148F9D4B1BCB4118006EDF48 /* EnumTests.swift in Sources */,
+				142EDA861BCB505F00A32149 /* ErrorTypeTests.swift in Sources */,
 				140C8F241A4EBF9A00F85556 /* KeychainAccessTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -387,6 +392,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				148F9D4A1BCB4118006EDF48 /* EnumTests.swift in Sources */,
+				142EDA851BCB505F00A32149 /* ErrorTypeTests.swift in Sources */,
 				140F196F1A49D79500B0016A /* KeychainAccessTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;

Lib/KeychainAccess/Keychain.swift

@@ -1375,8 +1375,15 @@ extension CFError {
 public enum Status : OSStatus, ErrorType {
     case Success
     case Unimplemented
+    case DiskFull
+    case IO
+    case OpWr
     case Param
+    case WrPerm
     case Allocate
+    case UserCanceled
+    case BadReq
+    case InternalComponent
     case NotAvailable
     case ReadOnly
     case AuthFailed
@@ -1406,6 +1413,7 @@ public enum Status : OSStatus, ErrorType {
     case DataNotModifiable
     case CreateChainFailed
     case InvalidPrefsDomain
+    case InDarkWake
     case ACLNotSimple
     case PolicyNotFound
     case InvalidTrustSetting
@@ -1464,7 +1472,6 @@ public enum Status : OSStatus, ErrorType {
     case AppleInvalidKeyEndDate
     case ConversionError
     case AppleSSLv2Rollback
-    case DiskFull
     case QuotaExceeded
     case FileTooBig
     case InvalidDatabaseBlob
@@ -1749,6 +1756,25 @@ public enum Status : OSStatus, ErrorType {
     case InvalidIndexInfo
     case InvalidNewOwner
     case InvalidModifyMode
+    case MissingRequiredExtension
+    case ExtendedKeyUsageNotCritical
+    case TimestampMissing
+    case TimestampInvalid
+    case TimestampNotTrusted
+    case TimestampServiceNotAvailable
+    case TimestampBadAlg
+    case TimestampBadRequest
+    case TimestampBadDataFormat
+    case TimestampTimeNotAvailable
+    case TimestampUnacceptedPolicy
+    case TimestampUnacceptedExtension
+    case TimestampAddInfoNotAvailable
+    case TimestampSystemFailure
+    case SigningTimeMissing
+    case TimestampRejection
+    case TimestampWaiting
+    case TimestampRevocationWarning
+    case TimestampRevocationNotification
     case UnexpectedError
 }
 
@@ -1760,10 +1786,24 @@ extension Status : RawRepresentable, CustomStringConvertible {
             self = Success
         case -4:
             self = Unimplemented
+        case -34:
+            self = DiskFull
+        case -36:
+            self = IO
+        case -49:
+            self = OpWr
         case -50:
             self = Param
+        case -61:
+            self = WrPerm
         case -108:
             self = Allocate
+        case -128:
+            self = UserCanceled
+        case -909:
+            self = BadReq
+        case -2070:
+            self = InternalComponent
         case -25291:
             self = NotAvailable
         case -25292:
@@ -1822,6 +1862,8 @@ extension Status : RawRepresentable, CustomStringConvertible {
             self = CreateChainFailed
         case -25319:
             self = InvalidPrefsDomain
+        case -25320:
+            self = InDarkWake
         case -25240:
             self = ACLNotSimple
         case -25241:
@@ -1938,8 +1980,6 @@ extension Status : RawRepresentable, CustomStringConvertible {
             self = ConversionError
         case -67595:
             self = AppleSSLv2Rollback
-        case -34:
-            self = DiskFull
         case -67596:
             self = QuotaExceeded
         case -67597:
@@ -2508,6 +2548,44 @@ extension Status : RawRepresentable, CustomStringConvertible {
             self = InvalidNewOwner
         case -67879:
             self = InvalidModifyMode
+        case -67880:
+            self = MissingRequiredExtension
+        case -67881:
+            self = ExtendedKeyUsageNotCritical
+        case -67882:
+            self = TimestampMissing
+        case -67883:
+            self = TimestampInvalid
+        case -67884:
+            self = TimestampNotTrusted
+        case -67885:
+            self = TimestampServiceNotAvailable
+        case -67886:
+            self = TimestampBadAlg
+        case -67887:
+            self = TimestampBadRequest
+        case -67888:
+            self = TimestampBadDataFormat
+        case -67889:
+            self = TimestampTimeNotAvailable
+        case -67890:
+            self = TimestampUnacceptedPolicy
+        case -67891:
+            self = TimestampUnacceptedExtension
+        case -67892:
+            self = TimestampAddInfoNotAvailable
+        case -67893:
+            self = TimestampSystemFailure
+        case -67894:
+            self = SigningTimeMissing
+        case -67895:
+            self = TimestampRejection
+        case -67896:
+            self = TimestampWaiting
+        case -67897:
+            self = TimestampRevocationWarning
+        case -67898:
+            self = TimestampRevocationNotification
         default:
             self = UnexpectedError
         }
@@ -2519,10 +2597,24 @@ extension Status : RawRepresentable, CustomStringConvertible {
             return 0
         case Unimplemented:
             return -4
+        case DiskFull:
+            return -34
+        case IO:
+            return -36
+        case OpWr:
+            return -49
         case Param:
             return -50
+        case WrPerm:
+            return -61
         case Allocate:
             return -108
+        case UserCanceled:
+            return -128
+        case BadReq:
+            return -909
+        case InternalComponent:
+            return -2070
         case NotAvailable:
             return -25291
         case ReadOnly:
@@ -2581,6 +2673,8 @@ extension Status : RawRepresentable, CustomStringConvertible {
             return -25318
         case InvalidPrefsDomain:
             return -25319
+        case InDarkWake:
+            return -25320
         case ACLNotSimple:
             return -25240
         case PolicyNotFound:
@@ -2697,8 +2791,6 @@ extension Status : RawRepresentable, CustomStringConvertible {
             return -67594
         case AppleSSLv2Rollback:
             return -67595
-        case DiskFull:
-            return -34
         case QuotaExceeded:
             return -67596
         case FileTooBig:
@@ -3267,6 +3359,44 @@ extension Status : RawRepresentable, CustomStringConvertible {
             return -67878
         case InvalidModifyMode:
             return -67879
+        case MissingRequiredExtension:
+            return -67880
+        case ExtendedKeyUsageNotCritical:
+            return -67881
+        case TimestampMissing:
+            return -67882
+        case TimestampInvalid:
+            return -67883
+        case TimestampNotTrusted:
+            return -67884
+        case TimestampServiceNotAvailable:
+            return -67885
+        case TimestampBadAlg:
+            return -67886
+        case TimestampBadRequest:
+            return -67887
+        case TimestampBadDataFormat:
+            return -67888
+        case TimestampTimeNotAvailable:
+            return -67889
+        case TimestampUnacceptedPolicy:
+            return -67890
+        case TimestampUnacceptedExtension:
+            return -67891
+        case TimestampAddInfoNotAvailable:
+            return -67892
+        case TimestampSystemFailure:
+            return -67893
+        case SigningTimeMissing:
+            return -67894
+        case TimestampRejection:
+            return -67895
+        case TimestampWaiting:
+            return -67896
+        case TimestampRevocationWarning:
+            return -67897
+        case TimestampRevocationNotification:
+            return -67898
         default:
             return -99999
         }
@@ -3278,10 +3408,24 @@ extension Status : RawRepresentable, CustomStringConvertible {
             return "No error."
         case Unimplemented:
             return "Function or operation not implemented."
+        case DiskFull:
+            return "The disk is full."
+        case IO:
+            return "I/O error (bummers)"
+        case OpWr:
+            return "file already open with with write permission"
         case Param:
             return "One or more parameters passed to a function were not valid."
+        case WrPerm:
+            return "write permissions error"
         case Allocate:
             return "Failed to allocate memory."
+        case UserCanceled:
+            return "User canceled the operation."
+        case BadReq:
+            return "Bad parameter or invalid state for operation."
+        case InternalComponent:
+            return ""
         case NotAvailable:
             return "No keychain is available. You may need to restart your computer."
         case ReadOnly:
@@ -3340,6 +3484,8 @@ extension Status : RawRepresentable, CustomStringConvertible {
             return "One or more certificates required to validate this certificate cannot be found."
         case InvalidPrefsDomain:
             return "The specified preferences domain is not valid."
+        case InDarkWake:
+            return "In dark wake, no UI possible"
         case ACLNotSimple:
             return "The specified access control list is not in standard (simple) form."
         case PolicyNotFound:
@@ -3456,8 +3602,6 @@ extension Status : RawRepresentable, CustomStringConvertible {
             return "A conversion error has occurred."
         case AppleSSLv2Rollback:
             return "A SSLv2 rollback error has occurred."
-        case DiskFull:
-            return "The disk is full."
         case QuotaExceeded:
             return "The quota was exceeded."
         case FileTooBig:
@@ -4026,6 +4170,44 @@ extension Status : RawRepresentable, CustomStringConvertible {
             return "The new owner is not valid."
         case InvalidModifyMode:
             return "The modify mode is not valid."
+        case MissingRequiredExtension:
+            return "A required certificate extension is missing."
+        case ExtendedKeyUsageNotCritical:
+            return "The extended key usage extension was not marked critical."
+        case TimestampMissing:
+            return "A timestamp was expected but was not found."
+        case TimestampInvalid:
+            return "The timestamp was not valid."
+        case TimestampNotTrusted:
+            return "The timestamp was not trusted."
+        case TimestampServiceNotAvailable:
+            return "The timestamp service is not available."
+        case TimestampBadAlg:
+            return "An unrecognized or unsupported Algorithm Identifier in timestamp."
+        case TimestampBadRequest:
+            return "The timestamp transaction is not permitted or supported."
+        case TimestampBadDataFormat:
+            return "The timestamp data submitted has the wrong format."
+        case TimestampTimeNotAvailable:
+            return "The time source for the Timestamp Authority is not available."
+        case TimestampUnacceptedPolicy:
+            return "The requested policy is not supported by the Timestamp Authority."
+        case TimestampUnacceptedExtension:
+            return "The requested extension is not supported by the Timestamp Authority."
+        case TimestampAddInfoNotAvailable:
+            return "The additional information requested is not available."
+        case TimestampSystemFailure:
+            return "The timestamp request cannot be handled due to system failure."
+        case SigningTimeMissing:
+            return "A signing time was expected but was not found."
+        case TimestampRejection:
+            return "A timestamp transaction was rejected."
+        case TimestampWaiting:
+            return "A timestamp transaction is waiting."
+        case TimestampRevocationWarning:
+            return "A timestamp authority revocation warning was issued."
+        case TimestampRevocationNotification:
+            return "A timestamp authority revocation notification was issued."
         default:
             return "Unexpected error has occurred."
         }

Lib/KeychainAccessTests/ErrorTypeTests.swift

@@ -0,0 +1,1905 @@
+//
+//  ErrorTypeTests.swift
+//  KeychainAccessTests
+//
+//  Created by kishikawa katsumi on 10/12/15.
+//  Copyright © 2015 kishikawa katsumi. All rights reserved.
+//
+
+import XCTest
+import KeychainAccess
+
+class ErrorTypeTests: XCTestCase {
+    
+    override func setUp() {
+        super.setUp()
+    }
+
+    override func tearDown() {
+        super.tearDown()
+    }
+    
+    func testErrorType() {
+        do {
+            let status = Status(rawValue: errSecSuccess)
+            XCTAssertEqual(status, .Success)
+            XCTAssertEqual(status?.description, "No error.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnimplemented)
+            XCTAssertEqual(status, .Unimplemented)
+            XCTAssertEqual(status?.description, "Function or operation not implemented.")
+        }
+        #if os(OSX)
+        do {
+            let status = Status(rawValue: errSecDskFull)
+            XCTAssertEqual(status, .DiskFull)
+            XCTAssertEqual(status?.description, "The disk is full.")
+        }
+        #endif
+        do {
+            let status = Status(rawValue: errSecIO)
+            XCTAssertEqual(status, .IO)
+            XCTAssertEqual(status?.description, "I/O error (bummers)")
+        }
+        #if os(iOS)
+        do {
+            let status = Status(rawValue: errSecOpWr)
+            XCTAssertEqual(status, .OpWr)
+            XCTAssertEqual(status?.description, "file already open with with write permission")
+        }
+        #endif
+        do {
+            let status = Status(rawValue: errSecParam)
+            XCTAssertEqual(status, .Param)
+            XCTAssertEqual(status?.description, "One or more parameters passed to a function were not valid.")
+        }
+        #if os(OSX)
+        do {
+            let status = Status(rawValue: errSecWrPerm)
+            XCTAssertEqual(status, .WrPerm)
+            XCTAssertEqual(status?.description, "write permissions error")
+        }
+        #endif
+        do {
+            let status = Status(rawValue: errSecAllocate)
+            XCTAssertEqual(status, .Allocate)
+            XCTAssertEqual(status?.description, "Failed to allocate memory.")
+        }
+        do {
+            let status = Status(rawValue: errSecUserCanceled)
+            XCTAssertEqual(status, .UserCanceled)
+            XCTAssertEqual(status?.description, "User canceled the operation.")
+        }
+        do {
+            let status = Status(rawValue: errSecBadReq)
+            XCTAssertEqual(status, .BadReq)
+            XCTAssertEqual(status?.description, "Bad parameter or invalid state for operation.")
+        }
+        do {
+            let status = Status(rawValue: errSecInternalComponent)
+            XCTAssertEqual(status, .InternalComponent)
+            XCTAssertEqual(status?.description, "")
+        }
+        do {
+            let status = Status(rawValue: errSecNotAvailable)
+            XCTAssertEqual(status, .NotAvailable)
+            XCTAssertEqual(status?.description, "No keychain is available. You may need to restart your computer.")
+        }
+        #if os(OSX)
+        do {
+            let status = Status(rawValue: errSecReadOnly)
+            XCTAssertEqual(status, .ReadOnly)
+            XCTAssertEqual(status?.description, "This keychain cannot be modified.")
+        }
+        #endif
+        do {
+            let status = Status(rawValue: errSecAuthFailed)
+            XCTAssertEqual(status, .AuthFailed)
+            XCTAssertEqual(status?.description, "The user name or passphrase you entered is not correct.")
+        }
+        #if os(OSX)
+        do {
+            let status = Status(rawValue: errSecNoSuchKeychain)
+            XCTAssertEqual(status, .NoSuchKeychain)
+            XCTAssertEqual(status?.description, "The specified keychain could not be found.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidKeychain)
+            XCTAssertEqual(status, .InvalidKeychain)
+            XCTAssertEqual(status?.description, "The specified keychain is not a valid keychain file.")
+        }
+        do {
+            let status = Status(rawValue: errSecDuplicateKeychain)
+            XCTAssertEqual(status, .DuplicateKeychain)
+            XCTAssertEqual(status?.description, "A keychain with the same name already exists.")
+        }
+        do {
+            let status = Status(rawValue: errSecDuplicateCallback)
+            XCTAssertEqual(status, .DuplicateCallback)
+            XCTAssertEqual(status?.description, "The specified callback function is already installed.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidCallback)
+            XCTAssertEqual(status, .InvalidCallback)
+            XCTAssertEqual(status?.description, "The specified callback function is not valid.")
+        }
+        #endif
+        do {
+            let status = Status(rawValue: errSecDuplicateItem)
+            XCTAssertEqual(status, .DuplicateItem)
+            XCTAssertEqual(status?.description, "The specified item already exists in the keychain.")
+        }
+        do {
+            let status = Status(rawValue: errSecItemNotFound)
+            XCTAssertEqual(status, .ItemNotFound)
+            XCTAssertEqual(status?.description, "The specified item could not be found in the keychain.")
+        }
+        #if os(OSX)
+        do {
+            let status = Status(rawValue: errSecBufferTooSmall)
+            XCTAssertEqual(status, .BufferTooSmall)
+            XCTAssertEqual(status?.description, "There is not enough memory available to use the specified item.")
+        }
+        do {
+            let status = Status(rawValue: errSecDataTooLarge)
+            XCTAssertEqual(status, .DataTooLarge)
+            XCTAssertEqual(status?.description, "This item contains information which is too large or in a format that cannot be displayed.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoSuchAttr)
+            XCTAssertEqual(status, .NoSuchAttr)
+            XCTAssertEqual(status?.description, "The specified attribute does not exist.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidItemRef)
+            XCTAssertEqual(status, .InvalidItemRef)
+            XCTAssertEqual(status?.description, "The specified item is no longer valid. It may have been deleted from the keychain.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidSearchRef)
+            XCTAssertEqual(status, .InvalidSearchRef)
+            XCTAssertEqual(status?.description, "Unable to search the current keychain.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoSuchClass)
+            XCTAssertEqual(status, .NoSuchClass)
+            XCTAssertEqual(status?.description, "The specified item does not appear to be a valid keychain item.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoDefaultKeychain)
+            XCTAssertEqual(status, .NoDefaultKeychain)
+            XCTAssertEqual(status?.description, "A default keychain could not be found.")
+        }
+        #endif
+        do {
+            let status = Status(rawValue: errSecInteractionNotAllowed)
+            XCTAssertEqual(status, .InteractionNotAllowed)
+            XCTAssertEqual(status?.description, "User interaction is not allowed.")
+        }
+        #if os(OSX)
+        do {
+            let status = Status(rawValue: errSecReadOnlyAttr)
+            XCTAssertEqual(status, .ReadOnlyAttr)
+            XCTAssertEqual(status?.description, "The specified attribute could not be modified.")
+        }
+        do {
+            let status = Status(rawValue: errSecWrongSecVersion)
+            XCTAssertEqual(status, .WrongSecVersion)
+            XCTAssertEqual(status?.description, "This keychain was created by a different version of the system software and cannot be opened.")
+        }
+        do {
+            let status = Status(rawValue: errSecKeySizeNotAllowed)
+            XCTAssertEqual(status, .KeySizeNotAllowed)
+            XCTAssertEqual(status?.description, "This item specifies a key size which is too large.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoStorageModule)
+            XCTAssertEqual(status, .NoStorageModule)
+            XCTAssertEqual(status?.description, "A required component (data storage module) could not be loaded. You may need to restart your computer.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoCertificateModule)
+            XCTAssertEqual(status, .NoCertificateModule)
+            XCTAssertEqual(status?.description, "A required component (certificate module) could not be loaded. You may need to restart your computer.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoPolicyModule)
+            XCTAssertEqual(status, .NoPolicyModule)
+            XCTAssertEqual(status?.description, "A required component (policy module) could not be loaded. You may need to restart your computer.")
+        }
+        do {
+            let status = Status(rawValue: errSecInteractionRequired)
+            XCTAssertEqual(status, .InteractionRequired)
+            XCTAssertEqual(status?.description, "User interaction is required, but is currently not allowed.")
+        }
+        do {
+            let status = Status(rawValue: errSecDataNotAvailable)
+            XCTAssertEqual(status, .DataNotAvailable)
+            XCTAssertEqual(status?.description, "The contents of this item cannot be retrieved.")
+        }
+        do {
+            let status = Status(rawValue: errSecDataNotModifiable)
+            XCTAssertEqual(status, .DataNotModifiable)
+            XCTAssertEqual(status?.description, "The contents of this item cannot be modified.")
+        }
+        do {
+            let status = Status(rawValue: errSecCreateChainFailed)
+            XCTAssertEqual(status, .CreateChainFailed)
+            XCTAssertEqual(status?.description, "One or more certificates required to validate this certificate cannot be found.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidPrefsDomain)
+            XCTAssertEqual(status, .InvalidPrefsDomain)
+            XCTAssertEqual(status?.description, "The specified preferences domain is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInDarkWake)
+            XCTAssertEqual(status, .InDarkWake)
+            XCTAssertEqual(status?.description, "In dark wake, no UI possible")
+        }
+        do {
+            let status = Status(rawValue: errSecACLNotSimple)
+            XCTAssertEqual(status, .ACLNotSimple)
+            XCTAssertEqual(status?.description, "The specified access control list is not in standard (simple) form.")
+        }
+        do {
+            let status = Status(rawValue: errSecPolicyNotFound)
+            XCTAssertEqual(status, .PolicyNotFound)
+            XCTAssertEqual(status?.description, "The specified policy cannot be found.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidTrustSetting)
+            XCTAssertEqual(status, .InvalidTrustSetting)
+            XCTAssertEqual(status?.description, "The specified trust setting is invalid.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoAccessForItem)
+            XCTAssertEqual(status, .NoAccessForItem)
+            XCTAssertEqual(status?.description, "The specified item has no access control.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidOwnerEdit)
+            XCTAssertEqual(status, .InvalidOwnerEdit)
+            XCTAssertEqual(status?.description, "Invalid attempt to change the owner of this item.")
+        }
+        do {
+            let status = Status(rawValue: errSecTrustNotAvailable)
+            XCTAssertEqual(status, .TrustNotAvailable)
+            XCTAssertEqual(status?.description, "No trust results are available.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedFormat)
+            XCTAssertEqual(status, .UnsupportedFormat)
+            XCTAssertEqual(status?.description, "Import/Export format unsupported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnknownFormat)
+            XCTAssertEqual(status, .UnknownFormat)
+            XCTAssertEqual(status?.description, "Unknown format in import.")
+        }
+        do {
+            let status = Status(rawValue: errSecKeyIsSensitive)
+            XCTAssertEqual(status, .KeyIsSensitive)
+            XCTAssertEqual(status?.description, "Key material must be wrapped for export.")
+        }
+        do {
+            let status = Status(rawValue: errSecMultiplePrivKeys)
+            XCTAssertEqual(status, .MultiplePrivKeys)
+            XCTAssertEqual(status?.description, "An attempt was made to import multiple private keys.")
+        }
+        do {
+            let status = Status(rawValue: errSecPassphraseRequired)
+            XCTAssertEqual(status, .PassphraseRequired)
+            XCTAssertEqual(status?.description, "Passphrase is required for import/export.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidPasswordRef)
+            XCTAssertEqual(status, .InvalidPasswordRef)
+            XCTAssertEqual(status?.description, "The password reference was invalid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidTrustSettings)
+            XCTAssertEqual(status, .InvalidTrustSettings)
+            XCTAssertEqual(status?.description, "The Trust Settings Record was corrupted.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoTrustSettings)
+            XCTAssertEqual(status, .NoTrustSettings)
+            XCTAssertEqual(status?.description, "No Trust Settings were found.")
+        }
+        do {
+            let status = Status(rawValue: errSecPkcs12VerifyFailure)
+            XCTAssertEqual(status, .Pkcs12VerifyFailure)
+            XCTAssertEqual(status?.description, "MAC verification failed during PKCS12 import (wrong password?)")
+        }
+        do {
+            let status = Status(rawValue: errSecNotSigner)
+            XCTAssertEqual(status, .NotSigner)
+            XCTAssertEqual(status?.description, "A certificate was not signed by its proposed parent.")
+        }
+        #endif
+        do {
+            let status = Status(rawValue: errSecDecode)
+            XCTAssertEqual(status, .Decode)
+            XCTAssertEqual(status?.description, "Unable to decode the provided data.")
+        }
+        #if os(OSX)
+        do {
+            let status = Status(rawValue: errSecServiceNotAvailable)
+            XCTAssertEqual(status, .ServiceNotAvailable)
+            XCTAssertEqual(status?.description, "The required service is not available.")
+        }
+        do {
+            let status = Status(rawValue: errSecInsufficientClientID)
+            XCTAssertEqual(status, .InsufficientClientID)
+            XCTAssertEqual(status?.description, "The client ID is not correct.")
+        }
+        do {
+            let status = Status(rawValue: errSecDeviceReset)
+            XCTAssertEqual(status, .DeviceReset)
+            XCTAssertEqual(status?.description, "A device reset has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecDeviceFailed)
+            XCTAssertEqual(status, .DeviceFailed)
+            XCTAssertEqual(status?.description, "A device failure has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecAppleAddAppACLSubject)
+            XCTAssertEqual(status, .AppleAddAppACLSubject)
+            XCTAssertEqual(status?.description, "Adding an application ACL subject failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecApplePublicKeyIncomplete)
+            XCTAssertEqual(status, .ApplePublicKeyIncomplete)
+            XCTAssertEqual(status?.description, "The public key is incomplete.")
+        }
+        do {
+            let status = Status(rawValue: errSecAppleSignatureMismatch)
+            XCTAssertEqual(status, .AppleSignatureMismatch)
+            XCTAssertEqual(status?.description, "A signature mismatch has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecAppleInvalidKeyStartDate)
+            XCTAssertEqual(status, .AppleInvalidKeyStartDate)
+            XCTAssertEqual(status?.description, "The specified key has an invalid start date.")
+        }
+        do {
+            let status = Status(rawValue: errSecAppleInvalidKeyEndDate)
+            XCTAssertEqual(status, .AppleInvalidKeyEndDate)
+            XCTAssertEqual(status?.description, "The specified key has an invalid end date.")
+        }
+        do {
+            let status = Status(rawValue: errSecConversionError)
+            XCTAssertEqual(status, .ConversionError)
+            XCTAssertEqual(status?.description, "A conversion error has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecAppleSSLv2Rollback)
+            XCTAssertEqual(status, .AppleSSLv2Rollback)
+            XCTAssertEqual(status?.description, "A SSLv2 rollback error has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecDiskFull)
+            XCTAssertEqual(status, .DiskFull)
+            XCTAssertEqual(status?.description, "The disk is full.")
+        }
+        do {
+            let status = Status(rawValue: errSecQuotaExceeded)
+            XCTAssertEqual(status, .QuotaExceeded)
+            XCTAssertEqual(status?.description, "The quota was exceeded.")
+        }
+        do {
+            let status = Status(rawValue: errSecFileTooBig)
+            XCTAssertEqual(status, .FileTooBig)
+            XCTAssertEqual(status?.description, "The file is too big.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidDatabaseBlob)
+            XCTAssertEqual(status, .InvalidDatabaseBlob)
+            XCTAssertEqual(status?.description, "The specified database has an invalid blob.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidKeyBlob)
+            XCTAssertEqual(status, .InvalidKeyBlob)
+            XCTAssertEqual(status?.description, "The specified database has an invalid key blob.")
+        }
+        do {
+            let status = Status(rawValue: errSecIncompatibleDatabaseBlob)
+            XCTAssertEqual(status, .IncompatibleDatabaseBlob)
+            XCTAssertEqual(status?.description, "The specified database has an incompatible blob.")
+        }
+        do {
+            let status = Status(rawValue: errSecIncompatibleKeyBlob)
+            XCTAssertEqual(status, .IncompatibleKeyBlob)
+            XCTAssertEqual(status?.description, "The specified database has an incompatible key blob.")
+        }
+        do {
+            let status = Status(rawValue: errSecHostNameMismatch)
+            XCTAssertEqual(status, .HostNameMismatch)
+            XCTAssertEqual(status?.description, "A host name mismatch has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnknownCriticalExtensionFlag)
+            XCTAssertEqual(status, .UnknownCriticalExtensionFlag)
+            XCTAssertEqual(status?.description, "There is an unknown critical extension flag.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoBasicConstraints)
+            XCTAssertEqual(status, .NoBasicConstraints)
+            XCTAssertEqual(status?.description, "No basic constraints were found.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoBasicConstraintsCA)
+            XCTAssertEqual(status, .NoBasicConstraintsCA)
+            XCTAssertEqual(status?.description, "No basic CA constraints were found.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAuthorityKeyID)
+            XCTAssertEqual(status, .InvalidAuthorityKeyID)
+            XCTAssertEqual(status?.description, "The authority key ID is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidSubjectKeyID)
+            XCTAssertEqual(status, .InvalidSubjectKeyID)
+            XCTAssertEqual(status?.description, "The subject key ID is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidKeyUsageForPolicy)
+            XCTAssertEqual(status, .InvalidKeyUsageForPolicy)
+            XCTAssertEqual(status?.description, "The key usage is not valid for the specified policy.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidExtendedKeyUsage)
+            XCTAssertEqual(status, .InvalidExtendedKeyUsage)
+            XCTAssertEqual(status?.description, "The extended key usage is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidIDLinkage)
+            XCTAssertEqual(status, .InvalidIDLinkage)
+            XCTAssertEqual(status?.description, "The ID linkage is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecPathLengthConstraintExceeded)
+            XCTAssertEqual(status, .PathLengthConstraintExceeded)
+            XCTAssertEqual(status?.description, "The path length constraint was exceeded.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidRoot)
+            XCTAssertEqual(status, .InvalidRoot)
+            XCTAssertEqual(status?.description, "The root or anchor certificate is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecCRLExpired)
+            XCTAssertEqual(status, .CRLExpired)
+            XCTAssertEqual(status?.description, "The CRL has expired.")
+        }
+        do {
+            let status = Status(rawValue: errSecCRLNotValidYet)
+            XCTAssertEqual(status, .CRLNotValidYet)
+            XCTAssertEqual(status?.description, "The CRL is not yet valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecCRLNotFound)
+            XCTAssertEqual(status, .CRLNotFound)
+            XCTAssertEqual(status?.description, "The CRL was not found.")
+        }
+        do {
+            let status = Status(rawValue: errSecCRLServerDown)
+            XCTAssertEqual(status, .CRLServerDown)
+            XCTAssertEqual(status?.description, "The CRL server is down.")
+        }
+        do {
+            let status = Status(rawValue: errSecCRLBadURI)
+            XCTAssertEqual(status, .CRLBadURI)
+            XCTAssertEqual(status?.description, "The CRL has a bad Uniform Resource Identifier.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnknownCertExtension)
+            XCTAssertEqual(status, .UnknownCertExtension)
+            XCTAssertEqual(status?.description, "An unknown certificate extension was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnknownCRLExtension)
+            XCTAssertEqual(status, .UnknownCRLExtension)
+            XCTAssertEqual(status?.description, "An unknown CRL extension was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecCRLNotTrusted)
+            XCTAssertEqual(status, .CRLNotTrusted)
+            XCTAssertEqual(status?.description, "The CRL is not trusted.")
+        }
+        do {
+            let status = Status(rawValue: errSecCRLPolicyFailed)
+            XCTAssertEqual(status, .CRLPolicyFailed)
+            XCTAssertEqual(status?.description, "The CRL policy failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecIDPFailure)
+            XCTAssertEqual(status, .IDPFailure)
+            XCTAssertEqual(status?.description, "The issuing distribution point was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecSMIMEEmailAddressesNotFound)
+            XCTAssertEqual(status, .SMIMEEmailAddressesNotFound)
+            XCTAssertEqual(status?.description, "An email address mismatch was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecSMIMEBadExtendedKeyUsage)
+            XCTAssertEqual(status, .SMIMEBadExtendedKeyUsage)
+            XCTAssertEqual(status?.description, "The appropriate extended key usage for SMIME was not found.")
+        }
+        do {
+            let status = Status(rawValue: errSecSMIMEBadKeyUsage)
+            XCTAssertEqual(status, .SMIMEBadKeyUsage)
+            XCTAssertEqual(status?.description, "The key usage is not compatible with SMIME.")
+        }
+        do {
+            let status = Status(rawValue: errSecSMIMEKeyUsageNotCritical)
+            XCTAssertEqual(status, .SMIMEKeyUsageNotCritical)
+            XCTAssertEqual(status?.description, "The key usage extension is not marked as critical.")
+        }
+        do {
+            let status = Status(rawValue: errSecSMIMENoEmailAddress)
+            XCTAssertEqual(status, .SMIMENoEmailAddress)
+            XCTAssertEqual(status?.description, "No email address was found in the certificate.")
+        }
+        do {
+            let status = Status(rawValue: errSecSMIMESubjAltNameNotCritical)
+            XCTAssertEqual(status, .SMIMESubjAltNameNotCritical)
+            XCTAssertEqual(status?.description, "The subject alternative name extension is not marked as critical.")
+        }
+        do {
+            let status = Status(rawValue: errSecSSLBadExtendedKeyUsage)
+            XCTAssertEqual(status, .SSLBadExtendedKeyUsage)
+            XCTAssertEqual(status?.description, "The appropriate extended key usage for SSL was not found.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPBadResponse)
+            XCTAssertEqual(status, .OCSPBadResponse)
+            XCTAssertEqual(status?.description, "The OCSP response was incorrect or could not be parsed.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPBadRequest)
+            XCTAssertEqual(status, .OCSPBadRequest)
+            XCTAssertEqual(status?.description, "The OCSP request was incorrect or could not be parsed.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPUnavailable)
+            XCTAssertEqual(status, .OCSPUnavailable)
+            XCTAssertEqual(status?.description, "OCSP service is unavailable.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPStatusUnrecognized)
+            XCTAssertEqual(status, .OCSPStatusUnrecognized)
+            XCTAssertEqual(status?.description, "The OCSP server did not recognize this certificate.")
+        }
+        do {
+            let status = Status(rawValue: errSecEndOfData)
+            XCTAssertEqual(status, .EndOfData)
+            XCTAssertEqual(status?.description, "An end-of-data was detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecIncompleteCertRevocationCheck)
+            XCTAssertEqual(status, .IncompleteCertRevocationCheck)
+            XCTAssertEqual(status?.description, "An incomplete certificate revocation check occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecNetworkFailure)
+            XCTAssertEqual(status, .NetworkFailure)
+            XCTAssertEqual(status?.description, "A network failure occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPNotTrustedToAnchor)
+            XCTAssertEqual(status, .OCSPNotTrustedToAnchor)
+            XCTAssertEqual(status?.description, "The OCSP response was not trusted to a root or anchor certificate.")
+        }
+        do {
+            let status = Status(rawValue: errSecRecordModified)
+            XCTAssertEqual(status, .RecordModified)
+            XCTAssertEqual(status?.description, "The record was modified.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPSignatureError)
+            XCTAssertEqual(status, .OCSPSignatureError)
+            XCTAssertEqual(status?.description, "The OCSP response had an invalid signature.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPNoSigner)
+            XCTAssertEqual(status, .OCSPNoSigner)
+            XCTAssertEqual(status?.description, "The OCSP response had no signer.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPResponderMalformedReq)
+            XCTAssertEqual(status, .OCSPResponderMalformedReq)
+            XCTAssertEqual(status?.description, "The OCSP responder was given a malformed request.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPResponderInternalError)
+            XCTAssertEqual(status, .OCSPResponderInternalError)
+            XCTAssertEqual(status?.description, "The OCSP responder encountered an internal error.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPResponderTryLater)
+            XCTAssertEqual(status, .OCSPResponderTryLater)
+            XCTAssertEqual(status?.description, "The OCSP responder is busy, try again later.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPResponderSignatureRequired)
+            XCTAssertEqual(status, .OCSPResponderSignatureRequired)
+            XCTAssertEqual(status?.description, "The OCSP responder requires a signature.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPResponderUnauthorized)
+            XCTAssertEqual(status, .OCSPResponderUnauthorized)
+            XCTAssertEqual(status?.description, "The OCSP responder rejected this request as unauthorized.")
+        }
+        do {
+            let status = Status(rawValue: errSecOCSPResponseNonceMismatch)
+            XCTAssertEqual(status, .OCSPResponseNonceMismatch)
+            XCTAssertEqual(status?.description, "The OCSP response nonce did not match the request.")
+        }
+        do {
+            let status = Status(rawValue: errSecCodeSigningBadCertChainLength)
+            XCTAssertEqual(status, .CodeSigningBadCertChainLength)
+            XCTAssertEqual(status?.description, "Code signing encountered an incorrect certificate chain length.")
+        }
+        do {
+            let status = Status(rawValue: errSecCodeSigningNoBasicConstraints)
+            XCTAssertEqual(status, .CodeSigningNoBasicConstraints)
+            XCTAssertEqual(status?.description, "Code signing found no basic constraints.")
+        }
+        do {
+            let status = Status(rawValue: errSecCodeSigningBadPathLengthConstraint)
+            XCTAssertEqual(status, .CodeSigningBadPathLengthConstraint)
+            XCTAssertEqual(status?.description, "Code signing encountered an incorrect path length constraint.")
+        }
+        do {
+            let status = Status(rawValue: errSecCodeSigningNoExtendedKeyUsage)
+            XCTAssertEqual(status, .CodeSigningNoExtendedKeyUsage)
+            XCTAssertEqual(status?.description, "Code signing found no extended key usage.")
+        }
+        do {
+            let status = Status(rawValue: errSecCodeSigningDevelopment)
+            XCTAssertEqual(status, .CodeSigningDevelopment)
+            XCTAssertEqual(status?.description, "Code signing indicated use of a development-only certificate.")
+        }
+        do {
+            let status = Status(rawValue: errSecResourceSignBadCertChainLength)
+            XCTAssertEqual(status, .ResourceSignBadCertChainLength)
+            XCTAssertEqual(status?.description, "Resource signing has encountered an incorrect certificate chain length.")
+        }
+        do {
+            let status = Status(rawValue: errSecResourceSignBadExtKeyUsage)
+            XCTAssertEqual(status, .ResourceSignBadExtKeyUsage)
+            XCTAssertEqual(status?.description, "Resource signing has encountered an error in the extended key usage.")
+        }
+        do {
+            let status = Status(rawValue: errSecTrustSettingDeny)
+            XCTAssertEqual(status, .TrustSettingDeny)
+            XCTAssertEqual(status?.description, "The trust setting for this policy was set to Deny.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidSubjectName)
+            XCTAssertEqual(status, .InvalidSubjectName)
+            XCTAssertEqual(status?.description, "An invalid certificate subject name was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnknownQualifiedCertStatement)
+            XCTAssertEqual(status, .UnknownQualifiedCertStatement)
+            XCTAssertEqual(status?.description, "An unknown qualified certificate statement was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeRequestQueued)
+            XCTAssertEqual(status, .MobileMeRequestQueued)
+            XCTAssertEqual(status?.description, "The MobileMe request will be sent during the next connection.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeRequestRedirected)
+            XCTAssertEqual(status, .MobileMeRequestRedirected)
+            XCTAssertEqual(status?.description, "The MobileMe request was redirected.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeServerError)
+            XCTAssertEqual(status, .MobileMeServerError)
+            XCTAssertEqual(status?.description, "A MobileMe server error occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeServerNotAvailable)
+            XCTAssertEqual(status, .MobileMeServerNotAvailable)
+            XCTAssertEqual(status?.description, "The MobileMe server is not available.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeServerAlreadyExists)
+            XCTAssertEqual(status, .MobileMeServerAlreadyExists)
+            XCTAssertEqual(status?.description, "The MobileMe server reported that the item already exists.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeServerServiceErr)
+            XCTAssertEqual(status, .MobileMeServerServiceErr)
+            XCTAssertEqual(status?.description, "A MobileMe service error has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeRequestAlreadyPending)
+            XCTAssertEqual(status, .MobileMeRequestAlreadyPending)
+            XCTAssertEqual(status?.description, "A MobileMe request is already pending.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeNoRequestPending)
+            XCTAssertEqual(status, .MobileMeNoRequestPending)
+            XCTAssertEqual(status?.description, "MobileMe has no request pending.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeCSRVerifyFailure)
+            XCTAssertEqual(status, .MobileMeCSRVerifyFailure)
+            XCTAssertEqual(status?.description, "A MobileMe CSR verification failure has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecMobileMeFailedConsistencyCheck)
+            XCTAssertEqual(status, .MobileMeFailedConsistencyCheck)
+            XCTAssertEqual(status?.description, "MobileMe has found a failed consistency check.")
+        }
+        do {
+            let status = Status(rawValue: errSecNotInitialized)
+            XCTAssertEqual(status, .NotInitialized)
+            XCTAssertEqual(status?.description, "A function was called without initializing CSSM.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidHandleUsage)
+            XCTAssertEqual(status, .InvalidHandleUsage)
+            XCTAssertEqual(status?.description, "The CSSM handle does not match with the service type.")
+        }
+        do {
+            let status = Status(rawValue: errSecPVCReferentNotFound)
+            XCTAssertEqual(status, .PVCReferentNotFound)
+            XCTAssertEqual(status?.description, "A reference to the calling module was not found in the list of authorized callers.")
+        }
+        do {
+            let status = Status(rawValue: errSecFunctionIntegrityFail)
+            XCTAssertEqual(status, .FunctionIntegrityFail)
+            XCTAssertEqual(status?.description, "A function address was not within the verified module.")
+        }
+        do {
+            let status = Status(rawValue: errSecInternalError)
+            XCTAssertEqual(status, .InternalError)
+            XCTAssertEqual(status?.description, "An internal error has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecMemoryError)
+            XCTAssertEqual(status, .MemoryError)
+            XCTAssertEqual(status?.description, "A memory error has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidData)
+            XCTAssertEqual(status, .InvalidData)
+            XCTAssertEqual(status?.description, "Invalid data was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecMDSError)
+            XCTAssertEqual(status, .MDSError)
+            XCTAssertEqual(status?.description, "A Module Directory Service error has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidPointer)
+            XCTAssertEqual(status, .InvalidPointer)
+            XCTAssertEqual(status?.description, "An invalid pointer was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecSelfCheckFailed)
+            XCTAssertEqual(status, .SelfCheckFailed)
+            XCTAssertEqual(status?.description, "Self-check has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecFunctionFailed)
+            XCTAssertEqual(status, .FunctionFailed)
+            XCTAssertEqual(status?.description, "A function has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecModuleManifestVerifyFailed)
+            XCTAssertEqual(status, .ModuleManifestVerifyFailed)
+            XCTAssertEqual(status?.description, "A module manifest verification failure has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidGUID)
+            XCTAssertEqual(status, .InvalidGUID)
+            XCTAssertEqual(status?.description, "An invalid GUID was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidHandle)
+            XCTAssertEqual(status, .InvalidHandle)
+            XCTAssertEqual(status?.description, "An invalid handle was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidDBList)
+            XCTAssertEqual(status, .InvalidDBList)
+            XCTAssertEqual(status?.description, "An invalid DB list was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidPassthroughID)
+            XCTAssertEqual(status, .InvalidPassthroughID)
+            XCTAssertEqual(status?.description, "An invalid passthrough ID was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidNetworkAddress)
+            XCTAssertEqual(status, .InvalidNetworkAddress)
+            XCTAssertEqual(status?.description, "An invalid network address was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecCRLAlreadySigned)
+            XCTAssertEqual(status, .CRLAlreadySigned)
+            XCTAssertEqual(status?.description, "The certificate revocation list is already signed.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidNumberOfFields)
+            XCTAssertEqual(status, .InvalidNumberOfFields)
+            XCTAssertEqual(status?.description, "An invalid number of fields were encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecVerificationFailure)
+            XCTAssertEqual(status, .VerificationFailure)
+            XCTAssertEqual(status?.description, "A verification failure occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnknownTag)
+            XCTAssertEqual(status, .UnknownTag)
+            XCTAssertEqual(status?.description, "An unknown tag was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidSignature)
+            XCTAssertEqual(status, .InvalidSignature)
+            XCTAssertEqual(status?.description, "An invalid signature was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidName)
+            XCTAssertEqual(status, .InvalidName)
+            XCTAssertEqual(status?.description, "An invalid name was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidCertificateRef)
+            XCTAssertEqual(status, .InvalidCertificateRef)
+            XCTAssertEqual(status?.description, "An invalid certificate reference was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidCertificateGroup)
+            XCTAssertEqual(status, .InvalidCertificateGroup)
+            XCTAssertEqual(status?.description, "An invalid certificate group was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecTagNotFound)
+            XCTAssertEqual(status, .TagNotFound)
+            XCTAssertEqual(status?.description, "The specified tag was not found.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidQuery)
+            XCTAssertEqual(status, .InvalidQuery)
+            XCTAssertEqual(status?.description, "The specified query was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidValue)
+            XCTAssertEqual(status, .InvalidValue)
+            XCTAssertEqual(status?.description, "An invalid value was detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecCallbackFailed)
+            XCTAssertEqual(status, .CallbackFailed)
+            XCTAssertEqual(status?.description, "A callback has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecACLDeleteFailed)
+            XCTAssertEqual(status, .ACLDeleteFailed)
+            XCTAssertEqual(status?.description, "An ACL delete operation has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecACLReplaceFailed)
+            XCTAssertEqual(status, .ACLReplaceFailed)
+            XCTAssertEqual(status?.description, "An ACL replace operation has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecACLAddFailed)
+            XCTAssertEqual(status, .ACLAddFailed)
+            XCTAssertEqual(status?.description, "An ACL add operation has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecACLChangeFailed)
+            XCTAssertEqual(status, .ACLChangeFailed)
+            XCTAssertEqual(status?.description, "An ACL change operation has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAccessCredentials)
+            XCTAssertEqual(status, .InvalidAccessCredentials)
+            XCTAssertEqual(status?.description, "Invalid access credentials were encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidRecord)
+            XCTAssertEqual(status, .InvalidRecord)
+            XCTAssertEqual(status?.description, "An invalid record was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidACL)
+            XCTAssertEqual(status, .InvalidACL)
+            XCTAssertEqual(status?.description, "An invalid ACL was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidSampleValue)
+            XCTAssertEqual(status, .InvalidSampleValue)
+            XCTAssertEqual(status?.description, "An invalid sample value was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecIncompatibleVersion)
+            XCTAssertEqual(status, .IncompatibleVersion)
+            XCTAssertEqual(status?.description, "An incompatible version was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecPrivilegeNotGranted)
+            XCTAssertEqual(status, .PrivilegeNotGranted)
+            XCTAssertEqual(status?.description, "The privilege was not granted.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidScope)
+            XCTAssertEqual(status, .InvalidScope)
+            XCTAssertEqual(status?.description, "An invalid scope was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecPVCAlreadyConfigured)
+            XCTAssertEqual(status, .PVCAlreadyConfigured)
+            XCTAssertEqual(status?.description, "The PVC is already configured.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidPVC)
+            XCTAssertEqual(status, .InvalidPVC)
+            XCTAssertEqual(status?.description, "An invalid PVC was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecEMMLoadFailed)
+            XCTAssertEqual(status, .EMMLoadFailed)
+            XCTAssertEqual(status?.description, "The EMM load has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecEMMUnloadFailed)
+            XCTAssertEqual(status, .EMMUnloadFailed)
+            XCTAssertEqual(status?.description, "The EMM unload has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecAddinLoadFailed)
+            XCTAssertEqual(status, .AddinLoadFailed)
+            XCTAssertEqual(status?.description, "The add-in load operation has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidKeyRef)
+            XCTAssertEqual(status, .InvalidKeyRef)
+            XCTAssertEqual(status?.description, "An invalid key was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidKeyHierarchy)
+            XCTAssertEqual(status, .InvalidKeyHierarchy)
+            XCTAssertEqual(status?.description, "An invalid key hierarchy was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecAddinUnloadFailed)
+            XCTAssertEqual(status, .AddinUnloadFailed)
+            XCTAssertEqual(status?.description, "The add-in unload operation has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecLibraryReferenceNotFound)
+            XCTAssertEqual(status, .LibraryReferenceNotFound)
+            XCTAssertEqual(status?.description, "A library reference was not found.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAddinFunctionTable)
+            XCTAssertEqual(status, .InvalidAddinFunctionTable)
+            XCTAssertEqual(status?.description, "An invalid add-in function table was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidServiceMask)
+            XCTAssertEqual(status, .InvalidServiceMask)
+            XCTAssertEqual(status?.description, "An invalid service mask was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecModuleNotLoaded)
+            XCTAssertEqual(status, .ModuleNotLoaded)
+            XCTAssertEqual(status?.description, "A module was not loaded.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidSubServiceID)
+            XCTAssertEqual(status, .InvalidSubServiceID)
+            XCTAssertEqual(status?.description, "An invalid subservice ID was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecAttributeNotInContext)
+            XCTAssertEqual(status, .AttributeNotInContext)
+            XCTAssertEqual(status?.description, "An attribute was not in the context.")
+        }
+        do {
+            let status = Status(rawValue: errSecModuleManagerInitializeFailed)
+            XCTAssertEqual(status, .ModuleManagerInitializeFailed)
+            XCTAssertEqual(status?.description, "A module failed to initialize.")
+        }
+        do {
+            let status = Status(rawValue: errSecModuleManagerNotFound)
+            XCTAssertEqual(status, .ModuleManagerNotFound)
+            XCTAssertEqual(status?.description, "A module was not found.")
+        }
+        do {
+            let status = Status(rawValue: errSecEventNotificationCallbackNotFound)
+            XCTAssertEqual(status, .EventNotificationCallbackNotFound)
+            XCTAssertEqual(status?.description, "An event notification callback was not found.")
+        }
+        do {
+            let status = Status(rawValue: errSecInputLengthError)
+            XCTAssertEqual(status, .InputLengthError)
+            XCTAssertEqual(status?.description, "An input length error was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecOutputLengthError)
+            XCTAssertEqual(status, .OutputLengthError)
+            XCTAssertEqual(status?.description, "An output length error was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecPrivilegeNotSupported)
+            XCTAssertEqual(status, .PrivilegeNotSupported)
+            XCTAssertEqual(status?.description, "The privilege is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecDeviceError)
+            XCTAssertEqual(status, .DeviceError)
+            XCTAssertEqual(status?.description, "A device error was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecAttachHandleBusy)
+            XCTAssertEqual(status, .AttachHandleBusy)
+            XCTAssertEqual(status?.description, "The CSP handle was busy.")
+        }
+        do {
+            let status = Status(rawValue: errSecNotLoggedIn)
+            XCTAssertEqual(status, .NotLoggedIn)
+            XCTAssertEqual(status?.description, "You are not logged in.")
+        }
+        do {
+            let status = Status(rawValue: errSecAlgorithmMismatch)
+            XCTAssertEqual(status, .AlgorithmMismatch)
+            XCTAssertEqual(status?.description, "An algorithm mismatch was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecKeyUsageIncorrect)
+            XCTAssertEqual(status, .KeyUsageIncorrect)
+            XCTAssertEqual(status?.description, "The key usage is incorrect.")
+        }
+        do {
+            let status = Status(rawValue: errSecKeyBlobTypeIncorrect)
+            XCTAssertEqual(status, .KeyBlobTypeIncorrect)
+            XCTAssertEqual(status?.description, "The key blob type is incorrect.")
+        }
+        do {
+            let status = Status(rawValue: errSecKeyHeaderInconsistent)
+            XCTAssertEqual(status, .KeyHeaderInconsistent)
+            XCTAssertEqual(status?.description, "The key header is inconsistent.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedKeyFormat)
+            XCTAssertEqual(status, .UnsupportedKeyFormat)
+            XCTAssertEqual(status?.description, "The key header format is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedKeySize)
+            XCTAssertEqual(status, .UnsupportedKeySize)
+            XCTAssertEqual(status?.description, "The key size is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidKeyUsageMask)
+            XCTAssertEqual(status, .InvalidKeyUsageMask)
+            XCTAssertEqual(status?.description, "The key usage mask is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedKeyUsageMask)
+            XCTAssertEqual(status, .UnsupportedKeyUsageMask)
+            XCTAssertEqual(status?.description, "The key usage mask is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidKeyAttributeMask)
+            XCTAssertEqual(status, .InvalidKeyAttributeMask)
+            XCTAssertEqual(status?.description, "The key attribute mask is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedKeyAttributeMask)
+            XCTAssertEqual(status, .UnsupportedKeyAttributeMask)
+            XCTAssertEqual(status?.description, "The key attribute mask is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidKeyLabel)
+            XCTAssertEqual(status, .InvalidKeyLabel)
+            XCTAssertEqual(status?.description, "The key label is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedKeyLabel)
+            XCTAssertEqual(status, .UnsupportedKeyLabel)
+            XCTAssertEqual(status?.description, "The key label is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidKeyFormat)
+            XCTAssertEqual(status, .InvalidKeyFormat)
+            XCTAssertEqual(status?.description, "The key format is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedVectorOfBuffers)
+            XCTAssertEqual(status, .UnsupportedVectorOfBuffers)
+            XCTAssertEqual(status?.description, "The vector of buffers is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidInputVector)
+            XCTAssertEqual(status, .InvalidInputVector)
+            XCTAssertEqual(status?.description, "The input vector is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidOutputVector)
+            XCTAssertEqual(status, .InvalidOutputVector)
+            XCTAssertEqual(status?.description, "The output vector is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidContext)
+            XCTAssertEqual(status, .InvalidContext)
+            XCTAssertEqual(status?.description, "An invalid context was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAlgorithm)
+            XCTAssertEqual(status, .InvalidAlgorithm)
+            XCTAssertEqual(status?.description, "An invalid algorithm was encountered.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeKey)
+            XCTAssertEqual(status, .InvalidAttributeKey)
+            XCTAssertEqual(status?.description, "A key attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeKey)
+            XCTAssertEqual(status, .MissingAttributeKey)
+            XCTAssertEqual(status?.description, "A key attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeInitVector)
+            XCTAssertEqual(status, .InvalidAttributeInitVector)
+            XCTAssertEqual(status?.description, "An init vector attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeInitVector)
+            XCTAssertEqual(status, .MissingAttributeInitVector)
+            XCTAssertEqual(status?.description, "An init vector attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeSalt)
+            XCTAssertEqual(status, .InvalidAttributeSalt)
+            XCTAssertEqual(status?.description, "A salt attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeSalt)
+            XCTAssertEqual(status, .MissingAttributeSalt)
+            XCTAssertEqual(status?.description, "A salt attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributePadding)
+            XCTAssertEqual(status, .InvalidAttributePadding)
+            XCTAssertEqual(status?.description, "A padding attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributePadding)
+            XCTAssertEqual(status, .MissingAttributePadding)
+            XCTAssertEqual(status?.description, "A padding attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeRandom)
+            XCTAssertEqual(status, .InvalidAttributeRandom)
+            XCTAssertEqual(status?.description, "A random number attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeRandom)
+            XCTAssertEqual(status, .MissingAttributeRandom)
+            XCTAssertEqual(status?.description, "A random number attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeSeed)
+            XCTAssertEqual(status, .InvalidAttributeSeed)
+            XCTAssertEqual(status?.description, "A seed attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeSeed)
+            XCTAssertEqual(status, .MissingAttributeSeed)
+            XCTAssertEqual(status?.description, "A seed attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributePassphrase)
+            XCTAssertEqual(status, .InvalidAttributePassphrase)
+            XCTAssertEqual(status?.description, "A passphrase attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributePassphrase)
+            XCTAssertEqual(status, .MissingAttributePassphrase)
+            XCTAssertEqual(status?.description, "A passphrase attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeKeyLength)
+            XCTAssertEqual(status, .InvalidAttributeKeyLength)
+            XCTAssertEqual(status?.description, "A key length attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeKeyLength)
+            XCTAssertEqual(status, .MissingAttributeKeyLength)
+            XCTAssertEqual(status?.description, "A key length attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeBlockSize)
+            XCTAssertEqual(status, .InvalidAttributeBlockSize)
+            XCTAssertEqual(status?.description, "A block size attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeBlockSize)
+            XCTAssertEqual(status, .MissingAttributeBlockSize)
+            XCTAssertEqual(status?.description, "A block size attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeOutputSize)
+            XCTAssertEqual(status, .InvalidAttributeOutputSize)
+            XCTAssertEqual(status?.description, "An output size attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeOutputSize)
+            XCTAssertEqual(status, .MissingAttributeOutputSize)
+            XCTAssertEqual(status?.description, "An output size attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeRounds)
+            XCTAssertEqual(status, .InvalidAttributeRounds)
+            XCTAssertEqual(status?.description, "The number of rounds attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeRounds)
+            XCTAssertEqual(status, .MissingAttributeRounds)
+            XCTAssertEqual(status?.description, "The number of rounds attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAlgorithmParms)
+            XCTAssertEqual(status, .InvalidAlgorithmParms)
+            XCTAssertEqual(status?.description, "An algorithm parameters attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAlgorithmParms)
+            XCTAssertEqual(status, .MissingAlgorithmParms)
+            XCTAssertEqual(status?.description, "An algorithm parameters attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeLabel)
+            XCTAssertEqual(status, .InvalidAttributeLabel)
+            XCTAssertEqual(status?.description, "A label attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeLabel)
+            XCTAssertEqual(status, .MissingAttributeLabel)
+            XCTAssertEqual(status?.description, "A label attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeKeyType)
+            XCTAssertEqual(status, .InvalidAttributeKeyType)
+            XCTAssertEqual(status?.description, "A key type attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeKeyType)
+            XCTAssertEqual(status, .MissingAttributeKeyType)
+            XCTAssertEqual(status?.description, "A key type attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeMode)
+            XCTAssertEqual(status, .InvalidAttributeMode)
+            XCTAssertEqual(status?.description, "A mode attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeMode)
+            XCTAssertEqual(status, .MissingAttributeMode)
+            XCTAssertEqual(status?.description, "A mode attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeEffectiveBits)
+            XCTAssertEqual(status, .InvalidAttributeEffectiveBits)
+            XCTAssertEqual(status?.description, "An effective bits attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeEffectiveBits)
+            XCTAssertEqual(status, .MissingAttributeEffectiveBits)
+            XCTAssertEqual(status?.description, "An effective bits attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeStartDate)
+            XCTAssertEqual(status, .InvalidAttributeStartDate)
+            XCTAssertEqual(status?.description, "A start date attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeStartDate)
+            XCTAssertEqual(status, .MissingAttributeStartDate)
+            XCTAssertEqual(status?.description, "A start date attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeEndDate)
+            XCTAssertEqual(status, .InvalidAttributeEndDate)
+            XCTAssertEqual(status?.description, "An end date attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeEndDate)
+            XCTAssertEqual(status, .MissingAttributeEndDate)
+            XCTAssertEqual(status?.description, "An end date attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeVersion)
+            XCTAssertEqual(status, .InvalidAttributeVersion)
+            XCTAssertEqual(status?.description, "A version attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeVersion)
+            XCTAssertEqual(status, .MissingAttributeVersion)
+            XCTAssertEqual(status?.description, "A version attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributePrime)
+            XCTAssertEqual(status, .InvalidAttributePrime)
+            XCTAssertEqual(status?.description, "A prime attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributePrime)
+            XCTAssertEqual(status, .MissingAttributePrime)
+            XCTAssertEqual(status?.description, "A prime attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeBase)
+            XCTAssertEqual(status, .InvalidAttributeBase)
+            XCTAssertEqual(status?.description, "A base attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeBase)
+            XCTAssertEqual(status, .MissingAttributeBase)
+            XCTAssertEqual(status?.description, "A base attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeSubprime)
+            XCTAssertEqual(status, .InvalidAttributeSubprime)
+            XCTAssertEqual(status?.description, "A subprime attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeSubprime)
+            XCTAssertEqual(status, .MissingAttributeSubprime)
+            XCTAssertEqual(status?.description, "A subprime attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeIterationCount)
+            XCTAssertEqual(status, .InvalidAttributeIterationCount)
+            XCTAssertEqual(status?.description, "An iteration count attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeIterationCount)
+            XCTAssertEqual(status, .MissingAttributeIterationCount)
+            XCTAssertEqual(status?.description, "An iteration count attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeDLDBHandle)
+            XCTAssertEqual(status, .InvalidAttributeDLDBHandle)
+            XCTAssertEqual(status?.description, "A database handle attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeDLDBHandle)
+            XCTAssertEqual(status, .MissingAttributeDLDBHandle)
+            XCTAssertEqual(status?.description, "A database handle attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeAccessCredentials)
+            XCTAssertEqual(status, .InvalidAttributeAccessCredentials)
+            XCTAssertEqual(status?.description, "An access credentials attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeAccessCredentials)
+            XCTAssertEqual(status, .MissingAttributeAccessCredentials)
+            XCTAssertEqual(status?.description, "An access credentials attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributePublicKeyFormat)
+            XCTAssertEqual(status, .InvalidAttributePublicKeyFormat)
+            XCTAssertEqual(status?.description, "A public key format attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributePublicKeyFormat)
+            XCTAssertEqual(status, .MissingAttributePublicKeyFormat)
+            XCTAssertEqual(status?.description, "A public key format attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributePrivateKeyFormat)
+            XCTAssertEqual(status, .InvalidAttributePrivateKeyFormat)
+            XCTAssertEqual(status?.description, "A private key format attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributePrivateKeyFormat)
+            XCTAssertEqual(status, .MissingAttributePrivateKeyFormat)
+            XCTAssertEqual(status?.description, "A private key format attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeSymmetricKeyFormat)
+            XCTAssertEqual(status, .InvalidAttributeSymmetricKeyFormat)
+            XCTAssertEqual(status?.description, "A symmetric key format attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeSymmetricKeyFormat)
+            XCTAssertEqual(status, .MissingAttributeSymmetricKeyFormat)
+            XCTAssertEqual(status?.description, "A symmetric key format attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAttributeWrappedKeyFormat)
+            XCTAssertEqual(status, .InvalidAttributeWrappedKeyFormat)
+            XCTAssertEqual(status?.description, "A wrapped key format attribute was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingAttributeWrappedKeyFormat)
+            XCTAssertEqual(status, .MissingAttributeWrappedKeyFormat)
+            XCTAssertEqual(status?.description, "A wrapped key format attribute was missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecStagedOperationInProgress)
+            XCTAssertEqual(status, .StagedOperationInProgress)
+            XCTAssertEqual(status?.description, "A staged operation is in progress.")
+        }
+        do {
+            let status = Status(rawValue: errSecStagedOperationNotStarted)
+            XCTAssertEqual(status, .StagedOperationNotStarted)
+            XCTAssertEqual(status?.description, "A staged operation was not started.")
+        }
+        do {
+            let status = Status(rawValue: errSecVerifyFailed)
+            XCTAssertEqual(status, .VerifyFailed)
+            XCTAssertEqual(status?.description, "A cryptographic verification failure has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecQuerySizeUnknown)
+            XCTAssertEqual(status, .QuerySizeUnknown)
+            XCTAssertEqual(status?.description, "The query size is unknown.")
+        }
+        do {
+            let status = Status(rawValue: errSecBlockSizeMismatch)
+            XCTAssertEqual(status, .BlockSizeMismatch)
+            XCTAssertEqual(status?.description, "A block size mismatch occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecPublicKeyInconsistent)
+            XCTAssertEqual(status, .PublicKeyInconsistent)
+            XCTAssertEqual(status?.description, "The public key was inconsistent.")
+        }
+        do {
+            let status = Status(rawValue: errSecDeviceVerifyFailed)
+            XCTAssertEqual(status, .DeviceVerifyFailed)
+            XCTAssertEqual(status?.description, "A device verification failure has occurred.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidLoginName)
+            XCTAssertEqual(status, .InvalidLoginName)
+            XCTAssertEqual(status?.description, "An invalid login name was detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecAlreadyLoggedIn)
+            XCTAssertEqual(status, .AlreadyLoggedIn)
+            XCTAssertEqual(status?.description, "The user is already logged in.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidDigestAlgorithm)
+            XCTAssertEqual(status, .InvalidDigestAlgorithm)
+            XCTAssertEqual(status?.description, "An invalid digest algorithm was detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidCRLGroup)
+            XCTAssertEqual(status, .InvalidCRLGroup)
+            XCTAssertEqual(status?.description, "An invalid CRL group was detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecCertificateCannotOperate)
+            XCTAssertEqual(status, .CertificateCannotOperate)
+            XCTAssertEqual(status?.description, "The certificate cannot operate.")
+        }
+        do {
+            let status = Status(rawValue: errSecCertificateExpired)
+            XCTAssertEqual(status, .CertificateExpired)
+            XCTAssertEqual(status?.description, "An expired certificate was detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecCertificateNotValidYet)
+            XCTAssertEqual(status, .CertificateNotValidYet)
+            XCTAssertEqual(status?.description, "The certificate is not yet valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecCertificateRevoked)
+            XCTAssertEqual(status, .CertificateRevoked)
+            XCTAssertEqual(status?.description, "The certificate was revoked.")
+        }
+        do {
+            let status = Status(rawValue: errSecCertificateSuspended)
+            XCTAssertEqual(status, .CertificateSuspended)
+            XCTAssertEqual(status?.description, "The certificate was suspended.")
+        }
+        do {
+            let status = Status(rawValue: errSecInsufficientCredentials)
+            XCTAssertEqual(status, .InsufficientCredentials)
+            XCTAssertEqual(status?.description, "Insufficient credentials were detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAction)
+            XCTAssertEqual(status, .InvalidAction)
+            XCTAssertEqual(status?.description, "The action was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAuthority)
+            XCTAssertEqual(status, .InvalidAuthority)
+            XCTAssertEqual(status?.description, "The authority was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecVerifyActionFailed)
+            XCTAssertEqual(status, .VerifyActionFailed)
+            XCTAssertEqual(status?.description, "A verify action has failed.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidCertAuthority)
+            XCTAssertEqual(status, .InvalidCertAuthority)
+            XCTAssertEqual(status?.description, "The certificate authority was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvaldCRLAuthority)
+            XCTAssertEqual(status, .InvaldCRLAuthority)
+            XCTAssertEqual(status?.description, "The CRL authority was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidCRLEncoding)
+            XCTAssertEqual(status, .InvalidCRLEncoding)
+            XCTAssertEqual(status?.description, "The CRL encoding was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidCRLType)
+            XCTAssertEqual(status, .InvalidCRLType)
+            XCTAssertEqual(status?.description, "The CRL type was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidCRL)
+            XCTAssertEqual(status, .InvalidCRL)
+            XCTAssertEqual(status?.description, "The CRL was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidFormType)
+            XCTAssertEqual(status, .InvalidFormType)
+            XCTAssertEqual(status?.description, "The form type was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidID)
+            XCTAssertEqual(status, .InvalidID)
+            XCTAssertEqual(status?.description, "The ID was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidIdentifier)
+            XCTAssertEqual(status, .InvalidIdentifier)
+            XCTAssertEqual(status?.description, "The identifier was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidIndex)
+            XCTAssertEqual(status, .InvalidIndex)
+            XCTAssertEqual(status?.description, "The index was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidPolicyIdentifiers)
+            XCTAssertEqual(status, .InvalidPolicyIdentifiers)
+            XCTAssertEqual(status?.description, "The policy identifiers are not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidTimeString)
+            XCTAssertEqual(status, .InvalidTimeString)
+            XCTAssertEqual(status?.description, "The time specified was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidReason)
+            XCTAssertEqual(status, .InvalidReason)
+            XCTAssertEqual(status?.description, "The trust policy reason was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidRequestInputs)
+            XCTAssertEqual(status, .InvalidRequestInputs)
+            XCTAssertEqual(status?.description, "The request inputs are not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidResponseVector)
+            XCTAssertEqual(status, .InvalidResponseVector)
+            XCTAssertEqual(status?.description, "The response vector was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidStopOnPolicy)
+            XCTAssertEqual(status, .InvalidStopOnPolicy)
+            XCTAssertEqual(status?.description, "The stop-on policy was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidTuple)
+            XCTAssertEqual(status, .InvalidTuple)
+            XCTAssertEqual(status?.description, "The tuple was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMultipleValuesUnsupported)
+            XCTAssertEqual(status, .MultipleValuesUnsupported)
+            XCTAssertEqual(status?.description, "Multiple values are not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecNotTrusted)
+            XCTAssertEqual(status, .NotTrusted)
+            XCTAssertEqual(status?.description, "The trust policy was not trusted.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoDefaultAuthority)
+            XCTAssertEqual(status, .NoDefaultAuthority)
+            XCTAssertEqual(status?.description, "No default authority was detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecRejectedForm)
+            XCTAssertEqual(status, .RejectedForm)
+            XCTAssertEqual(status?.description, "The trust policy had a rejected form.")
+        }
+        do {
+            let status = Status(rawValue: errSecRequestLost)
+            XCTAssertEqual(status, .RequestLost)
+            XCTAssertEqual(status?.description, "The request was lost.")
+        }
+        do {
+            let status = Status(rawValue: errSecRequestRejected)
+            XCTAssertEqual(status, .RequestRejected)
+            XCTAssertEqual(status?.description, "The request was rejected.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedAddressType)
+            XCTAssertEqual(status, .UnsupportedAddressType)
+            XCTAssertEqual(status?.description, "The address type is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedService)
+            XCTAssertEqual(status, .UnsupportedService)
+            XCTAssertEqual(status?.description, "The service is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidTupleGroup)
+            XCTAssertEqual(status, .InvalidTupleGroup)
+            XCTAssertEqual(status?.description, "The tuple group was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidBaseACLs)
+            XCTAssertEqual(status, .InvalidBaseACLs)
+            XCTAssertEqual(status?.description, "The base ACLs are not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidTupleCredendtials)
+            XCTAssertEqual(status, .InvalidTupleCredendtials)
+            XCTAssertEqual(status?.description, "The tuple credentials are not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidEncoding)
+            XCTAssertEqual(status, .InvalidEncoding)
+            XCTAssertEqual(status?.description, "The encoding was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidValidityPeriod)
+            XCTAssertEqual(status, .InvalidValidityPeriod)
+            XCTAssertEqual(status?.description, "The validity period was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidRequestor)
+            XCTAssertEqual(status, .InvalidRequestor)
+            XCTAssertEqual(status?.description, "The requestor was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecRequestDescriptor)
+            XCTAssertEqual(status, .RequestDescriptor)
+            XCTAssertEqual(status?.description, "The request descriptor was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidBundleInfo)
+            XCTAssertEqual(status, .InvalidBundleInfo)
+            XCTAssertEqual(status?.description, "The bundle information was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidCRLIndex)
+            XCTAssertEqual(status, .InvalidCRLIndex)
+            XCTAssertEqual(status?.description, "The CRL index was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecNoFieldValues)
+            XCTAssertEqual(status, .NoFieldValues)
+            XCTAssertEqual(status?.description, "No field values were detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedFieldFormat)
+            XCTAssertEqual(status, .UnsupportedFieldFormat)
+            XCTAssertEqual(status?.description, "The field format is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedIndexInfo)
+            XCTAssertEqual(status, .UnsupportedIndexInfo)
+            XCTAssertEqual(status?.description, "The index information is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedLocality)
+            XCTAssertEqual(status, .UnsupportedLocality)
+            XCTAssertEqual(status?.description, "The locality is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedNumAttributes)
+            XCTAssertEqual(status, .UnsupportedNumAttributes)
+            XCTAssertEqual(status?.description, "The number of attributes is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedNumIndexes)
+            XCTAssertEqual(status, .UnsupportedNumIndexes)
+            XCTAssertEqual(status?.description, "The number of indexes is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedNumRecordTypes)
+            XCTAssertEqual(status, .UnsupportedNumRecordTypes)
+            XCTAssertEqual(status?.description, "The number of record types is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecFieldSpecifiedMultiple)
+            XCTAssertEqual(status, .FieldSpecifiedMultiple)
+            XCTAssertEqual(status?.description, "Too many fields were specified.")
+        }
+        do {
+            let status = Status(rawValue: errSecIncompatibleFieldFormat)
+            XCTAssertEqual(status, .IncompatibleFieldFormat)
+            XCTAssertEqual(status?.description, "The field format was incompatible.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidParsingModule)
+            XCTAssertEqual(status, .InvalidParsingModule)
+            XCTAssertEqual(status?.description, "The parsing module was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecDatabaseLocked)
+            XCTAssertEqual(status, .DatabaseLocked)
+            XCTAssertEqual(status?.description, "The database is locked.")
+        }
+        do {
+            let status = Status(rawValue: errSecDatastoreIsOpen)
+            XCTAssertEqual(status, .DatastoreIsOpen)
+            XCTAssertEqual(status?.description, "The data store is open.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingValue)
+            XCTAssertEqual(status, .MissingValue)
+            XCTAssertEqual(status?.description, "A missing value was detected.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedQueryLimits)
+            XCTAssertEqual(status, .UnsupportedQueryLimits)
+            XCTAssertEqual(status?.description, "The query limits are not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedNumSelectionPreds)
+            XCTAssertEqual(status, .UnsupportedNumSelectionPreds)
+            XCTAssertEqual(status?.description, "The number of selection predicates is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecUnsupportedOperator)
+            XCTAssertEqual(status, .UnsupportedOperator)
+            XCTAssertEqual(status?.description, "The operator is not supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidDBLocation)
+            XCTAssertEqual(status, .InvalidDBLocation)
+            XCTAssertEqual(status?.description, "The database location is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidAccessRequest)
+            XCTAssertEqual(status, .InvalidAccessRequest)
+            XCTAssertEqual(status?.description, "The access request is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidIndexInfo)
+            XCTAssertEqual(status, .InvalidIndexInfo)
+            XCTAssertEqual(status?.description, "The index information is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidNewOwner)
+            XCTAssertEqual(status, .InvalidNewOwner)
+            XCTAssertEqual(status?.description, "The new owner is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecInvalidModifyMode)
+            XCTAssertEqual(status, .InvalidModifyMode)
+            XCTAssertEqual(status?.description, "The modify mode is not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecMissingRequiredExtension)
+            XCTAssertEqual(status, .MissingRequiredExtension)
+            XCTAssertEqual(status?.description, "A required certificate extension is missing.")
+        }
+        do {
+            let status = Status(rawValue: errSecExtendedKeyUsageNotCritical)
+            XCTAssertEqual(status, .ExtendedKeyUsageNotCritical)
+            XCTAssertEqual(status?.description, "The extended key usage extension was not marked critical.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampMissing)
+            XCTAssertEqual(status, .TimestampMissing)
+            XCTAssertEqual(status?.description, "A timestamp was expected but was not found.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampInvalid)
+            XCTAssertEqual(status, .TimestampInvalid)
+            XCTAssertEqual(status?.description, "The timestamp was not valid.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampNotTrusted)
+            XCTAssertEqual(status, .TimestampNotTrusted)
+            XCTAssertEqual(status?.description, "The timestamp was not trusted.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampServiceNotAvailable)
+            XCTAssertEqual(status, .TimestampServiceNotAvailable)
+            XCTAssertEqual(status?.description, "The timestamp service is not available.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampBadAlg)
+            XCTAssertEqual(status, .TimestampBadAlg)
+            XCTAssertEqual(status?.description, "An unrecognized or unsupported Algorithm Identifier in timestamp.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampBadRequest)
+            XCTAssertEqual(status, .TimestampBadRequest)
+            XCTAssertEqual(status?.description, "The timestamp transaction is not permitted or supported.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampBadDataFormat)
+            XCTAssertEqual(status, .TimestampBadDataFormat)
+            XCTAssertEqual(status?.description, "The timestamp data submitted has the wrong format.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampTimeNotAvailable)
+            XCTAssertEqual(status, .TimestampTimeNotAvailable)
+            XCTAssertEqual(status?.description, "The time source for the Timestamp Authority is not available.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampUnacceptedPolicy)
+            XCTAssertEqual(status, .TimestampUnacceptedPolicy)
+            XCTAssertEqual(status?.description, "The requested policy is not supported by the Timestamp Authority.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampUnacceptedExtension)
+            XCTAssertEqual(status, .TimestampUnacceptedExtension)
+            XCTAssertEqual(status?.description, "The requested extension is not supported by the Timestamp Authority.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampAddInfoNotAvailable)
+            XCTAssertEqual(status, .TimestampAddInfoNotAvailable)
+            XCTAssertEqual(status?.description, "The additional information requested is not available.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampSystemFailure)
+            XCTAssertEqual(status, .TimestampSystemFailure)
+            XCTAssertEqual(status?.description, "The timestamp request cannot be handled due to system failure.")
+        }
+        do {
+            let status = Status(rawValue: errSecSigningTimeMissing)
+            XCTAssertEqual(status, .SigningTimeMissing)
+            XCTAssertEqual(status?.description, "A signing time was expected but was not found.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampRejection)
+            XCTAssertEqual(status, .TimestampRejection)
+            XCTAssertEqual(status?.description, "A timestamp transaction was rejected.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampWaiting)
+            XCTAssertEqual(status, .TimestampWaiting)
+            XCTAssertEqual(status?.description, "A timestamp transaction is waiting.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampRevocationWarning)
+            XCTAssertEqual(status, .TimestampRevocationWarning)
+            XCTAssertEqual(status?.description, "A timestamp authority revocation warning was issued.")
+        }
+        do {
+            let status = Status(rawValue: errSecTimestampRevocationNotification)
+            XCTAssertEqual(status, .TimestampRevocationNotification)
+            XCTAssertEqual(status?.description, "A timestamp authority revocation notification was issued.")
+        }
+        #endif
+    }
+}