diff --git a/Cartfile.resolved b/Cartfile.resolved
index 0bff474..c433ad3 100644
--- a/Cartfile.resolved
+++ b/Cartfile.resolved
@@ -1,3 +1 @@
-github "daltoniam/Starscream" "3.0.4"
-github "daltoniam/common-crypto-spm" "1.1.0"
-github "daltoniam/zlib-spm" "1.1.0"
+github "daltoniam/Starscream" "3.0.5"
diff --git a/Tests/TestSocketIO/SocketBasicPacketTest.swift b/Tests/TestSocketIO/SocketBasicPacketTest.swift
index b1c36ad..e833d61 100644
--- a/Tests/TestSocketIO/SocketBasicPacketTest.swift
+++ b/Tests/TestSocketIO/SocketBasicPacketTest.swift
@@ -9,143 +9,180 @@
 import XCTest
 @testable import SocketIO
 
-class SocketBasicPacketTest: XCTestCase {
-    let data = "test".data(using: String.Encoding.utf8)!
-    let data2 = "test2".data(using: String.Encoding.utf8)!
-
-    func testEmpyEmit() {
-        let expectedSendString = "2[\"test\"]"
+class SocketBasicPacketTest : XCTestCase {
+    func testEmptyEmit() {
         let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testNullEmit() {
-        let expectedSendString = "2[\"test\",null]"
 		let sendData: [Any] = ["test", NSNull()]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testStringEmit() {
-        let expectedSendString = "2[\"test\",\"foo bar\"]"
         let sendData = ["test", "foo bar"]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testStringEmitWithQuotes() {
-        let expectedSendString = "2[\"test\",\"\\\"he\\\"llo world\\\"\"]"
         let sendData = ["test", "\"he\"llo world\""]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testJSONEmit() {
-        let expectedSendString = "2[\"test\",{\"null\":null,\"hello\":1,\"test\":\"hello\",\"foobar\":true}]"
         let sendData: [Any] = ["test", ["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testArrayEmit() {
-        let expectedSendString = "2[\"test\",[\"hello\",1,{\"test\":\"test\"}]]"
         let sendData: [Any] = ["test", ["hello", 1, ["test": "test"]]]
-        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testBinaryEmit() {
-        let expectedSendString = "51-[\"test\",{\"_placeholder\":true,\"num\":0}]"
         let sendData: [Any] = ["test", data]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .binaryEvent)
         XCTAssertEqual(packet.binary, [data])
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            "test",
+            ["_placeholder": true, "num": 0]
+        ]))
     }
 
     func testMultipleBinaryEmit() {
-        let expectedSendString = "52-[\"test\",{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
         let sendData: [Any] = ["test", ["data1": data, "data2": data2] as NSDictionary]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data2, data])
+        XCTAssertEqual(parsed.type, .binaryEvent)
+
+        let binaryObj = parsed.data[1] as! [String: Any]
+        let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
+        let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
+
+        XCTAssertEqual(packet.binary[data1Loc], data)
+        XCTAssertEqual(packet.binary[data2Loc], data2)
     }
 
     func testEmitWithAck() {
-        let expectedSendString = "20[\"test\"]"
         let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString,
-
-                       expectedSendString)
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testEmitDataWithAck() {
-        let expectedSendString = "51-0[\"test\",{\"_placeholder\":true,\"num\":0}]"
         let sendData: [Any] = ["test", data]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .binaryEvent)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            "test",
+            ["_placeholder": true, "num": 0]
+        ]))
         XCTAssertEqual(packet.binary, [data])
     }
 
     // Acks
     func testEmptyAck() {
-        let expectedSendString = "30[]"
-        let packet = SocketPacket.packetFromEmit([], id: 0, nsp: "/", ack: true)
+        let packetStr = SocketPacket.packetFromEmit([], id: 0, nsp: "/", ack: true).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: []))
     }
 
     func testNullAck() {
-        let expectedSendString = "30[null]"
         let sendData = [NSNull()]
-        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testStringAck() {
-        let expectedSendString = "30[\"test\"]"
         let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testJSONAck() {
-        let expectedSendString = "30[{\"null\":null,\"hello\":1,\"test\":\"hello\",\"foobar\":true}]"
         let sendData = [["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
-        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let packetStr = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true).packetString
+        let parsed = parser.parseSocketMessage(packetStr)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
 
     func testBinaryAck() {
-        let expectedSendString = "61-0[{\"_placeholder\":true,\"num\":0}]"
         let sendData = [data]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        XCTAssertEqual(parsed.type, .binaryAck)
         XCTAssertEqual(packet.binary, [data])
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            ["_placeholder": true, "num": 0]
+        ]))
     }
 
     func testMultipleBinaryAck() {
-        let expectedSendString = "62-0[{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
         let sendData = [["data1": data, "data2": data2]]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
 
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data2, data])
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertEqual(parsed.type, .binaryAck)
+
+        let binaryObj = parsed.data[0] as! [String: Any]
+        let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
+        let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
+
+        XCTAssertEqual(packet.binary[data1Loc], data)
+        XCTAssertEqual(packet.binary[data2Loc], data2)
     }
 
     func testBinaryStringPlaceholderInMessage() {
@@ -159,4 +196,20 @@ class SocketBasicPacketTest: XCTestCase {
         _ = packet.addData(data2)
         XCTAssertEqual(packet.args[0] as? String, "~~0")
     }
+
+    private func compareAnyArray(input: [Any], expected: [Any]) -> Bool {
+        guard input.count == expected.count else { return false }
+
+        return (input as NSArray).isEqual(to: expected)
+    }
+
+    let data = "test".data(using: String.Encoding.utf8)!
+    let data2 = "test2".data(using: String.Encoding.utf8)!
+    var parser: SocketParsable!
+
+    override func setUp() {
+        super.setUp()
+
+        parser = SocketManager(socketURL: URL(string: "http://localhost")!)
+    }
 }
