Merge pull request #51 from orchetect/tcp-slip-hotfix

TCP SLIP Decoding Bug HotFix

Author: orchetect

Sources/OSCKit/TCP/Framing/SLIP Coding.swift

@@ -52,7 +52,7 @@ extension Data {
     ///
     /// This can accommodate one or more packets in the same data stream. Each packet is
     /// returned as an element in the array.
-    func slipDecoded() throws -> [Data] {
+    func slipDecoded() throws(OSCTCPSLIPDecodingError) -> [Data] {
         var packets: [Data] = []
 
         var currentPacketData = Data()
@@ -62,7 +62,9 @@ extension Data {
             switch self[index] {
             case SLIPByte.end.rawValue:
                 // END should never come after an escape byte
-                guard !isEscaped else { throw OSCTCPSLIPDecodingError.missingEscapedCharacter}
+                guard !isEscaped else {
+                    throw .missingEscapedCharacter
+                }
 
                 // consider the END byte the end of the current packet
                 if !currentPacketData.isEmpty {
@@ -74,34 +76,44 @@ extension Data {
 
             case SLIPByte.esc.rawValue:
                 // we should never get more than one consecutive ESC byte
-                guard !isEscaped else { throw OSCTCPSLIPDecodingError.doubleEscapeBytes}
+                guard !isEscaped else {
+                    throw .doubleEscapeBytes
+                }
 
                 isEscaped = true
 
             case SLIPByte.escEnd.rawValue:
-                // must follow an ESC byte
-                guard isEscaped else { throw OSCTCPSLIPDecodingError.missingEscapeByte}
-                isEscaped = false // reset ESC
-                
-                currentPacketData.append(SLIPByte.end.rawValue)
+                // if following an ESC byte, translate it
+                if isEscaped {
+                    isEscaped = false // reset ESC
+                    currentPacketData.append(SLIPByte.end.rawValue)
+                } else {
+                    currentPacketData.append(SLIPByte.escEnd.rawValue)
+                }
 
             case SLIPByte.escEsc.rawValue:
-                // must follow an ESC byte
-                guard isEscaped else { throw OSCTCPSLIPDecodingError.missingEscapeByte}
-                isEscaped = false // reset ESC
-                
-                currentPacketData.append(SLIPByte.esc.rawValue)
+                // if following an ESC byte, translate it
+                if isEscaped  {
+                    isEscaped = false // reset ESC
+                    currentPacketData.append(SLIPByte.esc.rawValue)
+                } else {
+                    currentPacketData.append(SLIPByte.escEsc.rawValue)
+                }
 
             default:
                 // the only two bytes that should follow an ESC byte are ESC_END and ESC_ESC
-                guard !isEscaped else { throw OSCTCPSLIPDecodingError.missingEscapedCharacter}
+                guard !isEscaped else {
+                    throw .missingEscapedCharacter
+                }
 
                 currentPacketData.append(self[index])
             }
         }
 
         // failsafe: ensure we are not ending while escaped (check if final byte was ESC)
-        guard !isEscaped else { throw OSCTCPSLIPDecodingError.missingEscapedCharacter}
+        guard !isEscaped else {
+            throw .missingEscapedCharacter
+        }
 
         // add final packet if needed
         if !currentPacketData.isEmpty {

Tests/OSCKitTests/TCP/SLIP Coding Tests.swift

@@ -123,21 +123,26 @@ import Testing
         }
     }
 
-    /// Test for error: encountering an escaped character without first receiving an ESC byte.
+    /// Encountering an escaped character without first receiving an ESC byte
+    /// should treat the byte as-is.
     @Test
     func dataSlipDecoded_MissingEscapeByte() throws {
-        #expect(throws: OSCTCPSLIPDecodingError.missingEscapeByte) {
+        #expect(
             try Data([END, 0x01, ESC_ESC, 0x02, END]).slipDecoded()
-        }
-        #expect(throws: OSCTCPSLIPDecodingError.missingEscapeByte) {
+            == [Data([0x01, ESC_ESC, 0x02])]
+        )
+        #expect(
             try Data([END, 0x01, ESC_END, 0x02, END]).slipDecoded()
-        }
-        #expect(throws: OSCTCPSLIPDecodingError.missingEscapeByte) {
+            == [Data([0x01, ESC_END, 0x02])]
+        )
+        #expect(
             try Data([END, ESC_ESC, END]).slipDecoded()
-        }
-        #expect(throws: OSCTCPSLIPDecodingError.missingEscapeByte) {
+            == [Data([ESC_ESC])]
+        )
+        #expect(
             try Data([END, ESC_END, END]).slipDecoded()
-        }
+            == [Data([ESC_END])]
+        )
     }
 
     /// Test for error: missing valid escaped character after receiving ESC byte.
@@ -170,4 +175,20 @@ import Testing
         let decodedData = try encodedData.slipDecoded()
         #expect(decodedData == [oscRawData])
     }
+    
+    /// Test encoding all possible byte values.
+    @Test
+    func allByteValuesSlipEncodeDecode() throws {
+        for value in UInt8(0) ... UInt8(255) {
+            let valueByte = Data([value])
+            let byteDescription = "Byte \(value.hexString(prefix: true))"
+            let encoded = valueByte.slipEncoded()
+            do {
+                let decoded = try encoded.slipDecoded()
+                #expect(decoded == [valueByte], "\(byteDescription)")
+            } catch {
+                Issue.record("\(byteDescription) error: \(error.localizedDescription)")
+            }
+        }
+    }
 }