Update for Swift 3.0 & Xcode 8

Examples/Example-iOS/Example-iOS.xcodeproj/project.pbxproj

@@ -301,7 +301,7 @@
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 2.3;
+				SWIFT_VERSION = 3.0;
 			};
 			name = Debug;
 		};
@@ -340,7 +340,7 @@
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = iphoneos;
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
-				SWIFT_VERSION = 2.3;
+				SWIFT_VERSION = 3.0;
 				VALIDATE_PRODUCT = YES;
 			};
 			name = Release;

Examples/Example-iOS/Example-iOS/AccountsViewController.swift

@@ -27,13 +27,13 @@ import UIKit
 import KeychainAccess
 
 class AccountsViewController: UITableViewController {
-    var itemsGroupedByService: [String: [[String: AnyObject]]]?
+    var itemsGroupedByService: [String: [[String: Any]]]?
 
     override func viewDidLoad() {
         super.viewDidLoad()
     }
 
-    override func viewWillAppear(animated: Bool) {
+    override func viewWillAppear(_ animated: Bool) {
         super.viewWillAppear(animated)
 
         reloadData()
@@ -46,7 +46,7 @@ class AccountsViewController: UITableViewController {
 
     // MARK:
 
-    override func numberOfSectionsInTableView(tableView: UITableView) -> Int {
+    override func numberOfSections(in tableView: UITableView) -> Int {
         if itemsGroupedByService != nil {
             let services = Array(itemsGroupedByService!.keys)
             return services.count
@@ -54,7 +54,7 @@ class AccountsViewController: UITableViewController {
         return 0
     }
 
-    override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
+    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
         let services = Array(itemsGroupedByService!.keys)
         let service = services[section]
 
@@ -62,13 +62,13 @@ class AccountsViewController: UITableViewController {
         return items.count
     }
 
-    override func tableView(tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
+    override func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
         let services = Array(itemsGroupedByService!.keys)
         return services[section]
     }
 
-    override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
-        let cell = tableView.dequeueReusableCellWithIdentifier("Cell", forIndexPath: indexPath)
+    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+        let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
 
         let services = Array(itemsGroupedByService!.keys)
         let service = services[indexPath.section]
@@ -82,7 +82,7 @@ class AccountsViewController: UITableViewController {
         return cell
     }
 
-    override func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
+    override func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCellEditingStyle, forRowAt indexPath: IndexPath) {
         let services = Array(itemsGroupedByService!.keys)
         let service = services[indexPath.section]
 
@@ -96,16 +96,16 @@ class AccountsViewController: UITableViewController {
 
         if items.count == 1 {
             reloadData()
-            tableView.deleteSections(NSIndexSet(index: indexPath.section), withRowAnimation: .Automatic)
+            tableView.deleteSections(IndexSet(integer: indexPath.section), with: .automatic)
         } else {
-            tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
+            tableView.deleteRows(at: [indexPath], with: .automatic)
         }
     }
 
     // MARK:
 
     func reloadData() {
-        let items = Keychain.allItems(.GenericPassword)
+        let items = Keychain.allItems(.genericPassword)
         itemsGroupedByService = groupBy(items) { item -> String in
             if let service = item["service"] as? String {
                 return service
@@ -115,8 +115,8 @@ class AccountsViewController: UITableViewController {
     }
 }
 
-private func groupBy<C: CollectionType, K: Hashable>(xs: C, key: C.Generator.Element -> K) -> [K:[C.Generator.Element]] {
-    var gs: [K:[C.Generator.Element]] = [:]
+private func groupBy<C: Collection, K: Hashable>(_ xs: C, key: (C.Iterator.Element) -> K) -> [K:[C.Iterator.Element]] {
+    var gs: [K:[C.Iterator.Element]] = [:]
     for x in xs {
         let k = key(x)
         var ys = gs[k] ?? []

Examples/Example-iOS/Example-iOS/AppDelegate.swift

@@ -29,7 +29,7 @@ import UIKit
 class AppDelegate: UIResponder, UIApplicationDelegate {
     var window: UIWindow?
 
-    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey : Any]? = nil) -> Bool {
         return true
     }
 

Examples/Example-iOS/Example-iOS/InputViewController.swift

@@ -49,31 +49,31 @@ class InputViewController: UITableViewController {
     // MARK:
 
     @IBAction func cancelAction(sender: UIBarButtonItem) {
-        dismissViewControllerAnimated(true, completion: nil)
+        dismiss(animated: true, completion: nil)
     }
 
     @IBAction func saveAction(sender: UIBarButtonItem) {
         let keychain: Keychain
-        if let service = serviceField.text where !service.isEmpty {
+        if let service = serviceField.text, !service.isEmpty {
             keychain = Keychain(service: service)
         } else {
             keychain = Keychain()
         }
         keychain[usernameField.text!] = passwordField.text
 
-        dismissViewControllerAnimated(true, completion: nil)
+        dismiss(animated: true, completion: nil)
     }
 
     @IBAction func editingChanged(sender: UITextField) {
         switch (usernameField.text, passwordField.text) {
         case let (username?, password?):
-            saveButton.enabled = !username.isEmpty && !password.isEmpty
+            saveButton.isEnabled = !username.isEmpty && !password.isEmpty
         case (_?, nil):
-            saveButton.enabled = false
+            saveButton.isEnabled = false
         case (nil, _?):
-            saveButton.enabled = false
+            saveButton.isEnabled = false
         case (nil, nil):
-            saveButton.enabled = false
+            saveButton.isEnabled = false
         }
     }
 

Examples/Playground-iOS.playground/section-1.swift

@@ -13,8 +13,8 @@ var keychain: Keychain
 keychain = Keychain(service: "com.example.github-token")
 
 /* for Internet Password */
-let URL = NSURL(string: "https://github.com")!
-keychain = Keychain(server: URL, protocolType: .HTTPS)
+let url = URL(string: "https://github.com")!
+keychain = Keychain(server: url, protocolType: .https)
 
 
 /**************
@@ -87,7 +87,7 @@ do {
  * Label and Comment
  *******************/
 
-keychain = Keychain(server: NSURL(string: "https://github.com")!, protocolType: .HTTPS)
+keychain = Keychain(server: URL(string: "https://github.com")!, protocolType: .https)
     .label("github.com (kishikawakatsumi)")
     .comment("github access token")
 
@@ -98,11 +98,11 @@ keychain = Keychain(server: NSURL(string: "https://github.com")!, protocolType:
 
 /* for background application */
 let background = Keychain(service: "com.example.github-token")
-    .accessibility(.AfterFirstUnlock)
+    .accessibility(.afterFirstUnlock)
 
 /* for forground application */
 let forground = Keychain(service: "com.example.github-token")
-    .accessibility(.WhenUnlocked)
+    .accessibility(.whenUnlocked)
 
 /* Sharing Keychain Items */
 let shared = Keychain(service: "com.example.github-token", accessGroup: "12ABCD3E4F.shared")
@@ -114,12 +114,12 @@ let iCloud = Keychain(service: "com.example.github-token")
 /* One-Shot configuration change */
 
 try! keychain
-    .accessibility(.AfterFirstUnlock)
+    .accessibility(.afterFirstUnlock)
     .synchronizable(true)
     .set("01234567-89ab-cdef-0123-456789abcdef", key: "kishikawakatsumi")
 
 try! keychain
-    .accessibility(.WhenUnlocked)
+    .accessibility(.whenUnlocked)
     .set("01234567-89ab-cdef-0123-456789abcdef", key: "kishikawakatsumi")
 
 
@@ -128,7 +128,7 @@ try! keychain
  ***********/
 
 /* Display all stored items if print keychain object */
-keychain = Keychain(server: NSURL(string: "https://github.com")!, protocolType: .HTTPS)
+keychain = Keychain(server: URL(string: "https://github.com")!, protocolType: .https)
 print("\(keychain)")
 
 /* Obtaining all stored keys */

Lib/Configurations/Base.xcconfig

@@ -36,4 +36,4 @@ WATCHOS_DEPLOYMENT_TARGET = 2.0;
 TVOS_DEPLOYMENT_TARGET = 9.0;
 MACOSX_DEPLOYMENT_TARGET = 10.9;
 
-SWIFT_VERSION = 2.3;
+SWIFT_VERSION = 3.0;

Lib/Configurations/Release.xcconfig

@@ -5,3 +5,4 @@ DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 ENABLE_NS_ASSERTIONS = NO;
 MTL_ENABLE_DEBUG_INFO = NO;
 VALIDATE_PRODUCT = YES;
+SWIFT_OPTIMIZATION_LEVEL = -Owholemodule;

Lib/KeychainAccessTests/EnumTests.swift

@@ -39,12 +39,12 @@ class EnumTests: XCTestCase {
     func testItemClass() {
         do {
             let itemClass = ItemClass(rawValue: kSecClassGenericPassword as String)
-            XCTAssertEqual(itemClass, .GenericPassword)
+            XCTAssertEqual(itemClass, .genericPassword)
             XCTAssertEqual(itemClass?.description, "GenericPassword")
         }
         do {
             let itemClass = ItemClass(rawValue: kSecClassInternetPassword as String)
-            XCTAssertEqual(itemClass, .InternetPassword)
+            XCTAssertEqual(itemClass, .internetPassword)
             XCTAssertEqual(itemClass?.description, "InternetPassword")
         }
         do {
@@ -64,157 +64,157 @@ class EnumTests: XCTestCase {
     func testProtocolType() {
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolFTP as String)
-            XCTAssertEqual(protocolType, .FTP)
+            XCTAssertEqual(protocolType, .ftp)
             XCTAssertEqual(protocolType?.description, "FTP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolFTPAccount as String)
-            XCTAssertEqual(protocolType, .FTPAccount)
+            XCTAssertEqual(protocolType, .ftpAccount)
             XCTAssertEqual(protocolType?.description, "FTPAccount")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolHTTP as String)
-            XCTAssertEqual(protocolType, .HTTP)
+            XCTAssertEqual(protocolType, .http)
             XCTAssertEqual(protocolType?.description, "HTTP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolIRC as String)
-            XCTAssertEqual(protocolType, .IRC)
+            XCTAssertEqual(protocolType, .irc)
             XCTAssertEqual(protocolType?.description, "IRC")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolNNTP as String)
-            XCTAssertEqual(protocolType, .NNTP)
+            XCTAssertEqual(protocolType, .nntp)
             XCTAssertEqual(protocolType?.description, "NNTP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolPOP3 as String)
-            XCTAssertEqual(protocolType, .POP3)
+            XCTAssertEqual(protocolType, .pop3)
             XCTAssertEqual(protocolType?.description, "POP3")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolSMTP as String)
-            XCTAssertEqual(protocolType, .SMTP)
+            XCTAssertEqual(protocolType, .smtp)
             XCTAssertEqual(protocolType?.description, "SMTP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolSOCKS as String)
-            XCTAssertEqual(protocolType, .SOCKS)
+            XCTAssertEqual(protocolType, .socks)
             XCTAssertEqual(protocolType?.description, "SOCKS")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolIMAP as String)
-            XCTAssertEqual(protocolType, .IMAP)
+            XCTAssertEqual(protocolType, .imap)
             XCTAssertEqual(protocolType?.description, "IMAP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolLDAP as String)
-            XCTAssertEqual(protocolType, .LDAP)
+            XCTAssertEqual(protocolType, .ldap)
             XCTAssertEqual(protocolType?.description, "LDAP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolAppleTalk as String)
-            XCTAssertEqual(protocolType, .AppleTalk)
+            XCTAssertEqual(protocolType, .appleTalk)
             XCTAssertEqual(protocolType?.description, "AppleTalk")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolAFP as String)
-            XCTAssertEqual(protocolType, .AFP)
+            XCTAssertEqual(protocolType, .afp)
             XCTAssertEqual(protocolType?.description, "AFP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolTelnet as String)
-            XCTAssertEqual(protocolType, .Telnet)
+            XCTAssertEqual(protocolType, .telnet)
             XCTAssertEqual(protocolType?.description, "Telnet")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolSSH as String)
-            XCTAssertEqual(protocolType, .SSH)
+            XCTAssertEqual(protocolType, .ssh)
             XCTAssertEqual(protocolType?.description, "SSH")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolFTPS as String)
-            XCTAssertEqual(protocolType, .FTPS)
+            XCTAssertEqual(protocolType, .ftps)
             XCTAssertEqual(protocolType?.description, "FTPS")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolHTTPS as String)
-            XCTAssertEqual(protocolType, .HTTPS)
+            XCTAssertEqual(protocolType, .https)
             XCTAssertEqual(protocolType?.description, "HTTPS")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolHTTPProxy as String)
-            XCTAssertEqual(protocolType, .HTTPProxy)
+            XCTAssertEqual(protocolType, .httpProxy)
             XCTAssertEqual(protocolType?.description, "HTTPProxy")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolHTTPSProxy as String)
-            XCTAssertEqual(protocolType, .HTTPSProxy)
+            XCTAssertEqual(protocolType, .httpsProxy)
             XCTAssertEqual(protocolType?.description, "HTTPSProxy")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolFTPProxy as String)
-            XCTAssertEqual(protocolType, .FTPProxy)
+            XCTAssertEqual(protocolType, .ftpProxy)
             XCTAssertEqual(protocolType?.description, "FTPProxy")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolSMB as String)
-            XCTAssertEqual(protocolType, .SMB)
+            XCTAssertEqual(protocolType, .smb)
             XCTAssertEqual(protocolType?.description, "SMB")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolRTSP as String)
-            XCTAssertEqual(protocolType, .RTSP)
+            XCTAssertEqual(protocolType, .rtsp)
             XCTAssertEqual(protocolType?.description, "RTSP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolRTSPProxy as String)
-            XCTAssertEqual(protocolType, .RTSPProxy)
+            XCTAssertEqual(protocolType, .rtspProxy)
             XCTAssertEqual(protocolType?.description, "RTSPProxy")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolDAAP as String)
-            XCTAssertEqual(protocolType, .DAAP)
+            XCTAssertEqual(protocolType, .daap)
             XCTAssertEqual(protocolType?.description, "DAAP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolEPPC as String)
-            XCTAssertEqual(protocolType, .EPPC)
+            XCTAssertEqual(protocolType, .eppc)
             XCTAssertEqual(protocolType?.description, "EPPC")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolIPP as String)
-            XCTAssertEqual(protocolType, .IPP)
+            XCTAssertEqual(protocolType, .ipp)
             XCTAssertEqual(protocolType?.description, "IPP")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolNNTPS as String)
-            XCTAssertEqual(protocolType, .NNTPS)
+            XCTAssertEqual(protocolType, .nntps)
             XCTAssertEqual(protocolType?.description, "NNTPS")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolLDAPS as String)
-            XCTAssertEqual(protocolType, .LDAPS)
+            XCTAssertEqual(protocolType, .ldaps)
             XCTAssertEqual(protocolType?.description, "LDAPS")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolTelnetS as String)
-            XCTAssertEqual(protocolType, .TelnetS)
+            XCTAssertEqual(protocolType, .telnetS)
             XCTAssertEqual(protocolType?.description, "TelnetS")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolIMAPS as String)
-            XCTAssertEqual(protocolType, .IMAPS)
+            XCTAssertEqual(protocolType, .imaps)
             XCTAssertEqual(protocolType?.description, "IMAPS")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolIRCS as String)
-            XCTAssertEqual(protocolType, .IRCS)
+            XCTAssertEqual(protocolType, .ircs)
             XCTAssertEqual(protocolType?.description, "IRCS")
         }
         do {
             let protocolType = ProtocolType(rawValue: kSecAttrProtocolPOP3S as String)
-            XCTAssertEqual(protocolType, .POP3S)
+            XCTAssertEqual(protocolType, .pop3S)
             XCTAssertEqual(protocolType?.description, "POP3S")
         }
     }
@@ -222,42 +222,42 @@ class EnumTests: XCTestCase {
     func testAuthenticationType() {
         do {
             let authenticationType = AuthenticationType(rawValue: kSecAttrAuthenticationTypeNTLM as String)
-            XCTAssertEqual(authenticationType, .NTLM)
+            XCTAssertEqual(authenticationType, .ntlm)
             XCTAssertEqual(authenticationType?.description, "NTLM")
         }
         do {
             let authenticationType = AuthenticationType(rawValue: kSecAttrAuthenticationTypeMSN as String)
-            XCTAssertEqual(authenticationType, .MSN)
+            XCTAssertEqual(authenticationType, .msn)
             XCTAssertEqual(authenticationType?.description, "MSN")
         }
         do {
             let authenticationType = AuthenticationType(rawValue: kSecAttrAuthenticationTypeDPA as String)
-            XCTAssertEqual(authenticationType, .DPA)
+            XCTAssertEqual(authenticationType, .dpa)
             XCTAssertEqual(authenticationType?.description, "DPA")
         }
         do {
             let authenticationType = AuthenticationType(rawValue: kSecAttrAuthenticationTypeRPA as String)
-            XCTAssertEqual(authenticationType, .RPA)
+            XCTAssertEqual(authenticationType, .rpa)
             XCTAssertEqual(authenticationType?.description, "RPA")
         }
         do {
             let authenticationType = AuthenticationType(rawValue: kSecAttrAuthenticationTypeHTTPBasic as String)
-            XCTAssertEqual(authenticationType, .HTTPBasic)
+            XCTAssertEqual(authenticationType, .httpBasic)
             XCTAssertEqual(authenticationType?.description, "HTTPBasic")
         }
         do {
             let authenticationType = AuthenticationType(rawValue: kSecAttrAuthenticationTypeHTTPDigest as String)
-            XCTAssertEqual(authenticationType, .HTTPDigest)
+            XCTAssertEqual(authenticationType, .httpDigest)
             XCTAssertEqual(authenticationType?.description, "HTTPDigest")
         }
         do {
             let authenticationType = AuthenticationType(rawValue: kSecAttrAuthenticationTypeHTMLForm as String)
-            XCTAssertEqual(authenticationType, .HTMLForm)
+            XCTAssertEqual(authenticationType, .htmlForm)
             XCTAssertEqual(authenticationType?.description, "HTMLForm")
         }
         do {
             let authenticationType = AuthenticationType(rawValue: kSecAttrAuthenticationTypeDefault as String)
-            XCTAssertEqual(authenticationType, .Default)
+            XCTAssertEqual(authenticationType, .default)
             XCTAssertEqual(authenticationType?.description, "Default")
         }
     }
@@ -268,37 +268,37 @@ class EnumTests: XCTestCase {
         }
         do {
             let accessibility = Accessibility(rawValue: kSecAttrAccessibleWhenUnlocked as String)
-            XCTAssertEqual(accessibility, .WhenUnlocked)
+            XCTAssertEqual(accessibility, .whenUnlocked)
             XCTAssertEqual(accessibility?.description, "WhenUnlocked")
         }
         do {
             let accessibility = Accessibility(rawValue: kSecAttrAccessibleAfterFirstUnlock as String)
-            XCTAssertEqual(accessibility, .AfterFirstUnlock)
+            XCTAssertEqual(accessibility, .afterFirstUnlock)
             XCTAssertEqual(accessibility?.description, "AfterFirstUnlock")
         }
         do {
             let accessibility = Accessibility(rawValue: kSecAttrAccessibleAlways as String)
-            XCTAssertEqual(accessibility, .Always)
+            XCTAssertEqual(accessibility, .always)
             XCTAssertEqual(accessibility?.description, "Always")
         }
         do {
             let accessibility = Accessibility(rawValue: kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly as String)
-            XCTAssertEqual(accessibility, .WhenPasscodeSetThisDeviceOnly)
+            XCTAssertEqual(accessibility, .whenPasscodeSetThisDeviceOnly)
             XCTAssertEqual(accessibility?.description, "WhenPasscodeSetThisDeviceOnly")
         }
         do {
             let accessibility = Accessibility(rawValue: kSecAttrAccessibleWhenUnlockedThisDeviceOnly as String)
-            XCTAssertEqual(accessibility, .WhenUnlockedThisDeviceOnly)
+            XCTAssertEqual(accessibility, .whenUnlockedThisDeviceOnly)
             XCTAssertEqual(accessibility?.description, "WhenUnlockedThisDeviceOnly")
         }
         do {
             let accessibility = Accessibility(rawValue: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly as String)
-            XCTAssertEqual(accessibility, .AfterFirstUnlockThisDeviceOnly)
+            XCTAssertEqual(accessibility, .afterFirstUnlockThisDeviceOnly)
             XCTAssertEqual(accessibility?.description, "AfterFirstUnlockThisDeviceOnly")
         }
         do {
             let accessibility = Accessibility(rawValue: kSecAttrAccessibleAlwaysThisDeviceOnly as String)
-            XCTAssertEqual(accessibility, .AlwaysThisDeviceOnly)
+            XCTAssertEqual(accessibility, .alwaysThisDeviceOnly)
             XCTAssertEqual(accessibility?.description, "AlwaysThisDeviceOnly")
         }
     }

Lib/KeychainAccessTests/ErrorTypeTests.swift

@@ -39,2062 +39,2062 @@ class ErrorTypeTests: XCTestCase {
     func testErrorType() {
         do {
             let status = Status(rawValue: errSecSuccess)
-            XCTAssertEqual(status, .Success)
+            XCTAssertEqual(status, .success)
             XCTAssertEqual(status?.description, "No error.")
         }
         do {
             let status = Status(rawValue: errSecUnimplemented)
-            XCTAssertEqual(status, .Unimplemented)
+            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, .diskFull)
             XCTAssertEqual(status?.description, "The disk is full.")
         }
         #endif
         do {
             let status = Status(rawValue: errSecIO)
-            XCTAssertEqual(status, .IO)
+            XCTAssertEqual(status, .io)
             XCTAssertEqual(status?.description, "I/O error (bummers)")
         }
         #if os(iOS)
         do {
             let status = Status(rawValue: errSecOpWr)
-            XCTAssertEqual(status, .OpWr)
+            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, .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, .wrPerm)
             XCTAssertEqual(status?.description, "write permissions error")
         }
         #endif
         do {
             let status = Status(rawValue: errSecAllocate)
-            XCTAssertEqual(status, .Allocate)
+            XCTAssertEqual(status, .allocate)
             XCTAssertEqual(status?.description, "Failed to allocate memory.")
         }
         do {
             let status = Status(rawValue: errSecUserCanceled)
-            XCTAssertEqual(status, .UserCanceled)
+            XCTAssertEqual(status, .userCanceled)
             XCTAssertEqual(status?.description, "User canceled the operation.")
         }
         do {
             let status = Status(rawValue: errSecBadReq)
-            XCTAssertEqual(status, .BadReq)
+            XCTAssertEqual(status, .badReq)
             XCTAssertEqual(status?.description, "Bad parameter or invalid state for operation.")
         }
         do {
             let status = Status(rawValue: errSecInternalComponent)
-            XCTAssertEqual(status, .InternalComponent)
+            XCTAssertEqual(status, .internalComponent)
             XCTAssertEqual(status?.description, "")
         }
         do {
             let status = Status(rawValue: errSecNotAvailable)
-            XCTAssertEqual(status, .NotAvailable)
+            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, .readOnly)
             XCTAssertEqual(status?.description, "This keychain cannot be modified.")
         }
         #endif
         do {
             let status = Status(rawValue: errSecAuthFailed)
-            XCTAssertEqual(status, .AuthFailed)
+            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, .noSuchKeychain)
             XCTAssertEqual(status?.description, "The specified keychain could not be found.")
         }
         do {
             let status = Status(rawValue: errSecInvalidKeychain)
-            XCTAssertEqual(status, .InvalidKeychain)
+            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, .duplicateKeychain)
             XCTAssertEqual(status?.description, "A keychain with the same name already exists.")
         }
         do {
             let status = Status(rawValue: errSecDuplicateCallback)
-            XCTAssertEqual(status, .DuplicateCallback)
+            XCTAssertEqual(status, .duplicateCallback)
             XCTAssertEqual(status?.description, "The specified callback function is already installed.")
         }
         do {
             let status = Status(rawValue: errSecInvalidCallback)
-            XCTAssertEqual(status, .InvalidCallback)
+            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, .duplicateItem)
             XCTAssertEqual(status?.description, "The specified item already exists in the keychain.")
         }
         do {
             let status = Status(rawValue: errSecItemNotFound)
-            XCTAssertEqual(status, .ItemNotFound)
+            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, .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, .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, .noSuchAttr)
             XCTAssertEqual(status?.description, "The specified attribute does not exist.")
         }
         do {
             let status = Status(rawValue: errSecInvalidItemRef)
-            XCTAssertEqual(status, .InvalidItemRef)
+            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, .invalidSearchRef)
             XCTAssertEqual(status?.description, "Unable to search the current keychain.")
         }
         do {
             let status = Status(rawValue: errSecNoSuchClass)
-            XCTAssertEqual(status, .NoSuchClass)
+            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, .noDefaultKeychain)
             XCTAssertEqual(status?.description, "A default keychain could not be found.")
         }
         #endif
         do {
             let status = Status(rawValue: errSecInteractionNotAllowed)
-            XCTAssertEqual(status, .InteractionNotAllowed)
+            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, .readOnlyAttr)
             XCTAssertEqual(status?.description, "The specified attribute could not be modified.")
         }
         do {
             let status = Status(rawValue: errSecWrongSecVersion)
-            XCTAssertEqual(status, .WrongSecVersion)
+            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, .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, .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, .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, .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, .interactionRequired)
             XCTAssertEqual(status?.description, "User interaction is required, but is currently not allowed.")
         }
         do {
             let status = Status(rawValue: errSecDataNotAvailable)
-            XCTAssertEqual(status, .DataNotAvailable)
+            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, .dataNotModifiable)
             XCTAssertEqual(status?.description, "The contents of this item cannot be modified.")
         }
         do {
             let status = Status(rawValue: errSecCreateChainFailed)
-            XCTAssertEqual(status, .CreateChainFailed)
+            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, .invalidPrefsDomain)
             XCTAssertEqual(status?.description, "The specified preferences domain is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInDarkWake)
-            XCTAssertEqual(status, .InDarkWake)
+            XCTAssertEqual(status, .inDarkWake)
             XCTAssertEqual(status?.description, "In dark wake, no UI possible")
         }
         do {
             let status = Status(rawValue: errSecACLNotSimple)
-            XCTAssertEqual(status, .ACLNotSimple)
+            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, .policyNotFound)
             XCTAssertEqual(status?.description, "The specified policy cannot be found.")
         }
         do {
             let status = Status(rawValue: errSecInvalidTrustSetting)
-            XCTAssertEqual(status, .InvalidTrustSetting)
+            XCTAssertEqual(status, .invalidTrustSetting)
             XCTAssertEqual(status?.description, "The specified trust setting is invalid.")
         }
         do {
             let status = Status(rawValue: errSecNoAccessForItem)
-            XCTAssertEqual(status, .NoAccessForItem)
+            XCTAssertEqual(status, .noAccessForItem)
             XCTAssertEqual(status?.description, "The specified item has no access control.")
         }
         do {
             let status = Status(rawValue: errSecInvalidOwnerEdit)
-            XCTAssertEqual(status, .InvalidOwnerEdit)
+            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, .trustNotAvailable)
             XCTAssertEqual(status?.description, "No trust results are available.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedFormat)
-            XCTAssertEqual(status, .UnsupportedFormat)
+            XCTAssertEqual(status, .unsupportedFormat)
             XCTAssertEqual(status?.description, "Import/Export format unsupported.")
         }
         do {
             let status = Status(rawValue: errSecUnknownFormat)
-            XCTAssertEqual(status, .UnknownFormat)
+            XCTAssertEqual(status, .unknownFormat)
             XCTAssertEqual(status?.description, "Unknown format in import.")
         }
         do {
             let status = Status(rawValue: errSecKeyIsSensitive)
-            XCTAssertEqual(status, .KeyIsSensitive)
+            XCTAssertEqual(status, .keyIsSensitive)
             XCTAssertEqual(status?.description, "Key material must be wrapped for export.")
         }
         do {
             let status = Status(rawValue: errSecMultiplePrivKeys)
-            XCTAssertEqual(status, .MultiplePrivKeys)
+            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, .passphraseRequired)
             XCTAssertEqual(status?.description, "Passphrase is required for import/export.")
         }
         do {
             let status = Status(rawValue: errSecInvalidPasswordRef)
-            XCTAssertEqual(status, .InvalidPasswordRef)
+            XCTAssertEqual(status, .invalidPasswordRef)
             XCTAssertEqual(status?.description, "The password reference was invalid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidTrustSettings)
-            XCTAssertEqual(status, .InvalidTrustSettings)
+            XCTAssertEqual(status, .invalidTrustSettings)
             XCTAssertEqual(status?.description, "The Trust Settings Record was corrupted.")
         }
         do {
             let status = Status(rawValue: errSecNoTrustSettings)
-            XCTAssertEqual(status, .NoTrustSettings)
+            XCTAssertEqual(status, .noTrustSettings)
             XCTAssertEqual(status?.description, "No Trust Settings were found.")
         }
         do {
             let status = Status(rawValue: errSecPkcs12VerifyFailure)
-            XCTAssertEqual(status, .Pkcs12VerifyFailure)
+            XCTAssertEqual(status, .pkcs12VerifyFailure)
             XCTAssertEqual(status?.description, "MAC verification failed during PKCS12 import (wrong password?)")
         }
         do {
             let errSecInvalidCertificate: OSStatus = -26265
             let status = Status(rawValue: errSecInvalidCertificate)
-            XCTAssertEqual(status, .InvalidCertificate)
+            XCTAssertEqual(status, .invalidCertificate)
             XCTAssertEqual(status?.description, "This certificate could not be decoded.")
         }
         do {
             let status = Status(rawValue: errSecNotSigner)
-            XCTAssertEqual(status, .NotSigner)
+            XCTAssertEqual(status, .notSigner)
             XCTAssertEqual(status?.description, "A certificate was not signed by its proposed parent.")
         }
         do {
             let errSecPolicyDenied: OSStatus = -26270
             let status = Status(rawValue: errSecPolicyDenied)
-            XCTAssertEqual(status, .PolicyDenied)
+            XCTAssertEqual(status, .policyDenied)
             XCTAssertEqual(status?.description, "The certificate chain was not trusted due to a policy not accepting it.")
         }
         do {
             let errSecInvalidKey: OSStatus = -26274
             let status = Status(rawValue: errSecInvalidKey)
-            XCTAssertEqual(status, .InvalidKey)
+            XCTAssertEqual(status, .invalidKey)
             XCTAssertEqual(status?.description, "The provided key material was not valid.")
         }
         #endif
         do {
             let status = Status(rawValue: errSecDecode)
-            XCTAssertEqual(status, .Decode)
+            XCTAssertEqual(status, .decode)
             XCTAssertEqual(status?.description, "Unable to decode the provided data.")
         }
         do {
             let errSecInternal: OSStatus = -26276
             let status = Status(rawValue: errSecInternal)
-            XCTAssertEqual(status, .Internal)
+            XCTAssertEqual(status, .internal)
             XCTAssertEqual(status?.description, "An internal error occurred in the Security framework.")
         }
         #if os(OSX)
         do {
             let status = Status(rawValue: errSecServiceNotAvailable)
-            XCTAssertEqual(status, .ServiceNotAvailable)
+            XCTAssertEqual(status, .serviceNotAvailable)
             XCTAssertEqual(status?.description, "The required service is not available.")
         }
         do {
             let errSecUnsupportedAlgorithm: OSStatus = -26268
             let status = Status(rawValue: errSecUnsupportedAlgorithm)
-            XCTAssertEqual(status, .UnsupportedAlgorithm)
+            XCTAssertEqual(status, .unsupportedAlgorithm)
             XCTAssertEqual(status?.description, "An unsupported algorithm was encountered.")
         }
-            do {
+        do {
             let errSecUnsupportedOperation: OSStatus = -26271
             let status = Status(rawValue: errSecUnsupportedOperation)
-            XCTAssertEqual(status, .UnsupportedOperation)
+            XCTAssertEqual(status, .unsupportedOperation)
             XCTAssertEqual(status?.description, "The operation you requested is not supported by this key.")
         }
         do {
             let errSecUnsupportedPadding: OSStatus = -26273
             let status = Status(rawValue: errSecUnsupportedPadding)
-            XCTAssertEqual(status, .UnsupportedPadding)
+            XCTAssertEqual(status, .unsupportedPadding)
             XCTAssertEqual(status?.description, "The padding you requested is not supported.")
         }
         do {
             let errSecItemInvalidKey: OSStatus = -34000
             let status = Status(rawValue: errSecItemInvalidKey)
-            XCTAssertEqual(status, .ItemInvalidKey)
+            XCTAssertEqual(status, .itemInvalidKey)
             XCTAssertEqual(status?.description, "A string key in dictionary is not one of the supported keys.")
         }
         do {
             let errSecItemInvalidKeyType: OSStatus = -34001
             let status = Status(rawValue: errSecItemInvalidKeyType)
-            XCTAssertEqual(status, .ItemInvalidKeyType)
+            XCTAssertEqual(status, .itemInvalidKeyType)
             XCTAssertEqual(status?.description, "A key in a dictionary is neither a CFStringRef nor a CFNumberRef.")
         }
         do {
             let errSecItemInvalidValue: OSStatus = -34002
             let status = Status(rawValue: errSecItemInvalidValue)
-            XCTAssertEqual(status, .ItemInvalidValue)
+            XCTAssertEqual(status, .itemInvalidValue)
             XCTAssertEqual(status?.description, "A value in a dictionary is an invalid (or unsupported) CF type.")
         }
         do {
             let errSecItemClassMissing: OSStatus = -34003
             let status = Status(rawValue: errSecItemClassMissing)
-            XCTAssertEqual(status, .ItemClassMissing)
+            XCTAssertEqual(status, .itemClassMissing)
             XCTAssertEqual(status?.description, "No kSecItemClass key was specified in a dictionary.")
         }
         do {
             let errSecItemMatchUnsupported: OSStatus = -34004
             let status = Status(rawValue: errSecItemMatchUnsupported)
-            XCTAssertEqual(status, .ItemMatchUnsupported)
+            XCTAssertEqual(status, .itemMatchUnsupported)
             XCTAssertEqual(status?.description, "The caller passed one or more kSecMatch keys to a function which does not support matches.")
         }
         do {
             let errSecUseItemListUnsupported: OSStatus = -34005
             let status = Status(rawValue: errSecUseItemListUnsupported)
-            XCTAssertEqual(status, .UseItemListUnsupported)
+            XCTAssertEqual(status, .useItemListUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecUseItemList key to a function which does not support it.")
         }
         do {
             let errSecUseKeychainUnsupported: OSStatus = -34006
             let status = Status(rawValue: errSecUseKeychainUnsupported)
-            XCTAssertEqual(status, .UseKeychainUnsupported)
+            XCTAssertEqual(status, .useKeychainUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecUseKeychain key to a function which does not support it.")
         }
         do {
             let errSecUseKeychainListUnsupported: OSStatus = -34007
             let status = Status(rawValue: errSecUseKeychainListUnsupported)
-            XCTAssertEqual(status, .UseKeychainListUnsupported)
+            XCTAssertEqual(status, .useKeychainListUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecUseKeychainList key to a function which does not support it.")
         }
         do {
             let errSecReturnDataUnsupported: OSStatus = -34008
             let status = Status(rawValue: errSecReturnDataUnsupported)
-            XCTAssertEqual(status, .ReturnDataUnsupported)
+            XCTAssertEqual(status, .returnDataUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecReturnData key to a function which does not support it.")
         }
         do {
             let errSecReturnAttributesUnsupported: OSStatus = -34009
             let status = Status(rawValue: errSecReturnAttributesUnsupported)
-            XCTAssertEqual(status, .ReturnAttributesUnsupported)
+            XCTAssertEqual(status, .returnAttributesUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecReturnAttributes key to a function which does not support it.")
         }
         do {
             let errSecReturnRefUnsupported: OSStatus = -34010
             let status = Status(rawValue: errSecReturnRefUnsupported)
-            XCTAssertEqual(status, .ReturnRefUnsupported)
+            XCTAssertEqual(status, .returnRefUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecReturnRef key to a function which does not support it.")
         }
         do {
             let errSecReturnPersitentRefUnsupported: OSStatus = -34011
             let status = Status(rawValue: errSecReturnPersitentRefUnsupported)
-            XCTAssertEqual(status, .ReturnPersitentRefUnsupported)
+            XCTAssertEqual(status, .returnPersitentRefUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecReturnPersistentRef key to a function which does not support it.")
         }
         do {
             let errSecValueRefUnsupported: OSStatus = -34012
             let status = Status(rawValue: errSecValueRefUnsupported)
-            XCTAssertEqual(status, .ValueRefUnsupported)
+            XCTAssertEqual(status, .valueRefUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecValueRef key to a function which does not support it.")
         }
         do {
             let errSecValuePersistentRefUnsupported: OSStatus = -34013
             let status = Status(rawValue: errSecValuePersistentRefUnsupported)
-            XCTAssertEqual(status, .ValuePersistentRefUnsupported)
+            XCTAssertEqual(status, .valuePersistentRefUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecValuePersistentRef key to a function which does not support it.")
         }
         do {
             let errSecReturnMissingPointer: OSStatus = -34014
             let status = Status(rawValue: errSecReturnMissingPointer)
-            XCTAssertEqual(status, .ReturnMissingPointer)
+            XCTAssertEqual(status, .returnMissingPointer)
             XCTAssertEqual(status?.description, "The caller passed asked for something to be returned but did not pass in a result pointer.")
         }
         do {
             let errSecMatchLimitUnsupported: OSStatus = -34015
             let status = Status(rawValue: errSecMatchLimitUnsupported)
-            XCTAssertEqual(status, .MatchLimitUnsupported)
+            XCTAssertEqual(status, .matchLimitUnsupported)
             XCTAssertEqual(status?.description, "The caller passed in a kSecMatchLimit key to a call which does not support limits.")
         }
         do {
             let errSecItemIllegalQuery: OSStatus = -34016
             let status = Status(rawValue: errSecItemIllegalQuery)
-            XCTAssertEqual(status, .ItemIllegalQuery)
+            XCTAssertEqual(status, .itemIllegalQuery)
             XCTAssertEqual(status?.description, "The caller passed in a query which contained too many keys.")
         }
         do {
             let errSecWaitForCallback: OSStatus = -34017
             let status = Status(rawValue: errSecWaitForCallback)
-            XCTAssertEqual(status, .WaitForCallback)
+            XCTAssertEqual(status, .waitForCallback)
             XCTAssertEqual(status?.description, "This operation is incomplete, until the callback is invoked (not an error).")
         }
         do {
             let errSecMissingEntitlement: OSStatus = -34018
             let status = Status(rawValue: errSecMissingEntitlement)
-            XCTAssertEqual(status, .MissingEntitlement)
+            XCTAssertEqual(status, .missingEntitlement)
             XCTAssertEqual(status?.description, "Internal error when a required entitlement isn't present, client has neither application-identifier nor keychain-access-groups entitlements.")
         }
         do {
             let errSecUpgradePending: OSStatus = -34019
             let status = Status(rawValue: errSecUpgradePending)
-            XCTAssertEqual(status, .UpgradePending)
+            XCTAssertEqual(status, .upgradePending)
             XCTAssertEqual(status?.description, "Error returned if keychain database needs a schema migration but the device is locked, clients should wait for a device unlock notification and retry the command.")
         }
         do {
             let errSecMPSignatureInvalid: OSStatus = -25327
             let status = Status(rawValue: errSecMPSignatureInvalid)
-            XCTAssertEqual(status, .MPSignatureInvalid)
+            XCTAssertEqual(status, .mpSignatureInvalid)
             XCTAssertEqual(status?.description, "Signature invalid on MP message")
         }
         do {
             let errSecOTRTooOld: OSStatus = -25328
             let status = Status(rawValue: errSecOTRTooOld)
-            XCTAssertEqual(status, .OTRTooOld)
+            XCTAssertEqual(status, .otrTooOld)
             XCTAssertEqual(status?.description, "Message is too old to use")
         }
         do {
             let errSecOTRIDTooNew: OSStatus = -25329
             let status = Status(rawValue: errSecOTRIDTooNew)
-            XCTAssertEqual(status, .OTRIDTooNew)
+            XCTAssertEqual(status, .otrIDTooNew)
             XCTAssertEqual(status?.description, "Key ID is too new to use! Message from the future?")
         }
         do {
             let status = Status(rawValue: errSecInsufficientClientID)
-            XCTAssertEqual(status, .InsufficientClientID)
+            XCTAssertEqual(status, .insufficientClientID)
             XCTAssertEqual(status?.description, "The client ID is not correct.")
         }
         do {
             let status = Status(rawValue: errSecDeviceReset)
-            XCTAssertEqual(status, .DeviceReset)
+            XCTAssertEqual(status, .deviceReset)
             XCTAssertEqual(status?.description, "A device reset has occurred.")
         }
         do {
             let status = Status(rawValue: errSecDeviceFailed)
-            XCTAssertEqual(status, .DeviceFailed)
+            XCTAssertEqual(status, .deviceFailed)
             XCTAssertEqual(status?.description, "A device failure has occurred.")
         }
         do {
             let status = Status(rawValue: errSecAppleAddAppACLSubject)
-            XCTAssertEqual(status, .AppleAddAppACLSubject)
+            XCTAssertEqual(status, .appleAddAppACLSubject)
             XCTAssertEqual(status?.description, "Adding an application ACL subject failed.")
         }
         do {
             let status = Status(rawValue: errSecApplePublicKeyIncomplete)
-            XCTAssertEqual(status, .ApplePublicKeyIncomplete)
+            XCTAssertEqual(status, .applePublicKeyIncomplete)
             XCTAssertEqual(status?.description, "The public key is incomplete.")
         }
         do {
             let status = Status(rawValue: errSecAppleSignatureMismatch)
-            XCTAssertEqual(status, .AppleSignatureMismatch)
+            XCTAssertEqual(status, .appleSignatureMismatch)
             XCTAssertEqual(status?.description, "A signature mismatch has occurred.")
         }
         do {
             let status = Status(rawValue: errSecAppleInvalidKeyStartDate)
-            XCTAssertEqual(status, .AppleInvalidKeyStartDate)
+            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, .appleInvalidKeyEndDate)
             XCTAssertEqual(status?.description, "The specified key has an invalid end date.")
         }
         do {
             let status = Status(rawValue: errSecConversionError)
-            XCTAssertEqual(status, .ConversionError)
+            XCTAssertEqual(status, .conversionError)
             XCTAssertEqual(status?.description, "A conversion error has occurred.")
         }
         do {
             let status = Status(rawValue: errSecAppleSSLv2Rollback)
-            XCTAssertEqual(status, .AppleSSLv2Rollback)
+            XCTAssertEqual(status, .appleSSLv2Rollback)
             XCTAssertEqual(status?.description, "A SSLv2 rollback error has occurred.")
         }
         do {
             let status = Status(rawValue: errSecDiskFull)
-            XCTAssertEqual(status, .DiskFull)
+            XCTAssertEqual(status, .diskFull)
             XCTAssertEqual(status?.description, "The disk is full.")
         }
         do {
             let status = Status(rawValue: errSecQuotaExceeded)
-            XCTAssertEqual(status, .QuotaExceeded)
+            XCTAssertEqual(status, .quotaExceeded)
             XCTAssertEqual(status?.description, "The quota was exceeded.")
         }
         do {
             let status = Status(rawValue: errSecFileTooBig)
-            XCTAssertEqual(status, .FileTooBig)
+            XCTAssertEqual(status, .fileTooBig)
             XCTAssertEqual(status?.description, "The file is too big.")
         }
         do {
             let status = Status(rawValue: errSecInvalidDatabaseBlob)
-            XCTAssertEqual(status, .InvalidDatabaseBlob)
+            XCTAssertEqual(status, .invalidDatabaseBlob)
             XCTAssertEqual(status?.description, "The specified database has an invalid blob.")
         }
         do {
             let status = Status(rawValue: errSecInvalidKeyBlob)
-            XCTAssertEqual(status, .InvalidKeyBlob)
+            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, .incompatibleDatabaseBlob)
             XCTAssertEqual(status?.description, "The specified database has an incompatible blob.")
         }
         do {
             let status = Status(rawValue: errSecIncompatibleKeyBlob)
-            XCTAssertEqual(status, .IncompatibleKeyBlob)
+            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, .hostNameMismatch)
             XCTAssertEqual(status?.description, "A host name mismatch has occurred.")
         }
         do {
             let status = Status(rawValue: errSecUnknownCriticalExtensionFlag)
-            XCTAssertEqual(status, .UnknownCriticalExtensionFlag)
+            XCTAssertEqual(status, .unknownCriticalExtensionFlag)
             XCTAssertEqual(status?.description, "There is an unknown critical extension flag.")
         }
         do {
             let status = Status(rawValue: errSecNoBasicConstraints)
-            XCTAssertEqual(status, .NoBasicConstraints)
+            XCTAssertEqual(status, .noBasicConstraints)
             XCTAssertEqual(status?.description, "No basic constraints were found.")
         }
         do {
             let status = Status(rawValue: errSecNoBasicConstraintsCA)
-            XCTAssertEqual(status, .NoBasicConstraintsCA)
+            XCTAssertEqual(status, .noBasicConstraintsCA)
             XCTAssertEqual(status?.description, "No basic CA constraints were found.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAuthorityKeyID)
-            XCTAssertEqual(status, .InvalidAuthorityKeyID)
+            XCTAssertEqual(status, .invalidAuthorityKeyID)
             XCTAssertEqual(status?.description, "The authority key ID is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidSubjectKeyID)
-            XCTAssertEqual(status, .InvalidSubjectKeyID)
+            XCTAssertEqual(status, .invalidSubjectKeyID)
             XCTAssertEqual(status?.description, "The subject key ID is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidKeyUsageForPolicy)
-            XCTAssertEqual(status, .InvalidKeyUsageForPolicy)
+            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, .invalidExtendedKeyUsage)
             XCTAssertEqual(status?.description, "The extended key usage is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidIDLinkage)
-            XCTAssertEqual(status, .InvalidIDLinkage)
+            XCTAssertEqual(status, .invalidIDLinkage)
             XCTAssertEqual(status?.description, "The ID linkage is not valid.")
         }
         do {
             let status = Status(rawValue: errSecPathLengthConstraintExceeded)
-            XCTAssertEqual(status, .PathLengthConstraintExceeded)
+            XCTAssertEqual(status, .pathLengthConstraintExceeded)
             XCTAssertEqual(status?.description, "The path length constraint was exceeded.")
         }
         do {
             let status = Status(rawValue: errSecInvalidRoot)
-            XCTAssertEqual(status, .InvalidRoot)
+            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, .crlExpired)
             XCTAssertEqual(status?.description, "The CRL has expired.")
         }
         do {
             let status = Status(rawValue: errSecCRLNotValidYet)
-            XCTAssertEqual(status, .CRLNotValidYet)
+            XCTAssertEqual(status, .crlNotValidYet)
             XCTAssertEqual(status?.description, "The CRL is not yet valid.")
         }
         do {
             let status = Status(rawValue: errSecCRLNotFound)
-            XCTAssertEqual(status, .CRLNotFound)
+            XCTAssertEqual(status, .crlNotFound)
             XCTAssertEqual(status?.description, "The CRL was not found.")
         }
         do {
             let status = Status(rawValue: errSecCRLServerDown)
-            XCTAssertEqual(status, .CRLServerDown)
+            XCTAssertEqual(status, .crlServerDown)
             XCTAssertEqual(status?.description, "The CRL server is down.")
         }
         do {
             let status = Status(rawValue: errSecCRLBadURI)
-            XCTAssertEqual(status, .CRLBadURI)
+            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, .unknownCertExtension)
             XCTAssertEqual(status?.description, "An unknown certificate extension was encountered.")
         }
         do {
             let status = Status(rawValue: errSecUnknownCRLExtension)
-            XCTAssertEqual(status, .UnknownCRLExtension)
+            XCTAssertEqual(status, .unknownCRLExtension)
             XCTAssertEqual(status?.description, "An unknown CRL extension was encountered.")
         }
         do {
             let status = Status(rawValue: errSecCRLNotTrusted)
-            XCTAssertEqual(status, .CRLNotTrusted)
+            XCTAssertEqual(status, .crlNotTrusted)
             XCTAssertEqual(status?.description, "The CRL is not trusted.")
         }
         do {
             let status = Status(rawValue: errSecCRLPolicyFailed)
-            XCTAssertEqual(status, .CRLPolicyFailed)
+            XCTAssertEqual(status, .crlPolicyFailed)
             XCTAssertEqual(status?.description, "The CRL policy failed.")
         }
         do {
             let status = Status(rawValue: errSecIDPFailure)
-            XCTAssertEqual(status, .IDPFailure)
+            XCTAssertEqual(status, .idpFailure)
             XCTAssertEqual(status?.description, "The issuing distribution point was not valid.")
         }
         do {
             let status = Status(rawValue: errSecSMIMEEmailAddressesNotFound)
-            XCTAssertEqual(status, .SMIMEEmailAddressesNotFound)
+            XCTAssertEqual(status, .smimeEmailAddressesNotFound)
             XCTAssertEqual(status?.description, "An email address mismatch was encountered.")
         }
         do {
             let status = Status(rawValue: errSecSMIMEBadExtendedKeyUsage)
-            XCTAssertEqual(status, .SMIMEBadExtendedKeyUsage)
+            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, .smimeBadKeyUsage)
             XCTAssertEqual(status?.description, "The key usage is not compatible with SMIME.")
         }
         do {
             let status = Status(rawValue: errSecSMIMEKeyUsageNotCritical)
-            XCTAssertEqual(status, .SMIMEKeyUsageNotCritical)
+            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, .smimeNoEmailAddress)
             XCTAssertEqual(status?.description, "No email address was found in the certificate.")
         }
         do {
             let status = Status(rawValue: errSecSMIMESubjAltNameNotCritical)
-            XCTAssertEqual(status, .SMIMESubjAltNameNotCritical)
+            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, .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, .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, .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, .ocspUnavailable)
             XCTAssertEqual(status?.description, "OCSP service is unavailable.")
         }
         do {
             let status = Status(rawValue: errSecOCSPStatusUnrecognized)
-            XCTAssertEqual(status, .OCSPStatusUnrecognized)
+            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, .endOfData)
             XCTAssertEqual(status?.description, "An end-of-data was detected.")
         }
         do {
             let status = Status(rawValue: errSecIncompleteCertRevocationCheck)
-            XCTAssertEqual(status, .IncompleteCertRevocationCheck)
+            XCTAssertEqual(status, .incompleteCertRevocationCheck)
             XCTAssertEqual(status?.description, "An incomplete certificate revocation check occurred.")
         }
         do {
             let status = Status(rawValue: errSecNetworkFailure)
-            XCTAssertEqual(status, .NetworkFailure)
+            XCTAssertEqual(status, .networkFailure)
             XCTAssertEqual(status?.description, "A network failure occurred.")
         }
         do {
             let status = Status(rawValue: errSecOCSPNotTrustedToAnchor)
-            XCTAssertEqual(status, .OCSPNotTrustedToAnchor)
+            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, .recordModified)
             XCTAssertEqual(status?.description, "The record was modified.")
         }
         do {
             let status = Status(rawValue: errSecOCSPSignatureError)
-            XCTAssertEqual(status, .OCSPSignatureError)
+            XCTAssertEqual(status, .ocspSignatureError)
             XCTAssertEqual(status?.description, "The OCSP response had an invalid signature.")
         }
         do {
             let status = Status(rawValue: errSecOCSPNoSigner)
-            XCTAssertEqual(status, .OCSPNoSigner)
+            XCTAssertEqual(status, .ocspNoSigner)
             XCTAssertEqual(status?.description, "The OCSP response had no signer.")
         }
         do {
             let status = Status(rawValue: errSecOCSPResponderMalformedReq)
-            XCTAssertEqual(status, .OCSPResponderMalformedReq)
+            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, .ocspResponderInternalError)
             XCTAssertEqual(status?.description, "The OCSP responder encountered an internal error.")
         }
         do {
             let status = Status(rawValue: errSecOCSPResponderTryLater)
-            XCTAssertEqual(status, .OCSPResponderTryLater)
+            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, .ocspResponderSignatureRequired)
             XCTAssertEqual(status?.description, "The OCSP responder requires a signature.")
         }
         do {
             let status = Status(rawValue: errSecOCSPResponderUnauthorized)
-            XCTAssertEqual(status, .OCSPResponderUnauthorized)
+            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, .ocspResponseNonceMismatch)
             XCTAssertEqual(status?.description, "The OCSP response nonce did not match the request.")
         }
         do {
             let status = Status(rawValue: errSecCodeSigningBadCertChainLength)
-            XCTAssertEqual(status, .CodeSigningBadCertChainLength)
+            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, .codeSigningNoBasicConstraints)
             XCTAssertEqual(status?.description, "Code signing found no basic constraints.")
         }
         do {
             let status = Status(rawValue: errSecCodeSigningBadPathLengthConstraint)
-            XCTAssertEqual(status, .CodeSigningBadPathLengthConstraint)
+            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, .codeSigningNoExtendedKeyUsage)
             XCTAssertEqual(status?.description, "Code signing found no extended key usage.")
         }
         do {
             let status = Status(rawValue: errSecCodeSigningDevelopment)
-            XCTAssertEqual(status, .CodeSigningDevelopment)
+            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, .resourceSignBadCertChainLength)
             XCTAssertEqual(status?.description, "Resource signing has encountered an incorrect certificate chain length.")
         }
         do {
             let status = Status(rawValue: errSecResourceSignBadExtKeyUsage)
-            XCTAssertEqual(status, .ResourceSignBadExtKeyUsage)
+            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, .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, .invalidSubjectName)
             XCTAssertEqual(status?.description, "An invalid certificate subject name was encountered.")
         }
         do {
             let status = Status(rawValue: errSecUnknownQualifiedCertStatement)
-            XCTAssertEqual(status, .UnknownQualifiedCertStatement)
+            XCTAssertEqual(status, .unknownQualifiedCertStatement)
             XCTAssertEqual(status?.description, "An unknown qualified certificate statement was encountered.")
         }
         do {
             let status = Status(rawValue: errSecMobileMeRequestQueued)
-            XCTAssertEqual(status, .MobileMeRequestQueued)
+            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, .mobileMeRequestRedirected)
             XCTAssertEqual(status?.description, "The MobileMe request was redirected.")
         }
         do {
             let status = Status(rawValue: errSecMobileMeServerError)
-            XCTAssertEqual(status, .MobileMeServerError)
+            XCTAssertEqual(status, .mobileMeServerError)
             XCTAssertEqual(status?.description, "A MobileMe server error occurred.")
         }
         do {
             let status = Status(rawValue: errSecMobileMeServerNotAvailable)
-            XCTAssertEqual(status, .MobileMeServerNotAvailable)
+            XCTAssertEqual(status, .mobileMeServerNotAvailable)
             XCTAssertEqual(status?.description, "The MobileMe server is not available.")
         }
         do {
             let status = Status(rawValue: errSecMobileMeServerAlreadyExists)
-            XCTAssertEqual(status, .MobileMeServerAlreadyExists)
+            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, .mobileMeServerServiceErr)
             XCTAssertEqual(status?.description, "A MobileMe service error has occurred.")
         }
         do {
             let status = Status(rawValue: errSecMobileMeRequestAlreadyPending)
-            XCTAssertEqual(status, .MobileMeRequestAlreadyPending)
+            XCTAssertEqual(status, .mobileMeRequestAlreadyPending)
             XCTAssertEqual(status?.description, "A MobileMe request is already pending.")
         }
         do {
             let status = Status(rawValue: errSecMobileMeNoRequestPending)
-            XCTAssertEqual(status, .MobileMeNoRequestPending)
+            XCTAssertEqual(status, .mobileMeNoRequestPending)
             XCTAssertEqual(status?.description, "MobileMe has no request pending.")
         }
         do {
             let status = Status(rawValue: errSecMobileMeCSRVerifyFailure)
-            XCTAssertEqual(status, .MobileMeCSRVerifyFailure)
+            XCTAssertEqual(status, .mobileMeCSRVerifyFailure)
             XCTAssertEqual(status?.description, "A MobileMe CSR verification failure has occurred.")
         }
         do {
             let status = Status(rawValue: errSecMobileMeFailedConsistencyCheck)
-            XCTAssertEqual(status, .MobileMeFailedConsistencyCheck)
+            XCTAssertEqual(status, .mobileMeFailedConsistencyCheck)
             XCTAssertEqual(status?.description, "MobileMe has found a failed consistency check.")
         }
         do {
             let status = Status(rawValue: errSecNotInitialized)
-            XCTAssertEqual(status, .NotInitialized)
+            XCTAssertEqual(status, .notInitialized)
             XCTAssertEqual(status?.description, "A function was called without initializing CSSM.")
         }
         do {
             let status = Status(rawValue: errSecInvalidHandleUsage)
-            XCTAssertEqual(status, .InvalidHandleUsage)
+            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, .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, .functionIntegrityFail)
             XCTAssertEqual(status?.description, "A function address was not within the verified module.")
         }
         do {
             let status = Status(rawValue: errSecInternalError)
-            XCTAssertEqual(status, .InternalError)
+            XCTAssertEqual(status, .internalError)
             XCTAssertEqual(status?.description, "An internal error has occurred.")
         }
         do {
             let status = Status(rawValue: errSecMemoryError)
-            XCTAssertEqual(status, .MemoryError)
+            XCTAssertEqual(status, .memoryError)
             XCTAssertEqual(status?.description, "A memory error has occurred.")
         }
         do {
             let status = Status(rawValue: errSecInvalidData)
-            XCTAssertEqual(status, .InvalidData)
+            XCTAssertEqual(status, .invalidData)
             XCTAssertEqual(status?.description, "Invalid data was encountered.")
         }
         do {
             let status = Status(rawValue: errSecMDSError)
-            XCTAssertEqual(status, .MDSError)
+            XCTAssertEqual(status, .mdsError)
             XCTAssertEqual(status?.description, "A Module Directory Service error has occurred.")
         }
         do {
             let status = Status(rawValue: errSecInvalidPointer)
-            XCTAssertEqual(status, .InvalidPointer)
+            XCTAssertEqual(status, .invalidPointer)
             XCTAssertEqual(status?.description, "An invalid pointer was encountered.")
         }
         do {
             let status = Status(rawValue: errSecSelfCheckFailed)
-            XCTAssertEqual(status, .SelfCheckFailed)
+            XCTAssertEqual(status, .selfCheckFailed)
             XCTAssertEqual(status?.description, "Self-check has failed.")
         }
         do {
             let status = Status(rawValue: errSecFunctionFailed)
-            XCTAssertEqual(status, .FunctionFailed)
+            XCTAssertEqual(status, .functionFailed)
             XCTAssertEqual(status?.description, "A function has failed.")
         }
         do {
             let status = Status(rawValue: errSecModuleManifestVerifyFailed)
-            XCTAssertEqual(status, .ModuleManifestVerifyFailed)
+            XCTAssertEqual(status, .moduleManifestVerifyFailed)
             XCTAssertEqual(status?.description, "A module manifest verification failure has occurred.")
         }
         do {
             let status = Status(rawValue: errSecInvalidGUID)
-            XCTAssertEqual(status, .InvalidGUID)
+            XCTAssertEqual(status, .invalidGUID)
             XCTAssertEqual(status?.description, "An invalid GUID was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidHandle)
-            XCTAssertEqual(status, .InvalidHandle)
+            XCTAssertEqual(status, .invalidHandle)
             XCTAssertEqual(status?.description, "An invalid handle was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidDBList)
-            XCTAssertEqual(status, .InvalidDBList)
+            XCTAssertEqual(status, .invalidDBList)
             XCTAssertEqual(status?.description, "An invalid DB list was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidPassthroughID)
-            XCTAssertEqual(status, .InvalidPassthroughID)
+            XCTAssertEqual(status, .invalidPassthroughID)
             XCTAssertEqual(status?.description, "An invalid passthrough ID was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidNetworkAddress)
-            XCTAssertEqual(status, .InvalidNetworkAddress)
+            XCTAssertEqual(status, .invalidNetworkAddress)
             XCTAssertEqual(status?.description, "An invalid network address was encountered.")
         }
         do {
             let status = Status(rawValue: errSecCRLAlreadySigned)
-            XCTAssertEqual(status, .CRLAlreadySigned)
+            XCTAssertEqual(status, .crlAlreadySigned)
             XCTAssertEqual(status?.description, "The certificate revocation list is already signed.")
         }
         do {
             let status = Status(rawValue: errSecInvalidNumberOfFields)
-            XCTAssertEqual(status, .InvalidNumberOfFields)
+            XCTAssertEqual(status, .invalidNumberOfFields)
             XCTAssertEqual(status?.description, "An invalid number of fields were encountered.")
         }
         do {
             let status = Status(rawValue: errSecVerificationFailure)
-            XCTAssertEqual(status, .VerificationFailure)
+            XCTAssertEqual(status, .verificationFailure)
             XCTAssertEqual(status?.description, "A verification failure occurred.")
         }
         do {
             let status = Status(rawValue: errSecUnknownTag)
-            XCTAssertEqual(status, .UnknownTag)
+            XCTAssertEqual(status, .unknownTag)
             XCTAssertEqual(status?.description, "An unknown tag was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidSignature)
-            XCTAssertEqual(status, .InvalidSignature)
+            XCTAssertEqual(status, .invalidSignature)
             XCTAssertEqual(status?.description, "An invalid signature was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidName)
-            XCTAssertEqual(status, .InvalidName)
+            XCTAssertEqual(status, .invalidName)
             XCTAssertEqual(status?.description, "An invalid name was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidCertificateRef)
-            XCTAssertEqual(status, .InvalidCertificateRef)
+            XCTAssertEqual(status, .invalidCertificateRef)
             XCTAssertEqual(status?.description, "An invalid certificate reference was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidCertificateGroup)
-            XCTAssertEqual(status, .InvalidCertificateGroup)
+            XCTAssertEqual(status, .invalidCertificateGroup)
             XCTAssertEqual(status?.description, "An invalid certificate group was encountered.")
         }
         do {
             let status = Status(rawValue: errSecTagNotFound)
-            XCTAssertEqual(status, .TagNotFound)
+            XCTAssertEqual(status, .tagNotFound)
             XCTAssertEqual(status?.description, "The specified tag was not found.")
         }
         do {
             let status = Status(rawValue: errSecInvalidQuery)
-            XCTAssertEqual(status, .InvalidQuery)
+            XCTAssertEqual(status, .invalidQuery)
             XCTAssertEqual(status?.description, "The specified query was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidValue)
-            XCTAssertEqual(status, .InvalidValue)
+            XCTAssertEqual(status, .invalidValue)
             XCTAssertEqual(status?.description, "An invalid value was detected.")
         }
         do {
             let status = Status(rawValue: errSecCallbackFailed)
-            XCTAssertEqual(status, .CallbackFailed)
+            XCTAssertEqual(status, .callbackFailed)
             XCTAssertEqual(status?.description, "A callback has failed.")
         }
         do {
             let status = Status(rawValue: errSecACLDeleteFailed)
-            XCTAssertEqual(status, .ACLDeleteFailed)
+            XCTAssertEqual(status, .aclDeleteFailed)
             XCTAssertEqual(status?.description, "An ACL delete operation has failed.")
         }
         do {
             let status = Status(rawValue: errSecACLReplaceFailed)
-            XCTAssertEqual(status, .ACLReplaceFailed)
+            XCTAssertEqual(status, .aclReplaceFailed)
             XCTAssertEqual(status?.description, "An ACL replace operation has failed.")
         }
         do {
             let status = Status(rawValue: errSecACLAddFailed)
-            XCTAssertEqual(status, .ACLAddFailed)
+            XCTAssertEqual(status, .aclAddFailed)
             XCTAssertEqual(status?.description, "An ACL add operation has failed.")
         }
         do {
             let status = Status(rawValue: errSecACLChangeFailed)
-            XCTAssertEqual(status, .ACLChangeFailed)
+            XCTAssertEqual(status, .aclChangeFailed)
             XCTAssertEqual(status?.description, "An ACL change operation has failed.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAccessCredentials)
-            XCTAssertEqual(status, .InvalidAccessCredentials)
+            XCTAssertEqual(status, .invalidAccessCredentials)
             XCTAssertEqual(status?.description, "Invalid access credentials were encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidRecord)
-            XCTAssertEqual(status, .InvalidRecord)
+            XCTAssertEqual(status, .invalidRecord)
             XCTAssertEqual(status?.description, "An invalid record was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidACL)
-            XCTAssertEqual(status, .InvalidACL)
+            XCTAssertEqual(status, .invalidACL)
             XCTAssertEqual(status?.description, "An invalid ACL was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidSampleValue)
-            XCTAssertEqual(status, .InvalidSampleValue)
+            XCTAssertEqual(status, .invalidSampleValue)
             XCTAssertEqual(status?.description, "An invalid sample value was encountered.")
         }
         do {
             let status = Status(rawValue: errSecIncompatibleVersion)
-            XCTAssertEqual(status, .IncompatibleVersion)
+            XCTAssertEqual(status, .incompatibleVersion)
             XCTAssertEqual(status?.description, "An incompatible version was encountered.")
         }
         do {
             let status = Status(rawValue: errSecPrivilegeNotGranted)
-            XCTAssertEqual(status, .PrivilegeNotGranted)
+            XCTAssertEqual(status, .privilegeNotGranted)
             XCTAssertEqual(status?.description, "The privilege was not granted.")
         }
         do {
             let status = Status(rawValue: errSecInvalidScope)
-            XCTAssertEqual(status, .InvalidScope)
+            XCTAssertEqual(status, .invalidScope)
             XCTAssertEqual(status?.description, "An invalid scope was encountered.")
         }
         do {
             let status = Status(rawValue: errSecPVCAlreadyConfigured)
-            XCTAssertEqual(status, .PVCAlreadyConfigured)
+            XCTAssertEqual(status, .pvcAlreadyConfigured)
             XCTAssertEqual(status?.description, "The PVC is already configured.")
         }
         do {
             let status = Status(rawValue: errSecInvalidPVC)
-            XCTAssertEqual(status, .InvalidPVC)
+            XCTAssertEqual(status, .invalidPVC)
             XCTAssertEqual(status?.description, "An invalid PVC was encountered.")
         }
         do {
             let status = Status(rawValue: errSecEMMLoadFailed)
-            XCTAssertEqual(status, .EMMLoadFailed)
+            XCTAssertEqual(status, .emmLoadFailed)
             XCTAssertEqual(status?.description, "The EMM load has failed.")
         }
         do {
             let status = Status(rawValue: errSecEMMUnloadFailed)
-            XCTAssertEqual(status, .EMMUnloadFailed)
+            XCTAssertEqual(status, .emmUnloadFailed)
             XCTAssertEqual(status?.description, "The EMM unload has failed.")
         }
         do {
             let status = Status(rawValue: errSecAddinLoadFailed)
-            XCTAssertEqual(status, .AddinLoadFailed)
+            XCTAssertEqual(status, .addinLoadFailed)
             XCTAssertEqual(status?.description, "The add-in load operation has failed.")
         }
         do {
             let status = Status(rawValue: errSecInvalidKeyRef)
-            XCTAssertEqual(status, .InvalidKeyRef)
+            XCTAssertEqual(status, .invalidKeyRef)
             XCTAssertEqual(status?.description, "An invalid key was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidKeyHierarchy)
-            XCTAssertEqual(status, .InvalidKeyHierarchy)
+            XCTAssertEqual(status, .invalidKeyHierarchy)
             XCTAssertEqual(status?.description, "An invalid key hierarchy was encountered.")
         }
         do {
             let status = Status(rawValue: errSecAddinUnloadFailed)
-            XCTAssertEqual(status, .AddinUnloadFailed)
+            XCTAssertEqual(status, .addinUnloadFailed)
             XCTAssertEqual(status?.description, "The add-in unload operation has failed.")
         }
         do {
             let status = Status(rawValue: errSecLibraryReferenceNotFound)
-            XCTAssertEqual(status, .LibraryReferenceNotFound)
+            XCTAssertEqual(status, .libraryReferenceNotFound)
             XCTAssertEqual(status?.description, "A library reference was not found.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAddinFunctionTable)
-            XCTAssertEqual(status, .InvalidAddinFunctionTable)
+            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, .invalidServiceMask)
             XCTAssertEqual(status?.description, "An invalid service mask was encountered.")
         }
         do {
             let status = Status(rawValue: errSecModuleNotLoaded)
-            XCTAssertEqual(status, .ModuleNotLoaded)
+            XCTAssertEqual(status, .moduleNotLoaded)
             XCTAssertEqual(status?.description, "A module was not loaded.")
         }
         do {
             let status = Status(rawValue: errSecInvalidSubServiceID)
-            XCTAssertEqual(status, .InvalidSubServiceID)
+            XCTAssertEqual(status, .invalidSubServiceID)
             XCTAssertEqual(status?.description, "An invalid subservice ID was encountered.")
         }
         do {
             let status = Status(rawValue: errSecAttributeNotInContext)
-            XCTAssertEqual(status, .AttributeNotInContext)
+            XCTAssertEqual(status, .attributeNotInContext)
             XCTAssertEqual(status?.description, "An attribute was not in the context.")
         }
         do {
             let status = Status(rawValue: errSecModuleManagerInitializeFailed)
-            XCTAssertEqual(status, .ModuleManagerInitializeFailed)
+            XCTAssertEqual(status, .moduleManagerInitializeFailed)
             XCTAssertEqual(status?.description, "A module failed to initialize.")
         }
         do {
             let status = Status(rawValue: errSecModuleManagerNotFound)
-            XCTAssertEqual(status, .ModuleManagerNotFound)
+            XCTAssertEqual(status, .moduleManagerNotFound)
             XCTAssertEqual(status?.description, "A module was not found.")
         }
         do {
             let status = Status(rawValue: errSecEventNotificationCallbackNotFound)
-            XCTAssertEqual(status, .EventNotificationCallbackNotFound)
+            XCTAssertEqual(status, .eventNotificationCallbackNotFound)
             XCTAssertEqual(status?.description, "An event notification callback was not found.")
         }
         do {
             let status = Status(rawValue: errSecInputLengthError)
-            XCTAssertEqual(status, .InputLengthError)
+            XCTAssertEqual(status, .inputLengthError)
             XCTAssertEqual(status?.description, "An input length error was encountered.")
         }
         do {
             let status = Status(rawValue: errSecOutputLengthError)
-            XCTAssertEqual(status, .OutputLengthError)
+            XCTAssertEqual(status, .outputLengthError)
             XCTAssertEqual(status?.description, "An output length error was encountered.")
         }
         do {
             let status = Status(rawValue: errSecPrivilegeNotSupported)
-            XCTAssertEqual(status, .PrivilegeNotSupported)
+            XCTAssertEqual(status, .privilegeNotSupported)
             XCTAssertEqual(status?.description, "The privilege is not supported.")
         }
         do {
             let status = Status(rawValue: errSecDeviceError)
-            XCTAssertEqual(status, .DeviceError)
+            XCTAssertEqual(status, .deviceError)
             XCTAssertEqual(status?.description, "A device error was encountered.")
         }
         do {
             let status = Status(rawValue: errSecAttachHandleBusy)
-            XCTAssertEqual(status, .AttachHandleBusy)
+            XCTAssertEqual(status, .attachHandleBusy)
             XCTAssertEqual(status?.description, "The CSP handle was busy.")
         }
         do {
             let status = Status(rawValue: errSecNotLoggedIn)
-            XCTAssertEqual(status, .NotLoggedIn)
+            XCTAssertEqual(status, .notLoggedIn)
             XCTAssertEqual(status?.description, "You are not logged in.")
         }
         do {
             let status = Status(rawValue: errSecAlgorithmMismatch)
-            XCTAssertEqual(status, .AlgorithmMismatch)
+            XCTAssertEqual(status, .algorithmMismatch)
             XCTAssertEqual(status?.description, "An algorithm mismatch was encountered.")
         }
         do {
             let status = Status(rawValue: errSecKeyUsageIncorrect)
-            XCTAssertEqual(status, .KeyUsageIncorrect)
+            XCTAssertEqual(status, .keyUsageIncorrect)
             XCTAssertEqual(status?.description, "The key usage is incorrect.")
         }
         do {
             let status = Status(rawValue: errSecKeyBlobTypeIncorrect)
-            XCTAssertEqual(status, .KeyBlobTypeIncorrect)
+            XCTAssertEqual(status, .keyBlobTypeIncorrect)
             XCTAssertEqual(status?.description, "The key blob type is incorrect.")
         }
         do {
             let status = Status(rawValue: errSecKeyHeaderInconsistent)
-            XCTAssertEqual(status, .KeyHeaderInconsistent)
+            XCTAssertEqual(status, .keyHeaderInconsistent)
             XCTAssertEqual(status?.description, "The key header is inconsistent.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedKeyFormat)
-            XCTAssertEqual(status, .UnsupportedKeyFormat)
+            XCTAssertEqual(status, .unsupportedKeyFormat)
             XCTAssertEqual(status?.description, "The key header format is not supported.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedKeySize)
-            XCTAssertEqual(status, .UnsupportedKeySize)
+            XCTAssertEqual(status, .unsupportedKeySize)
             XCTAssertEqual(status?.description, "The key size is not supported.")
         }
         do {
             let status = Status(rawValue: errSecInvalidKeyUsageMask)
-            XCTAssertEqual(status, .InvalidKeyUsageMask)
+            XCTAssertEqual(status, .invalidKeyUsageMask)
             XCTAssertEqual(status?.description, "The key usage mask is not valid.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedKeyUsageMask)
-            XCTAssertEqual(status, .UnsupportedKeyUsageMask)
+            XCTAssertEqual(status, .unsupportedKeyUsageMask)
             XCTAssertEqual(status?.description, "The key usage mask is not supported.")
         }
         do {
             let status = Status(rawValue: errSecInvalidKeyAttributeMask)
-            XCTAssertEqual(status, .InvalidKeyAttributeMask)
+            XCTAssertEqual(status, .invalidKeyAttributeMask)
             XCTAssertEqual(status?.description, "The key attribute mask is not valid.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedKeyAttributeMask)
-            XCTAssertEqual(status, .UnsupportedKeyAttributeMask)
+            XCTAssertEqual(status, .unsupportedKeyAttributeMask)
             XCTAssertEqual(status?.description, "The key attribute mask is not supported.")
         }
         do {
             let status = Status(rawValue: errSecInvalidKeyLabel)
-            XCTAssertEqual(status, .InvalidKeyLabel)
+            XCTAssertEqual(status, .invalidKeyLabel)
             XCTAssertEqual(status?.description, "The key label is not valid.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedKeyLabel)
-            XCTAssertEqual(status, .UnsupportedKeyLabel)
+            XCTAssertEqual(status, .unsupportedKeyLabel)
             XCTAssertEqual(status?.description, "The key label is not supported.")
         }
         do {
             let status = Status(rawValue: errSecInvalidKeyFormat)
-            XCTAssertEqual(status, .InvalidKeyFormat)
+            XCTAssertEqual(status, .invalidKeyFormat)
             XCTAssertEqual(status?.description, "The key format is not valid.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedVectorOfBuffers)
-            XCTAssertEqual(status, .UnsupportedVectorOfBuffers)
+            XCTAssertEqual(status, .unsupportedVectorOfBuffers)
             XCTAssertEqual(status?.description, "The vector of buffers is not supported.")
         }
         do {
             let status = Status(rawValue: errSecInvalidInputVector)
-            XCTAssertEqual(status, .InvalidInputVector)
+            XCTAssertEqual(status, .invalidInputVector)
             XCTAssertEqual(status?.description, "The input vector is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidOutputVector)
-            XCTAssertEqual(status, .InvalidOutputVector)
+            XCTAssertEqual(status, .invalidOutputVector)
             XCTAssertEqual(status?.description, "The output vector is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidContext)
-            XCTAssertEqual(status, .InvalidContext)
+            XCTAssertEqual(status, .invalidContext)
             XCTAssertEqual(status?.description, "An invalid context was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAlgorithm)
-            XCTAssertEqual(status, .InvalidAlgorithm)
+            XCTAssertEqual(status, .invalidAlgorithm)
             XCTAssertEqual(status?.description, "An invalid algorithm was encountered.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeKey)
-            XCTAssertEqual(status, .InvalidAttributeKey)
+            XCTAssertEqual(status, .invalidAttributeKey)
             XCTAssertEqual(status?.description, "A key attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeKey)
-            XCTAssertEqual(status, .MissingAttributeKey)
+            XCTAssertEqual(status, .missingAttributeKey)
             XCTAssertEqual(status?.description, "A key attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeInitVector)
-            XCTAssertEqual(status, .InvalidAttributeInitVector)
+            XCTAssertEqual(status, .invalidAttributeInitVector)
             XCTAssertEqual(status?.description, "An init vector attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeInitVector)
-            XCTAssertEqual(status, .MissingAttributeInitVector)
+            XCTAssertEqual(status, .missingAttributeInitVector)
             XCTAssertEqual(status?.description, "An init vector attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeSalt)
-            XCTAssertEqual(status, .InvalidAttributeSalt)
+            XCTAssertEqual(status, .invalidAttributeSalt)
             XCTAssertEqual(status?.description, "A salt attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeSalt)
-            XCTAssertEqual(status, .MissingAttributeSalt)
+            XCTAssertEqual(status, .missingAttributeSalt)
             XCTAssertEqual(status?.description, "A salt attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributePadding)
-            XCTAssertEqual(status, .InvalidAttributePadding)
+            XCTAssertEqual(status, .invalidAttributePadding)
             XCTAssertEqual(status?.description, "A padding attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributePadding)
-            XCTAssertEqual(status, .MissingAttributePadding)
+            XCTAssertEqual(status, .missingAttributePadding)
             XCTAssertEqual(status?.description, "A padding attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeRandom)
-            XCTAssertEqual(status, .InvalidAttributeRandom)
+            XCTAssertEqual(status, .invalidAttributeRandom)
             XCTAssertEqual(status?.description, "A random number attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeRandom)
-            XCTAssertEqual(status, .MissingAttributeRandom)
+            XCTAssertEqual(status, .missingAttributeRandom)
             XCTAssertEqual(status?.description, "A random number attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeSeed)
-            XCTAssertEqual(status, .InvalidAttributeSeed)
+            XCTAssertEqual(status, .invalidAttributeSeed)
             XCTAssertEqual(status?.description, "A seed attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeSeed)
-            XCTAssertEqual(status, .MissingAttributeSeed)
+            XCTAssertEqual(status, .missingAttributeSeed)
             XCTAssertEqual(status?.description, "A seed attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributePassphrase)
-            XCTAssertEqual(status, .InvalidAttributePassphrase)
+            XCTAssertEqual(status, .invalidAttributePassphrase)
             XCTAssertEqual(status?.description, "A passphrase attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributePassphrase)
-            XCTAssertEqual(status, .MissingAttributePassphrase)
+            XCTAssertEqual(status, .missingAttributePassphrase)
             XCTAssertEqual(status?.description, "A passphrase attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeKeyLength)
-            XCTAssertEqual(status, .InvalidAttributeKeyLength)
+            XCTAssertEqual(status, .invalidAttributeKeyLength)
             XCTAssertEqual(status?.description, "A key length attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeKeyLength)
-            XCTAssertEqual(status, .MissingAttributeKeyLength)
+            XCTAssertEqual(status, .missingAttributeKeyLength)
             XCTAssertEqual(status?.description, "A key length attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeBlockSize)
-            XCTAssertEqual(status, .InvalidAttributeBlockSize)
+            XCTAssertEqual(status, .invalidAttributeBlockSize)
             XCTAssertEqual(status?.description, "A block size attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeBlockSize)
-            XCTAssertEqual(status, .MissingAttributeBlockSize)
+            XCTAssertEqual(status, .missingAttributeBlockSize)
             XCTAssertEqual(status?.description, "A block size attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeOutputSize)
-            XCTAssertEqual(status, .InvalidAttributeOutputSize)
+            XCTAssertEqual(status, .invalidAttributeOutputSize)
             XCTAssertEqual(status?.description, "An output size attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeOutputSize)
-            XCTAssertEqual(status, .MissingAttributeOutputSize)
+            XCTAssertEqual(status, .missingAttributeOutputSize)
             XCTAssertEqual(status?.description, "An output size attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeRounds)
-            XCTAssertEqual(status, .InvalidAttributeRounds)
+            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, .missingAttributeRounds)
             XCTAssertEqual(status?.description, "The number of rounds attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAlgorithmParms)
-            XCTAssertEqual(status, .InvalidAlgorithmParms)
+            XCTAssertEqual(status, .invalidAlgorithmParms)
             XCTAssertEqual(status?.description, "An algorithm parameters attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAlgorithmParms)
-            XCTAssertEqual(status, .MissingAlgorithmParms)
+            XCTAssertEqual(status, .missingAlgorithmParms)
             XCTAssertEqual(status?.description, "An algorithm parameters attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeLabel)
-            XCTAssertEqual(status, .InvalidAttributeLabel)
+            XCTAssertEqual(status, .invalidAttributeLabel)
             XCTAssertEqual(status?.description, "A label attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeLabel)
-            XCTAssertEqual(status, .MissingAttributeLabel)
+            XCTAssertEqual(status, .missingAttributeLabel)
             XCTAssertEqual(status?.description, "A label attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeKeyType)
-            XCTAssertEqual(status, .InvalidAttributeKeyType)
+            XCTAssertEqual(status, .invalidAttributeKeyType)
             XCTAssertEqual(status?.description, "A key type attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeKeyType)
-            XCTAssertEqual(status, .MissingAttributeKeyType)
+            XCTAssertEqual(status, .missingAttributeKeyType)
             XCTAssertEqual(status?.description, "A key type attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeMode)
-            XCTAssertEqual(status, .InvalidAttributeMode)
+            XCTAssertEqual(status, .invalidAttributeMode)
             XCTAssertEqual(status?.description, "A mode attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeMode)
-            XCTAssertEqual(status, .MissingAttributeMode)
+            XCTAssertEqual(status, .missingAttributeMode)
             XCTAssertEqual(status?.description, "A mode attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeEffectiveBits)
-            XCTAssertEqual(status, .InvalidAttributeEffectiveBits)
+            XCTAssertEqual(status, .invalidAttributeEffectiveBits)
             XCTAssertEqual(status?.description, "An effective bits attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeEffectiveBits)
-            XCTAssertEqual(status, .MissingAttributeEffectiveBits)
+            XCTAssertEqual(status, .missingAttributeEffectiveBits)
             XCTAssertEqual(status?.description, "An effective bits attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeStartDate)
-            XCTAssertEqual(status, .InvalidAttributeStartDate)
+            XCTAssertEqual(status, .invalidAttributeStartDate)
             XCTAssertEqual(status?.description, "A start date attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeStartDate)
-            XCTAssertEqual(status, .MissingAttributeStartDate)
+            XCTAssertEqual(status, .missingAttributeStartDate)
             XCTAssertEqual(status?.description, "A start date attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeEndDate)
-            XCTAssertEqual(status, .InvalidAttributeEndDate)
+            XCTAssertEqual(status, .invalidAttributeEndDate)
             XCTAssertEqual(status?.description, "An end date attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeEndDate)
-            XCTAssertEqual(status, .MissingAttributeEndDate)
+            XCTAssertEqual(status, .missingAttributeEndDate)
             XCTAssertEqual(status?.description, "An end date attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeVersion)
-            XCTAssertEqual(status, .InvalidAttributeVersion)
+            XCTAssertEqual(status, .invalidAttributeVersion)
             XCTAssertEqual(status?.description, "A version attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeVersion)
-            XCTAssertEqual(status, .MissingAttributeVersion)
+            XCTAssertEqual(status, .missingAttributeVersion)
             XCTAssertEqual(status?.description, "A version attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributePrime)
-            XCTAssertEqual(status, .InvalidAttributePrime)
+            XCTAssertEqual(status, .invalidAttributePrime)
             XCTAssertEqual(status?.description, "A prime attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributePrime)
-            XCTAssertEqual(status, .MissingAttributePrime)
+            XCTAssertEqual(status, .missingAttributePrime)
             XCTAssertEqual(status?.description, "A prime attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeBase)
-            XCTAssertEqual(status, .InvalidAttributeBase)
+            XCTAssertEqual(status, .invalidAttributeBase)
             XCTAssertEqual(status?.description, "A base attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeBase)
-            XCTAssertEqual(status, .MissingAttributeBase)
+            XCTAssertEqual(status, .missingAttributeBase)
             XCTAssertEqual(status?.description, "A base attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeSubprime)
-            XCTAssertEqual(status, .InvalidAttributeSubprime)
+            XCTAssertEqual(status, .invalidAttributeSubprime)
             XCTAssertEqual(status?.description, "A subprime attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeSubprime)
-            XCTAssertEqual(status, .MissingAttributeSubprime)
+            XCTAssertEqual(status, .missingAttributeSubprime)
             XCTAssertEqual(status?.description, "A subprime attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeIterationCount)
-            XCTAssertEqual(status, .InvalidAttributeIterationCount)
+            XCTAssertEqual(status, .invalidAttributeIterationCount)
             XCTAssertEqual(status?.description, "An iteration count attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeIterationCount)
-            XCTAssertEqual(status, .MissingAttributeIterationCount)
+            XCTAssertEqual(status, .missingAttributeIterationCount)
             XCTAssertEqual(status?.description, "An iteration count attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeDLDBHandle)
-            XCTAssertEqual(status, .InvalidAttributeDLDBHandle)
+            XCTAssertEqual(status, .invalidAttributeDLDBHandle)
             XCTAssertEqual(status?.description, "A database handle attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeDLDBHandle)
-            XCTAssertEqual(status, .MissingAttributeDLDBHandle)
+            XCTAssertEqual(status, .missingAttributeDLDBHandle)
             XCTAssertEqual(status?.description, "A database handle attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeAccessCredentials)
-            XCTAssertEqual(status, .InvalidAttributeAccessCredentials)
+            XCTAssertEqual(status, .invalidAttributeAccessCredentials)
             XCTAssertEqual(status?.description, "An access credentials attribute was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingAttributeAccessCredentials)
-            XCTAssertEqual(status, .MissingAttributeAccessCredentials)
+            XCTAssertEqual(status, .missingAttributeAccessCredentials)
             XCTAssertEqual(status?.description, "An access credentials attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributePublicKeyFormat)
-            XCTAssertEqual(status, .InvalidAttributePublicKeyFormat)
+            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, .missingAttributePublicKeyFormat)
             XCTAssertEqual(status?.description, "A public key format attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributePrivateKeyFormat)
-            XCTAssertEqual(status, .InvalidAttributePrivateKeyFormat)
+            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, .missingAttributePrivateKeyFormat)
             XCTAssertEqual(status?.description, "A private key format attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeSymmetricKeyFormat)
-            XCTAssertEqual(status, .InvalidAttributeSymmetricKeyFormat)
+            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, .missingAttributeSymmetricKeyFormat)
             XCTAssertEqual(status?.description, "A symmetric key format attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAttributeWrappedKeyFormat)
-            XCTAssertEqual(status, .InvalidAttributeWrappedKeyFormat)
+            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, .missingAttributeWrappedKeyFormat)
             XCTAssertEqual(status?.description, "A wrapped key format attribute was missing.")
         }
         do {
             let status = Status(rawValue: errSecStagedOperationInProgress)
-            XCTAssertEqual(status, .StagedOperationInProgress)
+            XCTAssertEqual(status, .stagedOperationInProgress)
             XCTAssertEqual(status?.description, "A staged operation is in progress.")
         }
         do {
             let status = Status(rawValue: errSecStagedOperationNotStarted)
-            XCTAssertEqual(status, .StagedOperationNotStarted)
+            XCTAssertEqual(status, .stagedOperationNotStarted)
             XCTAssertEqual(status?.description, "A staged operation was not started.")
         }
         do {
             let status = Status(rawValue: errSecVerifyFailed)
-            XCTAssertEqual(status, .VerifyFailed)
+            XCTAssertEqual(status, .verifyFailed)
             XCTAssertEqual(status?.description, "A cryptographic verification failure has occurred.")
         }
         do {
             let status = Status(rawValue: errSecQuerySizeUnknown)
-            XCTAssertEqual(status, .QuerySizeUnknown)
+            XCTAssertEqual(status, .querySizeUnknown)
             XCTAssertEqual(status?.description, "The query size is unknown.")
         }
         do {
             let status = Status(rawValue: errSecBlockSizeMismatch)
-            XCTAssertEqual(status, .BlockSizeMismatch)
+            XCTAssertEqual(status, .blockSizeMismatch)
             XCTAssertEqual(status?.description, "A block size mismatch occurred.")
         }
         do {
             let status = Status(rawValue: errSecPublicKeyInconsistent)
-            XCTAssertEqual(status, .PublicKeyInconsistent)
+            XCTAssertEqual(status, .publicKeyInconsistent)
             XCTAssertEqual(status?.description, "The public key was inconsistent.")
         }
         do {
             let status = Status(rawValue: errSecDeviceVerifyFailed)
-            XCTAssertEqual(status, .DeviceVerifyFailed)
+            XCTAssertEqual(status, .deviceVerifyFailed)
             XCTAssertEqual(status?.description, "A device verification failure has occurred.")
         }
         do {
             let status = Status(rawValue: errSecInvalidLoginName)
-            XCTAssertEqual(status, .InvalidLoginName)
+            XCTAssertEqual(status, .invalidLoginName)
             XCTAssertEqual(status?.description, "An invalid login name was detected.")
         }
         do {
             let status = Status(rawValue: errSecAlreadyLoggedIn)
-            XCTAssertEqual(status, .AlreadyLoggedIn)
+            XCTAssertEqual(status, .alreadyLoggedIn)
             XCTAssertEqual(status?.description, "The user is already logged in.")
         }
         do {
             let status = Status(rawValue: errSecInvalidDigestAlgorithm)
-            XCTAssertEqual(status, .InvalidDigestAlgorithm)
+            XCTAssertEqual(status, .invalidDigestAlgorithm)
             XCTAssertEqual(status?.description, "An invalid digest algorithm was detected.")
         }
         do {
             let status = Status(rawValue: errSecInvalidCRLGroup)
-            XCTAssertEqual(status, .InvalidCRLGroup)
+            XCTAssertEqual(status, .invalidCRLGroup)
             XCTAssertEqual(status?.description, "An invalid CRL group was detected.")
         }
         do {
             let status = Status(rawValue: errSecCertificateCannotOperate)
-            XCTAssertEqual(status, .CertificateCannotOperate)
+            XCTAssertEqual(status, .certificateCannotOperate)
             XCTAssertEqual(status?.description, "The certificate cannot operate.")
         }
         do {
             let status = Status(rawValue: errSecCertificateExpired)
-            XCTAssertEqual(status, .CertificateExpired)
+            XCTAssertEqual(status, .certificateExpired)
             XCTAssertEqual(status?.description, "An expired certificate was detected.")
         }
         do {
             let status = Status(rawValue: errSecCertificateNotValidYet)
-            XCTAssertEqual(status, .CertificateNotValidYet)
+            XCTAssertEqual(status, .certificateNotValidYet)
             XCTAssertEqual(status?.description, "The certificate is not yet valid.")
         }
         do {
             let status = Status(rawValue: errSecCertificateRevoked)
-            XCTAssertEqual(status, .CertificateRevoked)
+            XCTAssertEqual(status, .certificateRevoked)
             XCTAssertEqual(status?.description, "The certificate was revoked.")
         }
         do {
             let status = Status(rawValue: errSecCertificateSuspended)
-            XCTAssertEqual(status, .CertificateSuspended)
+            XCTAssertEqual(status, .certificateSuspended)
             XCTAssertEqual(status?.description, "The certificate was suspended.")
         }
         do {
             let status = Status(rawValue: errSecInsufficientCredentials)
-            XCTAssertEqual(status, .InsufficientCredentials)
+            XCTAssertEqual(status, .insufficientCredentials)
             XCTAssertEqual(status?.description, "Insufficient credentials were detected.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAction)
-            XCTAssertEqual(status, .InvalidAction)
+            XCTAssertEqual(status, .invalidAction)
             XCTAssertEqual(status?.description, "The action was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAuthority)
-            XCTAssertEqual(status, .InvalidAuthority)
+            XCTAssertEqual(status, .invalidAuthority)
             XCTAssertEqual(status?.description, "The authority was not valid.")
         }
         do {
             let status = Status(rawValue: errSecVerifyActionFailed)
-            XCTAssertEqual(status, .VerifyActionFailed)
+            XCTAssertEqual(status, .verifyActionFailed)
             XCTAssertEqual(status?.description, "A verify action has failed.")
         }
         do {
             let status = Status(rawValue: errSecInvalidCertAuthority)
-            XCTAssertEqual(status, .InvalidCertAuthority)
+            XCTAssertEqual(status, .invalidCertAuthority)
             XCTAssertEqual(status?.description, "The certificate authority was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvaldCRLAuthority)
-            XCTAssertEqual(status, .InvaldCRLAuthority)
+            XCTAssertEqual(status, .invaldCRLAuthority)
             XCTAssertEqual(status?.description, "The CRL authority was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidCRLEncoding)
-            XCTAssertEqual(status, .InvalidCRLEncoding)
+            XCTAssertEqual(status, .invalidCRLEncoding)
             XCTAssertEqual(status?.description, "The CRL encoding was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidCRLType)
-            XCTAssertEqual(status, .InvalidCRLType)
+            XCTAssertEqual(status, .invalidCRLType)
             XCTAssertEqual(status?.description, "The CRL type was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidCRL)
-            XCTAssertEqual(status, .InvalidCRL)
+            XCTAssertEqual(status, .invalidCRL)
             XCTAssertEqual(status?.description, "The CRL was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidFormType)
-            XCTAssertEqual(status, .InvalidFormType)
+            XCTAssertEqual(status, .invalidFormType)
             XCTAssertEqual(status?.description, "The form type was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidID)
-            XCTAssertEqual(status, .InvalidID)
+            XCTAssertEqual(status, .invalidID)
             XCTAssertEqual(status?.description, "The ID was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidIdentifier)
-            XCTAssertEqual(status, .InvalidIdentifier)
+            XCTAssertEqual(status, .invalidIdentifier)
             XCTAssertEqual(status?.description, "The identifier was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidIndex)
-            XCTAssertEqual(status, .InvalidIndex)
+            XCTAssertEqual(status, .invalidIndex)
             XCTAssertEqual(status?.description, "The index was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidPolicyIdentifiers)
-            XCTAssertEqual(status, .InvalidPolicyIdentifiers)
+            XCTAssertEqual(status, .invalidPolicyIdentifiers)
             XCTAssertEqual(status?.description, "The policy identifiers are not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidTimeString)
-            XCTAssertEqual(status, .InvalidTimeString)
+            XCTAssertEqual(status, .invalidTimeString)
             XCTAssertEqual(status?.description, "The time specified was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidReason)
-            XCTAssertEqual(status, .InvalidReason)
+            XCTAssertEqual(status, .invalidReason)
             XCTAssertEqual(status?.description, "The trust policy reason was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidRequestInputs)
-            XCTAssertEqual(status, .InvalidRequestInputs)
+            XCTAssertEqual(status, .invalidRequestInputs)
             XCTAssertEqual(status?.description, "The request inputs are not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidResponseVector)
-            XCTAssertEqual(status, .InvalidResponseVector)
+            XCTAssertEqual(status, .invalidResponseVector)
             XCTAssertEqual(status?.description, "The response vector was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidStopOnPolicy)
-            XCTAssertEqual(status, .InvalidStopOnPolicy)
+            XCTAssertEqual(status, .invalidStopOnPolicy)
             XCTAssertEqual(status?.description, "The stop-on policy was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidTuple)
-            XCTAssertEqual(status, .InvalidTuple)
+            XCTAssertEqual(status, .invalidTuple)
             XCTAssertEqual(status?.description, "The tuple was not valid.")
         }
         do {
             let status = Status(rawValue: errSecMultipleValuesUnsupported)
-            XCTAssertEqual(status, .MultipleValuesUnsupported)
+            XCTAssertEqual(status, .multipleValuesUnsupported)
             XCTAssertEqual(status?.description, "Multiple values are not supported.")
         }
         do {
             let status = Status(rawValue: errSecNotTrusted)
-            XCTAssertEqual(status, .NotTrusted)
+            XCTAssertEqual(status, .notTrusted)
             XCTAssertEqual(status?.description, "The trust policy was not trusted.")
         }
         do {
             let status = Status(rawValue: errSecNoDefaultAuthority)
-            XCTAssertEqual(status, .NoDefaultAuthority)
+            XCTAssertEqual(status, .noDefaultAuthority)
             XCTAssertEqual(status?.description, "No default authority was detected.")
         }
         do {
             let status = Status(rawValue: errSecRejectedForm)
-            XCTAssertEqual(status, .RejectedForm)
+            XCTAssertEqual(status, .rejectedForm)
             XCTAssertEqual(status?.description, "The trust policy had a rejected form.")
         }
         do {
             let status = Status(rawValue: errSecRequestLost)
-            XCTAssertEqual(status, .RequestLost)
+            XCTAssertEqual(status, .requestLost)
             XCTAssertEqual(status?.description, "The request was lost.")
         }
         do {
             let status = Status(rawValue: errSecRequestRejected)
-            XCTAssertEqual(status, .RequestRejected)
+            XCTAssertEqual(status, .requestRejected)
             XCTAssertEqual(status?.description, "The request was rejected.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedAddressType)
-            XCTAssertEqual(status, .UnsupportedAddressType)
+            XCTAssertEqual(status, .unsupportedAddressType)
             XCTAssertEqual(status?.description, "The address type is not supported.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedService)
-            XCTAssertEqual(status, .UnsupportedService)
+            XCTAssertEqual(status, .unsupportedService)
             XCTAssertEqual(status?.description, "The service is not supported.")
         }
         do {
             let status = Status(rawValue: errSecInvalidTupleGroup)
-            XCTAssertEqual(status, .InvalidTupleGroup)
+            XCTAssertEqual(status, .invalidTupleGroup)
             XCTAssertEqual(status?.description, "The tuple group was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidBaseACLs)
-            XCTAssertEqual(status, .InvalidBaseACLs)
+            XCTAssertEqual(status, .invalidBaseACLs)
             XCTAssertEqual(status?.description, "The base ACLs are not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidTupleCredendtials)
-            XCTAssertEqual(status, .InvalidTupleCredendtials)
+            XCTAssertEqual(status, .invalidTupleCredendtials)
             XCTAssertEqual(status?.description, "The tuple credentials are not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidEncoding)
-            XCTAssertEqual(status, .InvalidEncoding)
+            XCTAssertEqual(status, .invalidEncoding)
             XCTAssertEqual(status?.description, "The encoding was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidValidityPeriod)
-            XCTAssertEqual(status, .InvalidValidityPeriod)
+            XCTAssertEqual(status, .invalidValidityPeriod)
             XCTAssertEqual(status?.description, "The validity period was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidRequestor)
-            XCTAssertEqual(status, .InvalidRequestor)
+            XCTAssertEqual(status, .invalidRequestor)
             XCTAssertEqual(status?.description, "The requestor was not valid.")
         }
         do {
             let status = Status(rawValue: errSecRequestDescriptor)
-            XCTAssertEqual(status, .RequestDescriptor)
+            XCTAssertEqual(status, .requestDescriptor)
             XCTAssertEqual(status?.description, "The request descriptor was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidBundleInfo)
-            XCTAssertEqual(status, .InvalidBundleInfo)
+            XCTAssertEqual(status, .invalidBundleInfo)
             XCTAssertEqual(status?.description, "The bundle information was not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidCRLIndex)
-            XCTAssertEqual(status, .InvalidCRLIndex)
+            XCTAssertEqual(status, .invalidCRLIndex)
             XCTAssertEqual(status?.description, "The CRL index was not valid.")
         }
         do {
             let status = Status(rawValue: errSecNoFieldValues)
-            XCTAssertEqual(status, .NoFieldValues)
+            XCTAssertEqual(status, .noFieldValues)
             XCTAssertEqual(status?.description, "No field values were detected.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedFieldFormat)
-            XCTAssertEqual(status, .UnsupportedFieldFormat)
+            XCTAssertEqual(status, .unsupportedFieldFormat)
             XCTAssertEqual(status?.description, "The field format is not supported.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedIndexInfo)
-            XCTAssertEqual(status, .UnsupportedIndexInfo)
+            XCTAssertEqual(status, .unsupportedIndexInfo)
             XCTAssertEqual(status?.description, "The index information is not supported.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedLocality)
-            XCTAssertEqual(status, .UnsupportedLocality)
+            XCTAssertEqual(status, .unsupportedLocality)
             XCTAssertEqual(status?.description, "The locality is not supported.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedNumAttributes)
-            XCTAssertEqual(status, .UnsupportedNumAttributes)
+            XCTAssertEqual(status, .unsupportedNumAttributes)
             XCTAssertEqual(status?.description, "The number of attributes is not supported.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedNumIndexes)
-            XCTAssertEqual(status, .UnsupportedNumIndexes)
+            XCTAssertEqual(status, .unsupportedNumIndexes)
             XCTAssertEqual(status?.description, "The number of indexes is not supported.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedNumRecordTypes)
-            XCTAssertEqual(status, .UnsupportedNumRecordTypes)
+            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, .fieldSpecifiedMultiple)
             XCTAssertEqual(status?.description, "Too many fields were specified.")
         }
         do {
             let status = Status(rawValue: errSecIncompatibleFieldFormat)
-            XCTAssertEqual(status, .IncompatibleFieldFormat)
+            XCTAssertEqual(status, .incompatibleFieldFormat)
             XCTAssertEqual(status?.description, "The field format was incompatible.")
         }
         do {
             let status = Status(rawValue: errSecInvalidParsingModule)
-            XCTAssertEqual(status, .InvalidParsingModule)
+            XCTAssertEqual(status, .invalidParsingModule)
             XCTAssertEqual(status?.description, "The parsing module was not valid.")
         }
         do {
             let status = Status(rawValue: errSecDatabaseLocked)
-            XCTAssertEqual(status, .DatabaseLocked)
+            XCTAssertEqual(status, .databaseLocked)
             XCTAssertEqual(status?.description, "The database is locked.")
         }
         do {
             let status = Status(rawValue: errSecDatastoreIsOpen)
-            XCTAssertEqual(status, .DatastoreIsOpen)
+            XCTAssertEqual(status, .datastoreIsOpen)
             XCTAssertEqual(status?.description, "The data store is open.")
         }
         do {
             let status = Status(rawValue: errSecMissingValue)
-            XCTAssertEqual(status, .MissingValue)
+            XCTAssertEqual(status, .missingValue)
             XCTAssertEqual(status?.description, "A missing value was detected.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedQueryLimits)
-            XCTAssertEqual(status, .UnsupportedQueryLimits)
+            XCTAssertEqual(status, .unsupportedQueryLimits)
             XCTAssertEqual(status?.description, "The query limits are not supported.")
         }
         do {
             let status = Status(rawValue: errSecUnsupportedNumSelectionPreds)
-            XCTAssertEqual(status, .UnsupportedNumSelectionPreds)
+            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, .unsupportedOperator)
             XCTAssertEqual(status?.description, "The operator is not supported.")
         }
         do {
             let status = Status(rawValue: errSecInvalidDBLocation)
-            XCTAssertEqual(status, .InvalidDBLocation)
+            XCTAssertEqual(status, .invalidDBLocation)
             XCTAssertEqual(status?.description, "The database location is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidAccessRequest)
-            XCTAssertEqual(status, .InvalidAccessRequest)
+            XCTAssertEqual(status, .invalidAccessRequest)
             XCTAssertEqual(status?.description, "The access request is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidIndexInfo)
-            XCTAssertEqual(status, .InvalidIndexInfo)
+            XCTAssertEqual(status, .invalidIndexInfo)
             XCTAssertEqual(status?.description, "The index information is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidNewOwner)
-            XCTAssertEqual(status, .InvalidNewOwner)
+            XCTAssertEqual(status, .invalidNewOwner)
             XCTAssertEqual(status?.description, "The new owner is not valid.")
         }
         do {
             let status = Status(rawValue: errSecInvalidModifyMode)
-            XCTAssertEqual(status, .InvalidModifyMode)
+            XCTAssertEqual(status, .invalidModifyMode)
             XCTAssertEqual(status?.description, "The modify mode is not valid.")
         }
         do {
             let status = Status(rawValue: errSecMissingRequiredExtension)
-            XCTAssertEqual(status, .MissingRequiredExtension)
+            XCTAssertEqual(status, .missingRequiredExtension)
             XCTAssertEqual(status?.description, "A required certificate extension is missing.")
         }
         do {
             let status = Status(rawValue: errSecExtendedKeyUsageNotCritical)
-            XCTAssertEqual(status, .ExtendedKeyUsageNotCritical)
+            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, .timestampMissing)
             XCTAssertEqual(status?.description, "A timestamp was expected but was not found.")
         }
         do {
             let status = Status(rawValue: errSecTimestampInvalid)
-            XCTAssertEqual(status, .TimestampInvalid)
+            XCTAssertEqual(status, .timestampInvalid)
             XCTAssertEqual(status?.description, "The timestamp was not valid.")
         }
         do {
             let status = Status(rawValue: errSecTimestampNotTrusted)
-            XCTAssertEqual(status, .TimestampNotTrusted)
+            XCTAssertEqual(status, .timestampNotTrusted)
             XCTAssertEqual(status?.description, "The timestamp was not trusted.")
         }
         do {
             let status = Status(rawValue: errSecTimestampServiceNotAvailable)
-            XCTAssertEqual(status, .TimestampServiceNotAvailable)
+            XCTAssertEqual(status, .timestampServiceNotAvailable)
             XCTAssertEqual(status?.description, "The timestamp service is not available.")
         }
         do {
             let status = Status(rawValue: errSecTimestampBadAlg)
-            XCTAssertEqual(status, .TimestampBadAlg)
+            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, .timestampBadRequest)
             XCTAssertEqual(status?.description, "The timestamp transaction is not permitted or supported.")
         }
         do {
             let status = Status(rawValue: errSecTimestampBadDataFormat)
-            XCTAssertEqual(status, .TimestampBadDataFormat)
+            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, .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, .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, .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, .timestampAddInfoNotAvailable)
             XCTAssertEqual(status?.description, "The additional information requested is not available.")
         }
         do {
             let status = Status(rawValue: errSecTimestampSystemFailure)
-            XCTAssertEqual(status, .TimestampSystemFailure)
+            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, .signingTimeMissing)
             XCTAssertEqual(status?.description, "A signing time was expected but was not found.")
         }
         do {
             let status = Status(rawValue: errSecTimestampRejection)
-            XCTAssertEqual(status, .TimestampRejection)
+            XCTAssertEqual(status, .timestampRejection)
             XCTAssertEqual(status?.description, "A timestamp transaction was rejected.")
         }
         do {
             let status = Status(rawValue: errSecTimestampWaiting)
-            XCTAssertEqual(status, .TimestampWaiting)
+            XCTAssertEqual(status, .timestampWaiting)
             XCTAssertEqual(status?.description, "A timestamp transaction is waiting.")
         }
         do {
             let status = Status(rawValue: errSecTimestampRevocationWarning)
-            XCTAssertEqual(status, .TimestampRevocationWarning)
+            XCTAssertEqual(status, .timestampRevocationWarning)
             XCTAssertEqual(status?.description, "A timestamp authority revocation warning was issued.")
         }
         do {
             let status = Status(rawValue: errSecTimestampRevocationNotification)
-            XCTAssertEqual(status, .TimestampRevocationNotification)
+            XCTAssertEqual(status, .timestampRevocationNotification)
             XCTAssertEqual(status?.description, "A timestamp authority revocation notification was issued.")
         }
         #endif

Lib/KeychainAccessTests/KeychainAccessTests.swift

@@ -36,8 +36,8 @@ class KeychainAccessTests: XCTestCase {
         do { try Keychain(service: "Twitter", accessGroup: "27AEDK3C9F.shared").removeAll() } catch {}
         do { try Keychain(service: "Twitter").removeAll() } catch {}
 
-        do { try Keychain(server: NSURL(string: "https://example.com")!, protocolType: .HTTPS).removeAll() } catch {}
-        do { try Keychain(server: NSURL(string: "https://example.com:443")!, protocolType: .HTTPS).removeAll() } catch {}
+        do { try Keychain(server: URL(string: "https://example.com")!, protocolType: .https).removeAll() } catch {}
+        do { try Keychain(server: URL(string: "https://example.com:443")!, protocolType: .https).removeAll() } catch {}
 
         do { try Keychain().removeAll() } catch {}
     }
@@ -135,7 +135,7 @@ class KeychainAccessTests: XCTestCase {
     func testInternetPassword() {
         do {
             // Add Keychain items
-            let keychain = Keychain(server: NSURL(string: "https://kishikawakatsumi.com")!, protocolType: .HTTPS)
+            let keychain = Keychain(server: URL(string: "https://kishikawakatsumi.com")!, protocolType: .https)
 
             do { try keychain.set("kishikawa_katsumi", key: "username") } catch {}
             do { try keychain.set("password_1234", key: "password") } catch {}
@@ -149,7 +149,7 @@ class KeychainAccessTests: XCTestCase {
 
         do {
             // Update Keychain items
-            let keychain = Keychain(server: NSURL(string: "https://kishikawakatsumi.com")!, protocolType: .HTTPS)
+            let keychain = Keychain(server: URL(string: "https://kishikawakatsumi.com")!, protocolType: .https)
 
             do { try keychain.set("katsumi_kishikawa", key: "username") } catch {}
             do { try keychain.set("1234_password", key: "password") } catch {}
@@ -163,7 +163,7 @@ class KeychainAccessTests: XCTestCase {
 
         do {
             // Remove Keychain items
-            let keychain = Keychain(server: NSURL(string: "https://kishikawakatsumi.com")!, protocolType: .HTTPS)
+            let keychain = Keychain(server: URL(string: "https://kishikawakatsumi.com")!, protocolType: .https)
 
             do { try keychain.remove("username") } catch {}
             do { try keychain.remove("password") } catch {}
@@ -176,7 +176,7 @@ class KeychainAccessTests: XCTestCase {
     func testInternetPasswordSubscripting() {
         do {
             // Add Keychain items
-            let keychain = Keychain(server: NSURL(string: "https://kishikawakatsumi.com")!, protocolType: .HTTPS)
+            let keychain = Keychain(server: URL(string: "https://kishikawakatsumi.com")!, protocolType: .https)
 
             keychain["username"] = "kishikawa_katsumi"
             keychain["password"] = "password_1234"
@@ -190,7 +190,7 @@ class KeychainAccessTests: XCTestCase {
 
         do {
             // Update Keychain items
-            let keychain = Keychain(server: NSURL(string: "https://kishikawakatsumi.com")!, protocolType: .HTTPS)
+            let keychain = Keychain(server: URL(string: "https://kishikawakatsumi.com")!, protocolType: .https)
 
             keychain["username"] = "katsumi_kishikawa"
             keychain["password"] = "1234_password"
@@ -204,7 +204,7 @@ class KeychainAccessTests: XCTestCase {
 
         do {
             // Remove Keychain items
-            let keychain = Keychain(server: NSURL(string: "https://kishikawakatsumi.com")!, protocolType: .HTTPS)
+            let keychain = Keychain(server: URL(string: "https://kishikawakatsumi.com")!, protocolType: .https)
 
             keychain["username"] = nil
             keychain["password"] = nil
@@ -218,7 +218,7 @@ class KeychainAccessTests: XCTestCase {
 
     func testDefaultInitializer() {
         let keychain = Keychain()
-        XCTAssertEqual(keychain.service, NSBundle.mainBundle().bundleIdentifier)
+        XCTAssertEqual(keychain.service, Bundle.main.bundleIdentifier)
         XCTAssertEqual(keychain.service, "com.kishikawakatsumi.KeychainAccess.TestHost")
         XCTAssertNil(keychain.accessGroup)
     }
@@ -243,37 +243,37 @@ class KeychainAccessTests: XCTestCase {
 
     func testInitializerWithServer() {
         let server = "https://kishikawakatsumi.com"
-        let URL = NSURL(string: server)!
+        let url = URL(string: server)!
 
         do {
-            let keychain = Keychain(server: server, protocolType: .HTTPS)
-            XCTAssertEqual(keychain.server, URL)
-            XCTAssertEqual(keychain.protocolType, ProtocolType.HTTPS)
-            XCTAssertEqual(keychain.authenticationType, AuthenticationType.Default)
+            let keychain = Keychain(server: server, protocolType: .https)
+            XCTAssertEqual(keychain.server, url)
+            XCTAssertEqual(keychain.protocolType, ProtocolType.https)
+            XCTAssertEqual(keychain.authenticationType, AuthenticationType.default)
         }
         do {
-            let keychain = Keychain(server: URL, protocolType: .HTTPS)
-            XCTAssertEqual(keychain.server, URL)
-            XCTAssertEqual(keychain.protocolType, ProtocolType.HTTPS)
-            XCTAssertEqual(keychain.authenticationType, AuthenticationType.Default)
+            let keychain = Keychain(server: url, protocolType: .https)
+            XCTAssertEqual(keychain.server, url)
+            XCTAssertEqual(keychain.protocolType, ProtocolType.https)
+            XCTAssertEqual(keychain.authenticationType, AuthenticationType.default)
         }
     }
 
     func testInitializerWithServerAndAuthenticationType() {
         let server = "https://kishikawakatsumi.com"
-        let URL = NSURL(string: server)!
+        let url = URL(string: server)!
 
         do {
-            let keychain = Keychain(server: server, protocolType: .HTTPS, authenticationType: .HTMLForm)
-            XCTAssertEqual(keychain.server, URL)
-            XCTAssertEqual(keychain.protocolType, ProtocolType.HTTPS)
-            XCTAssertEqual(keychain.authenticationType, AuthenticationType.HTMLForm)
+            let keychain = Keychain(server: server, protocolType: .https, authenticationType: .htmlForm)
+            XCTAssertEqual(keychain.server, url)
+            XCTAssertEqual(keychain.protocolType, ProtocolType.https)
+            XCTAssertEqual(keychain.authenticationType, AuthenticationType.htmlForm)
         }
         do {
-            let keychain = Keychain(server: URL, protocolType: .HTTPS, authenticationType: .HTMLForm)
-            XCTAssertEqual(keychain.server, URL)
-            XCTAssertEqual(keychain.protocolType, ProtocolType.HTTPS)
-            XCTAssertEqual(keychain.authenticationType, AuthenticationType.HTMLForm)
+            let keychain = Keychain(server: url, protocolType: .https, authenticationType: .htmlForm)
+            XCTAssertEqual(keychain.server, url)
+            XCTAssertEqual(keychain.protocolType, ProtocolType.https)
+            XCTAssertEqual(keychain.authenticationType, AuthenticationType.htmlForm)
         }
     }
 
@@ -408,7 +408,7 @@ class KeychainAccessTests: XCTestCase {
 
     func testSetData() {
         let JSONObject = ["username": "kishikawakatsumi", "password": "password1234"]
-        let JSONData = try! NSJSONSerialization.dataWithJSONObject(JSONObject, options: [])
+        let JSONData = try! JSONSerialization.data(withJSONObject: JSONObject, options: [])
 
         let keychain = Keychain(service: "Twitter")
 
@@ -423,14 +423,15 @@ class KeychainAccessTests: XCTestCase {
 
         let length = 256
         let data = NSMutableData(length: length)!
-        _ = SecRandomCopyBytes(kSecRandomDefault, length, UnsafeMutablePointer<UInt8>(data.mutableBytes))
+        let bytes = data.mutableBytes.bindMemory(to: UInt8.self, capacity: length)
+        _ = SecRandomCopyBytes(kSecRandomDefault, length, bytes)
 
         do {
-            try keychain.set(data, key: "RandomData")
+            try keychain.set(data as Data, key: "RandomData")
             let _ = try keychain.getString("RandomData")
         } catch let error as NSError {
             XCTAssertEqual(error.domain, KeychainAccessErrorDomain)
-            XCTAssertEqual(error.code, Int(Status.ConversionError.rawValue))
+            XCTAssertEqual(error.code, Int(Status.conversionError.rawValue))
         }
     }
 
@@ -459,11 +460,11 @@ class KeychainAccessTests: XCTestCase {
 
     #if os(iOS) || os(tvOS)
     func testSetAttributes() {
-        let expectation = expectationWithDescription("Touch ID authentication")
+        let expectation = self.expectation(description: "Touch ID authentication")
 
-        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
+        DispatchQueue.global(qos: .default).async {
             do {
-                var attributes = [String: AnyObject]()
+                var attributes = [String: Any]()
                 attributes[String(kSecAttrDescription)] = "Description Test"
                 attributes[String(kSecAttrComment)] = "Comment Test"
                 attributes[String(kSecAttrCreator)] = "Creator Test"
@@ -474,7 +475,7 @@ class KeychainAccessTests: XCTestCase {
 
                 let keychain = Keychain(service: "Twitter")
                     .attributes(attributes)
-                    .accessibility(.WhenPasscodeSetThisDeviceOnly, authenticationPolicy: .UserPresence)
+                    .accessibility(.whenPasscodeSetThisDeviceOnly, authenticationPolicy: .UserPresence)
 
                 XCTAssertNil(keychain["kishikawakatsumi"], "not stored password")
 
@@ -490,11 +491,11 @@ class KeychainAccessTests: XCTestCase {
 
                 do {
                     let attributes = try keychain.get("kishikawakatsumi") { $0 }
-                    XCTAssertEqual(attributes?.`class`, ItemClass.GenericPassword.rawValue)
-                    XCTAssertEqual(attributes?.data, "password1234".dataUsingEncoding(NSUTF8StringEncoding))
+                    XCTAssertEqual(attributes?.`class`, ItemClass.genericPassword.rawValue)
+                    XCTAssertEqual(attributes?.data, "password1234".data(using: .utf8))
                     XCTAssertNil(attributes?.ref)
                     XCTAssertNotNil(attributes?.persistentRef)
-                    XCTAssertEqual(attributes?.accessible, Accessibility.WhenPasscodeSetThisDeviceOnly.rawValue)
+                    XCTAssertEqual(attributes?.accessible, Accessibility.whenPasscodeSetThisDeviceOnly.rawValue)
                     XCTAssertNotNil(attributes?.accessControl)
                     XCTAssertEqual(attributes?.accessGroup, "27AEDK3C9F.com.kishikawakatsumi.KeychainAccess.TestHost")
                     XCTAssertNotNil(attributes?.synchronizable)
@@ -517,8 +518,8 @@ class KeychainAccessTests: XCTestCase {
                     XCTAssertNil(attributes?.port)
                     XCTAssertNil(attributes?.path)
 
-                    XCTAssertEqual(attributes![String(kSecClass)] as? String, ItemClass.GenericPassword.rawValue)
-                    XCTAssertEqual(attributes![String(kSecValueData)] as? NSData, "password1234".dataUsingEncoding(NSUTF8StringEncoding))
+                    XCTAssertEqual(attributes![String(kSecClass)] as? String, ItemClass.genericPassword.rawValue)
+                    XCTAssertEqual(attributes![String(kSecValueData)] as? Data, "password1234".data(using: .utf8))
 
                     expectation.fulfill()
                 } catch {
@@ -526,10 +527,10 @@ class KeychainAccessTests: XCTestCase {
                 }
             }
         }
-        waitForExpectationsWithTimeout(10.0, handler: nil)
+        waitForExpectations(timeout: 10.0, handler: nil)
 
         do {
-            var attributes = [String: AnyObject]()
+            var attributes = [String: Any]()
             attributes[String(kSecAttrDescription)] = "Description Test"
             attributes[String(kSecAttrComment)] = "Comment Test"
             attributes[String(kSecAttrCreator)] = "Creator Test"
@@ -539,7 +540,7 @@ class KeychainAccessTests: XCTestCase {
             attributes[String(kSecAttrIsNegative)] = true
             attributes[String(kSecAttrSecurityDomain)] = "securitydomain"
 
-            let keychain = Keychain(server: NSURL(string: "https://example.com:443/api/login/")!, protocolType: .HTTPS)
+            let keychain = Keychain(server: URL(string: "https://example.com:443/api/login/")!, protocolType: .https)
                 .attributes(attributes)
 
             XCTAssertNil(keychain["kishikawakatsumi"], "not stored password")
@@ -556,11 +557,11 @@ class KeychainAccessTests: XCTestCase {
                 XCTAssertEqual(keychain["kishikawakatsumi"], "password1234", "stored password")
 
                 let attributes = try keychain.get("kishikawakatsumi") { $0 }
-                XCTAssertEqual(attributes?.`class`, ItemClass.InternetPassword.rawValue)
-                XCTAssertEqual(attributes?.data, "password1234".dataUsingEncoding(NSUTF8StringEncoding))
+                XCTAssertEqual(attributes?.`class`, ItemClass.internetPassword.rawValue)
+                XCTAssertEqual(attributes?.data, "password1234".data(using: .utf8))
                 XCTAssertNil(attributes?.ref)
                 XCTAssertNotNil(attributes?.persistentRef)
-                XCTAssertEqual(attributes?.accessible, Accessibility.AfterFirstUnlock.rawValue)
+                XCTAssertEqual(attributes?.accessible, Accessibility.afterFirstUnlock.rawValue)
                 if #available(iOS 9.0, *) {
                     XCTAssertNil(attributes?.accessControl)
                 } else {
@@ -582,15 +583,15 @@ class KeychainAccessTests: XCTestCase {
                 XCTAssertNil(attributes?.generic)
                 XCTAssertEqual(attributes?.securityDomain, "securitydomain")
                 XCTAssertEqual(attributes?.server, "example.com")
-                XCTAssertEqual(attributes?.`protocol`, ProtocolType.HTTPS.rawValue)
-                XCTAssertEqual(attributes?.authenticationType, AuthenticationType.Default.rawValue)
+                XCTAssertEqual(attributes?.`protocol`, ProtocolType.https.rawValue)
+                XCTAssertEqual(attributes?.authenticationType, AuthenticationType.default.rawValue)
                 XCTAssertEqual(attributes?.port, 443)
                 XCTAssertEqual(attributes?.path, "")
             } catch {
                 XCTFail("error occurred")
             }
             do {
-                let keychain = Keychain(server: NSURL(string: "https://example.com:443/api/login/")!, protocolType: .HTTPS)
+                let keychain = Keychain(server: URL(string: "https://example.com:443/api/login/")!, protocolType: .https)
 
                 XCTAssertEqual(keychain["kishikawakatsumi"], "password1234", "stored password")
 
@@ -598,11 +599,11 @@ class KeychainAccessTests: XCTestCase {
                 XCTAssertEqual(keychain["kishikawakatsumi"], "1234password", "updated password")
 
                 let attributes = try keychain.get("kishikawakatsumi") { $0 }
-                XCTAssertEqual(attributes?.`class`, ItemClass.InternetPassword.rawValue)
-                XCTAssertEqual(attributes?.data, "1234password".dataUsingEncoding(NSUTF8StringEncoding))
+                XCTAssertEqual(attributes?.`class`, ItemClass.internetPassword.rawValue)
+                XCTAssertEqual(attributes?.data, "1234password".data(using: .utf8))
                 XCTAssertNil(attributes?.ref)
                 XCTAssertNotNil(attributes?.persistentRef)
-                XCTAssertEqual(attributes?.accessible, Accessibility.AfterFirstUnlock.rawValue)
+                XCTAssertEqual(attributes?.accessible, Accessibility.afterFirstUnlock.rawValue)
                 if #available(iOS 9.0, *) {
                     XCTAssertNil(attributes?.accessControl)
                 } else {
@@ -624,15 +625,15 @@ class KeychainAccessTests: XCTestCase {
                 XCTAssertNil(attributes?.generic)
                 XCTAssertEqual(attributes?.securityDomain, "securitydomain")
                 XCTAssertEqual(attributes?.server, "example.com")
-                XCTAssertEqual(attributes?.`protocol`, ProtocolType.HTTPS.rawValue)
-                XCTAssertEqual(attributes?.authenticationType, AuthenticationType.Default.rawValue)
+                XCTAssertEqual(attributes?.`protocol`, ProtocolType.https.rawValue)
+                XCTAssertEqual(attributes?.authenticationType, AuthenticationType.default.rawValue)
                 XCTAssertEqual(attributes?.port, 443)
                 XCTAssertEqual(attributes?.path, "")
             } catch {
                 XCTFail("error occurred")
             }
             do {
-                let keychain = Keychain(server: NSURL(string: "https://example.com:443/api/login/")!, protocolType: .HTTPS)
+                let keychain = Keychain(server: URL(string: "https://example.com:443/api/login/")!, protocolType: .https)
                     .attributes([String(kSecAttrDescription): "Updated Description"])
 
                 XCTAssertEqual(keychain["kishikawakatsumi"], "1234password", "stored password")
@@ -641,11 +642,11 @@ class KeychainAccessTests: XCTestCase {
                 XCTAssertEqual(keychain["kishikawakatsumi"], "password1234", "updated password")
 
                 let attributes = keychain[attributes: "kishikawakatsumi"]
-                XCTAssertEqual(attributes?.`class`, ItemClass.InternetPassword.rawValue)
-                XCTAssertEqual(attributes?.data, "password1234".dataUsingEncoding(NSUTF8StringEncoding))
+                XCTAssertEqual(attributes?.`class`, ItemClass.internetPassword.rawValue)
+                XCTAssertEqual(attributes?.data, "password1234".data(using: .utf8))
                 XCTAssertNil(attributes?.ref)
                 XCTAssertNotNil(attributes?.persistentRef)
-                XCTAssertEqual(attributes?.accessible, Accessibility.AfterFirstUnlock.rawValue)
+                XCTAssertEqual(attributes?.accessible, Accessibility.afterFirstUnlock.rawValue)
                 if #available(iOS 9.0, *) {
                     XCTAssertNil(attributes?.accessControl)
                 } else {
@@ -667,8 +668,8 @@ class KeychainAccessTests: XCTestCase {
                 XCTAssertNil(attributes?.generic)
                 XCTAssertEqual(attributes?.securityDomain, "securitydomain")
                 XCTAssertEqual(attributes?.server, "example.com")
-                XCTAssertEqual(attributes?.`protocol`, ProtocolType.HTTPS.rawValue)
-                XCTAssertEqual(attributes?.authenticationType, AuthenticationType.Default.rawValue)
+                XCTAssertEqual(attributes?.`protocol`, ProtocolType.https.rawValue)
+                XCTAssertEqual(attributes?.authenticationType, AuthenticationType.default.rawValue)
                 XCTAssertEqual(attributes?.port, 443)
                 XCTAssertEqual(attributes?.path, "")
             }
@@ -699,7 +700,7 @@ class KeychainAccessTests: XCTestCase {
 
     func testRemoveData() {
         let JSONObject = ["username": "kishikawakatsumi", "password": "password1234"]
-        let JSONData = try! NSJSONSerialization.dataWithJSONObject(JSONObject, options: [])
+        let JSONData = try! JSONSerialization.data(withJSONObject: JSONObject, options: [])
 
         let keychain = Keychain(service: "Twitter")
 
@@ -743,7 +744,7 @@ class KeychainAccessTests: XCTestCase {
         XCTAssertNil(keychain[string: "password"], "removed password")
 
         let JSONObject = ["username": "kishikawakatsumi", "password": "password1234"]
-        let JSONData = try! NSJSONSerialization.dataWithJSONObject(JSONObject, options: [])
+        let JSONData = try! JSONSerialization.data(withJSONObject: JSONObject, options: [])
 
         XCTAssertNil(keychain[data:"JSONData"], "not stored JSON data")
 
@@ -756,7 +757,6 @@ class KeychainAccessTests: XCTestCase {
 
     // MARK:
 
-    #if !os(OSX) // Disable on CI
     func testErrorHandling() {
         do {
             let keychain = Keychain(service: "Twitter", accessGroup: "27AEDK3C9F.shared")
@@ -775,7 +775,7 @@ class KeychainAccessTests: XCTestCase {
         }
 
         do {
-            let keychain = Keychain(server: NSURL(string: "https://kishikawakatsumi.com")!, protocolType: .HTTPS)
+            let keychain = Keychain(server: URL(string: "https://kishikawakatsumi.com")!, protocolType: .https)
             try keychain.removeAll()
             XCTAssertTrue(true, "no error occurred")
         } catch {
@@ -820,7 +820,7 @@ class KeychainAccessTests: XCTestCase {
                 XCTFail("error occurred")
             }
         }
-        
+
         do {
             // Update Keychain items
             let keychain = Keychain(service: "Twitter")
@@ -870,7 +870,6 @@ class KeychainAccessTests: XCTestCase {
             }
         }
     }
-    #endif
 
     // MARK:
 
@@ -1009,9 +1008,9 @@ class KeychainAccessTests: XCTestCase {
         XCTAssertEqual(keychain.synchronizable, false)
         XCTAssertEqual(keychain.synchronizable(true).synchronizable, true)
         XCTAssertEqual(keychain.synchronizable(false).synchronizable, false)
-        XCTAssertEqual(keychain.accessibility(.AfterFirstUnlock).accessibility, Accessibility.AfterFirstUnlock)
-        XCTAssertEqual(keychain.accessibility(.WhenPasscodeSetThisDeviceOnly, authenticationPolicy: .UserPresence).accessibility, Accessibility.WhenPasscodeSetThisDeviceOnly)
-        XCTAssertEqual(keychain.accessibility(.WhenPasscodeSetThisDeviceOnly, authenticationPolicy: .UserPresence).authenticationPolicy, AuthenticationPolicy.UserPresence)
+        XCTAssertEqual(keychain.accessibility(.afterFirstUnlock).accessibility, Accessibility.afterFirstUnlock)
+        XCTAssertEqual(keychain.accessibility(.whenPasscodeSetThisDeviceOnly, authenticationPolicy: .UserPresence).accessibility, Accessibility.whenPasscodeSetThisDeviceOnly)
+        XCTAssertEqual(keychain.accessibility(.whenPasscodeSetThisDeviceOnly, authenticationPolicy: .UserPresence).authenticationPolicy, AuthenticationPolicy.UserPresence)
         XCTAssertNil(keychain.label)
         XCTAssertEqual(keychain.label("Label").label, "Label")
         XCTAssertNil(keychain.comment)
@@ -1021,7 +1020,6 @@ class KeychainAccessTests: XCTestCase {
 
     // MARK:
 
-    #if !os(OSX) // Disable on CI
     func testAllKeys() {
         do {
             let keychain = Keychain()
@@ -1031,15 +1029,15 @@ class KeychainAccessTests: XCTestCase {
 
             let allKeys = keychain.allKeys()
             XCTAssertEqual(allKeys.count, 3)
-            XCTAssertEqual(allKeys.sort(), ["key1", "key2", "key3"])
+            XCTAssertEqual(allKeys.sorted(), ["key1", "key2", "key3"])
 
             let allItems = keychain.allItems()
             XCTAssertEqual(allItems.count, 3)
 
-            let sortedItems = allItems.sort { (item1, item2) -> Bool in
+            let sortedItems = allItems.sorted { (item1, item2) -> Bool in
                 let key1 = item1["key"] as! String
                 let key2 = item2["key"] as! String
-                return key1.compare(key2) == .OrderedAscending || key1.compare(key2) == .OrderedSame
+                return key1.compare(key2) == .orderedAscending || key1.compare(key2) == .orderedSame
             }
 
             #if !os(OSX)
@@ -1084,25 +1082,25 @@ class KeychainAccessTests: XCTestCase {
             let keychain = Keychain(service: "service1")
             try! keychain
                 .synchronizable(true)
-                .accessibility(.WhenUnlockedThisDeviceOnly)
+                .accessibility(.whenUnlockedThisDeviceOnly)
                 .set("service1_value1", key: "service1_key1")
 
             try! keychain
                 .synchronizable(false)
-                .accessibility(.AfterFirstUnlockThisDeviceOnly)
+                .accessibility(.afterFirstUnlockThisDeviceOnly)
                 .set("service1_value2", key: "service1_key2")
 
             let allKeys = keychain.allKeys()
             XCTAssertEqual(allKeys.count, 2)
-            XCTAssertEqual(allKeys.sort(), ["service1_key1", "service1_key2"])
+            XCTAssertEqual(allKeys.sorted(), ["service1_key1", "service1_key2"])
 
             let allItems = keychain.allItems()
             XCTAssertEqual(allItems.count, 2)
 
-            let sortedItems = allItems.sort { (item1, item2) -> Bool in
+            let sortedItems = allItems.sorted { (item1, item2) -> Bool in
                 let key1 = item1["key"] as! String
                 let key2 = item2["key"] as! String
-                return key1.compare(key2) == .OrderedAscending || key1.compare(key2) == .OrderedSame
+                return key1.compare(key2) == .orderedAscending || key1.compare(key2) == .orderedSame
             }
 
             #if !os(OSX)
@@ -1132,28 +1130,28 @@ class KeychainAccessTests: XCTestCase {
             #endif
         }
         do {
-            let keychain = Keychain(server: "https://google.com", protocolType: .HTTPS)
+            let keychain = Keychain(server: "https://google.com", protocolType: .https)
             try! keychain
                 .synchronizable(false)
-                .accessibility(.AlwaysThisDeviceOnly)
+                .accessibility(.alwaysThisDeviceOnly)
                 .set("google.com_value1", key: "google.com_key1")
 
             try! keychain
                 .synchronizable(true)
-                .accessibility(.Always)
+                .accessibility(.always)
                 .set("google.com_value2", key: "google.com_key2")
 
             let allKeys = keychain.allKeys()
             XCTAssertEqual(allKeys.count, 2)
-            XCTAssertEqual(allKeys.sort(), ["google.com_key1", "google.com_key2"])
+            XCTAssertEqual(allKeys.sorted(), ["google.com_key1", "google.com_key2"])
 
             let allItems = keychain.allItems()
             XCTAssertEqual(allItems.count, 2)
 
-            let sortedItems = allItems.sort { (item1, item2) -> Bool in
+            let sortedItems = allItems.sorted { (item1, item2) -> Bool in
                 let key1 = item1["key"] as! String
                 let key2 = item2["key"] as! String
-                return key1.compare(key2) == .OrderedAscending || key1.compare(key2) == .OrderedSame
+                return key1.compare(key2) == .orderedAscending || key1.compare(key2) == .orderedSame
             }
 
             #if !os(OSX)
@@ -1191,11 +1189,11 @@ class KeychainAccessTests: XCTestCase {
 
         #if !os(OSX)
         do {
-            let allKeys = Keychain.allKeys(.GenericPassword)
+            let allKeys = Keychain.allKeys(.genericPassword)
             XCTAssertEqual(allKeys.count, 5)
 
-            let sortedKeys = allKeys.sort { (key1, key2) -> Bool in
-                return key1.1.compare(key2.1) == .OrderedAscending || key1.1.compare(key2.1) == .OrderedSame
+            let sortedKeys = allKeys.sorted { (key1, key2) -> Bool in
+                return key1.1.compare(key2.1) == .orderedAscending || key1.1.compare(key2.1) == .orderedSame
             }
             XCTAssertEqual(sortedKeys[0].0, "com.kishikawakatsumi.KeychainAccess.TestHost")
             XCTAssertEqual(sortedKeys[0].1, "key1")
@@ -1209,11 +1207,11 @@ class KeychainAccessTests: XCTestCase {
             XCTAssertEqual(sortedKeys[4].1, "service1_key2")
         }
         do {
-            let allKeys = Keychain.allKeys(.InternetPassword)
+            let allKeys = Keychain.allKeys(.internetPassword)
             XCTAssertEqual(allKeys.count, 2)
 
-            let sortedKeys = allKeys.sort { (key1, key2) -> Bool in
-                return key1.1.compare(key2.1) == .OrderedAscending || key1.1.compare(key2.1) == .OrderedSame
+            let sortedKeys = allKeys.sorted { (key1, key2) -> Bool in
+                return key1.1.compare(key2.1) == .orderedAscending || key1.1.compare(key2.1) == .orderedSame
             }
             XCTAssertEqual(sortedKeys[0].0, "google.com")
             XCTAssertEqual(sortedKeys[0].1, "google.com_key1")
@@ -1222,7 +1220,6 @@ class KeychainAccessTests: XCTestCase {
         }
         #endif
     }
-    #endif
 
     func testDescription() {
         do {
@@ -1241,194 +1238,194 @@ class KeychainAccessTests: XCTestCase {
         }
 
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.UserPresence]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         #if os(iOS)
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.UserPresence, .ApplicationPassword]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.UserPresence, .ApplicationPassword, .PrivateKeyUsage]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.ApplicationPassword]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.ApplicationPassword, .PrivateKeyUsage]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.PrivateKeyUsage]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDAny]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDAny, .DevicePasscode]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDAny, .ApplicationPassword]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDAny, .ApplicationPassword, .PrivateKeyUsage]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDCurrentSet]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDCurrentSet, .DevicePasscode]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDCurrentSet, .ApplicationPassword]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDCurrentSet, .ApplicationPassword, .PrivateKeyUsage]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDAny, .Or, .DevicePasscode]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.TouchIDAny, .And, .DevicePasscode]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
@@ -1436,25 +1433,25 @@ class KeychainAccessTests: XCTestCase {
         #endif
         #if os(OSX)
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.UserPresence]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)
         }
         do {
-            let accessibility: Accessibility = .WhenPasscodeSetThisDeviceOnly
+            let accessibility: Accessibility = .whenPasscodeSetThisDeviceOnly
 
             let policy: AuthenticationPolicy = [.DevicePasscode]
             let flags = SecAccessControlCreateFlags(rawValue: policy.rawValue)
 
             var error: Unmanaged<CFError>?
-            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue, flags, &error)
+            let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, accessibility.rawValue as CFTypeRef, flags, &error)
 
             XCTAssertNil(error)
             XCTAssertNotNil(accessControl)

Lib/KeychainAccessTests/SharedCredentialTests.swift

@@ -38,9 +38,9 @@ class SharedCredentialTests: XCTestCase {
 
     func testGetSharedPassword() {
         do {
-            let expectation = expectationWithDescription("getSharedPassword")
+            let expectation = self.expectation(description: "getSharedPassword")
 
-            let keychain = Keychain(server: "https://kishikawakatsumi.com", protocolType: .HTTPS)
+            let keychain = Keychain(server: "https://kishikawakatsumi.com", protocolType: .https)
 
             keychain.getSharedPassword("kishikawakatsumi") { (password, error) -> () in
                 XCTAssertNil(password)
@@ -48,12 +48,12 @@ class SharedCredentialTests: XCTestCase {
                 expectation.fulfill()
             }
 
-            waitForExpectationsWithTimeout(10.0, handler: nil)
+            waitForExpectations(timeout: 10.0, handler: nil)
         }
         do {
-            let expectation = expectationWithDescription("getSharedPassword")
+            let expectation = self.expectation(description: "getSharedPassword")
 
-            let keychain = Keychain(server: "https://kishikawakatsumi.com", protocolType: .HTTPS)
+            let keychain = Keychain(server: "https://kishikawakatsumi.com", protocolType: .https)
 
             keychain.getSharedPassword { (account, password, error) -> () in
                 XCTAssertNil(account)
@@ -62,7 +62,7 @@ class SharedCredentialTests: XCTestCase {
                 expectation.fulfill()
             }
 
-            waitForExpectationsWithTimeout(10.0, handler: nil)
+            waitForExpectations(timeout: 10.0, handler: nil)
         }
 
     }

Lib/TestHost/AppDelegate.swift

@@ -42,7 +42,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
 
     var window: UIWindow?
 
-    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey : Any]? = nil) -> Bool {
         return true
     }
 }