diff --git a/Tests/TestSocketIO/SocketNamespacePacketTest.swift b/Tests/TestSocketIO/SocketNamespacePacketTest.swift
index 51a7ba4..d257453 100644
--- a/Tests/TestSocketIO/SocketNamespacePacketTest.swift
+++ b/Tests/TestSocketIO/SocketNamespacePacketTest.swift
@@ -9,133 +9,198 @@
 import XCTest
 @testable import SocketIO
 
-class SocketNamespacePacketTest: XCTestCase {
-    let data = "test".data(using: String.Encoding.utf8)!
-    let data2 = "test2".data(using: String.Encoding.utf8)!
-    
-    func testEmpyEmit() {
-        let expectedSendString = "2/swift,[\"test\"]"
+class SocketNamespacePacketTest : XCTestCase {
+    func testEmptyEmit() {
         let sendData: [Any] = ["test"]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
-    
+
     func testNullEmit() {
-        let expectedSendString = "2/swift,[\"test\",null]"
         let sendData: [Any] = ["test", NSNull()]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
-    
+
     func testStringEmit() {
-        let expectedSendString = "2/swift,[\"test\",\"foo bar\"]"
         let sendData: [Any] = ["test", "foo bar"]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
-    
+
     func testJSONEmit() {
-        let expectedSendString = "2/swift,[\"test\",{\"null\":null,\"test\":\"hello\",\"hello\":1,\"foobar\":true}]"
         let sendData: [Any] = ["test", ["foobar": true, "hello": 1, "test": "hello", "null": NSNull()] as NSDictionary]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
-    
+
     func testArrayEmit() {
-        let expectedSendString = "2/swift,[\"test\",[\"hello\",1,{\"test\":\"test\"},true]]"
         let sendData: [Any] = ["test", ["hello", 1, ["test": "test"], true]]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
-        
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
-    
+
     func testBinaryEmit() {
-        let expectedSendString = "51-/swift,[\"test\",{\"_placeholder\":true,\"num\":0}]"
         let sendData: [Any] = ["test", data]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .binaryEvent)
+        XCTAssertEqual(parsed.nsp, "/swift")
         XCTAssertEqual(packet.binary, [data])
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            "test",
+            ["_placeholder": true, "num": 0]
+        ]))
     }
-    
+
     func testMultipleBinaryEmit() {
-        let expectedSendString = "52-/swift,[\"test\",{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
         let sendData: [Any] = ["test", ["data1": data, "data2": data2] as NSDictionary]
         let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data2, data])
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .binaryEvent)
+        XCTAssertEqual(parsed.nsp, "/swift")
+
+        let binaryObj = parsed.data[1] as! [String: Any]
+        let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
+        let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
+
+        XCTAssertEqual(packet.binary[data1Loc], data)
+        XCTAssertEqual(packet.binary[data2Loc], data2)
     }
-    
+
     func testEmitWithAck() {
-        let expectedSendString = "2/swift,0[\"test\"]"
         let sendData = ["test"]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: false)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .event)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
