Swift 3 - tests compile

CryptoSwiftTests/AESTests.swift

@@ -20,9 +20,9 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0xae,0x8c,0x59,0x95,0xb2,0x6f,0x8e,0x3d,0xb0,0x6f,0x0a,0xa5,0xfe,0xc4,0xf0,0xc2];
         
         let aes = try! AES(key: key, iv: iv, blockMode: .CBC, padding: NoPadding())
-        let encrypted = try! aes.encrypt(input)
+        let encrypted = try! aes.encrypt(bytes: input)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, input, "decryption failed")
     }
 
@@ -33,9 +33,9 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0xae,0x8c,0x59,0x95,0xb2,0x6f,0x8e,0x3d,0xb0,0x6f,0x0a,0xa5,0xfe,0xc4,0xf0,0xc2];
         
         let aes = try! AES(key: key, iv: iv, blockMode: .CBC, padding: NoPadding())
-        let encrypted = try! aes.encrypt(input)
+        let encrypted = try! aes.encrypt(bytes: input)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, input, "decryption failed")
     }
     
@@ -44,9 +44,9 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x4, 0x30, 0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a];
         
         let aes = try! AES(key: aesKey, blockMode: .ECB, padding: NoPadding())
-        let encrypted = try! aes.encrypt(input)
+        let encrypted = try! aes.encrypt(bytes: input)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, input, "decryption failed")
     }
 
@@ -57,9 +57,9 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0x76,0x49,0xab,0xac,0x81,0x19,0xb2,0x46,0xce,0xe9,0x8e,0x9b,0x12,0xe9,0x19,0x7d];
 
         let aes = try! AES(key: key, iv:iv, blockMode: .CBC, padding: NoPadding())
-        let encrypted = try! aes.encrypt(plaintext)
+        let encrypted = try! aes.encrypt(bytes: plaintext)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, plaintext, "decryption failed")
     }
 
@@ -70,9 +70,9 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0x76,0x49,0xab,0xac,0x81,0x19,0xb2,0x46,0xce,0xe9,0x8e,0x9b,0x12,0xe9,0x19,0x7d,0x89,0x64,0xe0,0xb1,0x49,0xc1,0x0b,0x7b,0x68,0x2e,0x6e,0x39,0xaa,0xeb,0x73,0x1c]
         
         let aes = try! AES(key: key, iv:iv, blockMode: .CBC, padding: PKCS7())
-        let encrypted = try! aes.encrypt(plaintext)
+        let encrypted = try! aes.encrypt(bytes: plaintext)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, plaintext, "decryption failed")
     }
 
@@ -89,7 +89,7 @@ final class AESTests: XCTestCase {
         ciphertext += try! encryptor.update(withBytes: Array(plaintext[8..<16]))
         ciphertext += try! encryptor.update(withBytes: Array(plaintext[16..<32]))
         ciphertext += try! encryptor.finish()
-        XCTAssertEqual(try! aes.encrypt(plaintext), ciphertext, "encryption failed")
+        XCTAssertEqual(try! aes.encrypt(bytes: plaintext), ciphertext, "encryption failed")
     }
 
     func testAES_encrypt_incremental() {
@@ -118,7 +118,7 @@ final class AESTests: XCTestCase {
         plaintext += try! decryptor.update(withBytes: Array(ciphertext[8..<16]))
         plaintext += try! decryptor.update(withBytes: Array(ciphertext[16..<32]))
         plaintext += try! decryptor.finish()
-        XCTAssertEqual(try! aes.decrypt(ciphertext), plaintext, "encryption failed")
+        XCTAssertEqual(try! aes.decrypt(bytes: ciphertext), plaintext, "encryption failed")
     }
 
     func testAES_encrypt_cfb() {
@@ -128,9 +128,9 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0x3b,0x3f,0xd9,0x2e,0xb7,0x2d,0xad,0x20,0x33,0x34,0x49,0xf8,0xe8,0x3c,0xfb,0x4a];
         
         let aes = try! AES(key: key, iv:iv, blockMode: .CFB, padding: NoPadding())
-        let encrypted = try! aes.encrypt(plaintext)
+        let encrypted = try! aes.encrypt(bytes: plaintext)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, plaintext, "decryption failed")
     }
 
