Add enum with associated value encoding tests

Add nested array encoding test

Add array within dictionary test

Formatting

Add keyed within unkeyed test

Add roundtrip test for keyed within keyed case

Update test to roundtrip for robustness

Add wrapped tests for encoding

Fix formatting

Tests/XMLCoderTests/CompositeChoiceTests.swift

@@ -47,40 +47,60 @@ extension IntOrStringWrapper: Codable {
     }
 }
 
-class CompositeChoiceTests: XCTestCase {
-    func testIntOrStringWrapper() throws {
-        let xml = """
-        <container>
-            <string>
-                <wrapped>A Word About Woke Times</wrapped>
-            </string>
-        </container>
-        """
-        let result = try XMLDecoder().decode(IntOrStringWrapper.self, from: xml.data(using: .utf8)!)
-        let expected = IntOrStringWrapper.string(StringWrapper(wrapped: "A Word About Woke Times"))
-        XCTAssertEqual(result, expected)
+class EnumAssociatedValueTestComposite: XCTestCase {
+    var encoder: XMLEncoder {
+        let encoder = XMLEncoder()
+        encoder.outputFormatting = [.prettyPrinted]
+        return encoder
     }
 
-    func testArrayOfIntOrStringWrappers() throws {
-        let xml = """
-        <container>
-            <string>
-                <wrapped>A Word About Woke Times</wrapped>
-            </string>
-            <int>
-                <wrapped>9000</wrapped>
-            </int>
-            <string>
-                <wrapped>A Word About Woke Tomes</wrapped>
-            </string>
-        </container>
-        """
-        let result = try XMLDecoder().decode([IntOrStringWrapper].self, from: xml.data(using: .utf8)!)
-        let expected: [IntOrStringWrapper] = [
-            .string(StringWrapper(wrapped: "A Word About Woke Times")),
-            .int(IntWrapper(wrapped: 9000)),
-            .string(StringWrapper(wrapped: "A Word About Woke Tomes")),
-        ]
-        XCTAssertEqual(result, expected)
+    private let simpleString = IntOrStringWrapper.string(StringWrapper(wrapped: "A Word About Woke Times"))
+
+    private let xmlSimpleString = """
+    <container>
+        <string>
+            <wrapped>A Word About Woke Times</wrapped>
+        </string>
+    </container>
+    """
+
+    private let simpleArray: [IntOrStringWrapper] = [
+        .string(StringWrapper(wrapped: "A Word About Woke Times")),
+        .int(IntWrapper(wrapped: 9000)),
+        .string(StringWrapper(wrapped: "A Word About Woke Tomes")),
+    ]
+
+    private let xmlSimpleArray = """
+    <container>
+        <string>
+            <wrapped>A Word About Woke Times</wrapped>
+        </string>
+        <int>
+            <wrapped>9000</wrapped>
+        </int>
+        <string>
+            <wrapped>A Word About Woke Tomes</wrapped>
+        </string>
+    </container>
+    """
+
+    func testDecodeIntOrStringWrapper() throws {
+        let decoded = try XMLDecoder().decode(IntOrStringWrapper.self, from: xmlSimpleString.data(using: .utf8)!)
+        XCTAssertEqual(decoded, simpleString)
+    }
+
+    func testEncodeIntOrStringWrapper() throws {
+        let encoded = try encoder.encode(simpleString, withRootKey: "container")
+        XCTAssertEqual(String(data: encoded, encoding: .utf8), xmlSimpleString)
+    }
+
+    func testDecodeArrayOfIntOrStringWrappers() throws {
+        let decoded = try XMLDecoder().decode([IntOrStringWrapper].self, from: xmlSimpleArray.data(using: .utf8)!)
+        XCTAssertEqual(decoded, simpleArray)
+    }
+
+    func testEncodeArrayOfIntOrStringWrappers() throws {
+        let encoded = try encoder.encode(simpleArray, withRootKey: "container")
+        XCTAssertEqual(String(data: encoded, encoding: .utf8), xmlSimpleArray)
     }
 }

Tests/XMLCoderTests/NestingTests.swift

@@ -25,107 +25,125 @@ final class NestingTests: XCTestCase {
         [1, 2, 3],
     ]
 
+    let xmlUnkeyedWithinUnkeyed =
+        """
+        <element>
+            <element>
+                <element>1</element>
+                <element>2</element>
+                <element>3</element>
+            </element>
+            <element>
+                <element>1</element>
+                <element>2</element>
+                <element>3</element>
+            </element>
+        </element>
+        """
+
     let unkeyedWithinKeyed: [String: [Int]] = [
         "first": [1, 2, 3],
         "second": [1, 2, 3],
     ]
 
+    let xmlUnkeyedWithinKeyed =
+        """
+        <element>
+            <first>1</first>
+            <first>2</first>
+            <first>3</first>
+            <second>1</second>
+            <second>2</second>
+            <second>3</second>
+        </element>
+        """
+
     let keyedWithinUnkeyed: [[String: Int]] = [
         ["first": 1],
         ["second": 2],
     ]
 
+    let xmlKeyedWithinUnkeyed =
+        """
+        <element>
+            <element>
+                <first>1</first>
+            </element>
+            <element>
+                <second>2</second>
+            </element>
+        </element>
+        """
+
     let keyedWithinKeyed: [String: [String: Int]] = [
         "first": ["a": 1, "b": 2],
         "second": ["c": 3, "d": 4],
     ]
 
+    let xmlKeyedWithinKeyed =
+        """
+        <element>
+            <first>
+                <b>2</b>
+                <a>1</a>
+            </first>
+            <second>
+                <c>3</c>
+                <d>4</d>
+            </second>
+        </element>
+        """
+
     func testEncodeUnkeyedWithinUnkeyed() throws {
-        XCTAssertNoThrow(try encoder.encode(unkeyedWithinUnkeyed, withRootKey: "element"))
+        let encoded = try encoder.encode(unkeyedWithinUnkeyed, withRootKey: "element")
+        XCTAssertEqual(String(data: encoded, encoding: .utf8), xmlUnkeyedWithinUnkeyed)
     }
 
     func testEncodeUnkeyedWithinKeyed() throws {
-        XCTAssertNoThrow(try encoder.encode(unkeyedWithinKeyed, withRootKey: "element"))
+        let encoded = try encoder.encode(unkeyedWithinKeyed, withRootKey: "element")
+        let decoded = try decoder.decode([String: [Int]].self, from: encoded)
+        XCTAssertEqual(decoded, unkeyedWithinKeyed)
     }
 
     func testEncodeKeyedWithinUnkeyed() throws {
-        XCTAssertNoThrow(try encoder.encode(keyedWithinUnkeyed, withRootKey: "element"))
+        let encoded = try encoder.encode(keyedWithinUnkeyed, withRootKey: "element")
+        XCTAssertEqual(String(data: encoded, encoding: .utf8), xmlKeyedWithinUnkeyed)
     }
 
     func testEncodeKeyedWithinKeyed() throws {
-        XCTAssertNoThrow(try encoder.encode(keyedWithinKeyed, withRootKey: "element"))
+        let encoded = try encoder.encode(keyedWithinKeyed, withRootKey: "element")
+        let decoded = try decoder.decode([String: [String: Int]].self, from: encoded)
+        XCTAssertEqual(decoded, keyedWithinKeyed)
     }
 
     func testDecodeUnkeyedWithinUnkeyed() throws {
-        let xml =
-            """
-            <element>
-                <element>
-                    <element>1</element>
-                    <element>2</element>
-                    <element>3</element>
-                </element>
-                <element>
-                    <element>1</element>
-                    <element>2</element>
-                    <element>3</element>
-                </element>
-            </element>
-            """
-        let encoded = xml.data(using: .utf8)!
+        let encoded = xmlUnkeyedWithinUnkeyed.data(using: .utf8)!
+        let expected = [[1, 2, 3], [1, 2, 3]]
+        let decoded = try decoder.decode([[Int]].self, from: encoded)
 
         XCTAssertNoThrow(try decoder.decode(type(of: unkeyedWithinUnkeyed), from: encoded))
     }
 
     func testDecodeUnkeyedWithinKeyed() throws {
-        let xml =
-            """
-            <element>
-                <first>1</first>
-                <first>2</first>
-                <first>3</first>
-                <second>1</second>
-                <second>2</second>
-                <second>3</second>
-            </element>
-            """
-        let encoded = xml.data(using: .utf8)!
+        let encoded = xmlUnkeyedWithinKeyed.data(using: .utf8)!
+        let expected = ["first": [1, 2, 3], "second": [1, 2, 3]]
+        let decoded = try decoder.decode([String: [Int]].self, from: encoded)
 
         XCTAssertNoThrow(try decoder.decode(type(of: unkeyedWithinKeyed), from: encoded))
     }
 
     func testDecodeKeyedWithinUnkeyed() throws {
-        let xml =
-            """
-            <element>
-                <element>
-                    <first>1</first>
-                </element>
-                <element>
-                    <second>2</second>
-                </element>
-            </element>
-            """
-        let encoded = xml.data(using: .utf8)!
+        let encoded = xmlKeyedWithinUnkeyed.data(using: .utf8)!
+        let expected = [["first": 1], ["second": 2]]
+        let decoded = try decoder.decode([[String: Int]].self, from: encoded)
 
         XCTAssertNoThrow(try decoder.decode(type(of: keyedWithinUnkeyed), from: encoded))
     }
 
     func testDecodeKeyedWithinKeyed() throws {
-        let xml =
-            """
-            <element>
-                <first>
-                    <b>2</b>
-                    <a>1</a>
-                </first>
-                <second>
-                    <c>3</c>
-                    <d>4</d>
-                </second>
-            </element>
-            """
-        let encoded = xml.data(using: .utf8)!
+        let encoded = xmlKeyedWithinKeyed.data(using: .utf8)!
+        let expected = ["first": ["a": 1, "b": 2], "second": ["c": 3, "d": 4]]
+        let decoded = try decoder.decode([String: [String: Int]].self, from: encoded)
 
         XCTAssertNoThrow(try decoder.decode(type(of: keyedWithinKeyed), from: encoded))
     }