-    
+
     func testEmitDataWithAck() {
-        let expectedSendString = "51-/swift,0[\"test\",{\"_placeholder\":true,\"num\":0}]"
         let sendData: [Any] = ["test", data]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: false)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data])
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .binaryEvent)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            "test",
+            ["_placeholder": true, "num": 0]
+        ]))
     }
-    
+
     // Acks
     func testEmptyAck() {
-        let expectedSendString = "3/swift,0[]"
         let packet = SocketPacket.packetFromEmit([], id: 0, nsp: "/swift", ack: true)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
     }
-    
+
     func testNullAck() {
-        let expectedSendString = "3/swift,0[null]"
         let sendData = [NSNull()]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
-    
+
     func testStringAck() {
-        let expectedSendString = "3/swift,0[\"test\"]"
         let sendData = ["test"]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
-    
+
     func testJSONAck() {
-        let expectedSendString = "3/swift,0[{\"null\":null,\"hello\":1,\"test\":\"hello\",\"foobar\":true}]"
         let sendData = [["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .ack)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: sendData))
     }
-    
+
     func testBinaryAck() {
-        let expectedSendString = "61-/swift,0[{\"_placeholder\":true,\"num\":0}]"
         let sendData = [data]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data])
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .binaryAck)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+        XCTAssertTrue(compareAnyArray(input: parsed.data, expected: [
+            ["_placeholder": true, "num": 0]
+        ]))
     }
-    
+
     func testMultipleBinaryAck() {
-        let expectedSendString = "62-/swift,0[{\"data2\":{\"_placeholder\":true,\"num\":0},\"data1\":{\"_placeholder\":true,\"num\":1}}]"
         let sendData = [["data1": data, "data2": data2]]
         let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
-        
-        XCTAssertEqual(packet.packetString, expectedSendString)
-        XCTAssertEqual(packet.binary, [data2, data])
+        let parsed = parser.parseSocketMessage(packet.packetString)!
+
+        XCTAssertEqual(parsed.type, .binaryAck)
+        XCTAssertEqual(parsed.nsp, "/swift")
+        XCTAssertEqual(parsed.id, 0)
+
+        let binaryObj = parsed.data[0] as! [String: Any]
+        let data1Loc = (binaryObj["data1"] as! [String: Any])["num"] as! Int
+        let data2Loc = (binaryObj["data2"] as! [String: Any])["num"] as! Int
+
+        XCTAssertEqual(packet.binary[data1Loc], data)
+        XCTAssertEqual(packet.binary[data2Loc], data2)
+    }
+
+    let data = "test".data(using: String.Encoding.utf8)!
+    let data2 = "test2".data(using: String.Encoding.utf8)!
+    var parser: SocketParsable!
+
+    private func compareAnyArray(input: [Any], expected: [Any]) -> Bool {
+        guard input.count == expected.count else { return false }
+
+        return (input as NSArray).isEqual(to: expected)
+    }
+
+    override func setUp() {
+        super.setUp()
+
+        parser = SocketManager(socketURL: URL(string: "http://localhost")!)
     }
 }