@@ -139,8 +139,8 @@ final class AESTests: XCTestCase {
         let key: Array<UInt8> = [56, 118, 37, 51, 125, 78, 103, 107, 119, 40, 74, 88, 117, 112, 123, 75, 122, 89, 72, 36, 46, 91, 106, 60, 54, 110, 34, 126, 69, 126, 61, 87]
         let iv: Array<UInt8> = [69, 122, 99, 87, 83, 112, 110, 65, 54, 109, 107, 89, 73, 122, 74, 49]
         let plaintext: Array<UInt8> = [123, 10, 32, 32, 34, 67, 111, 110, 102, 105, 114, 109, 34, 32, 58, 32, 34, 116, 101, 115, 116, 105, 110, 103, 34, 44, 10, 32, 32, 34, 70, 105, 114, 115, 116, 78, 97, 109, 101, 34, 32, 58, 32, 34, 84, 101, 115, 116, 34, 44, 10, 32, 32, 34, 69, 109, 97, 105, 108, 34, 32, 58, 32, 34, 116, 101, 115, 116, 64, 116, 101, 115, 116, 46, 99, 111, 109, 34, 44, 10, 32, 32, 34, 76, 97, 115, 116, 78, 97, 109, 101, 34, 32, 58, 32, 34, 84, 101, 115, 116, 101, 114, 34, 44, 10, 32, 32, 34, 80, 97, 115, 115, 119, 111, 114, 100, 34, 32, 58, 32, 34, 116, 101, 115, 116, 105, 110, 103, 34, 44, 10, 32, 32, 34, 85, 115, 101, 114, 110, 97, 109, 101, 34, 32, 58, 32, 34, 84, 101, 115, 116, 34, 10, 125]
-        let encrypted: Array<UInt8> = try! AES(key: key, iv: iv, blockMode: .CFB).encrypt(plaintext)
-        let decrypted: Array<UInt8> = try! AES(key: key, iv: iv, blockMode: .CFB).decrypt(encrypted)
+        let encrypted: Array<UInt8> = try! AES(key: key, iv: iv, blockMode: .CFB).encrypt(bytes: plaintext)
+        let decrypted: Array<UInt8> = try! AES(key: key, iv: iv, blockMode: .CFB).decrypt(bytes: encrypted)
         XCTAssert(decrypted == plaintext, "decryption failed")
     }
 
@@ -151,9 +151,9 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0x3b,0x3f,0xd9,0x2e,0xb7,0x2d,0xad,0x20,0x33,0x34,0x49,0xf8,0xe8,0x3c,0xfb,0x4a];
 
         let aes = try! AES(key: key, iv:iv, blockMode: .OFB, padding: NoPadding())
-        let encrypted = try! aes.encrypt(plaintext)
+        let encrypted = try! aes.encrypt(bytes: plaintext)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, plaintext, "decryption failed")
     }
 
@@ -164,9 +164,9 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0xdc,0x7e,0x84,0xbf,0xda,0x79,0x16,0x4b,0x7e,0xcd,0x84,0x86,0x98,0x5d,0x38,0x60];
 
         let aes = try! AES(key: key, iv:iv, blockMode: .OFB, padding: NoPadding())
-        let encrypted = try! aes.encrypt(plaintext)
+        let encrypted = try! aes.encrypt(bytes: plaintext)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, plaintext, "decryption failed")
     }
 
@@ -177,10 +177,10 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0xf5,0x8c,0x4c,0x04,0xd6,0xe5,0xf1,0xba,0x77,0x9e,0xab,0xfb,0x5f,0x7b,0xfb,0xd6];
 
         let aes = try! AES(key: key, iv:iv, blockMode: .PCBC, padding: NoPadding())
-        let encrypted = try! aes.encrypt(plaintext)
+        let encrypted = try! aes.encrypt(bytes: plaintext)
         print(encrypted.toHexString())
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, plaintext, "decryption failed")
     }
 
@@ -191,9 +191,9 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0x87,0x4d,0x61,0x91,0xb6,0x20,0xe3,0x26,0x1b,0xef,0x68,0x64,0x99,0x0d,0xb6,0xce]
         
         let aes = try! AES(key: key, iv:iv, blockMode: .CTR, padding: NoPadding())
-        let encrypted = try! aes.encrypt(plaintext)
+        let encrypted = try! aes.encrypt(bytes: plaintext)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, plaintext, "decryption failed")
     }
 
