[Base64] Fix: Dont add line separators in last line when last line fits (#1184)

Author: fabianfett

Sources/FoundationEssentials/Data/Data+Base64.swift

@@ -351,16 +351,8 @@ extension Base64 {
         Self.withUnsafeEncodingTablesAsBufferPointers(options: options) { (e0, e1) throws(Never) -> Void in
             let to = input.count / 3 * 3
             var outIndex = 0
-            for index in stride(from: 0, to: to, by: 3) {
-                let i1 = input[index]
-                let i2 = input[index &+ 1]
-                let i3 = input[index &+ 2]
-                buffer[outIndex] = e0[Int(i1)]
-                buffer[outIndex &+ 1] = e1[Int(((i1 & 0x03) &<< 4) | ((i2 &>> 4) & 0x0F))]
-                buffer[outIndex &+ 2] = e1[Int(((i2 & 0x0F) &<< 2) | ((i3 &>> 6) & 0x03))]
-                buffer[outIndex &+ 3] = e1[Int(i3)]
-                outIndex += 4
-            }
+
+            self.loopEncode(e0, e1, input: input, from: 0, to: to, output: buffer, outIndex: &outIndex)
 
             if to < input.count {
                 let index = to
@@ -435,37 +427,35 @@ extension Base64 {
 
         Self.withUnsafeEncodingTablesAsBufferPointers(options: options) { e0, e1 in
             var outIndex = 0
-            for lineInputIndex in stride(from: 0, to: lines * lineLength, by: lineLength) {
-                for index in stride(from: lineInputIndex, to: lineInputIndex + lineLength, by: 3) {
-                    let i1 = input[index]
-                    let i2 = input[index + 1]
-                    let i3 = input[index + 2]
-                    buffer[outIndex] = e0[Int(i1)]
-                    buffer[outIndex + 1] = e1[Int(((i1 & 0x03) << 4) | ((i2 >> 4) & 0x0F))]
-                    buffer[outIndex + 2] = e1[Int(((i2 & 0x0F) << 2) | ((i3 >> 6) & 0x03))]
-                    buffer[outIndex + 3] = e1[Int(i3)]
-                    outIndex += 4
-                }
 
+            // first full line
+            if input.count >= lineLength {
+                self.loopEncode(e0, e1, input: input, from: 0, to: lineLength, output: buffer, outIndex: &outIndex)
+            }
+
+            // following full lines
+            for lineInputIndex in stride(from: lineLength, to: lines * lineLength, by: lineLength) {
                 buffer[outIndex] = separatorByte1
                 outIndex += 1
                 if let separatorByte2 {
                     buffer[outIndex] = separatorByte2
                     outIndex += 1
                 }
+
+                self.loopEncode(e0, e1, input: input, from: lineInputIndex, to: lineInputIndex + lineLength, output: buffer, outIndex: &outIndex)
             }
 
-            let to = input.count / 3 * 3
-            for index in stride(from: lines * lineLength, to: to, by: 3) {
-                    let i1 = input[index]
-                    let i2 = input[index + 1]
-                    let i3 = input[index + 2]
-                    buffer[outIndex] = e0[Int(i1)]
-                    buffer[outIndex + 1] = e1[Int(((i1 & 0x03) << 4) | ((i2 >> 4) & 0x0F))]
-                    buffer[outIndex + 2] = e1[Int(((i2 & 0x0F) << 2) | ((i3 >> 6) & 0x03))]
-                    buffer[outIndex + 3] = e1[Int(i3)]
-                    outIndex += 4
+            // last line beginning
+            if lines > 0 && lines * lineLength < input.count {
+                buffer[outIndex] = separatorByte1
+                outIndex += 1
+                if let separatorByte2 {
+                    buffer[outIndex] = separatorByte2
+                    outIndex += 1
+                }
             }
+            let to = input.count / 3 * 3
+            self.loopEncode(e0, e1, input: input, from: lines * lineLength, to: to, output: buffer, outIndex: &outIndex)
 
             if to < input.count {
                 let index = to
@@ -504,6 +494,27 @@ extension Base64 {
         }
     }
 
+    private static func loopEncode(
+        _ e0: UnsafeBufferPointer<UInt8>,
+        _ e1: UnsafeBufferPointer<UInt8>,
+        input: UnsafeBufferPointer<UInt8>,
+        from: Int,
+        to: Int,
+        output: UnsafeMutableBufferPointer<UInt8>,
+        outIndex: inout Int
+    ) {
+        for index in stride(from: from, to: to, by: 3) {
+            let i1 = input[index]
+            let i2 = input[index + 1]
+            let i3 = input[index + 2]
+            output[outIndex] = e0[Int(i1)]
+            output[outIndex + 1] = e1[Int(((i1 & 0x03) << 4) | ((i2 >> 4) & 0x0F))]
+            output[outIndex + 2] = e1[Int(((i2 & 0x0F) << 2) | ((i3 >> 6) & 0x03))]
+            output[outIndex + 3] = e1[Int(i3)]
+            outIndex += 4
+        }
+    }
+
     static func encodeComputeCapacity(bytes: Int, options: Data.Base64EncodingOptions) -> Int {
         let capacityWithoutBreaks = ((bytes + 2) / 3) * 4
 

Tests/FoundationEssentialsTests/DataTests.swift

@@ -1902,6 +1902,36 @@ extension DataTests {
         )
     }
 
+    func test_base64Encode_DoesNotAddLineSeparatorsInLastLineWhenStringFitsInLine() {
+         XCTAssertEqual(
+             Data(repeating: 0, count: 48).base64EncodedString(options: .lineLength64Characters),
+            "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+        )
+
+         XCTAssertEqual(
+             Data(repeating: 0, count: 96).base64EncodedString(options: .lineLength64Characters),
+             """
+             AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n\
+             AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+             """,
+        )
+        print([UInt8](Data(repeating: 0, count: 96).base64EncodedString(options: .lineLength64Characters).utf8))
+
+        XCTAssertEqual(
+            Data(repeating: 0, count: 57).base64EncodedString(options: .lineLength76Characters),
+            "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+        )
+
+        XCTAssertEqual(
+            Data(repeating: 0, count: 114).base64EncodedString(options: .lineLength76Characters),
+            """
+            AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n\
+            AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+            """,
+        )
+
+    }
+
     func test_base64Decode_emptyString() {
         XCTAssertEqual(Data(), Data(base64Encoded: ""))
     }