import Foundation
import XCTest

struct Model {
    struct SubModel: Encodable {
        var data: [Int]

        init(count: Int) {
            self.data = []
            self.data.reserveCapacity(count)

            for _ in 0..<count {
                self.data.append(Int.random(in: 0..<99999999))
            }
        }
    }

    internal enum Enum: Int, Encodable {
        case notRequested = 0
        case verified = 1
        case failed = 2

    }

    let submodel: SubModel
    let count: Int
    let result: Enum = .verified

    init(count: Int) {
        self.submodel = .init(count: count)
        self.count = count
    }
}

extension Model: Encodable {
    private enum CodingKeys: String, CodingKey {
        case submodel
        case count
        case result
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)

        try self.submodel.encode(to: encoder)
        try container.encode(self.count, forKey: .count)
        try container.encode(self.result, forKey: .result)
    }
}

let jsonEncoder = JSONEncoder()

extension Encodable {
    var asData: Data {
        get throws {
            return try jsonEncoder.encode(self)
        }
    }
}

private let model = Model(count: 1000000)

final class JSONRegressionTests: XCTestCase {

    func testComparison() throws {
        try XCTAssertEqual(model.asData, model.asData)
    }
}