@@ -204,44 +204,44 @@ final class AESTests: XCTestCase {
         let expected:Array<UInt8> = [0x87,0x4d,0x61,0x91,0xb6,0x20,0xe3,0x26,0x1b,0xef,0x68,0x64,0x99,0x0d,0xb6,0xce,0x37]
 
         let aes = try! AES(key: key, iv:iv, blockMode: .CTR, padding: NoPadding())
-        let encrypted = try! aes.encrypt(plaintext)
+        let encrypted = try! aes.encrypt(bytes: plaintext)
         XCTAssertEqual(encrypted, expected, "encryption failed")
-        let decrypted = try! aes.decrypt(encrypted)
+        let decrypted = try! aes.decrypt(bytes: encrypted)
         XCTAssertEqual(decrypted, plaintext, "decryption failed")
     }
 
     func testAES_encrypt_performance() {
         let key:Array<UInt8> = [0x2b,0x7e,0x15,0x16,0x28,0xae,0xd2,0xa6,0xab,0xf7,0x15,0x88,0x09,0xcf,0x4f,0x3c];
         let iv:Array<UInt8> = [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F]
-        let message = Array<UInt8>(count: 1024 * 1024, repeatedValue: 7)
+        let message = Array<UInt8>(repeating: 7, count: 1024 * 1024)
         let aes = try! AES(key: key, iv: iv, blockMode: .CBC, padding: PKCS7())
-        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: true, forBlock: { () -> Void in
-            try! aes.encrypt(message)
+        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: true, for: { () -> Void in
+            try! aes.encrypt(bytes: message)
         })
     }
 
     func testAES_decrypt_performance() {
         let key:Array<UInt8> = [0x2b,0x7e,0x15,0x16,0x28,0xae,0xd2,0xa6,0xab,0xf7,0x15,0x88,0x09,0xcf,0x4f,0x3c];
         let iv:Array<UInt8> = [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F]
-        let message = Array<UInt8>(count: 1024 * 1024, repeatedValue: 7)
+        let message = Array<UInt8>(repeating: 7, count: 1024 * 1024)
         let aes = try! AES(key: key, iv: iv, blockMode: .CBC, padding: PKCS7())
-        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: true, forBlock: { () -> Void in
-            try! aes.decrypt(message)
+        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: true, for: { () -> Void in
+            try! aes.decrypt(bytes: message)
         })
     }
 
     func testAESPerformanceCommonCrypto() {
         let key:Array<UInt8> = [0x2b,0x7e,0x15,0x16,0x28,0xae,0xd2,0xa6,0xab,0xf7,0x15,0x88,0x09,0xcf,0x4f,0x3c];
         let iv:Array<UInt8> = [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F]
-        let message = Array<UInt8>(count: 1024 * 1024, repeatedValue: 7)
+        let message = Array<UInt8>(repeating: 7, count: 1024 * 1024)
         
-        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, forBlock: { () -> Void in
-            let keyData     = NSData.withBytes(key)
+        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: { () -> Void in
+            let keyData     = NSData.withBytes(bytes: key)
             let keyBytes    = UnsafePointer<Void>(keyData.bytes)
-            let ivData      = NSData.withBytes(iv)
+            let ivData      = NSData.withBytes(bytes: iv)
             let ivBytes     = UnsafePointer<Void>(ivData.bytes)
             
-            let data = NSData.withBytes(message)
+            let data = NSData.withBytes(bytes: message)
             let dataLength    = data.length
             let dataBytes     = UnsafePointer<Void>(data.bytes)
             
@@ -277,8 +277,8 @@ final class AESTests: XCTestCase {
 
         let aes = try! AES(key: key, iv:iv, blockMode: .CBC, padding: PKCS7())
         let aes2 = try! AES(key: key2, iv:iv, blockMode: .CBC, padding: PKCS7())
-        let encrypted = try! aes.encrypt(plaintext)
-        let decrypted = try? aes2.decrypt(encrypted)
+        let encrypted = try! aes.encrypt(bytes: plaintext)
+        let decrypted = try? aes2.decrypt(bytes: encrypted)
         XCTAssertTrue(decrypted! != plaintext, "failed")
     }
 

CryptoSwiftTests/ChaCha20Tests.swift

@@ -48,15 +48,15 @@ final class ChaCha20Tests: XCTestCase {
             let message = Array<UInt8>(repeating: 0, count: (expectedHex.characters.count / 2))
             
             do {
-                let encrypted = try ChaCha20(key: keys[idx], iv: ivs[idx])!.encrypt(message)
-                let decrypted = try ChaCha20(key: keys[idx], iv: ivs[idx])!.decrypt(encrypted)
+                let encrypted = try ChaCha20(key: keys[idx], iv: ivs[idx])!.encrypt(bytes: message)
+                let decrypted = try ChaCha20(key: keys[idx], iv: ivs[idx])!.decrypt(bytes: encrypted)
                 XCTAssertEqual(message, decrypted, "ChaCha20 decryption failed");
                 
                 // check extension
                 let messageData = NSData(bytes: message, length: message.count);
-                let encrypted2 = try! messageData.encrypt(ChaCha20(key: keys[idx], iv: ivs[idx])!)
+                let encrypted2 = try! messageData.encrypt(cipher: ChaCha20(key: keys[idx], iv: ivs[idx])!)
                 XCTAssertNotNil(encrypted2, "")
-                XCTAssertEqual(NSData.withBytes(encrypted), encrypted2, "ChaCha20 extension failed")
+                XCTAssertEqual(NSData.withBytes(bytes: encrypted), encrypted2, "ChaCha20 extension failed")
             } catch CipherError.Encrypt {
                 XCTAssert(false, "Encryption failed")
             } catch CipherError.Decrypt {
@@ -75,16 +75,16 @@ final class ChaCha20Tests: XCTestCase {
 
         print(message.count)
 
-        let encrypted = try! ChaCha20(key: key, iv: iv)!.encrypt(message)
+        let encrypted = try! ChaCha20(key: key, iv: iv)!.encrypt(bytes: message)
         XCTAssertEqual(encrypted, expected, "Ciphertext failed")
     }
 
     func testChaCha20Performance() {
         let key:Array<UInt8> = [0x2b,0x7e,0x15,0x16,0x28,0xae,0xd2,0xa6,0xab,0xf7,0x15,0x88,0x09,0xcf,0x4f,0x3c];
         let iv:Array<UInt8> = [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F]
-        let message = Array<UInt8>(count: (1024 * 1024) * 1, repeatedValue: 7)
-        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: true, forBlock: { () -> Void in
-            let encrypted = try! ChaCha20(key: key, iv: iv)?.encrypt(message)
+        let message = Array<UInt8>(repeating: 7, count: (1024 * 1024) * 1)
+        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: true, for: { () -> Void in
+            let encrypted = try! ChaCha20(key: key, iv: iv)?.encrypt(bytes: message)
             self.stopMeasuring()
             XCTAssert(encrypted != nil, "not encrypted")
         })

CryptoSwiftTests/ExtensionsTest.swift

@@ -19,10 +19,10 @@ final class ExtensionsTest: XCTestCase {
     }
 
     func testArrayChunksPerformance() {
-        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, forBlock: { () -> Void in
-            let message = Array<UInt8>(count: 1024 * 1024, repeatedValue: 7)
+        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: { () -> Void in
+            let message = Array<UInt8>(repeating: 7, count: 1024 * 1024)
             self.startMeasuring()
-            message.chunks(AES.blockSize)
+            message.chunks(chunksize: AES.blockSize)
             self.stopMeasuring()
         })
     }
@@ -30,14 +30,14 @@ final class ExtensionsTest: XCTestCase {
     
     func testIntExtension() {
         let i1:Int = 1024
-        let i1Array = i1.bytes(32 / 8) // 32 bit
-        let i1recovered = Int.withBytes(i1Array)
+        let i1Array = i1.bytes(totalBytes: 32 / 8) // 32 bit
+        let i1recovered = Int.withBytes(bytes: i1Array)
         
         XCTAssertEqual(i1, i1recovered, "Bytes conversion failed")
         
         let i2:Int = 1024
-        let i2Array = i2.bytes(160 / 8) // 160 bit
-        let i2recovered = Int.withBytes(i2Array)
+        let i2Array = i2.bytes(totalBytes: 160 / 8) // 160 bit
+        let i2recovered = Int.withBytes(bytes: i2Array)
         
         XCTAssertEqual(i2, i2recovered, "Bytes conversion failed")
     }
@@ -50,7 +50,7 @@ final class ExtensionsTest: XCTestCase {
         XCTAssertTrue(bytes.count == size, "Invalid bytes length =  \(bytes.count)")
         
         // test padding
-        bytes = i.bytes(16)
+        bytes = i.bytes(totalBytes: 16)
         XCTAssertTrue(bytes.count == 16, "Invalid return type \(bytes.count)")
         XCTAssertTrue(bytes[14] == 4, "Invalid return type \(bytes.count)")
     }
@@ -78,7 +78,7 @@ final class ExtensionsTest: XCTestCase {
     
     func testtoUInt32Array() {
         let chunk:ArraySlice<UInt8> = [1,1,1,7,2,3,4,5]
-        let result = toUInt32Array(chunk)
+        let result = toUInt32Array(slice: chunk)
         
         XCTAssert(result.count == 2, "Invalid conversion")
         XCTAssert(result[0] == 117506305, "Invalid conversion")
@@ -91,13 +91,13 @@ final class ExtensionsTest: XCTestCase {
     }
 
     func test_String_encrypt_base64() {
-        let encryptedBase64 = try! "my secret string".encrypt(AES(key: "secret0key000000", iv: "0123456789012345")).toBase64()
+        let encryptedBase64 = try! "my secret string".encrypt(cipher: AES(key: "secret0key000000", iv: "0123456789012345")).toBase64()
         XCTAssertEqual(encryptedBase64, "aPf/i9th9iX+vf49eR7PYk2q7S5xmm3jkRLejgzHNJs=")
     }
 
     func test_String_decrypt_base64() {
         let encryptedBase64 = "aPf/i9th9iX+vf49eR7PYk2q7S5xmm3jkRLejgzHNJs="
-        let decrypted = try! encryptedBase64.decryptBase64ToString(AES(key: "secret0key000000", iv: "0123456789012345"))
+        let decrypted = try! encryptedBase64.decryptBase64ToString(cipher: AES(key: "secret0key000000", iv: "0123456789012345"))
         XCTAssertEqual(decrypted, "my secret string")
     }
 

CryptoSwiftTests/HMACTests.swift

@@ -24,7 +24,7 @@ final class HMACTests: XCTestCase {
         let msg:Array<UInt8> = []
         let expectedMac:Array<UInt8> = [0x74,0xe6,0xf7,0x29,0x8a,0x9c,0x2d,0x16,0x89,0x35,0xf5,0x8c,0x00,0x1b,0xad,0x88]
         
-        let hmac = try! Authenticator.HMAC(key: key, variant: .md5).authenticate(msg)
+        let hmac = try! Authenticator.HMAC(key: key, variant: .md5).authenticate(message: msg)
         XCTAssertEqual(hmac, expectedMac, "Invalid authentication result")
     }
     
@@ -33,7 +33,7 @@ final class HMACTests: XCTestCase {
         let msg:Array<UInt8> = []
         let expectedMac:Array<UInt8> = [0xfb,0xdb,0x1d,0x1b,0x18,0xaa,0x6c,0x08,0x32,0x4b,0x7d,0x64,0xb7,0x1f,0xb7,0x63,0x70,0x69,0x0e,0x1d]
         
-        let hmac = try! Authenticator.HMAC(key: key, variant: .sha1).authenticate(msg)
+        let hmac = try! Authenticator.HMAC(key: key, variant: .sha1).authenticate(message: msg)
         XCTAssertEqual(hmac, expectedMac, "Invalid authentication result")
     }
 
@@ -42,7 +42,7 @@ final class HMACTests: XCTestCase {
         let msg:Array<UInt8> = []
         let expectedMac:Array<UInt8> = [0xb6,0x13,0x67,0x9a,0x08,0x14,0xd9,0xec,0x77,0x2f,0x95,0xd7,0x78,0xc3,0x5f,0xc5,0xff,0x16,0x97,0xc4,0x93,0x71,0x56,0x53,0xc6,0xc7,0x12,0x14,0x42,0x92,0xc5,0xad]
         
-        let hmac = try! Authenticator.HMAC(key: key, variant: .sha256).authenticate(msg)
+        let hmac = try! Authenticator.HMAC(key: key, variant: .sha256).authenticate(message: msg)
         XCTAssertEqual(hmac, expectedMac, "Invalid authentication result")
     }
 
@@ -51,7 +51,7 @@ final class HMACTests: XCTestCase {
         let msg:Array<UInt8> = []
         let expectedMac:Array<UInt8> = [0x6c, 0x1f, 0x2e, 0xe9, 0x38, 0xfa, 0xd2, 0xe2, 0x4b, 0xd9, 0x12, 0x98, 0x47, 0x43, 0x82, 0xca, 0x21, 0x8c, 0x75, 0xdb, 0x3d, 0x83, 0xe1, 0x14, 0xb3, 0xd4, 0x36, 0x77, 0x76, 0xd1, 0x4d, 0x35, 0x51, 0x28, 0x9e, 0x75, 0xe8, 0x20, 0x9c, 0xd4, 0xb7, 0x92, 0x30, 0x28, 0x40, 0x23, 0x4a, 0xdc]
 
-        let hmac = try! Authenticator.HMAC(key: key, variant: .sha384).authenticate(msg)
+        let hmac = try! Authenticator.HMAC(key: key, variant: .sha384).authenticate(message: msg)
         XCTAssertEqual(hmac, expectedMac, "Invalid authentication result")
     }
 
@@ -60,7 +60,7 @@ final class HMACTests: XCTestCase {
         let msg:Array<UInt8> = []
         let expectedMac:Array<UInt8> = [0xb9, 0x36, 0xce, 0xe8, 0x6c, 0x9f, 0x87, 0xaa, 0x5d, 0x3c, 0x6f, 0x2e, 0x84, 0xcb, 0x5a, 0x42, 0x39, 0xa5, 0xfe, 0x50, 0x48, 0x0a, 0x6e, 0xc6, 0x6b, 0x70, 0xab, 0x5b, 0x1f, 0x4a, 0xc6, 0x73, 0x0c, 0x6c, 0x51, 0x54, 0x21, 0xb3, 0x27, 0xec, 0x1d, 0x69, 0x40, 0x2e, 0x53, 0xdf, 0xb4, 0x9a, 0xd7, 0x38, 0x1e, 0xb0, 0x67, 0xb3, 0x38, 0xfd, 0x7b, 0x0c, 0xb2, 0x22, 0x47, 0x22, 0x5d, 0x47]
 
-        let hmac = try! Authenticator.HMAC(key: key, variant: .sha512).authenticate(msg)
+        let hmac = try! Authenticator.HMAC(key: key, variant: .sha512).authenticate(message: msg)
         XCTAssertEqual(hmac, expectedMac, "Invalid authentication result")
     }
 }

CryptoSwiftTests/HashTests.swift

@@ -25,7 +25,7 @@ final class CryptoSwiftTests: XCTestCase {
     }
 
     func testMD5_emptyString() {
-        let data:NSData = "".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)!
+        let data:NSData = "".data(using: NSUTF8StringEncoding, allowLossyConversion: false)!
         XCTAssertEqual(Hash.md5(data.arrayOfBytes()).calculate(), [0xd4,0x1d,0x8c,0xd9,0x8f,0x00,0xb2,0x04,0xe9,0x80,0x09,0x98,0xec,0xf8,0x42,0x7e], "MD5 calculation failed")
     }
 
@@ -41,31 +41,31 @@ final class CryptoSwiftTests: XCTestCase {
     }
     
     func testMD5PerformanceSwift() {
-        self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, forBlock: { () -> Void in
+        self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: { () -> Void in
             let buf = UnsafeMutablePointer<UInt8>(calloc(1024 * 1024, sizeof(UInt8)))
             let data = NSData(bytes: buf, length: 1024 * 1024)
             let arr = data.arrayOfBytes()
             self.startMeasuring()
                 Hash.md5(arr).calculate()
             self.stopMeasuring()
-            buf.dealloc(1024 * 1024)
-            buf.destroy()
+            buf?.deallocateCapacity(1024 * 1024)
+            buf?.deinitialize()
         })
     }
     
     func testMD5PerformanceCommonCrypto() {
-        self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, forBlock: { () -> Void in
+        self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: { () -> Void in
             let buf = UnsafeMutablePointer<UInt8>(calloc(1024 * 1024, sizeof(UInt8)))
             let data = NSData(bytes: buf, length: 1024 * 1024)
-            let outbuf = UnsafeMutablePointer<UInt8>.alloc(Int(CC_MD5_DIGEST_LENGTH))
+            let outbuf = UnsafeMutablePointer<UInt8>(allocatingCapacity: Int(CC_MD5_DIGEST_LENGTH))
             self.startMeasuring()
                 CC_MD5(data.bytes, CC_LONG(data.length), outbuf)
             //let output = NSData(bytes: outbuf, length: Int(CC_MD5_DIGEST_LENGTH));
             self.stopMeasuring()
-            outbuf.dealloc(Int(CC_MD5_DIGEST_LENGTH))
-            outbuf.destroy()
-            buf.dealloc(1024 * 1024)
-            buf.destroy()
+            outbuf.deallocateCapacity(Int(CC_MD5_DIGEST_LENGTH))
+            outbuf.deinitialize()
+            buf?.deallocateCapacity(1024 * 1024)
+            buf?.deinitialize()
         })
     }
     
@@ -119,25 +119,25 @@ final class CryptoSwiftTests: XCTestCase {
     
     func testCRC32() {
         let data:NSData = NSData(bytes: [49, 50, 51] as Array<UInt8>, length: 3)
-        if let crc = data.crc32(nil) {
+        if let crc = data.crc32(seed: nil) {
             XCTAssertEqual(crc.toHexString(), "884863d2", "CRC32 calculation failed");
         }
         
-        XCTAssertEqual("".crc32(nil), "00000000", "CRC32 calculation failed");
+        XCTAssertEqual("".crc32(seed: nil), "00000000", "CRC32 calculation failed");
     }
     
     func testCRC32NotReflected() {
         let bytes : Array<UInt8> = [0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39]
         let data:NSData = NSData(bytes: bytes, length: bytes.count)
-        if let crc = data.crc32(nil, reflect: false) {
+        if let crc = data.crc32(seed: nil, reflect: false) {
             XCTAssertEqual(crc.toHexString(), "fc891918", "CRC32 (with reflection) calculation failed");
         }
         
-        XCTAssertEqual("".crc32(nil, reflect: false), "00000000", "CRC32 (with reflection) calculation failed");
+        XCTAssertEqual("".crc32(seed: nil, reflect: false), "00000000", "CRC32 (with reflection) calculation failed");
     }
     
     func testCRC16() {
-        let result = CRC().crc16([49,50,51,52,53,54,55,56,57] as Array<UInt8>)
+        let result = CRC().crc16(message: [49,50,51,52,53,54,55,56,57] as Array<UInt8>)
         XCTAssert(result == 0xBB3D, "CRC16 failed")
     }
     

CryptoSwiftTests/Helpers.swift

@@ -7,8 +7,8 @@
 //
 
 func compareMatrix(a:[Array<UInt8>], b:[Array<UInt8>]) -> Bool {
-    for (i,arr) in a.enumerate() {
-        for (j,val) in arr.enumerate() {
+    for (i,arr) in a.enumerated() {
+        for (j,val) in arr.enumerated() {
             if (val != b[i][j]) {
                 print("Not equal: \(val) vs \(b[i][j])") //FIXME: remove verbose
                 return false

CryptoSwiftTests/PaddingTests.swift

@@ -12,27 +12,27 @@ final class PaddingTests: XCTestCase {
     func testPKCS7_0() {
         let input:Array<UInt8>    = [1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6]
         let expected:Array<UInt8> = [1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16]
-        let padded = PKCS7().add(input, blockSize: 16)
+        let padded = PKCS7().add(data: input, blockSize: 16)
         XCTAssertEqual(padded, expected, "PKCS7 failed")
-        let clean = PKCS7().remove(padded, blockSize: nil)
+        let clean = PKCS7().remove(data: padded, blockSize: nil)
         XCTAssertEqual(clean, input, "PKCS7 failed")
     }
     
     func testPKCS7_1() {
         let input:Array<UInt8>    = [1,2,3,4,5,6,7,8,9,0,1,2,3,4,5]
         let expected:Array<UInt8> = [1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,1]
-        let padded = PKCS7().add(input, blockSize: 16)
+        let padded = PKCS7().add(data: input, blockSize: 16)
         XCTAssertEqual(padded, expected, "PKCS7 failed")
-        let clean = PKCS7().remove(padded, blockSize: nil)
+        let clean = PKCS7().remove(data: padded, blockSize: nil)
         XCTAssertEqual(clean, input, "PKCS7 failed")
     }
     
     func testPKCS7_2() {
         let input:Array<UInt8>    = [1,2,3,4,5,6,7,8,9,0,1,2,3,4]
         let expected:Array<UInt8> = [1,2,3,4,5,6,7,8,9,0,1,2,3,4,2,2]
-        let padded = PKCS7().add(input, blockSize: 16)
+        let padded = PKCS7().add(data: input, blockSize: 16)
         XCTAssertEqual(padded, expected, "PKCS7 failed")
-        let clean = PKCS7().remove(padded, blockSize: nil)
+        let clean = PKCS7().remove(data: padded, blockSize: nil)
         XCTAssertEqual(clean, input, "PKCS7 failed")
     }
 }

CryptoSwiftTests/Poly1305Tests.swift

@@ -24,12 +24,12 @@ final class Poly1305Tests: XCTestCase {
         let msg:Array<UInt8> = [0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf,0xc0,0xc1]
         let expectedMac:Array<UInt8> = [0xdd,0xb9,0xda,0x7d,0xdd,0x5e,0x52,0x79,0x27,0x30,0xed,0x5c,0xda,0x5f,0x90,0xa4]
         
-        let mac = try! Authenticator.Poly1305(key: key).authenticate(msg)
+        let mac = try! Authenticator.Poly1305(key: key).authenticate(message: msg)
         XCTAssertEqual(mac, expectedMac, "Invalid authentication result")
         
         // extensions
-        let msgData = NSData.withBytes(msg)
-        let mac2 = try! msgData.authenticate(Authenticator.Poly1305(key: key))
-        XCTAssertEqual(mac2, NSData.withBytes(expectedMac), "Invalid authentication result")
+        let msgData = NSData.withBytes(bytes: msg)
+        let mac2 = try! msgData.authenticate(authenticator: Authenticator.Poly1305(key: key))
+        XCTAssertEqual(mac2, NSData.withBytes(bytes: expectedMac), "Invalid authentication result")
     }
 }

CryptoSwiftTests/RabbitTests.swift

@@ -72,9 +72,9 @@ class RabbitTests: XCTestCase {
         let plainText = Array<UInt8>(repeating: 0, count: 48)
         for (key, expectedCipher) in cases {
             let rabbit = Rabbit(key: key)!
-            let cipherText = rabbit.encrypt(plainText)
+            let cipherText = rabbit.encrypt(bytes: plainText)
             XCTAssertEqual(cipherText, expectedCipher)
-            XCTAssertEqual(rabbit.decrypt(cipherText), plainText)
+            XCTAssertEqual(rabbit.decrypt(bytes: cipherText), plainText)
         }
     }
     
@@ -111,18 +111,18 @@ class RabbitTests: XCTestCase {
         let plainText = Array<UInt8>(repeating: 0, count: 48)
         for (iv, expectedCipher) in cases {
             let rabbit = Rabbit(key: key, iv: iv)!
-            let cipherText = rabbit.encrypt(plainText)
+            let cipherText = rabbit.encrypt(bytes: plainText)
             XCTAssertEqual(cipherText, expectedCipher)
-            XCTAssertEqual(rabbit.decrypt(cipherText), plainText)
+            XCTAssertEqual(rabbit.decrypt(bytes: cipherText), plainText)
         }
     }
     
     func testRabbitPerformance() {
         let key: Array<UInt8> = Array<UInt8>(repeating: 0, count: Rabbit.keySize)
         let iv: Array<UInt8> = Array<UInt8>(repeating: 0, count: Rabbit.ivSize)
-        let message = Array<UInt8>(count: (1024 * 1024) * 1, repeatedValue: 7)
-        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: true, forBlock: { () -> Void in
-            let encrypted = Rabbit(key: key, iv: iv)?.encrypt(message)
+        let message = Array<UInt8>(repeating: 7, count: (1024 * 1024) * 1)
+        measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: true, for: { () -> Void in
+            let encrypted = Rabbit(key: key, iv: iv)?.encrypt(bytes: message)
             self.stopMeasuring()
             XCTAssert(encrypted != nil, "not encrypted")
         })