Snatch some of the Apple foundation tests to cover edge cases

[icanzilb]

Codable tests in the foundation repo:

• https://github.com/apple/swift-corelibs-foundation/blob/main/Tests/Foundation/Tests/TestCodable.swift
• https://github.com/apple/swift-corelibs-foundation/blob/main/Tests/Foundation/Tests/TestJSONEncoder.swift

These should help re-create some of the more difficult to hit scenarios like — when do you need a nested unkeyed container in an unkeyed container? Trying to have a [[Int]] property on a Codable struct doesn't seem to hit that codepath in the encoding container 🤷🏽‍♂️

[DivineDominion]

I really like the test helper and the naming (via https://github.com/apple/swift-corelibs-foundation/blob/main/Tests/Foundation/Tests/TestCodable.swift):

func expectRoundTripEquality<T : Codable>(of value: T, encode: (T) throws -> Data, decode: (Data) throws -> T) throws where T : Equatable  {
    do {
        let data = try encode(value)
        let decoded: T = try decode(data)
        if value != decoded {
            throw NSError(domain: "Decode mismatch", code: 0, userInfo: ["msg": "Decoded \(T.self) <\(decoded)> not equal to original <\(value)>"])
        }
    }
}

func expectRoundTripEqualityThroughJSON<T : Codable>(for value: T) throws where T : Equatable {
    let inf = "INF", negInf = "-INF", nan = "NaN"
    let encode = { (_ value: T) throws -> Data in
        let encoder = JSONEncoder()
        encoder.nonConformingFloatEncodingStrategy = .convertToString(positiveInfinity: inf,
                                                                      negativeInfinity: negInf,
                                                                      nan: nan)
        return try encoder.encode(value)
    }

    let decode = { (_ data: Data) throws -> T in
        let decoder = JSONDecoder()
        decoder.nonConformingFloatDecodingStrategy = .convertFromString(positiveInfinity: inf,
                                                                        negativeInfinity: negInf,
                                                                        nan: nan)
        return try decoder.decode(T.self, from: data)
    }

    try expectRoundTripEquality(of: value, encode: encode, decode: decode)
}