diff --git a/Old/AnyCodingKey.swift b/Old/AnyCodingKey.swift deleted file mode 100644 index a97bbff..0000000 --- a/Old/AnyCodingKey.swift +++ /dev/null @@ -1,68 +0,0 @@ -struct AnyCodingKey: CodingKey, Equatable { - var stringValue: String { - get { self._stringValue ?? "_do_not_use_this_string_value_use_the_int_value_instead_" } - } - - var _stringValue: String? - var intValue: Int? - - init(stringValue: String) { - self._stringValue = stringValue - self.intValue = nil - } - - init(intValue: Int) { - self.intValue = intValue - self._stringValue = nil - } - - init(_ base: Key, useStringKey: Bool = false) { - if !useStringKey, let intValue = base.intValue { - self.init(intValue: intValue) - } else { - self.init(stringValue: base.stringValue) - } - } - - func key() -> K { - if let intValue = self.intValue { - return K(intValue: intValue)! - } else if let stringValue = self._stringValue { - return K(stringValue: stringValue)! - } else { - fatalError("AnyCodingKey created without a string or int value") - } - } -} - -extension AnyCodingKey: Hashable { - public func hash(into hasher: inout Hasher) { - self.intValue?.hash(into: &hasher) ?? self._stringValue?.hash(into: &hasher) - } -} - -extension AnyCodingKey: Encodable { - func encode(to encoder: Encoder) throws { - var container = encoder.singleValueContainer() - if let intValue = self.intValue { - try container.encode(intValue) - } else if let stringValue = self._stringValue { - try container.encode(stringValue) - } else { - fatalError("AnyCodingKey created without a string or int value") - } - } -} - -extension AnyCodingKey: Decodable { - init(from decoder: Decoder) throws { - let value = try decoder.singleValueContainer() - if let intValue = try? value.decode(Int.self) { - self._stringValue = nil - self.intValue = intValue - } else { - self._stringValue = try! value.decode(String.self) - self.intValue = nil - } - } -} diff --git a/Old/CBOR.swift b/Old/CBOR.swift deleted file mode 100644 index e5270bc..0000000 --- a/Old/CBOR.swift +++ /dev/null @@ -1,179 +0,0 @@ -#if canImport(Foundation) -import Foundation -#endif - -public indirect enum CBOR : Equatable, Hashable, - ExpressibleByNilLiteral, ExpressibleByIntegerLiteral, ExpressibleByStringLiteral, - ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral, ExpressibleByBooleanLiteral, - ExpressibleByFloatLiteral { - - case unsignedInt(UInt64) - case negativeInt(UInt64) - case byteString([UInt8]) - case utf8String(String) - case array([CBOR]) - case map([CBOR : CBOR]) - case tagged(Tag, CBOR) - case simple(UInt8) - case boolean(Bool) - case null - case undefined - case half(Float32) - case float(Float32) - case double(Float64) - case `break` - #if canImport(Foundation) - case date(Date) - #endif - - public func hash(into hasher: inout Hasher) { - switch self { - case let .unsignedInt(l): l.hash(into: &hasher) - case let .negativeInt(l): l.hash(into: &hasher) - case let .byteString(l): Util.djb2Hash(l.map { Int($0) }).hash(into: &hasher) - case let .utf8String(l): l.hash(into: &hasher) - case let .array(l): Util.djb2Hash(l.map { $0.hashValue }).hash(into: &hasher) - case let .map(l): Util.djb2Hash(l.map { $0.hashValue &+ $1.hashValue }).hash(into: &hasher) - case let .tagged(t, l): t.hash(into: &hasher) - l.hash(into: &hasher) - case let .simple(l): l.hash(into: &hasher) - case let .boolean(l): l.hash(into: &hasher) - case .null: (-1).hash(into: &hasher) - case .undefined: (-2).hash(into: &hasher) - case let .half(l): l.hash(into: &hasher) - case let .float(l): l.hash(into: &hasher) - case let .double(l): l.hash(into: &hasher) - #if canImport(Foundation) - case let .date(l): l.hash(into: &hasher) - #endif - case .break: Int.min.hash(into: &hasher) - } - } - - public subscript(position: CBOR) -> CBOR? { - get { - switch (self, position) { - case (let .array(l), let .unsignedInt(i)): return l[Int(i)] - case (let .map(l), let i): return l[i] - default: return nil - } - } - set(x) { - switch (self, position) { - case (var .array(l), let .unsignedInt(i)): - l[Int(i)] = x! - self = .array(l) - case (var .map(l), let i): - l[i] = x! - self = .map(l) - default: break - } - } - } - - public init(nilLiteral: ()) { self = .null } - public init(integerLiteral value: Int) { - if value < 0 { - self = .negativeInt(~UInt64(bitPattern: Int64(value))) - } else { - self = .unsignedInt(UInt64(value)) - } - } - public init(extendedGraphemeClusterLiteral value: String) { self = .utf8String(value) } - public init(unicodeScalarLiteral value: String) { self = .utf8String(value) } - public init(stringLiteral value: String) { self = .utf8String(value) } - public init(arrayLiteral elements: CBOR...) { self = .array(elements) } - public init(dictionaryLiteral elements: (CBOR, CBOR)...) { - var result = [CBOR : CBOR]() - for (key, value) in elements { - result[key] = value - } - self = .map(result) - } - public init(booleanLiteral value: Bool) { self = .boolean(value) } - public init(floatLiteral value: Float32) { self = .float(value) } - - public static func ==(lhs: CBOR, rhs: CBOR) -> Bool { - switch (lhs, rhs) { - case (let .unsignedInt(l), let .unsignedInt(r)): return l == r - case (let .negativeInt(l), let .negativeInt(r)): return l == r - case (let .byteString(l), let .byteString(r)): return l == r - case (let .utf8String(l), let .utf8String(r)): return l == r - case (let .array(l), let .array(r)): return l == r - case (let .map(l), let .map(r)): return l == r - case (let .tagged(tl, l), let .tagged(tr, r)): return tl == tr && l == r - case (let .simple(l), let .simple(r)): return l == r - case (let .boolean(l), let .boolean(r)): return l == r - case (.null, .null): return true - case (.undefined, .undefined): return true - case (let .half(l), let .half(r)): return l == r - case (let .float(l), let .float(r)): return l == r - case (let .double(l), let .double(r)): return l == r - #if canImport(Foundation) - case (let .date(l), let .date(r)): return l == r - #endif - case (.break, .break): return true - case (.unsignedInt, _): return false - case (.negativeInt, _): return false - case (.byteString, _): return false - case (.utf8String, _): return false - case (.array, _): return false - case (.map, _): return false - case (.tagged, _): return false - case (.simple, _): return false - case (.boolean, _): return false - case (.null, _): return false - case (.undefined, _): return false - case (.half, _): return false - case (.float, _): return false - case (.double, _): return false - case (.break, _): return false - default: return false - } - } - - public struct Tag: RawRepresentable, Hashable, Sendable { - public let rawValue: UInt64 - - public init(rawValue: UInt64) { - self.rawValue = rawValue - } - - public var hashValue : Int { - return rawValue.hashValue - } - } -} - -extension CBOR.Tag { - public static let standardDateTimeString = CBOR.Tag(rawValue: 0) - public static let epochBasedDateTime = CBOR.Tag(rawValue: 1) - public static let positiveBignum = CBOR.Tag(rawValue: 2) - public static let negativeBignum = CBOR.Tag(rawValue: 3) - public static let decimalFraction = CBOR.Tag(rawValue: 4) - public static let bigfloat = CBOR.Tag(rawValue: 5) - - // 6...20 unassigned - - public static let expectedConversionToBase64URLEncoding = CBOR.Tag(rawValue: 21) - public static let expectedConversionToBase64Encoding = CBOR.Tag(rawValue: 22) - public static let expectedConversionToBase16Encoding = CBOR.Tag(rawValue: 23) - public static let encodedCBORDataItem = CBOR.Tag(rawValue: 24) - - // 25...31 unassigned - - public static let uri = CBOR.Tag(rawValue: 32) - public static let base64Url = CBOR.Tag(rawValue: 33) - public static let base64 = CBOR.Tag(rawValue: 34) - public static let regularExpression = CBOR.Tag(rawValue: 35) - public static let mimeMessage = CBOR.Tag(rawValue: 36) - public static let uuid = CBOR.Tag(rawValue: 37) - - // 38...55798 unassigned - - public static let selfDescribeCBOR = CBOR.Tag(rawValue: 55799) -} - -#if os(Linux) || os(Windows) || os(Android) -let NSEC_PER_SEC: UInt64 = 1_000_000_000 -#endif diff --git a/Old/CBORDecoder.swift b/Old/CBORDecoder.swift deleted file mode 100644 index 4e26806..0000000 --- a/Old/CBORDecoder.swift +++ /dev/null @@ -1,235 +0,0 @@ -#if canImport(Foundation) -import Foundation -#endif - -public enum CBORError : Error { - case unfinishedSequence - case wrongTypeInsideSequence - case tooLongSequence - case incorrectUTF8String - case maximumDepthExceeded -} - -extension CBOR { - static public func decode(_ input: [UInt8], options: CBOROptions = CBOROptions()) throws -> CBOR? { - return try CBORDecoder(input: input, options: options).decodeItem() - } -} - -public class CBORDecoder { - private var istream : CBORInputStream - public var options: CBOROptions - private var currentDepth = 0 - - public init(stream: CBORInputStream, options: CBOROptions = CBOROptions()) { - self.istream = stream - self.options = options - } - - public init(input: ArraySlice, options: CBOROptions = CBOROptions()) { - self.istream = ArraySliceUInt8(slice: input) - self.options = options - } - - public init(input: [UInt8], options: CBOROptions = CBOROptions()) { - self.istream = ArrayUInt8(array: ArraySlice(input)) - self.options = options - } - - func readBinaryNumber(_ type: T.Type) throws -> T { - Array(try self.istream.popBytes(MemoryLayout.size).reversed()).withUnsafeBytes { ptr in - return ptr.load(as: T.self) - } - } - - func readVarUInt(_ v: UInt8, base: UInt8) throws -> UInt64 { - guard v > base + 0x17 else { return UInt64(v - base) } - - switch VarUIntSize(rawValue: v) { - case .uint8: return UInt64(try readBinaryNumber(UInt8.self)) - case .uint16: return UInt64(try readBinaryNumber(UInt16.self)) - case .uint32: return UInt64(try readBinaryNumber(UInt32.self)) - case .uint64: return UInt64(try readBinaryNumber(UInt64.self)) - } - } - - func readLength(_ v: UInt8, base: UInt8) throws -> Int { - let n = try readVarUInt(v, base: base) - - guard n <= Int.max else { - throw CBORError.tooLongSequence - } - - return Int(n) - } - - private func readN(_ n: Int) throws -> [CBOR] { - return try (0.. [CBOR] { - var result: [CBOR] = [] - var cur = try decodeItem() - while cur != CBOR.break { - guard let curr = cur else { throw CBORError.unfinishedSequence } - result.append(curr) - cur = try decodeItem() - } - return result - } - - private func readNPairs(_ n: Int) throws -> [CBOR : CBOR] { - var result: [CBOR: CBOR] = [:] - for _ in (0.. [CBOR : CBOR] { - var result: [CBOR: CBOR] = [:] - var key = try decodeItem() - if key == CBOR.break { - return result - } - var val = try decodeItem() - while key != CBOR.break { - guard let okey = key else { throw CBORError.unfinishedSequence } - guard let oval = val else { throw CBORError.unfinishedSequence } - result[okey] = oval - do { key = try decodeItem() } catch CBORError.unfinishedSequence { key = nil } - guard (key != CBOR.break) else { break } // don't eat the val after the break! - do { val = try decodeItem() } catch CBORError.unfinishedSequence { val = nil } - } - return result - } - - public func decodeItem() throws -> CBOR? { - guard currentDepth <= options.maximumDepth - else { throw CBORError.maximumDepthExceeded } - - currentDepth += 1 - defer { currentDepth -= 1 } - let b = try istream.popByte() - - switch b { - // positive integers - case 0x00...0x1b: - return CBOR.unsignedInt(try readVarUInt(b, base: 0x00)) - - // negative integers - case 0x20...0x3b: - return CBOR.negativeInt(try readVarUInt(b, base: 0x20)) - - // byte strings - case 0x40...0x5b: - let numBytes = try readLength(b, base: 0x40) - return CBOR.byteString(Array(try istream.popBytes(numBytes))) - case 0x5f: - return CBOR.byteString(try readUntilBreak().flatMap { x -> [UInt8] in - guard case .byteString(let r) = x else { throw CBORError.wrongTypeInsideSequence } - return r - }) - - // utf-8 strings - case 0x60...0x7b: - let numBytes = try readLength(b, base: 0x60) - return CBOR.utf8String(try Util.decodeUtf8(try istream.popBytes(numBytes))) - case 0x7f: - return CBOR.utf8String(try readUntilBreak().map { x -> String in - guard case .utf8String(let r) = x else { throw CBORError.wrongTypeInsideSequence } - return r - }.joined(separator: "")) - - // arrays - case 0x80...0x9b: - let numBytes = try readLength(b, base: 0x80) - return CBOR.array(try readN(numBytes)) - case 0x9f: - return CBOR.array(try readUntilBreak()) - - // pairs - case 0xa0...0xbb: - let numBytes = try readLength(b, base: 0xa0) - let pairs = try readNPairs(numBytes) - if self.options.dateStrategy == .annotatedMap { - if let annotatedType = pairs[CBOR.utf8String(AnnotatedMapDateStrategy.typeKey)], - annotatedType == CBOR.utf8String(AnnotatedMapDateStrategy.typeValue), - let dateEpochTimestampCBOR = pairs[CBOR.utf8String(AnnotatedMapDateStrategy.valueKey)], - let date = try? getDateFromTimestamp(dateEpochTimestampCBOR) - { - return CBOR.date(date) - } - } - return CBOR.map(pairs) - case 0xbf: - return CBOR.map(try readPairsUntilBreak()) - - // tagged values - case 0xc0...0xdb: - let tag = try readVarUInt(b, base: 0xc0) - guard let item = try decodeItem() else { throw CBORError.unfinishedSequence } - #if canImport(Foundation) - if tag == 1 { - let date = try getDateFromTimestamp(item) - return CBOR.date(date) - } - #endif - return CBOR.tagged(CBOR.Tag(rawValue: tag), item) - - case 0xe0...0xf3: return CBOR.simple(b - 0xe0) - case 0xf4: return CBOR.boolean(false) - case 0xf5: return CBOR.boolean(true) - case 0xf6: return CBOR.null - case 0xf7: return CBOR.undefined - case 0xf8: return CBOR.simple(try istream.popByte()) - - case 0xf9: - return CBOR.half(Util.readFloat16(x: try readBinaryNumber(UInt16.self))) - case 0xfa: - return CBOR.float(try readBinaryNumber(Float32.self)) - case 0xfb: - return CBOR.double(try readBinaryNumber(Float64.self)) - - case 0xff: return CBOR.break - default: return nil - } - } -} - -func getDateFromTimestamp(_ item: CBOR) throws -> Date { - switch item { - case .double(let d): - return Date(timeIntervalSince1970: TimeInterval(d)) - case .negativeInt(let n): - return Date(timeIntervalSince1970: TimeInterval(-1 - Double(n))) - case .float(let f): - return Date(timeIntervalSince1970: TimeInterval(f)) - case .unsignedInt(let u): - return Date(timeIntervalSince1970: TimeInterval(u)) - default: - throw CBORError.wrongTypeInsideSequence - } -} - -private enum VarUIntSize: UInt8 { - case uint8 = 0 - case uint16 = 1 - case uint32 = 2 - case uint64 = 3 - - init(rawValue: UInt8) { - switch rawValue & 0b11 { - case 0: self = .uint8 - case 1: self = .uint16 - case 2: self = .uint32 - case 3: self = .uint64 - default: fatalError() // mask only allows values from 0-3 - } - } -} diff --git a/Old/CBOREncodable.swift b/Old/CBOREncodable.swift deleted file mode 100644 index 50cff6b..0000000 --- a/Old/CBOREncodable.swift +++ /dev/null @@ -1,263 +0,0 @@ -#if canImport(Foundation) -import Foundation -#endif - -public protocol CBOREncodable { - /// Optional function that can potentially serve as an opportunity to optimize encoding. - func encode(options: CBOROptions) -> [UInt8] - - /// Required function that returns the appropriate `CBOR` variant for a `CBOREncodable`-conforming value. - func toCBOR(options: CBOROptions) -> CBOR -} - -extension CBOREncodable { - func encode(options: CBOROptions) -> [UInt8] { - self.toCBOR(options: options).encode(options: options) - } -} - -extension CBOR: CBOREncodable { - /// Encodes a wrapped CBOR value. CBOR.half (Float16) is not supported and encodes as `undefined`. - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - switch self { - case let .unsignedInt(ui): return CBOR.encodeVarUInt(ui) - case let .negativeInt(ni): return CBOR.encodeNegativeInt(~Int64(bitPattern: ni)) - case let .byteString(bs): return CBOR.encodeByteString(bs, options: options) - case let .utf8String(str): return str.encode(options: options) - case let .array(a): return CBOR.encodeArray(a, options: options) - case let .map(m): return CBOR.encodeMap(m, options: options) - #if canImport(Foundation) - case let .date(d): return CBOR.encodeDate(d, options: options) - #endif - case let .tagged(t, l): return CBOR.encodeTagged(tag: t, value: l, options: options) - case let .simple(s): return CBOR.encodeSimpleValue(s) - case let .boolean(b): return b.encode(options: options) - case .null: return CBOR.encodeNull() - case .undefined: return CBOR.encodeUndefined() - case .half(_): return CBOR.undefined.encode(options: options) - case let .float(f): return f.encode() - case let .double(d): return d.encode() - case .break: return CBOR.encodeBreak() - } - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return self - } -} - -extension Int: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return Int64(self).encode(options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return Int64(self).toCBOR(options: options) - } -} - -extension Int8: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return Int64(self).encode(options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return Int64(self).toCBOR(options: options) - } -} - -extension Int16: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return Int64(self).encode(options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return Int64(self).toCBOR(options: options) - } -} - -extension Int32: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return Int64(self).encode(options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return Int64(self).toCBOR(options: options) - } -} - -extension Int64: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - if (self < 0) { - return CBOR.encodeNegativeInt(self) - } else { - return CBOR.encodeVarUInt(UInt64(self)) - } - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - if self < 0 { - return CBOR.negativeInt(~UInt64(bitPattern: self)) - } else { - return CBOR.unsignedInt(UInt64(self)) - } - } -} - -extension UInt: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeVarUInt(UInt64(self)) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return UInt64(self).toCBOR(options: options) - } -} - -extension UInt8: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeUInt8(self) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return UInt64(self).toCBOR(options: options) - } -} - -extension UInt16: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeUInt16(self) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return UInt64(self).toCBOR(options: options) - } -} - -extension UInt32: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeUInt32(self) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return UInt64(self).toCBOR(options: options) - } -} - -extension UInt64: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeUInt64(self) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.unsignedInt(self) - } -} - -extension String: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeString(self, options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.utf8String(self) - } -} - -extension Float: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeFloat(self) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.float(self) - } -} - -extension Double: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeDouble(self) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.double(self) - } -} - -extension Bool: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeBool(self) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.boolean(self) - } -} - -extension Array where Element: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeArray(self, options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.array(self.map { $0.toCBOR(options: options) }) - } -} - -extension Dictionary where Key: CBOREncodable, Value: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeMap(self, options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.map(Dictionary(uniqueKeysWithValues: self.map { ($0.key.toCBOR(options: options), $0.value.toCBOR(options: options)) })) - } -} - -extension Optional where Wrapped: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - switch self { - case .some(let wrapped): return wrapped.encode(options: options) - case .none: return CBOR.encodeNull() - } - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - switch self { - case .some(let wrapped): return wrapped.toCBOR(options: options) - case .none: return CBOR.null - } - } -} - -extension NSNull: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeNull() - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.null - } -} - -#if canImport(Foundation) -extension Date: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeDate(self, options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.date(self) - } -} - -extension Data: CBOREncodable { - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - return CBOR.encodeByteString(self.map{ $0 }, options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR.byteString(self.map { $0 }) - } -} -#endif diff --git a/Old/CBOREncoder.swift b/Old/CBOREncoder.swift deleted file mode 100644 index eb55dc5..0000000 --- a/Old/CBOREncoder.swift +++ /dev/null @@ -1,468 +0,0 @@ -#if canImport(Foundation) -import Foundation -#endif - -let isBigEndian = Int(bigEndian: 42) == 42 - -/// Takes a value breaks it into bytes. assumes necessity to reverse for endianness if needed -/// This function has only been tested with UInt_s, Floats and Doubles -/// T must be a simple type. It cannot be a collection type. -func rawBytes(of x: T) -> [UInt8] { - var mutable = x // create mutable copy for `withUnsafeBytes` - let bigEndianResult = withUnsafeBytes(of: &mutable) { Array($0) } - return isBigEndian ? bigEndianResult : bigEndianResult.reversed() -} - -/// Defines basic CBOR.encode API. -/// Defines more fine-grained functions of form CBOR.encode*(_ x) -/// for all CBOR types except Float16 -extension CBOR { - public static func encode(_ value: T, options: CBOROptions = CBOROptions()) -> [UInt8] { - return value.encode(options: options) - } - - /// Encodes an array as either a CBOR array type or a CBOR bytestring type, depending on `asByteString`. - /// NOTE: when `asByteString` is true and T = UInt8, the array is interpreted in network byte order - /// Arrays with values of all other types will have their bytes reversed if the system is little endian. - public static func encode(_ array: [T], asByteString: Bool = false, options: CBOROptions = CBOROptions()) -> [UInt8] { - if asByteString { - let length = array.count - var res = length.encode() - res[0] = res[0] | 0b010_00000 - let itemSize = MemoryLayout.size - let bytelength = length * itemSize - res.reserveCapacity(res.count + bytelength) - - let noReversalNeeded = isBigEndian || T.self == UInt8.self - - array.withUnsafeBytes { bufferPtr in - guard let ptr = bufferPtr.baseAddress?.bindMemory(to: UInt8.self, capacity: bytelength) else { - fatalError("Invalid pointer") - } - var j = 0 - for i in 0..(_ dict: [A: B], options: CBOROptions = CBOROptions()) -> [UInt8] { - return encodeMap(dict, options: options) - } - - // MARK: - major 0: unsigned integer - - public static func encodeUInt8(_ x: UInt8) -> [UInt8] { - if (x < 24) { return [x] } - else { return [0x18, x] } - } - - public static func encodeUInt16(_ x: UInt16) -> [UInt8] { - return [0x19] + rawBytes(of: x) - } - - public static func encodeUInt32(_ x: UInt32) -> [UInt8] { - return [0x1a] + rawBytes(of: x) - } - - public static func encodeUInt64(_ x: UInt64) -> [UInt8] { - return [0x1b] + rawBytes(of: x) - } - - internal static func encodeVarUInt(_ x: UInt64) -> [UInt8] { - switch x { - case let x where x <= UInt8.max: return CBOR.encodeUInt8(UInt8(x)) - case let x where x <= UInt16.max: return CBOR.encodeUInt16(UInt16(x)) - case let x where x <= UInt32.max: return CBOR.encodeUInt32(UInt32(x)) - default: return CBOR.encodeUInt64(x) - } - } - - // MARK: - major 1: negative integer - - public static func encodeNegativeInt(_ x: Int64) -> [UInt8] { - assert(x < 0) - var res = encodeVarUInt(~UInt64(bitPattern: x)) - res[0] = res[0] | 0b001_00000 - return res - } - - // MARK: - major 2: bytestring - - public static func encodeByteString(_ bs: [UInt8], options: CBOROptions = CBOROptions()) -> [UInt8] { - var res = bs.count.encode(options: options) - res[0] = res[0] | 0b010_00000 - res.append(contentsOf: bs) - return res - } - - #if canImport(Foundation) - public static func encodeData(_ data: Data, options: CBOROptions = CBOROptions()) -> [UInt8] { - return encodeByteString([UInt8](data), options: options) - } - #endif - - // MARK: - major 3: UTF8 string - - public static func encodeString(_ str: String, options: CBOROptions = CBOROptions()) -> [UInt8] { - let utf8array = Array(str.utf8) - var res = utf8array.count.encode(options: options) - res[0] = res[0] | 0b011_00000 - res.append(contentsOf: utf8array) - return res - } - - // MARK: - major 4: array of data items - - public static func encodeArray(_ arr: [T], options: CBOROptions = CBOROptions()) -> [UInt8] { - var res = arr.count.encode(options: options) - res[0] = res[0] | 0b100_00000 - res.append(contentsOf: arr.flatMap{ return $0.encode(options: options) }) - return res - } - - // MARK: - major 5: a map of pairs of data items - - public static func encodeMap(_ map: [A: B], options: CBOROptions = CBOROptions()) -> [UInt8] { - if options.forbidNonStringMapKeys { - try! ensureStringKey(A.self) - } - var res: [UInt8] = [] - res.reserveCapacity(1 + map.count * (MemoryLayout.size + MemoryLayout.size + 2)) - res = map.count.encode(options: options) - res[0] = res[0] | 0b101_00000 - for (k, v) in map { - res.append(contentsOf: k.encode(options: options)) - res.append(contentsOf: v.encode(options: options)) - } - return res - } - - public static func encodeMap(_ map: [A: Any?], options: CBOROptions = CBOROptions()) throws -> [UInt8] { - if options.forbidNonStringMapKeys { - try ensureStringKey(A.self) - } - var res: [UInt8] = [] - res = map.count.encode(options: options) - res[0] = res[0] | 0b101_00000 - try CBOR.encodeMap(map, into: &res, options: options) - return res - } - - // MARK: - major 6: tagged values - - public static func encodeTagged(tag: Tag, value: T, options: CBOROptions = CBOROptions()) -> [UInt8] { - var res = encodeVarUInt(tag.rawValue) - res[0] = res[0] | 0b110_00000 - res.append(contentsOf: value.encode(options: options)) - return res - } - - // MARK: - major 7: floats, simple values, the 'break' stop code - - public static func encodeSimpleValue(_ x: UInt8) -> [UInt8] { - if x < 24 { - return [0b111_00000 | x] - } else { - return [0xf8, x] - } - } - - public static func encodeNull() -> [UInt8] { - return [0xf6] - } - - public static func encodeUndefined() -> [UInt8] { - return [0xf7] - } - - public static func encodeBreak() -> [UInt8] { - return [0xff] - } - - public static func encodeFloat(_ x: Float) -> [UInt8] { - return [0xfa] + rawBytes(of: x) - } - - public static func encodeDouble(_ x: Double) -> [UInt8] { - return [0xfb] + rawBytes(of: x) - } - - public static func encodeBool(_ x: Bool) -> [UInt8] { - return x ? [0xf5] : [0xf4] - } - - // MARK: - Indefinite length items - - /// Returns a CBOR value indicating the opening of an indefinite-length data item. - /// The user is responsible for creating and sending subsequent valid CBOR. - /// In particular, the user must end the stream with the CBOR.break byte, which - /// can be returned with `encodeStreamEnd()`. - /// - /// The stream API is limited right now, but will get better when Swift allows - /// one to generically constrain the elements of generic Iterators, in which case - /// streaming implementation is trivial - public static func encodeArrayStreamStart() -> [UInt8] { - return [0x9f] - } - - public static func encodeMapStreamStart() -> [UInt8] { - return [0xbf] - } - - public static func encodeStringStreamStart() -> [UInt8] { - return [0x7f] - } - - public static func encodeByteStringStreamStart() -> [UInt8] { - return [0x5f] - } - - /// This is the same as a CBOR "break" value - public static func encodeStreamEnd() -> [UInt8] { - return [0xff] - } - - // TODO: unify definite and indefinite code - public static func encodeArrayChunk(_ chunk: [T], options: CBOROptions = CBOROptions()) -> [UInt8] { - var res: [UInt8] = [] - res.reserveCapacity(chunk.count * MemoryLayout.size) - res.append(contentsOf: chunk.flatMap{ return $0.encode(options: options) }) - return res - } - - public static func encodeMapChunk(_ map: [A: B], options: CBOROptions = CBOROptions()) -> [UInt8] { - if options.forbidNonStringMapKeys { - try! ensureStringKey(A.self) - } - var res: [UInt8] = [] - let count = map.count - res.reserveCapacity(count * MemoryLayout.size + count * MemoryLayout.size) - for (k, v) in map { - res.append(contentsOf: k.encode(options: options)) - res.append(contentsOf: v.encode(options: options)) - } - return res - } - - #if canImport(Foundation) - public static func encodeDate(_ date: Date, options: CBOROptions = CBOROptions()) -> [UInt8] { - let timeInterval = date.timeIntervalSince1970 - let (integral, fractional) = modf(timeInterval) - - let seconds = Int64(integral) - let nanoseconds = Int32(fractional * Double(NSEC_PER_SEC)) - - switch options.dateStrategy { - case .annotatedMap: - var dateCBOR: CBOR - if seconds < 0 && nanoseconds == 0 { - dateCBOR = CBOR.negativeInt(UInt64(-Double(timeInterval + 1))) - } else if seconds > UInt32.max { - dateCBOR = CBOR.double(timeInterval) - } else if nanoseconds != 0 { - dateCBOR = CBOR.double(timeInterval) - } else { - dateCBOR = CBOR.unsignedInt(UInt64(seconds)) - } - - let map: [String: CBOREncodable] = [ - AnnotatedMapDateStrategy.typeKey: AnnotatedMapDateStrategy.typeValue, - AnnotatedMapDateStrategy.valueKey: dateCBOR - ] - return try! CBOR.encodeMap(map, options: options) - case .taggedAsEpochTimestamp: - var res: [UInt8] = [0b110_00001] // Epoch timestamp tag is 1 - if seconds < 0 && nanoseconds == 0 { - res.append(contentsOf: CBOR.encodeNegativeInt(Int64(timeInterval))) - } else if seconds > UInt32.max { - res.append(contentsOf: CBOR.encodeDouble(timeInterval)) - } else if nanoseconds != 0 { - res.append(contentsOf: CBOR.encodeDouble(timeInterval)) - } else { - res.append(contentsOf: CBOR.encode(Int(seconds), options: options)) - } - - return res - } - } - #endif - - public static func encodeAny(_ any: Any?, options: CBOROptions = CBOROptions()) throws -> [UInt8] { - switch any { - case is Int: - return (any as! Int).encode() - case is Int8: - return (any as! Int8).encode() - case is Int16: - return (any as! Int16).encode() - case is Int32: - return (any as! Int32).encode() - case is Int64: - return (any as! Int64).encode() - case is UInt: - return (any as! UInt).encode() - case is UInt8: - return (any as! UInt8).encode() - case is UInt16: - return (any as! UInt16).encode() - case is UInt32: - return (any as! UInt32).encode() - case is UInt64: - return (any as! UInt64).encode() - case is String: - return (any as! String).encode(options: options) - case is Float: - return (any as! Float).encode() - case is Double: - return (any as! Double).encode() - case is Bool: - return (any as! Bool).encode() - #if canImport(Foundation) - case is Data: - return CBOR.encodeByteString((any as! Data).map { $0 }, options: options) - case is Date: - return CBOR.encodeDate((any as! Date), options: options) - case is NSNull: - return CBOR.encodeNull() - #endif - case is [Any?]: - let anyArr = any as! [Any?] - var res = anyArr.count.encode(options: options) - res[0] = res[0] | 0b100_00000 - let encodedInners = try anyArr.reduce(into: []) { acc, next in - acc.append(contentsOf: try encodeAny(next, options: options)) - } - res.append(contentsOf: encodedInners) - return res - case is [String: Any?]: - let anyMap = any as! [String: Any?] - var res: [UInt8] = anyMap.count.encode(options: options) - res[0] = res[0] | 0b101_00000 - try CBOR.encodeMap(anyMap, into: &res, options: options) - return res - case is Void: - return CBOR.encodeUndefined() - case nil: - return CBOR.encodeNull() - default: - if let encodable = any as? CBOREncodable { - return encodable.encode(options: options) - } else if let encodable = any as? Codable { - let encoder = CodableCBOREncoder() - encoder.options = options.toCodableEncoderOptions() - return try [UInt8](encoder.encode(encodable)) - } - throw CBOREncoderError.invalidType - } - } - - internal static func cborFromAny(_ any: Any?, options: CBOROptions = CBOROptions()) throws -> CBOR { - switch any { - case is Int: - return cborFromInt64(Int64(any as! Int)) - case is Int8: - return cborFromInt64(Int64(any as! Int8)) - case is Int16: - return cborFromInt64(Int64(any as! Int16)) - case is Int32: - return cborFromInt64(Int64(any as! Int32)) - case is Int64: - return cborFromInt64(any as! Int64) - case is UInt: - return CBOR.unsignedInt(UInt64(any as! UInt)) - case is UInt8: - return CBOR.unsignedInt(UInt64(any as! UInt8)) - case is UInt16: - return CBOR.unsignedInt(UInt64(any as! UInt16)) - case is UInt32: - return CBOR.unsignedInt(UInt64(any as! UInt32)) - case is UInt64: - return CBOR.unsignedInt(any as! UInt64) - case is String: - return CBOR.utf8String(any as! String) - case is Float: - return CBOR.float(any as! Float) - case is Double: - return CBOR.double(any as! Double) - case is Bool: - return CBOR.boolean(any as! Bool) - #if canImport(Foundation) - case is Data: - return CBOR.byteString((any as! Data).map { $0 }) - case is Date: - return CBOR.date(any as! Date) - case is NSNull: - return CBOR.null - #endif - case is [Any?]: - let anyArr = any as! [Any?] - return try CBOR.array(anyArr.map { try cborFromAny($0) }) - case is [String: Any?]: - let anyMap = any as! [String: Any?] - return try CBOR.map(Dictionary( - uniqueKeysWithValues: anyMap.map { try (cborFromAny($0.key), cborFromAny($0.value)) } - )) - case is Void: - return CBOR.undefined - case nil: - return CBOR.null - default: - if let encodable = any as? CBOREncodable { - return encodable.toCBOR(options: options) - } else if let encodable = any as? Codable { - // This is very much a slow path - we fully encode and then - // decode the value to get it as a `CBOR` - let encoder = CodableCBOREncoder() - encoder.options = options.toCodableEncoderOptions() - let encoded = try [UInt8](encoder.encode(encodable)) - guard let decoded = try CBOR.decode(encoded) else { - throw CBOREncoderError.invalidType - } - return decoded - } - throw CBOREncoderError.invalidType - } - } - - private static func cborFromInt64(_ i: Int64) -> CBOR { - if i < 0 { - return CBOR.negativeInt(~UInt64(bitPattern: i)) - } else { - return CBOR.unsignedInt(UInt64(i)) - } - } - - private static func encodeMap(_ map: [A: Any?], into res: inout [UInt8], options: CBOROptions = CBOROptions()) throws { - if options.forbidNonStringMapKeys { - try ensureStringKey(A.self) - } - let sortedKeysWithEncodedKeys = map.keys.map { - (encoded: $0.encode(options: options), key: $0) - }.sorted(by: { - $0.encoded.lexicographicallyPrecedes($1.encoded) - }) - - try sortedKeysWithEncodedKeys.forEach { keyTuple in - res.append(contentsOf: keyTuple.encoded) - let encodedVal = try encodeAny(map[keyTuple.key]!, options: options) - res.append(contentsOf: encodedVal) - } - } -} - -public enum CBOREncoderError: Error { - case invalidType - case nonStringKeyInMap -} - -func ensureStringKey(_ keyType: T.Type) throws where T: CBOREncodable { - guard T.self is SwiftCBORStringKey.Type else { - throw CBOREncoderError.nonStringKeyInMap - } -} diff --git a/Old/CBORInputStream.swift b/Old/CBORInputStream.swift deleted file mode 100644 index 5caba9f..0000000 --- a/Old/CBORInputStream.swift +++ /dev/null @@ -1,41 +0,0 @@ -public protocol CBORInputStream { - mutating func popByte() throws -> UInt8 - mutating func popBytes(_ n: Int) throws -> ArraySlice -} - -// FUCK: https://openradar.appspot.com/23255436 -struct ArraySliceUInt8 { - var slice : ArraySlice -} - -struct ArrayUInt8 { - var array : ArraySlice -} - -extension ArraySliceUInt8: CBORInputStream { - mutating func popByte() throws -> UInt8 { - if slice.count < 1 { throw CBORError.unfinishedSequence } - return slice.removeFirst() - } - - mutating func popBytes(_ n: Int) throws -> ArraySlice { - if slice.count < n { throw CBORError.unfinishedSequence } - let result = slice.prefix(n) - slice = slice.dropFirst(n) - return result - } -} - -extension ArrayUInt8: CBORInputStream { - mutating func popByte() throws -> UInt8 { - guard array.count > 0 else { throw CBORError.unfinishedSequence } - return array.removeFirst() - } - - mutating func popBytes(_ n: Int) throws -> ArraySlice { - guard array.count >= n else { throw CBORError.unfinishedSequence } - let res = array.prefix(n) - array = array.dropFirst(n) - return res - } -} diff --git a/Old/CBOROptions.swift b/Old/CBOROptions.swift deleted file mode 100644 index 9c1bd61..0000000 --- a/Old/CBOROptions.swift +++ /dev/null @@ -1,54 +0,0 @@ -public struct CBOROptions { - let useStringKeys: Bool - let dateStrategy: DateStrategy - let forbidNonStringMapKeys: Bool - let orderKeys: Bool - /// The maximum number of nested items, inclusive, to decode. A maximum set to 0 dissallows anything other than top-level primitives. - let maximumDepth: Int - - public init( - useStringKeys: Bool = false, - dateStrategy: DateStrategy = .taggedAsEpochTimestamp, - forbidNonStringMapKeys: Bool = false, - orderKeys: Bool = false, - maximumDepth: Int = .max - ) { - self.useStringKeys = useStringKeys - self.dateStrategy = dateStrategy - self.forbidNonStringMapKeys = forbidNonStringMapKeys - self.orderKeys = orderKeys - self.maximumDepth = maximumDepth - } - - func toCodableEncoderOptions() -> CodableCBOREncoder._Options { - return CodableCBOREncoder._Options( - useStringKeys: self.useStringKeys, - dateStrategy: self.dateStrategy, - forbidNonStringMapKeys: self.forbidNonStringMapKeys, - orderKeys: self.orderKeys - ) - } - - func toCodableDecoderOptions() -> CodableCBORDecoder._Options { - return CodableCBORDecoder._Options( - useStringKeys: self.useStringKeys, - dateStrategy: self.dateStrategy, - maximumDepth: self.maximumDepth - ) - } -} - -public enum DateStrategy { - case taggedAsEpochTimestamp - case annotatedMap -} - -struct AnnotatedMapDateStrategy { - static let typeKey = "__type" - static let typeValue = "date_epoch_timestamp" - static let valueKey = "__value" -} - -protocol SwiftCBORStringKey {} - -extension String: SwiftCBORStringKey {} diff --git a/Old/Decoder/CodableCBORDecoder.swift b/Old/Decoder/CodableCBORDecoder.swift deleted file mode 100644 index 4f77d43..0000000 --- a/Old/Decoder/CodableCBORDecoder.swift +++ /dev/null @@ -1,219 +0,0 @@ -import Foundation - -final public class CodableCBORDecoder { - public var useStringKeys: Bool = false - public var dateStrategy: DateStrategy = .taggedAsEpochTimestamp - - struct _Options { - let useStringKeys: Bool - let dateStrategy: DateStrategy - let maximumDepth: Int - - init( - useStringKeys: Bool = false, - dateStrategy: DateStrategy = .taggedAsEpochTimestamp, - maximumDepth: Int = .max - ) { - self.useStringKeys = useStringKeys - self.dateStrategy = dateStrategy - self.maximumDepth = maximumDepth - } - - func toCBOROptions() -> CBOROptions { - return CBOROptions( - useStringKeys: self.useStringKeys, - dateStrategy: self.dateStrategy, - maximumDepth: self.maximumDepth - ) - } - } - - var options: _Options { - return _Options(useStringKeys: self.useStringKeys, dateStrategy: self.dateStrategy) - } - - public init() {} - - public var userInfo: [CodingUserInfoKey : Any] = [:] - - public func decode(_ type: T.Type, from data: Data) throws -> T { - return try decode(type, from: ArraySlice([UInt8](data))) - } - - public func decode(_ type: T.Type, from data: ArraySlice) throws -> T { - let decoder = _CBORDecoder(data: data, options: self.options) - decoder.userInfo = self.userInfo - if type == Date.self { - guard let cbor = try? CBORDecoder(input: [UInt8](data), options: self.options.toCBOROptions()).decodeItem(), - case .date(let date) = cbor - else { - let context = DecodingError.Context(codingPath: [], debugDescription: "Unable to decode data for Date") - throw DecodingError.dataCorrupted(context) - } - return date as! T - } else if type == Data.self { - guard let cbor = try? CBORDecoder(input: [UInt8](data), options: self.options.toCBOROptions()).decodeItem(), - case .byteString(let data) = cbor - else { - let context = DecodingError.Context(codingPath: [], debugDescription: "Unable to decode data for Data") - throw DecodingError.dataCorrupted(context) - } - return Data(data) as! T - } - return try T(from: decoder) - } - - func setOptions(_ newOptions: _Options) { - self.useStringKeys = newOptions.useStringKeys - self.dateStrategy = newOptions.dateStrategy - } -} - -final class _CBORDecoder { - var codingPath: [CodingKey] = [] - - var userInfo: [CodingUserInfoKey : Any] = [:] - - var container: CBORDecodingContainer? - fileprivate var data: ArraySlice - - let options: CodableCBORDecoder._Options - - init(data: ArraySlice, options: CodableCBORDecoder._Options) { - self.data = data - self.options = options - } -} - -extension _CBORDecoder: Decoder { - func container(keyedBy type: Key.Type) throws -> KeyedDecodingContainer { - try ensureMap(self.data.first, keyType: Key.self) - - let container = KeyedContainer(data: self.data, codingPath: self.codingPath, userInfo: self.userInfo, options: self.options) - self.container = container - - return KeyedDecodingContainer(container) - } - - func unkeyedContainer() throws -> UnkeyedDecodingContainer { - try ensureArray(self.data.first) - - let container = UnkeyedContainer(data: self.data, codingPath: self.codingPath, userInfo: self.userInfo, options: self.options) - self.container = container - - return container - } - - func singleValueContainer() throws -> SingleValueDecodingContainer { - let container = SingleValueContainer(data: self.data, codingPath: self.codingPath, userInfo: self.userInfo, options: self.options) - self.container = container - - return container - } - - func ensureMap(_ initialByte: UInt8?, keyType: Key.Type) throws { - switch initialByte { - case .some(0xa0...0xbf): - // all good, continue - return - case nil: - let context = DecodingError.Context( - codingPath: self.codingPath, - debugDescription: "Unexpected end of data" - ) - throw DecodingError.dataCorrupted(context) - default: - let typeDescriptionOfByte = typeDescriptionFromByte(initialByte!) ?? "unknown" - let context = DecodingError.Context( - codingPath: self.codingPath, - debugDescription: "Expected map but found \(typeDescriptionOfByte)" - ) - throw DecodingError.typeMismatch(keyType, context) - } - } - - func ensureArray(_ initialByte: UInt8?) throws { - switch initialByte { - case .some(0x80...0x9f): - // all good, continue - return - case nil: - let context = DecodingError.Context( - codingPath: self.codingPath, - debugDescription: "Unexpected end of data" - ) - throw DecodingError.dataCorrupted(context) - default: - let typeDescriptionOfByte = typeDescriptionFromByte(initialByte!) ?? "unknown" - let context = DecodingError.Context( - codingPath: self.codingPath, - debugDescription: "Expected array but found \(typeDescriptionOfByte)" - ) - throw DecodingError.typeMismatch(Array.self, context) - } - } -} - -protocol CBORDecodingContainer: AnyObject { - var codingPath: [CodingKey] { get set } - - var userInfo: [CodingUserInfoKey : Any] { get } - - var data: ArraySlice { get set } - var index: Data.Index { get set } -} - -extension CBORDecodingContainer { - func readByte() throws -> UInt8 { - return try read(1).first! - } - - func read(_ length: Int) throws -> Data { - let nextIndex = self.index.advanced(by: length) - guard nextIndex <= self.data.endIndex else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Unexpected end of data") - throw DecodingError.dataCorrupted(context) - } - defer { self.index = nextIndex } - - return Data(Array(self.data[self.index..<(nextIndex)])) - } - - func peekByte() throws -> UInt8 { - return try peek(1).first! - } - - func peek(_ length: Int) throws -> ArraySlice { - let nextIndex = self.index.advanced(by: length) - guard nextIndex <= self.data.endIndex else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Unexpected end of data") - throw DecodingError.dataCorrupted(context) - } - - return self.data[self.index..<(nextIndex)] - } - - func read(_ type: T.Type) throws -> T { - let stride = MemoryLayout.stride - let bytes = [UInt8](try read(stride)) - return T(bytes: bytes) - } -} - -func typeDescriptionFromByte(_ byte: UInt8) -> String? { - switch byte { - case 0x00...0x1b, 0x20...0x3b: return "integer" - case 0x40...0x5b, 0x5f: return "byte string" - case 0x60...0x7b, 0x7f: return "string" - case 0x80...0x9f: return "array" - case 0xa0...0xbf: return "map" - case 0xc0: return "text-based date/time" - case 0xc1: return "epoch-based date/time" - case 0xc2...0xdb: return "unspecified tagged value" - case 0xf4, 0xf5: return "boolean" - case 0xf6: return "null" - case 0xf8...0xfb: return "float" - default: - return nil - } -} diff --git a/Old/Decoder/KeyedDecodingContainer.swift b/Old/Decoder/KeyedDecodingContainer.swift deleted file mode 100644 index a7eccc9..0000000 --- a/Old/Decoder/KeyedDecodingContainer.swift +++ /dev/null @@ -1,189 +0,0 @@ -import Foundation - -extension _CBORDecoder { - final class KeyedContainer { - - // This is non-nil once nestedContainers() has been called once, and if the data is valid - var _nestedContainers: [AnyCodingKey: CBORDecodingContainer]? = nil - - // This is non-nil once count() has been called once, and if the data is valid - var _count: Int? - - var data: ArraySlice - var index: Data.Index - var codingPath: [CodingKey] - var userInfo: [CodingUserInfoKey: Any] - let options: CodableCBORDecoder._Options - - init(data: ArraySlice, codingPath: [CodingKey], userInfo: [CodingUserInfoKey : Any], options: CodableCBORDecoder._Options) { - self.codingPath = codingPath - self.userInfo = userInfo - self.data = data - self.index = self.data.startIndex - self.options = options - } - - func checkCanDecodeValue(forKey key: Key) throws { - guard self.contains(key) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "key not found: \(key)") - throw DecodingError.keyNotFound(key, context) - } - } - - func nestedContainers() throws -> [AnyCodingKey: CBORDecodingContainer] { - if let nestedContainers = self._nestedContainers { - return nestedContainers - } - - guard let count = try count() else { - return [:] - } - - var nestedContainers: [AnyCodingKey: CBORDecodingContainer] = [:] - - let unkeyedContainer = UnkeyedContainer(data: self.data.suffix(from: self.index), codingPath: self.codingPath, userInfo: self.userInfo, options: self.options) - unkeyedContainer.count = count * 2 - - var iterator = unkeyedContainer.nestedContainers.makeIterator() - - for _ in 0.. Int? { - if let count = self._count { - return count - } - - let count: Int? - - let format = try self.readByte() - switch format { - case 0xa0...0xb7: count = Int(format & 0x1F) - case 0xb8: count = Int(try read(UInt8.self)) - case 0xb9: count = Int(try read(UInt16.self)) - case 0xba: count = Int(try read(UInt32.self)) - case 0xbb: count = Int(try read(UInt64.self)) - case 0xbf: - // FIXME: This is a very inefficient way of doing this. Really we should be modifying the - // nestedContainers code so that if we're working with a map that has a break at the end - // it creates the containers as it goes, rather than first calculating the count (which - // involves going through all the bytes) and then going back through the data and decoding - // each key-value pair in the map. - let nextIndex = self.data.startIndex.advanced(by: 1) - let remainingData = self.data.suffix(from: nextIndex) - count = try? CBORDecoder(input: remainingData.map { $0 }).readPairsUntilBreak().keys.count - default: - let context = DecodingError.Context( - codingPath: self.codingPath, - debugDescription: "Unable to get count of elements in dictionary" - ) - throw DecodingError.typeMismatch(Int.self, context) - } - - self._count = count - return count - } - } -} - -extension _CBORDecoder.KeyedContainer: KeyedDecodingContainerProtocol { - var allKeys: [Key] { - if let containers = try? self.nestedContainers() { - return containers.keys.map { $0.key() } - } - return [] - } - - func contains(_ key: Key) -> Bool { - if let containers = try? self.nestedContainers() { - return containers.keys.contains(anyCodingKeyForKey(key)) - } - return false - } - - func decodeNil(forKey key: Key) throws -> Bool { - let container = try self.nestedContainers()[anyCodingKeyForKey(key)] - switch container { - case is _CBORDecoder.SingleValueContainer: - return (container as! _CBORDecoder.SingleValueContainer).decodeNil() - case is _CBORDecoder.UnkeyedContainer: - return try (container as! _CBORDecoder.UnkeyedContainer).decodeNil() - case is _CBORDecoder.KeyedContainer: - return try (container as! _CBORDecoder.KeyedContainer).decodeNil(forKey: anyCodingKeyForKey(key)) - case nil: - return false - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "cannot decode nil for key: \(key)") - throw DecodingError.typeMismatch(Any?.self, context) - } - } - - func decode(_ type: T.Type, forKey key: Key) throws -> T { - try checkCanDecodeValue(forKey: key) - - let container = try self.nestedContainers()[anyCodingKeyForKey(key)]! - let decoder = CodableCBORDecoder() - decoder.setOptions(self.options) - return try decoder.decode(T.self, from: container.data) - } - - func nestedUnkeyedContainer(forKey key: Key) throws -> UnkeyedDecodingContainer { - try checkCanDecodeValue(forKey: key) - - guard let unkeyedContainer = try self.nestedContainers()[anyCodingKeyForKey(key)] as? _CBORDecoder.UnkeyedContainer else { - throw DecodingError.dataCorruptedError(forKey: key, in: self, debugDescription: "cannot decode nested container for key: \(key)") - } - - return unkeyedContainer - } - - func nestedContainer(keyedBy type: NestedKey.Type, forKey key: Key) throws -> KeyedDecodingContainer { - try checkCanDecodeValue(forKey: key) - - guard let anyCodingKeyedContainer = try self.nestedContainers()[anyCodingKeyForKey(key)] as? _CBORDecoder.KeyedContainer else { - throw DecodingError.dataCorruptedError(forKey: key, in: self, debugDescription: "cannot decode nested container for key: \(key)") - } - let container = _CBORDecoder.KeyedContainer( - data: anyCodingKeyedContainer.data, - codingPath: anyCodingKeyedContainer.codingPath, - userInfo: anyCodingKeyedContainer.userInfo, - options: anyCodingKeyedContainer.options - ) - return KeyedDecodingContainer(container) - } - - func superDecoder() throws -> Decoder { - return _CBORDecoder(data: self.data, options: self.options) - } - - func superDecoder(forKey key: Key) throws -> Decoder { - let decoder = _CBORDecoder(data: self.data, options: self.options) - decoder.codingPath = [key] - - return decoder - } - - fileprivate func anyCodingKeyForKey(_ key: Key) -> AnyCodingKey { - return AnyCodingKey(key, useStringKey: self.options.useStringKeys) - } -} - -extension _CBORDecoder.KeyedContainer: CBORDecodingContainer {} diff --git a/Old/Decoder/SingleValueDecodingContainer.swift b/Old/Decoder/SingleValueDecodingContainer.swift deleted file mode 100644 index f6b7446..0000000 --- a/Old/Decoder/SingleValueDecodingContainer.swift +++ /dev/null @@ -1,245 +0,0 @@ -import Foundation - -extension _CBORDecoder { - final class SingleValueContainer { - var codingPath: [CodingKey] - var userInfo: [CodingUserInfoKey: Any] - var data: ArraySlice - var index: Data.Index - let options: CodableCBORDecoder._Options - - init(data: ArraySlice, codingPath: [CodingKey], userInfo: [CodingUserInfoKey : Any], options: CodableCBORDecoder._Options) { - self.codingPath = codingPath - self.userInfo = userInfo - self.data = data - self.index = self.data.startIndex - self.options = options - } - - func checkCanDecode(_ type: T.Type, format: UInt8) throws { - guard self.index <= self.data.endIndex else { - throw DecodingError.dataCorruptedError(in: self, debugDescription: "Unexpected end of data") - } - - guard self.data[self.index] == format else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(format)") - throw DecodingError.typeMismatch(type, context) - } - } - - } -} - -extension _CBORDecoder.SingleValueContainer: SingleValueDecodingContainer { - func decodeNil() -> Bool { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - return false - } - switch cbor { - case .null: return true - default: return false - } - } - - func decode(_ type: Bool.Type) throws -> Bool { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .boolean(let bool): return bool - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(Bool.self, context) - } - } - - func decode(_ type: String.Type) throws -> String { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .utf8String(let str): return str - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(String.self, context) - } - } - - func decode(_ type: Double.Type) throws -> Double { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .double(let dbl): return dbl - case .float(let flt): return Double(flt) - case .half(let flt): return Double(flt) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(Double.self, context) - } - } - - func decode(_ type: Float.Type) throws -> Float { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .float(let flt): return flt - case .half(let flt): return Float(flt) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(Float.self, context) - } - } - - func decode(_ type: Int.Type) throws -> Int { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return Int(u64) - case .negativeInt(let u64): return -1 - Int(u64) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(Int.self, context) - } - } - - func decode(_ type: Int8.Type) throws -> Int8 { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return Int8(u64) - case .negativeInt(let u64): return -1 - Int8(u64) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(Int8.self, context) - } - } - - func decode(_ type: Int16.Type) throws -> Int16 { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return Int16(u64) - case .negativeInt(let u64): return -1 - Int16(u64) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(Int16.self, context) - } - } - - func decode(_ type: Int32.Type) throws -> Int32 { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return Int32(u64) - case .negativeInt(let u64): return -1 - Int32(u64) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(Int32.self, context) - } - } - - func decode(_ type: Int64.Type) throws -> Int64 { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return Int64(u64) - case .negativeInt(let u64): return -1 - Int64(u64) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(Int64.self, context) - } - } - - func decode(_ type: UInt.Type) throws -> UInt { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return UInt(u64) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(UInt.self, context) - } - } - - func decode(_ type: UInt8.Type) throws -> UInt8 { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return UInt8(u64) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(UInt8.self, context) - } - } - - func decode(_ type: UInt16.Type) throws -> UInt16 { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return UInt16(u64) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(UInt16.self, context) - } - } - - func decode(_ type: UInt32.Type) throws -> UInt32 { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return UInt32(u64) - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(UInt32.self, context) - } - } - - func decode(_ type: UInt64.Type) throws -> UInt64 { - guard let cbor = try? CBOR.decode(self.data.map { $0 }) else { - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.dataCorrupted(context) - } - switch cbor { - case .unsignedInt(let u64): return u64 - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "Invalid format: \(self.data)") - throw DecodingError.typeMismatch(UInt64.self, context) - } - } - - func decode(_ type: T.Type) throws -> T { - let decoder = _CBORDecoder(data: self.data, options: self.options) - let value = try T(from: decoder) - if let nextIndex = decoder.container?.index { - self.index = nextIndex - } - - return value - } -} - -extension _CBORDecoder.SingleValueContainer: CBORDecodingContainer {} diff --git a/Old/Decoder/UnkeyedDecodingContainer.swift b/Old/Decoder/UnkeyedDecodingContainer.swift deleted file mode 100644 index 7f4dab3..0000000 --- a/Old/Decoder/UnkeyedDecodingContainer.swift +++ /dev/null @@ -1,310 +0,0 @@ -import Foundation - -extension _CBORDecoder { - final class UnkeyedContainer { - var codingPath: [CodingKey] - - var nestedCodingPath: [CodingKey] { - return self.codingPath + [AnyCodingKey(intValue: self.count ?? 0)] - } - - var userInfo: [CodingUserInfoKey: Any] - - var data: ArraySlice - var index: Data.Index - - let options: CodableCBORDecoder._Options - - lazy var count: Int? = { - do { - let format = try self.readByte() - switch format { - case 0x80...0x97 : - return Int(format & 0x1F) - case 0x98: - return Int(try read(UInt8.self)) - case 0x99: - return Int(try read(UInt16.self)) - case 0x9a: - return Int(try read(UInt32.self)) - case 0x9b: - return Int(try read(UInt64.self)) - case 0x9f: - // FIXME: This is a very inefficient way of doing this. Really we should be modifying the - // nestedContainers code so that if we're working with an array that has a break at the - // end it creates the containers as it goes, rather than first calculating the count - // (which involves going through all the bytes) and then going back through the data and - // decoding each item in the array. - let nextIndex = self.data.startIndex.advanced(by: 1) - let remainingData = self.data.suffix(from: nextIndex) - return try? CBORDecoder(input: remainingData).readUntilBreak().count - default: - return nil - } - } catch { - return nil - } - }() - - var currentIndex: Int = 0 - - lazy var nestedContainers: [CBORDecodingContainer] = { - guard let count = self.count else { - return [] - } - - var nestedContainers: [CBORDecodingContainer] = [] - - do { - for _ in 0.., codingPath: [CodingKey], userInfo: [CodingUserInfoKey : Any], options: CodableCBORDecoder._Options) { - self.codingPath = codingPath - self.userInfo = userInfo - self.data = data - self.index = self.data.startIndex - self.options = options - } - - var isAtEnd: Bool { - guard let count = self.count else { - return true - } - - return currentIndex >= count - } - - var isEmpty: Bool { - if let count = self.count, count == 0 { - return true - } - return false - } - - func checkCanDecodeValue() throws { - guard !self.isAtEnd else { - throw DecodingError.dataCorruptedError(in: self, debugDescription: "Unexpected end of data") - } - } - - } -} - -extension _CBORDecoder.UnkeyedContainer: UnkeyedDecodingContainer { - - func decodeNil() throws -> Bool { - if self.isEmpty { - return false - } - try checkCanDecodeValue() - defer { self.currentIndex += 1 } - - switch self.nestedContainers[self.currentIndex] { - case let singleValueContainer as _CBORDecoder.SingleValueContainer: - return singleValueContainer.decodeNil() - case is _CBORDecoder.UnkeyedContainer, is _CBORDecoder.KeyedContainer: - return false - default: - let context = DecodingError.Context(codingPath: self.codingPath, debugDescription: "cannot decode nil for index: \(self.currentIndex)") - throw DecodingError.typeMismatch(Any?.self, context) - } - } - - func decode(_ type: T.Type) throws -> T { - try checkCanDecodeValue() - defer { self.currentIndex += 1 } - - let container = self.nestedContainers[self.currentIndex] - let decoder = CodableCBORDecoder() - decoder.setOptions(self.options) - let value = try decoder.decode(T.self, from: container.data) - - return value - } - - func nestedUnkeyedContainer() throws -> UnkeyedDecodingContainer { - try checkCanDecodeValue() - defer { self.currentIndex += 1 } - - let container = self.nestedContainers[self.currentIndex] as! _CBORDecoder.UnkeyedContainer - - return container - } - - func nestedContainer(keyedBy type: NestedKey.Type) throws -> KeyedDecodingContainer { - try checkCanDecodeValue() - defer { self.currentIndex += 1 } - - let anyCodingKeyContainer = self.nestedContainers[self.currentIndex] as! _CBORDecoder.KeyedContainer - - let container = _CBORDecoder.KeyedContainer( - data: anyCodingKeyContainer.data, - codingPath: anyCodingKeyContainer.codingPath, - userInfo: anyCodingKeyContainer.userInfo, - options: anyCodingKeyContainer.options - ) - return KeyedDecodingContainer(container) - } - - func superDecoder() throws -> Decoder { - return _CBORDecoder(data: self.data, options: self.options) - } -} - -extension _CBORDecoder.UnkeyedContainer { - func decodeContainer() throws -> CBORDecodingContainer { - try checkCanDecodeValue() - defer { self.currentIndex += 1 } - - let startIndex = self.index - - let length: Int - let format = try self.readByte() - - switch format { - // Integers - case 0x00...0x1b, 0x20...0x3b: - length = try getLengthOfItem(format: format, startIndex: startIndex) - // Byte strings - case 0x40...0x5b: - length = try getLengthOfItem(format: format, startIndex: startIndex) - // Terminated by break - case 0x5f: - // TODO: Is this ever going to get hit? - throw DecodingError.dataCorruptedError(in: self, debugDescription: "Handling byte strings with break bytes is not supported yet") - // UTF8 strings - case 0x60...0x7b: - length = try getLengthOfItem(format: format, startIndex: startIndex) - // Terminated by break - case 0x7f: - // FIXME - throw DecodingError.dataCorruptedError(in: self, debugDescription: "Handling UTF8 strings with break bytes is not supported yet") - // Arrays - case 0x80...0x9f: - let container = _CBORDecoder.UnkeyedContainer(data: self.data.suffix(from: startIndex), codingPath: self.nestedCodingPath, userInfo: self.userInfo, options: self.options) - _ = container.nestedContainers - - self.index = container.index - // Ensure that we're moving the index along for indefinite arrays so - // that we don't try and decode the break byte (0xff) - if format == 0x9f { - if self.data.suffix(from: self.index).count > 0 { - self.index = self.index.advanced(by: 1) - } - } - return container - // Maps - case 0xa0...0xbf: - let container = _CBORDecoder.KeyedContainer(data: self.data.suffix(from: startIndex), codingPath: self.nestedCodingPath, userInfo: self.userInfo, options: self.options) - let _ = try container.nestedContainers() // FIXME - - self.index = container.index - // Ensure that we're moving the index along for indefinite arrays so - // that we don't try and decode the break byte (0xff) - if format == 0xbf { - if self.data.suffix(from: self.index).count > 0 { - self.index = self.index.advanced(by: 1) - } - } - return container - case 0xc0: - throw DecodingError.dataCorruptedError(in: self, debugDescription: "Handling text-based date/time is not supported yet") - // Tagged value (epoch-baed date/time) - case 0xc1: - length = try getLengthOfItem(format: try self.peekByte(), startIndex: startIndex.advanced(by: 1)) + 1 - case 0xc2...0xdb: - // FIXME - throw DecodingError.dataCorruptedError(in: self, debugDescription: "Handling tags (other than epoch-based date/time) is not supported yet") - case 0xe0...0xfb, 0xff: - length = try getLengthOfItem(format: format, startIndex: startIndex.advanced(by: 1)) - default: - throw DecodingError.dataCorruptedError(in: self, debugDescription: "Invalid format: \(format)") - } - - let range: Range = startIndex.. Int { - switch format { - // Integers - // Small positive and negative integers - case 0x00...0x17, 0x20...0x37: - return 0 - // UInt8 in following byte - case 0x18, 0x38: - return 1 - // UInt16 in following bytes - case 0x19, 0x39: - return 2 - // UInt32 in following bytes - case 0x1a, 0x3a: - return 4 - // UInt64 in following bytes - case 0x1b, 0x3b: - return 8 - // Byte strings - case 0x40...0x57: - return try CBORDecoder(input: [0]).readLength(format, base: 0x40) - case 0x58: - let remainingData = self.data.suffix(from: startIndex.advanced(by: 1)) - return try CBORDecoder(input: remainingData).readLength(format, base: 0x40) + 1 - case 0x59: - let remainingData = self.data.suffix(from: startIndex.advanced(by: 1)) - return try CBORDecoder(input: remainingData).readLength(format, base: 0x40) + 2 - case 0x5a: - let remainingData = self.data.suffix(from: startIndex.advanced(by: 1)) - return try CBORDecoder(input: remainingData).readLength(format, base: 0x40) + 4 - case 0x5b: - let remainingData = self.data.suffix(from: startIndex.advanced(by: 1)) - return try CBORDecoder(input: remainingData).readLength(format, base: 0x40) + 8 - // UTF8 strings - case 0x60...0x77: - return try CBORDecoder(input: [0]).readLength(format, base: 0x60) - case 0x78: - let remainingData = self.data.suffix(from: startIndex.advanced(by: 1)) - return try CBORDecoder(input: remainingData).readLength(format, base: 0x60) + 1 - case 0x79: - let remainingData = self.data.suffix(from: startIndex.advanced(by: 1)) - return try CBORDecoder(input: remainingData).readLength(format, base: 0x60) + 2 - case 0x7a: - let remainingData = self.data.suffix(from: startIndex.advanced(by: 1)) - return try CBORDecoder(input: remainingData).readLength(format, base: 0x60) + 4 - case 0x7b: - let remainingData = self.data.suffix(from: startIndex.advanced(by: 1)) - return try CBORDecoder(input: remainingData).readLength(format, base: 0x60) + 8 - case 0xe0...0xf3: - return 0 - case 0xf4, 0xf5, 0xf6, 0xf7, 0xf8: - return 0 - case 0xf9: - return 2 - case 0xfa: - return 4 - case 0xfb: - return 8 - case 0xff: - return 0 - default: - throw DecodingError.dataCorruptedError(in: self, debugDescription: "Invalid format for getting length of item: \(format)") - } - - } -} - -extension _CBORDecoder.UnkeyedContainer: CBORDecodingContainer {} diff --git a/Old/Encoder/CodableCBOREncoder.swift b/Old/Encoder/CodableCBOREncoder.swift deleted file mode 100644 index 36a2850..0000000 --- a/Old/Encoder/CodableCBOREncoder.swift +++ /dev/null @@ -1,131 +0,0 @@ -import Foundation - -public class CodableCBOREncoder { - public var useStringKeys: Bool = false - public var dateStrategy: DateStrategy = .taggedAsEpochTimestamp - public var forbidNonStringMapKeys: Bool = false - public var orderKeys: Bool = false - - struct _Options { - let useStringKeys: Bool - let dateStrategy: DateStrategy - let forbidNonStringMapKeys: Bool - let orderKeys: Bool - - init( - useStringKeys: Bool = false, - dateStrategy: DateStrategy = .taggedAsEpochTimestamp, - forbidNonStringMapKeys: Bool = false, - orderKeys: Bool = false - ) { - self.useStringKeys = useStringKeys - self.dateStrategy = dateStrategy - self.forbidNonStringMapKeys = forbidNonStringMapKeys - self.orderKeys = orderKeys - } - - func toCBOROptions() -> CBOROptions { - return CBOROptions( - useStringKeys: self.useStringKeys, - dateStrategy: self.dateStrategy, - forbidNonStringMapKeys: self.forbidNonStringMapKeys - ) - } - } - - var options: _Options { - get { - _Options( - useStringKeys: self.useStringKeys, - dateStrategy: self.dateStrategy, - forbidNonStringMapKeys: self.forbidNonStringMapKeys, - orderKeys: self.orderKeys - ) - } - set { - self.useStringKeys = newValue.useStringKeys - self.dateStrategy = newValue.dateStrategy - self.forbidNonStringMapKeys = newValue.forbidNonStringMapKeys - } - } - - public init() {} - - public func encode(_ value: Encodable) throws -> Data { - let encoder = _CBOREncoder(options: self.options) - if let dateVal = value as? Date { - return Data(CBOR.encodeDate(dateVal, options: self.options.toCBOROptions())) - } else if let dataVal = value as? Data { - return Data(CBOR.encodeData(dataVal, options: self.options.toCBOROptions())) - } - if options.forbidNonStringMapKeys { - if let dict = value as? Dictionary { - guard let _ = dict as? Dictionary else { - throw CBOREncoderError.nonStringKeyInMap - } - } - } - - try value.encode(to: encoder) - return try encoder.data() - } -} - -final class _CBOREncoder { - var codingPath: [CodingKey] = [] - - var userInfo: [CodingUserInfoKey : Any] = [:] - - fileprivate var container: CBOREncodingContainer? { - willSet { - precondition(self.container == nil) - } - } - - func data() throws -> Data { - try container?.data() ?? Data() - } - - let options: CodableCBOREncoder._Options - - init(options: CodableCBOREncoder._Options = CodableCBOREncoder._Options()) { - self.options = options - } -} - -extension _CBOREncoder: Encoder { - fileprivate func assertCanCreateContainer() { - precondition(self.container == nil) - } - - func container(keyedBy type: Key.Type) -> KeyedEncodingContainer { - assertCanCreateContainer() - - let container = KeyedContainer(codingPath: self.codingPath, userInfo: self.userInfo, options: self.options) - self.container = container - - return KeyedEncodingContainer(container) - } - - func unkeyedContainer() -> UnkeyedEncodingContainer { - assertCanCreateContainer() - - let container = UnkeyedContainer(codingPath: self.codingPath, userInfo: self.userInfo, options: self.options) - self.container = container - - return container - } - - func singleValueContainer() -> SingleValueEncodingContainer { - assertCanCreateContainer() - - let container = SingleValueContainer(codingPath: self.codingPath, userInfo: self.userInfo, options: self.options) - self.container = container - - return container - } -} - -protocol CBOREncodingContainer: AnyObject { - func data() throws -> Data -} diff --git a/Old/Encoder/KeyedEncodingContainer.swift b/Old/Encoder/KeyedEncodingContainer.swift deleted file mode 100644 index 2a27855..0000000 --- a/Old/Encoder/KeyedEncodingContainer.swift +++ /dev/null @@ -1,124 +0,0 @@ -import Foundation -import HeapModule - -extension _CBOREncoder { - final class KeyedContainer { - struct StorageItem: Comparable { - let key: AnyCodingKey - let value: CBOREncodingContainer - - static func < (lhs: StorageItem, rhs: StorageItem) -> Bool { - lhs.key.stringValue < rhs.key.stringValue - } - - static func == (lhs: StorageItem, rhs: StorageItem) -> Bool { - lhs.key.stringValue == rhs.key.stringValue - } - } - - var storage: Heap = [] - - var codingPath: [CodingKey] - var userInfo: [CodingUserInfoKey: Any] - - let options: CodableCBOREncoder._Options - - init(codingPath: [CodingKey], userInfo: [CodingUserInfoKey : Any], options: CodableCBOREncoder._Options) { - self.codingPath = codingPath - self.userInfo = userInfo - self.options = options - } - } -} - -extension _CBOREncoder.KeyedContainer: KeyedEncodingContainerProtocol { - func encodeNil(forKey key: Key) throws { - var container = self.nestedSingleValueContainer(forKey: key) - try container.encodeNil() - } - - func encode(_ value: T, forKey key: Key) throws { - var container = self.nestedSingleValueContainer(forKey: key) - try container.encode(value) - } - - private func nestedCodingPath(forKey key: CodingKey) -> [CodingKey] { - return self.codingPath + [key] - } - - private func nestedSingleValueContainer(forKey key: Key) -> SingleValueEncodingContainer { - let container = _CBOREncoder.SingleValueContainer( - codingPath: self.nestedCodingPath(forKey: key), - userInfo: self.userInfo, - options: self.options - ) - self.storage.insert(storageItem(forKey: key, container: container)) - return container - } - - func nestedUnkeyedContainer(forKey key: Key) -> UnkeyedEncodingContainer { - let container = _CBOREncoder.UnkeyedContainer( - codingPath: self.nestedCodingPath(forKey: key), - userInfo: self.userInfo, - options: self.options - ) - self.storage.insert(storageItem(forKey: key, container: container)) - return container - } - - func nestedContainer(keyedBy keyType: NestedKey.Type, forKey key: Key) -> KeyedEncodingContainer { - let container = _CBOREncoder.KeyedContainer( - codingPath: self.nestedCodingPath(forKey: key), - userInfo: self.userInfo, - options: self.options - ) - self.storage.insert(storageItem(forKey: key, container: container)) - return KeyedEncodingContainer(container) - } - - fileprivate func storageItem(forKey key: Key, container: CBOREncodingContainer) -> StorageItem { - StorageItem( - key: AnyCodingKey(key, useStringKey: self.options.useStringKeys), - value: container - ) - } - - func superEncoder() -> Encoder { - fatalError("Unimplemented") // FIXME - } - - func superEncoder(forKey key: Key) -> Encoder { - fatalError("Unimplemented") // FIXME - } -} - -extension _CBOREncoder.KeyedContainer: CBOREncodingContainer { - func data() throws -> Data { - var data = Data() - data.append(0b101_00000) // Blank count for now - var foundKeys: Set = [] - - while let item = storage.popMin() { - let key = item.key - let container = item.value - - guard !foundKeys.contains(key.stringValue) else { continue } - foundKeys.insert(key.stringValue) - - let keyContainer = _CBOREncoder.SingleValueContainer(codingPath: self.codingPath, userInfo: self.userInfo, options: self.options) - try keyContainer.encode(key) - data.append(contentsOf: try keyContainer.data()) - data.append(contentsOf: try container.data()) - - } - - if foundKeys.count >= 31 { - data[0] = data[0] | UInt8(0b11111) // >= 31 keys means we've broken the maximum size - data.append(0xFF) // 32, the BREAK code to end the indeterminate mep length. - } else { - data[0] = data[0] | UInt8(foundKeys.count) - } - - return Data(data) - } -} diff --git a/Old/Encoder/SingleValueEncodingContainer.swift b/Old/Encoder/SingleValueEncodingContainer.swift deleted file mode 100644 index cd40700..0000000 --- a/Old/Encoder/SingleValueEncodingContainer.swift +++ /dev/null @@ -1,169 +0,0 @@ -import Foundation - -extension _CBOREncoder { - final class SingleValueContainer { - private var storage: Data = Data() - - fileprivate var canEncodeNewValue = true - fileprivate func checkCanEncode(value: Any?) throws { - guard self.canEncodeNewValue else { - let context = EncodingError.Context(codingPath: self.codingPath, debugDescription: "Attempt to encode value through single value container when previously value already encoded.") - throw EncodingError.invalidValue(value as Any, context) - } - } - - var codingPath: [CodingKey] - var userInfo: [CodingUserInfoKey: Any] - - let options: CodableCBOREncoder._Options - - init(codingPath: [CodingKey], userInfo: [CodingUserInfoKey : Any], options: CodableCBOREncoder._Options) { - self.codingPath = codingPath - self.userInfo = userInfo - self.options = options - } - } -} - -extension _CBOREncoder.SingleValueContainer: SingleValueEncodingContainer { - func encodeNil() throws { - try checkCanEncode(value: nil) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encodeNull()) - } - - func encode(_ value: Bool) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encodeBool(value)) - } - - func encode(_ value: String) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encodeString(value, options: self.options.toCBOROptions())) - } - - func encode(_ value: Double) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encodeDouble(value)) - } - - func encode(_ value: Float) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encodeFloat(value)) - } - - func encode(_ value: Int) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(value)) - } - - func encode(_ value: Int8) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(Int(value))) - } - - func encode(_ value: Int16) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(Int(value))) - } - - func encode(_ value: Int32) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(Int(value))) - } - - func encode(_ value: Int64) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(Int(value))) - } - - func encode(_ value: UInt) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(value)) - } - - func encode(_ value: UInt8) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(value)) - } - - func encode(_ value: UInt16) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(value)) - } - - func encode(_ value: UInt32) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(value)) - } - - func encode(_ value: UInt64) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encode(value)) - } - - func encodeDate(_ value: Date) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encodeDate(value, options: self.options.toCBOROptions())) - } - - func encodeData(_ value: Data) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - self.storage.append(contentsOf: CBOR.encodeData(value, options: self.options.toCBOROptions())) - } - - func encode(_ value: T) throws { - try checkCanEncode(value: value) - defer { self.canEncodeNewValue = false } - - switch value { - case let data as Data: - try self.encodeData(data) - case let date as Date: - try self.encodeDate(date) - default: - let encoder = _CBOREncoder(options: self.options) - try value.encode(to: encoder) - self.storage.append(try encoder.data()) - } - } -} - -extension _CBOREncoder.SingleValueContainer: CBOREncodingContainer { - func data() throws -> Data { - return storage - } -} diff --git a/Old/Encoder/UnkeyedEncodingContainer.swift b/Old/Encoder/UnkeyedEncodingContainer.swift deleted file mode 100644 index d6081a0..0000000 --- a/Old/Encoder/UnkeyedEncodingContainer.swift +++ /dev/null @@ -1,85 +0,0 @@ -import Foundation - -extension _CBOREncoder { - final class UnkeyedContainer { - private var storage: [CBOREncodingContainer] = [] - - var count: Int { - return storage.count - } - - var codingPath: [CodingKey] - - var nestedCodingPath: [CodingKey] { - return self.codingPath + [AnyCodingKey(intValue: self.count)] - } - - var userInfo: [CodingUserInfoKey: Any] - - let options: CodableCBOREncoder._Options - - init(codingPath: [CodingKey], userInfo: [CodingUserInfoKey : Any], options: CodableCBOREncoder._Options) { - self.codingPath = codingPath - self.userInfo = userInfo - self.options = options - } - } -} - -extension _CBOREncoder.UnkeyedContainer: UnkeyedEncodingContainer { - func encodeNil() throws { - var container = self.nestedSingleValueContainer() - try container.encodeNil() - } - - func encode(_ value: T) throws { - var container = self.nestedSingleValueContainer() - try container.encode(value) - } - - private func nestedSingleValueContainer() -> SingleValueEncodingContainer { - let container = _CBOREncoder.SingleValueContainer(codingPath: self.nestedCodingPath, userInfo: self.userInfo, options: self.options) - self.storage.append(container) - - return container - } - - func nestedContainer(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer { - let container = _CBOREncoder.KeyedContainer(codingPath: self.nestedCodingPath, userInfo: self.userInfo, options: self.options) - self.storage.append(container) - - return KeyedEncodingContainer(container) - } - - func nestedUnkeyedContainer() -> UnkeyedEncodingContainer { - let container = _CBOREncoder.UnkeyedContainer(codingPath: self.nestedCodingPath, userInfo: self.userInfo, options: self.options) - self.storage.append(container) - - return container - } - - func superEncoder() -> Encoder { - fatalError("Unimplemented") // FIXME - } -} - -extension _CBOREncoder.UnkeyedContainer: CBOREncodingContainer { - func data() throws -> Data { - var data = Data() - if storage.count >= 31 { - data.append(0b100_11111) // array tag + indefinite count - } else { - data.append(0b100_00000 | UInt8(storage.count)) // array tag + count - } - - for container in storage { - data.append(contentsOf: try container.data()) - } - - if storage.count >= 31 { - data.append(0xFF) // 32, the BREAK code to end the indeterminate array length. - } - - return Data(data) - } -} diff --git a/Old/FixedWidthInteger+Bytes.swift b/Old/FixedWidthInteger+Bytes.swift deleted file mode 100644 index ece9052..0000000 --- a/Old/FixedWidthInteger+Bytes.swift +++ /dev/null @@ -1,19 +0,0 @@ -extension FixedWidthInteger { - init(bytes: [UInt8]) { - self = bytes.withUnsafeBufferPointer { - $0.baseAddress!.withMemoryRebound(to: Self.self, capacity: 1) { - $0.pointee - } - }.bigEndian - } - - var bytes: [UInt8] { - let capacity = MemoryLayout.size - var mutableValue = self.bigEndian - return withUnsafePointer(to: &mutableValue) { - return $0.withMemoryRebound(to: UInt8.self, capacity: capacity) { - return Array(UnsafeBufferPointer(start: $0, count: capacity)) - } - } - } -} diff --git a/Old/SwiftCBORTests-old/CBORCodableRoundtripTests.swift b/Old/SwiftCBORTests-old/CBORCodableRoundtripTests.swift deleted file mode 100644 index 65bd24f..0000000 --- a/Old/SwiftCBORTests-old/CBORCodableRoundtripTests.swift +++ /dev/null @@ -1,555 +0,0 @@ -import XCTest -import Foundation -@testable import SwiftCBOR - -class CBORCodableRoundtripTests: XCTestCase { - struct MyStruct: Codable, Equatable, Hashable { - let age: Int - let name: String - } - - func testSimpleStruct() { - let encoded = try! CodableCBOREncoder().encode(MyStruct(age: 27, name: "Ham")) - let decoded = try! CodableCBORDecoder().decode(MyStruct.self, from: encoded) - XCTAssertEqual(decoded, MyStruct(age: 27, name: "Ham")) - } - - func testSimpleStructsInArray() { - let encoded = try! CodableCBOREncoder().encode([ - MyStruct(age: 27, name: "Ham"), - MyStruct(age: 24, name: "Greg") - ]) - let decoded = try! CodableCBORDecoder().decode([MyStruct].self, from: encoded) - XCTAssertEqual(decoded, [MyStruct(age: 27, name: "Ham"), MyStruct(age: 24, name: "Greg")]) - } - - func testSimpleStructsAsValuesInMap() { - let encoded = try! CodableCBOREncoder().encode([ - "Ham": MyStruct(age: 27, name: "Ham"), - "Greg": MyStruct(age: 24, name: "Greg") - ]) - let decoded = try! CodableCBORDecoder().decode([String: MyStruct].self, from: encoded) - XCTAssertEqual( - decoded, - [ - "Ham": MyStruct(age: 27, name: "Ham"), - "Greg": MyStruct(age: 24, name: "Greg") - ] - ) - } - - func testSimpleStructsAsKeysInMap() { - let encoded = try! CodableCBOREncoder().encode([ - MyStruct(age: 27, name: "Ham"): "Ham", - MyStruct(age: 24, name: "Greg"): "Greg" - ]) - let decoded = try! CodableCBORDecoder().decode([MyStruct: String].self, from: encoded) - XCTAssertEqual( - decoded, - [ - MyStruct(age: 27, name: "Ham"): "Ham", - MyStruct(age: 24, name: "Greg"): "Greg" - ] - ) - } - - func testNil() { - let nilValue = try! CodableCBOREncoder().encode(Optional(nil)) - let nilDecoded = try! CodableCBORDecoder().decode(Optional.self, from: nilValue) - XCTAssertNil(nilDecoded) - } - - func testBools() { - let falseVal = try! CodableCBOREncoder().encode(false) - let falseValDecoded = try! CodableCBORDecoder().decode(Bool.self, from: falseVal) - XCTAssertFalse(falseValDecoded) - let trueVal = try! CodableCBOREncoder().encode(true) - let trueValDecoded = try! CodableCBORDecoder().decode(Bool.self, from: trueVal) - XCTAssertTrue(trueValDecoded) - } - - func testInts() { - // Less than 24 - let zero = try! CodableCBOREncoder().encode(0) - let zeroDecoded = try! CodableCBORDecoder().decode(Int.self, from: zero) - XCTAssertEqual(zeroDecoded, 0) - let eight = try! CodableCBOREncoder().encode(8) - let eightDecoded = try! CodableCBORDecoder().decode(Int.self, from: eight) - XCTAssertEqual(eightDecoded, 8) - let ten = try! CodableCBOREncoder().encode(10) - let tenDecoded = try! CodableCBORDecoder().decode(Int.self, from: ten) - XCTAssertEqual(tenDecoded, 10) - let twentyThree = try! CodableCBOREncoder().encode(23) - let twentyThreeDecoded = try! CodableCBORDecoder().decode(Int.self, from: twentyThree) - XCTAssertEqual(twentyThreeDecoded, 23) - - // Just bigger than 23 - let twentyFour = try! CodableCBOREncoder().encode(24) - let twentyFourDecoded = try! CodableCBORDecoder().decode(Int.self, from: twentyFour) - XCTAssertEqual(twentyFourDecoded, 24) - let twentyFive = try! CodableCBOREncoder().encode(25) - let twentyFiveDecoded = try! CodableCBORDecoder().decode(Int.self, from: twentyFive) - XCTAssertEqual(twentyFiveDecoded, 25) - - // Bigger - let hundred = try! CodableCBOREncoder().encode(100) - let hundredDecoded = try! CodableCBORDecoder().decode(Int.self, from: hundred) - XCTAssertEqual(hundredDecoded, 100) - let thousand = try! CodableCBOREncoder().encode(1_000) - let thousandDecoded = try! CodableCBORDecoder().decode(Int.self, from: thousand) - XCTAssertEqual(thousandDecoded, 1_000) - let million = try! CodableCBOREncoder().encode(1_000_000) - let millionDecoded = try! CodableCBORDecoder().decode(Int.self, from: million) - XCTAssertEqual(millionDecoded, 1_000_000) - let trillion = try! CodableCBOREncoder().encode(1_000_000_000_000) - let trillionDecoded = try! CodableCBORDecoder().decode(Int.self, from: trillion) - XCTAssertEqual(trillionDecoded, 1_000_000_000_000) - - // TODO: Tagged byte strings for big numbers -// let bigNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])) -// XCTAssertEqual(bigNum, 18_446_744_073_709_551_615) -// let biggerNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x2c, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,])) -// XCTAssertEqual(biggerNum, 18_446_744_073_709_551_616) - } - - func testNegativeInts() { - // Less than 24 - let minusOne = try! CodableCBOREncoder().encode(-1) - let minusOneDecoded = try! CodableCBORDecoder().decode(Int.self, from: minusOne) - XCTAssertEqual(minusOneDecoded, -1) - let minusTen = try! CodableCBOREncoder().encode(-10) - let minusTenDecoded = try! CodableCBORDecoder().decode(Int.self, from: minusTen) - XCTAssertEqual(minusTenDecoded, -10) - - // Bigger - let minusHundred = try! CodableCBOREncoder().encode(-100) - let minusHundredDecoded = try! CodableCBORDecoder().decode(Int.self, from: minusHundred) - XCTAssertEqual(minusHundredDecoded, -100) - let minusThousand = try! CodableCBOREncoder().encode(-1_000) - let minusThousandDecoded = try! CodableCBORDecoder().decode(Int.self, from: minusThousand) - XCTAssertEqual(minusThousandDecoded, -1_000) - - // TODO: Tagged byte strings for big numbers -// let bigNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])) -// XCTAssertEqual(bigNum, 18_446_744_073_709_551_615) -// let biggerNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x2c, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,])) -// XCTAssertEqual(biggerNum, 18_446_744_073_709_551_616) - } - - func testStrings() { - let empty = try! CodableCBOREncoder().encode("") - let emptyDecoded = try! CodableCBORDecoder().decode(String.self, from: empty) - XCTAssertEqual(emptyDecoded, "") - let a = try! CodableCBOREncoder().encode("a") - let aDecoded = try! CodableCBORDecoder().decode(String.self, from: a) - XCTAssertEqual(aDecoded, "a") - let IETF = try! CodableCBOREncoder().encode("IETF") - let IETFDecoded = try! CodableCBORDecoder().decode(String.self, from: IETF) - XCTAssertEqual(IETFDecoded, "IETF") - let quoteSlash = try! CodableCBOREncoder().encode("\"\\") - let quoteSlashDecoded = try! CodableCBORDecoder().decode(String.self, from: quoteSlash) - XCTAssertEqual(quoteSlashDecoded, "\"\\") - let littleUWithDiaeresis = try! CodableCBOREncoder().encode("\u{00FC}") - let littleUWithDiaeresisDecoded = try! CodableCBORDecoder().decode(String.self, from: littleUWithDiaeresis) - XCTAssertEqual(littleUWithDiaeresisDecoded, "\u{00FC}") - } - - func testArrays() { - let empty = try! CodableCBOREncoder().encode([String]()) - let emptyDecoded = try! CodableCBORDecoder().decode([String].self, from: empty) - XCTAssertEqual(emptyDecoded, []) - let oneTwoThree = try! CodableCBOREncoder().encode([1, 2, 3]) - let oneTwoThreeDecoded = try! CodableCBORDecoder().decode([Int].self, from: oneTwoThree) - XCTAssertEqual(oneTwoThreeDecoded, [1, 2, 3]) - let lotsOfInts = try! CodableCBOREncoder().encode([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]) - let lotsOfIntsDecoded = try! CodableCBORDecoder().decode([Int].self, from: lotsOfInts) - XCTAssertEqual(lotsOfIntsDecoded, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]) - let nestedSimple = try! CodableCBOREncoder().encode([[1], [2, 3], [4, 5]]) - let nestedSimpleDecoded = try! CodableCBORDecoder().decode([[Int]].self, from: nestedSimple) - XCTAssertEqual(nestedSimpleDecoded, [[1], [2, 3], [4, 5]]) - } - - func testMaps() { - let empty = try! CodableCBOREncoder().encode([String: String]()) - let emptyDecoded = try! CodableCBORDecoder().decode([String: String].self, from: empty) - XCTAssertEqual(emptyDecoded, [:]) - let stringToString = try! CodableCBOREncoder().encode(["a": "A", "b": "B", "c": "C", "d": "D", "e": "E"]) - let stringToStringDecoded = try! CodableCBORDecoder().decode([String: String].self, from: stringToString) - XCTAssertEqual(stringToStringDecoded, ["a": "A", "b": "B", "c": "C", "d": "D", "e": "E"]) - let intKeyedMap = [1: 2, 3: 4] - let oneTwoThreeFour = try! CodableCBOREncoder().encode(intKeyedMap) - let oneTwoThreeFourDecoded = try! CodableCBORDecoder().decode([Int: Int].self, from: oneTwoThreeFour) - XCTAssertEqual(oneTwoThreeFourDecoded, intKeyedMap) - - let encoder = CodableCBOREncoder() - encoder.forbidNonStringMapKeys = true - XCTAssertThrowsError(try encoder.encode(intKeyedMap)) { err in - XCTAssertEqual(err as! CBOREncoderError, CBOREncoderError.nonStringKeyInMap) - } - } - - func testWrappedStruct() { - struct Wrapped: Decodable { - let _id: String - let value: T - - private enum CodingKeys: String, CodingKey { - case _id - } - - init(from decoder: Decoder) throws { - let container = try decoder.container(keyedBy: CodingKeys.self) - - _id = try container.decode(String.self, forKey: ._id) - value = try T(from: decoder) - } - } - - struct BasicCar: Codable { - let color: String - let age: Int - let data: Data - } - - struct Car: Codable { - let _id: String - let color: String - let age: Int - let data: Data - } - - // Generate some random Data - let randomBytes = (1...4).map { _ in UInt8.random(in: 0...UInt8.max) } - let data = Data(randomBytes) - - let car = Car( - _id: "5caf23633337661721236cfa", - color: "Red", - age: 56, - data: data - ) - - let encodedCar = try! CodableCBOREncoder().encode(car) - let decoded = try! CodableCBORDecoder().decode(Wrapped.self, from: encodedCar) - - XCTAssertEqual(decoded._id, car._id) - XCTAssertEqual(decoded.value.color, car.color) - XCTAssertEqual(decoded.value.age, car.age) - XCTAssertEqual(decoded.value.data, data) - } - - func testStructWithFloat() { - struct MenuItemWithFloatOrdinal: Codable { - var _id: String - var category: String - var ordinal: Float - } - - let menuItem = MenuItemWithFloatOrdinal( - _id: "aaa", - category: "cake", - ordinal: 12 - ) - - let encoded = try! CodableCBOREncoder().encode(menuItem) - let decoded = try! CodableCBORDecoder().decode(MenuItemWithFloatOrdinal.self, from: encoded) - - XCTAssertEqual(decoded._id, menuItem._id) - XCTAssertEqual(decoded.category, menuItem.category) - XCTAssertEqual(decoded.ordinal, menuItem.ordinal) - } - - func testStructContainingEnum() { - enum Status: Codable { - case done, underway, open - } - - struct Order: Codable { - var status: Status = .done - } - - let order = Order() - let cborOrder = try! CodableCBOREncoder().encode(order) - let decodedCBOROrder = try! CodableCBORDecoder().decode(Order.self, from: cborOrder) - - XCTAssertEqual(decodedCBOROrder.status, order.status) - } - - func testStructWithArray() { - struct StructWithArray: Codable, Equatable { - let arr: [Int] - } - - let arraysToTest = [[], [1], [2, 3]] - - for arr in arraysToTest { - let structWithArray = StructWithArray(arr: arr) - - let encoded = try! CodableCBOREncoder().encode(structWithArray) - let decoded = try! CodableCBORDecoder().decode(StructWithArray.self, from: encoded) - - XCTAssertEqual(structWithArray, decoded) - } - } - - func testMultiTypeStruct() { - struct MultiTypeStruct: Codable, Equatable { - let stringVal: String - let bytesVal: Data - let integer: Int - let booleanVal: Bool - let doubleVal: Double - let arrayVal: [Int]? - } - - let arraysToTest: [[Int]?] = [[], nil] - - for arr in arraysToTest { - let multiTypeStruct = MultiTypeStruct( - stringVal: "s", - bytesVal: Data(hex: "aabbcc")!, - integer: 4711, - booleanVal: true, - doubleVal: 3.14, - arrayVal: arr - ) - - let encoded = try! CodableCBOREncoder().encode(multiTypeStruct) - let decoded = try! CodableCBORDecoder().decode(MultiTypeStruct.self, from: encoded) - - XCTAssertEqual(multiTypeStruct, decoded) - } - - let hexToRoundtrip = [ - // Definite map without an arrayVal key-value pair - "a56a626f6f6c65616e56616cf569737472696e6756616c63666f6f69646f75626c6556616cfb40091eb851eb851f67696e746567657219126768627974657356616c43aabbcc", - - // Indefinite map without an arrayVal key-value pair - "bf6a626f6f6c65616e56616cf569737472696e6756616c63666f6f69646f75626c6556616cfb40091eb851eb851f67696e746567657219126768627974657356616c43aabbccff", - - // Definite map with an arrayVal key-value pair - "a669737472696e6756616c63666f6f6a626f6f6c65616e56616cf567696e746567657219126769646f75626c6556616cfb40091eb851eb851f68627974657356616c43aabbcc68617272617956616c84010222191267", - - // Indefinite map with an arrayVal key-value pair - "bf69737472696e6756616c63666f6f6a626f6f6c65616e56616cf567696e746567657219126769646f75626c6556616cfb40091eb851eb851f68627974657356616c43aabbcc68617272617956616c84010222191267ff" - ] - - for hex in hexToRoundtrip { - let _ = try! CodableCBORDecoder().decode(MultiTypeStruct.self, from: Data(hex: hex)!) - } - } - - func testAnyRecursive() { - let anyRecursive: AnyRecursive = .object([ - "intValue": .number(10), - "floatValue": .number(130.1), - "stringValue": .string("name 1"), - "boolValue": .bool(true), - "nilValue": .null, - "arrayValue": .array([.number(1000), .number(2000), .number(3000)]), - "objectValue": .object(["intValue": .number(5100)]) - ]) - - let encoded = try! CodableCBOREncoder().encode(anyRecursive) - let decoded = try! CodableCBORDecoder().decode(AnyRecursive.self, from: encoded) - XCTAssertEqual(anyRecursive, decoded) - } - - func testOptionalArray() { - struct StructWithOptionalArray: Codable, Equatable { - var array: [InnerStruct]? - } - - struct InnerStruct: Codable, Equatable { - var parameter: String - } - - let test1 = StructWithOptionalArray(array: [InnerStruct(parameter: "present")]) - let test2 = StructWithOptionalArray(array: nil) - - for testVal in [test1, test2] { - let encoded = try! CodableCBOREncoder().encode(testVal) - let decoded = try! CodableCBORDecoder().decode(StructWithOptionalArray.self, from: encoded) - XCTAssertEqual(testVal, decoded) - } - } - - func testFoundationHeavyType() { - struct FoundationLaden: Codable, Equatable { - let date: Date - let oldDate: Date - let dateComponents: DateComponents - let calendar: Calendar - let locale: Locale - let url: URL - let urlComponents: URLComponents - let measurement: Measurement - let uuid: UUID - let personNameComponents: PersonNameComponents - let timeZone: TimeZone - let decimal: Decimal - let dateInterval: DateInterval - let characterSet: CharacterSet - let indexPath: IndexPath - let indexSet: IndexSet - let range: Range - let data: Data - } - - var personNameComponents = PersonNameComponents() - personNameComponents.givenName = "Bridget" - personNameComponents.familyName = "Christie" - personNameComponents.middleName = "Louise" - personNameComponents.namePrefix = "Dame" - personNameComponents.nickname = "Bridge" - personNameComponents.nameSuffix = "Esq." - - var calendar = Calendar(identifier: .gregorian) - calendar.timeZone = TimeZone(identifier: "UTC")! - let dateComponents: Set = [ - .era, - .year, - .month, - .day, - .hour, - .minute, - .second, - .weekday, - .weekdayOrdinal, - .weekOfMonth, - .weekOfYear, - .yearForWeekOfYear, - .timeZone, - .calendar, - .nanosecond, - .quarter, - ] - - let foundationLadenObj = FoundationLaden( - date: Date(timeIntervalSince1970: 1501283774), - oldDate: Date(timeIntervalSince1970: -65672354), - dateComponents: calendar.dateComponents(dateComponents, from: Date(timeIntervalSince1970: 1501283775)), - calendar: calendar, - locale: Locale(identifier: "UTC"), - url: URL(string: "https://www.cars.com/cool/big?color=yellow")!, - urlComponents: URLComponents(string: "https://subdomain.domain.com/some/path?and_a_query=string")!, - measurement: Measurement(value: 67.4, unit: UnitMass.grams), - uuid: UUID(), - personNameComponents: personNameComponents, - timeZone: TimeZone(identifier: "PST")!, - decimal: Decimal(sign: .plus, exponent: -10, significand: 31415926536), - dateInterval: DateInterval(start: Date(timeIntervalSince1970: 1501283772), duration: 86400), - characterSet: CharacterSet.illegalCharacters, - indexPath: IndexPath(indexes: [12, 3]), - indexSet: IndexSet(arrayLiteral: 1, 2, 3, 9, 123, 1247890123), - range: Range(NSRange(location: 12, length: 366))!, - data: Data([163, 99, 95, 105, 100, 99, 97, 97, 97, 104, 99, 97, 116, 101, 103, 111, 114, 121, 100, 99, 97, 107, 101, 103, 111, 114, 100, 105, 110, 97, 108, 250, 65, 64, 0, 0]) - ) - - let encoder = CodableCBOREncoder() - encoder.useStringKeys = true - let encodedWithStringKeys = try! encoder.encode(foundationLadenObj) - let decoder = CodableCBORDecoder() - decoder.useStringKeys = true - let decodedFromStringKeys = try! decoder.decode(FoundationLaden.self, from: encodedWithStringKeys) - XCTAssertEqual(decodedFromStringKeys, foundationLadenObj) - - encoder.dateStrategy = .annotatedMap - let encodedWithStringKeysAndAnnotatedMapDate = try! encoder.encode(foundationLadenObj) - decoder.dateStrategy = .annotatedMap - let decodedFromStringKeysAndAnnotatedMapDate = try! decoder.decode(FoundationLaden.self, from: encodedWithStringKeysAndAnnotatedMapDate) - XCTAssertEqual(decodedFromStringKeysAndAnnotatedMapDate, foundationLadenObj) - - XCTAssertNotEqual(encodedWithStringKeys, encodedWithStringKeysAndAnnotatedMapDate) - - let encoded = try! CodableCBOREncoder().encode(foundationLadenObj) - let decoded = try! CodableCBORDecoder().decode(FoundationLaden.self, from: encoded) - XCTAssertEqual(decoded, foundationLadenObj) - - XCTAssertNotEqual(encoded, encodedWithStringKeys) - XCTAssertNotEqual(encoded, encodedWithStringKeysAndAnnotatedMapDate) - } - -#if os(macOS) - func testMacOSOnlyTypes() { - struct MacOSOnlyTypes: Codable, Equatable { - let affineTransform: AffineTransform - let point: NSPoint - let size: NSSize - } - - let macOSOnlyObj = MacOSOnlyTypes( - affineTransform: AffineTransform(translationByX: 12.34, byY: -56.78), - point: NSPoint(x: -99.123, y: 2.04), - size: NSSize(width: 77.77, height: 88.88) - ) - - let encoder = CodableCBOREncoder() - encoder.useStringKeys = true - let encodedWithStringKeys = try! encoder.encode(macOSOnlyObj) - let decoder = CodableCBORDecoder() - decoder.useStringKeys = true - let decodedFromStringKeys = try! decoder.decode(MacOSOnlyTypes.self, from: encodedWithStringKeys) - XCTAssertEqual(decodedFromStringKeys, macOSOnlyObj) - - let encoded = try! CodableCBOREncoder().encode(macOSOnlyObj) - let decoded = try! CodableCBORDecoder().decode(MacOSOnlyTypes.self, from: encoded) - XCTAssertEqual(decoded, macOSOnlyObj) - } -#endif -} - -enum AnyRecursive: Equatable { - case string(String) - case number(Float) - case object([String: AnyRecursive]) - case array([AnyRecursive]) - case bool(Bool) - case null -} - -extension AnyRecursive: Codable { - init(from decoder: Decoder) throws { - let container = try decoder.singleValueContainer() - - if let object = try? container.decode([String: AnyRecursive].self) { - self = .object(object) - } else if let array = try? container.decode([AnyRecursive].self) { - self = .array(array) - } else if let string = try? container.decode(String.self) { - self = .string(string) - } else if let bool = try? container.decode(Bool.self) { - self = .bool(bool) - } else if let number = try? container.decode(Float.self) { - self = .number(number) - } else if container.decodeNil() { - self = .null - } else { - throw DecodingError.dataCorrupted( - .init( - codingPath: decoder.codingPath, - debugDescription: "Invalid \(String(describing: AnyRecursive.self)) value." - ) - ) - } - } - - func encode(to encoder: Encoder) throws { - var container = encoder.singleValueContainer() - - switch self { - case let .array(array): - try container.encode(array) - case let .object(object): - try container.encode(object) - case let .string(string): - try container.encode(string) - case let .number(number): - try container.encode(number) - case let .bool(bool): - try container.encode(bool) - case .null: - try container.encodeNil() - } - } -} diff --git a/Old/SwiftCBORTests-old/CBORDecoderTests.swift b/Old/SwiftCBORTests-old/CBORDecoderTests.swift deleted file mode 100644 index 502f8d1..0000000 --- a/Old/SwiftCBORTests-old/CBORDecoderTests.swift +++ /dev/null @@ -1,221 +0,0 @@ -import XCTest -@testable import SwiftCBOR - -class CBORDecoderTests: XCTestCase { - func testDecodeNumbers() { - for i in (0..<24) { - XCTAssertEqual(try! CBORDecoder(input: [UInt8(i)]).decodeItem(), CBOR.unsignedInt(UInt64(i))) - } - XCTAssertEqual(try! CBORDecoder(input: [0x18, 0xff]).decodeItem(), 255) - XCTAssertEqual(try! CBORDecoder(input: [0x19, 0x03, 0xe8]).decodeItem(), 1000) // Network byte order! - XCTAssertEqual(try! CBORDecoder(input: [0x19, 0xff, 0xff]).decodeItem(), 65535) - do { _ = try CBORDecoder(input: [0x19, 0xff]).decodeItem(); XCTAssertTrue(false) } catch { XCTAssertTrue(true) } - XCTAssertEqual(try! CBORDecoder(input: [0x1a, 0x00, 0x0f, 0x42, 0x40]).decodeItem(), 1000000) - XCTAssertEqual(try! CBORDecoder(input: [0x1a, 0xff, 0xff, 0xff, 0xff]).decodeItem(), 4294967295) - do { _ = try CBORDecoder(input: [0x1a]).decodeItem(); XCTAssertTrue(false) } catch { XCTAssertTrue(true) } - XCTAssertEqual(try! CBORDecoder(input: [0x1b, 0x00, 0x00, 0x00, 0xe8, 0xd4, 0xa5, 0x10, 0x00]).decodeItem(), 1000000000000) - XCTAssertEqual(try! CBORDecoder(input: [0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]).decodeItem(), CBOR.unsignedInt(18446744073709551615)) - do { _ = try CBORDecoder(input: [0x1b, 0x00, 0x00]).decodeItem(); XCTAssertTrue(false) } catch { XCTAssertTrue(true) } - - XCTAssertEqual(try! CBORDecoder(input: [0x20]).decodeItem(), -1) - XCTAssertEqual(try! CBORDecoder(input: [0x21]).decodeItem(), CBOR.negativeInt(1)) - XCTAssertEqual(try! CBORDecoder(input: [0x37]).decodeItem(), -24) - XCTAssertEqual(try! CBORDecoder(input: [0x38, 0xff]).decodeItem(), -256) - XCTAssertEqual(try! CBORDecoder(input: [0x39, 0x03, 0xe7]).decodeItem(), -1000) - XCTAssertEqual(try! CBORDecoder(input: [0x3a, 0x00, 0x0f, 0x42, 0x3f]).decodeItem(), CBOR.negativeInt(999999)) - XCTAssertEqual(try! CBORDecoder(input: [0x3b, 0x00, 0x00, 0x00, 0xe8, 0xd4, 0xa5, 0x0f, 0xff]).decodeItem(), CBOR.negativeInt(999999999999)) - } - - func testDecodeByteStrings() { - XCTAssertEqual(try! CBORDecoder(input: [0x40]).decodeItem(), CBOR.byteString([])) - XCTAssertEqual(try! CBORDecoder(input: [0x41, 0xf0]).decodeItem(), CBOR.byteString([0xf0])) - XCTAssertEqual(try! CBORDecoder(input: [0x57, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xaa]).decodeItem(), CBOR.byteString([0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xaa])) - XCTAssertEqual(try! CBORDecoder(input: [0x58, 0]).decodeItem(), CBOR.byteString([])) - XCTAssertEqual(try! CBORDecoder(input: [0x58, 1, 0xf0]).decodeItem(), CBOR.byteString([0xf0])) - XCTAssertEqual(try! CBORDecoder(input: [0x59, 0x00, 3, 0xc0, 0xff, 0xee]).decodeItem(), CBOR.byteString([0xc0, 0xff, 0xee])) - XCTAssertEqual(try! CBORDecoder(input: [0x5a, 0x00, 0x00, 0x00, 3, 0xc0, 0xff, 0xee]).decodeItem(), CBOR.byteString([0xc0, 0xff, 0xee])) - XCTAssertEqual(try! CBORDecoder(input: [0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 3, 0xc0, 0xff, 0xee]).decodeItem(), CBOR.byteString([0xc0, 0xff, 0xee])) - XCTAssertEqual(try! CBORDecoder(input: [0x5f, 0x58, 3, 0xc0, 0xff, 0xee, 0x43, 0xc0, 0xff, 0xee, 0xff]).decodeItem(), CBOR.byteString([0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee])) - } - - func testDecodeData() { - XCTAssertEqual(try! CBORDecoder(input: [0x40]).decodeItem(), CBOR.byteString([])) - XCTAssertEqual(try! CBORDecoder(input: [0x41, 0xf0]).decodeItem(), CBOR.byteString([0xf0])) - XCTAssertEqual(try! CBORDecoder(input: [0x57, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xaa]).decodeItem(), CBOR.byteString([0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xaa])) - XCTAssertEqual(try! CBORDecoder(input: [0x58, 0]).decodeItem(), CBOR.byteString([])) - XCTAssertEqual(try! CBORDecoder(input: [0x58, 1, 0xf0]).decodeItem(), CBOR.byteString([0xf0])) - XCTAssertEqual(try! CBORDecoder(input: [0x59, 0x00, 3, 0xc0, 0xff, 0xee]).decodeItem(), CBOR.byteString([0xc0, 0xff, 0xee])) - XCTAssertEqual(try! CBORDecoder(input: [0x5a, 0x00, 0x00, 0x00, 3, 0xc0, 0xff, 0xee]).decodeItem(), CBOR.byteString([0xc0, 0xff, 0xee])) - XCTAssertEqual(try! CBORDecoder(input: [0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 3, 0xc0, 0xff, 0xee]).decodeItem(), CBOR.byteString([0xc0, 0xff, 0xee])) - XCTAssertEqual(try! CBORDecoder(input: [0x5f, 0x58, 3, 0xc0, 0xff, 0xee, 0x43, 0xc0, 0xff, 0xee, 0xff]).decodeItem(), CBOR.byteString([0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee])) - } - - func testDecodeUtf8Strings() { - XCTAssertEqual(try! CBORDecoder(input: [0x60]).decodeItem(), CBOR.utf8String("")) - XCTAssertEqual(try! CBORDecoder(input: [0x61, 0x42]).decodeItem(), "B") - XCTAssertEqual(try! CBORDecoder(input: [0x78, 0]).decodeItem(), "") - XCTAssertEqual(try! CBORDecoder(input: [0x78, 1, 0x42]).decodeItem(), "B") - XCTAssertEqual(try! CBORDecoder(input: [0x79, 0x00, 3, 0x41, 0x42, 0x43]).decodeItem(), CBOR.utf8String("ABC")) - XCTAssertEqual(try! CBORDecoder(input: [0x7a, 0x00, 0x00, 0x00, 3, 0x41, 0x42, 0x43]).decodeItem(), "ABC") - XCTAssertEqual(try! CBORDecoder(input: [0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 3, 0x41, 0x42, 0x43]).decodeItem(), "ABC") - XCTAssertEqual(try! CBORDecoder(input: [0x7f, 0x78, 3, 0x41, 0x42, 0x43, 0x63, 0x41, 0x42, 0x43, 0xff]).decodeItem(), "ABCABC") - } - - func testDecodeArrays() { - XCTAssertEqual(try! CBORDecoder(input: [0x80]).decodeItem(), []) - XCTAssertEqual(try! CBORDecoder(input: [0x82, 0x18, 1, 0x79, 0x00, 3, 0x41, 0x42, 0x43]).decodeItem(), [1, "ABC"]) - XCTAssertEqual(try! CBORDecoder(input: [0x98, 0]).decodeItem(), []) - XCTAssertEqual(try! CBORDecoder(input: [0x98, 3, 0x18, 2, 0x18, 2, 0x79, 0x00, 3, 0x41, 0x42, 0x43, 0xff]).decodeItem(), [2, 2, "ABC"]) - XCTAssertEqual(try! CBORDecoder(input: [0x9f, 0x18, 255, 0x9b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 2, 0x18, 1, 0x79, 0x00, 3, 0x41, 0x42, 0x43, 0x79, 0x00, 3, 0x41, 0x42, 0x43, 0xff]).decodeItem(), [255, [1, "ABC"], "ABC"]) - XCTAssertEqual(try! CBORDecoder(input: [0x9f, 0x81, 0x01, 0x82, 0x02, 0x03, 0x9f, 0x04, 0x05, 0xff, 0xff]).decodeItem(), [[1], [2, 3], [4, 5]]) - } - - func testDecodeMaps() { - XCTAssertEqual(try! CBORDecoder(input: [0xa0]).decodeItem(), [:]) - XCTAssertEqual(try! CBORDecoder(input: [0xa1, 0x63, 0x6b, 0x65, 0x79, 0x37]).decodeItem()!["key"], -24) - XCTAssertEqual(try! CBORDecoder(input: [0xb8, 1, 0x63, 0x6b, 0x65, 0x79, 0x81, 0x37]).decodeItem(), ["key" : [-24]]) - XCTAssertEqual(try! CBORDecoder(input: [0xbf, 0x63, 0x6b, 0x65, 0x79, 0xa1, 0x63, 0x6b, 0x65, 0x79, 0x37, 0xff]).decodeItem(), ["key" : ["key" : -24]]) - XCTAssertEqual(try! CBORDecoder(input: [0xa3, 0x63, 0x5f, 0x69, 0x64, 0x63, 0x61, 0x61, 0x61, 0x68, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x64, 0x63, 0x61, 0x6b, 0x65, 0x67, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0xf9, 0x4a, 0x00]).decodeItem(), ["_id": "aaa", "category": "cake", "ordinal": CBOR.half(12.0)]) - } - - func testDecodeTagged() { - XCTAssertEqual(try! CBORDecoder(input: [0xc0, 0x79, 0x00, 3, 0x41, 0x42, 0x43]).decodeItem(), CBOR.tagged(.standardDateTimeString, "ABC")) - XCTAssertEqual(try! CBORDecoder(input: [0xd8, 255, 0x79, 0x00, 3, 0x41, 0x42, 0x43]).decodeItem(), CBOR.tagged(.init(rawValue: 255), "ABC")) - XCTAssertEqual(try! CBORDecoder(input: [0xdb, 255, 255, 255, 255, 255, 255, 255, 255, 0x79, 0x00, 3, 0x41, 0x42, 0x43]).decodeItem(), CBOR.tagged(.init(rawValue: UInt64.max), "ABC")) - XCTAssertEqual(try! CBORDecoder(input: [0xdb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 3, 0xbf, 0x63, 0x6b, 0x65, 0x79, 0xa1, 0x63, 0x6b, 0x65, 0x79, 0x37, 0xff]).decodeItem(), CBOR.tagged(.negativeBignum, ["key" : ["key" : -24]])) - } - - func testDecodeSimple() { - XCTAssertEqual(try! CBORDecoder(input: [0xe0]).decodeItem(), CBOR.simple(0)) - XCTAssertEqual(try! CBORDecoder(input: [0xf3]).decodeItem(), CBOR.simple(19)) - XCTAssertEqual(try! CBORDecoder(input: [0xf8, 19]).decodeItem(), CBOR.simple(19)) - XCTAssertEqual(try! CBORDecoder(input: [0xf4]).decodeItem(), false) - XCTAssertEqual(try! CBORDecoder(input: [0xf5]).decodeItem(), true) - XCTAssertEqual(try! CBORDecoder(input: [0xf6]).decodeItem(), CBOR.null) - XCTAssertEqual(try! CBORDecoder(input: [0xf7]).decodeItem(), CBOR.undefined) - } - - func testDecodeFloats() { - XCTAssertEqual(try! CBORDecoder(input: [0xf9, 0xc4, 0x00]).decodeItem(), CBOR.half(-4.0)) - XCTAssertEqual(try! CBORDecoder(input: [0xf9, 0xfc, 0x00]).decodeItem(), CBOR.half(-Float.infinity)) - XCTAssertEqual(try! CBORDecoder(input: [0xfa, 0x47, 0xc3, 0x50, 0x00]).decodeItem(), 100000.0) - XCTAssertEqual(try! CBORDecoder(input: [0xfa, 0x7f, 0x80, 0x00, 0x00]).decodeItem(), CBOR.float(Float.infinity)) - XCTAssertEqual(try! CBORDecoder(input: [0xfb, 0xc0, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66]).decodeItem(), CBOR.double(-4.1)) - } - - func testDecodeDates() { - let dateOne = Date(timeIntervalSince1970: 1363896240) - XCTAssertEqual(try! CBOR.decode([0xc1, 0x1a, 0x51, 0x4b, 0x67, 0xb0]), CBOR.date(dateOne)) - let dateTwo = Date(timeIntervalSince1970: 1363896240.5) - XCTAssertEqual(try! CBOR.decode([0xc1, 0xfb, 0x41, 0xd4, 0x52, 0xd9, 0xec, 0x20, 0x00, 0x00]), CBOR.date(dateTwo)) - } - - func testDecodePerformance() { - var data : ArraySlice = [0x9f] - for i in (0..<255) { - data.append(contentsOf: [0xbf, 0x63, 0x6b, 0x65, 0x79, 0xa1, 0x63, 0x6b, 0x65, 0x79, 0x18, UInt8(i), 0xff]) - } - data.append(0xff) - self.measure { - _ = try! CBORDecoder(input: data).decodeItem() - } - } - - func testDecodeMapFromIssue29() { - let loremIpsumData: [UInt8] = [0x4c, 0x6f, 0x72, 0x65, 0x6d, 0x20, 0x69, 0x70, 0x73, 0x75, 0x6d, 0x20, 0x64, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x73, 0x69, 0x74, 0x20, 0x61, 0x6d, 0x65, 0x74, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x63, 0x74, 0x65, 0x74, 0x75, 0x72, 0x20, 0x61, 0x64, 0x69, 0x70, 0x69, 0x73, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x2e, 0x20, 0x51, 0x75, 0x69, 0x73, 0x71, 0x75, 0x65, 0x20, 0x65, 0x78, 0x20, 0x61, 0x6e, 0x74, 0x65, 0x2c, 0x20, 0x73, 0x65, 0x6d, 0x70, 0x65, 0x72, 0x20, 0x75, 0x74, 0x20, 0x66, 0x61, 0x75, 0x63, 0x69, 0x62, 0x75, 0x73, 0x20, 0x70, 0x68, 0x61, 0x72, 0x65, 0x74, 0x72, 0x61, 0x2c, 0x20, 0x61, 0x63, 0x63, 0x75, 0x6d, 0x73, 0x61, 0x6e, 0x20, 0x65, 0x74, 0x20, 0x61, 0x75, 0x67, 0x75, 0x65, 0x2e, 0x20, 0x56, 0x65, 0x73, 0x74, 0x69, 0x62, 0x75, 0x6c, 0x75, 0x6d, 0x20, 0x76, 0x75, 0x6c, 0x70, 0x75, 0x74, 0x61, 0x74, 0x65, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x20, 0x6c, 0x69, 0x67, 0x75, 0x6c, 0x61, 0x2c, 0x20, 0x65, 0x75, 0x20, 0x74, 0x69, 0x6e, 0x63, 0x69, 0x64, 0x75, 0x6e, 0x74, 0x20, 0x6f, 0x72, 0x63, 0x69, 0x20, 0x6c, 0x61, 0x63, 0x69, 0x6e, 0x69, 0x61, 0x20, 0x71, 0x75, 0x69, 0x73, 0x2e, 0x20, 0x50, 0x72, 0x6f, 0x69, 0x6e, 0x20, 0x73, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x69, 0x73, 0x71, 0x75, 0x65, 0x20, 0x64, 0x75, 0x69, 0x20, 0x61, 0x74, 0x20, 0x6d, 0x61, 0x67, 0x6e, 0x61, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x72, 0x61, 0x74, 0x2c, 0x20, 0x69, 0x64, 0x20, 0x62, 0x6c, 0x61, 0x6e, 0x64, 0x69, 0x74, 0x20, 0x66, 0x65, 0x6c, 0x69, 0x73, 0x20, 0x76, 0x65, 0x68, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x2e, 0x20, 0x4d, 0x61, 0x65, 0x63, 0x65, 0x6e, 0x61, 0x73, 0x20, 0x61, 0x63, 0x20, 0x6e, 0x69, 0x73, 0x6c, 0x20, 0x61, 0x20, 0x6f, 0x64, 0x69, 0x6f, 0x20, 0x76, 0x61, 0x72, 0x69, 0x75, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x75, 0x6d, 0x20, 0x6c] - let data: [UInt8] = [0xbf, 0x63, 0x6f, 0x66, 0x66, 0x00, 0x64, 0x64, 0x61, 0x74, 0x61, 0x59, 0x01, 0x2c] - + loremIpsumData - + [0x62, 0x72, 0x63, 0x00, 0x63, 0x6c, 0x65, 0x6e, 0x19, 0x01, 0x2c, 0xff] - - let expectedMap = CBOR.map([ - CBOR.utf8String("off"): CBOR.unsignedInt(0), - CBOR.utf8String("data"): CBOR.byteString(loremIpsumData), - CBOR.utf8String("rc"): CBOR.unsignedInt(0), - CBOR.utf8String("len"): CBOR.unsignedInt(300) - ]) - - let decoded = try! CBOR.decode(data) - XCTAssertEqual(decoded, expectedMap) - } - - func testDecodeFromIssue78() { - struct CborFiles: Codable { - let files: [File] - let status: Int - } - - struct File: Codable { - let name: String - let time, id, size, checksum: Int - } - - let withDefiniteArrayHex = "bf6566696c657381a5626964016474696d651a001b7d4868636865636b73756d1a0ad227576473697a6505646e616d656d2f6c66732f68722f31312e68726673746174757301ff" - let _ = try! CodableCBORDecoder().decode(CborFiles.self, from: withDefiniteArrayHex.hexaData) - - let withIndefiniteArrayHex = "bf6566696c65739fa5626964016474696d651a001b7d4868636865636b73756d1a0ad227576473697a6505646e616d656d2f6c66732f68722f31312e6872ff6673746174757301ff" - let _ = try! CodableCBORDecoder().decode(CborFiles.self, from: withIndefiniteArrayHex.hexaData) - } - - func testDecodeOfStructContainingNestedIndefiniteMapsAndArrays() { - struct NestedIndefinite: Codable, Equatable { - let nested: [String: [String: [[String: [[[String: [[String: Int]]]? ]]]]]] - } - - let hex = "bf666e6573746564bf6161bf61629fbf61639f9fbf61649fbf6165187bffffffff9fff9ff6ffffffffffffff" - - let decoded = try! CodableCBORDecoder().decode(NestedIndefinite.self, from: hex.hexaData) - let expected = NestedIndefinite(nested: ["a": ["b": [["c": [[["d": [["e": 123 ]] ]], [], [nil]]]]]]) - - XCTAssertEqual(decoded, expected) - } - - func testDecodeFailsForExtremelyDeepStructures() { - let justOverTags: [UInt8] = Array(repeating: 202, count: 1025) + [0] - XCTAssertThrowsError(try CBOR.decode(justOverTags, options: CBOROptions(maximumDepth: 1024))) { error in - XCTAssertEqual(error as? CBORError, CBORError.maximumDepthExceeded) - } - let endlessTags: [UInt8] = Array(repeating: 202, count: 10000) + [0] - XCTAssertThrowsError(try CBOR.decode(endlessTags, options: CBOROptions(maximumDepth: 1024))) { error in - XCTAssertEqual(error as? CBORError, CBORError.maximumDepthExceeded) - } - } - - func testDecodeFailsForSillyMaximumDepths() { - let singleItem: [UInt8] = [0] - XCTAssertThrowsError(try CBOR.decode(singleItem, options: CBOROptions(maximumDepth: -1))) { error in - XCTAssertEqual(error as? CBORError, CBORError.maximumDepthExceeded) - } - } - - func testDecodeSucceedsForAllowedDeepStructures() { - let singleItem: [UInt8] = [0] - XCTAssertNoThrow(try CBOR.decode(singleItem, options: CBOROptions(maximumDepth: 0))) - let endlessTags: [UInt8] = Array(repeating: 202, count: 1024) + [0] - XCTAssertNoThrow(try CBOR.decode(endlessTags, options: CBOROptions(maximumDepth: 1024))) - } - - func testRandomInputDoesNotHitStackLimits() { - for _ in 1...50 { - let length = Int.random(in: 1...1_000_000) - let randomData: [UInt8] = Array(repeating: UInt8.random(in: 0...255), count: length) - _ = try? CBOR.decode(randomData, options: CBOROptions(maximumDepth: 512)) - } - } -} - -#if os(Android) - -extension XCTestCase { - /// XCTestCase.measure on Android is problematic because - /// the emulator on a virtualized runner can be quite slow - /// but there is no way to set the standard deviation threshold - /// for failure, so we override it to simply run the block - /// and not perform any measurement. - /// - /// See: https://github.com/swiftlang/swift-corelibs-xctest/pull/506 - func measure(_ count: Int = 0, _ block: () -> ()) { - block() - } -} -#endif - diff --git a/Old/SwiftCBORTests-old/CBOREncodableTests.swift b/Old/SwiftCBORTests-old/CBOREncodableTests.swift deleted file mode 100644 index 83f7a0d..0000000 --- a/Old/SwiftCBORTests-old/CBOREncodableTests.swift +++ /dev/null @@ -1,66 +0,0 @@ -import XCTest -@testable import SwiftCBOR - -class CBOREncodableTests: XCTestCase { - func testToCBOR() { - XCTAssertEqual(CBOR.unsignedInt(0), 0.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.unsignedInt(1), 1.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.unsignedInt(20), 20.toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.unsignedInt(UInt64(Int8.max)), Int8.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(127, Int8.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.unsignedInt(UInt64(Int16.max)), Int16.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(32_767, Int16.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.unsignedInt(UInt64(Int32.max)), Int32.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(2_147_483_647, Int32.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.unsignedInt(UInt64(Int64.max)), Int64.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(9_223_372_036_854_775_807, Int64.max.toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.unsignedInt(UInt64(UInt8.max)), UInt8.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(255, UInt8.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.unsignedInt(UInt64(UInt16.max)), UInt16.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(65_535, UInt16.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.unsignedInt(UInt64(UInt32.max)), UInt32.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(4_294_967_295, UInt32.max.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.unsignedInt(UInt64.max), UInt64.max.toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.negativeInt(~UInt64(bitPattern: Int64(Int8.min))), Int8.min.toCBOR(options: CBOROptions())) - XCTAssertEqual(-128, Int8.min.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.negativeInt(~UInt64(bitPattern: Int64(Int16.min))), Int16.min.toCBOR(options: CBOROptions())) - XCTAssertEqual(-32_768, Int16.min.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.negativeInt(~UInt64(bitPattern: Int64(Int32.min))), Int32.min.toCBOR(options: CBOROptions())) - XCTAssertEqual(-2_147_483_648, Int32.min.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.negativeInt(~UInt64(bitPattern: Int64(Int64.min))), Int64.min.toCBOR(options: CBOROptions())) - XCTAssertEqual(-9_223_372_036_854_775_808, Int64.min.toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.double(Double.greatestFiniteMagnitude), Double.greatestFiniteMagnitude.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.double(Double.leastNonzeroMagnitude), Double.leastNonzeroMagnitude.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.double(Double.pi), Double.pi.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.double(0.123456789), 0.123456789.toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.float(Float.greatestFiniteMagnitude), Float.greatestFiniteMagnitude.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.float(Float.leastNonzeroMagnitude), Float.leastNonzeroMagnitude.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.float(Float.pi), Float.pi.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.float(0.123456789), Float(0.123456789).toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.boolean(true), true.toCBOR(options: CBOROptions())) - XCTAssertEqual(true, true.toCBOR(options: CBOROptions())) - XCTAssertEqual(CBOR.boolean(false), false.toCBOR(options: CBOROptions())) - XCTAssertEqual(false, false.toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.utf8String("test"), "test".toCBOR(options: CBOROptions())) - XCTAssertEqual("test", "test".toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.null, Optional.none.toCBOR(options: CBOROptions())) - XCTAssertEqual(nil, Optional.none.toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.byteString([1, 2, 3]), Data([1, 2, 3]).toCBOR(options: CBOROptions())) - - XCTAssertEqual(CBOR.array([CBOR.unsignedInt(1), CBOR.unsignedInt(2)]), [1, 2].toCBOR(options: CBOROptions())) - - XCTAssertEqual( - CBOR.map([CBOR.utf8String("a"): CBOR.unsignedInt(1), CBOR.utf8String("b"): CBOR.unsignedInt(2)]), - ["a": 1, "b": 2].toCBOR(options: CBOROptions()) - ) - } -} diff --git a/Old/SwiftCBORTests-old/CBOREncoderTests.swift b/Old/SwiftCBORTests-old/CBOREncoderTests.swift deleted file mode 100644 index 79f6bc4..0000000 --- a/Old/SwiftCBORTests-old/CBOREncoderTests.swift +++ /dev/null @@ -1,287 +0,0 @@ -import XCTest -@testable import SwiftCBOR - -class CBOREncoderTests: XCTestCase { - func assertEquivalent(_ input: T, _ cbor: [UInt8], options: CBOROptions = CBOROptions()) { - XCTAssertEqual(input.encode(options: options), cbor) - XCTAssertEqual(try! CBOR.decode(input.encode(options: options)), try! CBOR.decode(cbor)) - } - - func testEncodeInts() { - for i in 0..<24 { - assertEquivalent(i, [UInt8(i)]) - XCTAssertEqual((-i).encode().count, 1) - } - XCTAssertEqual(Int(-1).encode(), [0x20]) - XCTAssertEqual(UInt(1).encode(), [0x1]) - XCTAssertEqual(CBOR.encode(-10), [0x29]) - XCTAssertEqual(Int(-24).encode(), [0x37]) - XCTAssertEqual(Int(-25).encode(), [0x38, 24]) - XCTAssertEqual(1000000.encode(), [0x1a, 0x00, 0x0f, 0x42, 0x40]) - XCTAssertEqual(4294967295.encode(), [0x1a, 0xff, 0xff, 0xff, 0xff]) //UInt32.max - XCTAssertEqual(1000000000000.encode(), [0x1b, 0x00, 0x00, 0x00, 0xe8, 0xd4, 0xa5, 0x10, 0x00]) - XCTAssertEqual(Int(-1_000_000).encode(), [0x3a, 0x00, 0x0f, 0x42, 0x3f]) - XCTAssertEqual(Int(-1_000_000_000_000).encode(), [0x3b, 0x00, 0x00, 0x00, 0xe8, 0xd4, 0xa5, 0x0f, 0xff]) - } - - func testEncodeByteStrings() { - XCTAssertEqual(CBOR.encode([UInt8](), asByteString: true), [0x40]) - XCTAssertEqual(CBOR.encode([UInt8]([0xf0]), asByteString: true), [0x41, 0xf0]) - XCTAssertEqual(CBOR.encode([UInt8]([0x01, 0x02, 0x03, 0x04]), asByteString: true), [0x44, 0x01, 0x02, 0x03, 0x04]) - let bs23: [UInt8] = [0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xaa] - assert(bs23.count == 23) - XCTAssertEqual(CBOR.encode(bs23, asByteString: true), [0x57] + bs23) - let bs24 = bs23 + [0xaa] - XCTAssertEqual(CBOR.encode(bs24, asByteString: true), [0x58, 24] + bs24) - - // non-UInt8, raw bytes (reversed). - XCTAssertEqual(CBOR.encode([UInt16]([240]), asByteString: true), [0x41, 0x00, 0xf0]) - } - - func testEncodeData() { - XCTAssertEqual(CBOR.encode(Data()), [0x40]) - XCTAssertEqual(CBOR.encode(Data([0xf0])), [0x41, 0xf0]) - XCTAssertEqual(CBOR.encode(Data([0x01, 0x02, 0x03, 0x04])), [0x44, 0x01, 0x02, 0x03, 0x04]) - let bs23 = Data([0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xaa]) - assert(bs23.count == 23) - XCTAssertEqual(CBOR.encode(bs23), [0x57] + bs23) - let bs24 = Data(bs23 + [0xaa]) - XCTAssertEqual(CBOR.encode(bs24), [0x58, 24] + bs24) - - // non-UInt8, raw bytes (reversed). - XCTAssertEqual(CBOR.encode([UInt16]([240]), asByteString: true), [0x41, 0x00, 0xf0]) - } - - func testEncodeUtf8Strings() { - XCTAssertEqual("".encode(), [0x60]) - XCTAssertEqual("a".encode(), [0x61, 0x61]) - XCTAssertEqual("B".encode(), [0x61, 0x42]) - XCTAssertEqual(try! CBOR.decode("B".encode()), try! CBOR.decode([0x78, 1, 0x42])) - XCTAssertEqual("ABC".encode(), [0x63, 0x41, 0x42, 0x43]) - XCTAssertEqual(try! CBOR.decode("ABC".encode()), try! CBOR.decode([0x79, 0x00, 3, 0x41, 0x42, 0x43])) - XCTAssertEqual("IETF".encode(), [0x64, 0x49, 0x45, 0x54, 0x46]) - XCTAssertEqual("今日は".encode(), [0x69, 0xE4, 0xBB, 0x8A, 0xE6, 0x97, 0xA5, 0xE3, 0x81, 0xAF]) - XCTAssertEqual("♨️français;日本語！Longer text\n with break?".encode(), [0x78, 0x34, 0xe2, 0x99, 0xa8, 0xef, 0xb8, 0x8f, 0x66, 0x72, 0x61, 0x6e, 0xc3, 0xa7, 0x61, 0x69, 0x73, 0x3b, 0xe6, 0x97, 0xa5, 0xe6, 0x9c, 0xac, 0xe8, 0xaa, 0x9e, 0xef, 0xbc, 0x81, 0x4c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x20, 0x74, 0x65, 0x78, 0x74, 0x0a, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x3f]) - XCTAssertEqual("\"\\".encode(), [0x62, 0x22, 0x5c]) - XCTAssertEqual("\u{6C34}".encode(), [0x63, 0xe6, 0xb0, 0xb4]) - XCTAssertEqual("水".encode(), [0x63, 0xe6, 0xb0, 0xb4]) - XCTAssertEqual("\u{00fc}".encode(), [0x62, 0xc3, 0xbc]) - XCTAssertEqual("abc\n123".encode(), [0x67, 0x61, 0x62, 0x63, 0x0a, 0x31, 0x32, 0x33]) - } - - func testEncodeArrays() { - XCTAssertEqual(CBOR.encode(Array()), [0x80]) - XCTAssertEqual(Array().encode(), [0x80]) - - XCTAssertEqual(CBOR.encode([1, 2, 3]), [0x83, 0x01, 0x02, 0x03]) - XCTAssertEqual([1, 2, 3].encode(), [0x83, 0x01, 0x02, 0x03]) - - let arr: [[UInt64]] = [[1], [2, 3], [4, 5]] - - let wrapped = arr.map{ inner in return CBOR.array(inner.map{ return CBOR.unsignedInt($0) })} - XCTAssertEqual(CBOR.encode(wrapped), [0x83, 0x81, 0x01, 0x82, 0x02, 0x03, 0x82, 0x04, 0x05]) - - let arr25Enc: [UInt8] = [0x98,0x19,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x18,0x18,0x19] - XCTAssertEqual(CBOR.encode(Array(1...25)), arr25Enc) - } - - func testEncodeMaps() { - XCTAssertEqual(CBOR.encode(Dictionary()), [0xa0]) - - let encoded = CBOR.encode([1: 2, 3: 4]) - XCTAssert(encoded == [0xa2, 0x01, 0x02, 0x03, 0x04] || encoded == [0xa2, 0x03, 0x04, 0x01, 0x02]) - - let arr1: CBOR = [1] - let arr2: CBOR = [2,3] - let nestedEnc: [UInt8] = CBOR.encode(["a": arr1, "b": arr2]) - let encodedAFirst: [UInt8] = [0xa2, 0x61, 0x61, 0x81, 0x01, 0x61, 0x62, 0x82, 0x02, 0x03] - let encodedBFirst: [UInt8] = [0xa2, 0x61, 0x62, 0x82, 0x02, 0x03, 0x61, 0x61, 0x81, 0x01] - XCTAssert(nestedEnc == encodedAFirst || nestedEnc == encodedBFirst) - - let mapToAny: [String: Any] = [ - "a": 1, - "b": [2, 3] - ] - let encodedMapToAny = try! CBOR.encodeMap(mapToAny) - XCTAssertEqual(encodedMapToAny, [0xa2, 0x61, 0x61, 0x01, 0x61, 0x62, 0x82, 0x02, 0x03]) - - let mapToAnyWithIntKeys: [Int: Any] = [ - 12: 1, - 51: "testing" - ] - XCTAssertThrowsError(try CBOR.encodeMap(mapToAnyWithIntKeys, options: CBOROptions(forbidNonStringMapKeys: true))) { err in - XCTAssertEqual(err as! CBOREncoderError, CBOREncoderError.nonStringKeyInMap) - } - } - - func testEncodeTagged() { - let bignum: [UInt8] = [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] // 2**64 - let bignumCBOR = CBOR.byteString(bignum) - XCTAssertEqual(CBOR.encodeTagged(tag: .positiveBignum, value: bignumCBOR), [0xc2, 0x49] + bignum) - XCTAssertEqual(CBOR.encodeTagged(tag: .init(rawValue: UInt64.max), value: bignumCBOR), [0xdb, 255, 255, 255, 255, 255, 255, 255, 255, 0x49] + bignum) - } - - func testEncodeSimple() { - XCTAssertEqual(false.encode(), [0xf4]) - XCTAssertEqual(true.encode(), [0xf5]) - XCTAssertEqual(CBOR.null.encode(), [0xf6]) - XCTAssertEqual(CBOR.undefined.encode(), [0xf7]) - XCTAssertEqual(CBOR.simple(16).encode(), [0xf0]) - XCTAssertEqual(CBOR.simple(24).encode(), [0xf8, 0x18]) - XCTAssertEqual(CBOR.simple(255).encode(), [0xf8, 0xff]) - XCTAssertEqual(CBOR.break.encode(), [0xff]) - } - - func testEncodeFloats() { - // The following tests are modifications of examples of Float16 in the RFC - XCTAssertEqual(Float(0.0).encode(), [0xfa,0x00, 0x00, 0x00, 0x00]) - XCTAssertEqual(Float(-0.0).encode(), [0xfa, 0x80, 0x00, 0x00, 0x00]) - XCTAssertEqual(Float(1.0).encode(), [0xfa, 0x3f, 0x80, 0x00, 0x00]) - XCTAssertEqual(Float(1.5).encode(), [0xfa,0x3f,0xc0, 0x00,0x00]) - XCTAssertEqual(Float(65504.0).encode(), [0xfa, 0x47, 0x7f, 0xe0, 0x00]) - - // The following are seen as Float32s in the RFC - XCTAssertEqual(Float(100000.0).encode(), [0xfa,0x47,0xc3,0x50,0x00]) - XCTAssertEqual(Float(3.4028234663852886e+38).encode(), [0xfa, 0x7f, 0x7f, 0xff, 0xff]) - - // The following are seen as Doubles in the RFC - XCTAssertEqual(Double(1.1).encode(), [0xfb,0x3f,0xf1,0x99,0x99,0x99,0x99,0x99,0x9a]) - XCTAssertEqual(Double(-4.1).encode(), [0xfb, 0xc0, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66]) - XCTAssertEqual(CBOR.encode(1.0e+300), [0xfb, 0x7e, 0x37, 0xe4, 0x3c, 0x88, 0x00, 0x75, 0x9c]) - XCTAssertEqual(Double(5.960464477539063e-8).encode(), [0xfb, 0x3e, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) - - // Special values - XCTAssertEqual(Float.infinity.encode(), [0xfa, 0x7f, 0x80, 0x00, 0x00]) - XCTAssertEqual(CBOR.encode(-Float.infinity), [0xfa, 0xff, 0x80, 0x00, 0x00]) - XCTAssertEqual(Double.infinity.encode(), [0xfb, 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) - XCTAssertEqual(CBOR.encode(-Double.infinity), [0xfb, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) - XCTAssertEqual(Float.nan.encode(), [0xfa,0x7f, 0xc0, 0x00, 0x00]) - XCTAssertEqual(Double.nan.encode(), [0xfb, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) - - // Swift's floating point literals are read as Doubles unless specifically specified. e.g. - XCTAssertEqual(CBOR.encode(0.0), [0xfb,0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) - } - - func testEncodeIndefiniteArrays() { - var indefArray = CBOR.encodeArrayStreamStart() - XCTAssertEqual(indefArray, [0x9f]) - let a: [Int] = [1, 2] - indefArray.append(contentsOf: CBOR.encodeArrayChunk(a)) // this encode a definite array! - // send current indef array (without close. the receiver would be programmed to anticipate this. - indefArray.append(contentsOf: 3.encode()) - indefArray.append(contentsOf: CBOR.encodeStreamEnd()) - XCTAssertEqual(indefArray, [0x9f, 0x01, 0x02, 0x03, 0xff]) - - indefArray.removeLast() // remove stream end - let innerArray = [UInt8]([1,2,3]) - indefArray.append(contentsOf: CBOR.encodeArrayStreamStart() + CBOR.encodeArrayChunk(innerArray)) - indefArray.append(contentsOf: CBOR.encodeStreamEnd()) // close inner array - indefArray.append(contentsOf: CBOR.encodeStreamEnd()) // close outer - XCTAssertEqual(indefArray, [0x9f, 0x01, 0x02, 0x03, 0x9f, 0x01, 0x02, 0x03, 0xff, 0xff]) - } - - func testEncodeIndefiniteMaps() { - XCTAssertEqual(CBOR.encodeMapStreamStart(), [0xbf]) - let map: [String: Int] = ["a": 1] - let map2 = ["B": 2] - let a1_enc: [UInt8] = [0x61, 0x61, 0x01] - let b2_enc: [UInt8] = [0x61, 0x42, 0x02] - let final: [UInt8] = CBOR.encodeMapStreamStart() + CBOR.encodeMapChunk(map) + CBOR.encodeMapChunk(map2) + CBOR.encodeStreamEnd() - XCTAssertEqual(final, [0xbf] + a1_enc + b2_enc + [0xff]) - } - - func testEncodeIndefiniteStrings() { - XCTAssertEqual(CBOR.encodeStringStreamStart(), [0x7f]) - let s = "a" - let t = "B" - let st_enc: [UInt8] = [0x7f, 0x61, 0x61, 0x61, 0x42, 0xff] - XCTAssertEqual(CBOR.encodeStringStreamStart() + CBOR.encode(s) + CBOR.encode(t) + CBOR.encodeStreamEnd(), st_enc) - } - - func testEncodeIndefiniteByteStrings() { - XCTAssertEqual(CBOR.encodeByteStringStreamStart(), [0x5f]) - let bs: [UInt8] = [0xf0] - let bs2: [UInt8] = [0xff] - let cbor: [UInt8] = [0x5f, 0x41, 0xf0, 0x41, 0xff, 0xff] - let encoded = CBOR.encodeByteStringStreamStart() - + CBOR.encode(bs, asByteString: true) - + CBOR.encode(bs2, asByteString: true) - + CBOR.encodeStreamEnd() - XCTAssertEqual(encoded, cbor) - } - - func testEncodeDates() { - let dateFormatter = DateFormatter() - dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZ" - dateFormatter.locale = Locale(identifier: "en_US_POSIX") - dateFormatter.timeZone = TimeZone(secondsFromGMT: 0) - let dateOne = dateFormatter.date(from: "2013-03-21T20:04:00+00:00")! - XCTAssertEqual(CBOR.encodeDate(dateOne), [0xc1, 0x1a, 0x51, 0x4b, 0x67, 0xb0]) - - let dateTwo = Date(timeIntervalSince1970: 1363896240.5) - XCTAssertEqual(CBOR.encodeDate(dateTwo), [0xc1, 0xfb, 0x41, 0xd4, 0x52, 0xd9, 0xec, 0x20, 0x00, 0x00]) - - let dateAsMap = Date(timeIntervalSince1970: 1363896240.5) - XCTAssertEqual( - CBOR.encodeDate(dateAsMap, options: CBOROptions(dateStrategy: .annotatedMap)), - [0xa2, 0x66, 0x5f, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x74, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x67, 0x5f, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0xfb, 0x41, 0xd4, 0x52, 0xd9, 0xec, 0x20, 0x00, 0x00] - ) - - let oldDateAsMap = Date(timeIntervalSince1970: -156896240.5) - XCTAssertEqual( - CBOR.encodeDate(oldDateAsMap, options: CBOROptions(dateStrategy: .annotatedMap)), - [0xa2, 0x66, 0x5f, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x74, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x67, 0x5f, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0xfb, 0xc1, 0xa2, 0xb4, 0x17, 0xe1, 0x00, 0x00, 0x00] - ) - } - - func testReadmeExamples() { - XCTAssertEqual(100.encode(), [0x18, 0x64]) - XCTAssertEqual(CBOR.encode(100), [0x18, 0x64]) - XCTAssertEqual("hello".encode(), [0x65, 0x68, 0x65, 0x6c, 0x6c, 0x6f]) - XCTAssertEqual(CBOR.encode(["a", "b", "c"]), [0x83, 0x61, 0x61, 0x61, 0x62, 0x61, 0x63]) - - struct MyStruct: CBOREncodable { - var x: Int - var y: String - - public func encode(options: CBOROptions = CBOROptions()) -> [UInt8] { - let cborWrapper: CBOR = [ - "x": CBOR(integerLiteral: self.x), - "y": .utf8String(self.y) - ] - return cborWrapper.encode(options: options) - } - - public func toCBOR(options: CBOROptions = CBOROptions()) -> CBOR { - return CBOR(dictionaryLiteral:("x", CBOR(integerLiteral: self.x)), ("y", .utf8String(self.y))) - } - } - - let encoded = MyStruct(x: 42, y: "words").encode() - XCTAssert( - encoded == [0xa2, 0x61, 0x79, 0x65, 0x77, 0x6f, 0x72, 0x64, 0x73, 0x61, 0x78, 0x18, 0x2a] - || encoded == [0xa2, 0x61, 0x78, 0x18, 0x2a, 0x61, 0x79, 0x65, 0x77, 0x6f, 0x72, 0x64, 0x73] - ) - } - - func testEncodeAny() { - struct MyCodableThing: Codable, Equatable { - var zipcode: String - var locationId: Int - - static func random() -> MyCodableThing { - let formatter = NumberFormatter() - formatter.minimumIntegerDigits = 5 - let randomInt = Int.random(in: 0..<99999) - let zip = formatter.string(from: NSNumber(integerLiteral: randomInt))! - return MyCodableThing(zipcode: zip, locationId: Int.random(in: 0..<1000)) - } - } - - let myCodableThing = MyCodableThing.random() - - let encoded = try! CBOR.encodeAny(myCodableThing) - let decoded = try! CodableCBORDecoder().decode(MyCodableThing.self, from: Data(encoded)) - XCTAssertEqual(decoded, myCodableThing) - } -} diff --git a/Old/SwiftCBORTests-old/CBORTests.swift b/Old/SwiftCBORTests-old/CBORTests.swift deleted file mode 100644 index e888f24..0000000 --- a/Old/SwiftCBORTests-old/CBORTests.swift +++ /dev/null @@ -1,61 +0,0 @@ -import XCTest -@testable import SwiftCBOR - -class CBORTests: XCTestCase { - func testSubscriptSetter() { - let dictionary: [String: Any] = [ - "foo": 1, - "bar": "a", - "zwii": "hd", - "tags": [ - "a": "1", - "b": 2 - ] - ] - - let cborEncoded: [UInt8] = try! CBOR.encodeMap(dictionary) - var cbor = try! CBOR.decode(cborEncoded)! - cbor["foo"] = "changed" - XCTAssertEqual(cbor["foo"], "changed") - } - - func testNestedSubscriptSetter() { - let dictionary: [String: Any] = [ - "foo": 1, - "bar": "a", - "zwii": "hd", - "tags": [ - "a": "1", - "b": 2 - ] - ] - - let cborEncoded: [UInt8] = try! CBOR.encodeMap(dictionary) - var cbor = try! CBOR.decode(cborEncoded)! - cbor["tags"]?[2] = "changed" - XCTAssertEqual(cbor["tags"]?[2], "changed") - } - - func testNestedSubscriptSetterWithNewMap() { - let dictionary: [String: Any] = [ - "foo": 1, - "bar": "a", - "zwii": "hd", - "tags": [ - "a": "1", - "b": 2 - ] - ] - - let cborEncoded: [UInt8] = try! CBOR.encodeMap(dictionary) - var cbor = try! CBOR.decode(cborEncoded)! - - let nestedMap: [CBOR: CBOR] = [ - "joe": "schmoe", - "age": 56 - ] - - cbor["tags"]?[2] = CBOR.map(nestedMap) - XCTAssertEqual(cbor["tags"]?[2], CBOR.map(nestedMap)) - } -} diff --git a/Old/SwiftCBORTests-old/CodableCBORDecoderTests.swift b/Old/SwiftCBORTests-old/CodableCBORDecoderTests.swift deleted file mode 100644 index 436ce6a..0000000 --- a/Old/SwiftCBORTests-old/CodableCBORDecoderTests.swift +++ /dev/null @@ -1,128 +0,0 @@ -import XCTest -@testable import SwiftCBOR - -class CodableCBORDecoderTests: XCTestCase { - func testDecodeNull() { - let decoded = try! CodableCBORDecoder().decode(Optional.self, from: Data([0xf6])) - XCTAssertNil(decoded) - } - - func testDecodeBools() { - let falseVal = try! CodableCBORDecoder().decode(Bool.self, from: Data([0xf4])) - XCTAssertEqual(falseVal, false) - let trueVal = try! CodableCBORDecoder().decode(Bool.self, from: Data([0xf5])) - XCTAssertEqual(trueVal, true) - } - - func testDecodeInts() { - // Less than 24 - let zero = try! CodableCBORDecoder().decode(Int.self, from: Data([0x00])) - XCTAssertEqual(zero, 0) - let eight = try! CodableCBORDecoder().decode(Int.self, from: Data([0x08])) - XCTAssertEqual(eight, 8) - let ten = try! CodableCBORDecoder().decode(Int.self, from: Data([0x0a])) - XCTAssertEqual(ten, 10) - let twentyThree = try! CodableCBORDecoder().decode(Int.self, from: Data([0x17])) - XCTAssertEqual(twentyThree, 23) - - // Just bigger than 23 - let twentyFour = try! CodableCBORDecoder().decode(Int.self, from: Data([0x18, 0x18])) - XCTAssertEqual(twentyFour, 24) - let twentyFive = try! CodableCBORDecoder().decode(Int.self, from: Data([0x18, 0x19])) - XCTAssertEqual(twentyFive, 25) - - // Bigger - let hundred = try! CodableCBORDecoder().decode(Int.self, from: Data([0x18, 0x64])) - XCTAssertEqual(hundred, 100) - let thousand = try! CodableCBORDecoder().decode(Int.self, from: Data([0x19, 0x03, 0xe8])) - XCTAssertEqual(thousand, 1_000) - let million = try! CodableCBORDecoder().decode(Int.self, from: Data([0x1a, 0x00, 0x0f, 0x42, 0x40])) - XCTAssertEqual(million, 1_000_000) - let trillion = try! CodableCBORDecoder().decode(Int.self, from: Data([0x1b, 0x00, 0x00, 0x00, 0xe8, 0xd4, 0xa5, 0x10, 0x00])) - XCTAssertEqual(trillion, 1_000_000_000_000) - - // TODO: Tagged byte strings for big numbers -// let bigNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])) -// XCTAssertEqual(bigNum, 18_446_744_073_709_551_615) -// let biggerNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x2c, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,])) -// XCTAssertEqual(biggerNum, 18_446_744_073_709_551_616) - } - - func testDecodeNegativeInts() { - // Less than 24 - let minusOne = try! CodableCBORDecoder().decode(Int.self, from: Data([0x20])) - XCTAssertEqual(minusOne, -1) - let minusTen = try! CodableCBORDecoder().decode(Int.self, from: Data([0x29])) - XCTAssertEqual(minusTen, -10) - - // Bigger - let minusHundred = try! CodableCBORDecoder().decode(Int.self, from: Data([0x38, 0x63])) - XCTAssertEqual(minusHundred, -100) - let minusThousand = try! CodableCBORDecoder().decode(Int.self, from: Data([0x39, 0x03, 0xe7])) - XCTAssertEqual(minusThousand, -1_000) - - // TODO: Tagged byte strings for big numbers -// let bigNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])) -// XCTAssertEqual(bigNum, 18_446_744_073_709_551_615) -// let biggerNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x2c, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,])) -// XCTAssertEqual(biggerNum, 18_446_744_073_709_551_616) - } - - func testDecodeStrings() { - let empty = try! CodableCBORDecoder().decode(String.self, from: Data([0x60])) - XCTAssertEqual(empty, "") - let a = try! CodableCBORDecoder().decode(String.self, from: Data([0x61, 0x61])) - XCTAssertEqual(a, "a") - let IETF = try! CodableCBORDecoder().decode(String.self, from: Data([0x64, 0x49, 0x45, 0x54, 0x46])) - XCTAssertEqual(IETF, "IETF") - let quoteSlash = try! CodableCBORDecoder().decode(String.self, from: Data([0x62, 0x22, 0x5c])) - XCTAssertEqual(quoteSlash, "\"\\") - let littleUWithDiaeresis = try! CodableCBORDecoder().decode(String.self, from: Data([0x62, 0xc3, 0xbc])) - XCTAssertEqual(littleUWithDiaeresis, "\u{00FC}") - - } - - func testDecodeByteStrings() { - let fourByteByteString = try! CodableCBORDecoder().decode(Data.self, from: Data([0x44, 0x01, 0x02, 0x03, 0x04])) - XCTAssertEqual(fourByteByteString, Data([0x01, 0x02, 0x03, 0x04])) - let indefiniteByteSting = try! CodableCBORDecoder().decode(Data.self, from: Data([0x5f, 0x42, 0x01, 0x02, 0x43, 0x03, 0x04, 0x05, 0xff])) - XCTAssertEqual(indefiniteByteSting, Data([0x01, 0x02, 0x03, 0x04, 0x05])) - } - - func testDecodeArrays() { - let empty = try! CodableCBORDecoder().decode([String].self, from: Data([0x80])) - XCTAssertEqual(empty, []) - let oneTwoThree = try! CodableCBORDecoder().decode([Int].self, from: Data([0x83, 0x01, 0x02, 0x03])) - XCTAssertEqual(oneTwoThree, [1, 2, 3]) - let lotsOfInts = try! CodableCBORDecoder().decode([Int].self, from: Data([0x98, 0x19, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x18, 0x18, 0x19])) - XCTAssertEqual(lotsOfInts, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]) - let nestedSimple = try! CodableCBORDecoder().decode([[Int]].self, from: Data([0x83, 0x81, 0x01, 0x82, 0x02, 0x03, 0x82, 0x04, 0x05])) - XCTAssertEqual(nestedSimple, [[1], [2, 3], [4, 5]]) - let indefiniteArray = try! CodableCBORDecoder().decode([Int].self, from: Data([0x9f, 0x04, 0x05, 0xff])) - XCTAssertEqual(indefiniteArray, [4, 5]) - let nestedIndefiniteArrays = try! CodableCBORDecoder().decode([[Int]].self, from: Data([0x9f, 0x81, 0x01, 0x82, 0x02, 0x03, 0x9f, 0x04, 0x05, 0xff, 0xff])) - XCTAssertEqual(nestedIndefiniteArrays, [[1], [2, 3], [4, 5]]) - } - - func testDecodeMaps() { - let empty = try! CodableCBORDecoder().decode([String: String].self, from: Data([0xa0])) - XCTAssertEqual(empty, [:]) - let stringToString = try! CodableCBORDecoder().decode([String: String].self, from: Data([0xa5, 0x61, 0x61, 0x61, 0x41, 0x61, 0x62, 0x61, 0x42, 0x61, 0x63, 0x61, 0x43, 0x61, 0x64, 0x61, 0x44, 0x61, 0x65, 0x61, 0x45])) - XCTAssertEqual(stringToString, ["a": "A", "b": "B", "c": "C", "d": "D", "e": "E"]) - let oneTwoThreeFour = try! CodableCBORDecoder().decode([Int: Int].self, from: Data([0xa2, 0x01, 0x02, 0x03, 0x04])) - XCTAssertEqual(oneTwoThreeFour, [1: 2, 3: 4]) - let indefiniteMap = try! CodableCBORDecoder().decode([String: String].self, from: Data([0xbf, 0x63, 0x46, 0x75, 0x6e, 0x61, 0x62, 0x63, 0x41, 0x6d, 0x74, 0x61, 0x63, 0xff])) - XCTAssertEqual(indefiniteMap, ["Fun": "b", "Amt": "c"]) - let nestedIndefiniteMap = try! CodableCBORDecoder().decode([String: [String: String]].self, from: Data([0xbf, 0x63, 0x46, 0x75, 0x6e, 0xa1, 0x61, 0x62, 0x61, 0x42, 0x63, 0x41, 0x6d, 0x74, 0xbf, 0x61, 0x63, 0x61, 0x43, 0xff, 0xff])) - XCTAssertEqual(nestedIndefiniteMap, ["Fun": ["b": "B"], "Amt": ["c": "C"]]) - } - - func testDecodeDates() { - let expectedDateOne = Date(timeIntervalSince1970: 1363896240) - let dateOne = try! CodableCBORDecoder().decode(Date.self, from: Data([0xc1, 0x1a, 0x51, 0x4b, 0x67, 0xb0])) - XCTAssertEqual(dateOne, expectedDateOne) - let expectedDateTwo = Date(timeIntervalSince1970: 1363896240.5) - let dateTwo = try! CodableCBORDecoder().decode(Date.self, from: Data([0xc1, 0xfb, 0x41, 0xd4, 0x52, 0xd9, 0xec, 0x20, 0x00, 0x00])) - XCTAssertEqual(dateTwo, expectedDateTwo) - } -} diff --git a/Old/SwiftCBORTests-old/CodableCBOREncoderTests.swift b/Old/SwiftCBORTests-old/CodableCBOREncoderTests.swift deleted file mode 100644 index eff44a1..0000000 --- a/Old/SwiftCBORTests-old/CodableCBOREncoderTests.swift +++ /dev/null @@ -1,141 +0,0 @@ -import XCTest -@testable import SwiftCBOR - -class CodableCBOREncoderTests: XCTestCase { - func testEncodeNull() { - let encoded = try! CodableCBOREncoder().encode(Optional(nil)) - XCTAssertEqual(encoded, Data([0xf6])) - } - - func testEncodeBools() { - let falseVal = try! CodableCBOREncoder().encode(false) - XCTAssertEqual(falseVal, Data([0xf4])) - let trueVal = try! CodableCBOREncoder().encode(true) - XCTAssertEqual(trueVal, Data([0xf5])) - } - - func testEncodeInts() { - // Less than 24 - let zero = try! CodableCBOREncoder().encode(0) - XCTAssertEqual(zero, Data([0x00])) - let eight = try! CodableCBOREncoder().encode(8) - XCTAssertEqual(eight, Data([0x08])) - let ten = try! CodableCBOREncoder().encode(10) - XCTAssertEqual(ten, Data([0x0a])) - let twentyThree = try! CodableCBOREncoder().encode(23) - XCTAssertEqual(twentyThree, Data([0x17])) - - // Just bigger than 23 - let twentyFour = try! CodableCBOREncoder().encode(24) - XCTAssertEqual(twentyFour, Data([0x18, 0x18])) - let twentyFive = try! CodableCBOREncoder().encode(25) - XCTAssertEqual(twentyFive, Data([0x18, 0x19])) - - // Bigger - let hundred = try! CodableCBOREncoder().encode(100) - XCTAssertEqual(hundred, Data([0x18, 0x64])) - let thousand = try! CodableCBOREncoder().encode(1_000) - XCTAssertEqual(thousand, Data([0x19, 0x03, 0xe8])) - let million = try! CodableCBOREncoder().encode(1_000_000) - XCTAssertEqual(million, Data([0x1a, 0x00, 0x0f, 0x42, 0x40])) - let trillion = try! CodableCBOREncoder().encode(1_000_000_000_000) - XCTAssertEqual(trillion, Data([0x1b, 0x00, 0x00, 0x00, 0xe8, 0xd4, 0xa5, 0x10, 0x00])) - - // TODO: Tagged byte strings for big numbers -// let bigNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])) -// XCTAssertEqual(bigNum, 18_446_744_073_709_551_615) -// let biggerNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x2c, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,])) -// XCTAssertEqual(biggerNum, 18_446_744_073_709_551_616) - } - - func testEncodeNegativeInts() { - // Less than 24 - let minusOne = try! CodableCBOREncoder().encode(-1) - XCTAssertEqual(minusOne, Data([0x20])) - let minusTen = try! CodableCBOREncoder().encode(-10) - XCTAssertEqual(minusTen, Data([0x29])) - - // Bigger - let minusHundred = try! CodableCBOREncoder().encode(-100) - XCTAssertEqual(minusHundred, Data([0x38, 0x63])) - let minusThousand = try! CodableCBOREncoder().encode(-1_000) - XCTAssertEqual(minusThousand, Data([0x39, 0x03, 0xe7])) - - // TODO: Tagged byte strings for big negative numbers -// let bigNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])) -// XCTAssertEqual(bigNum, 18_446_744_073_709_551_615) -// let biggerNum = try! CodableCBORDecoder().decode(Int.self, from: Data([0x2c, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,])) -// XCTAssertEqual(biggerNum, 18_446_744_073_709_551_616) - } - - func testEncodeStrings() { - let empty = try! CodableCBOREncoder().encode("") - XCTAssertEqual(empty, Data([0x60])) - let a = try! CodableCBOREncoder().encode("a") - XCTAssertEqual(a, Data([0x61, 0x61])) - let IETF = try! CodableCBOREncoder().encode("IETF") - XCTAssertEqual(IETF, Data([0x64, 0x49, 0x45, 0x54, 0x46])) - let quoteSlash = try! CodableCBOREncoder().encode("\"\\") - XCTAssertEqual(quoteSlash, Data([0x62, 0x22, 0x5c])) - let littleUWithDiaeresis = try! CodableCBOREncoder().encode("\u{00FC}") - XCTAssertEqual(littleUWithDiaeresis, Data([0x62, 0xc3, 0xbc])) - } - - func testEncodeByteStrings() { - let fourByteByteString = try! CodableCBOREncoder().encode(Data([0x01, 0x02, 0x03, 0x04])) - XCTAssertEqual(fourByteByteString, Data([0x44, 0x01, 0x02, 0x03, 0x04])) - } - - func testEncodeArrays() { - let empty = try! CodableCBOREncoder().encode([String]()) - XCTAssertEqual(empty, Data([0x80])) - let oneTwoThree = try! CodableCBOREncoder().encode([1, 2, 3]) - XCTAssertEqual(oneTwoThree, Data([0x83, 0x01, 0x02, 0x03])) - let lotsOfInts = try! CodableCBOREncoder().encode([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]) - XCTAssertEqual(lotsOfInts, Data([0x98, 0x19, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x18, 0x18, 0x19])) - let nestedSimple = try! CodableCBOREncoder().encode([[1], [2, 3], [4, 5]]) - XCTAssertEqual(nestedSimple, Data([0x83, 0x81, 0x01, 0x82, 0x02, 0x03, 0x82, 0x04, 0x05])) - } - - func testEncodeMaps() { - let empty = try! CodableCBOREncoder().encode([String: String]()) - XCTAssertEqual(empty, Data([0xa0])) - let stringToString = try! CodableCBOREncoder().encode(["a": "A", "b": "B", "c": "C", "d": "D", "e": "E"]) - XCTAssertEqual(stringToString.first!, 0xa5) - let dataMinusFirstByte = stringToString[1...].map { $0 }.chunked(into: 4).sorted(by: { $0.lexicographicallyPrecedes($1) }) - let dataForKeyValuePairs: [[UInt8]] = [[0x61, 0x61, 0x61, 0x41], [0x61, 0x62, 0x61, 0x42], [0x61, 0x63, 0x61, 0x43], [0x61, 0x64, 0x61, 0x44], [0x61, 0x65, 0x61, 0x45]] - XCTAssertEqual(dataMinusFirstByte, dataForKeyValuePairs) - let oneTwoThreeFour = try! CodableCBOREncoder().encode([1: 2, 3: 4]) - XCTAssert( - oneTwoThreeFour == Data([0xa2, 0x01, 0x02, 0x03, 0x04]) - || oneTwoThreeFour == Data([0xa2, 0x03, 0x04, 0x01, 0x02]) - ) - - let encoder = CodableCBOREncoder() - encoder.useStringKeys = true - let encodedWithStringKeys = try! encoder.encode([1: 2, 3: 4]) - XCTAssert(encodedWithStringKeys == Data([0xa2, 0x61, 0x31, 0x02, 0x61, 0x33, 0x04]) || encodedWithStringKeys == Data([0xa2, 0x61, 0x33, 0x04, 0x61, 0x31, 0x02])) - } - - func testEncodeSimpleStructs() { - struct MyStruct: Codable { - let age: Int - let name: String - } - - let encoded = try! CodableCBOREncoder().encode(MyStruct(age: 27, name: "Ham")).map { $0 } - - XCTAssert( - encoded == [0xa2, 0x63, 0x61, 0x67, 0x65, 0x18, 0x1b, 0x64, 0x6e, 0x61, 0x6d, 0x65, 0x63, 0x48, 0x61, 0x6d] - || encoded == [0xa2, 0x64, 0x6e, 0x61, 0x6d, 0x65, 0x63, 0x48, 0x61, 0x6d, 0x63, 0x61, 0x67, 0x65, 0x18, 0x1b] - ) - } -} - -extension Array { - func chunked(into size: Int) -> [[Element]] { - return stride(from: 0, to: count, by: size).map { - Array(self[$0 ..< Swift.min($0 + size, count)]) - } - } -} diff --git a/Old/SwiftCBORTests-old/Helpers.swift b/Old/SwiftCBORTests-old/Helpers.swift deleted file mode 100644 index a08b496..0000000 --- a/Old/SwiftCBORTests-old/Helpers.swift +++ /dev/null @@ -1,39 +0,0 @@ -import Foundation - -extension Data { - init?(hex: String) { - let len = hex.count / 2 - var data = Data(capacity: len) - for i in 0.. { - sequence(state: startIndex) { startIndex in - guard startIndex < self.endIndex else { return nil } - let endIndex = self.index(startIndex, offsetBy: 2, limitedBy: self.endIndex) ?? self.endIndex - defer { startIndex = endIndex } - return UInt8(self[startIndex..) throws -> String { - var result = "" - var decoder = UTF8() - var generator = bytes.makeIterator() - var finished = false - repeat { - let decodingResult = decoder.decode(&generator) - switch decodingResult { - case .scalarValue(let char): - result.append(String(char)) - case .emptyInput: - finished = true - case .error: - throw CBORError.incorrectUTF8String - } - } while (!finished) - return result - } - - static func djb2Hash(_ array: [Int]) -> Int { - return array.reduce(5381, { hash, elem in ((hash << 5) &+ hash) &+ Int(elem) }) - } - - // https://gist.github.com/martinkallman/5049614 - // rewritten to Swift + applied fixes from comments + added NaN/Inf checks - // should be good enough, who cares about float16 - static func readFloat16(x: UInt16) -> Float32 { - if (x & 0x7fff) > 0x7c00 { - return Float32.nan - } - if x == 0x7c00 { - return Float32.infinity - } - if x == 0xfc00 { - return -Float32.infinity - } - var t1 = UInt32(x & 0x7fff) // Non-sign bits - var t2 = UInt32(x & 0x8000) // Sign bit - let t3 = UInt32(x & 0x7c00) // Exponent - t1 <<= 13 // Align mantissa on MSB - t2 <<= 16 // Shift sign bit into position - t1 += 0x38000000 // Adjust bias - t1 = (t3 == 0 ? 0 : t1) // Denormals-as-zero - t1 |= t2 // Re-insert sign bit - return Float32(bitPattern: t1) - } -} diff --git a/Package.swift b/Package.swift index c113f26..9689b67 100644 --- a/Package.swift +++ b/Package.swift @@ -18,6 +18,10 @@ let package = Package( .product(name: "Collections", package: "swift-collections") ] ), + .executableTarget( + name: "Fuzzing", + dependencies: ["CBOR"] + ), .testTarget( name: "CBORTests", dependencies: ["CBOR"], diff --git a/Sources/CBOR/Decoder/CBORDecoder.swift b/Sources/CBOR/Decoder/CBORDecoder.swift index b5351e8..7626306 100644 --- a/Sources/CBOR/Decoder/CBORDecoder.swift +++ b/Sources/CBOR/Decoder/CBORDecoder.swift @@ -40,47 +40,63 @@ public struct CBORDecoder { let scanner = CBORScanner(data: reader, options: options) try scanner.scan() + guard !scanner.isEmpty else { + throw ScanError.unexpectedEndOfData + } + let context = DecodingContext(scanner: scanner) let region = scanner.load(at: 0) return try SingleValueCBORDecodingContainer(context: context, data: region).decode(T.self) } } catch { - if let error = error as? CBORScanner.ScanError { - switch error { - case .unexpectedEndOfData: - throw DecodingError.dataCorrupted( - .init(codingPath: [], debugDescription: "Unexpected end of data.") - ) - case let .invalidMajorType(byte, offset): - throw DecodingError.dataCorrupted(.init( - codingPath: [], - debugDescription: "Unexpected major type: \(String(byte, radix: 2)) at offset \(offset)" - )) - case let .invalidSize(byte, offset): - throw DecodingError.dataCorrupted(.init( - codingPath: [], - debugDescription: "Unexpected size argument: \(String(byte, radix: 2)) at offset \(offset)" - )) - case let .expectedMajorType(offset): - throw DecodingError.dataCorrupted(.init( - codingPath: [], - debugDescription: "Expected major type at offset \(offset)" - )) - case let .typeInIndeterminateString(type, offset): - throw DecodingError.dataCorrupted(.init( - codingPath: [], - debugDescription: "Unexpected major type in indeterminate \(type) at offset \(offset)" - )) - case let .rejectedIndeterminateLength(type, offset): - throw DecodingError.dataCorrupted(.init( - codingPath: [], - debugDescription: "Rejected indeterminate length type \(type) at offset \(offset)" - )) - } + if let error = error as? ScanError { + try throwScanError(error) } else { throw error } } } + + private func throwScanError(_ error: ScanError) throws -> Never { + switch error { + case .unexpectedEndOfData: + throw DecodingError.dataCorrupted( + .init(codingPath: [], debugDescription: "Unexpected end of data.") + ) + case let .invalidMajorType(byte, offset): + throw DecodingError.dataCorrupted(.init( + codingPath: [], + debugDescription: "Unexpected major type: \(String(byte, radix: 2)) at offset \(offset)" + )) + case let .invalidSize(byte, offset): + throw DecodingError.dataCorrupted(.init( + codingPath: [], + debugDescription: "Unexpected size argument: \(String(byte, radix: 2)) at offset \(offset)" + )) + case let .expectedMajorType(offset): + throw DecodingError.dataCorrupted(.init( + codingPath: [], + debugDescription: "Expected major type at offset \(offset)" + )) + case let .typeInIndeterminateString(type, offset): + throw DecodingError.dataCorrupted(.init( + codingPath: [], + debugDescription: "Unexpected major type in indeterminate \(type) at offset \(offset)" + )) + case let .rejectedIndeterminateLength(type, offset): + throw DecodingError.dataCorrupted(.init( + codingPath: [], + debugDescription: "Rejected indeterminate length type \(type) at offset \(offset)" + )) + case let .cannotRepresentInt(max, found, offset): + throw DecodingError.dataCorrupted( + .init( + codingPath: [], + debugDescription: "Failed to decode integer with maximum \(max), " + + "found \(found) at \(offset)" + ) + ) + } + } } diff --git a/Sources/CBOR/Decoder/Containers/DataRegion.swift b/Sources/CBOR/Decoder/Containers/DataRegion.swift index 5e97a33..e6203b4 100644 --- a/Sources/CBOR/Decoder/Containers/DataRegion.swift +++ b/Sources/CBOR/Decoder/Containers/DataRegion.swift @@ -88,34 +88,68 @@ internal extension Slice { count >= numBytes } + @inline(__always) + @inlinable + func canRead(_ numBytes: Int, from index: Index) -> Bool { + index + numBytes <= endIndex + } + @inlinable func readInt(as: T.Type, argument: UInt8) throws -> T { + try readInt(as: T.self, argument: argument, from: startIndex) + } + + @inline(__always) + @usableFromInline + func checkIntConversion(_ type: T.Type, val: F) throws { + guard val <= T.max else { + throw ScanError.cannotRepresentInt(max: UInt(T.max), found: UInt(val), offset: startIndex) + } + } + + @inlinable + func readInt(as: T.Type, argument: UInt8, from index: Index) throws -> T { let byteCount = argument - return switch byteCount { + switch byteCount { case let value where value < Constants.maxArgSize: - T(value) + let intVal = value + try checkIntConversion(T.self, val: intVal) + return T(intVal) case 24: - T(try read(as: UInt8.self)) + let intVal = try read(as: UInt8.self, from: index) + try checkIntConversion(T.self, val: intVal) + return T(intVal) case 25: - T(try read(as: UInt16.self)) + let intVal = try read(as: UInt16.self, from: index) + try checkIntConversion(T.self, val: intVal) + return T(intVal) case 26: - T(try read(as: UInt32.self)) + let intVal = try read(as: UInt32.self, from: index) + try checkIntConversion(T.self, val: intVal) + return T(intVal) case 27: - T(try read(as: UInt64.self)) + let intVal = try read(as: UInt64.self, from: index) + try checkIntConversion(T.self, val: intVal) + return T(intVal) default: - throw CBORScanner.ScanError.invalidSize(byte: byteCount, offset: startIndex) + throw ScanError.invalidSize(byte: byteCount, offset: startIndex) } } @inlinable func read(as: F.Type) throws -> F { - guard canRead(F.byteCount) else { - throw CBORScanner.ScanError.unexpectedEndOfData + try read(as: F.self, from: startIndex) + } + + @inlinable + func read(as: F.Type, from index: Index) throws -> F { + guard canRead(F.byteCount, from: index) else { + throw ScanError.unexpectedEndOfData } var val = F.zero for idx in 0..<(F.byteCount) { let shift = (F.byteCount - idx - 1) * 8 - val |= F(self[startIndex + idx]) << shift + val |= F(self[index + idx]) << shift } return F(val) } diff --git a/Sources/CBOR/Decoder/Containers/SingleValueCBORDecodingContainer.swift b/Sources/CBOR/Decoder/Containers/SingleValueCBORDecodingContainer.swift index 22392db..2b4ead3 100644 --- a/Sources/CBOR/Decoder/Containers/SingleValueCBORDecodingContainer.swift +++ b/Sources/CBOR/Decoder/Containers/SingleValueCBORDecodingContainer.swift @@ -52,6 +52,12 @@ extension SingleValueCBORDecodingContainer: SingleValueDecodingContainer { try checkType(.uint, .nint) let value = try data.readInt(as: T.self) if data.type == .nint { + guard T.min < 0 else { + throw DecodingError.typeMismatch( + Int.self, + context.error("Found a negative integer while attempting to decode an unsigned int \(T.self).") + ) + } return -1 - value } return value @@ -91,7 +97,7 @@ extension SingleValueCBORDecodingContainer: SingleValueDecodingContainer { idx += 1 guard let byteCount = argument.byteCount() else { - throw CBORScanner.ScanError.invalidSize(byte: argument, offset: data.globalIndex) + throw ScanError.invalidSize(byte: argument, offset: data.globalIndex) } let utf8Start = idx + Int(byteCount) @@ -171,7 +177,7 @@ extension SingleValueCBORDecodingContainer: SingleValueDecodingContainer { } private func _decode(_: Data.Type) throws -> Data { - try checkType(.string) + try checkType(.bytes) if data.argument == Constants.indeterminateArg { return try decodeIndeterminateData() @@ -201,7 +207,7 @@ extension SingleValueCBORDecodingContainer: SingleValueDecodingContainer { idx += 1 guard let byteCount = argument.byteCount() else { - throw CBORScanner.ScanError.invalidSize(byte: argument, offset: data.globalIndex) + throw ScanError.invalidSize(byte: argument, offset: data.globalIndex) } let substringStart = idx + Int(byteCount) diff --git a/Sources/CBOR/Decoder/Scanner/CBORScanner+DebugDescription.swift b/Sources/CBOR/Decoder/Scanner/CBORScanner+DebugDescription.swift new file mode 100644 index 0000000..ee9cdc2 --- /dev/null +++ b/Sources/CBOR/Decoder/Scanner/CBORScanner+DebugDescription.swift @@ -0,0 +1,36 @@ +// +// CBORScanner+DebugDescription.swift +// CBOR +// +// Created by Khan Winter on 8/30/25. +// + +#if DEBUG +extension CBORScanner: CustomDebugStringConvertible { + @usableFromInline var debugDescription: String { + var string = "" + func indent(_ other: String, d: Int) { string += String(repeating: " ", count: d * 2) + other + "\n" } + + func gen(_ idx: Int, depth: Int) { + let value = load(at: idx) + switch value.type { + case .map, .array: + indent( + "\(value.type), mapIdx: \(value.mapOffset), children: \(value.childCount!), bytes: \(value.count)", + d: depth + ) + var idx = firstChildIndex(idx) + for _ in 0.. Int { + let byteCount = reader.popArgument() + return switch byteCount { + case let value where value < Constants.maxArgSize: 0 + case 24: 1 + case 25: 2 + case 26: 4 + case 27: 8 + default: + throw ScanError.invalidSize(byte: byteCount, offset: reader.index - 1) + } + } + + func peekIsIndeterminate() -> Bool { + (reader.peekArgument() ?? 0) == 0b1_1111 + } +} diff --git a/Sources/CBOR/Decoder/Scanner/CBORScanner.swift b/Sources/CBOR/Decoder/Scanner/CBORScanner.swift index a3ff7ef..912db7b 100644 --- a/Sources/CBOR/Decoder/Scanner/CBORScanner.swift +++ b/Sources/CBOR/Decoder/Scanner/CBORScanner.swift @@ -7,6 +7,17 @@ import Foundation +@usableFromInline +enum ScanError: Error { + case unexpectedEndOfData + case invalidMajorType(byte: UInt8, offset: Int) + case invalidSize(byte: UInt8, offset: Int) + case expectedMajorType(offset: Int) + case typeInIndeterminateString(type: MajorType, offset: Int) + case rejectedIndeterminateLength(type: MajorType, offset: Int) + case cannotRepresentInt(max: UInt, found: UInt, offset: Int) +} + /// # Why Scan? /// I'd have loved to use a 'pop' method for decoding, where we only decode as data is requested. However, the way /// Swift's decoding APIs work forces us to be able to be able to do random access for keys in maps, which requires @@ -21,16 +32,6 @@ import Foundation /// take either indeterminate or specific lengths and decode them. @usableFromInline final class CBORScanner { - @usableFromInline - enum ScanError: Error { - case unexpectedEndOfData - case invalidMajorType(byte: UInt8, offset: Int) - case invalidSize(byte: UInt8, offset: Int) - case expectedMajorType(offset: Int) - case typeInIndeterminateString(type: MajorType, offset: Int) - case rejectedIndeterminateLength(type: MajorType, offset: Int) - } - // MARK: - Results /// After the scanner scans, this contains a map that allows the CBOR data to be scanned for values at arbitrary @@ -96,6 +97,10 @@ final class CBORScanner { var results: Results let options: DecodingOptions + var isEmpty: Bool { + results.map.isEmpty + } + init(data: DataReader, options: DecodingOptions = DecodingOptions()) { self.reader = data self.results = Results(dataCount: data.count) @@ -199,9 +204,9 @@ final class CBORScanner { case .map: try scanMap() case .simple: - scanSimple(raw: raw) + try scanSimple(raw: raw) case .tagged: - fatalError() + throw ScanError.expectedMajorType(offset: 0) } } @@ -217,9 +222,12 @@ final class CBORScanner { // MARK: - Scan Simple - private func scanSimple(raw: UInt8) { + private func scanSimple(raw: UInt8) throws { let idx = reader.index results.recordSimple(reader.pop(), currentByteIndex: idx) + guard reader.canRead(simpleLength(raw)) else { + throw ScanError.unexpectedEndOfData + } reader.pop(simpleLength(raw)) } @@ -308,7 +316,12 @@ final class CBORScanner { private func scanMap() throws { guard peekIsIndeterminate() else { - let size = try reader.readNextInt(as: Int.self) * 2 + let keyCount = try reader.readNextInt(as: Int.self) + guard keyCount < Int.max / 2 else { + throw ScanError.cannotRepresentInt(max: UInt(Int.max), found: UInt(keyCount) * 2, offset: reader.index) + } + + let size = keyCount * 2 let mapIdx = results.recordMapStart(currentByteIndex: reader.index) for _ in 0.. Int { - let byteCount = reader.popArgument() - return switch byteCount { - case let value where value < Constants.maxArgSize: 0 - case 24: 1 - case 25: 2 - case 26: 4 - case 27: 8 - default: - throw ScanError.invalidSize(byte: byteCount, offset: reader.index - 1) - } - } - - func peekIsIndeterminate() -> Bool { - (reader.peekArgument() ?? 0) == 0b1_1111 - } -} - -// MARK: - Debug Description - -#if DEBUG -extension CBORScanner: CustomDebugStringConvertible { - @usableFromInline var debugDescription: String { - var string = "" - func indent(_ other: String, d: Int) { string += String(repeating: " ", count: d * 2) + other + "\n" } - - func gen(_ idx: Int, depth: Int) { - let value = load(at: idx) - switch value.type { - case .map, .array: - indent( - "\(value.type), mapIdx: \(value.mapOffset), children: \(value.childCount!), bytes: \(value.count)", - d: depth - ) - var idx = firstChildIndex(idx) - for _ in 0..(as: F.Type) throws -> F { - guard canRead(F.byteCount) else { - throw CBORScanner.ScanError.unexpectedEndOfData - } - var val = F.zero - for idx in 0..<(F.byteCount) { - let shift = (F.byteCount - idx - 1) * 8 - val |= F(pop()) << shift - } - return F(val) - } - /// Reads the next variable-sized integer off the data stack. @inlinable mutating func readNextInt(as: T.Type) throws -> T { - let byteCount = popArgument() - return switch byteCount { - case let value where value < Constants.maxArgSize: - T(value) - case 24: - T(try readInt(as: UInt8.self)) - case 25: - T(try readInt(as: UInt16.self)) - case 26: - T(try readInt(as: UInt32.self)) - case 27: - T(try readInt(as: UInt64.self)) - default: - throw CBORScanner.ScanError.invalidSize(byte: byteCount, offset: index - 1) + let arg = popArgument() + let value = try data.readInt(as: T.self, argument: arg, from: data.startIndex + index) + if let byteCount = arg.byteCount(), byteCount > 0 { + pop(Int(byteCount)) } + return value } @inlinable diff --git a/Sources/Fuzzing/AnyDecodable.swift b/Sources/Fuzzing/AnyDecodable.swift new file mode 100644 index 0000000..0c9c2dc --- /dev/null +++ b/Sources/Fuzzing/AnyDecodable.swift @@ -0,0 +1,198 @@ +// From https://github.com/Flight-School/AnyCodable/blob/master/Sources/AnyCodable/AnyDecodable.swift + +// swiftlint:disable cyclomatic_complexity +// swiftlint:disable line_length +// swiftlint:disable type_name + +#if canImport(Foundation) +import Foundation +#endif + +/** + A type-erased `Decodable` value. + + The `AnyDecodable` type forwards decoding responsibilities + to an underlying value, hiding its specific underlying type. + + You can decode mixed-type values in dictionaries + and other collections that require `Decodable` conformance + by declaring their contained type to be `AnyDecodable`: + + let json = """ + { + "boolean": true, + "integer": 42, + "double": 3.141592653589793, + "string": "string", + "array": [1, 2, 3], + "nested": { + "a": "alpha", + "b": "bravo", + "c": "charlie" + }, + "null": null + } + """.data(using: .utf8)! + + let decoder = JSONDecoder() + let dictionary = try! decoder.decode([String: AnyDecodable].self, from: json) + */ +struct AnyDecodable: Decodable { + let value: Any + + init(_ value: T?) { + self.value = value ?? () + } +} + +@usableFromInline +protocol _AnyDecodable { + var value: Any { get } + init(_ value: T?) +} + +extension AnyDecodable: _AnyDecodable {} + +extension _AnyDecodable { + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + + if container.decodeNil() { + #if canImport(Foundation) + self.init(NSNull()) + #else + self.init(Optional.none) + #endif + } else if let bool = try? container.decode(Bool.self) { + self.init(bool) + } else if let int = try? container.decode(Int.self) { + self.init(int) + } else if let uint = try? container.decode(UInt.self) { + self.init(uint) + } else if let double = try? container.decode(Double.self) { + self.init(double) + } else if let string = try? container.decode(String.self) { + self.init(string) + } else if let array = try? container.decode([AnyDecodable].self) { + self.init(array.map { $0.value }) + } else if let dictionary = try? container.decode([String: AnyDecodable].self) { + self.init(dictionary.mapValues { $0.value }) + } else { + throw DecodingError.dataCorruptedError(in: container, debugDescription: "AnyDecodable value cannot be decoded") + } + } +} + +extension AnyDecodable: Equatable { + static func == (lhs: AnyDecodable, rhs: AnyDecodable) -> Bool { + switch (lhs.value, rhs.value) { +#if canImport(Foundation) + case is (NSNull, NSNull), is (Void, Void): + return true +#endif + case let (lhs as Bool, rhs as Bool): + return lhs == rhs + case let (lhs as Int, rhs as Int): + return lhs == rhs + case let (lhs as Int8, rhs as Int8): + return lhs == rhs + case let (lhs as Int16, rhs as Int16): + return lhs == rhs + case let (lhs as Int32, rhs as Int32): + return lhs == rhs + case let (lhs as Int64, rhs as Int64): + return lhs == rhs + case let (lhs as UInt, rhs as UInt): + return lhs == rhs + case let (lhs as UInt8, rhs as UInt8): + return lhs == rhs + case let (lhs as UInt16, rhs as UInt16): + return lhs == rhs + case let (lhs as UInt32, rhs as UInt32): + return lhs == rhs + case let (lhs as UInt64, rhs as UInt64): + return lhs == rhs + case let (lhs as Float, rhs as Float): + return lhs == rhs + case let (lhs as Double, rhs as Double): + return lhs == rhs + case let (lhs as String, rhs as String): + return lhs == rhs + case let (lhs as [String: AnyDecodable], rhs as [String: AnyDecodable]): + return lhs == rhs + case let (lhs as [AnyDecodable], rhs as [AnyDecodable]): + return lhs == rhs + default: + return false + } + } +} + +extension AnyDecodable: CustomStringConvertible { + var description: String { + switch value { + case is Void: + return String(describing: nil as Any?) + case let value as CustomStringConvertible: + return value.description + default: + return String(describing: value) + } + } +} + +extension AnyDecodable: CustomDebugStringConvertible { + var debugDescription: String { + switch value { + case let value as CustomDebugStringConvertible: + return "AnyDecodable(\(value.debugDescription))" + default: + return "AnyDecodable(\(description))" + } + } +} + +extension AnyDecodable: Hashable { + func hash(into hasher: inout Hasher) { + switch value { + case let value as Bool: + hasher.combine(value) + case let value as Int: + hasher.combine(value) + case let value as Int8: + hasher.combine(value) + case let value as Int16: + hasher.combine(value) + case let value as Int32: + hasher.combine(value) + case let value as Int64: + hasher.combine(value) + case let value as UInt: + hasher.combine(value) + case let value as UInt8: + hasher.combine(value) + case let value as UInt16: + hasher.combine(value) + case let value as UInt32: + hasher.combine(value) + case let value as UInt64: + hasher.combine(value) + case let value as Float: + hasher.combine(value) + case let value as Double: + hasher.combine(value) + case let value as String: + hasher.combine(value) + case let value as [String: AnyDecodable]: + hasher.combine(value) + case let value as [AnyDecodable]: + hasher.combine(value) + default: + break + } + } +} + +// swiftlint:enable cyclomatic_complexity +// swiftlint:enable line_length +// swiftlint:enable type_name diff --git a/Sources/Fuzzing/main.swift b/Sources/Fuzzing/main.swift new file mode 100644 index 0000000..60c2f68 --- /dev/null +++ b/Sources/Fuzzing/main.swift @@ -0,0 +1,67 @@ +// +// fuzz.swift +// CBOR +// +// Created by Khan Winter on 8/29/25. +// + +import CBOR +import Foundation + +@_optimize(none) +func blackhole(_ val: some Any) { } + +/// Fuzzing entry point +@_cdecl("LLVMFuzzerTestOneInput") +public func fuzz(_ start: UnsafeRawPointer, _ count: Int) -> CInt { + let bytes = UnsafeRawBufferPointer(start: start, count: count) + let data = Data(bytes) + + // Try decoding against a bunch of standard types. + // Each attempt is independent — errors are ignored, crashes are what fuzzing is for. + func tryDecode(_ type: T.Type) { + do { + blackhole(try CBORDecoder(rejectIndeterminateLengths: false).decode(T.self, from: data)) + } catch { + // ignore decode errors + } + } + + // Scalars + tryDecode(Bool.self) + tryDecode(Int.self) + tryDecode(Int8.self) + tryDecode(Int16.self) + tryDecode(Int32.self) + tryDecode(Int64.self) + tryDecode(UInt.self) + tryDecode(UInt8.self) + tryDecode(UInt16.self) + tryDecode(UInt32.self) + tryDecode(UInt64.self) + tryDecode(Float.self) + tryDecode(Double.self) + tryDecode(String.self) + tryDecode(Data.self) + + // Optionals + tryDecode(Optional.self) + tryDecode(Optional.self) + tryDecode(Optional.self) + + // Collections + tryDecode([Int].self) + tryDecode([String].self) + tryDecode([Data].self) + tryDecode([String: Int].self) + tryDecode([String: String].self) + + // Nested combinations + tryDecode([[Int]].self) + tryDecode([String: [String: Int]].self) + + // Any decodable + tryDecode(AnyDecodable.self) + + return 0 +} diff --git a/Tests/CBORTests/DecodableTests.swift b/Tests/CBORTests/DecodableTests.swift index 335d731..cea8ce5 100644 --- a/Tests/CBORTests/DecodableTests.swift +++ b/Tests/CBORTests/DecodableTests.swift @@ -16,21 +16,26 @@ import Foundation struct DecodableTests { @Test func uint8() throws { - var value = try CBORDecoder().decode(UInt8.self, from: [0]) - #expect(value == 0) - value = try CBORDecoder().decode(UInt8.self, from: [1]) - #expect(value == 1) - // Just below max arg size - value = try CBORDecoder().decode(UInt8.self, from: [23]) - #expect(value == 23) + var value: UInt8 = 0 // try CBORDecoder().decode(UInt8.self, from: [0]) +// #expect(value == 0) +// value = try CBORDecoder().decode(UInt8.self, from: [1]) +// #expect(value == 1) +// // Just below max arg size +// value = try CBORDecoder().decode(UInt8.self, from: [23]) +// #expect(value == 23) // Just above max arg size value = try CBORDecoder().decode(UInt8.self, from: [24, 24]) #expect(value == 24) // Max Int - value = try CBORDecoder().decode(UInt8.self, from: [24, UInt8.max]) - #expect(value == UInt8.max) +// value = try CBORDecoder().decode(UInt8.self, from: [24, UInt8.max]) +// #expect(value == UInt8.max) +// +// #expect(throws: DecodingError.self) { try CBORDecoder().decode(UInt8.self, from: [128]) } + } - #expect(throws: DecodingError.self) { try CBORDecoder().decode(UInt8.self, from: [128]) } + @Test + func int8() throws { + #expect(throws: DecodingError.self) { try CBORDecoder().decode(Int8.self, from: [24, 255]) } } @Test @@ -182,7 +187,7 @@ struct DecodableTests { ]) func indeterminateString(data: String, expected: String) throws { let data = data.asHexData() - let string = try CBORDecoder(options: DecodingOptions(rejectIndeterminateLengthStrings: false)) + let string = try CBORDecoder(rejectIndeterminateLengths: false) .decode(String.self, from: data) #expect(string == expected) } @@ -207,7 +212,7 @@ struct DecodableTests { try data.withUnsafeBytes { let data = $0[...] let reader = DataReader(data: data) - let scanner = CBORScanner(data: reader, options: DecodingOptions(rejectIndeterminateLengthArrays: false)) + let scanner = CBORScanner(data: reader, options: DecodingOptions(rejectIndeterminateLengths: false)) try scanner.scan() let context = DecodingContext(scanner: scanner) @@ -239,30 +244,26 @@ struct DecodableTests { @Test func indeterminateArray() throws { -// let array = "9F0203FF".asHexData() - let options = DecodingOptions(rejectIndeterminateLengthArrays: false) -// #expect(try CBORDecoder(options: options).decode([Int].self, from: array) == [2, 3]) + let array = "9F0203FF".asHexData() + #expect(try CBORDecoder(rejectIndeterminateLengths: false).decode([Int].self, from: array) == [2, 3]) let twodArray = "9F9F0203FF9F0405FFFF".asHexData() - try twodArray.withUnsafeBytes { - let data = $0[...] - let reader = DataReader(data: data) - let scanner = CBORScanner(data: reader, options: DecodingOptions(rejectIndeterminateLengthArrays: false)) - try scanner.scan() - print(scanner.debugDescription) - dump(scanner.results.map) - } - let result = try CBORDecoder(options: options).decode([[Int]].self, from: twodArray) + let result = try CBORDecoder(rejectIndeterminateLengths: false).decode([[Int]].self, from: twodArray) #expect(result == [[2, 3], [4, 5]]) } @Test func rejectsIndeterminateArrayWhenConfigured() throws { let array = "9FFF".asHexData() - let options = DecodingOptions(rejectIndeterminateLengthArrays: true) #expect(throws: DecodingError.self) { - try CBORDecoder(options: options).decode([Int].self, from: array) + try CBORDecoder(rejectIndeterminateLengths: true).decode([Int].self, from: array) } } + + @Test + func emptyData() throws { + let data = Data() + #expect(throws: DecodingError.self) { try CBORDecoder().decode(Data.self, from: data) } + } } diff --git a/Tests/CBORTests/RoundTripTests.swift b/Tests/CBORTests/RoundTripTests.swift index 64a1903..5898929 100644 --- a/Tests/CBORTests/RoundTripTests.swift +++ b/Tests/CBORTests/RoundTripTests.swift @@ -53,4 +53,64 @@ struct RoundTripTests { #expect(value == result) } } + + @Test + func data() throws { + let value = Data([0xde, 0xad, 0xbe, 0xef]) + let encoded = try CBOREncoder().encode(value) + let decoded = try CBORDecoder().decode(Data.self, from: encoded) + #expect(value == decoded) + } + + @Test + func emptyData() throws { + let value = Data() + let encoded = try CBOREncoder().encode(value) + let decoded = try CBORDecoder().decode(Data.self, from: encoded) + #expect(value == decoded) + } + + @Test + func string() throws { + let value = "Hello, CBOR 👋" + let encoded = try CBOREncoder().encode(value) + let decoded = try CBORDecoder().decode(String.self, from: encoded) + #expect(value == decoded) + } + + @Test + func emptyString() throws { + let value = "" + let encoded = try CBOREncoder().encode(value) + let decoded = try CBORDecoder().decode(String.self, from: encoded) + #expect(value == decoded) + } + + @Test + func person() throws { + let value = Person.mock + let encoded = try CBOREncoder().encode(value) + let decoded = try CBORDecoder().decode(Person.self, from: encoded) + #expect(value.name == decoded.name) + #expect(value.age == decoded.age) + #expect(value.email == decoded.email) + #expect(value.isActive == decoded.isActive) + #expect(value.tags == decoded.tags) + } + + @Test + func company() throws { + let value = Company.mock + let encoded = try CBOREncoder().encode(value) + let decoded = try CBORDecoder().decode(Company.self, from: encoded) + #expect(value.name == decoded.name) + #expect(value.founded == decoded.founded) + #expect(value.employees.count == decoded.employees.count) + #expect(value.metadata == decoded.metadata) + + // sanity check one employee too + if let first = decoded.employees.first { + #expect(first.name == Person.mock.name) + } + } } diff --git a/Tests/CBORTests/ScannerTests.swift b/Tests/CBORTests/ScannerTests.swift index d9fa087..824683a 100644 --- a/Tests/CBORTests/ScannerTests.swift +++ b/Tests/CBORTests/ScannerTests.swift @@ -34,7 +34,7 @@ struct ScannerTests { let data = Array(repeating: UInt8.zero, count: count) Data([argument] + data).withUnsafeBytes { let data = $0[...] - #expect(throws: CBORScanner.ScanError.self) { + #expect(throws: ScanError.self) { try CBORScanner(data: DataReader(data: data)).scan() } } @@ -59,7 +59,7 @@ struct ScannerTests { let data = Data([MajorType.nint.bits | argument] + Array(repeating: UInt8.zero, count: count)) data.withUnsafeBytes { let data = $0[...] - #expect(throws: CBORScanner.ScanError.self) { + #expect(throws: ScanError.self) { try CBORScanner(data: DataReader(data: data)).scan() } } @@ -77,7 +77,7 @@ struct ScannerTests { let data = data.asHexData() try data.withUnsafeBytes { let data = $0[...] - let options = DecodingOptions(rejectIndeterminateLengthMaps: false) + let options = DecodingOptions(rejectIndeterminateLengths: false) let scanner = CBORScanner(data: DataReader(data: data), options: options) try scanner.scan() let map = scanner.results.map @@ -114,7 +114,7 @@ struct ScannerTests { let data = "9F9F0203FF9F0405FFFF".asHexData() try data.withUnsafeBytes { let data = $0[...] - let options = DecodingOptions(rejectIndeterminateLengthArrays: false) + let options = DecodingOptions(rejectIndeterminateLengths: false) let scanner = CBORScanner(data: DataReader(data: data), options: options) try scanner.scan() let map = scanner.results.map