CSVWriter tests updated

Author: dehesa

Sources/Active/Writer/Writer.swift

@@ -69,7 +69,7 @@ extension CSVWriter {
     public func endFile() throws {
         guard self.stream.streamStatus != .closed else { return }
 
-        if self.fieldIndex >= 0 {
+        if self.fieldIndex > 0 {
             try self.endRow()
         }
 
@@ -82,7 +82,7 @@ extension CSVWriter {
     /// - parameter field: The `String` to concatenate to the current CSV row.
     /// - throws: `CSVError<CSVWriter>` exclusively.
     public func write(field: String) throws {
-        guard self.expectedFields <= 0 || self.fieldIndex >= self.expectedFields else {
+        guard self.expectedFields <= 0 || self.fieldIndex <= self.expectedFields else {
             throw Error.fieldOverflow(expectedFields: self.expectedFields)
         }
 
@@ -100,7 +100,7 @@ extension CSVWriter {
     /// - parameter fields: A collection representing several fields (usually `[String]`).
     /// - throws: `CSVWriter.Error` exclusively.
     public func write<C:Collection>(fields: C) throws where C.Element == String {
-        guard self.expectedFields <= 0 || (self.fieldIndex + fields.count) >= self.expectedFields else {
+        guard self.expectedFields <= 0 || (self.fieldIndex + fields.count) <= self.expectedFields else {
             throw Error.fieldOverflow(expectedFields: self.expectedFields)
         }
 
@@ -122,7 +122,6 @@ extension CSVWriter {
             return try self.writeEmptyRow()
         }
 
-        // If this is the first row, fill the `expectedFields` variable.
         if self.expectedFields > 0 {
             try stride(from: self.fieldIndex, to: self.expectedFields, by: 1).forEach { [f = self.settings.delimiters.field] _ in
                 try self.lowlevelWrite(delimiter: f)

Tests/CodableCSVTests/ActiveTests/ReaderTests.swift

@@ -16,10 +16,54 @@ final class ReaderTests: XCTestCase {
     override func setUp() {
         self.continueAfterFailure = false
     }
+}
+
+// MARK: -
+
+extension ReaderTests {
+    /// The test data used for this file.
+    private enum TestData {
+        /// A CSV row representing a header row (4 fields).
+        static let headers   =  ["seq", "Name", "Country", "Number Pair"]
+        /// Small amount of regular CSV rows (4 fields per row).
+        static let content  =  [["1", "Marcos", "Spain", "99"],
+                                ["2", "Marine-Anaïs", "France", "88"],
+                                ["3", "Alex", "Germany", "77"],
+                                ["4", "Pei", "China", "66"]]
+        /// A bunch of rows each one containing an edge case.
+        static let edgeCases = [["", "Marcos", "Spaiñ", "99"],
+                                ["2", "Marine-Anaïs", #""Fra""nce""#, ""],
+                                ["", "", "", ""],
+                                ["4", "Pei", "China", #""\#n""#],
+                                ["", "", "", #""\#r\#n""#],
+                                ["5", #""A\#rh,me\#nd""#, "Egypt", #""\#r""#],
+                                ["6", #""Man""olo""#, "México", "100_000"]]
+        /// Exactly the same data as `contentEdgeCases`, but the quotes delimiting the beginning and end of a field have been removed.
+        ///
+        /// It is tipically used to check the result of parsing `contentEdgeCases`.
+        static let unescapedEdgeCases = [
+                                ["", "Marcos", "Spaiñ", "99"],
+                                ["2", "Marine-Anaïs", #"Fra"nce"#, ""],
+                                ["", "", "", ""],
+                                ["4", "Pei", "China", "\n"],
+                                ["", "", "", "\r\n"],
+                                ["5", "A\rh,me\nd", "Egypt", "\r"],
+                                ["6", #"Man"olo"#, "México", "100_000"]]
+        /// Encodes the test data into a Swift `String`.
+        /// - parameter sample:
+        /// - parameter delimiters: Unicode scalars to use to mark fields and rows.
+        /// - returns: Swift String representing the CSV file.
+        static func toCSV(_ sample: [[String]], delimiters: Delimiter.Pair) -> String {
+            let (f, r) = (String(delimiters.field.rawValue), String(delimiters.row.rawValue))
+            return sample.map { $0.joined(separator: f) }.joined(separator: r).appending(r)
+        }
+    }
 
     private typealias Encoded = (string: String, data: Data)
 }
 
+// MARK: -
+
 extension ReaderTests {
     /// Tests the correct parsing of an empty CSV.
     func testEmpty() throws {
@@ -30,8 +74,14 @@ extension ReaderTests {
 
     /// Tests the correct parsing of a single value CSV.
     func testSingleValue() throws {
+        let delimiters: Delimiter.Pair = (",", "\n")
         let input = [["Marine-Anaïs"]]
-        let parsed = try CSVReader.parse(input: input.toCSV() as String) { $0.headerStrategy = .none }
+        
+        let parsed = try CSVReader.parse(input: TestData.toCSV(input, delimiters: delimiters)) {
+            $0.delimiters = delimiters
+            $0.headerStrategy = .none
+        }
+        
         XCTAssertTrue(parsed.headers.isEmpty)
         XCTAssertEqual(parsed.rows, input)
     }
@@ -45,8 +95,7 @@ extension ReaderTests {
         let trimStrategy: [CharacterSet] = [.init(), .whitespaces]
         let presamples: [Bool] = [true, false]
         // The data used for testing.
-        let headers = TestData.headers
-        let content = TestData.content
+        let (headers, content) = (TestData.headers, TestData.content)
 
         // The actual testing implementation.
         let work: (_ configuration: CSVReader.Configuration, _ encoded: Encoded) throws -> Void = {
@@ -79,7 +128,9 @@ extension ReaderTests {
                     case .firstLine: input = [headers] + content
 //                    case .unknown: return XCTFail("Testing header inference is not yet supported")
                     }
-                    let encoded: Encoded = (input.toCSV(delimiters: pair), input.toCSV(delimiters: pair))
+                    
+                    let string = TestData.toCSV(input, delimiters: pair)
+                    let encoded: Encoded = (string, string.data(using: .utf8)!)
 
                     for t in trimStrategy {
                         var toTrim = t
@@ -112,9 +163,8 @@ extension ReaderTests {
         let trimStrategy: [CharacterSet] = [.init(), /*.whitespaces*/] // The whitespaces remove the row or field delimiters.
         let presamples: [Bool] = [true, false]
         // The data used for testing.
-        let headers = TestData.headers
-        let content = TestData.contentEdgeCases
-        let unescapedContent = TestData.contentUnescapedEdgeCases
+        let (headers, content) = (TestData.headers, TestData.edgeCases)
+        let unescapedContent = TestData.unescapedEdgeCases
 
         // The actual testing implementation.
         let work: (_ configuration: CSVReader.Configuration, _ encoded: Encoded) throws -> Void = {
@@ -146,7 +196,9 @@ extension ReaderTests {
                     case .firstLine: input = [headers] + content
 //                    case .unknown: return XCTFail("Testing header inference is not yet supported")
                     }
-                    let encoded: Encoded = (input.toCSV(delimiters: pair), input.toCSV(delimiters: pair))
+                    
+                    let string = TestData.toCSV(input, delimiters: pair)
+                    let encoded: Encoded = (string, string.data(using: .utf8)!)
 
                     for t in trimStrategy {
                         var toTrim = t
@@ -177,8 +229,7 @@ extension ReaderTests {
         let trimStrategy: [CharacterSet] = [.init(), .whitespaces]
         let presamples: [Bool] = [true, false]
         // The data used for testing.
-        let headers = TestData.headers
-        let content = TestData.content
+        let (headers, content) = (TestData.headers, TestData.content)
         let input = ([headers] + content).mappingRandomFields(count: 5) { [quote = Character("\"")] in
             guard !$0.hasPrefix(String(quote)) else { return $0 }
 
@@ -203,7 +254,9 @@ extension ReaderTests {
         for r in rowDelimiters {
             for f in fieldDelimiters {
                 let pair: Delimiter.Pair = (f, r)
-                let encoded: Encoded = (input.toCSV(delimiters: pair), input.toCSV(delimiters: pair))
+                
+                let string = TestData.toCSV(input, delimiters: pair)
+                let encoded: Encoded = (string, string.data(using: .utf8)!)
 
                 for t in trimStrategy {
                     var toTrim = t
@@ -232,14 +285,15 @@ extension ReaderTests {
         let fieldDelimiters: [Delimiter.Field] = [",", ";", "\t"]
         let presamples: [Bool] = [true, false]
         // The data used for testing.
-        let headers = TestData.headers
-        let content = TestData.content
+        let (headers, content) = (TestData.headers, TestData.content)
         let input = ([headers] + content).removingRandomFields(count: 2)
         // Iterate through all configuration values.
         for r in rowDelimiters {
             for f in fieldDelimiters {
                 let pair: Delimiter.Pair = (f, r)
-                let encoded: Encoded = (input.toCSV(delimiters: pair), input.toCSV(delimiters: pair))
+                
+                let string = TestData.toCSV(input, delimiters: pair)
+                let encoded: Encoded = (string, string.data(using: .utf8)!)
 
                 for p in presamples {
                     var c = CSVReader.Configuration()
@@ -253,3 +307,56 @@ extension ReaderTests {
         }
     }
 }
+
+// MARK: -
+
+fileprivate extension Array where Element == [String] {
+    /// Removes a random field from a random row.
+    /// - parameter num: The number of random fields to remove.
+    mutating func removeRandomFields(count: Int = 1) {
+        guard !self.isEmpty && !self.first!.isEmpty else {
+            fatalError("The receiving rows cannot be empty.")
+        }
+        
+        for _ in 0..<count {
+            let selectedRow = Int.random(in: 0..<self.count)
+            let selectedField = Int.random(in: 0..<self[selectedRow].count)
+            
+            let _ = self[selectedRow].remove(at: selectedField)
+        }
+    }
+    
+    /// Copies the receiving array and removes from it a random field from a random row.
+    /// - parameter num: The number of random fields to remove.
+    /// - returns: A copy of the receiving array lacking `count` number of fields.
+    func removingRandomFields(count: Int = 1) -> [[String]] {
+        var result = self
+        result.removeRandomFields(count: count)
+        return result
+    }
+
+    /// Transform a random field into the value returned in the argument closure.
+    /// - parameter num: The number of random fields to modify.
+    mutating func mapRandomFields(count: Int = 1, _ transform: (String) -> String) {
+        guard !self.isEmpty && !self.first!.isEmpty else {
+            fatalError("The receiving rows cannot be empty.")
+        }
+        
+        for _ in 0..<count {
+            let selectedRow = Int.random(in: 0..<self.count)
+            let selectedField = Int.random(in: 0..<self[selectedRow].count)
+            
+            self[selectedRow][selectedField] = transform(self[selectedRow][selectedField])
+        }
+    }
+    
+    /// Copies the receiving array and transforms a random field from it into another value.
+    /// - parameter num: The number of random fields to modify.
+    /// - returns: A copy of the receiving array with the `count` number of fields modified.
+    func mappingRandomFields(count: Int = 1, _ transform: (String) -> String) -> [[String]] {
+        var result = self
+        result.mapRandomFields(count: count, transform)
+        return result
+    }
+}
+