428fd03 · typeable/aeson

git.iko.soy/typeable/aeson

test PMJSON 1.1 and 1.2

commit428fd03924bbd7791ee27de7f1b76b9c7e2511a3 authorNicolas Seriot <nicolas@seriot.ch> dateThu 27 Oct 2016, 13:21 (10 years ago) parent954c2cc

22 files changed+9562−392

compare with master

unifiedsplit

parsers/test_PMJSON_1_1_0/bin/test_PMJSON

Binary file not shown.

parsers/test_PMJSON_1_1_0/test_PMJSON.xcodeproj/project.xcworkspace/xcuserdata/nst.xcuserdatad/UserInterfaceState.xcuserstate

Binary file not shown.

parsers/test_PMJSON_1_2_0/Accessors.swiftnew file+255

@@ -0,0 +1,255 @@

1+//

2+// Accessors.swift

3+// PMJSON

4+//

5+// Created by Kevin Ballard on 10/9/15.

7+//

8+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

9+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

10+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

11+// option. This file may not be copied, modified, or distributed

12+// except according to those terms.

13+//

14+

15+public extension JSON {

16+ /// Returns `true` iff the receiver is `.null`.

17+ var isNull: Bool {

18+ switch self {

19+ case .null: return true

20+ default: return false

21+ }

22+ }

23+

24+ /// Returns `true` iff the receiver is `.bool`.

25+ var isBool: Bool {

26+ switch self {

27+ case .bool: return true

28+ default: return false

29+ }

30+ }

31+

32+ /// Returns `true` iff the receiver is `.string`.

33+ var isString: Bool {

34+ switch self {

35+ case .string: return true

36+ default: return false

37+ }

38+ }

39+

40+ /// Returns `true` iff the receiver is `.int64`.

41+ var isInt64: Bool {

42+ switch self {

43+ case .int64: return true

44+ default: return false

45+ }

46+ }

47+

48+ /// Returns `true` iff the receiver is `.double`.

49+ var isDouble: Bool {

50+ switch self {

51+ case .double: return true

52+ default: return false

53+ }

54+ }

55+

56+ /// Returns `true` iff the receiver is `.int64` or `.double`.

57+ var isNumber: Bool {

58+ switch self {

59+ case .int64, .double: return true

60+ default: return false

61+ }

62+ }

63+

64+ /// Returns `true` iff the receiver is `.object`.

65+ var isObject: Bool {

66+ switch self {

67+ case .object: return true

68+ default: return false

69+ }

70+ }

71+

72+ /// Returns `true` iff the receiver is `.array`.

73+ var isArray: Bool {

74+ switch self {

75+ case .array: return true

76+ default: return false

77+ }

78+ }

79+}

80+

81+public extension JSON {

82+ /// Returns the boolean value if the receiver is `.bool`, otherwise `nil`.

83+ ///

84+ /// When setting, replaces the receiver with the given boolean value, or with

85+ /// null if the value is `nil`.

86+ var bool: Bool? {

87+ get {

88+ switch self {

89+ case .bool(let b): return b

90+ default: return nil

91+ }

92+ }

93+ set {

94+ self = newValue.map(JSON.bool) ?? nil

95+ }

96+ }

97+

98+ /// Returns the string value if the receiver is `.string`, otherwise `nil`.

99+ ///

100+ /// When setting, replaces the receiver with the given string value, or with

101+ /// null if the value is `nil`.

102+ var string: String? {

103+ get {

104+ switch self {

105+ case .string(let s): return s

106+ default: return nil

107+ }

108+ }

109+ set {

110+ self = newValue.map(JSON.string) ?? nil

111+ }

112+ }

113+

114+ /// Returns the 64-bit integral value if the receiver is `.int64` or `.double`, otherwise `nil`.

115+ /// If the receiver is `.double`, the value is truncated. If it does not fit in 64 bits, `nil` is returned.

116+ ///

117+ /// When setting, replaces the receiver with the given integral value, or with

118+ /// null if the value is `nil`.

119+ var int64: Int64? {

120+ get {

121+ switch self {

122+ case .int64(let i): return i

123+ case .double(let d): return convertDoubleToInt64(d)

124+ default: return nil

125+ }

126+ } set {

127+ self = newValue.map(JSON.int64) ?? nil

128+ }

129+ }

130+

131+ /// Returns the integral value if the receiver is `.int64` or `.double`, otherwise `nil`.

132+ /// If the receiver is `.double`, the value is truncated. If it does not fit in an `Int`, `nil` is returned.

133+ /// If the receiver is `.int64` and the value does not fit in an `Int`, `nil` is returned.

134+ ///

135+ /// When setting, replaces the receiver with the given integral value, or with

136+ /// null if the value is `nil`.

137+ var int: Int? {

138+ get {

139+ guard let value = self.int64 else { return nil}

140+ let truncated = Int(truncatingBitPattern: value)

141+ guard Int64(truncated) == value else { return nil }

142+ return truncated

143+ }

144+ set {

145+ self = newValue.map({ JSON.int64(Int64($0)) }) ?? nil

146+ }

147+ }

148+

149+ /// Returns the numeric value as a `Double` if the receiver is `.int64` or `.double`, otherwise `nil`.

150+ ///

151+ /// When setting, replaces the receiver with the given double value, or with

152+ /// null if the value is `nil`.

153+ var double: Double? {

154+ get {

155+ switch self {

156+ case .int64(let i): return Double(i)

157+ case .double(let d): return d

158+ default: return nil

159+ }

160+ }

161+ set {

162+ self = newValue.map(JSON.double) ?? nil

163+ }

164+ }

165+

166+ /// Returns the object dictionary if the receiver is `.object`, otherwise `nil`.

167+ ///

168+ /// When setting, replaces the receiver with the given object value, or with

169+ /// null if the value is `nil`.

170+ var object: JSONObject? {

171+ get {

172+ switch self {

173+ case .object(let obj): return obj

174+ default: return nil

175+ }

176+ }

177+ set {

178+ self = newValue.map(JSON.object) ?? nil

179+ }

180+ }

181+

182+ /// Returns the array if the receiver is `.array`, otherwise `nil`.

183+ ///

184+ /// When setting, replaces the receiver with the given array value, or with

185+ /// null if the value is `nil`.

186+ var array: JSONArray? {

187+ get {

188+ switch self {

189+ case .array(let ary): return ary

190+ default: return nil

191+ }

192+ }

193+ set {

194+ self = newValue.map(JSON.array) ?? nil

195+ }

196+ }

197+}

198+

199+public extension JSON {

200+ /// Returns the string value if the receiver is `.string`, coerces the value to a string if

201+ /// the receiver is `.bool`, `.null`, `.int64`, or `.double`, or otherwise returns `nil`.

202+ var asString: String? {

203+ return try? toString()

204+ }

205+

206+ /// Returns the 64-bit integral value if the receiver is `.int64` or `.double`, coerces the value

207+ /// if the receiver is `.string`, otherwise returns `nil`.

208+ /// If the receiver is `.double`, the value is truncated. If it does not fit in 64 bits, `nil` is returned.

209+ /// If the receiver is `.string`, it must parse fully as an integral or floating-point number.

210+ /// If it parses as a floating-point number, it is truncated. If it does not fit in 64 bits, `nil` is returned.

211+ var asInt64: Int64? {

212+ return try? toInt64()

213+ }

214+

215+ /// Returns the integral value if the receiver is `.int64` or `.double`, coerces the value

216+ /// if the receiver is `.string`, otherwise returns `nil`.

217+ /// If the receiver is `.double`, the value is truncated. If it does not fit in an `Int`, `nil` is returned.

218+ /// If the receiver is `.string`, it must parse fully as an integral or floating-point number.

219+ /// If it parses as a floating-point number, it is truncated. If it does not fit in an `Int`, `nil` is returned.

220+ var asInt: Int? {

221+ return try? toInt()

222+ }

223+

224+ /// Returns the double value if the receiver is `.int64` or `.double`, coerces the value

225+ /// if the receiver is `.string`, otherwise returns `nil`.

226+ /// If the receiver is `.string`, it must parse fully as a floating-point number.

227+ var asDouble: Double? {

228+ return try? toDouble()

229+ }

230+}

231+

232+public extension JSON {

233+ /// If the receiver is `.object`, returns the result of subscripting the object.

234+ /// Otherwise, returns `nil`.

235+ subscript(key: String) -> JSON? {

236+ return self.object?[key]

237+ }

238+

239+ /// If the receiver is `.array` and the index is in range of the array, returns the result of subscripting the array.

240+ /// Otherwise returns `nil`.

241+ subscript(index: Int) -> JSON? {

242+ guard let ary = self.array else { return nil }

243+ guard index >= ary.startIndex && index < ary.endIndex else { return nil }

244+ return ary[index]

245+ }

246+}

247+

248+internal func convertDoubleToInt64(_ d: Double) -> Int64? {

249+ // Int64(Double(Int64.max)) asserts because it interprets it as out of bounds.

250+ // Int64(Double(Int64.min)) works just fine.

251+ if d >= Double(Int64.max) || d < Double(Int64.min) {

252+ return nil

253+ }

254+ return Int64(d)

255+}

parsers/test_PMJSON_1_2_0/DecimalNumber.swiftnew file+236

@@ -0,0 +1,236 @@

1+//

2+// DecimalNumber.swift

3+// PMJSON

4+//

5+// Created by Kevin Ballard on 2/8/16.

7+//

8+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

9+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

10+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

11+// option. This file may not be copied, modified, or distributed

12+// except according to those terms.

13+//

14+

15+#if os(iOS) || os(OSX) || os(tvOS) || os(watchOS)

16+

17+ import Foundation

18+

19+ // MARK: Basic accessors

20+

21+ public extension JSON {

22+ /// Returns the receiver as an `NSDecimalNumber` if possible.

23+ /// - Returns: An `NSDecimalNumber` if the receiver is `.int64` or `.double`, or is a `.string`

24+ /// that contains a valid decimal number representation, otherwise `nil`.

25+ /// - Note: Whitespace is not allowed in the string representation.

26+ var asDecimalNumber: NSDecimalNumber? {

27+ switch self {

28+ case .int64(let i): return NSDecimalNumber(value: i)

29+ case .double(let d): return NSDecimalNumber(value: d)

30+ case .string(let s) where !s.isEmpty:

31+ // NSDecimalNumber(string:) doesn't tell us if the number was valid.

32+ // We could check for NaN, but that still doesn't tell us if there's anything left in the string.

33+ // I'm pretty sure it uses NSScanner.scanDecimal() internally, so we'll just use that instead.

34+ let scanner = Scanner(string: s)

35+ scanner.charactersToBeSkipped = nil

36+ var decimal = Decimal()

37+ if scanner.scanDecimal(&decimal) && scanner.isAtEnd {

38+ return NSDecimalNumber(decimal: decimal)

39+ }

40+ return nil

41+ default: return nil

42+ }

43+ }

44+

45+ /// Returns the receiver as an `NSDecimalNumber` if it is `.int64` or `.double`.

46+ /// - Returns: An `NSDecimalNumber`.

47+ /// - Throws: `JSONError` if the receiver is not an `.int64` or a `.double`.

48+ func getDecimalNumber() throws -> NSDecimalNumber {

49+ switch self {

50+ case .int64(let i): return NSDecimalNumber(value: i)

51+ case .double(let d): return NSDecimalNumber(value: d)

52+ default: throw JSONError.missingOrInvalidType(path: nil, expected: .required(.number), actual: .forValue(self))

53+ }

54+ }

55+

56+ /// Returns the receiver as an `NSDecimalNumber` if it is `.int64` or `.double`.

57+ /// - Returns: An `NSDecimalNumber`, or `nil` if the receivre is `null`.

58+ /// - Throws: `JSONError` if the receiver is not an `.int64` or a `.double`.

59+ func getDecimalNumberOrNil() throws -> NSDecimalNumber? {

60+ switch self {

61+ case .int64(let i): return NSDecimalNumber(value: i)

62+ case .double(let d): return NSDecimalNumber(value: d)

63+ case .null: return nil

64+ default: throw JSONError.missingOrInvalidType(path: nil, expected: .required(.number), actual: .forValue(self))

65+ }

66+ }

67+

68+ /// Returns the receiver as an `NSDecimalNumber` if possible.

69+ /// - Returns: An `NSDecimalNumber` if the receiver is `.int64` or `.double`, or is a `.string`

70+ /// that contains a valid decimal number representation.

71+ /// - Throws: `JSONError` if the receiver is the wrong type, or is a `.string` that does not contain

72+ /// a valid decimal number representation.

73+ /// - Note: Whitespace is not allowed in the string representation.

74+ func toDecimalNumber() throws -> NSDecimalNumber {

75+ guard let value = asDecimalNumber else {

76+ throw JSONError.missingOrInvalidType(path: nil, expected: .required(.number), actual: .forValue(self))

77+ }

78+ return value

79+ }

80+

81+ /// Returns the receiver as an `NSDecimalNumber` if possible.

82+ /// - Returns: An `NSDecimalNumber` if the receiver is `.int64` or `.double`, or is a `.string`

83+ /// that contains a valid decimal number representation, or `nil` if the receiver is `null`.

84+ /// - Throws: `JSONError` if the receiver is the wrong type, or is a `.string` that does not contain

85+ /// a valid decimal number representation.

86+ /// - Note: Whitespace is not allowed in the string representation.

87+ func toDecimalNumberOrNil() throws -> NSDecimalNumber? {

88+ if let value = asDecimalNumber { return value }

89+ else if isNull { return nil }

90+ else { throw JSONError.missingOrInvalidType(path: nil, expected: .optional(.number), actual: .forValue(self)) }

91+ }

92+ }

93+

94+ // MARK: - Keyed accessors

95+

96+ public extension JSON {

97+ /// Subscripts the receiver with `key` and returns the result as an `NSDecimalNumber`.

98+ /// - Parameter key: The key that's used to subscript the receiver.

99+ /// - Returns: An `NSDecimalNumber`.

100+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

101+ /// the receiver is not an object.

102+ func getDecimalNumber(_ key: String) throws -> NSDecimalNumber {

103+ let dict = try getObject()

104+ let value = try getRequired(dict, key: key, type: .number)

105+ return try scoped(key) { try value.getDecimalNumber() }

106+ }

107+

108+ /// Subscripts the receiver with `key` and returns the result as an `NSDecimalNumber`.

109+ /// - Parameter key: The key that's used to subscript the receiver.

110+ /// - Returns: An `NSDecimalNumber`, or `nil` if the key doesn't exist or the value is `null`.

111+ /// - Throws: `JSONError` if the value is the wrong type, or if the receiver is

112+ /// not an object.

113+ func getDecimalNumberOrNil(_ key: String) throws -> NSDecimalNumber? {

114+ let dict = try getObject()

115+ guard let value = dict[key] else { return nil }

116+ return try scoped(key) { try value.getDecimalNumberOrNil() }

117+ }

118+

119+ /// Subscripts the receiver with `key` and returns the result as an `NSDecimalNumber`.

120+ /// - Parameter key: The key that's used to subscript the receiver.

121+ /// - Returns: An `NSDecimalNumber`.

122+ /// - Throws: `JSONError` if the key doesn't exist or the value is `null`, a boolean, an object,

123+ /// an array, or a string that cannot be coerced to a decimal number, or if the

124+ /// receiver is not an object.

125+ func toDecimalNumber(_ key: String) throws -> NSDecimalNumber {

126+ let dict = try getObject()

127+ let value = try getRequired(dict, key: key, type: .number)

128+ return try scoped(key) { try value.toDecimalNumber() }

129+ }

130+

131+ /// Subscripts the receiver with `key` and returns the result as an `NSDecimalNumber`.

132+ /// - Parameter key: The key that's used to subscript the receiver.

133+ /// - Returns: An `NSDecimalNumber`, or `nil` if the key doesn't exist or the value is `null`.

134+ /// - Throws: `JSONError` if the value is a boolean, an object, an array, or a string that

135+ /// cannot be coerced to a decimal number, or if the receiver is not an object.

136+ func toDecimalNumberOrNil(_ key: String) throws -> NSDecimalNumber? {

137+ let dict = try getObject()

138+ guard let value = dict[key] else { return nil }

139+ return try scoped(key) { try value.toDecimalNumberOrNil() }

140+ }

141+ }

142+

143+ // MARK: - Indexed accessors

144+

145+ public extension JSON {

146+ /// Subscripts the receiver with `index` and returns the result as an `NSDecimalNumber`.

147+ /// - Parameter index: The index that's used to subscript the receiver.

148+ /// - Returns: An `NSDecimalNumber`.

149+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type, or if

150+ /// the receiver is not an array.

151+ func getDecimalNumber(_ index: Int) throws -> NSDecimalNumber {

152+ let array = try getArray()

153+ let value = try getRequired(array, index: index, type: .number)

154+ return try scoped(index) { try value.getDecimalNumber() }

155+ }

156+

157+ /// Subscripts the receiver with `index` and returns the result as an `NSDecimalNumber`.

158+ /// - Parameter index: The index that's used to subscript the receiver.

159+ /// - Returns: An `NSDecimalNumber`, or `nil` if the index is out of bounds or the value is `null`.

160+ /// - Throws: `JSONError` if the value is the wrong type, or if the receiver is not an array.

161+ func getDecimalNumberOrNil(_ index: Int) throws -> NSDecimalNumber? {

162+ let array = try getArray()

163+ guard let value = array[safe: index] else { return nil }

164+ return try scoped(index) { try value.getDecimalNumberOrNil() }

165+ }

166+

167+ /// Subscripts the receiver with `index` and returns the result as an `NSDecimalNumber`.

168+ /// - Parameter index: The index that's used to subscript the receiver.

169+ /// - Returns: An `NSDecimalNumber`.

170+ /// - Throws: `JSONError` if the index is out of bounds or the value is `null`, a boolean,

171+ /// an object, an array, or a string that cannot be coerced to a decimal number, or

172+ /// if the receiver is not an array.

173+ func toDecimalNumber(_ index: Int) throws -> NSDecimalNumber {

174+ let array = try getArray()

175+ let value = try getRequired(array, index: index, type: .number)

176+ return try scoped(index) { try value.toDecimalNumber() }

177+ }

178+

179+ /// Subscripts the receiver with `index` and returns the result as an `NSDecimalNumber`.

180+ /// - Parameter index: The index that's used to subscript the receiver.

181+ /// - Returns: An `NSDecimalNumber`, or `nil` if the index is out of bounds or the value is `null`.

182+ /// - Throws: `JSONError` if the value is a boolean, an object, an array, or a string that

183+ /// cannot be coerced to a decimal number, or if the receiver is not an array.

184+ func toDecimalNumberOrNil(_ index: Int) throws -> NSDecimalNumber? {

185+ let array = try getArray()

186+ guard let value = array[safe: index] else { return nil }

187+ return try scoped(index) { try value.toDecimalNumberOrNil() }

188+ }

189+ }

190+

191+ // MARK: -

192+

193+ public extension JSONObject {

194+ /// Subscripts the receiver with `key` and returns the result as an `NSDecimalNumber`.

195+ /// - Parameter key: The key that's used to subscript the receiver.

196+ /// - Returns: An `NSDecimalNumber`.

197+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

198+ /// the receiver is not an object.

199+ func getDecimalNumber(_ key: String) throws -> NSDecimalNumber {

200+ let value = try getRequired(self, key: key, type: .number)

201+ return try scoped(key) { try value.getDecimalNumber() }

202+ }

203+

204+ /// Subscripts the receiver with `key` and returns the result as an `NSDecimalNumber`.

205+ /// - Parameter key: The key that's used to subscript the receiver.

206+ /// - Returns: An `NSDecimalNumber`, or `nil` if the key doesn't exist or the value is `null`.

207+ /// - Throws: `JSONError` if the value is the wrong type, or if the receiver is

208+ /// not an object.

209+ func getDecimalNumberOrNil(_ key: String) throws -> NSDecimalNumber? {

210+ guard let value = self[key] else { return nil }

211+ return try scoped(key) { try value.getDecimalNumberOrNil() }

212+ }

213+

214+ /// Subscripts the receiver with `key` and returns the result as an `NSDecimalNumber`.

215+ /// - Parameter key: The key that's used to subscript the receiver.

216+ /// - Returns: An `NSDecimalNumber`.

217+ /// - Throws: `JSONError` if the key doesn't exist or the value is `null`, a boolean, an object,

218+ /// an array, or a string that cannot be coerced to a decimal number, or if the

219+ /// receiver is not an object.

220+ func toDecimalNumber(_ key: String) throws -> NSDecimalNumber {

221+ let value = try getRequired(self, key: key, type: .number)

222+ return try scoped(key) { try value.toDecimalNumber() }

223+ }

224+

225+ /// Subscripts the receiver with `key` and returns the result as an `NSDecimalNumber`.

226+ /// - Parameter key: The key that's used to subscript the receiver.

227+ /// - Returns: An `NSDecimalNumber`, or `nil` if the key doesn't exist or the value is `null`.

228+ /// - Throws: `JSONError` if the value is a boolean, an object, an array, or a string that

229+ /// cannot be coerced to a decimal number, or if the receiver is not an object.

230+ func toDecimalNumberOrNil(_ key: String) throws -> NSDecimalNumber? {

231+ guard let value = self[key] else { return nil }

232+ return try scoped(key) { try value.toDecimalNumberOrNil() }

233+ }

234+ }

235+

236+#endif // os(iOS) || os(OSX) || os(tvOS) || os(watchOS)

parsers/test_PMJSON_1_2_0/Decoder.swiftnew file+502

@@ -0,0 +1,502 @@

1+//

2+// Decoder.swift

3+// PMJSON

4+//

5+// Created by Kevin Ballard on 10/8/15.

7+//

8+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

9+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

10+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

11+// option. This file may not be copied, modified, or distributed

12+// except according to those terms.

13+//

14+

15+extension JSON {

16+ /// Decodes a string as JSON.

17+ /// - Parameter string: A string to parse as JSON.

18+ /// - Parameter options: Options that controls JSON parsing. Defaults to no options. See `JSONOptions` for details.

19+ /// - Returns: A `JSON` value.

20+ /// - Throws: `JSONParserError`

21+ public static func decode(_ string: String, options: JSONOptions = []) throws -> JSON {

22+ return try decode(string.unicodeScalars, options: options)

23+ }

24+

25+ @available(*, deprecated, message: "Use JSON.decode(_:options:) instead")

26+ public static func decode(_ string: String, strict: Bool) throws -> JSON {

27+ return try decode(string, options: JSONOptions(strict: strict))

28+ }

29+

30+ /// Decodes a sequence of `UnicodeScalar`s as JSON.

31+ /// - Parameter scalars: A sequence of `UnicodeScalar`s to parse as JSON.

32+ /// - Parameter options: Options that controls JSON parsing. Defaults to no options. See `JSONOptions` for details.

33+ /// - Returns: A `JSON` value.

34+ /// - Throws: `JSONParserError`

35+ public static func decode<Seq: Sequence>(_ scalars: Seq, options: JSONOptions = []) throws -> JSON where Seq.Iterator.Element == UnicodeScalar {

36+ let parser = JSONParser(scalars, options: options.parserOptions)

37+ var decoder = JSONDecoder(parser, options: options.decoderOptions)

38+ return try decoder.decode()

39+ }

40+

41+ @available(*, deprecated, message: "Use JSON.decode(_:options:) instead")

42+ public static func decode<Seq: Sequence>(_ scalars: Seq, strict: Bool) throws -> JSON where Seq.Iterator.Element == UnicodeScalar {

43+ return try decode(scalars, options: JSONOptions(strict: strict))

44+ }

45+

46+ /// Lazily decodes a string as a JSON stream.

47+ ///

48+ /// A JSON stream is a series of top-level JSON values. See `JSONStreamDecoder` for details.

49+ ///

50+ /// - Parameter string: A string to parse as a JSON stream.

51+ /// - Parameter options: Options that controls JSON parsing. Defaults to no options. See `JSONOptions` for details.

52+ /// - Returns: A `JSONStreamDecoder`.

53+ public static func decodeStream(_ string: String, options: JSONOptions = []) -> JSONStreamDecoder<JSONParser<String.UnicodeScalarView>> {

54+ return decodeStream(string.unicodeScalars, options: options)

55+ }

56+

57+ @available(*, deprecated, message: "Use JSON.decodeStream(_:options:) instead")

58+ public static func decodeStream(_ string: String, strict: Bool) -> JSONStreamDecoder<JSONParser<String.UnicodeScalarView>> {

59+ return decodeStream(string, options: JSONOptions(strict: strict))

60+ }

61+

62+ /// Lazily decodes a sequence of `UnicodeScalar`s as a JSON stream.

63+ ///

64+ /// A JSON stream is a series of top-level JSON values. See `JSONStreamDecoder` for details.

65+ ///

66+ /// - Parameter scalars: A sequence of `UnicodeScalar`s to parse as a JSON stream.

67+ /// - Parameter options: Options that controls JSON parsing. Defaults to no options. See `JSONOptions` for details.

68+ /// - Returns: A `JSONStreamDecoder`.

69+ public static func decodeStream<Seq: Sequence>(_ scalars: Seq, options: JSONOptions = []) -> JSONStreamDecoder<JSONParser<Seq>> where Seq.Iterator.Element == UnicodeScalar {

70+ var parserOptions = options.parserOptions

71+ parserOptions.streaming = true

72+ let parser = JSONParser(scalars, options: parserOptions)

73+ return JSONStreamDecoder(parser)

74+ }

75+

76+ @available(*, deprecated, message: "Use JSON.decodeStream(_:options:) instead")

77+ public static func decodeStream<Seq: Sequence>(_ scalars: Seq, strict: Bool) -> JSONStreamDecoder<JSONParser<Seq>> where Seq.Iterator.Element == UnicodeScalar {

78+ return decodeStream(scalars, options: JSONOptions(strict: strict))

79+ }

80+}

81+

82+/// Options that can be used with `JSON.decode(…)`.

83+public struct JSONOptions {

84+ /// If `true`, the parser strictly conforms to RFC 7159.

85+ /// If `false`, the parser accepts the following extensions:

86+ /// - Trailing commas.

87+ /// - Less restrictive about numbers, such as `-01` or `-.123`.

88+ ///

89+ /// The default value is `false`.

90+ public var strict: Bool = false

91+

92+ /// A maximum depth limit to apply to nested arrays/dictionaries.

93+ /// If `nil`, there is no depth limit.

94+ ///

95+ /// The default value is `10_000`.

96+ public var depthLimit: Int? = 10_000

97+

98+ /// Returns a new `JSONOptions` with default values.

99+ public init() {}

100+

101+ /// Returns a new `JSONOptions`.

102+ /// - Parameter strict: Whether the parser should be strict. Defaults to `false`.

103+ /// - Parameter depthLimit: A maximum depth limit to use. Default is `10_000`.

104+ public init(strict: Bool = false, depthLimit: Int? = 10_000) {

105+ self.strict = strict

106+ self.depthLimit = depthLimit

107+ }

108+

109+ public var decoderOptions: JSONDecoderOptions {

110+ return JSONDecoderOptions(depthLimit: depthLimit)

111+ }

112+

113+ public var streamDecoderOptions: JSONStreamDecoderOptions {

114+ return JSONStreamDecoderOptions(depthLimit: depthLimit)

115+ }

116+

117+ public var parserOptions: JSONParserOptions {

118+ return JSONParserOptions(strict: strict)

119+ }

120+}

121+

122+extension JSONOptions: ExpressibleByArrayLiteral {

123+ public enum Element {

124+ /// Makes the parser strictly conform to RFC 7159.

125+ /// - SeeAlso: `JSONOptions.strict`.

126+ case strict

127+ /// Sets a maximum depth limit for nested arrays/dictionaries.

128+ /// If specified multiple times, the last specified limit is used.

129+ /// Specifying `nil` removes the default depth limit of `10_000`.

130+ /// - SeeAlso: `JSONOptions.depthLimit`.

131+ case depthLimit(Int?)

132+ }

133+

134+ public init(arrayLiteral elements: Element...) {

135+ for elt in elements {

136+ switch elt {

137+ case .strict: strict = true

138+ case .depthLimit(let limit):

139+ depthLimit = limit

140+ }

141+ }

142+ }

143+}

144+

145+/// A JSON decoder that consumes a stream of JSON events.

146+///

147+/// In most cases, you should use the convenience method `JSON.decode(_:)` to decode values

148+/// instead of using this class directly.

149+///

150+/// - SeeAlso: `JSONParser`.

151+public struct JSONDecoder<Seq: Sequence> where Seq.Iterator: JSONEventIterator, Seq.Iterator.Element == JSONEvent {

152+ public init(_ parser: Seq, options: JSONDecoderOptions = []) {

153+ iter = parser.makeIterator()

154+ self.options = options

155+ }

156+

157+ /// Options to apply to the decoder.

158+ /// See `JSONDecoderOptions` for details.

159+ var options: JSONDecoderOptions

160+

161+ @available(*, deprecated, renamed: "options.streaming")

162+ public var streaming: Bool {

163+ get { return options.streaming }

164+ set { options.streaming = newValue }

165+ }

166+

167+ /// Decodes and returns a top-level JSON value from the event stream.

168+ ///

169+ /// When `streaming` is `false`, any events after the top-level value has been consumed

170+ /// will throw an error, and any subsequent calls to `decode()` after the first call

171+ /// will also throw an error. When `streaming` is `false`, after a top-level value has

172+ /// been decoded, no more events will be consumed, and `decode()` can be called repeatedly

173+ /// to decode more top-level events.

174+ ///

175+ /// Because the normal operation of this class is to decode one-shot values rather than

176+ /// streams, this method returns a non-optional value. As such, when operating in a

177+ /// streaming manner, this method will throw the special error `JSONDecoderError.streamEnded`

178+ /// to signal that there are no more values. To make this easier to work with, a convenience

179+ /// method `decodeStream()` is provided that returns an array of `JSON` values and automatically

180+ /// handles `JSONDecoderError.streamEnded`, and the type `JSONStreamDecoder` provides a

181+ /// lazy sequence interface to decoding a JSON stream.

182+ ///

183+ /// - Returns: A single top-level `JSON` value.

184+ ///

185+ /// - Throws: `JSONParserError`, `JSONDecoderError`.

186+ public mutating func decode() throws -> JSON {

187+ bump()

188+ if options.streaming && token == nil {

189+ throw JSONDecoderError.streamEnded

190+ }

191+ let result = try buildValue(depth: 0)

192+ if !options.streaming {

193+ bump()

194+ switch token {

195+ case .none: break

196+ case .some(.error(let err)): throw err

197+ case .some: throw JSONDecoderError.unexpectedToken

198+ }

199+ }

200+ return result

201+ }

202+

203+ /// Decodes and returns an array of top-level JSON values from the event stream.

204+ ///

205+ /// This is a convenience method that sets `streaming` to `true` and then decodes

206+ /// as many top-level JSON values as it can before the stream ends.

207+ ///

208+ /// - Returns: An array of top-level `JSON` values.

209+ ///

210+ /// - SeeAlso: `JSONStreamDecoder`.

211+ public mutating func decodeStream() throws -> [JSON] {

212+ options.streaming = true

213+ var results: [JSON] = []

214+ repeat {

215+ do {

216+ results.append(try decode())

217+ } catch JSONDecoderError.streamEnded {

218+ return results

219+ }

220+ } while true

221+ }

222+

223+ private mutating func bump() {

224+ token = iter.next()

225+ }

226+

227+ private mutating func buildValue(depth: Int) throws -> JSON {

228+ switch token {

229+ case .objectStart?:

230+ let newDepth = depth + 1

231+ if let limit = options.depthLimit, newDepth > limit {

232+ throw JSONDecoderError.exceededDepthLimit

233+ }

234+ return try buildObject(depth: newDepth)

235+ case .objectEnd?: throw error(.invalidSyntax)

236+ case .arrayStart?:

237+ let newDepth = depth + 1

238+ if let limit = options.depthLimit, newDepth > limit {

239+ throw JSONDecoderError.exceededDepthLimit

240+ }

241+ return try buildArray(depth: newDepth)

242+ case .arrayEnd?: throw error(.invalidSyntax)

243+ case .booleanValue(let b)?: return .bool(b)

244+ case .int64Value(let i)?: return .int64(i)

245+ case .doubleValue(let d)?: return .double(d)

246+ case .stringValue(let s)?: return .string(s)

247+ case .nullValue?: return .null

248+ case .error(let err)?: throw err

249+ case nil: throw error(.unexpectedEOF)

250+ }

251+ }

252+

253+ private mutating func buildObject(depth: Int) throws -> JSON {

254+ bump()

255+ var dict: [String: JSON] = Dictionary(minimumCapacity: objectHighWaterMark)

256+ defer { objectHighWaterMark = max(objectHighWaterMark, dict.count) }

257+ while let token = self.token {

258+ let key: String

259+ switch token {

260+ case .objectEnd: return .object(JSONObject(dict))

261+ case .error(let err): throw err

262+ case .stringValue(let s): key = s

263+ default: throw error(.nonStringKey)

264+ }

265+ bump()

266+ dict[key] = try buildValue(depth: depth)

267+ bump()

268+ }

269+ throw error(.unexpectedEOF)

270+ }

271+

272+ private mutating func buildArray(depth: Int) throws -> JSON {

273+ bump()

274+ var ary: JSONArray = []

275+ while let token = self.token {

276+ if case .arrayEnd = token {

277+ return .array(ary)

278+ }

279+ ary.append(try buildValue(depth: depth))

280+ bump()

281+ }

282+ throw error(.unexpectedEOF)

283+ }

284+

285+ private func error(_ code: JSONParserError.Code) -> JSONParserError {

286+ return JSONParserError(code: code, line: iter.line, column: iter.column)

287+ }

288+

289+ private var iter: Seq.Iterator

290+ private var token: JSONEvent?

291+ private var objectHighWaterMark: Int = 0

292+}

293+

294+/// Options that can be used with `JSONDecoder`.

295+public struct JSONDecoderOptions {

296+ /// A maximum depth limit to apply to nested arrays/dictionaries.

297+ /// If `nil`, there is no depth limit.

298+ ///

299+ /// The default value is `10_000`.

300+ public var depthLimit: Int? = 10_000

301+

302+ /// If `true`, the decoder will operate in streaming mode, allowing for multiple

303+ /// top-level json values, with each call to `decode()` returning a successive value.

304+ /// The default value of `false` means that `decode()` can only be called once, and

305+ /// any JSON events past the first top-level value are considered an error.

306+ ///

307+ /// See `JSONDecoder.decode()` for more details on the streaming operation.

308+ ///

309+ /// The default value is `false`.

310+ ///

311+ /// - Important: When wrapping a `JSONParser`, the parser must separately be put into

312+ /// streaming mode, as `JSONDecoder` operates generically over a sequence of `JSONEvent`s.

313+ public var streaming: Bool = false

314+

315+ /// Returns a new `JSONDecoderOptions` with default values.

316+ public init() {}

317+

318+ /// Returns a new `JSONDecoderOptions`.

319+ /// - Parameter depthLimit: A maximum depth limit to use. Default is `10_000`.

320+ /// - Parameter streaming: Whether the decode should operate in streaming mode. Default is `false`.

321+ public init(depthLimit: Int? = 10_000, streaming: Bool = false) {

322+ self.depthLimit = depthLimit

323+ self.streaming = streaming

324+ }

325+}

326+

327+extension JSONDecoderOptions: ExpressibleByArrayLiteral {

328+ public enum Element {

329+ /// Sets a maximum depth limit for nested arrays/dictionaries.

330+ /// If specified multiple times, the last specified limit is used.

331+ /// Specifying `nil` removes the default depth limit of `10_000`.

332+ /// - SeeAlso: `JSONDecoderOptions.depthLimit`.

333+ case depthLimit(Int?)

334+ /// Puts the decoder into streaming mode.

335+ /// - SeeAlso: `JSONDecoderOptions.streaming`.

336+ case streaming

337+ }

338+

339+ public init(arrayLiteral elements: Element...) {

340+ for elt in elements {

341+ switch elt {

342+ case .depthLimit(let limit):

343+ depthLimit = limit

344+ case .streaming:

345+ streaming = true

346+ }

347+ }

348+ }

349+}

350+

351+/// Errors that may be thrown by the `JSONDecoder` during the decode stage.

352+public enum JSONDecoderError: Error {

353+ /// Signals that a `JSONDecoder` operating in streaming mode has reached the end of the stream.

354+ case streamEnded

355+ /// Thrown when a `JSONDecoder` operating in one-shot mode finds extra tokens after the first top-level JSON value.

356+ case unexpectedToken

357+ /// Thrown when a `JSONDecoder` exceeds the specified depth limit.

358+ case exceededDepthLimit

359+}

360+

361+/// A JSON decoder that decodes a stream of JSON events into a lazy sequence of top-level JSON values.

362+///

363+/// This is a sequence of zero or more `JSONStreamValue.json` values, ending with zero or one `JSONStreamValue.error` value.

364+///

365+/// - Important: When wrapping a `JSONParser`, the parser must separately be put into streaming mode, as `JSONStreamDecoder`

366+/// operates generically over a sequence of `JSONEvent`s. You should consider using `JSON.decodeStream(_:)` instead to

367+/// create the stream decoder.

368+///

369+/// - SeeAlso: `JSON.decodeStream(_:)`.

370+public struct JSONStreamDecoder<Seq: Sequence>: Sequence, IteratorProtocol where Seq.Iterator: JSONEventIterator, Seq.Iterator.Element == JSONEvent {

371+ public init(_ parser: Seq, options: JSONStreamDecoderOptions = []) {

372+ decoder = JSONDecoder(parser, options: options.decoderOptions)

373+ }

374+

375+ /// Options to apply to the decoder.

376+ /// See `JSONStreamDecoderOptions` for details.

377+ public var options: JSONStreamDecoderOptions {

378+ get { return decoder.options.streamDecoderOptions }

379+ set { decoder.options.update(with: newValue) }

380+ }

381+

382+ /// Returns an array of all decoded values, or throws an error if one occurs.

383+ ///

384+ /// This eagerly decodes the rest of the JSON stream and returns all values. If a parse error occurs at any point,

385+ /// the error is thrown and all values are discarded.

386+ ///

387+ /// - Returns: An array of `JSON` values.

388+ /// - Throws: `JSONParserError`.

389+ public func values() throws -> [JSON] {

390+ return try map({ try $0.unwrap() })

391+ }

392+

393+ public func makeIterator() -> JSONStreamDecoder<Seq> {

394+ return self

395+ }

396+

397+ public mutating func next() -> JSONStreamValue? {

398+ do {

399+ return try JSONStreamValue.json(decoder.decode())

400+ } catch JSONDecoderError.streamEnded {

401+ return nil

402+ } catch let error as JSONParserError {

403+ return JSONStreamValue.error(error)

404+ } catch {

405+ // This shouldn't be reachable. A `JSONDecoder` operating in streaming mode can throw only

406+ // `JSONParserError`s or `JSONDecoderError.streamEnded`.

407+ return nil

408+ }

409+ }

410+

411+ private var decoder: JSONDecoder<Seq>

412+}

413+

414+/// Options that can be used with `JSONStreamDecoder`.

415+public struct JSONStreamDecoderOptions {

416+ /// A maximum depth limit to apply to nested arrays/dictionaries.

417+ /// If `nil`, there is no depth limit.

418+ ///

419+ /// The default value is `10_000`.

420+ public var depthLimit: Int? = 10_000

421+

422+ /// Returns a new `JSONStreamDecoderOptions` with default values.

423+ public init() {}

424+

425+ /// Returns a new `JSONStreamDecoderOptions`.

426+ /// - Parameter depthLimit: A maximum depth limit to use. Default is `10_000`.

427+ public init(depthLimit: Int? = 10_000) {

428+ self.depthLimit = depthLimit

429+ }

430+

431+ fileprivate var decoderOptions: JSONDecoderOptions {

432+ return JSONDecoderOptions(depthLimit: depthLimit, streaming: true)

433+ }

434+}

435+

436+private extension JSONDecoderOptions {

437+ var streamDecoderOptions: JSONStreamDecoderOptions {

438+ return JSONStreamDecoderOptions(depthLimit: depthLimit)

439+ }

440+

441+ mutating func update(with options: JSONStreamDecoderOptions) {

442+ depthLimit = options.depthLimit

443+ }

444+}

445+

446+extension JSONStreamDecoderOptions: ExpressibleByArrayLiteral {

447+ public enum Element {

448+ /// Sets a maximum depth limit for nested arrays/dictionaries.

449+ /// If specified multiple times, the last specified limit is used.

450+ /// Specifying `nil` removes the default depth limit of `10_000`.

451+ /// - SeeAlso: `JSONStreamDecoderOptions.depthLimit`.

452+ case depthLimit(Int?)

453+ }

454+

455+ public init(arrayLiteral elements: Element...) {

456+ for elt in elements {

457+ switch elt {

458+ case .depthLimit(let limit):

459+ depthLimit = limit

460+ }

461+ }

462+ }

463+}

464+

465+public enum JSONStreamValue: Equatable {

466+ case json(JSON)

467+ case error(JSONParserError)

468+

469+ /// Returns the contained `JSON` value, otherwise `nil`.

470+ public var json: JSON? {

471+ switch self {

472+ case .json(let json): return json

473+ case .error: return nil

474+ }

475+ }

476+

477+ /// Returns the contained error, otherwise `nil`.

478+ public var error: JSONParserError? {

479+ switch self {

480+ case .json: return nil

481+ case .error(let error): return error

482+ }

483+ }

484+

485+ /// Unwraps the contained `JSON` value or throws the contained error.

486+ ///

487+ /// - Throws: `JSONParserError`.

488+ public func unwrap() throws -> JSON {

489+ switch self {

490+ case .json(let value): return value

491+ case .error(let error): throw error

492+ }

493+ }

494+

495+ public static func ==(lhs: JSONStreamValue, rhs: JSONStreamValue) -> Bool {

496+ switch (lhs, rhs) {

497+ case let (.json(a), .json(b)): return a == b

498+ case let (.error(a), .error(b)): return a == b

499+ default: return false

500+ }

501+ }

502+}

parsers/test_PMJSON_1_2_0/Encoder.swiftnew file+215

@@ -0,0 +1,215 @@

1+//

2+// Encoder.swift

3+// PMJSON

4+//

5+// Created by Kevin Ballard on 2/1/16.

7+//

8+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

9+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

10+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

11+// option. This file may not be copied, modified, or distributed

12+// except according to those terms.

13+//

14+

15+extension JSON {

16+ /// Encodes a `JSON` to a `String`.

17+ /// - Parameter json: The `JSON` to encode.

18+ /// - Parameters options: Options that controls JSON encoding. Defaults to no options. See `JSONEncoderOptions` for details.

19+ /// - Returns: A `String` with the JSON representation of *json*.

20+ public static func encodeAsString(_ json: JSON, options: JSONEncoderOptions = []) -> String {

21+ var s = ""

22+ encode(json, to: &s, options: options)

23+ return s

24+ }

25+

26+ @available(*, deprecated, message: "Use JSON.encodeAsString(_:options:) instead")

27+ public static func encodeAsString(_ json: JSON, pretty: Bool) -> String {

28+ return encodeAsString(json, options: JSONEncoderOptions(pretty: pretty))

29+ }

30+

31+ /// Encodes a `JSON` to an output stream.

32+ /// - Parameter json: The `JSON` to encode.

33+ /// - Parameter stream: The output stream to write the encoded JSON to.

34+ /// - Parameters options: Options that controls JSON encoding. Defaults to no options. See `JSONEncoderOptions` for details.

35+ public static func encode<Target: TextOutputStream>(_ json: JSON, to stream: inout Target, options: JSONEncoderOptions = []) {

36+ encode(json, to: &stream, indent: options.pretty ? 0 : nil)

37+ }

38+

39+ @available(*, deprecated, message: "Use JSON.encode(_:to:options:) instead")

40+ public static func encode<Target: TextOutputStream>(_ json: JSON, to stream: inout Target, pretty: Bool) {

41+ encode(json, to: &stream, options: JSONEncoderOptions(pretty: pretty))

42+ }

43+

44+ @available(*, deprecated, renamed: "encode(_:to:pretty:)")

45+ public static func encode<Target: TextOutputStream>(_ json: JSON, toStream stream: inout Target, pretty: Bool) {

46+ encode(json, to: &stream, options: JSONEncoderOptions(pretty: pretty))

47+ }

48+

49+ private static func encode<Target: TextOutputStream>(_ json: JSON, to stream: inout Target, indent: Int?) {

50+ switch json {

51+ case .null: encodeNull(&stream)

52+ case .bool(let b): encodeBool(b, toStream: &stream)

53+ case .int64(let i): encodeInt64(i, toStream: &stream)

54+ case .double(let d): encodeDouble(d, toStream: &stream)

55+ case .string(let s): encodeString(s, toStream: &stream)

56+ case .object(let obj): encodeObject(obj, toStream: &stream, indent: indent)

57+ case .array(let ary): encodeArray(ary, toStream: &stream, indent: indent)

58+ }

59+ }

60+

61+ private static func encodeNull<Target: TextOutputStream>(_ stream: inout Target) {

62+ stream.write("null")

63+ }

64+

65+ private static func encodeBool<Target: TextOutputStream>(_ value: Bool, toStream stream: inout Target) {

66+ stream.write(value ? "true" : "false")

67+ }

68+

69+ private static func encodeInt64<Target: TextOutputStream>(_ value: Int64, toStream stream: inout Target) {

70+ stream.write(String(value))

71+ }

72+

73+ private static func encodeDouble<Target: TextOutputStream>(_ value: Double, toStream stream: inout Target) {

74+ stream.write(String(value))

75+ }

76+

77+ private static func encodeString<Target: TextOutputStream>(_ value: String, toStream stream: inout Target) {

78+ stream.write("\"")

79+ let scalars = value.unicodeScalars

80+ var start = scalars.startIndex

81+ let end = scalars.endIndex

82+ var idx = start

83+ while idx < scalars.endIndex {

84+ let s: String

85+ let c = scalars[idx]

86+ switch c {

87+ case "\\": s = "\\\\"

88+ case "\"": s = "\\\""

89+ case "\n": s = "\\n"

90+ case "\r": s = "\\r"

91+ case "\t": s = "\\t"

92+ case "\u{8}": s = "\\b"

93+ case "\u{C}": s = "\\f"

94+ case "\0"..<"\u{10}":

95+ s = "\\u000\(String(c.value, radix: 16, uppercase: true))"

96+ case "\u{10}"..<" ":

97+ s = "\\u00\(String(c.value, radix: 16, uppercase: true))"

98+ default:

99+ idx = scalars.index(after: idx)

100+ continue

101+ }

102+ if idx != start {

103+ stream.write(String(scalars[start..<idx]))

104+ }

105+ stream.write(s)

106+ idx = scalars.index(after: idx)

107+ start = idx

108+ }

109+ if start != end {

110+ String(scalars[start..<end]).write(to: &stream)

111+ }

112+ stream.write("\"")

113+ }

114+

115+ private static func encodeObject<Target: TextOutputStream>(_ object: JSONObject, toStream stream: inout Target, indent: Int?) {

116+ let indented = indent.map({$0+1})

117+ if let indent = indented {

118+ stream.write("{\n")

119+ writeIndent(indent, toStream: &stream)

120+ } else {

121+ stream.write("{")

122+ }

123+ var first = true

124+ for (key, value) in object {

125+ if first {

126+ first = false

127+ } else if let indent = indented {

128+ stream.write(",\n")

129+ writeIndent(indent, toStream: &stream)

130+ } else {

131+ stream.write(",")

132+ }

133+ encodeString(key, toStream: &stream)

134+ stream.write(indented != nil ? ": " : ":")

135+ encode(value, to: &stream, indent: indented)

136+ }

137+ if let indent = indent {

138+ stream.write("\n")

139+ writeIndent(indent, toStream: &stream)

140+ }

141+ stream.write("}")

142+ }

143+

144+ private static func encodeArray<Target: TextOutputStream>(_ array: JSONArray, toStream stream: inout Target, indent: Int?) {

145+ let indented = indent.map({$0+1})

146+ if let indent = indented {

147+ stream.write("[\n")

148+ writeIndent(indent, toStream: &stream)

149+ } else {

150+ stream.write("[")

151+ }

152+ var first = true

153+ for elt in array {

154+ if first {

155+ first = false

156+ } else if let indent = indented {

157+ stream.write(",\n")

158+ writeIndent(indent, toStream: &stream)

159+ } else {

160+ stream.write(",")

161+ }

162+ encode(elt, to: &stream, indent: indented)

163+ }

164+ if let indent = indent {

165+ stream.write("\n")

166+ writeIndent(indent, toStream: &stream)

167+ }

168+ stream.write("]")

169+ }

170+

171+ private static func writeIndent<Target: TextOutputStream>(_ indent: Int, toStream stream: inout Target) {

172+ for _ in stride(from: 4, through: indent, by: 4) {

173+ stream.write(" ")

174+ }

175+ switch indent % 4 {

176+ case 1: stream.write(" ")

177+ case 2: stream.write(" ")

178+ case 3: stream.write(" ")

179+ default: break

180+ }

181+ }

182+}

183+

184+public struct JSONEncoderOptions {

185+ /// If `true`, the output is formatted with whitespace to be easier to read.

186+ /// If `false`, the output omits any unnecessary whitespace.

187+ ///

188+ /// The default value is `false`.

189+ public var pretty: Bool = false

190+

191+ /// Returns a new `JSONEncoderOptions` with default values.

192+ public init() {}

193+

194+ /// Returns a new `JSONEncoderOptions`.

195+ /// - Parameter pretty: Whether the output should be formatted nicely. Defaults to `false`.

196+ public init(pretty: Bool = false) {

197+ self.pretty = pretty

198+ }

199+}

200+

201+extension JSONEncoderOptions: ExpressibleByArrayLiteral {

202+ public enum Element {

203+ /// Formats the output with whitespace to be easier to read.

204+ /// - SeeAlso: `JSONEncoderOptions.pretty`.

205+ case pretty

206+ }

207+

208+ public init(arrayLiteral elements: Element...) {

209+ for elt in elements {

210+ switch elt {

211+ case .pretty: pretty = true

212+ }

213+ }

214+ }

215+}

parsers/test_PMJSON_1_2_0/JSON.swiftnew file+170

@@ -0,0 +1,170 @@

1+//

2+// JSON.swift

3+// PMJSON

4+//

5+// Created by Kevin Ballard on 10/8/15.

7+//

8+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

9+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

10+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

11+// option. This file may not be copied, modified, or distributed

12+// except according to those terms.

13+//

14+

15+/// A single JSON-compatible value.

16+public enum JSON {

17+ /// The null value.

18+ case null

19+ /// A boolean.

20+ case bool(Bool)

21+ /// A string.

22+ case string(String)

23+ /// A 64-bit integer.

24+ case int64(Int64)

25+ /// A number.

26+ /// When decoding, any integer that doesn't fit in 64 bits and any floating-point number

27+ /// is decoded as a `Double`.

28+ case double(Double)

29+ /// An object.

30+ case object(JSONObject)

31+ /// An array.

32+ case array(JSONArray)

33+

34+ /// Initializes `self` as a boolean with the value `bool`.

35+ public init(_ bool: Bool) {

36+ self = .bool(bool)

37+ }

38+ /// Initializes `self` as a string with the value `str`.

39+ public init(_ str: String) {

40+ self = .string(str)

41+ }

42+ /// Initializes `self` as a 64-bit integer with the value `i`.

43+ public init(_ i: Int64) {

44+ self = .int64(i)

45+ }

46+ /// Initializes `self` as a double with the value `d`.

47+ public init(_ d: Double) {

48+ self = .double(d)

49+ }

50+ /// Initializes `self` as an object with the value `obj`.

51+ public init(_ obj: JSONObject) {

52+ self = .object(obj)

53+ }

54+ /// Initializes `self` as an array with the value `ary`.

55+ public init(_ ary: JSONArray) {

56+ self = .array(ary)

57+ }

58+}

59+

60+// Convenience conversions.

61+public extension JSON {

62+ /// Initializes `self` as a 64-bit integer with the value `i`.

63+ public init(_ i: Int) {

64+ self = .int64(Int64(i))

65+ }

66+

67+ /// Initializes `self` as an array with the contents of the sequence `seq`.

68+ public init<S: Sequence>(_ seq: S) where S.Iterator.Element == JSON {

69+ self = .array(JSONArray(seq))

70+ }

71+

72+ /// Initializes `self` as an array with the contents of the sequence `seq`.

73+ public init<S: Sequence>(_ seq: S) where S.Iterator.Element == JSONObject {

74+ self = .array(JSONArray(seq.lazy.map(JSON.init)))

75+ }

76+

77+ /// Initializes `self` as an array with the contents of the sequence `seq`.

78+ public init<S: Sequence>(_ seq: S) where S.Iterator.Element == JSONArray {

79+ self = .array(JSONArray(seq.lazy.map(JSON.init)))

80+ }

81+}

82+

83+public typealias JSONArray = ContiguousArray<JSON>

84+

85+extension JSON: Equatable {

86+ public static func ==(lhs: JSON, rhs: JSON) -> Bool {

87+ switch (lhs, rhs) {

88+ case (.null, .null): return true

89+ case (.bool(let a), .bool(let b)): return a == b

90+ case (.string(let a), .string(let b)): return a == b

91+ case (.int64(let a), .int64(let b)): return a == b

92+ case (.double(let a), .double(let b)): return a == b

93+ case (.int64(let a), .double(let b)): return Double(a) == b

94+ case (.double(let a), .int64(let b)): return a == Double(b)

95+ case (.object(let a), .object(let b)): return a == b

96+ case (.array(let a), .array(let b)): return a == b

97+ default: return false

98+ }

99+ }

100+}

101+

102+extension JSON: TextOutputStreamable, CustomStringConvertible, CustomDebugStringConvertible {

103+ public func write<Target : TextOutputStream>(to target: inout Target) {

104+ JSON.encode(self, to: &target)

105+ }

106+

107+ public var description: String {

108+ return JSON.encodeAsString(self)

109+ }

110+

111+ public var debugDescription: String {

112+ let desc = JSON.encodeAsString(self)

113+ return "JSON(\(desc))"

114+ }

115+}

116+

117+extension JSON: ExpressibleByIntegerLiteral, ExpressibleByFloatLiteral, ExpressibleByBooleanLiteral, ExpressibleByNilLiteral {

118+ public init(integerLiteral value: Int64) {

119+ self = .int64(value)

120+ }

121+

122+ public init(floatLiteral value: Double) {

123+ self = .double(value)

124+ }

125+

126+ public init(booleanLiteral value: Bool) {

127+ self = .bool(value)

128+ }

129+

130+ public init(nilLiteral: ()) {

131+ self = .null

132+ }

133+}

134+

135+extension JSON: ExpressibleByStringLiteral {

136+ public init(stringLiteral value: String) {

137+ self = .string(value)

138+ }

139+

140+ public init(extendedGraphemeClusterLiteral value: String) {

141+ self = .string(value)

142+ }

143+

144+ public init(unicodeScalarLiteral value: String) {

145+ self = .string(value)

146+ }

147+}

148+

149+extension JSON: ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral {

150+ public init(arrayLiteral elements: JSON...) {

151+ self = .array(JSONArray(elements))

152+ }

153+

154+ public init(dictionaryLiteral elements: (String, JSON)...) {

155+ self = .object(JSONObject(elements))

156+ }

157+}

158+

159+extension JSON: CustomReflectable {

160+ public var customMirror: Mirror {

161+ switch self {

162+ case .null, .bool, .string, .int64, .double: return Mirror(self, children: [])

163+ case .object(let obj):

164+ let children: LazyMapCollection<JSONObject, Mirror.Child> = obj.lazy.map({ ($0, $1) })

165+ return Mirror(self, children: children, displayStyle: .dictionary)

166+ case .array(let ary):

167+ return Mirror(self, unlabeledChildren: ary, displayStyle: .collection)

168+ }

169+ }

170+}

parsers/test_PMJSON_1_2_0/JSONError.swiftnew file+1619

@@ -0,0 +1,1619 @@

1+//

2+// JSONError.swift

3+// PMJSON

4+//

5+// Created by Kevin Ballard on 11/9/15.

7+//

8+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

9+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

10+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

11+// option. This file may not be copied, modified, or distributed

12+// except according to those terms.

13+//

14+

15+// MARK: JSONError

16+

17+/// Errors thrown by the JSON `get*` or `to*` accessor families.

18+public enum JSONError: Error, CustomStringConvertible {

19+ /// Thrown when a given path is missing or has the wrong type.

20+ /// - Parameter path: The path of the key that caused the error.

21+ /// - Parameter expected: The type that was expected at this path.

22+ /// - Parameter actual: The type of the value found at the path, or `nil` if there was no value.

23+ case missingOrInvalidType(path: String?, expected: ExpectedType, actual: JSONType?)

24+ /// Thrown when an integral value is coerced to a smaller type (e.g. `Int64` to `Int`) and the

25+ /// value doesn't fit in the smaller type.

26+ /// - Parameter path: The path of the value that cuased the error.

27+ /// - Parameter value: The actual value at that path.

28+ /// - Parameter expected: The type that the value doesn't fit in, e.g. `Int.self`.

29+ case outOfRangeInt64(path: String?, value: Int64, expected: Any.Type)

30+ /// Thrown when a floating-point value is coerced to a smaller type (e.g. `Double` to `Int`)

31+ /// and the value doesn't fit in the smaller type.

32+ /// - Parameter path: The path of the value that cuased the error.

33+ /// - Parameter value: The actual value at that path.

34+ /// - Parameter expected: The type that the value doesn't fit in, e.g. `Int.self`.

35+ case outOfRangeDouble(path: String?, value: Double, expected: Any.Type)

36+

37+ public var description: String {

38+ switch self {

39+ case let .missingOrInvalidType(path, expected, actual): return "\(path.map({"\($0): "}) ?? "")expected \(expected), found \(actual?.description ?? "missing value")"

40+ case let .outOfRangeInt64(path, value, expected): return "\(path.map({"\($0): "}) ?? "")value \(value) cannot be coerced to type \(expected)"

41+ case let .outOfRangeDouble(path, value, expected): return "\(path.map({"\($0): "}) ?? "")value \(value) cannot be coerced to type \(expected)"

42+ }

43+ }

44+

45+ fileprivate func withPrefix(_ prefix: String) -> JSONError {

46+ func prefixPath(_ path: String?, with prefix: String) -> String {

47+ guard let path = path, !path.isEmpty else { return prefix }

48+ if path.unicodeScalars.first == "[" {

49+ return prefix + path

50+ } else {

51+ return "\(prefix).\(path)"

52+ }

53+ }

54+ switch self {

55+ case let .missingOrInvalidType(path, expected, actual):

56+ return .missingOrInvalidType(path: prefixPath(path, with: prefix), expected: expected, actual: actual)

57+ case let .outOfRangeInt64(path, value, expected):

58+ return .outOfRangeInt64(path: prefixPath(path, with: prefix), value: value, expected: expected)

59+ case let .outOfRangeDouble(path, value, expected):

60+ return .outOfRangeDouble(path: prefixPath(path, with: prefix), value: value, expected: expected)

61+ }

62+ }

63+

64+ public enum ExpectedType: CustomStringConvertible {

65+ case required(JSONType)

66+ case optional(JSONType)

67+

68+ public var description: String {

69+ switch self {

70+ case .required(let type): return type.description

71+ case .optional(let type): return "\(type) or null"

72+ }

73+ }

74+ }

75+

76+ public enum JSONType: String, CustomStringConvertible {

77+ case null = "null"

78+ case bool = "bool"

79+ case string = "string"

80+ case number = "number"

81+ case object = "object"

82+ case array = "array"

83+

84+ internal static func forValue(_ value: JSON) -> JSONType {

85+ switch value {

86+ case .null: return .null

87+ case .bool: return .bool

88+ case .string: return .string

89+ case .int64, .double: return .number

90+ case .object: return .object

91+ case .array: return .array

92+ }

93+ }

94+

95+ public var description: String {

96+ return rawValue

97+ }

98+ }

99+}

100+

101+// MARK: - Basic accessors

102+public extension JSON {

103+ /// Returns the bool value if the receiver is a bool.

104+ /// - Returns: A `Bool` value.

105+ /// - Throws: `JSONError` if the receiver is the wrong type.

106+ func getBool() throws -> Bool {

107+ guard let b = self.bool else { throw JSONError.missingOrInvalidType(path: nil, expected: .required(.bool), actual: .forValue(self)) }

108+ return b

109+ }

110+

111+ /// Returns the bool value if the receiver is a bool.

112+ /// - Returns: A `Bool` value, or `nil` if the receiver is `null`.

113+ /// - Throws: `JSONError` if the receiver is the wrong type.

114+ func getBoolOrNil() throws -> Bool? {

115+ if let b = self.bool { return b }

116+ else if isNull { return nil }

117+ else { throw JSONError.missingOrInvalidType(path: nil, expected: .optional(.bool), actual: .forValue(self)) }

118+ }

119+

120+ /// Returns the string value if the receiver is a string.

121+ /// - Returns: A `String` value.

122+ /// - Throws: `JSONError` if the receiver is the wrong type.

123+ func getString() throws -> String {

124+ guard let str = self.string else { throw JSONError.missingOrInvalidType(path: nil, expected: .required(.string), actual: .forValue(self)) }

125+ return str

126+ }

127+

128+ /// Returns the string value if the receiver is a string.

129+ /// - Returns: A `String` value, or `nil` if the receiver is `null`.

130+ /// - Throws: `JSONError` if the receiver is the wrong type.

131+ func getStringOrNil() throws -> String? {

132+ if let str = self.string { return str }

133+ else if isNull { return nil }

134+ else { throw JSONError.missingOrInvalidType(path: nil, expected: .optional(.string), actual: .forValue(self)) }

135+ }

136+

137+ /// Returns the 64-bit integral value if the receiver is a number.

138+ /// - Returns: An `Int64` value.

139+ /// - Throws: `JSONError` if the receiver is the wrong type.

140+ func getInt64() throws -> Int64 {

141+ guard let val = self.int64 else { throw JSONError.missingOrInvalidType(path: nil, expected: .required(.number), actual: .forValue(self)) }

142+ return val

143+ }

144+

145+ /// Returns the 64-bit integral value value if the receiver is a number.

146+ /// - Returns: An `Int64` value, or `nil` if the receiver is `null`.

147+ /// - Throws: `JSONError` if the receiver is the wrong type.

148+ func getInt64OrNil() throws -> Int64? {

149+ if let val = self.int64 { return val }

150+ else if isNull { return nil }

151+ else { throw JSONError.missingOrInvalidType(path: nil, expected: .optional(.number), actual: .forValue(self)) }

152+ }

153+

154+ /// Returns the integral value if the receiver is a number.

155+ /// - Returns: An `Int` value.

156+ /// - Throws: `JSONError` if the receiver is the wrong type, or if the 64-bit integral value

157+ /// is too large to fit in an `Int`.

158+ func getInt() throws -> Int {

159+ guard let val = self.int64 else { throw JSONError.missingOrInvalidType(path: nil, expected: .required(.number), actual: .forValue(self)) }

160+ let truncated = Int(truncatingBitPattern: val)

161+ guard Int64(truncated) == val else { throw JSONError.outOfRangeInt64(path: nil, value: val, expected: Int.self) }

162+ return truncated

163+ }

164+

165+ /// Returns the integral value if the receiver is a number.

166+ /// - Returns: An `Int` value, or `nil` if the receiver is `null`.

167+ /// - Throws: `JSONError` if the receiver is the wrong type, or if the 64-bit integral value

168+ /// is too large to fit in an `Int`.

169+ func getIntOrNil() throws -> Int? {

170+ if let val = self.int64 {

171+ let truncated = Int(truncatingBitPattern: val)

172+ guard Int64(truncated) == val else { throw JSONError.outOfRangeInt64(path: nil, value: val, expected: Int.self) }

173+ return truncated

174+ } else if isNull { return nil }

175+ else { throw JSONError.missingOrInvalidType(path: nil, expected: .optional(.number), actual: .forValue(self)) }

176+ }

177+

178+ /// Returns the double value if the receiver is a number.

179+ /// - Returns: A `Double` value.

180+ /// - Throws: `JSONError` if the receiver is the wrong type.

181+ func getDouble() throws -> Double {

182+ guard let val = self.double else { throw JSONError.missingOrInvalidType(path: nil, expected: .required(.number), actual: .forValue(self)) }

183+ return val

184+ }

185+

186+ /// Returns the double value if the receiver is a number.

187+ /// - Returns: A `Double` value, or `nil` if the receiver is `null`.

188+ /// - Throws: `JSONError` if the receiver is the wrong type.

189+ func getDoubleOrNil() throws -> Double? {

190+ if let val = self.double { return val }

191+ else if isNull { return nil }

192+ else { throw JSONError.missingOrInvalidType(path: nil, expected: .optional(.number), actual: .forValue(self)) }

193+ }

194+

195+ /// Returns the object value if the receiver is an object.

196+ /// - Returns: An object value.

197+ /// - Throws: `JSONError` if the receiver is the wrong type.

198+ func getObject() throws -> JSONObject {

199+ guard let dict = self.object else { throw JSONError.missingOrInvalidType(path: nil, expected: .required(.object), actual: .forValue(self)) }

200+ return dict

201+ }

202+

203+ /// Returns the object value if the receiver is an object.

204+ /// - Returns: An object value, or `nil` if the receiver is `null`.

205+ /// - Throws: `JSONError` if the receiver is the wrong type.

206+ func getObjectOrNil() throws -> JSONObject? {

207+ if let dict = self.object { return dict }

208+ else if isNull { return nil }

209+ else { throw JSONError.missingOrInvalidType(path: nil, expected: .optional(.object), actual: .forValue(self)) }

210+ }

211+

212+ /// Returns the array value if the receiver is an array.

213+ /// - Returns: An array value.

214+ /// - Throws: `JSONError` if the receiver is the wrong type.

215+ func getArray() throws -> JSONArray {

216+ guard let ary = self.array else { throw JSONError.missingOrInvalidType(path: nil, expected: .required(.array), actual: .forValue(self)) }

217+ return ary

218+ }

219+

220+ /// Returns the array value if the receiver is an array.

221+ /// - Returns: An array value, or `nil` if the receiver is `null`.

222+ /// - Throws: `JSONError` if the receiver is the wrong type.

223+ func getArrayOrNil() throws -> JSONArray? {

224+ if let ary = self.array { return ary }

225+ else if isNull { return nil }

226+ else { throw JSONError.missingOrInvalidType(path: nil, expected: .optional(.array), actual: .forValue(self)) }

227+ }

228+}

229+

230+public extension JSON {

231+ /// Returns the receiver coerced to a string value.

232+ /// - Returns: A `String` value.

233+ /// - Throws: `JSONError` if the receiver is an object or array.

234+ func toString() throws -> String {

235+ return try toStringMaybeNil(.required(.string)) ?? "null"

236+ }

237+

238+ /// Returns the receiver coerced to a string value.

239+ /// - Returns: A `String` value, or `nil` if the receiver is `null`.

240+ /// - Throws: `JSONError` if the receiver is an object or array.

241+ func toStringOrNil() throws -> String? {

242+ return try toStringMaybeNil(.optional(.string))

243+ }

244+

245+ private func toStringMaybeNil(_ expected: JSONError.ExpectedType) throws -> String? {

246+ switch self {

247+ case .string(let s): return s

248+ case .null: return nil

249+ case .bool(let b): return String(b)

250+ case .int64(let i): return String(i)

251+ case .double(let d): return String(d)

252+ default: throw JSONError.missingOrInvalidType(path: nil, expected: expected, actual: .forValue(self))

253+ }

254+ }

255+

256+ /// Returns the receiver coerced to a 64-bit integral value.

257+ /// If the receiver is a floating-point value, the value will be truncated

258+ /// to an integer.

259+ /// - Returns: An `Int64` value`.

260+ /// - Throws: `JSONError` if the receiver is `null`, a boolean, an object,

261+ /// an array, a string that cannot be coerced to a 64-bit integral value,

262+ /// or a floating-point value that does not fit in 64 bits.

263+ func toInt64() throws -> Int64 {

264+ guard let val = try toInt64MaybeNil(.required(.number)) else {

265+ throw JSONError.missingOrInvalidType(path: nil, expected: .required(.number), actual: .null)

266+ }

267+ return val

268+ }

269+

270+ /// Returns the receiver coerced to a 64-bit integral value.

271+ /// If the receiver is a floating-point value, the value will be truncated

272+ /// to an integer.

273+ /// - Returns: An `Int64` value`, or `nil` if the receiver is `null`.

274+ /// - Throws: `JSONError` if the receiver is a boolean, an object, an array,

275+ /// a string that cannot be coerced to a 64-bit integral value,

276+ /// or a floating-point value that does not fit in 64 bits.

277+ func toInt64OrNil() throws -> Int64? {

278+ return try toInt64MaybeNil(.optional(.number))

279+ }

280+

281+ private func toInt64MaybeNil(_ expected: JSONError.ExpectedType) throws -> Int64? {

282+ switch self {

283+ case .int64(let i):

284+ return i

285+ case .double(let d):

286+ guard let val = convertDoubleToInt64(d) else {

287+ throw JSONError.outOfRangeDouble(path: nil, value: d, expected: Int64.self)

288+ }

289+ return val

290+ case .string(let s):

291+ if let i = Int64(s, radix: 10) {

292+ return i

293+ } else if let d = Double(s) {

294+ guard let val = convertDoubleToInt64(d) else {

295+ throw JSONError.outOfRangeDouble(path: nil, value: d, expected: Int64.self)

296+ }

297+ return val

298+ }

299+ case .null:

300+ return nil

301+ default:

302+ break

303+ }

304+ throw JSONError.missingOrInvalidType(path: nil, expected: expected, actual: .forValue(self))

305+ }

306+

307+ /// Returns the receiver coerced to an integral value.

308+ /// If the receiver is a floating-point value, the value will be truncated

309+ /// to an integer.

310+ /// - Returns: An `Int` value`.

311+ /// - Throws: `JSONError` if the receiver is `null`, a boolean, an object,

312+ /// an array, a string that cannot be coerced to an integral value,

313+ /// or a floating-point value that does not fit in an `Int`.

314+ func toInt() throws -> Int {

315+ let val = try toInt64()

316+ let truncated = Int(truncatingBitPattern: val)

317+ guard Int64(truncated) == val else { throw JSONError.outOfRangeInt64(path: nil, value: val, expected: Int.self) }

318+ return truncated

319+ }

320+

321+ /// Returns the receiver coerced to an integral value.

322+ /// If the receiver is a floating-point value, the value will be truncated

323+ /// to an integer.

324+ /// - Returns: An `Int` value`, or `nil` if the receiver is `null`.

325+ /// - Throws: `JSONError` if the receiver is a boolean, an object,

326+ /// an array, a string that cannot be coerced to an integral value,

327+ /// or a floating-point value that does not fit in an `Int`.

328+ func toIntOrNil() throws -> Int? {

329+ guard let val = try toInt64OrNil() else { return nil }

330+ let truncated = Int(truncatingBitPattern: val)

331+ guard Int64(truncated) == val else { throw JSONError.outOfRangeInt64(path: nil, value: val, expected: Int.self) }

332+ return truncated

333+ }

334+

335+ /// Returns the receiver coerced to a `Double`.

336+ /// - Returns: A `Double` value.

337+ /// - Throws: `JSONError` if the receiver is `null`, a boolean, an object, an array,

338+ /// or a string that cannot be coerced to a floating-point value.

339+ func toDouble() throws -> Double {

340+ guard let val = try toDoubleMaybeNil(.required(.number)) else {

341+ throw JSONError.missingOrInvalidType(path: nil, expected: .required(.number), actual: .null)

342+ }

343+ return val

344+ }

345+

346+ /// Returns the receiver coerced to a `Double`.

347+ /// - Returns: A `Double` value, or `nil` if the receiver is `null`.

348+ /// - Throws: `JSONError` if the receiver is a boolean, an object, an array,

349+ /// or a string that cannot be coerced to a floating-point value.

350+ func toDoubleOrNil() throws -> Double? {

351+ return try toDoubleMaybeNil(.optional(.number))

352+ }

353+

354+ private func toDoubleMaybeNil(_ expected: JSONError.ExpectedType) throws -> Double? {

355+ switch self {

356+ case .int64(let i): return Double(i)

357+ case .double(let d): return d

358+ case .string(let s): return Double(s)

359+ case .null: return nil

360+ default: throw JSONError.missingOrInvalidType(path: nil, expected: expected, actual: .forValue(self))

361+ }

362+ }

363+}

364+

365+// MARK: - Keyed accessors

366+public extension JSON {

367+ /// Subscripts the receiver with `key` and returns the result.

368+ /// - Parameter key: The key that's used to subscript the receiver.

369+ /// - Returns: A `Bool` value.

370+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

371+ /// the receiver is not an object.

372+ func getBool(_ key: String) throws -> Bool {

373+ let dict = try getObject()

374+ let value = try getRequired(dict, key: key, type: .string)

375+ return try scoped(key) { try value.getBool() }

376+ }

377+

378+ /// Subscripts the receiver with `key` and returns the result.

379+ /// - Parameter key: The key that's used to subscript the receiver.

380+ /// - Returns: A `Bool` value, or `nil` if the key doesn't exist or the value is `null`.

381+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an object.

382+ func getBoolOrNil(_ key: String) throws -> Bool? {

383+ let dict = try getObject()

384+ guard let value = dict[key] else { return nil }

385+ return try scoped(key) { try value.getBoolOrNil() }

386+ }

387+

388+ /// Subscripts the receiver with `key` and returns the result.

389+ /// - Parameter key: The key that's used to subscript the receiver.

390+ /// - Returns: A `String` value.

391+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

392+ /// the receiver is not an object.

393+ func getString(_ key: String) throws -> String {

394+ let dict = try getObject()

395+ let value = try getRequired(dict, key: key, type: .string)

396+ return try scoped(key) { try value.getString() }

397+ }

398+

399+ /// Subscripts the receiver with `key` and returns the result.

400+ /// - Parameter key: The key that's used to subscript the receiver.

401+ /// - Returns: A `String` value, or `nil` if the key doesn't exist or the value is `null`.

402+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an object.

403+ func getStringOrNil(_ key: String) throws -> String? {

404+ let dict = try getObject()

405+ guard let value = dict[key] else { return nil }

406+ return try scoped(key) { try value.getStringOrNil() }

407+ }

408+

409+ /// Subscripts the receiver with `key` and returns the result.

410+ /// - Parameter key: The key that's used to subscript the receiver.

411+ /// - Returns: An `Int64` value.

412+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

413+ /// the receiver is not an object.

414+ func getInt64(_ key: String) throws -> Int64 {

415+ let dict = try getObject()

416+ let value = try getRequired(dict, key: key, type: .number)

417+ return try scoped(key) { try value.getInt64() }

418+ }

419+

420+ /// Subscripts the receiver with `key` and returns the result.

421+ /// - Parameter key: The key that's used to subscript the receiver.

422+ /// - Returns: An `Int64` value, or `nil` if the key doesn't exist or the value is `null`.

423+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an object.

424+ func getInt64OrNil(_ key: String) throws -> Int64? {

425+ let dict = try getObject()

426+ guard let value = dict[key] else { return nil }

427+ return try scoped(key) { try value.getInt64OrNil() }

428+ }

429+

430+ /// Subscripts the receiver with `key` and returns the result.

431+ /// - Parameter key: The key that's used to subscript the receiver.

432+ /// - Returns: An `Int` value.

433+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type,

434+ /// or if the 64-bit integral value is too large to fit in an `Int`, or if

435+ /// the receiver is not an object.

436+ func getInt(_ key: String) throws -> Int {

437+ let dict = try getObject()

438+ let value = try getRequired(dict, key: key, type: .number)

439+ return try scoped(key) { try value.getInt() }

440+ }

441+

442+ /// Subscripts the receiver with `key` and returns the result.

443+ /// - Parameter key: The key that's used to subscript the receiver.

444+ /// - Returns: An `Int` value, or `nil` if the key doesn't exist or the value is `null`.

445+ /// - Throws: `JSONError` if the value has the wrong type, or if the 64-bit integral

446+ /// value is too large to fit in an `Int`, or if the receiver is not an object.

447+ func getIntOrNil(_ key: String) throws -> Int? {

448+ let dict = try getObject()

449+ guard let value = dict[key] else { return nil }

450+ return try scoped(key) { try value.getIntOrNil() }

451+ }

452+

453+ /// Subscripts the receiver with `key` and returns the result.

454+ /// - Parameter key: The key that's used to subscript the receiver.

455+ /// - Returns: A `Double` value.

456+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

457+ /// the receiver is not an object.

458+ func getDouble(_ key: String) throws -> Double {

459+ let dict = try getObject()

460+ let value = try getRequired(dict, key: key, type: .number)

461+ return try scoped(key) { try value.getDouble() }

462+ }

463+

464+ /// Subscripts the receiver with `key` and returns the result.

465+ /// - Parameter key: The key that's used to subscript the receiver.

466+ /// - Returns: A `Double` value, or `nil` if the key doesn't exist or the value is `null`.

467+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an object.

468+ func getDoubleOrNil(_ key: String) throws -> Double? {

469+ let dict = try getObject()

470+ guard let value = dict[key] else { return nil }

471+ return try scoped(key) { try value.getDoubleOrNil() }

472+ }

473+

474+ /// Subscripts the receiver with `key` and returns the result.

475+ /// - Note: Use `getObject(_:_:)` when using throwing accessors on the resulting

476+ /// object value to produce better errors.

477+ /// - Parameter key: The key that's used to subscript the receiver.

478+ /// - Returns: An object value.

479+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

480+ /// the receiver is not an object.

481+ /// - SeeAlso: `getObject(_:_:)`

482+ func getObject(_ key: String) throws -> JSONObject {

483+ return try getObject(key, { $0 })

484+ }

485+

486+ /// Subscripts the receiver with `key` and returns the result.

487+ /// - Note: Use `getObjectOrNil(_:_:)` when using throwing accessors on the resulting

488+ /// object value to produce better errors.

489+ /// - Parameter key: The key that's used to subscript the receiver.

490+ /// - Returns: An object value, or `nil` if the key doesn't exist or the value is `null`.

491+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an object.

492+ /// - SeeAlso: `getObjectOrNil(_:_:)`

493+ func getObjectOrNil(_ key: String) throws -> JSONObject? {

494+ return try getObjectOrNil(key, { $0 })

495+ }

496+

497+ /// Subscripts the receiver with `key` and passes the result to the given block.

498+ /// - Parameter key: The key that's used to subscript the receiver.

499+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `key`.

500+ /// - Returns: The result of calling the given block.

501+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

502+ /// the receiver is not an object, or any error thrown by `transform`.

503+ func getObject<T>(_ key: String, _ transform: (JSONObject) throws -> T) throws -> T {

504+ return try getObject().getObject(key, transform)

505+ }

506+

507+ /// Subscripts the receiver with `key` and passes the result to the given block.

508+ /// - Parameter key: The key that's used to subscript the receiver.

509+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `key`.

510+ /// - Returns: The result of calling the given block, or `nil` if the key doesn't exist or the value is `null`.

511+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an object,

512+ /// or any error thrown by `transform`.

513+ func getObjectOrNil<T>(_ key: String, _ transform: (JSONObject) throws -> T?) throws -> T? {

514+ return try getObject().getObjectOrNil(key, transform)

515+ }

516+

517+ /// Subscripts the receiver with `key` and returns the result.

518+ /// - Note: Use `getArray(_:_:)` when using throwing accessors on the resulting

519+ /// array value to produce better errors.

520+ /// - Parameter key: The key that's used to subscript the receiver.

521+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

522+ /// the receiver is not an object.

523+ /// - SeeAlso: `getArray(_:_:)`

524+ func getArray(_ key: String) throws -> JSONArray {

525+ return try getArray(key, { $0 })

526+ }

527+

528+ /// Subscripts the receiver with `key` and returns the result.

529+ /// - Note: Use `getArrayOrNil(_:_:)` when using throwing accessors on the resulting

530+ /// array value to produce better errors.

531+ /// - Parameter key: The key that's used to subscript the receiver.

532+ /// - Returns: An array value, or `nil` if the key doesn't exist or the value is `null`.

533+ /// - Throws: `JSONError` if the value has the wrong type.

534+ /// - SeeAlso: `getArrayOrNil(_:_:)`

535+ func getArrayOrNil(_ key: String) throws -> JSONArray? {

536+ return try getArrayOrNil(key, { $0 })

537+ }

538+

539+ /// Subscripts the receiver with `key` and passes the result to the given block.

540+ /// - Parameter key: The key that's used to subscript the receiver.

541+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `key`.

542+ /// - Returns: The result of calling the given block.

543+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or if

544+ /// the receiver is not an object, or any error thrown by `transform`.

545+ func getArray<T>(_ key: String, _ transform: (JSONArray) throws -> T) throws -> T {

546+ let dict = try getObject()

547+ let value = try getRequired(dict, key: key, type: .array)

548+ return try scoped(key) { try transform(value.getArray()) }

549+ }

550+

551+ /// Subscripts the receiver with `key` and passes the result to the given block.

552+ /// - Parameter key: The key that's used to subscript the receiver.

553+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `key`.

554+ /// - Returns: The result of calling the given block, or `nil` if the key doesn't exist or the value is `null`.

555+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an object,

556+ /// or any error thrown by `transform`.

557+ func getArrayOrNil<T>(_ key: String, _ transform: (JSONArray) throws -> T?) throws -> T? {

558+ let dict = try getObject()

559+ guard let value = dict[key] else { return nil }

560+ return try scoped(key) { try value.getArrayOrNil().flatMap(transform) }

561+ }

562+}

563+

564+public extension JSON {

565+ /// Subscripts the receiver with `key` and returns the result coerced to a `String`.

566+ /// - Parameter key: The key that's used to subscript the receiver.

567+ /// - Returns: A `String` value.

568+ /// - Throws: `JSONError` if the key doesn't exist, the value is an object or an array,

569+ /// or if the receiver is not an object.

570+ /// - SeeAlso: `toString()`.

571+ func toString(_ key: String) throws -> String {

572+ let dict = try getObject()

573+ let value = try getRequired(dict, key: key, type: .string)

574+ return try scoped(key) { try value.toString() }

575+ }

576+

577+ /// Subscripts the receiver with `key` and returns the result coerced to a `String`.

578+ /// - Parameter key: The key that's used to subscript the receiver.

579+ /// - Returns: A `String` value, or `nil` if the key doesn't exist or the value is `null`.

580+ /// - Throws: `JSONError` if the value is an object or an array, or if the receiver is not an object.

581+ /// - SeeAlso: `toStringOrNil()`.

582+ func toStringOrNil(_ key: String) throws -> String? {

583+ let dict = try getObject()

584+ guard let value = dict[key] else { return nil }

585+ return try scoped(key) { try value.toStringOrNil() }

586+ }

587+

588+ /// Subscripts the receiver with `key` and returns the result coerced to an `Int64`.

589+ /// - Parameter key: The key that's used to subscript the receiver.

590+ /// - Returns: An `Int64` value.

591+ /// - Throws: `JSONError` if the key doesn't exist or the value is `null`, a boolean, an object,

592+ /// an array, a string that cannot be coerced to a 64-bit integral value, or a floating-point

593+ /// value that does not fit in 64 bits, or if the receiver is not an object.

594+ func toInt64(_ key: String) throws -> Int64 {

595+ let dict = try getObject()

596+ let value = try getRequired(dict, key: key, type: .number)

597+ return try scoped(key) { try value.toInt64() }

598+ }

599+

600+ /// Subscripts the receiver with `key` and returns the result coerced to an `Int64`.

601+ /// - Parameter key: The key that's used to subscript the receiver.

602+ /// - Returns: An `Int64` value, or `nil` if the key doesn't exist or the value is `null`.

603+ /// - Throws: `JSONError` if the the value is a boolean, an object, an array, a string

604+ /// that cannot be coerced to a 64-bit integral value, or a floating-point value

605+ /// that does not fit in 64 bits, or if the receiver is not an object.

606+ func toInt64OrNil(_ key: String) throws -> Int64? {

607+ let dict = try getObject()

608+ guard let value = dict[key] else { return nil }

609+ return try scoped(key) { try value.toInt64OrNil() }

610+ }

611+

612+ /// Subscripts the receiver with `key` and returns the result coerced to an `Int`.

613+ /// - Parameter key: The key that's used to subscript the receiver.

614+ /// - Returns: An `Int` value.

615+ /// - Throws: `JSONError` if the key doesn't exist or the value is `null`, a boolean, an object,

616+ /// an array, a string that cannot be coerced to an integral value, or a floating-point

617+ /// value that does not fit in an `Int`, or if the receiver is not an object.

618+ func toInt(_ key: String) throws -> Int {

619+ let dict = try getObject()

620+ let value = try getRequired(dict, key: key, type: .number)

621+ return try scoped(key) { try value.toInt() }

622+ }

623+

624+ /// Subscripts the receiver with `key` and returns the result coerced to an `Int`.

625+ /// - Parameter key: The key that's used to subscript the receiver.

626+ /// - Returns: An `Int` value, or `nil` if the key doesn't exist or the value is `null`.

627+ /// - Throws: `JSONError` if the the value is a boolean, an object, an array, a string

628+ /// that cannot be coerced to an integral value, or a floating-point value

629+ /// that does not fit in an `Int`, or if the receiver is not an object.

630+ func toIntOrNil(_ key: String) throws -> Int? {

631+ let dict = try getObject()

632+ guard let value = dict[key] else { return nil }

633+ return try scoped(key) { try value.toIntOrNil() }

634+ }

635+

636+ /// Subscripts the receiver with `key` and returns the result coerced to a `Double`.

637+ /// - Parameter key: The key that's used to subscript the receiver.

638+ /// - Returns: A `Double` value.

639+ /// - Throws: `JSONError` if the key doesn't exist or the value is `null`, a boolean,

640+ /// an object, an array, or a string that cannot be coerced to a floating-point value,

641+ /// or if the receiver is not an object.

642+ func toDouble(_ key: String) throws -> Double {

643+ let dict = try getObject()

644+ let value = try getRequired(dict, key: key, type: .number)

645+ return try scoped(key) { try value.toDouble() }

646+ }

647+

648+ /// Subscripts the receiver with `key` and returns the result coerced to a `Double`.

649+ /// - Parameter key: The key that's used to subscript the receiver.

650+ /// - Returns: A `Double` value, or `nil` if the key doesn't exist or the value is `null`.

651+ /// - Throws: `JSONError` if the value is a boolean, an object, an array, or a string that

652+ /// cannot be coerced to a floating-point value, or if the receiver is not an object.

653+ func toDoubleOrNil(_ key: String) throws -> Double? {

654+ let dict = try getObject()

655+ guard let value = dict[key] else { return nil }

656+ return try scoped(key) { try value.toDoubleOrNil() }

657+ }

658+}

659+

660+// MARK: - Indexed accessors

661+public extension JSON {

662+ /// Subscripts the receiver with `index` and returns the result.

663+ /// - Parameter index: The index that's used to subscript the receiver.

664+ /// - Returns: A `Bool` value.

665+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type,

666+ /// or if the receiver is not an array.

667+ func getBool(_ index: Int) throws -> Bool {

668+ let ary = try getArray()

669+ let value = try getRequired(ary, index: index, type: .bool)

670+ return try scoped(index) { try value.getBool() }

671+ }

672+

673+ /// Subscripts the receiver with `index` and returns the result.

674+ /// - Parameter index: The index that's used to subscript the receiver.

675+ /// - Returns: A `Bool` value, or `nil` if the index is out of bounds or the value is `null`.

676+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an array.

677+ func getBoolOrNil(_ index: Int) throws -> Bool? {

678+ let ary = try getArray()

679+ guard let value = ary[safe: index] else { return nil }

680+ return try scoped(index) { try value.getBoolOrNil() }

681+ }

682+

683+ /// Subscripts the receiver with `index` and returns the result.

684+ /// - Parameter index: The index that's used to subscript the receiver.

685+ /// - Returns: A `String` value.

686+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type,

687+ /// or if the receiver is not an array.

688+ func getString(_ index: Int) throws -> String {

689+ let ary = try getArray()

690+ let value = try getRequired(ary, index: index, type: .string)

691+ return try scoped(index) { try value.getString() }

692+ }

693+

694+ /// Subscripts the receiver with `index` and returns the result.

695+ /// - Parameter index: The index that's used to subscript the receiver.

696+ /// - Returns: A `String` value, or `nil` if the index is out of bounds or the value is `null`.

697+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an array.

698+ func getStringOrNil(_ index: Int) throws -> String? {

699+ let ary = try getArray()

700+ guard let value = ary[safe: index] else { return nil }

701+ return try scoped(index) { try value.getStringOrNil() }

702+ }

703+

704+ /// Subscripts the receiver with `index` and returns the result.

705+ /// - Parameter index: The index that's used to subscript the receiver.

706+ /// - Returns: An `Int64` value.

707+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type,

708+ /// or if the receiver is not an array.

709+ func getInt64(_ index: Int) throws -> Int64 {

710+ let ary = try getArray()

711+ let value = try getRequired(ary, index: index, type: .number)

712+ return try scoped(index) { try value.getInt64() }

713+ }

714+

715+ /// Subscripts the receiver with `index` and returns the result.

716+ /// - Parameter index: The index that's used to subscript the receiver.

717+ /// - Returns: An `Int64` value, or `nil` if the index is out of bounds or the value is `null`.

718+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an array.

719+ func getInt64OrNil(_ index: Int) throws -> Int64? {

720+ let ary = try getArray()

721+ guard let value = ary[safe: index] else { return nil }

722+ return try scoped(index) { try value.getInt64OrNil() }

723+ }

724+

725+ /// Subscripts the receiver with `index` and returns the result.

726+ /// - Parameter index: The index that's used to subscript the receiver.

727+ /// - Returns: An `Int` value.

728+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type,

729+ /// or if the 64-bit integral value is too large to fit in an `Int`, or if

730+ /// the receiver is not an array.

731+ func getInt(_ index: Int) throws -> Int {

732+ let ary = try getArray()

733+ let value = try getRequired(ary, index: index, type: .number)

734+ return try scoped(index) { try value.getInt() }

735+ }

736+

737+ /// Subscripts the receiver with `index` and returns the result.

738+ /// - Parameter index: The index that's used to subscript the receiver.

739+ /// - Returns: An `Int` value, or `nil` if the index is out of bounds or the value is `null`.

740+ /// - Throws: `JSONError` if the value has the wrong type, or if the 64-bit integral value

741+ /// is too large to fit in an `Int`, or if the receiver is not an array.

742+ func getIntOrNil(_ index: Int) throws -> Int? {

743+ let ary = try getArray()

744+ guard let value = ary[safe: index] else { return nil }

745+ return try scoped(index) { try value.getIntOrNil() }

746+ }

747+

748+ /// Subscripts the receiver with `index` and returns the result.

749+ /// - Parameter index: The index that's used to subscript the receiver.

750+ /// - Returns: A `Double` value.

751+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type,

752+ /// or if the receiver is not an array.

753+ func getDouble(_ index: Int) throws -> Double {

754+ let ary = try getArray()

755+ let value = try getRequired(ary, index: index, type: .number)

756+ return try scoped(index) { try value.getDouble() }

757+ }

758+

759+ /// Subscripts the receiver with `index` and returns the result.

760+ /// - Parameter index: The index that's used to subscript the receiver.

761+ /// - Returns: A `Double` value, or `nil` if the index is out of bounds or the value is `null`.

762+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an array.

763+ func getDoubleOrNil(_ index: Int) throws -> Double? {

764+ let ary = try getArray()

765+ guard let value = ary[safe: index] else { return nil }

766+ return try scoped(index) { try value.getDoubleOrNil() }

767+ }

768+

769+ /// Subscripts the receiver with `index` and returns the result.

770+ /// - Note: Use `getObject(_:_:)` when using throwing accessors on the resulting

771+ /// object value to produce better errors.

772+ /// - Parameter index: The index that's used to subscript the receiver.

773+ /// - Returns: An object value.

774+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type,

775+ /// or if the receiver is not an array.

776+ /// - SeeAlso: `getObject(_:_:)`

777+ func getObject(_ index: Int) throws -> JSONObject {

778+ return try getObject(index, { $0 })

779+ }

780+

781+ /// Subscripts the receiver with `index` and returns the result.

782+ /// - Note: Use `getObjectOrNil(_:_:)` when using throwing accessors on the resulting

783+ /// object value to produce better errors.

784+ /// - Parameter index: The index that's used to subscript the receiver.

785+ /// - Returns: An object value, or `nil` if the index is out of bounds or the value is `null`.

786+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an array.

787+ /// - SeeAlso: `getObjectOrNil(_:_:)`

788+ func getObjectOrNil(_ index: Int) throws -> JSONObject? {

789+ return try getObjectOrNil(index, { $0 })

790+ }

791+

792+ /// Subscripts the receiver with `index` and passes the result to the given block.

793+ /// - Parameter index: The index that's used to subscript the receiver.

794+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `index`.

795+ /// - Returns: The result of calling the given block.

796+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type,

797+ /// or if the receiver is not an array, or any error thrown by `transform`.

798+ func getObject<T>(_ index: Int, _ f: (JSONObject) throws -> T) throws -> T {

799+ let ary = try getArray()

800+ let value = try getRequired(ary, index: index, type: .object)

801+ return try scoped(index) { try f(value.getObject()) }

802+ }

803+

804+ /// Subscripts the receiver with `index` and passes the result to the given block.

805+ /// - Parameter index: The index that's used to subscript the receiver.

806+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `index`.

807+ /// - Returns: The result of calling the given block, or `nil` if the index is out of bounds or the value is `null`.

808+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an array,

809+ //// or any error thrown by `transform`.

810+ func getObjectOrNil<T>(_ index: Int, _ f: (JSONObject) throws -> T?) throws -> T? {

811+ let ary = try getArray()

812+ guard let value = ary[safe: index] else { return nil }

813+ return try scoped(index) { try value.getObjectOrNil().flatMap(f) }

814+ }

815+

816+ /// Subscripts the receiver with `index` and returns the result.

817+ /// - Note: Use `getArray(_:_:)` when using throwing accessors on the resulting

818+ /// array value to produce better errors.

819+ /// - Parameter index: The index that's used to subscript the receiver.

820+ /// - Returns: An array value.

821+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type,

822+ /// or if the receiver is not an array.

823+ /// - SeeAlso: `getArray(_:_:)`

824+ func getArray(_ index: Int) throws -> JSONArray {

825+ return try getArray(index, { $0 })

826+ }

827+

828+ /// Subscripts the receiver with `index` and returns the result.

829+ /// - Note: Use `getArrayOrNil(_:_:)` when using throwing accessors on the resulting

830+ /// array value to produce better errors.

831+ /// - Parameter index: The index that's used to subscript the receiver.

832+ /// - Returns: An array value, or `nil` if the index is out of bounds or the value is `null`.

833+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an array.

834+ /// - SeeAlso: `getArrayOrNil(_:_:)`

835+ func getArrayOrNil(_ index: Int) throws -> JSONArray? {

836+ return try getArrayOrNil(index, { $0 })

837+ }

838+

839+ /// Subscripts the receiver with `index` and passes the result to the given block.

840+ /// - Parameter index: The index that's used to subscript the receiver.

841+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `index`.

842+ /// - Returns: The result of calling the given block.

843+ /// - Throws: `JSONError` if the index is out of bounds or the value is the wrong type,

844+ /// or if the receiver is not an array, or any error thrown by `transform`.

845+ func getArray<T>(_ index: Int, _ f: (JSONArray) throws -> T) throws -> T {

846+ let ary = try getArray()

847+ let value = try getRequired(ary, index: index, type: .array)

848+ return try scoped(index) { try f(value.getArray()) }

849+ }

850+

851+ /// Subscripts the receiver with `index` and passes the result to the given block.

852+ /// - Parameter index: The index that's used to subscript the receiver.

853+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `index`.

854+ /// - Returns: The result of calling the given block, or `nil` if the index is out of bounds or the value is `null`.

855+ /// - Throws: `JSONError` if the value has the wrong type, or if the receiver is not an array,

856+ /// or any error thrown by `transform`.

857+ func getArrayOrNil<T>(_ index: Int, _ f: (JSONArray) throws -> T?) throws -> T? {

858+ let ary = try getArray()

859+ guard let value = ary[safe: index] else { return nil }

860+ return try scoped(index) { try value.getArrayOrNil().flatMap(f) }

861+ }

862+}

863+

864+public extension JSON {

865+ /// Subscripts the receiver with `index` and returns the result coerced to a `String`.

866+ /// - Parameter index: The index that's used to subscript the receiver.

867+ /// - Returns: A `String` value.

868+ /// - Throws: `JSONError` if the index is out of bounds or the value is an object or an array,

869+ /// or if the receiver is not an array.

870+ /// - SeeAlso: `toString()`.

871+ func toString(_ index: Int) throws -> String {

872+ let ary = try getArray()

873+ let value = try getRequired(ary, index: index, type: .string)

874+ return try scoped(index) { try value.toString() }

875+ }

876+

877+ /// Subscripts the receiver with `index` and returns the result coerced to a `String`.

878+ /// - Parameter index: The index that's used to subscript the receiver.

879+ /// - Returns: A `String` value, or `nil` if the index is out of bounds or the value is `null`.

880+ /// - Throws: `JSONError` if the value is an object or an array, or if the receiver is not an array.

881+ /// - SeeAlso: `toStringOrNil()`.

882+ func toStringOrNil(_ index: Int) throws -> String? {

883+ let ary = try getArray()

884+ guard let value = ary[safe: index] else { return nil }

885+ return try scoped(index) { try value.toStringOrNil() }

886+ }

887+

888+ /// Subscripts the receiver with `index` and returns the result coerced to an `Int64`.

889+ /// - Parameter index: The index that's used to subscript the receiver.

890+ /// - Returns: An `Int64` value.

891+ /// - Throws: `JSONError` if the index is out of bounds or the value is `null`, a boolean,

892+ /// an object, an array, a string that cannot be coerced to a 64-bit integral value, or a

893+ /// floating-point value that does not fit in 64 bits, or if the receiver is not an array.

894+ /// - SeeAlso: `toInt64()`.

895+ func toInt64(_ index: Int) throws -> Int64 {

896+ let ary = try getArray()

897+ let value = try getRequired(ary, index: index, type: .number)

898+ return try scoped(index) { try value.toInt64() }

899+ }

900+

901+ /// Subscripts the receiver with `index` and returns the result coerced to an `Int64`.

902+ /// - Parameter index: The index that's used to subscript the receiver.

903+ /// - Returns: An `Int64` value, or `nil` if the index is out of bounds or the value is `null`.

904+ /// - Throws: `JSONError` if the the value is a boolean, an object, an array, a string

905+ /// that cannot be coerced to a 64-bit integral value, or a floating-point value

906+ /// that does not fit in 64 bits, or if the receiver is not an array.

907+ /// - SeeAlso: `toInt64OrNil()`.

908+ func toInt64OrNil(_ index: Int) throws -> Int64? {

909+ let ary = try getArray()

910+ guard let value = ary[safe: index] else { return nil }

911+ return try scoped(index) { try value.toInt64OrNil() }

912+ }

913+

914+ /// Subscripts the receiver with `index` and returns the result coerced to an `Int`.

915+ /// - Parameter index: The index that's used to subscript the receiver.

916+ /// - Returns: An `Int` value.

917+ /// - Throws: `JSONError` if the index is out of bounds or the value is `null`, a boolean,

918+ /// an object, an array, a string that cannot be coerced to an integral value, or a

919+ /// floating-point value that does not fit in an `Int`, or if the receiver is not an array.

920+ /// - SeeAlso: `toInt()`.

921+ func toInt(_ index: Int) throws -> Int {

922+ let ary = try getArray()

923+ let value = try getRequired(ary, index: index, type: .number)

924+ return try scoped(index) { try value.toInt() }

925+ }

926+

927+ /// Subscripts the receiver with `index` and returns the result coerced to an `Int`.

928+ /// - Parameter index: The index that's used to subscript the receiver.

929+ /// - Returns: An `Int` value, or `nil` if the index is out of bounds or the value is `null`.

930+ /// - Throws: `JSONError` if the the value is a boolean, an object, an array, a string

931+ /// that cannot be coerced to an integral value, or a floating-point value

932+ /// that does not fit in an `Int`, or if the receiver is not an array.

933+ /// - SeeAlso: `toIntOrNil()`.

934+ func toIntOrNil(_ index: Int) throws -> Int? {

935+ let ary = try getArray()

936+ guard let value = ary[safe: index] else { return nil }

937+ return try scoped(index) { try value.toIntOrNil() }

938+ }

939+

940+ /// Subscripts the receiver with `index` and returns the result coerced to a `Double`.

941+ /// - Parameter index: The index that's used to subscript the receiver.

942+ /// - Returns: A `Double` value.

943+ /// - Throws: `JSONError` if the index is out of bounds or the value is `null`, a boolean,

944+ /// an object, an array, or a string that cannot be coerced to a floating-point value,

945+ /// or if the receiver is not an array.

946+ /// - SeeAlso: `toDouble()`.

947+ func toDouble(_ index: Int) throws -> Double {

948+ let ary = try getArray()

949+ let value = try getRequired(ary, index: index, type: .number)

950+ return try scoped(index) { try value.toDouble() }

951+ }

952+

953+ /// Subscripts the receiver with `index` and returns the result coerced to a `Double`.

954+ /// - Parameter index: The index that's used to subscript the receiver.

955+ /// - Returns: A `Double` value, or `nil` if the index is out of bounds or the value is `null`.

956+ /// - Throws: `JSONError` if the value is a boolean, an object, an array, or a string that

957+ /// cannot be coerced to a floating-point value, or if the receiver is not an array.

958+ /// - SeeAlso: `toDouble()`.

959+ func toDoubleOrNil(_ index: Int) throws -> Double? {

960+ let ary = try getArray()

961+ guard let value = ary[safe: index] else { return nil }

962+ return try scoped(index) { try value.toDoubleOrNil() }

963+ }

964+}

965+

966+// MARK: -

967+

968+public extension JSONObject {

969+ /// Subscripts the receiver with `key` and returns the result.

970+ /// - Parameter key: The key that's used to subscript the receiver.

971+ /// - Returns: A `Bool` value.

972+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type.

973+ func getBool(_ key: String) throws -> Bool {

974+ let value = try getRequired(self, key: key, type: .string)

975+ return try scoped(key) { try value.getBool() }

976+ }

977+

978+ /// Subscripts the receiver with `key` and returns the result.

979+ /// - Parameter key: The key that's used to subscript the receiver.

980+ /// - Returns: A `Bool` value, or `nil` if the key doesn't exist or the value is `null`.

981+ /// - Throws: `JSONError` if the value has the wrong type.

982+ func getBoolOrNil(_ key: String) throws -> Bool? {

983+ guard let value = self[key] else { return nil }

984+ return try scoped(key) { try value.getBoolOrNil() }

985+ }

986+

987+ /// Subscripts the receiver with `key` and returns the result.

988+ /// - Parameter key: The key that's used to subscript the receiver.

989+ /// - Returns: A `String` value.

990+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type.

991+ func getString(_ key: String) throws -> String {

992+ let value = try getRequired(self, key: key, type: .string)

993+ return try scoped(key) { try value.getString() }

994+ }

995+

996+ /// Subscripts the receiver with `key` and returns the result.

997+ /// - Parameter key: The key that's used to subscript the receiver.

998+ /// - Returns: A `String` value, or `nil` if the key doesn't exist or the value is `null`.

999+ /// - Throws: `JSONError` if the value has the wrong type.

1000+ func getStringOrNil(_ key: String) throws -> String? {

1001+ guard let value = self[key] else { return nil }

1002+ return try scoped(key) { try value.getStringOrNil() }

1003+ }

1004+

1005+ /// Subscripts the receiver with `key` and returns the result.

1006+ /// - Parameter key: The key that's used to subscript the receiver.

1007+ /// - Returns: An `Int64` value.

1008+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type.

1009+ func getInt64(_ key: String) throws -> Int64 {

1010+ let value = try getRequired(self, key: key, type: .number)

1011+ return try scoped(key) { try value.getInt64() }

1012+ }

1013+

1014+ /// Subscripts the receiver with `key` and returns the result.

1015+ /// - Parameter key: The key that's used to subscript the receiver.

1016+ /// - Returns: An `Int64` value, or `nil` if the key doesn't exist or the value is `null`.

1017+ /// - Throws: `JSONError` if the value has the wrong type.

1018+ func getInt64OrNil(_ key: String) throws -> Int64? {

1019+ guard let value = self[key] else { return nil }

1020+ return try scoped(key) { try value.getInt64OrNil() }

1021+ }

1022+

1023+ /// Subscripts the receiver with `key` and returns the result.

1024+ /// - Parameter key: The key that's used to subscript the receiver.

1025+ /// - Returns: An `Int` value.

1026+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type,

1027+ /// or if the 64-bit integral value is too large to fit in an `Int`.

1028+ func getInt(_ key: String) throws -> Int {

1029+ let value = try getRequired(self, key: key, type: .number)

1030+ return try scoped(key) { try value.getInt() }

1031+ }

1032+

1033+ /// Subscripts the receiver with `key` and returns the result.

1034+ /// - Parameter key: The key that's used to subscript the receiver.

1035+ /// - Returns: An `Int` value, or `nil` if the key doesn't exist or the value is `null`.

1036+ /// - Throws: `JSONError` if the value has the wrong type, or if the 64-bit integral

1037+ /// value is too large to fit in an `Int`.

1038+ func getIntOrNil(_ key: String) throws -> Int? {

1039+ guard let value = self[key] else { return nil }

1040+ return try scoped(key) { try value.getIntOrNil() }

1041+ }

1042+

1043+ /// Subscripts the receiver with `key` and returns the result.

1044+ /// - Parameter key: The key that's used to subscript the receiver.

1045+ /// - Returns: A `Double` value.

1046+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type.

1047+ func getDouble(_ key: String) throws -> Double {

1048+ let value = try getRequired(self, key: key, type: .number)

1049+ return try scoped(key) { try value.getDouble() }

1050+ }

1051+

1052+ /// Subscripts the receiver with `key` and returns the result.

1053+ /// - Parameter key: The key that's used to subscript the receiver.

1054+ /// - Returns: A `Double` value, or `nil` if the key doesn't exist or the value is `null`.

1055+ /// - Throws: `JSONError` if the value has the wrong type.

1056+ func getDoubleOrNil(_ key: String) throws -> Double? {

1057+ guard let value = self[key] else { return nil }

1058+ return try scoped(key) { try value.getDoubleOrNil() }

1059+ }

1060+

1061+ /// Subscripts the receiver with `key` and returns the result.

1062+ /// - Note: Use `getObject(_:_:)` when using throwing accessors on the resulting

1063+ /// object value to produce better errors.

1064+ /// - Parameter key: The key that's used to subscript the receiver.

1065+ /// - Returns: An object value.

1066+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type.

1067+ /// - SeeAlso: `getObject(_:_:)`

1068+ func getObject(_ key: String) throws -> JSONObject {

1069+ return try getObject(key, { $0 })

1070+ }

1071+

1072+ /// Subscripts the receiver with `key` and returns the result.

1073+ /// - Note: Use `getObjectOrNil(_:_:)` when using throwing accessors on the resulting

1074+ /// object value to produce better errors.

1075+ /// - Parameter key: The key that's used to subscript the receiver.

1076+ /// - Returns: An object value, or `nil` if the key doesn't exist or the value is `null`.

1077+ /// - Throws: `JSONError` if the value has the wrong type.

1078+ /// - SeeAlso: `getObjectOrNil(_:_:)`

1079+ func getObjectOrNil(_ key: String) throws -> JSONObject? {

1080+ return try getObjectOrNil(key, { $0 })

1081+ }

1082+

1083+ /// Subscripts the receiver with `key` and passes the result to the given block.

1084+ /// - Parameter key: The key that's used to subscript the receiver.

1085+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `key`.

1086+ /// - Returns: The result of calling the given block.

1087+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or any

1088+ /// error thrown by `transform`.

1089+ func getObject<T>(_ key: String, _ f: (JSONObject) throws -> T) throws -> T {

1090+ let value = try getRequired(self, key: key, type: .object)

1091+ return try scoped(key) { try f(value.getObject()) }

1092+ }

1093+

1094+ /// Subscripts the receiver with `key` and passes the result to the given block.

1095+ /// - Parameter key: The key that's used to subscript the receiver.

1096+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `key`.

1097+ /// - Returns: The result of calling the given block, or `nil` if the key doesn't exist or the value is `null`.

1098+ /// - Throws: `JSONError` if the value has the wrong type, or any error thrown by `transform`.

1099+ func getObjectOrNil<T>(_ key: String, _ f: (JSONObject) throws -> T?) throws -> T? {

1100+ guard let value = self[key] else { return nil }

1101+ return try scoped(key) { try value.getObjectOrNil().flatMap(f) }

1102+ }

1103+

1104+ /// Subscripts the receiver with `key` and returns the result.

1105+ /// - Note: Use `getArray(_:_:)` when using throwing accessors on the resulting

1106+ /// array value to produce better errors.

1107+ /// - Parameter key: The key that's used to subscript the receiver.

1108+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type.

1109+ /// - SeeAlso: `getArray(_:_:)`

1110+ func getArray(_ key: String) throws -> JSONArray {

1111+ return try getArray(key, { $0 })

1112+ }

1113+

1114+ /// Subscripts the receiver with `key` and returns the result.

1115+ /// - Note: Use `getArrayOrNil(_:_:)` when using throwing accessors on the resulting

1116+ /// array value to produce better errors.

1117+ /// - Parameter key: The key that's used to subscript the receiver.

1118+ /// - Returns: An array value, or `nil` if the key doesn't exist or the value is `null`.

1119+ /// - Throws: `JSONError` if the value has the wrong type.

1120+ /// - SeeAlso: `getArrayOrNil(_:_:)`

1121+ func getArrayOrNil(_ key: String) throws -> JSONArray? {

1122+ return try getArrayOrNil(key, { $0 })

1123+ }

1124+

1125+ /// Subscripts the receiver with `key` and passes the result to the given block.

1126+ /// - Parameter key: The key that's used to subscript the receiver.

1127+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `key`.

1128+ /// - Returns: The result of calling the given block.

1129+ /// - Throws: `JSONError` if the key doesn't exist or the value is the wrong type, or any

1130+ /// error thrown by `transform`.

1131+ func getArray<T>(_ key: String, _ f: (JSONArray) throws -> T) throws -> T {

1132+ let value = try getRequired(self, key: key, type: .array)

1133+ return try scoped(key) { try f(value.getArray()) }

1134+ }

1135+

1136+ /// Subscripts the receiver with `key` and passes the result to the given block.

1137+ /// - Parameter key: The key that's used to subscript the receiver.

1138+ /// - Parameter transform: A block that's called with the result of subscripting the receiver with `key`.

1139+ /// - Returns: The result of calling the given block, or `nil` if the key doesn't exist or the value is `null`.

1140+ /// - Throws: `JSONError` if the value has the wrong type, or any error thrown by `transform`.

1141+ func getArrayOrNil<T>(_ key: String, _ f: (JSONArray) throws -> T?) throws -> T? {

1142+ guard let value = self[key] else { return nil }

1143+ return try scoped(key) { try value.getArrayOrNil().flatMap(f) }

1144+ }

1145+}

1146+

1147+public extension JSONObject {

1148+ /// Subscripts the receiver with `key` and returns the result coerced to a `String`.

1149+ /// - Parameter key: The key that's used to subscript the receiver.

1150+ /// - Returns: A `String` value.

1151+ /// - Throws: `JSONError` if the key doesn't exist, the value is an object or an array,

1152+ /// or if the receiver is not an object.

1153+ /// - SeeAlso: `toString()`.

1154+ func toString(_ key: String) throws -> String {

1155+ let value = try getRequired(self, key: key, type: .string)

1156+ return try scoped(key) { try value.toString() }

1157+ }

1158+

1159+ /// Subscripts the receiver with `key` and returns the result coerced to a `String`.

1160+ /// - Parameter key: The key that's used to subscript the receiver.

1161+ /// - Returns: A `String` value, or `nil` if the key doesn't exist or the value is `null`.

1162+ /// - Throws: `JSONError` if the value is an object or an array, or if the receiver is not an object.

1163+ /// - SeeAlso: `toStringOrNil()`.

1164+ func toStringOrNil(_ key: String) throws -> String? {

1165+ guard let value = self[key] else { return nil }

1166+ return try scoped(key) { try value.toStringOrNil() }

1167+ }

1168+

1169+ /// Subscripts the receiver with `key` and returns the result coerced to an `Int64`.

1170+ /// - Parameter key: The key that's used to subscript the receiver.

1171+ /// - Returns: An `Int64` value.

1172+ /// - Throws: `JSONError` if the key doesn't exist or the value is `null`, a boolean, an object,

1173+ /// an array, a string that cannot be coerced to a 64-bit integral value, or a floating-point

1174+ /// value that does not fit in 64 bits, or if the receiver is not an object.

1175+ func toInt64(_ key: String) throws -> Int64 {

1176+ let value = try getRequired(self, key: key, type: .number)

1177+ return try scoped(key) { try value.toInt64() }

1178+ }

1179+

1180+ /// Subscripts the receiver with `key` and returns the result coerced to an `Int64`.

1181+ /// - Parameter key: The key that's used to subscript the receiver.

1182+ /// - Returns: An `Int64` value, or `nil` if the key doesn't exist or the value is `null`.

1183+ /// - Throws: `JSONError` if the the value is a boolean, an object, an array, a string

1184+ /// that cannot be coerced to a 64-bit integral value, or a floating-point value

1185+ /// that does not fit in 64 bits, or if the receiver is not an object.

1186+ func toInt64OrNil(_ key: String) throws -> Int64? {

1187+ guard let value = self[key] else { return nil }

1188+ return try scoped(key) { try value.toInt64OrNil() }

1189+ }

1190+

1191+ /// Subscripts the receiver with `key` and returns the result coerced to an `Int`.

1192+ /// - Parameter key: The key that's used to subscript the receiver.

1193+ /// - Returns: An `Int` value.

1194+ /// - Throws: `JSONError` if the key doesn't exist or the value is `null`, a boolean, an object,

1195+ /// an array, a string that cannot be coerced to an integral value, or a floating-point

1196+ /// value that does not fit in an `Int`, or if the receiver is not an object.

1197+ func toInt(_ key: String) throws -> Int {

1198+ let value = try getRequired(self, key: key, type: .number)

1199+ return try scoped(key) { try value.toInt() }

1200+ }

1201+

1202+ /// Subscripts the receiver with `key` and returns the result coerced to an `Int`.

1203+ /// - Parameter key: The key that's used to subscript the receiver.

1204+ /// - Returns: An `Int` value, or `nil` if the key doesn't exist or the value is `null`.

1205+ /// - Throws: `JSONError` if the the value is a boolean, an object, an array, a string

1206+ /// that cannot be coerced to an integral value, or a floating-point value

1207+ /// that does not fit in an `Int`, or if the receiver is not an object.

1208+ func toIntOrNil(_ key: String) throws -> Int? {

1209+ guard let value = self[key] else { return nil }

1210+ return try scoped(key) { try value.toIntOrNil() }

1211+ }

1212+

1213+ /// Subscripts the receiver with `key` and returns the result coerced to a `Double`.

1214+ /// - Parameter key: The key that's used to subscript the receiver.

1215+ /// - Returns: A `Double` value.

1216+ /// - Throws: `JSONError` if the key doesn't exist or the value is `null`, a boolean,

1217+ /// an object, an array, or a string that cannot be coerced to a floating-point value,

1218+ /// or if the receiver is not an object.

1219+ func toDouble(_ key: String) throws -> Double {

1220+ let value = try getRequired(self, key: key, type: .number)

1221+ return try scoped(key) { try value.toDouble() }

1222+ }

1223+

1224+ /// Subscripts the receiver with `key` and returns the result coerced to a `Double`.

1225+ /// - Parameter key: The key that's used to subscript the receiver.

1226+ /// - Returns: A `Double` value, or `nil` if the key doesn't exist or the value is `null`.

1227+ /// - Throws: `JSONError` if the value is a boolean, an object, an array, or a string that

1228+ /// cannot be coerced to a floating-point value, or if the receiver is not an object.

1229+ func toDoubleOrNil(_ key: String) throws -> Double? {

1230+ guard let value = self[key] else { return nil }

1231+ return try scoped(key) { try value.toDoubleOrNil() }

1232+ }

1233+}

1234+

1235+// MARK: - JSONArray helpers

1236+

1237+public extension JSON {

1238+ /// Returns an `Array` containing the results of mapping `transform` over `array`.

1239+ ///

1240+ /// If `transform` throws a `JSONError`, the error will be modified to include the index

1241+ /// of the element that caused the error.

1242+ ///

1243+ /// - Parameter array: The `JSONArray` to map over.

1244+ /// - Parameter transform: A block that is called once for each element of `array`.

1245+ /// - Returns: An array with the results of mapping `transform` over `array`.

1246+ /// - Throws: Rethrows any error thrown by `transform`.

1247+ /// - Complexity: O(*N*).

1248+ static func map<T>(_ array: JSONArray, _ transform: (JSON) throws -> T) rethrows -> [T] {

1249+ return try array.enumerated().map({ i, elt in try scoped(i, { try transform(elt) }) })

1250+ }

1251+

1252+ /// Returns an `Array` containing the non-`nil` results of mapping `transform` over `array`.

1253+ ///

1254+ /// If `transform` throws a `JSONError`, the error will be modified to include the index

1255+ /// of the element that caused the error.

1256+ ///

1257+ /// - Parameter array: The `JSONArray` to map over.

1258+ /// - Parameter transform: A block that is called once for each element of `array`.

1259+ /// - Returns: An array with the non-`nil` results of mapping `transform` over `array`.

1260+ /// - Throws: Rethrows any error thrown by `transform`.

1261+ /// - Complexity: O(*N*).

1262+ static func flatMap<T>(_ array: JSONArray, _ transform: (JSON) throws -> T?) rethrows -> [T] {

1263+ return try array.enumerated().flatMap({ i, elt in try scoped(i, { try transform(elt) }) })

1264+ }

1265+

1266+ /// Returns an `Array` containing the concatenated results of mapping `transform` over `array`.

1267+ ///

1268+ /// If `transform` throws a `JSONError`, the error will be modified to include the index

1269+ /// of the element that caused the error.

1270+ ///

1271+ /// - Parameter array: The `JSONArray` to map over.

1272+ /// - Parameter transform: A block that is called once for each element of `array`.

1273+ /// - Returns: An array with the concatenated results of mapping `transform` over `array`.

1274+ /// - Throws: Rethrows any error thrown by `transform`.

1275+ /// - Complexity: O(*M* + *N*) where *M* is the length of `array` and *N* is the length of the result.

1276+ static func flatMap<S: Sequence>(_ array: JSONArray, _ transform: (JSON) throws -> S) rethrows -> [S.Iterator.Element] {

1277+ return try array.enumerated().flatMap({ (i, elt) in

1278+ return try scoped(i, { try transform(elt) })

1279+ })

1280+ }

1281+}

1282+

1283+public extension JSON {

1284+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1285+ /// containing the results of mapping `transform` over the value.

1286+ ///

1287+ /// - Note: This method is equivalent to `getArray(key, { try JSON.map($0, transform) })`.

1288+ ///

1289+ /// - Parameter key: The key to subscript the receiver with.

1290+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1291+ /// - Returns: An array with the results of mapping `transform` over the array.

1292+ /// - Throws: `JSONError` if the receiver is not an object, `key` does not exist, or the value

1293+ /// is not an array. Also rethrows any error thrown by `transform`.

1294+ /// - Complexity: O(*N*).

1295+ func mapArray<T>(_ key: String, _ transform: (JSON) throws -> T) throws -> [T] {

1296+ return try getArray(key, { try JSON.map($0, transform) })

1297+ }

1298+

1299+ /// Subscripts the receiver with `index`, converts the value to an array, and returns an `Array`

1300+ /// containing the results of mapping `transform` over the value.

1301+ ///

1302+ /// - Note: This method is equivalent to `getArray(index, { try JSON.map($0, transform) })`.

1303+ ///

1304+ /// - Parameter index: The index to subscript the receiver with.

1305+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1306+ /// - Returns: An array with the results of mapping `transform` over the array.

1307+ /// - Throws: `JSONError` if the receiver is not an array, `index` is out of bounds, or the

1308+ /// value is not an array. Also rethrows any error thrown by `transform`.

1309+ /// - Complexity: O(*N*).

1310+ func mapArray<T>(_ index: Int, _ transform: (JSON) throws -> T) throws -> [T] {

1311+ return try getArray(index, { try JSON.map($0, transform) })

1312+ }

1313+

1314+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1315+ /// containing the results of mapping `transform` over the value.

1316+ ///

1317+ /// Returns `nil` if `key` doesn't exist or the value is `null`.

1318+ ///

1319+ /// - Note: This method is equivalent to `getArrayOrNil(key, { try JSON.map($0, transform) })`.

1320+ ///

1321+ /// - Parameter key: The key to subscript the receiver with.

1322+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1323+ /// - Returns: An array with the results of mapping `transform` over the array, or `nil` if

1324+ /// `key` does not exist or the value is `null`.

1325+ /// - Throws: `JSONError` if the receiver is not an object or `key` exists but the value is not

1326+ /// an array or `null`. Also rethrows any error thrown by `transform`.

1327+ /// - Complexity: O(*N*).

1328+ func mapArrayOrNil<T>(_ key: String, _ transform: (JSON) throws -> T) throws -> [T]? {

1329+ return try getArrayOrNil(key, { try JSON.map($0, transform) })

1330+ }

1331+

1332+ /// Subscripts the receiver with `index`, converts the value to an array, and returns an `Array`

1333+ /// containing the results of mapping `transform` over the value.

1334+ ///

1335+ /// Returns `nil` if `index` is out of bounds or the value is `null`.

1336+ ///

1337+ /// - Note: This method is equivalent to `getArrayOrNil(index, { try JSON.map($0, transform) })`.

1338+ ///

1339+ /// - Parameter index: The index to subscript the receiver with.

1340+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1341+ /// - Returns: An array with the results of mapping `transform` over the array, or `nil` if

1342+ /// `index` is out of bounds or the value is `null`.

1343+ /// - Throws: `JSONError` if the receiver is not an object or the subscript value is not an

1344+ /// array or `null`. Also rethrows any error thrown by `transform`.

1345+ /// - Complexity: O(*N*).

1346+ func mapArrayOrNil<T>(_ index: Int, _ transform: (JSON) throws -> T) throws -> [T]? {

1347+ return try getArrayOrNil(index, { try JSON.map($0, transform) })

1348+ }

1349+

1350+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1351+ /// containing the non-`nil` results of mapping `transform` over the value.

1352+ ///

1353+ /// - Note: This method is equivalent to `getArray(key, { try JSON.flatMap($0, transform) })`.

1354+ ///

1355+ /// - Parameter key: The key to subscript the receiver with.

1356+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1357+ /// - Returns: An array with the non-`nil` results of mapping `transform` over the array.

1358+ /// - Throws: `JSONError` if the receiver is not an object, `key` does not exist, or the value

1359+ /// is not an array. Also rethrows any error thrown by `transform`.

1360+ /// - Complexity: O(*N*).

1361+ func flatMapArray<T>(_ key: String, _ transform: (JSON) throws -> T?) throws -> [T] {

1362+ return try getArray(key, { try JSON.flatMap($0, transform) })

1363+ }

1364+

1365+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1366+ /// containing the concatenated results of mapping `transform` over the value.

1367+ ///

1368+ /// - Note: This method is equivalent to `getArray(key, { try JSON.flatMap($0, transform) })`.

1369+ ///

1370+ /// - Parameter key: The key to subscript the receiver with.

1371+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1372+ /// - Returns: An array with the concatenated results of mapping `transform` over the array.

1373+ /// - Throws: `JSONError` if the receiver is not an object, `key` does not exist, or the value

1374+ /// is not an array. Also rethrows any error thrown by `transform`.

1375+ /// - Complexity: O(*M* + *N*) where *M* is the length of `array` and *N* is the length of the result.

1376+ func flatMapArray<S: Sequence>(_ key: String, _ transform: (JSON) throws -> S) throws -> [S.Iterator.Element] {

1377+ return try getArray(key, { try JSON.flatMap($0, transform) })

1378+ }

1379+

1380+ /// Subscripts the receiver with `index`, converts the value to an array, and returns an `Array`

1381+ /// containing the non-`nil` results of mapping `transform` over the value.

1382+ ///

1383+ /// - Note: This method is equivalent to `getArray(index, { try JSON.flatMap($0, transform) })`.

1384+ ///

1385+ /// - Parameter index: The index to subscript the receiver with.

1386+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1387+ /// - Returns: An array with the non-`nil` results of mapping `transform` over the array.

1388+ /// - Throws: `JSONError` if the receiver is not an array, `index` is out of bounds, or the

1389+ /// value is not an array. Also rethrows any error thrown by `transform`.

1390+ /// - Complexity: O(*N*).

1391+ func flatMapArray<T>(_ index: Int, _ transform: (JSON) throws -> T?) throws -> [T] {

1392+ return try getArray(index, { try JSON.flatMap($0, transform) })

1393+ }

1394+

1395+ /// Subscripts the receiver with `index`, converts the value to an array, and returns an `Array`

1396+ /// containing the concatenated results of mapping `transform` over the value.

1397+ ///

1398+ /// - Note: This method is equivalent to `getArray(index, { try JSON.flatMap($0, transform) })`.

1399+ ///

1400+ /// - Parameter index: The index to subscript the receiver with.

1401+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1402+ /// - Returns: An array with the concatenated results of mapping `transform` over the array.

1403+ /// - Throws: `JSONError` if the receiver is not an array, `index` is out of bounds, or the

1404+ /// value is not an array. Also rethrows any error thrown by `transform`.

1405+ /// - Complexity: O(*M* + *N*) where *M* is the length of `array` and *N* is the length of the result.

1406+ func flatMapArray<S: Sequence>(_ index: Int, _ transform: (JSON) throws -> S) throws -> [S.Iterator.Element] {

1407+ return try getArray(index, { try JSON.flatMap($0, transform) })

1408+ }

1409+

1410+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1411+ /// containing the non-`nil` results of mapping `transform` over the value.

1412+ ///

1413+ /// Returns `nil` if `key` doesn't exist or the value is `null`.

1414+ ///

1415+ /// - Note: This method is equivalent to `getArrayOrNil(key, { try JSON.flatMap($0, transform) })`.

1416+ ///

1417+ /// - Parameter key: The key to subscript the receiver with.

1418+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1419+ /// - Returns: An array with the non-`nil` results of mapping `transform` over the array, or

1420+ /// `nil` if `key` does not exist or the value is `null`.

1421+ /// - Throws: `JSONError` if the receiver is not an object or the value is not an array or

1422+ /// `null`. Also rethrows any error thrown by `transform`.

1423+ /// - Complexity: O(*N*).

1424+ func flatMapArrayOrNil<T>(_ key: String, _ transform: (JSON) throws -> T?) throws -> [T]? {

1425+ return try getArrayOrNil(key, { try JSON.flatMap($0, transform) })

1426+ }

1427+

1428+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1429+ /// containing the concatenated results of mapping `transform` over the value.

1430+ ///

1431+ /// Returns `nil` if `key` doesn't exist or the value is `null`.

1432+ ///

1433+ /// - Note: This method is equivalent to `getArrayOrNil(key, { try JSON.flatMap($0, transform) })`.

1434+ ///

1435+ /// - Parameter key: The key to subscript the receiver with.

1436+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1437+ /// - Returns: An array with the concatenated results of mapping `transform` over the array,

1438+ /// or `nil` if `key` does not exist or the value is `null`.

1439+ /// - Throws: `JSONError` if the receiver is not an object or the value is not an array or

1440+ /// `null`. Also rethrows any error thrown by `transform`.

1441+ /// - Complexity: O(*M* + *N*) where *M* is the length of `array` and *N* is the length of the result.

1442+ func flatMapArrayOrNil<S: Sequence>(_ key: String, _ transform: (JSON) throws -> S) throws -> [S.Iterator.Element]? {

1443+ return try getArrayOrNil(key, { try JSON.flatMap($0, transform) })

1444+ }

1445+

1446+ /// Subscripts the receiver with `index`, converts the value to an array, and returns an `Array`

1447+ /// containing the non-`nil` results of mapping `transform` over the value.

1448+ ///

1449+ /// Returns `nil` if `index` is out of bounds or the value is `null`.

1450+ ///

1451+ /// - Note: This method is equivalent to `getArrayOrNil(index, { try JSON.flatMap($0, transform) })`.

1452+ ///

1453+ /// - Parameter index: The index to subscript the receiver with.

1454+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1455+ /// - Returns: An array with the non-`nil` results of mapping `transform` over the array, or

1456+ /// `nil` if `index` is out of bounds or the value is `null`.

1457+ /// - Throws: `JSONError` if the receiver is not an array or the value is not an array or

1458+ /// `null`. Also rethrows any error thrown by `transform`.

1459+ /// - Complexity: O(*N*).

1460+ func flatMapArrayOrNil<T>(_ index: Int, _ transform: (JSON) throws -> T?) throws -> [T]? {

1461+ return try getArrayOrNil(index, { try JSON.flatMap($0, transform) })

1462+ }

1463+

1464+ /// Subscripts the receiver with `index`, converts the value to an array, and returns an `Array`

1465+ /// containing the concatenated results of mapping `transform` over the value.

1466+ ///

1467+ /// Returns `nil` if `index` is out of bounds or the value is `null`.

1468+ ///

1469+ /// - Note: This method is equivalent to `getArrayOrNil(index, { try JSON.flatMap($0, transform) })`.

1470+ ///

1471+ /// - Parameter index: The index to subscript the receiver with.

1472+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1473+ /// - Returns: An array with the concatenated results of mapping `transform` over the array,

1474+ /// or `nil` if `index` is out of bounds or the value is `null`.

1475+ /// - Throws: `JSONError` if the receiver is not an array or the value is not an array or

1476+ /// `null`. Also rethrows any error thrown by `transform`.

1477+ /// - Complexity: O(*M* + *N*) where *M* is the length of `array` and *N* is the length of the result.

1478+ func flatMapArrayOrNil<S: Sequence>(_ index: Int, _ transform: (JSON) throws -> S) throws -> [S.Iterator.Element]? {

1479+ return try getArrayOrNil(index, { try JSON.flatMap($0, transform) })

1480+ }

1481+}

1482+

1483+public extension JSONObject {

1484+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1485+ /// containing the results of mapping `transform` over the value.

1486+ ///

1487+ /// - Note: This method is equivalent to `getArray(key, { try JSON.map($0, transform) })`.

1488+ ///

1489+ /// - Parameter key: The key to subscript the receiver with.

1490+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1491+ /// - Returns: An array with the results of mapping `transform` over the array.

1492+ /// - Throws: `JSONError` if `key` does not exist or the value is not an array.

1493+ /// Also rethrows any error thrown by `transform`.

1494+ /// - Complexity: O(*N*).

1495+ func mapArray<T>(_ key: String, _ transform: (JSON) throws -> T) throws -> [T] {

1496+ return try getArray(key, { try JSON.map($0, transform) })

1497+ }

1498+

1499+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1500+ /// containing the results of mapping `transform` over the value.

1501+ ///

1502+ /// Returns `nil` if `key` doesn't exist or the value is `null`.

1503+ ///

1504+ /// - Note: This method is equivalent to `getArrayOrNil(key, { try JSON.map($0, transform) })`.

1505+ ///

1506+ /// - Parameter key: The key to subscript the receiver with.

1507+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1508+ /// - Returns: An array with the results of mapping `transform` over the array, or `nil` if

1509+ /// `key` does not exist or the value is `null`.

1510+ /// - Throws: `JSONError` if `key` exists but the value is not an array or `null`.

1511+ /// Also rethrows any error thrown by `transform`.

1512+ /// - Complexity: O(*N*).

1513+ func mapArrayOrNil<T>(_ key: String, _ transform: (JSON) throws -> T) throws -> [T]? {

1514+ return try getArrayOrNil(key, { try JSON.map($0, transform) })

1515+ }

1516+

1517+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1518+ /// containing the non-`nil` results of mapping `transform` over the value.

1519+ ///

1520+ /// - Note: This method is equivalent to `getArray(key, { try JSON.flatMap($0, transform) })`.

1521+ ///

1522+ /// - Parameter key: The key to subscript the receiver with.

1523+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1524+ /// - Returns: An array with the non-`nil` results of mapping `transform` over the array.

1525+ /// - Throws: `JSONError` if `key` does not exist or the value is not an array.

1526+ /// Also rethrows any error thrown by `transform`.

1527+ /// - Complexity: O(*N*).

1528+ func flatMapArray<T>(_ key: String, _ transform: (JSON) throws -> T?) throws -> [T] {

1529+ return try getArray(key, { try JSON.flatMap($0, transform) })

1530+ }

1531+

1532+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1533+ /// containing the concatenated results of mapping `transform` over the value.

1534+ ///

1535+ /// - Note: This method is equivalent to `getArray(key, { try JSON.flatMap($0, transform) })`.

1536+ ///

1537+ /// - Parameter key: The key to subscript the receiver with.

1538+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1539+ /// - Returns: An array with the concatenated results of mapping `transform` over the array.

1540+ /// - Throws: `JSONError` if `key` does not exist or the value is not an array.

1541+ /// Also rethrows any error thrown by `transform`.

1542+ /// - Complexity: O(*M* + *N*) where *M* is the length of `array` and *N* is the length of the result.

1543+ func flatMapArray<S: Sequence>(_ key: String, _ transform: (JSON) throws -> S) throws -> [S.Iterator.Element] {

1544+ return try getArray(key, { try JSON.flatMap($0, transform) })

1545+ }

1546+

1547+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1548+ /// containing the non-`nil` results of mapping `transform` over the value.

1549+ ///

1550+ /// Returns `nil` if `key` doesn't exist or the value is `null`.

1551+ ///

1552+ /// - Note: This method is equivalent to `getArrayOrNil(key, { try JSON.flatMap($0, transform) })`.

1553+ ///

1554+ /// - Parameter key: The key to subscript the receiver with.

1555+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1556+ /// - Returns: An array with the non-`nil` results of mapping `transform` over the array, or

1557+ /// `nil` if `key` does not exist or the value is `null`.

1558+ /// - Throws: `JSONError` if `key` exists but the value is not an array or `null`.

1559+ /// Also rethrows any error thrown by `transform`.

1560+ /// - Complexity: O(*N*).

1561+ func flatMapArrayOrNil<T>(_ key: String, _ transform: (JSON) throws -> T?) throws -> [T]? {

1562+ return try getArrayOrNil(key, { try JSON.flatMap($0, transform) })

1563+ }

1564+

1565+ /// Subscripts the receiver with `key`, converts the value to an array, and returns an `Array`

1566+ /// containing the concatenated results of mapping `transform` over the value.

1567+ ///

1568+ /// Returns `nil` if `key` doesn't exist or the value is `null`.

1569+ ///

1570+ /// - Note: This method is equivalent to `getArrayOrNil(key, { try JSON.flatMap($0, transform) })`.

1571+ ///

1572+ /// - Parameter key: The key to subscript the receiver with.

1573+ /// - Parameter transform: A block that is called once for each element of the resulting array.

1574+ /// - Returns: An array with the concatenated results of mapping `transform` over the array,

1575+ /// or `nil` if `key` does not exist or the value is `null`.

1576+ /// - Throws: `JSONError` if `key` exists but the value is not an array or `null`.

1577+ /// Also rethrows any error thrown by `transform`.

1578+ /// - Complexity: O(*M* + *N*) where *M* is the length of `array` and *N* is the length of the result.

1579+ func flatMapArrayOrNil<S: Sequence>(_ key: String, _ transform: (JSON) throws -> S) throws -> [S.Iterator.Element]? {

1580+ return try getArrayOrNil(key, { try JSON.flatMap($0, transform) })

1581+ }

1582+}

1583+

1584+// MARK: -

1585+

1586+internal func getRequired(_ dict: JSONObject, key: String, type: JSONError.JSONType) throws -> JSON {

1587+ guard let value = dict[key] else { throw JSONError.missingOrInvalidType(path: key, expected: .required(type), actual: nil) }

1588+ return value

1589+}

1590+

1591+internal func getRequired(_ ary: JSONArray, index: Int, type: JSONError.JSONType) throws -> JSON {

1592+ guard let value = ary[safe: index] else { throw JSONError.missingOrInvalidType(path: "[\(index)]", expected: .required(type), actual: nil) }

1593+ return value

1594+}

1595+

1596+@inline(__always)

1597+internal func scoped<T>(_ key: String, _ f: () throws -> T) rethrows -> T {

1598+ do {

1599+ return try f()

1600+ } catch let error as JSONError {

1601+ throw error.withPrefix(key)

1602+ }

1603+}

1604+

1605+@inline(__always)

1606+internal func scoped<T>(_ index: Int, _ f: () throws -> T) rethrows -> T {

1607+ do {

1608+ return try f()

1609+ } catch let error as JSONError {

1610+ throw error.withPrefix("[\(index)]")

1611+ }

1612+}

1613+

1614+internal extension ContiguousArray {

1615+ subscript(safe index: Int) -> Element? {

1616+ guard index >= startIndex && index < endIndex else { return nil }

1617+ return self[index]

1618+ }

1619+}

parsers/test_PMJSON_1_2_0/JSONObject.swiftnew file+215

@@ -0,0 +1,215 @@

1+//

2+// JSONObject.swift

3+// PMJSON

4+//

5+// Created by Kevin Ballard on 11/10/15.

7+//

8+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

9+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

10+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

11+// option. This file may not be copied, modified, or distributed

12+// except according to those terms.

13+//

14+

15+/// A collection of key-value pairs that maps `String` to `JSON`.

16+///

17+/// This collection abstracts away the underlying representation and allows for JSON-specific

18+/// methods to be added.

19+public struct JSONObject {

20+ /// Creates an empty object.

21+ public init() {

22+ dictionary = [:]

23+ }

24+

25+ /// Creates an object from a sequence of `(String,JSON)` pairs.

26+ public init<S: Sequence>(_ seq: S) where S.Iterator.Element == (String,JSON) {

27+ // optimize for the case where the sequence doesn't contain duplicate keys

28+ dictionary = Dictionary(minimumCapacity: seq.underestimatedCount)

29+ for (key,value) in seq {

30+ dictionary[key] = value

31+ }

32+ }

33+

34+ /// The JSON object represented as a `[String: JSON]`.

35+ public fileprivate(set) var dictionary: [String: JSON]

36+

37+ public subscript(key: String) -> JSON? {

38+ @inline(__always) get {

39+ return dictionary[key]

40+ }

41+ @inline(__always) set {

42+ dictionary[key] = newValue

43+ }

44+ }

45+}

46+

47+extension JSONObject: Collection {

48+ /// The position of the first element in a non-empty object.

49+ ///

50+ /// Identical to `endIndex` in an empty object.

51+ public var startIndex: Index {

52+ return Index(dictionary.startIndex)

53+ }

54+

55+ /// The collection's "past the end" position.

56+ ///

57+ /// `endIndex` is not a valid argument to `subscript`, and is always reachable from `startIndex`

58+ /// by zero or more applications of `successor()`.

59+ public var endIndex: Index {

60+ return Index(dictionary.endIndex)

61+ }

62+

63+ /// Returns `true` iff `self` is empty.

64+ public var isEmpty: Bool {

65+ return dictionary.isEmpty

66+ }

67+

68+ /// The number of entries in the object.

69+ public var count: Int {

70+ return dictionary.count

71+ }

72+

73+ public func makeIterator() -> Iterator {

74+ return Iterator(dictionary.makeIterator())

75+ }

76+

77+ public subscript(position: Index) -> (String,JSON) {

78+ return dictionary[position.base]

79+ }

80+

81+ public func index(after i: Index) -> Index {

82+ return Index(dictionary.index(after: i.base))

83+ }

84+

85+ public func formIndex(after i: inout Index) {

86+ dictionary.formIndex(after: &i.base)

87+ }

88+

89+ /// Represents a position in a `JSONObject`.

90+ public struct Index: Comparable {

91+ fileprivate var base: Dictionary<String,JSON>.Index

92+

93+ fileprivate init(_ base: Dictionary<String,JSON>.Index) {

94+ self.base = base

95+ }

96+

97+ public static func ==(lhs: JSONObject.Index, rhs: JSONObject.Index) -> Bool {

98+ return lhs.base == rhs.base

99+ }

100+

101+ public static func <(lhs: JSONObject.Index, rhs: JSONObject.Index) -> Bool {

102+ return lhs.base < rhs.base

103+ }

104+ }

105+

106+ public struct Iterator: IteratorProtocol {

107+ private var base: Dictionary<String,JSON>.Iterator

108+

109+ fileprivate init(_ base: Dictionary<String,JSON>.Iterator) {

110+ self.base = base

111+ }

112+

113+ /// Advance to the next element and return it, or `nil` if no next element exists.

114+ ///

115+ /// - Requires: No preceding call to `self.next()` has returned `nil`.

116+ public mutating func next() -> (String,JSON)? {

117+ return base.next()

118+ }

119+ }

120+}

121+

122+extension JSONObject {

123+ /// A collection containing just the keys of `self`.

124+ ///

125+ /// Keys appear in the same order as they occur as the `.0` member of key-value pairs in `self`.

126+ /// Each key in the result has a unique value.

127+ public var keys: LazyMapCollection<JSONObject, String> {

128+ return lazy.map({ $0.0 })

129+ }

130+

131+ /// A collection containing just the values of `self`.

132+ ///

133+ /// Values appear in the same order as they occur as the `.1` member of key-value pairs in `self`.

134+ public var values: LazyMapCollection<JSONObject, JSON> {

135+ return lazy.map({ $0.1 })

136+ }

137+

138+ /// Returns the `Index` for the given key, or `nil` if the key is not present in the object.

139+ public func indexForKey(_ key: String) -> Index? {

140+ return dictionary.index(forKey: key).map(Index.init)

141+ }

142+

143+ /// Update the value stored in the object for the given key, or, if the key does not exist,

144+ /// add a new key-value pair to the object.

145+ ///

146+ /// Returns the value that was replaced, or `nil` if a new key-value pair was added.

147+ public mutating func updateValue(_ value: JSON, forKey key: String) -> JSON? {

148+ return dictionary.updateValue(value, forKey: key)

149+ }

150+

151+ /// Remove the key-value pair at `index`.

152+ ///

153+ /// Invalidates all indices with respect to `self`.

154+ public mutating func removeAtIndex(_ index: Index) -> (String,JSON)? {

155+ return dictionary.remove(at: index.base)

156+ }

157+

158+ /// Remove a given key and the associated value from the object.

159+ /// Returns the value that was removed, or `nil` if the key was not present in the object.

160+ public mutating func removeValueForKey(_ key: String) -> JSON? {

161+ return dictionary.removeValue(forKey: key)

162+ }

163+

164+ /// Remove all elements.

165+ ///

166+ /// Invalidates all indices with respect to `self`.

167+ public mutating func removeAll() {

168+ dictionary.removeAll()

169+ }

170+

171+ /// If `!self.isEmpty`, return the first key-value pair in the sequence of elements, otherwise return `nil`.

172+ public mutating func popFirst() -> (String,JSON)? {

173+ return dictionary.popFirst()

174+ }

175+}

176+

177+extension JSONObject: ExpressibleByDictionaryLiteral {

178+ /// Creates an object from a dictionary.

179+ public init(_ dictionary: [String: JSON]) {

180+ self.dictionary = dictionary

181+ }

182+

183+ /// Creates an object initialized with `elements`.

184+ public init(dictionaryLiteral elements: (String, JSON)...) {

185+ self.init(elements)

186+ }

187+}

188+

189+extension JSONObject: TextOutputStreamable, CustomStringConvertible, CustomDebugStringConvertible {

190+ public func write<Target : TextOutputStream>(to target: inout Target) {

191+ JSON.encode(JSON(self), to: &target)

192+ }

193+

194+ public var description: String {

195+ return JSON.encodeAsString(JSON(self))

196+ }

197+

198+ public var debugDescription: String {

199+ let desc = JSON.encodeAsString(JSON(self))

200+ return "JSONObject(\(desc))"

201+ }

202+}

203+

204+extension JSONObject: Equatable {

205+ public static func ==(lhs: JSONObject, rhs: JSONObject) -> Bool {

206+ return lhs.dictionary == rhs.dictionary

207+ }

208+}

209+

210+extension JSONObject: CustomReflectable {

211+ public var customMirror: Mirror {

212+ let children: LazyMapCollection<Dictionary<String, JSON>, Mirror.Child> = dictionary.lazy.map({ ($0,$1) })

213+ return Mirror(self, children: children, displayStyle: .dictionary)

214+ }

215+}

parsers/test_PMJSON_1_2_0/ObjectiveC.swiftnew file+331

@@ -0,0 +1,331 @@

1+//

2+// ObjectiveC.swift

3+// PMJSON

4+//

5+// Created by Kevin Ballard on 10/9/15.

7+//

8+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

9+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

10+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

11+// option. This file may not be copied, modified, or distributed

12+// except according to those terms.

13+//

14+

15+#if os(iOS) || os(OSX) || os(watchOS) || os(tvOS)

16+

17+ import Foundation

18+

19+ extension JSON {

20+ /// Decodes a `Data` as JSON.

21+ /// - Note: Invalid unicode sequences in the data are replaced with U+FFFD.

22+ /// - Parameter data: The data to decode. Must be either UTF-8, or UTF-16 with a BOM.

23+ /// - Parameter options: Options that controls JSON parsing. Defaults to no options. See `JSONOptions` for details.

24+ /// - Returns: A `JSON` value.

25+ /// - Throws: `JSONParserError` if the data does not contain valid JSON.

26+ public static func decode(_ data: Data, options: JSONOptions = []) throws -> JSON {

27+ if let endian = UTF16Decoder.checkBOM(for: data) {

28+ return try JSON.decode(UTF16Decoder(data: data, endian: endian))

29+ } else {

30+ return try JSON.decode(UTF8Decoder(data: data), options: options)

31+ }

32+ }

33+

34+ @available(*, deprecated, message: "Use JSON.decode(_:options:) instead")

35+ public static func decode(_ data: Data, strict: Bool) throws -> JSON {

36+ return try JSON.decode(data, options: [.strict])

37+ }

38+

39+ /// Encodes a `JSON` to a `Data`.

40+ /// - Parameter json: The `JSON` to encode.

41+ /// - Parameter options: Options that controls JSON encoding. Defaults to no options. See `JSONEncoderOptions` for details.

42+ /// - Returns: An `NSData` with the JSON representation of *json*.

43+ public static func encodeAsData(_ json: JSON, options: JSONEncoderOptions = []) -> Data {

44+ struct Output: TextOutputStream {

45+ // NB: We use NSMutableData instead of Data because it's significantly faster as of Xcode 8b3

46+ var data = NSMutableData()

47+ mutating func write(_ string: String) {

48+ let oldLen = data.length

49+ data.increaseLength(by: string.utf8.count)

50+ let ptr = data.mutableBytes.assumingMemoryBound(to: UInt8.self) + oldLen

51+ for (i, x) in string.utf8.enumerated() {

52+ ptr[i] = x

53+ }

54+ }

55+ }

56+ var output = Output()

57+ JSON.encode(json, to: &output, options: options)

58+ return output.data as Data

59+ }

60+

61+ @available(*, deprecated, message: "Use JSON.encodeAsData(_:options:) instead")

62+ public static func encodeAsData(_ json: JSON, pretty: Bool) -> Data {

63+ return encodeAsData(json, options: JSONEncoderOptions(pretty: pretty))

64+ }

65+ }

66+

67+ extension JSON {

68+ /// Converts a JSON-compatible Foundation object into a `JSON` value.

69+ /// - Throws: `JSONFoundationError` if the object is not JSON-compatible.

70+ public init(ns: Any) throws {

71+ let object = ns as AnyObject

72+ if object === kCFBooleanTrue {

73+ self = .bool(true)

74+ return

75+ } else if object === kCFBooleanFalse {

76+ self = .bool(false)

77+ return

78+ }

79+ switch object {

80+ case is NSNull:

81+ self = .null

82+ case let n as NSNumber:

83+ let typeChar: UnicodeScalar

84+ let objCType = n.objCType

85+ if objCType[0] == 0 || objCType[1] != 0 {

86+ typeChar = "?"

87+ } else {

88+ typeChar = UnicodeScalar(UInt8(bitPattern: objCType[0]))

89+ }

90+ switch typeChar {

91+ case "c", "i", "s", "l", "q", "C", "I", "S", "L", "B":

92+ self = .int64(n.int64Value)

93+ case "Q": // unsigned long long

94+ let val = n.uint64Value

95+ if val > UInt64(Int64.max) {

96+ fallthrough

97+ }

98+ self = .int64(Int64(val))

99+ default:

100+ self = .double(n.doubleValue)

101+ }

102+ case let s as String:

103+ self = .string(s)

104+ case let dict as NSDictionary:

105+ var obj: [String: JSON] = Dictionary(minimumCapacity: dict.count)

106+ for (key, value) in dict {

107+ guard let key = key as? String else { throw JSONFoundationError.nonStringKey }

108+ obj[key] = try JSON(ns: value)

109+ }

110+ self = .object(JSONObject(obj))

111+ case let array as NSArray:

112+ var ary: JSONArray = []

113+ ary.reserveCapacity(array.count)

114+ for elt in array {

115+ ary.append(try JSON(ns: elt))

116+ }

117+ self = .array(ary)

118+ default:

119+ throw JSONFoundationError.incompatibleType

120+ }

121+ }

122+

123+ /// Returns the JSON as a JSON-compatible Foundation object.

124+ public var ns: Any {

125+ switch self {

126+ case .null: return NSNull()

127+ case .bool(let b): return NSNumber(value: b)

128+ case .string(let s): return s

129+ case .int64(let i): return NSNumber(value: i)

130+ case .double(let d): return d

131+ case .object(let obj): return obj.ns

132+ case .array(let ary):

133+ return ary.map({$0.ns})

134+ }

135+ }

136+

137+ /// Returns the JSON as a JSON-compatible Foundation object, discarding any nulls.

138+ public var nsNoNull: Any? {

139+ switch self {

140+ case .null: return nil

141+ case .bool(let b): return NSNumber(value: b)

142+ case .string(let s): return s

143+ case .int64(let i): return NSNumber(value: i)

144+ case .double(let d): return d

145+ case .object(let obj): return obj.nsNoNull

146+ case .array(let ary):

147+ return ary.flatMap({$0.nsNoNull})

148+ }

149+ }

150+ }

151+

152+ extension JSONObject {

153+ /// Returns the JSON as a JSON-compatible dictionary.

154+ public var ns: [AnyHashable: Any] {

155+ var dict: [AnyHashable: Any] = Dictionary(minimumCapacity: count)

156+ for (key, value) in self {

157+ dict[key] = value.ns

158+ }

159+ return dict

160+ }

161+

162+ /// Returns the JSON as a JSON-compatible dictionary, discarding any nulls.

163+ public var nsNoNull: [AnyHashable: Any] {

164+ var dict: [AnyHashable: Any] = Dictionary(minimumCapacity: count)

165+ for (key, value) in self {

166+ if let value = value.nsNoNull {

167+ dict[key] = value

168+ }

169+ }

170+ return dict

171+ }

172+ }

173+

174+ // MARK: - Errors

175+

176+ /// An error that is thrown when converting from `AnyObject` to `JSON`.

177+ /// - SeeAlso: `JSON.init(ns:)`

178+ public enum JSONFoundationError: Error {

179+ /// Thrown when a non-JSON-compatible type is found.

180+ case incompatibleType

181+ /// Thrown when a dictionary has a key that is not a string.

182+ case nonStringKey

183+ }

184+

185+ extension JSONError: LocalizedError {

186+ public var errorDescription: String? {

187+ return String(describing: self)

188+ }

189+ }

190+

191+ extension JSONParserError: CustomNSError {

192+ public static let errorDomain: String = "PMJSON.JSONParserError"

193+

194+ public var errorCode: Int {

195+ return code.rawValue

196+ }

197+

198+ public var errorUserInfo: [String: Any] {

199+ return [NSLocalizedDescriptionKey: String(describing: self)]

200+ }

201+ }

202+

203+ extension JSONDecoderError: LocalizedError {

204+ public var failureReason: String? {

205+ switch self {

206+ case .streamEnded: return "The JSON event stream ended."

207+ case .unexpectedToken: return "The JSON event stream contained more than one top-level value."

208+ case .exceededDepthLimit: return "The JSON event stream exceeded the nesting depth limit."

209+ }

210+ }

211+ }

212+

213+ // MARK: -

214+

215+ private struct UTF8Decoder: Sequence {

216+ init(data: Data) {

217+ self.data = data as NSData

218+ }

219+

220+ func makeIterator() -> Iterator {

221+ return Iterator(data: data)

222+ }

223+

224+ private let data: NSData

225+

226+ fileprivate struct Iterator: IteratorProtocol {

227+ init(data: NSData) {

228+ // NB: We use NSData instead of using Data's iterator because it's significantly faster as of Xcode 8b3

229+ self.data = data

230+ let ptr = UnsafeBufferPointer(start: data.bytes.assumingMemoryBound(to: UInt8.self), count: data.length)

231+ iter = ptr.makeIterator()

232+ if ptr.count >= 3 && ptr[0] == 0xEF && ptr[1] == 0xBB && ptr[2] == 0xBF {

233+ // UTF-8 BOM detected. Skip it.

234+ _ = iter.next(); _ = iter.next(); _ = iter.next()

235+ }

236+ utf8 = UTF8()

237+ }

238+

239+ mutating func next() -> UnicodeScalar? {

240+ switch utf8.decode(&iter) {

241+ case .scalarValue(let scalar): return scalar

242+ case .error: return "\u{FFFD}"

243+ case .emptyInput: return nil

244+ }

245+ }

246+

247+ private let data: NSData

248+ private var iter: UnsafeBufferPointerIterator<UInt8>

249+ private var utf8: UTF8

250+ }

251+ }

252+

253+ private struct UTF16Decoder: Sequence {

254+ /// Checks if the data has a UTF-16 BOM, and if so, returns the endianness.

255+ static func checkBOM(for data: Data) -> Endian? {

256+ guard data.count >= 2 else { return nil }

257+ switch (data[0], data[1]) {

258+ case (0xFE, 0xFF): return .big

259+ case (0xFF, 0xFE): return .little

260+ default: return nil

261+ }

262+ }

263+

264+ enum Endian {

265+ case big

266+ case little

267+ }

268+

269+ init(data: Data, endian: Endian) {

270+ self.data = data as NSData

271+ self.endian = endian

272+ }

273+

274+ func makeIterator() -> Iterator {

275+ return Iterator(data: data, endian: endian)

276+ }

277+

278+ private let data: NSData

279+ private let endian: Endian

280+

281+ fileprivate struct Iterator: IteratorProtocol {

282+ init(data: NSData, endian: Endian) {

283+ iter = DataIterator(data: data, endian: endian)

284+ utf16 = UTF16()

285+ }

286+

287+ mutating func next() -> UnicodeScalar? {

288+ switch utf16.decode(&iter) {

289+ case .scalarValue(let scalar): return scalar

290+ case .error: return "\u{FFFD}"

291+ case .emptyInput: return nil

292+ }

293+ }

294+

295+ private var iter: DataIterator

296+ private var utf16: UTF16

297+ }

298+

299+ private struct DataIterator: IteratorProtocol {

300+ init(data: NSData, endian: Endian) {

301+ // NB: We use NSData instead of using Data's iterator because it's significantly faster as of Xcode 8b3

302+ self.data = data

303+ self.endian = endian

304+ let ptr = UnsafeBufferPointer(start: data.bytes.assumingMemoryBound(to: UInt16.self), count: data.length / 2)

305+ iter = ptr.makeIterator()

306+ if !ptr.isEmpty && (ptr[0] == 0xFEFF || ptr[0] == 0xFFFE) {

307+ // Skip the BOM

308+ _ = iter.next()

309+ }

310+ trailingFFFD = data.length % 2 == 1

311+ }

312+

313+ mutating func next() -> UInt16? {

314+ switch (iter.next(), endian) {

315+ case (let x?, .big): return UInt16(bigEndian: x)

316+ case (let x?, .little): return UInt16(littleEndian: x)

317+ case (nil, _) where trailingFFFD:

318+ trailingFFFD = false

319+ return 0xFFFD

320+ default: return nil

321+ }

322+ }

323+

324+ private let data: NSData

325+ private let endian: Endian

326+ private var iter: UnsafeBufferPointerIterator<UInt16>

327+ private var trailingFFFD: Bool

328+ }

329+ }

330+

331+#endif // os(iOS) || os(OSX) || os(watchOS) || os(tvOS)

parsers/test_PMJSON_1_2_0/Parser.swiftnew file+745

@@ -0,0 +1,745 @@

1+//

2+// Decoder.swift

3+// PMJSON

4+//

5+// Created by Kevin Ballard on 10/8/15.

7+//

8+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

9+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license

10+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your

11+// option. This file may not be copied, modified, or distributed

12+// except according to those terms.

13+//

14+

15+#if os(Linux)

16+ import Glibc

17+#else

18+ import Darwin

19+#endif

20+

21+/// A streaming JSON parser that consumes a sequence of unicode scalars.

22+public struct JSONParser<Seq: Sequence>: Sequence where Seq.Iterator.Element == UnicodeScalar {

23+ public init(_ seq: Seq, options: JSONParserOptions = []) {

24+ base = seq

25+ self.options = options

26+ }

27+

28+ /// Options to apply to the parser.

29+ /// See `JSONParserOptions` for details.

30+ var options: JSONParserOptions

31+

32+ @available(*, deprecated, renamed: "options.strict")

33+ public var strict: Bool {

34+ get { return options.strict }

35+ set { options.strict = newValue }

36+ }

37+

38+ @available(*, deprecated, renamed: "options.streaming")

39+ public var streaming: Bool {

40+ get { return options.streaming }

41+ set { options.streaming = newValue }

42+ }

43+

44+ public func makeIterator() -> JSONParserIterator<Seq.Iterator> {

45+ return JSONParserIterator(base.makeIterator(), options: options)

46+ }

47+

48+ private let base: Seq

49+}

50+

51+

52+

53+/// Options that can be used to configure a `JSONParser`.

54+public struct JSONParserOptions {

55+ /// If `true`, the parser strictly conforms to RFC 7159.

56+ /// If `false`, the parser accepts the following extensions:

57+ /// - Trailing commas.

58+ /// - Less restrictive about numbers, such as `-01` or `-.123`.

59+ ///

60+ /// The default value is `false`.

61+ public var strict: Bool = false

62+

63+ /// If `true`, the parser will parse a stream of json values with optional whitespace delimiters.

64+ /// The default value of `false` makes the parser emit an error if there are any non-whitespace

65+ /// characters after the first JSON value.

66+ ///

67+ /// For example, with the input `"[1] [2,3]"`, if `streaming` is `true` the parser will emit

68+ /// events for the second JSON array after the first one, but if `streaming` is `false` it will

69+ /// emit an error upon encountering the second `[`.

70+ ///

71+ /// - Note: If `streaming` is `true` and the input is empty (or contains only whitespace), the

72+ /// parser will return `nil` instead of emitting an `.unexpectedEOF` error.

73+ ///

74+ /// The default value is `false`.

75+ public var streaming: Bool = false

76+

77+ /// Returns a new `JSONParserOptions` with default values.

78+ public init() {}

79+

80+ /// Returns a new `JSONParserOptions`.

81+ /// - Parameter strict: Whether the parser should be strict. Defaults to `false`.

82+ /// - Parameter streaming: Whether the parser should operate in streaming mode. Defaults to `false`.

83+ public init(strict: Bool = false, streaming: Bool = false) {

84+ self.strict = strict

85+ self.streaming = streaming

86+ }

87+}

88+

89+extension JSONParserOptions: ExpressibleByArrayLiteral {

90+ public enum Element {

91+ case strict

92+ case streaming

93+ }

94+

95+ public init(arrayLiteral elements: Element...) {

96+ for elt in elements {

97+ switch elt {

98+ case .strict: strict = true

99+ case .streaming: streaming = true

100+ }

101+ }

102+ }

103+}

104+

105+/// The iterator for `JSONParser`.

106+public struct JSONParserIterator<Iter: IteratorProtocol>: JSONEventIterator where Iter.Element == UnicodeScalar {

107+ public init(_ iter: Iter, options: JSONParserOptions = []) {

108+ base = PeekIterator(iter)

109+ self.options = options

110+ }

111+

112+ /// Options to apply to the parser.

113+ /// See `JSONParserOptions` for details.

114+ public var options: JSONParserOptions

115+

116+ @available(*, deprecated, renamed: "options.strict")

117+ public var strict: Bool {

118+ get { return options.strict }

119+ set { options.strict = newValue }

120+ }

121+

122+ @available(*, deprecated, renamed: "options.strict")

123+ public var streaming: Bool {

124+ get { return options.streaming }

125+ set { options.streaming = newValue }

126+ }

127+

128+ public mutating func next() -> JSONEvent? {

129+ do {

130+ // the only states that may loop are parseArrayComma, parseObjectComma, and (if streaming) parseEnd,

131+ // which are all guaranteed to shift to other states (if they don't return) so the loop is finite

132+ while true {

133+ switch state {

134+ case .parseArrayComma:

135+ switch skipWhitespace() {

136+ case ","?:

137+ state = .parseArray(first: false)

138+ continue

139+ case "]"?:

140+ try popStack()

141+ return .arrayEnd

142+ case .some:

143+ throw error(.invalidSyntax)

144+ case nil:

145+ throw error(.unexpectedEOF)

146+ }

147+ case .parseObjectComma:

148+ switch skipWhitespace() {

149+ case ","?:

150+ state = .parseObjectKey(first: false)

151+ continue

152+ case "}"?:

153+ try popStack()

154+ return .objectEnd

155+ case .some:

156+ throw error(.invalidSyntax)

157+ case nil:

158+ throw error(.unexpectedEOF)

159+ }

160+ case .initial:

161+ guard let c = skipWhitespace() else {

162+ if options.streaming {

163+ state = .finished

164+ return nil

165+ } else {

166+ throw error(.unexpectedEOF)

167+ }

168+ }

169+ let evt = try parseValue(c)

170+ switch evt {

171+ case .arrayStart, .objectStart:

172+ break

173+ default:

174+ state = .parseEnd

175+ }

176+ return evt

177+ case .parseArray(let first):

178+ guard let c = skipWhitespace() else { throw error(.unexpectedEOF) }

179+ switch c {

180+ case "]":

181+ if !first && options.strict {

182+ throw error(.trailingComma)

183+ }

184+ try popStack()

185+ return .arrayEnd

186+ case ",":

187+ throw error(.missingValue)

188+ default:

189+ let evt = try parseValue(c)

190+ switch evt {

191+ case .arrayStart, .objectStart:

192+ break

193+ default:

194+ state = .parseArrayComma

195+ }

196+ return evt

197+ }

198+ case .parseObjectKey(let first):

199+ guard let c = skipWhitespace() else { throw error(.unexpectedEOF) }

200+ switch c {

201+ case "}":

202+ if !first && options.strict {

203+ throw error(.trailingComma)

204+ }

205+ try popStack()

206+ return .objectEnd

207+ case ",", ":":

208+ throw error(.missingKey)

209+ default:

210+ let evt = try parseValue(c)

211+ switch evt {

212+ case .stringValue:

213+ state = .parseObjectValue

214+ default:

215+ throw error(.nonStringKey)

216+ }

217+ return evt

218+ }

219+ case .parseObjectValue:

220+ guard skipWhitespace() == ":" else { throw error(.expectedColon) }

221+ guard let c = skipWhitespace() else { throw error(.unexpectedEOF) }

222+ switch c {

223+ case ",", "}":

224+ throw error(.missingValue)

225+ default:

226+ let evt = try parseValue(c)

227+ switch evt {

228+ case .arrayStart, .objectStart:

229+ break

230+ default:

231+ state = .parseObjectComma

232+ }

233+ return evt

234+ }

235+ case .parseEnd:

236+ if options.streaming {

237+ state = .initial

238+ } else if skipWhitespace() != nil {

239+ throw error(.trailingCharacters)

240+ } else {

241+ state = .finished

242+ return nil

243+ }

244+ case .finished:

245+ return nil

246+ }

247+ }

248+ } catch let error as JSONParserError {

249+ state = .finished

250+ return .error(error)

251+ } catch {

252+ fatalError("unexpected error \(error)")

253+ }

254+ }

255+

256+ private mutating func popStack() throws {

257+ if stack.popLast() == nil {

258+ fatalError("exhausted stack")

259+ }

260+ switch stack.last {

261+ case .array?:

262+ state = .parseArrayComma

263+ case .object?:

264+ state = .parseObjectComma

265+ case nil:

266+ state = .parseEnd

267+ }

268+ }

269+

270+ private mutating func parseValue(_ c: UnicodeScalar) throws -> JSONEvent {

271+ switch c {

272+ case "[":

273+ state = .parseArray(first: true)

274+ stack.append(.array)

275+ return .arrayStart

276+ case "{":

277+ state = .parseObjectKey(first: true)

278+ stack.append(.object)

279+ return .objectStart

280+ case "\"":

281+ var scalars = String.UnicodeScalarView()

282+ while let c = bump() {

283+ switch c {

284+ case "\"":

285+ return .stringValue(String(scalars))

286+ case "\\":

287+ let c = try bumpRequired()

288+ switch c {

289+ case "\"", "\\", "/": scalars.append(c)

290+ case "b": scalars.append(UnicodeScalar(0x8))

291+ case "f": scalars.append(UnicodeScalar(0xC))

292+ case "n": scalars.append("\n" as UnicodeScalar)

293+ case "r": scalars.append("\r" as UnicodeScalar)

294+ case "t": scalars.append("\t" as UnicodeScalar)

295+ case "u":

296+ let codeUnit = try parseFourHex()

297+ if UTF16.isLeadSurrogate(codeUnit) {

298+ guard try (bumpRequired() == "\\" && bumpRequired() == "u") else {

299+ throw error(.invalidSurrogateEscape)

300+ }

301+ let trail = try parseFourHex()

302+ if UTF16.isTrailSurrogate(trail) {

303+ let lead = UInt32(codeUnit)

304+ let trail = UInt32(trail)

305+ // NB: The following is split up to avoid exponential time complexity in the type checker

306+ let leadComponent: UInt32 = (lead - 0xD800) << 10

307+ let trailComponent: UInt32 = trail - 0xDC00

308+ let scalar = UnicodeScalar(leadComponent + trailComponent + 0x10000)!

309+ scalars.append(scalar)

310+ } else {

311+ throw error(.invalidSurrogateEscape)

312+ }

313+ } else if let scalar = UnicodeScalar(codeUnit) {

314+ scalars.append(scalar)

315+ } else {

316+ // Must be a lone trail surrogate

317+ throw error(.invalidSurrogateEscape)

318+ }

319+ default:

320+ throw error(.invalidEscape)

321+ }

322+ case "\0"..."\u{1F}":

323+ throw error(.invalidSyntax)

324+ default:

325+ scalars.append(c)

326+ }

327+ }

328+ throw error(.unexpectedEOF)

329+ case "-", "0"..."9":

330+ var tempBuffer: ContiguousArray<Int8>

331+ if let buffer = replace(&self.tempBuffer, with: nil) {

332+ tempBuffer = buffer

333+ tempBuffer.removeAll(keepingCapacity: true)

334+ } else {

335+ tempBuffer = ContiguousArray()

336+ tempBuffer.reserveCapacity(12)

337+ }

338+ defer { self.tempBuffer = tempBuffer }

339+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

340+ if options.strict {

341+ let digit: UnicodeScalar

342+ if c == "-" {

343+ guard let c2 = bump(), case "0"..."9" = c2 else { throw error(.invalidNumber) }

344+ digit = c2

345+ tempBuffer.append(Int8(truncatingBitPattern: digit.value))

346+ } else {

347+ digit = c

348+ }

349+ if digit == "0", case ("0"..."9")? = base.peek() {

350+ // In strict mode, you can't have numbers like 01

351+ throw error(.invalidNumber)

352+ }

353+ }

354+ /// Invoke this after parsing the "e" character.

355+ @inline(__always) func parseExponent() throws -> Double {

356+ let c = try bumpRequired()

357+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

358+ switch c {

359+ case "-", "+":

360+ guard let c = bump(), case "0"..."9" = c else { throw error(.invalidNumber) }

361+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

362+ case "0"..."9": break

363+ default: throw error(.invalidNumber)

364+ }

365+ loop: while let c = base.peek() {

366+ switch c {

367+ case "0"..."9":

368+ bump()

369+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

370+ default:

371+ break loop

372+ }

373+ }

374+ tempBuffer.append(0)

375+ return tempBuffer.withUnsafeBufferPointer({strtod($0.baseAddress, nil)})

376+ }

377+ outerLoop: while let c = base.peek() {

378+ switch c {

379+ case "0"..."9":

380+ bump()

381+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

382+ case ".":

383+ bump()

384+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

385+ guard let c = bump(), case "0"..."9" = c else { throw error(.invalidNumber) }

386+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

387+ loop: while let c = base.peek() {

388+ switch c {

389+ case "0"..."9":

390+ bump()

391+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

392+ case "e", "E":

393+ bump()

394+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

395+ return try .doubleValue(parseExponent())

396+ default:

397+ break loop

398+ }

399+ }

400+ tempBuffer.append(0)

401+ return .doubleValue(tempBuffer.withUnsafeBufferPointer({strtod($0.baseAddress, nil)}))

402+ case "e", "E":

403+ bump()

404+ tempBuffer.append(Int8(truncatingBitPattern: c.value))

405+ return try .doubleValue(parseExponent())

406+ default:

407+ break outerLoop

408+ }

409+ }

410+ if tempBuffer.count == 1 && tempBuffer[0] == 0x2d /* - */ {

411+ throw error(.invalidNumber)

412+ }

413+ tempBuffer.append(0)

414+ let num = tempBuffer.withUnsafeBufferPointer({ ptr -> Int64? in

415+ errno = 0

416+ let n = strtoll(ptr.baseAddress, nil, 10)

417+ if n == 0 && errno != 0 {

418+ return nil

419+ } else {

420+ return n

421+ }

422+ })

423+ if let num = num {

424+ return .int64Value(num)

425+ }

426+ // out of range, fall back to Double

427+ return .doubleValue(tempBuffer.withUnsafeBufferPointer({strtod($0.baseAddress, nil)}))

428+ case "t":

429+ let line = self.line, column = self.column

430+ guard case "r"? = bump(), case "u"? = bump(), case "e"? = bump() else {

431+ throw JSONParserError(code: .invalidSyntax, line: line, column: column)

432+ }

433+ return .booleanValue(true)

434+ case "f":

435+ let line = self.line, column = self.column

436+ guard case "a"? = bump(), case "l"? = bump(), case "s"? = bump(), case "e"? = bump() else {

437+ throw JSONParserError(code: .invalidSyntax, line: line, column: column)

438+ }

439+ return .booleanValue(false)

440+ case "n":

441+ let line = self.line, column = self.column

442+ guard case "u"? = bump(), case "l"? = bump(), case "l"? = bump() else {

443+ throw JSONParserError(code: .invalidSyntax, line: line, column: column)

444+ }

445+ return .nullValue

446+ default:

447+ throw error(.invalidSyntax)

448+ }

449+ }

450+

451+ private mutating func skipWhitespace() -> UnicodeScalar? {

452+ while let c = bump() {

453+ switch c {

454+ case " ", "\t", "\n", "\r": continue

455+ default: return c

456+ }

457+ }

458+ return nil

459+ }

460+

461+ private mutating func parseFourHex() throws -> UInt16 {

462+ var codepoint: UInt32 = 0

463+ for _ in 0..<4 {

464+ let c = try bumpRequired()

465+ codepoint <<= 4

466+ switch c {

467+ case "0"..."9":

468+ codepoint += c.value - 48

469+ case "a"..."f":

470+ codepoint += c.value - 87

471+ case "A"..."F":

472+ codepoint += c.value - 55

473+ default:

474+ throw error(.invalidEscape)

475+ }

476+ }

477+ return UInt16(truncatingBitPattern: codepoint)

478+ }

479+

480+ @inline(__always) @discardableResult private mutating func bump() -> UnicodeScalar? {

481+ let c = base.next()

482+ if c == "\n" {

483+ line += 1

484+ column = 0

485+ } else {

486+ column += 1

487+ }

488+ return c

489+ }

490+

491+ @inline(__always) private mutating func bumpRequired() throws -> UnicodeScalar {

492+ guard let c = bump() else { throw error(.unexpectedEOF) }

493+ return c

494+ }

495+

496+ private func error(_ code: JSONParserError.Code) -> JSONParserError {

497+ return JSONParserError(code: code, line: line, column: column)

498+ }

499+

500+ /// The line of the last emitted token.

501+ public private(set) var line: UInt = 0

502+ /// The column of the last emitted token.

503+ public private(set) var column: UInt = 0

504+

505+ private var base: PeekIterator<Iter>

506+ private var state: State = .initial

507+ private var stack: [Stack] = []

508+ private var tempBuffer: ContiguousArray<Int8>?

509+}

510+

511+@available(*, renamed: "JSONParserIterator")

512+typealias JSONParserGenerator<Gen: IteratorProtocol> = JSONParserIterator<Gen> where Gen.Element == UnicodeScalar

513+

514+private enum State {

515+ /// Initial state

516+ case initial

517+ /// Parse an element or the end of the array

518+ case parseArray(first: Bool)

519+ /// Parse a comma or the end of the array

520+ case parseArrayComma

521+ /// Parse an object key or the end of the array

522+ case parseObjectKey(first: Bool)

523+ /// Parse a colon followed by an object value

524+ case parseObjectValue

525+ /// Parse a comma or the end of the object

526+ case parseObjectComma

527+ /// Parse whitespace or EOF

528+ case parseEnd

529+ /// Parsing has completed

530+ case finished

531+}

532+

533+private enum Stack {

534+ case array

535+ case object

536+}

537+

538+/// A streaming JSON parser event.

539+public enum JSONEvent: Hashable {

540+ /// The start of an object.

541+ /// Inside of an object, each key/value pair is emitted as a

542+ /// `StringValue` for the key followed by the `JSONEvent` sequence

543+ /// that describes the value.

544+ case objectStart

545+ /// The end of an object.

546+ case objectEnd

547+ /// The start of an array.

548+ case arrayStart

549+ /// The end of an array.

550+ case arrayEnd

551+ /// A boolean value.

552+ case booleanValue(Bool)

553+ /// A signed 64-bit integral value.

554+ case int64Value(Int64)

555+ /// A double value.

556+ case doubleValue(Double)

557+ /// A string value.

558+ case stringValue(String)

559+ /// The null value.

560+ case nullValue

561+ /// A parser error.

562+ case error(JSONParserError)

563+

564+ public var hashValue: Int {

565+ switch self {

566+ case .objectStart: return 1

567+ case .objectEnd: return 2

568+ case .arrayStart: return 3

569+ case .arrayEnd: return 4

570+ case .booleanValue(let b): return b.hashValue << 4 + 5

571+ case .int64Value(let i): return i.hashValue << 4 + 6

572+ case .doubleValue(let d): return d.hashValue << 4 + 7

573+ case .stringValue(let s): return s.hashValue << 4 + 8

574+ case .nullValue: return 9

575+ case .error(let error): return error.hashValue << 4 + 10

576+ }

577+ }

578+

579+ public static func ==(lhs: JSONEvent, rhs: JSONEvent) -> Bool {

580+ switch (lhs, rhs) {

581+ case (.objectStart, .objectStart), (.objectEnd, .objectEnd),

582+ (.arrayStart, .arrayStart), (.arrayEnd, .arrayEnd), (.nullValue, .nullValue):

583+ return true

584+ case let (.booleanValue(a), .booleanValue(b)):

585+ return a == b

586+ case let (.int64Value(a), .int64Value(b)):

587+ return a == b

588+ case let (.doubleValue(a), .doubleValue(b)):

589+ return a == b

590+ case let (.stringValue(a), .stringValue(b)):

591+ return a == b

592+ case let (.error(a), .error(b)):

593+ return a == b

594+ default:

595+ return false

596+ }

597+ }

598+}

599+

600+/// An iterator of `JSONEvent`s that records column/line info.

601+public protocol JSONEventIterator: IteratorProtocol {

602+ /// The line of the last emitted token.

603+ var line: UInt { get }

604+ /// The column of the last emitted token.

605+ var column: UInt { get }

606+}

607+

608+@available(*, renamed: "JSONEventIterator")

609+public typealias JSONEventGenerator = JSONEventIterator

610+

611+public struct JSONParserError: Error, Hashable, CustomStringConvertible {

612+ /// A generic syntax error.

613+ public static let invalidSyntax: Code = .invalidSyntax

614+ /// An invalid number.

615+ public static let invalidNumber: Code = .invalidNumber

616+ /// An invalid string escape.

617+ public static let invalidEscape: Code = .invalidEscape

618+ /// A unicode string escape with an invalid code point.

619+ public static let invalidUnicodeScalar: Code = .invalidUnicodeScalar

620+ /// A unicode string escape representing a leading surrogate that wasn't followed

621+ /// by a trailing surrogate, or a trailing surrogate that wasn't preceeded

622+ /// by a leading surrogate.

623+ public static let invalidSurrogateEscape: Code = .invalidSurrogateEscape

624+ /// A control character in a string.

625+ public static let controlCharacterInString: Code = .controlCharacterInString

626+ /// A comma was found where a colon was expected in an object.

627+ public static let expectedColon: Code = .expectedColon

628+ /// A comma or colon was found in an object without a key.

629+ public static let missingKey: Code = .missingKey

630+ /// An object key was found that was not a string.

631+ public static let nonStringKey: Code = .nonStringKey

632+ /// A comma or object end was encountered where a value was expected.

633+ public static let missingValue: Code = .missingValue

634+ /// A trailing comma was found in an array or object. Only emitted when the parser is in strict mode.

635+ public static let trailingComma: Code = .trailingComma

636+ /// Trailing (non-whitespace) characters found after the close

637+ /// of the root value.

638+ /// - Note: This error cannot be thrown if the parser is in streaming mode.

639+ public static let trailingCharacters: Code = .trailingCharacters

640+ /// EOF was found before the root value finished parsing.

641+ public static let unexpectedEOF: Code = .unexpectedEOF

642+

643+ @available(*, unavailable, renamed: "invalidSurrogateEscape")

644+ public static let loneLeadingSurrogateInUnicodeEscape: Code = .invalidSurrogateEscape

645+

646+ public let code: Code

647+ public let line: UInt

648+ public let column: UInt

649+

650+ public init(code: Code, line: UInt, column: UInt) {

651+ self.code = code

652+ self.line = line

653+ self.column = column

654+ }

655+

656+ public var _code: Int { return code.rawValue }

657+

658+ public enum Code: Int {

659+ /// A generic syntax error.

660+ case invalidSyntax

661+ /// An invalid number.

662+ case invalidNumber

663+ /// An invalid string escape.

664+ case invalidEscape

665+ /// A unicode string escape with an invalid code point.

666+ case invalidUnicodeScalar

667+ /// A unicode string escape representing a leading surrogate that wasn't followed

668+ /// by a trailing surrogate, or a trailing surrogate that wasn't preceeded

669+ /// by a leading surrogate.

670+ case invalidSurrogateEscape

671+ /// A control character in a string.

672+ case controlCharacterInString

673+ /// A comma was found where a colon was expected in an object.

674+ case expectedColon

675+ /// A comma or colon was found in an object without a key.

676+ case missingKey

677+ /// An object key was found that was not a string.

678+ case nonStringKey

679+ /// A comma or object end was encountered where a value was expected.

680+ case missingValue

681+ /// A trailing comma was found in an array or object. Only emitted when the parser is in strict mode.

682+ case trailingComma

683+ /// Trailing (non-whitespace) characters found after the close

684+ /// of the root value.

685+ /// - Note: This error cannot be thrown if the parser is in streaming mode.

686+ case trailingCharacters

687+ /// EOF was found before the root value finished parsing.

688+ case unexpectedEOF

689+

690+ @available(*, unavailable, renamed: "invalidSurrogateEscape")

691+ static let loneLeadingSurrogateInUnicodeEscape: Code = .invalidSurrogateEscape

692+

693+ public static func ~=(lhs: Code, rhs: Error) -> Bool {

694+ if let error = rhs as? JSONParserError {

695+ return lhs == error.code

696+ } else {

697+ return false

698+ }

699+ }

700+ }

701+

702+ public var description: String {

703+ return "JSONParserError(\(code), line: \(line), column: \(column))"

704+ }

705+

706+ public var hashValue: Int {

707+ return Int(bitPattern: line << 18) ^ Int(bitPattern: column << 4) ^ code.rawValue

708+ }

709+

710+ public static func ==(lhs: JSONParserError, rhs: JSONParserError) -> Bool {

711+ return (lhs.code, lhs.line, lhs.column) == (rhs.code, rhs.line, rhs.column)

712+ }

713+}

714+

715+private struct PeekIterator<Base: IteratorProtocol> {

716+ init(_ base: Base) {

717+ self.base = base

718+ }

719+

720+ mutating func peek() -> Base.Element? {

721+ if let elt = peeked {

722+ return elt

723+ }

724+ let elt = base.next()

725+ peeked = .some(elt)

726+ return elt

727+ }

728+

729+ mutating func next() -> Base.Element? {

730+ if let elt = peeked {

731+ peeked = nil

732+ return elt

733+ }

734+ return base.next()

735+ }

736+

737+ private var base: Base

738+ private var peeked: Base.Element??

739+}

740+

741+private func replace<T>(_ a: inout T, with b: T) -> T {

742+ var b = b

743+ swap(&a, &b)

744+ return b

745+}

parsers/test_PMJSON_1_2_0/bin/test_PMJSONnew file

Binary file not shown.

parsers/test_PMJSON_1_2_0/test_PMJSON.xcodeproj/project.pbxprojnew file+296

@@ -0,0 +1,296 @@

1+// !$*UTF8*$!

2+{

3+ archiveVersion = 1;

4+ classes = {

5+ };

6+ objectVersion = 46;

7+ objects = {

9+/* Begin PBXBuildFile section */

10+ 035C82521DC13EED00CDC48D /* main.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C82511DC13EED00CDC48D /* main.swift */; };

11+ 035C82611DC13F1B00CDC48D /* Accessors.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C82581DC13F1B00CDC48D /* Accessors.swift */; };

12+ 035C82621DC13F1B00CDC48D /* DecimalNumber.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C82591DC13F1B00CDC48D /* DecimalNumber.swift */; };

13+ 035C82631DC13F1B00CDC48D /* Decoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C825A1DC13F1B00CDC48D /* Decoder.swift */; };

14+ 035C82641DC13F1B00CDC48D /* Encoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C825B1DC13F1B00CDC48D /* Encoder.swift */; };

15+ 035C82651DC13F1B00CDC48D /* JSON.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C825C1DC13F1B00CDC48D /* JSON.swift */; };

16+ 035C82661DC13F1B00CDC48D /* JSONError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C825D1DC13F1B00CDC48D /* JSONError.swift */; };

17+ 035C82671DC13F1B00CDC48D /* JSONObject.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C825E1DC13F1B00CDC48D /* JSONObject.swift */; };

18+ 035C82681DC13F1B00CDC48D /* ObjectiveC.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C825F1DC13F1B00CDC48D /* ObjectiveC.swift */; };

19+ 035C82691DC13F1B00CDC48D /* Parser.swift in Sources */ = {isa = PBXBuildFile; fileRef = 035C82601DC13F1B00CDC48D /* Parser.swift */; };

20+/* End PBXBuildFile section */

21+

22+/* Begin PBXCopyFilesBuildPhase section */

23+ 035C824C1DC13EED00CDC48D /* CopyFiles */ = {

24+ isa = PBXCopyFilesBuildPhase;

25+ buildActionMask = 2147483647;

26+ dstPath = /usr/share/man/man1/;

27+ dstSubfolderSpec = 0;

28+ files = (

29+ );

30+ runOnlyForDeploymentPostprocessing = 1;

31+ };

32+/* End PBXCopyFilesBuildPhase section */

33+

34+/* Begin PBXFileReference section */

35+ 035C824E1DC13EED00CDC48D /* test_PMJSON */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = test_PMJSON; sourceTree = BUILT_PRODUCTS_DIR; };

36+ 035C82511DC13EED00CDC48D /* main.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = main.swift; sourceTree = "<group>"; };

37+ 035C82581DC13F1B00CDC48D /* Accessors.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Accessors.swift; sourceTree = "<group>"; };

38+ 035C82591DC13F1B00CDC48D /* DecimalNumber.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DecimalNumber.swift; sourceTree = "<group>"; };

39+ 035C825A1DC13F1B00CDC48D /* Decoder.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Decoder.swift; sourceTree = "<group>"; };

40+ 035C825B1DC13F1B00CDC48D /* Encoder.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Encoder.swift; sourceTree = "<group>"; };

41+ 035C825C1DC13F1B00CDC48D /* JSON.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSON.swift; sourceTree = "<group>"; };

42+ 035C825D1DC13F1B00CDC48D /* JSONError.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONError.swift; sourceTree = "<group>"; };

43+ 035C825E1DC13F1B00CDC48D /* JSONObject.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONObject.swift; sourceTree = "<group>"; };

44+ 035C825F1DC13F1B00CDC48D /* ObjectiveC.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ObjectiveC.swift; sourceTree = "<group>"; };

45+ 035C82601DC13F1B00CDC48D /* Parser.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Parser.swift; sourceTree = "<group>"; };

46+/* End PBXFileReference section */

47+

48+/* Begin PBXFrameworksBuildPhase section */

49+ 035C824B1DC13EED00CDC48D /* Frameworks */ = {

50+ isa = PBXFrameworksBuildPhase;

51+ buildActionMask = 2147483647;

52+ files = (

53+ );

54+ runOnlyForDeploymentPostprocessing = 0;

55+ };

56+/* End PBXFrameworksBuildPhase section */

57+

58+/* Begin PBXGroup section */

59+ 035C82451DC13EED00CDC48D = {

60+ isa = PBXGroup;

61+ children = (

62+ 035C82581DC13F1B00CDC48D /* Accessors.swift */,

63+ 035C82591DC13F1B00CDC48D /* DecimalNumber.swift */,

64+ 035C825A1DC13F1B00CDC48D /* Decoder.swift */,

65+ 035C825B1DC13F1B00CDC48D /* Encoder.swift */,

66+ 035C825C1DC13F1B00CDC48D /* JSON.swift */,

67+ 035C825D1DC13F1B00CDC48D /* JSONError.swift */,

68+ 035C825E1DC13F1B00CDC48D /* JSONObject.swift */,

69+ 035C825F1DC13F1B00CDC48D /* ObjectiveC.swift */,

70+ 035C82601DC13F1B00CDC48D /* Parser.swift */,

71+ 035C82501DC13EED00CDC48D /* test_PMJSON */,

72+ 035C824F1DC13EED00CDC48D /* Products */,

73+ );

74+ sourceTree = "<group>";

75+ };

76+ 035C824F1DC13EED00CDC48D /* Products */ = {

77+ isa = PBXGroup;

78+ children = (

79+ 035C824E1DC13EED00CDC48D /* test_PMJSON */,

80+ );

81+ name = Products;

82+ sourceTree = "<group>";

83+ };

84+ 035C82501DC13EED00CDC48D /* test_PMJSON */ = {

85+ isa = PBXGroup;

86+ children = (

87+ 035C82511DC13EED00CDC48D /* main.swift */,

88+ );

89+ path = test_PMJSON;

90+ sourceTree = "<group>";

91+ };

92+/* End PBXGroup section */

93+

94+/* Begin PBXNativeTarget section */

95+ 035C824D1DC13EED00CDC48D /* test_PMJSON */ = {

96+ isa = PBXNativeTarget;

97+ buildConfigurationList = 035C82551DC13EED00CDC48D /* Build configuration list for PBXNativeTarget "test_PMJSON" */;

98+ buildPhases = (

99+ 035C824A1DC13EED00CDC48D /* Sources */,

100+ 035C824B1DC13EED00CDC48D /* Frameworks */,

101+ 035C824C1DC13EED00CDC48D /* CopyFiles */,

102+ );

103+ buildRules = (

104+ );

105+ dependencies = (

106+ );

107+ name = test_PMJSON;

108+ productName = test_PMJSON;

109+ productReference = 035C824E1DC13EED00CDC48D /* test_PMJSON */;

110+ productType = "com.apple.product-type.tool";

111+ };

112+/* End PBXNativeTarget section */

113+

114+/* Begin PBXProject section */

115+ 035C82461DC13EED00CDC48D /* Project object */ = {

116+ isa = PBXProject;

117+ attributes = {

118+ LastSwiftUpdateCheck = 0800;

119+ LastUpgradeCheck = 0800;

120+ ORGANIZATIONNAME = "Nicolas Seriot";

121+ TargetAttributes = {

122+ 035C824D1DC13EED00CDC48D = {

123+ CreatedOnToolsVersion = 8.0;

124+ DevelopmentTeam = VBYRKYS73S;

125+ ProvisioningStyle = Automatic;

126+ };

127+ };

128+ };

129+ buildConfigurationList = 035C82491DC13EED00CDC48D /* Build configuration list for PBXProject "test_PMJSON" */;

130+ compatibilityVersion = "Xcode 3.2";

131+ developmentRegion = English;

132+ hasScannedForEncodings = 0;

133+ knownRegions = (

134+ en,

135+ );

136+ mainGroup = 035C82451DC13EED00CDC48D;

137+ productRefGroup = 035C824F1DC13EED00CDC48D /* Products */;

138+ projectDirPath = "";

139+ projectRoot = "";

140+ targets = (

141+ 035C824D1DC13EED00CDC48D /* test_PMJSON */,

142+ );

143+ };

144+/* End PBXProject section */

145+

146+/* Begin PBXSourcesBuildPhase section */

147+ 035C824A1DC13EED00CDC48D /* Sources */ = {

148+ isa = PBXSourcesBuildPhase;

149+ buildActionMask = 2147483647;

150+ files = (

151+ 035C82611DC13F1B00CDC48D /* Accessors.swift in Sources */,

152+ 035C82661DC13F1B00CDC48D /* JSONError.swift in Sources */,

153+ 035C82691DC13F1B00CDC48D /* Parser.swift in Sources */,

154+ 035C82521DC13EED00CDC48D /* main.swift in Sources */,

155+ 035C82641DC13F1B00CDC48D /* Encoder.swift in Sources */,

156+ 035C82671DC13F1B00CDC48D /* JSONObject.swift in Sources */,

157+ 035C82651DC13F1B00CDC48D /* JSON.swift in Sources */,

158+ 035C82631DC13F1B00CDC48D /* Decoder.swift in Sources */,

159+ 035C82621DC13F1B00CDC48D /* DecimalNumber.swift in Sources */,

160+ 035C82681DC13F1B00CDC48D /* ObjectiveC.swift in Sources */,

161+ );

162+ runOnlyForDeploymentPostprocessing = 0;

163+ };

164+/* End PBXSourcesBuildPhase section */

165+

166+/* Begin XCBuildConfiguration section */

167+ 035C82531DC13EED00CDC48D /* Debug */ = {

168+ isa = XCBuildConfiguration;

169+ buildSettings = {

170+ ALWAYS_SEARCH_USER_PATHS = NO;

171+ CLANG_ANALYZER_NONNULL = YES;

172+ CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";

173+ CLANG_CXX_LIBRARY = "libc++";

174+ CLANG_ENABLE_MODULES = YES;

175+ CLANG_ENABLE_OBJC_ARC = YES;

176+ CLANG_WARN_BOOL_CONVERSION = YES;

177+ CLANG_WARN_CONSTANT_CONVERSION = YES;

178+ CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;

179+ CLANG_WARN_DOCUMENTATION_COMMENTS = YES;

180+ CLANG_WARN_EMPTY_BODY = YES;

181+ CLANG_WARN_ENUM_CONVERSION = YES;

182+ CLANG_WARN_INFINITE_RECURSION = YES;

183+ CLANG_WARN_INT_CONVERSION = YES;

184+ CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;

185+ CLANG_WARN_SUSPICIOUS_MOVES = YES;

186+ CLANG_WARN_UNREACHABLE_CODE = YES;

187+ CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;

188+ CODE_SIGN_IDENTITY = "-";

189+ COPY_PHASE_STRIP = NO;

190+ DEBUG_INFORMATION_FORMAT = dwarf;

191+ ENABLE_STRICT_OBJC_MSGSEND = YES;

192+ ENABLE_TESTABILITY = YES;

193+ GCC_C_LANGUAGE_STANDARD = gnu99;

194+ GCC_DYNAMIC_NO_PIC = NO;

195+ GCC_NO_COMMON_BLOCKS = YES;

196+ GCC_OPTIMIZATION_LEVEL = 0;

197+ GCC_PREPROCESSOR_DEFINITIONS = (

198+ "DEBUG=1",

199+ "$(inherited)",

200+ );

201+ GCC_WARN_64_TO_32_BIT_CONVERSION = YES;

202+ GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;

203+ GCC_WARN_UNDECLARED_SELECTOR = YES;

204+ GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;

205+ GCC_WARN_UNUSED_FUNCTION = YES;

206+ GCC_WARN_UNUSED_VARIABLE = YES;

207+ MACOSX_DEPLOYMENT_TARGET = 10.12;

208+ MTL_ENABLE_DEBUG_INFO = YES;

209+ ONLY_ACTIVE_ARCH = YES;

210+ SDKROOT = macosx;

211+ SWIFT_OPTIMIZATION_LEVEL = "-Onone";

212+ };

213+ name = Debug;

214+ };

215+ 035C82541DC13EED00CDC48D /* Release */ = {

216+ isa = XCBuildConfiguration;

217+ buildSettings = {

218+ ALWAYS_SEARCH_USER_PATHS = NO;

219+ CLANG_ANALYZER_NONNULL = YES;

220+ CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";

221+ CLANG_CXX_LIBRARY = "libc++";

222+ CLANG_ENABLE_MODULES = YES;

223+ CLANG_ENABLE_OBJC_ARC = YES;

224+ CLANG_WARN_BOOL_CONVERSION = YES;

225+ CLANG_WARN_CONSTANT_CONVERSION = YES;

226+ CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;

227+ CLANG_WARN_DOCUMENTATION_COMMENTS = YES;

228+ CLANG_WARN_EMPTY_BODY = YES;

229+ CLANG_WARN_ENUM_CONVERSION = YES;

230+ CLANG_WARN_INFINITE_RECURSION = YES;

231+ CLANG_WARN_INT_CONVERSION = YES;

232+ CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;

233+ CLANG_WARN_SUSPICIOUS_MOVES = YES;

234+ CLANG_WARN_UNREACHABLE_CODE = YES;

235+ CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;

236+ CODE_SIGN_IDENTITY = "-";

237+ COPY_PHASE_STRIP = NO;

238+ DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";

239+ ENABLE_NS_ASSERTIONS = NO;

240+ ENABLE_STRICT_OBJC_MSGSEND = YES;

241+ GCC_C_LANGUAGE_STANDARD = gnu99;

242+ GCC_NO_COMMON_BLOCKS = YES;

243+ GCC_WARN_64_TO_32_BIT_CONVERSION = YES;

244+ GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;

245+ GCC_WARN_UNDECLARED_SELECTOR = YES;

246+ GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;

247+ GCC_WARN_UNUSED_FUNCTION = YES;

248+ GCC_WARN_UNUSED_VARIABLE = YES;

249+ MACOSX_DEPLOYMENT_TARGET = 10.12;

250+ MTL_ENABLE_DEBUG_INFO = NO;

251+ SDKROOT = macosx;

252+ };

253+ name = Release;

254+ };

255+ 035C82561DC13EED00CDC48D /* Debug */ = {

256+ isa = XCBuildConfiguration;

257+ buildSettings = {

258+ DEVELOPMENT_TEAM = VBYRKYS73S;

259+ PRODUCT_NAME = "$(TARGET_NAME)";

260+ SWIFT_VERSION = 3.0;

261+ };

262+ name = Debug;

263+ };

264+ 035C82571DC13EED00CDC48D /* Release */ = {

265+ isa = XCBuildConfiguration;

266+ buildSettings = {

267+ DEVELOPMENT_TEAM = VBYRKYS73S;

268+ PRODUCT_NAME = "$(TARGET_NAME)";

269+ SWIFT_VERSION = 3.0;

270+ };

271+ name = Release;

272+ };

273+/* End XCBuildConfiguration section */

274+

275+/* Begin XCConfigurationList section */

276+ 035C82491DC13EED00CDC48D /* Build configuration list for PBXProject "test_PMJSON" */ = {

277+ isa = XCConfigurationList;

278+ buildConfigurations = (

279+ 035C82531DC13EED00CDC48D /* Debug */,

280+ 035C82541DC13EED00CDC48D /* Release */,

281+ );

282+ defaultConfigurationIsVisible = 0;

283+ defaultConfigurationName = Release;

284+ };

285+ 035C82551DC13EED00CDC48D /* Build configuration list for PBXNativeTarget "test_PMJSON" */ = {

286+ isa = XCConfigurationList;

287+ buildConfigurations = (

288+ 035C82561DC13EED00CDC48D /* Debug */,

289+ 035C82571DC13EED00CDC48D /* Release */,

290+ );

291+ defaultConfigurationIsVisible = 0;

292+ };

293+/* End XCConfigurationList section */

294+ };

295+ rootObject = 035C82461DC13EED00CDC48D /* Project object */;

296+}

parsers/test_PMJSON_1_2_0/test_PMJSON.xcodeproj/project.xcworkspace/contents.xcworkspacedatanew file+7

@@ -0,0 +1,7 @@

1+<?xml version="1.0" encoding="UTF-8"?>

2+<Workspace

3+ version = "1.0">

4+ <FileRef

5+ location = "self:test_PMJSON.xcodeproj">

6+ </FileRef>

7+</Workspace>

parsers/test_PMJSON_1_2_0/test_PMJSON.xcodeproj/project.xcworkspace/xcuserdata/nst.xcuserdatad/UserInterfaceState.xcuserstatenew file

Binary file not shown.

parsers/test_PMJSON_1_2_0/test_PMJSON.xcodeproj/xcuserdata/nst.xcuserdatad/xcschemes/test_PMJSON.xcschemenew file+97

@@ -0,0 +1,97 @@

1+<?xml version="1.0" encoding="UTF-8"?>

2+<Scheme

3+ LastUpgradeVersion = "0800"

4+ version = "1.3">

5+ <BuildAction

6+ parallelizeBuildables = "YES"

7+ buildImplicitDependencies = "YES">

8+ <BuildActionEntries>

9+ <BuildActionEntry

10+ buildForTesting = "YES"

11+ buildForRunning = "YES"

12+ buildForProfiling = "YES"

13+ buildForArchiving = "YES"

14+ buildForAnalyzing = "YES">

15+ <BuildableReference

16+ BuildableIdentifier = "primary"

17+ BlueprintIdentifier = "035C824D1DC13EED00CDC48D"

18+ BuildableName = "test_PMJSON"

19+ BlueprintName = "test_PMJSON"

20+ ReferencedContainer = "container:test_PMJSON.xcodeproj">

21+ </BuildableReference>

22+ </BuildActionEntry>

23+ </BuildActionEntries>

24+ </BuildAction>

25+ <TestAction

26+ buildConfiguration = "Debug"

27+ selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"

28+ selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"

29+ shouldUseLaunchSchemeArgsEnv = "YES">

30+ <Testables>

31+ </Testables>

32+ <MacroExpansion>

33+ <BuildableReference

34+ BuildableIdentifier = "primary"

35+ BlueprintIdentifier = "035C824D1DC13EED00CDC48D"

36+ BuildableName = "test_PMJSON"

37+ BlueprintName = "test_PMJSON"

38+ ReferencedContainer = "container:test_PMJSON.xcodeproj">

39+ </BuildableReference>

40+ </MacroExpansion>

41+ <AdditionalOptions>

42+ </AdditionalOptions>

43+ </TestAction>

44+ <LaunchAction

45+ buildConfiguration = "Debug"

46+ selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"

47+ selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"

48+ launchStyle = "0"

49+ useCustomWorkingDirectory = "NO"

50+ ignoresPersistentStateOnLaunch = "NO"

51+ debugDocumentVersioning = "YES"

52+ debugServiceExtension = "internal"

53+ allowLocationSimulation = "YES">

54+ <BuildableProductRunnable

55+ runnableDebuggingMode = "0">

56+ <BuildableReference

57+ BuildableIdentifier = "primary"

58+ BlueprintIdentifier = "035C824D1DC13EED00CDC48D"

59+ BuildableName = "test_PMJSON"

60+ BlueprintName = "test_PMJSON"

61+ ReferencedContainer = "container:test_PMJSON.xcodeproj">

62+ </BuildableReference>

63+ </BuildableProductRunnable>

64+ <CommandLineArguments>

65+ <CommandLineArgument

66+ argument = "/Users/nst/Projects/JSONTestSuite/test_parsing/i_object_key_lone_2nd_surrogate.json"

67+ isEnabled = "YES">

68+ </CommandLineArgument>

69+ </CommandLineArguments>

70+ <AdditionalOptions>

71+ </AdditionalOptions>

72+ </LaunchAction>

73+ <ProfileAction

74+ buildConfiguration = "Release"

75+ shouldUseLaunchSchemeArgsEnv = "YES"

76+ savedToolIdentifier = ""

77+ useCustomWorkingDirectory = "NO"

78+ debugDocumentVersioning = "YES">

79+ <BuildableProductRunnable

80+ runnableDebuggingMode = "0">

81+ <BuildableReference

82+ BuildableIdentifier = "primary"

83+ BlueprintIdentifier = "035C824D1DC13EED00CDC48D"

84+ BuildableName = "test_PMJSON"

85+ BlueprintName = "test_PMJSON"

86+ ReferencedContainer = "container:test_PMJSON.xcodeproj">

87+ </BuildableReference>

88+ </BuildableProductRunnable>

89+ </ProfileAction>

90+ <AnalyzeAction

91+ buildConfiguration = "Debug">

92+ </AnalyzeAction>

93+ <ArchiveAction

94+ buildConfiguration = "Release"

95+ revealArchiveInOrganizer = "YES">

96+ </ArchiveAction>

97+</Scheme>

parsers/test_PMJSON_1_2_0/test_PMJSON.xcodeproj/xcuserdata/nst.xcuserdatad/xcschemes/xcschememanagement.plistnew file+22

@@ -0,0 +1,22 @@

1+<?xml version="1.0" encoding="UTF-8"?>

2+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

3+<plist version="1.0">

4+<dict>

5+ <key>SchemeUserState</key>

6+ <dict>

7+ <key>test_PMJSON.xcscheme</key>

8+ <dict>

9+ <key>orderHint</key>

10+ <integer>0</integer>

11+ </dict>

12+ </dict>

13+ <key>SuppressBuildableAutocreation</key>

14+ <dict>

15+ <key>035C824D1DC13EED00CDC48D</key>

16+ <dict>

17+ <key>primary</key>

18+ <true/>

19+ </dict>

20+ </dict>

21+</dict>

22+</plist>

parsers/test_PMJSON_1_2_0/test_PMJSON/main.swiftnew file+46

@@ -0,0 +1,46 @@

1+//

2+// main.swift

3+// test_PMJSON

4+//

5+// Created by nst on 26.10.16.

7+//

9+import Foundation

10+

11+func main() {

12+

13+ guard ProcessInfo.processInfo.arguments.count == 2 else {

14+ let url = URL(fileURLWithPath: ProcessInfo.processInfo.arguments[0])

15+ let programName = url.lastPathComponent

16+ print("Usage: ./\(programName) file.json")

17+ exit(1)

18+ }

19+

20+ let path = ProcessInfo.processInfo.arguments[1]

21+ let url = NSURL.fileURL(withPath:path)

22+

23+ do {

24+ let data = try Data(contentsOf:url)

25+

26+

27+ do {

28+ let json = try JSON.decode(data)

29+

30+ guard json != nil else {

31+ exit(1)

32+ }

33+

34+ exit(0)

35+ } catch let e {

36+ print(e)

37+ exit(1)

38+ }

39+ } catch let e {

40+ print("*** CANNOT READ DATA AT \(url)")

41+ print(e)

42+ exit(1)

43+ }

44+}

45+

46+main()

results/logs.txt+83−45

@@ -1648,51 +1648,6 @@ Java com.leastfixedpoint.json 1.0 SHOULD_HAVE_FAILED n_string_UTF8_surrogate_U+D

16481648Java com.leastfixedpoint.json 1.0 SHOULD_HAVE_FAILED n_structure_whitespace_formfeed.json

16491649Java com.leastfixedpoint.json 1.0 SHOULD_HAVE_PASSED y_number_huge_exp.json

16501650Java com.leastfixedpoint.json 1.0 SHOULD_HAVE_PASSED y_string_utf16.json

1651−Swift PMJSON 20161026 CRASH i_object_key_lone_2nd_surrogate.json

1652−Swift PMJSON 20161026 IMPLEMENTATION_FAIL i_string_1st_surrogate_but_2nd_missing.json

1653−Swift PMJSON 20161026 IMPLEMENTATION_FAIL i_string_1st_valid_surrogate_2nd_invalid.json

1654−Swift PMJSON 20161026 IMPLEMENTATION_FAIL i_string_incomplete_surrogate_and_escape_valid.json

1655−Swift PMJSON 20161026 CRASH i_string_incomplete_surrogate_pair.json

1656−Swift PMJSON 20161026 IMPLEMENTATION_FAIL i_string_incomplete_surrogates_escape_valid.json

1657−Swift PMJSON 20161026 CRASH i_string_inverted_surrogates_U+1D11E.json

1658−Swift PMJSON 20161026 CRASH i_string_lone_second_surrogate.json

1659−Swift PMJSON 20161026 IMPLEMENTATION_PASS i_string_not_in_unicode_range.json

1660−Swift PMJSON 20161026 IMPLEMENTATION_PASS i_string_truncated-utf-8.json

1661−Swift PMJSON 20161026 IMPLEMENTATION_PASS i_string_unicode_U+10FFFE_nonchar.json

1662−Swift PMJSON 20161026 IMPLEMENTATION_PASS i_string_unicode_U+1FFFE_nonchar.json

1663−Swift PMJSON 20161026 IMPLEMENTATION_PASS i_string_unicode_U+FDD0_nonchar.json

1664−Swift PMJSON 20161026 IMPLEMENTATION_PASS i_string_unicode_U+FFFE_nonchar.json

1665−Swift PMJSON 20161026 IMPLEMENTATION_FAIL i_string_UTF-16_invalid_lonely_surrogate.json

1666−Swift PMJSON 20161026 IMPLEMENTATION_FAIL i_string_UTF-16_invalid_surrogate.json

1667−Swift PMJSON 20161026 IMPLEMENTATION_PASS i_string_UTF-8_invalid_sequence.json

1668−Swift PMJSON 20161026 IMPLEMENTATION_PASS i_structure_500_nested_arrays.json

1669−Swift PMJSON 20161026 IMPLEMENTATION_FAIL i_structure_UTF-8_BOM_empty_object.json

1670−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_array_extra_comma.json

1671−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_array_number_and_comma.json

1672−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_number_-01.json

1673−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_number_neg_int_starting_with_zero.json

1674−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_number_neg_real_without_int_part.json

1675−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_number_with_leading_zero.json

1676−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_object_pi_in_key_and_trailing_comma.json

1677−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_object_trailing_comma.json

1678−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_string_invalid_utf-8.json

1679−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_string_iso_latin_1.json

1680−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_string_lone_utf8_continuation_byte.json

1681−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_string_overlong_sequence_2_bytes.json

1682−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_string_overlong_sequence_6_bytes.json

1683−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_string_overlong_sequence_6_bytes_null.json

1684−Swift PMJSON 20161026 SHOULD_HAVE_FAILED n_string_UTF8_surrogate_U+D800.json

1685−Swift PMJSON 20161026 CRASH n_structure_100000_opening_arrays.json

1686−Swift PMJSON 20161026 CRASH n_structure_open_array_object.json

1687−Swift PMJSON 20161026 SHOULD_HAVE_PASSED y_number_0e+1.json

1688−Swift PMJSON 20161026 SHOULD_HAVE_PASSED y_number_neg_int_huge_exp.json

1689−Swift PMJSON 20161026 SHOULD_HAVE_PASSED y_number_real_capital_e_neg_exp.json

1690−Swift PMJSON 20161026 SHOULD_HAVE_PASSED y_number_real_capital_e_pos_exp.json

1691−Swift PMJSON 20161026 SHOULD_HAVE_PASSED y_number_real_neg_exp.json

1692−Swift PMJSON 20161026 SHOULD_HAVE_PASSED y_number_real_pos_exponent.json

1693−Swift PMJSON 20161026 SHOULD_HAVE_PASSED y_number_real_underflow.json

1694−Swift PMJSON 20161026 SHOULD_HAVE_PASSED y_string_utf16.json

1695−Swift PMJSON 20161026 SHOULD_HAVE_PASSED y_structure_lonely_null.json

16961651Java nanojson 1.0 IMPLEMENTATION_PASS i_object_key_lone_2nd_surrogate.json

16971652Java nanojson 1.0 IMPLEMENTATION_PASS i_string_1st_surrogate_but_2nd_missing.json

16981653Java nanojson 1.0 IMPLEMENTATION_PASS i_string_1st_valid_surrogate_2nd_invalid.json

@@ -1719,3 +1674,86 @@ Java nanojson 1.0 SHOULD_HAVE_FAILED n_number_2.e-3.json

17191674Java nanojson 1.0 SHOULD_HAVE_FAILED n_number_2.e3.json

17201675Java nanojson 1.0 SHOULD_HAVE_FAILED n_number_real_without_fractional_part.json

17211676Java nanojson 1.0 SHOULD_HAVE_FAILED n_string_UTF8_surrogate_U+D800.json

1677+Swift PMJSON 1.1 CRASH i_object_key_lone_2nd_surrogate.json

1678+Swift PMJSON 1.1 IMPLEMENTATION_FAIL i_string_1st_surrogate_but_2nd_missing.json

1679+Swift PMJSON 1.1 IMPLEMENTATION_FAIL i_string_1st_valid_surrogate_2nd_invalid.json

1680+Swift PMJSON 1.1 IMPLEMENTATION_FAIL i_string_incomplete_surrogate_and_escape_valid.json

1681+Swift PMJSON 1.1 CRASH i_string_incomplete_surrogate_pair.json

1682+Swift PMJSON 1.1 IMPLEMENTATION_FAIL i_string_incomplete_surrogates_escape_valid.json

1683+Swift PMJSON 1.1 CRASH i_string_inverted_surrogates_U+1D11E.json

1684+Swift PMJSON 1.1 CRASH i_string_lone_second_surrogate.json

1685+Swift PMJSON 1.1 IMPLEMENTATION_PASS i_string_not_in_unicode_range.json

1686+Swift PMJSON 1.1 IMPLEMENTATION_PASS i_string_truncated-utf-8.json

1687+Swift PMJSON 1.1 IMPLEMENTATION_PASS i_string_unicode_U+10FFFE_nonchar.json

1688+Swift PMJSON 1.1 IMPLEMENTATION_PASS i_string_unicode_U+1FFFE_nonchar.json

1689+Swift PMJSON 1.1 IMPLEMENTATION_PASS i_string_unicode_U+FDD0_nonchar.json

1690+Swift PMJSON 1.1 IMPLEMENTATION_PASS i_string_unicode_U+FFFE_nonchar.json

1691+Swift PMJSON 1.1 IMPLEMENTATION_FAIL i_string_UTF-16_invalid_lonely_surrogate.json

1692+Swift PMJSON 1.1 IMPLEMENTATION_FAIL i_string_UTF-16_invalid_surrogate.json

1693+Swift PMJSON 1.1 IMPLEMENTATION_FAIL i_string_UTF-16LE_with_BOM.json

1694+Swift PMJSON 1.1 IMPLEMENTATION_PASS i_string_UTF-8_invalid_sequence.json

1695+Swift PMJSON 1.1 IMPLEMENTATION_PASS i_structure_500_nested_arrays.json

1696+Swift PMJSON 1.1 IMPLEMENTATION_FAIL i_structure_UTF-8_BOM_empty_object.json

1697+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_number_-01.json

1698+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_number_neg_int_starting_with_zero.json

1699+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_number_neg_real_without_int_part.json

1700+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_number_with_leading_zero.json

1701+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_string_invalid_utf-8.json

1702+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_string_iso_latin_1.json

1703+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_string_lone_utf8_continuation_byte.json

1704+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_string_overlong_sequence_2_bytes.json

1705+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_string_overlong_sequence_6_bytes.json

1706+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_string_overlong_sequence_6_bytes_null.json

1707+Swift PMJSON 1.1 SHOULD_HAVE_FAILED n_string_UTF8_surrogate_U+D800.json

1708+Swift PMJSON 1.1 CRASH n_structure_100000_opening_arrays.json

1709+Swift PMJSON 1.1 CRASH n_structure_open_array_object.json

1710+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_number_0e+1.json

1711+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_number_neg_int_huge_exp.json

1712+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_number_real_capital_e_neg_exp.json

1713+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_number_real_capital_e_pos_exp.json

1714+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_number_real_neg_exp.json

1715+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_number_real_pos_exponent.json

1716+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_number_real_underflow.json

1717+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_string_utf16BE_no_BOM.json

1718+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_string_utf16LE_no_BOM.json

1719+Swift PMJSON 1.1 SHOULD_HAVE_PASSED y_structure_lonely_null.json

1720+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_object_key_lone_2nd_surrogate.json

1721+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_string_1st_surrogate_but_2nd_missing.json

1722+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_string_1st_valid_surrogate_2nd_invalid.json

1723+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_string_incomplete_surrogate_and_escape_valid.json

1724+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_string_incomplete_surrogate_pair.json

1725+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_string_incomplete_surrogates_escape_valid.json

1726+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_string_inverted_surrogates_U+1D11E.json

1727+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_string_lone_second_surrogate.json

1728+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_string_not_in_unicode_range.json

1729+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_string_truncated-utf-8.json

1730+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_string_unicode_U+10FFFE_nonchar.json

1731+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_string_unicode_U+1FFFE_nonchar.json

1732+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_string_unicode_U+FDD0_nonchar.json

1733+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_string_unicode_U+FFFE_nonchar.json

1734+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_string_UTF-16_invalid_lonely_surrogate.json

1735+Swift PMJSON 1.2 IMPLEMENTATION_FAIL i_string_UTF-16_invalid_surrogate.json

1736+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_string_UTF-16LE_with_BOM.json

1737+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_string_UTF-8_invalid_sequence.json

1738+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_structure_500_nested_arrays.json

1739+Swift PMJSON 1.2 IMPLEMENTATION_PASS i_structure_UTF-8_BOM_empty_object.json

1740+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_array_extra_comma.json

1741+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_array_number_and_comma.json

1742+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_number_-01.json

1743+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_number_neg_int_starting_with_zero.json

1744+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_number_neg_real_without_int_part.json

1745+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_number_with_leading_zero.json

1746+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_object_pi_in_key_and_trailing_comma.json

1747+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_object_trailing_comma.json

1748+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_string_invalid_utf-8.json

1749+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_string_iso_latin_1.json

1750+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_string_lone_utf8_continuation_byte.json

1751+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_string_overlong_sequence_2_bytes.json

1752+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_string_overlong_sequence_6_bytes.json

1753+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_string_overlong_sequence_6_bytes_null.json

1754+Swift PMJSON 1.2 SHOULD_HAVE_FAILED n_string_UTF8_surrogate_U+D800.json

1755+Swift PMJSON 1.2 CRASH n_structure_100000_opening_arrays.json

1756+Swift PMJSON 1.2 CRASH n_structure_open_array_object.json

1757+Swift PMJSON 1.2 SHOULD_HAVE_PASSED y_string_utf16BE_no_BOM.json

1758+Swift PMJSON 1.2 SHOULD_HAVE_PASSED y_string_utf16LE_no_BOM.json

1759+Swift PMJSON 1.2 SHOULD_HAVE_PASSED y_structure_lonely_null.json

results/parsing.html+2433−249

@@ -11,13 +11,56 @@

1111 <BODY>

1212 <H1>JSON Parsing Tests</H1>

1313Appendix to: seriot.ch <A HREF="http://www.seriot.ch/parsing_json.php">Parsing JSON is a Minefield</A> http://www.seriot.ch/parsing_json.php

14−<PRE>2016-10-26 23:09:06</PRE>

14+<PRE>2016-10-27 13:18:27</PRE>

1515<H4>Contents</H4>

1616 <OL>

1717 <LI><A HREF="#color_scheme">Color Scheme</A>

1818 <LI><A HREF="#all_results">Full Results</A>

1919 <LI><A HREF="#results_by_parser">Results by Parser</A><UL>

20− <LI><A HREF="#0">Java nanojson 1.0</A>

20+ <LI><A HREF="#0">Bash JSON.sh 2016-08-12</A>

21+ <LI><A HREF="#1">C JSON Checker</A>

22+ <LI><A HREF="#2">C JSON Checker 2</A>

23+ <LI><A HREF="#3">C JSON Parser by udp</A>

24+ <LI><A HREF="#4">C cJSON</A>

25+ <LI><A HREF="#5">C ccan</A>

26+ <LI><A HREF="#6">C jansson</A>

27+ <LI><A HREF="#7">C jsmn</A>

28+ <LI><A HREF="#8">Crystal</A>

29+ <LI><A HREF="#9">Go 1.7.1</A>

30+ <LI><A HREF="#10">Haskell Aeson 0.11.2.1</A>

31+ <LI><A HREF="#11">Java Jackson 2.8.4</A>

32+ <LI><A HREF="#12">Java com.leastfixedpoint.json 1.0</A>

33+ <LI><A HREF="#13">Java gson 2.7</A>

34+ <LI><A HREF="#14">Java json-simple 1.1.1</A>

35+ <LI><A HREF="#15">Java nanojson 1.0</A>

36+ <LI><A HREF="#16">JavaScript</A>

37+ <LI><A HREF="#17">Json.NET 9.0.1</A>

38+ <LI><A HREF="#18">Lua JSON 20160916.19</A>

39+ <LI><A HREF="#19">Lua dkjson</A>

40+ <LI><A HREF="#20">Obj-C Apple NSJSONSerialization</A>

41+ <LI><A HREF="#21">Obj-C JSONKit</A>

42+ <LI><A HREF="#22">Obj-C SBJSON 4.0.3</A>

43+ <LI><A HREF="#23">Obj-C TouchJSON</A>

44+ <LI><A HREF="#24">PHP 5.5.36</A>

45+ <LI><A HREF="#25">Perl JSON</A>

46+ <LI><A HREF="#26">Perl JSON::XS</A>

47+ <LI><A HREF="#27">Python 2.7.10</A>

48+ <LI><A HREF="#28">Qt JSON</A>

49+ <LI><A HREF="#29">R jsonlite</A>

50+ <LI><A HREF="#30">R rjson</A>

51+ <LI><A HREF="#31">Ruby</A>

52+ <LI><A HREF="#32">Ruby regex</A>

53+ <LI><A HREF="#33">Rust json-rust</A>

54+ <LI><A HREF="#34">Rust rustc_serialize::json</A>

55+ <LI><A HREF="#35">Rust serde_json</A>

56+ <LI><A HREF="#36">Squeak JSON-tonyg</A>

57+ <LI><A HREF="#37">Swift Apple JSONSerialization</A>

58+ <LI><A HREF="#38">Swift Freddy 2.1.0</A>

59+ <LI><A HREF="#39">Swift Freddy 20160830</A>

60+ <LI><A HREF="#40">Swift Freddy 20161018</A>

61+ <LI><A HREF="#41">Swift PMJSON 1.1</A>

62+ <LI><A HREF="#42">Swift PMJSON 1.2</A>

63+ <LI><A HREF="#43">Swift STJSON</A>

2164</OL>

2265

2366 <A NAME="color_scheme"></A>

@@ -71,265 +114,264 @@

71114 <TH class="vertical"><DIV>Swift Freddy 2.1.0</DIV></TH>

72115 <TH class="vertical"><DIV>Swift Freddy 20160830</DIV></TH>

73116 <TH class="vertical"><DIV>Swift Freddy 20161018</DIV></TH>

74− <TH class="vertical"><DIV>Swift PMJSON 20161026</DIV></TH>

117+ <TH class="vertical"><DIV>Swift PMJSON 1.1</DIV></TH>

118+ <TH class="vertical"><DIV>Swift PMJSON 1.2</DIV></TH>

75119 <TH class="vertical"><DIV>Swift STJSON</DIV></TH>

76120 <TH></TH>

77121 </TR>

78122 <TR>

79− <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

80− <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

81− <TD>n_structure_no_data.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD></TD> </TR> <TR>

82− <TD>n_string_accentuated_char_no_quotes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[C3A9] <=> [é]</TD> </TR> <TR>

83− <TD>n_structure_unicode-identifier.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>C3A5 <=> å</TD> </TR> <TR>

84− <TD>n_array_unclosed_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,</TD> </TR> <TR>

85− <TD>n_object_missing_value.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":</TD> </TR> <TR>

86− <TD>n_single_space.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD> </TD> </TR> <TR>

87− <TD>n_structure_object_unclosed_no_value.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"":</TD> </TR> <TR>

88− <TD>n_string_start_escape_unclosed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\</TD> </TR> <TR>

89− <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

90− <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

91− <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

92− <TD>i_structure_500_nested_arrays.json</TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

93− <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

94− <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

95− <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

96− <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

97− <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

98− <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\ud800"]</TD> </TR> <TR>

99− <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\ud800abc"]</TD> </TR> <TR>

100− <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

101− <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

102− <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

103− <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

104− <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

105− <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

106− <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

107− <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

108− <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>100 <=> 1</TD> </TR> <TR>

109− <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\x00"]</TD> </TR> <TR>

110− <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

111− <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\a"]</TD> </TR> <TR>

112− <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>"\UA66D"</TD> </TR> <TR>

113− <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

114− <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.3e+]</TD> </TR> <TR>

115− <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.3e]</TD> </TR> <TR>

116− <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0E+]</TD> </TR> <TR>

117− <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0E]</TD> </TR> <TR>

118− <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e+]</TD> </TR> <TR>

119− <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e]</TD> </TR> <TR>

120− <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.0e+]</TD> </TR> <TR>

121− <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.0e-]</TD> </TR> <TR>

122− <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.0e]</TD> </TR> <TR>

123− <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

124− <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

125− <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[9.e+]</TD> </TR> <TR>

126− <TD>n_structure_null-byte-outside-string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[00] <=> []</TD> </TR> <TR>

127− <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

128− <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

129− <TD>n_string_invalid_utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

130− <TD>n_string_iso_latin_1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

131− <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

132− <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

133− <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

134− <TD>n_string_unescaped_tab.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

135− <TD>n_string_unescaped_newline.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["new0Aline"] <=> ["new

123+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

124+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

125+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

126+ <TD>n_structure_no_data.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD></TD> </TR> <TR>

127+ <TD>n_string_accentuated_char_no_quotes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[C3A9] <=> [é]</TD> </TR> <TR>

128+ <TD>n_structure_unicode-identifier.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>C3A5 <=> å</TD> </TR> <TR>

129+ <TD>n_array_unclosed_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,</TD> </TR> <TR>

130+ <TD>n_object_missing_value.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":</TD> </TR> <TR>

131+ <TD>n_single_space.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD> </TD> </TR> <TR>

132+ <TD>n_structure_object_unclosed_no_value.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"":</TD> </TR> <TR>

133+ <TD>n_string_start_escape_unclosed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\</TD> </TR> <TR>

134+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

135+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

136+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

137+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

138+ <TD>i_string_UTF-16LE_with_BOM.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>FFFE[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

139+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

140+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

141+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

142+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

143+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

144+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

145+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

146+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

147+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

148+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

149+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

150+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

151+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-2.]</TD> </TR> <TR>

152+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.e1]</TD> </TR> <TR>

153+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[2.e+3]</TD> </TR> <TR>

154+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[2.e-3]</TD> </TR> <TR>

155+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[2.e3]</TD> </TR> <TR>

156+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.]</TD> </TR> <TR>

157+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>100 <=> 1</TD> </TR> <TR>

158+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\x00"]</TD> </TR> <TR>

159+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

160+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\a"]</TD> </TR> <TR>

161+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>"\UA66D"</TD> </TR> <TR>

162+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

163+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.3e+]</TD> </TR> <TR>

164+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.3e]</TD> </TR> <TR>

165+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0E+]</TD> </TR> <TR>

166+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0E]</TD> </TR> <TR>

167+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e+]</TD> </TR> <TR>

168+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e]</TD> </TR> <TR>

169+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.0e+]</TD> </TR> <TR>

170+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.0e-]</TD> </TR> <TR>

171+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.0e]</TD> </TR> <TR>

172+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

173+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

174+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[9.e+]</TD> </TR> <TR>

175+ <TD>n_structure_null-byte-outside-string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[00] <=> []</TD> </TR> <TR>

176+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

177+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

178+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

179+ <TD>n_string_invalid_utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

180+ <TD>n_string_iso_latin_1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

181+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

182+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

183+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

184+ <TD>n_string_unescaped_tab.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

185+ <TD>n_string_unescaped_newline.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["new0Aline"] <=> ["new

136186line"]</TD> </TR> <TR>

137− <TD>n_array_just_minus.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-]</TD> </TR> <TR>

138− <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

139− <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

140− <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

141− <TD>n_array_extra_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["",]</TD> </TR> <TR>

142− <TD>n_array_number_and_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,]</TD> </TR> <TR>

143− <TD>n_object_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"id":0,}</TD> </TR> <TR>

144− <TD>n_string_single_doublequote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>"</TD> </TR> <TR>

145− <TD>n_number_neg_real_without_int_part.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-.123]</TD> </TR> <TR>

146− <TD>n_object_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

147− <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

148− <TD>n_object_trailing_comment.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

149− <TD>n_array_comma_after_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[""],</TD> </TR> <TR>

150− <TD>n_object_trailing_comment_open.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

151− <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

152− <TD>n_structure_array_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1]x</TD> </TR> <TR>

153− <TD>n_structure_double_array.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[][]</TD> </TR> <TR>

154− <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

155− <TD>n_number_-01.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-01]</TD> </TR> <TR>

156− <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-012]</TD> </TR> <TR>

157− <TD>n_number_with_leading_zero.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[012]</TD> </TR> <TR>

158− <TD>n_string_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>""x</TD> </TR> <TR>

159− <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>2@</TD> </TR> <TR>

160− <TD>n_structure_trailing_#.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

161− <TD>n_array_extra_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["x"]]</TD> </TR> <TR>

162− <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1]]</TD> </TR> <TR>

163− <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{}}</TD> </TR> <TR>

164− <TD>n_structure_close_unopened_array.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>1]</TD> </TR> <TR>

165− <TD>n_array_spaces_vertical_tab_formfeed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["0Ba"\f] <=> ["a"\f]</TD> </TR> <TR>

166− <TD>n_number_minus_space_1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[- 1]</TD> </TR> <TR>

167− <TD>n_object_missing_colon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a" b}</TD> </TR> <TR>

168− <TD>n_object_missing_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{:"b"}</TD> </TR> <TR>

169− <TD>n_string_leading_uescaped_thinspace.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[\u0020"asd"]</TD> </TR> <TR>

170− <TD>n_string_no_quotes_with_bad_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[\n]</TD> </TR> <TR>

171− <TD>n_structure_uescaped_LF_before_string.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[\u000A""]</TD> </TR> <TR>

172− <TD>n_array_star_inside.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[*]</TD> </TR> <TR>

173− <TD>n_incomplete_false.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[fals]</TD> </TR> <TR>

174− <TD>n_incomplete_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[nul]</TD> </TR> <TR>

175− <TD>n_incomplete_true.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[tru]</TD> </TR> <TR>

176− <TD>n_number_++.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[++1234]</TD> </TR> <TR>

177− <TD>n_number_+1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[+1]</TD> </TR> <TR>

178− <TD>n_number_+Inf.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[+Inf]</TD> </TR> <TR>

179− <TD>n_number_-1.0..json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-1.0.]</TD> </TR> <TR>

180− <TD>n_number_-NaN.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-NaN]</TD> </TR> <TR>

181− <TD>n_number_.-1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[.-1]</TD> </TR> <TR>

182− <TD>n_number_0.1.2.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.1.2]</TD> </TR> <TR>

183− <TD>n_number_1eE2.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1eE2]</TD> </TR> <TR>

184− <TD>n_number_Inf.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[Inf]</TD> </TR> <TR>

185− <TD>n_number_expression.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1+2]</TD> </TR> <TR>

186− <TD>n_number_hex_1_digit.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0x1]</TD> </TR> <TR>

187− <TD>n_number_hex_2_digits.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0x42]</TD> </TR> <TR>

188− <TD>n_number_invalid+-.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e+-1]</TD> </TR> <TR>

189− <TD>n_number_invalid-negative-real.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123.123foo]</TD> </TR> <TR>

190− <TD>n_number_minus_sign_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-foo]</TD> </TR> <TR>

191− <TD>n_number_neg_with_garbage_at_end.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-1x]</TD> </TR> <TR>

192− <TD>n_number_real_garbage_after_e.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1ea]</TD> </TR> <TR>

193− <TD>n_number_with_alpha.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.2a-3]</TD> </TR> <TR>

194− <TD>n_number_with_alpha_char.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.8011670033376514H-308]</TD> </TR> <TR>

195− <TD>n_object_bad_value.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["x", truth]</TD> </TR> <TR>

196− <TD>n_object_key_with_single_quotes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{key: 'value'}</TD> </TR> <TR>

197− <TD>n_object_repeated_null_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{null:null,null:null}</TD> </TR> <TR>

198− <TD>n_object_unquoted_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{a: "b"}</TD> </TR> <TR>

199− <TD>n_string_single_string_no_double_quotes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>abc</TD> </TR> <TR>

200− <TD>n_structure_<.>.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD><.></TD> </TR> <TR>

201− <TD>n_structure_<null>.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[<null>]</TD> </TR> <TR>

202− <TD>n_structure_single_star.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>*</TD> </TR> <TR>

203− <TD>n_object_single_quote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{'a':0}</TD> </TR> <TR>

204− <TD>n_string_single_quote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>['single quote']</TD> </TR> <TR>

205− <TD>n_array_comma_and_number.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[,1]</TD> </TR> <TR>

206− <TD>n_array_double_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,,2]</TD> </TR> <TR>

207− <TD>n_array_double_extra_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["x",,]</TD> </TR> <TR>

208− <TD>n_array_just_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[,]</TD> </TR> <TR>

209− <TD>n_array_missing_value.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[ , ""]</TD> </TR> <TR>

210− <TD>n_array_number_and_several_commas.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,,]</TD> </TR> <TR>

211− <TD>n_object_double_colon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x"::"b"}</TD> </TR> <TR>

212− <TD>n_object_several_trailing_commas.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"id":0,,,,,}</TD> </TR> <TR>

213− <TD>n_object_two_commas_in_a_row.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b",,"c":"d"}</TD> </TR> <TR>

214− <TD>n_array_colon_instead_of_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["": 1]</TD> </TR> <TR>

215− <TD>n_array_items_separated_by_semicolon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1:2]</TD> </TR> <TR>

216− <TD>n_object_comma_instead_of_colon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x", null}</TD> </TR> <TR>

217− <TD>n_object_garbage_at_end.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"a" 123}</TD> </TR> <TR>

218− <TD>n_object_with_single_string.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{ "foo" : "bar", "a" }</TD> </TR> <TR>

219− <TD>n_number_.2e-3.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[.2e-3]</TD> </TR> <TR>

220− <TD>n_number_starting_with_dot.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[.123]</TD> </TR> <TR>

221− <TD>n_object_non_string_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{1:1}</TD> </TR> <TR>

222− <TD>n_object_non_string_key_but_huge_number_instead.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{9999E9999:1}</TD> </TR> <TR>

223− <TD>n_array_1_true_without_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1 true]</TD> </TR> <TR>

224− <TD>n_number_1_000.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1 000.0]</TD> </TR> <TR>

225− <TD>n_object_missing_semicolon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a" "b"}</TD> </TR> <TR>

226− <TD>n_structure_object_with_comment.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

227− <TD>n_number_NaN.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[NaN]</TD> </TR> <TR>

228− <TD>n_number_infinity.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[Infinity]</TD> </TR> <TR>

229− <TD>n_number_minus_infinity.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-Infinity]</TD> </TR> <TR>

230− <TD>n_structure_capitalized_True.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[True]</TD> </TR> <TR>

231− <TD>n_array_a_invalid_utf8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[aE5] <=> [a]</TD> </TR> <TR>

232− <TD>n_array_invalid_utf8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[FF] <=> []</TD> </TR> <TR>

233− <TD>n_number_invalid-utf-8-in-bigger-int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123E5] <=> [123]</TD> </TR> <TR>

234− <TD>n_number_invalid-utf-8-in-exponent.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1e1E5] <=> [1e1]</TD> </TR> <TR>

235− <TD>n_number_invalid-utf-8-in-int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0E5]0A <=> [0]

187+ <TD>n_array_just_minus.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-]</TD> </TR> <TR>

188+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

189+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

190+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

191+ <TD>n_array_extra_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["",]</TD> </TR> <TR>

192+ <TD>n_array_number_and_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,]</TD> </TR> <TR>

193+ <TD>n_object_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"id":0,}</TD> </TR> <TR>

194+ <TD>n_string_single_doublequote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>"</TD> </TR> <TR>

195+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-.123]</TD> </TR> <TR>

196+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

197+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

198+ <TD>n_object_trailing_comment.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

199+ <TD>n_array_comma_after_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[""],</TD> </TR> <TR>

200+ <TD>n_object_trailing_comment_open.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

201+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

202+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1]x</TD> </TR> <TR>

203+ <TD>n_structure_double_array.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[][]</TD> </TR> <TR>

204+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

205+ <TD>n_number_-01.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-01]</TD> </TR> <TR>

206+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-012]</TD> </TR> <TR>

207+ <TD>n_number_with_leading_zero.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[012]</TD> </TR> <TR>

208+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>""x</TD> </TR> <TR>

209+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>2@</TD> </TR> <TR>

210+ <TD>n_structure_trailing_#.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

211+ <TD>n_array_extra_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["x"]]</TD> </TR> <TR>

212+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1]]</TD> </TR> <TR>

213+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{}}</TD> </TR> <TR>

214+ <TD>n_structure_close_unopened_array.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>1]</TD> </TR> <TR>

215+ <TD>n_array_spaces_vertical_tab_formfeed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["0Ba"\f] <=> ["a"\f]</TD> </TR> <TR>

216+ <TD>n_number_minus_space_1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[- 1]</TD> </TR> <TR>

217+ <TD>n_object_missing_colon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a" b}</TD> </TR> <TR>

218+ <TD>n_object_missing_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{:"b"}</TD> </TR> <TR>

219+ <TD>n_string_leading_uescaped_thinspace.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[\u0020"asd"]</TD> </TR> <TR>

220+ <TD>n_string_no_quotes_with_bad_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[\n]</TD> </TR> <TR>

221+ <TD>n_structure_uescaped_LF_before_string.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[\u000A""]</TD> </TR> <TR>

222+ <TD>n_array_star_inside.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[*]</TD> </TR> <TR>

223+ <TD>n_incomplete_false.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[fals]</TD> </TR> <TR>

224+ <TD>n_incomplete_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[nul]</TD> </TR> <TR>

225+ <TD>n_incomplete_true.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[tru]</TD> </TR> <TR>

226+ <TD>n_number_++.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[++1234]</TD> </TR> <TR>

227+ <TD>n_number_+1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[+1]</TD> </TR> <TR>

228+ <TD>n_number_+Inf.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[+Inf]</TD> </TR> <TR>

229+ <TD>n_number_-1.0..json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-1.0.]</TD> </TR> <TR>

230+ <TD>n_number_-NaN.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-NaN]</TD> </TR> <TR>

231+ <TD>n_number_.-1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[.-1]</TD> </TR> <TR>

232+ <TD>n_number_0.1.2.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.1.2]</TD> </TR> <TR>

233+ <TD>n_number_1eE2.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1eE2]</TD> </TR> <TR>

234+ <TD>n_number_Inf.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[Inf]</TD> </TR> <TR>

235+ <TD>n_number_expression.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1+2]</TD> </TR> <TR>

236+ <TD>n_number_hex_1_digit.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0x1]</TD> </TR> <TR>

237+ <TD>n_number_hex_2_digits.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0x42]</TD> </TR> <TR>

238+ <TD>n_number_invalid+-.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e+-1]</TD> </TR> <TR>

239+ <TD>n_number_invalid-negative-real.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123.123foo]</TD> </TR> <TR>

240+ <TD>n_number_minus_sign_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-foo]</TD> </TR> <TR>

241+ <TD>n_number_neg_with_garbage_at_end.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-1x]</TD> </TR> <TR>

242+ <TD>n_number_real_garbage_after_e.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1ea]</TD> </TR> <TR>

243+ <TD>n_number_with_alpha.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.2a-3]</TD> </TR> <TR>

244+ <TD>n_number_with_alpha_char.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.8011670033376514H-308]</TD> </TR> <TR>

245+ <TD>n_object_bad_value.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["x", truth]</TD> </TR> <TR>

246+ <TD>n_object_key_with_single_quotes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{key: 'value'}</TD> </TR> <TR>

247+ <TD>n_object_repeated_null_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{null:null,null:null}</TD> </TR> <TR>

248+ <TD>n_object_unquoted_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{a: "b"}</TD> </TR> <TR>

249+ <TD>n_string_single_string_no_double_quotes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>abc</TD> </TR> <TR>

250+ <TD>n_structure_<.>.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD><.></TD> </TR> <TR>

251+ <TD>n_structure_<null>.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[<null>]</TD> </TR> <TR>

252+ <TD>n_structure_single_star.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>*</TD> </TR> <TR>

253+ <TD>n_object_single_quote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{'a':0}</TD> </TR> <TR>

254+ <TD>n_string_single_quote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>['single quote']</TD> </TR> <TR>

255+ <TD>n_array_comma_and_number.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[,1]</TD> </TR> <TR>

256+ <TD>n_array_double_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,,2]</TD> </TR> <TR>

257+ <TD>n_array_double_extra_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["x",,]</TD> </TR> <TR>

258+ <TD>n_array_just_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[,]</TD> </TR> <TR>

259+ <TD>n_array_missing_value.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[ , ""]</TD> </TR> <TR>

260+ <TD>n_array_number_and_several_commas.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,,]</TD> </TR> <TR>

261+ <TD>n_object_double_colon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x"::"b"}</TD> </TR> <TR>

262+ <TD>n_object_several_trailing_commas.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"id":0,,,,,}</TD> </TR> <TR>

263+ <TD>n_object_two_commas_in_a_row.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b",,"c":"d"}</TD> </TR> <TR>

264+ <TD>n_array_colon_instead_of_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["": 1]</TD> </TR> <TR>

265+ <TD>n_array_items_separated_by_semicolon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1:2]</TD> </TR> <TR>

266+ <TD>n_object_comma_instead_of_colon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x", null}</TD> </TR> <TR>

267+ <TD>n_object_garbage_at_end.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"a" 123}</TD> </TR> <TR>

268+ <TD>n_object_with_single_string.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{ "foo" : "bar", "a" }</TD> </TR> <TR>

269+ <TD>n_number_.2e-3.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[.2e-3]</TD> </TR> <TR>

270+ <TD>n_number_starting_with_dot.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[.123]</TD> </TR> <TR>

271+ <TD>n_object_non_string_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{1:1}</TD> </TR> <TR>

272+ <TD>n_object_non_string_key_but_huge_number_instead.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{9999E9999:1}</TD> </TR> <TR>

273+ <TD>n_array_1_true_without_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1 true]</TD> </TR> <TR>

274+ <TD>n_number_1_000.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1 000.0]</TD> </TR> <TR>

275+ <TD>n_object_missing_semicolon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a" "b"}</TD> </TR> <TR>

276+ <TD>n_structure_object_with_comment.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

277+ <TD>n_number_NaN.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[NaN]</TD> </TR> <TR>

278+ <TD>n_number_infinity.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[Infinity]</TD> </TR> <TR>

279+ <TD>n_number_minus_infinity.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-Infinity]</TD> </TR> <TR>

280+ <TD>n_structure_capitalized_True.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[True]</TD> </TR> <TR>

281+ <TD>n_array_a_invalid_utf8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[aE5] <=> [a]</TD> </TR> <TR>

282+ <TD>n_array_invalid_utf8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[FF] <=> []</TD> </TR> <TR>

283+ <TD>n_number_invalid-utf-8-in-bigger-int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123E5] <=> [123]</TD> </TR> <TR>

284+ <TD>n_number_invalid-utf-8-in-exponent.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1e1E5] <=> [1e1]</TD> </TR> <TR>

285+ <TD>n_number_invalid-utf-8-in-int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0E5]0A <=> [0]

236286</TD> </TR> <TR>

237− <TD>n_number_real_with_invalid_utf8_after_e.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1eE5] <=> [1e]</TD> </TR> <TR>

238− <TD>n_structure_U+2060_word_joined.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[E281A0] <=> [⁠]</TD> </TR> <TR>

239− <TD>n_structure_ascii-unicode-identifier.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>aC3A5 <=> aå</TD> </TR> <TR>

240− <TD>n_structure_lone-invalid-utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>E5 <=> </TD> </TR> <TR>

241− <TD>n_structure_single_point.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>E9 <=> </TD> </TR> <TR>

242− <TD>n_structure_whitespace_U+2060_word_joiner.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[E281A0] <=> [⁠]</TD> </TR> <TR>

243− <TD>n_number_U+FF11_fullwidth_digit_one.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[EFBC91] <=> [１]</TD> </TR> <TR>

244− <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-2.]</TD> </TR> <TR>

245− <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.e1]</TD> </TR> <TR>

246− <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[2.e+3]</TD> </TR> <TR>

247− <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[2.e-3]</TD> </TR> <TR>

248− <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[2.e3]</TD> </TR> <TR>

249− <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1.]</TD> </TR> <TR>

250− <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

251− <TD>n_array_inner_array_no_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[3[4]]</TD> </TR> <TR>

252− <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

253− <TD>n_string_1_surrogate_then_escape u1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\u1"]</TD> </TR> <TR>

254− <TD>n_string_1_surrogate_then_escape u1x.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\u1x"]</TD> </TR> <TR>

255− <TD>n_string_UTF-16_incomplete_surrogate.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD834\uDd"]</TD> </TR> <TR>

256− <TD>n_string_incomplete_escaped_character.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u00A"]</TD> </TR> <TR>

257− <TD>n_string_invalid-utf-8-in-escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uE5"] <=> ["\u"]</TD> </TR> <TR>

258− <TD>n_string_invalid_unicode_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

259− <TD>n_array_unclosed_with_new_lines.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,0A10A,1 <=> [1,

287+ <TD>n_number_real_with_invalid_utf8_after_e.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1eE5] <=> [1e]</TD> </TR> <TR>

288+ <TD>n_structure_U+2060_word_joined.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[E281A0] <=> [⁠]</TD> </TR> <TR>

289+ <TD>n_structure_ascii-unicode-identifier.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>aC3A5 <=> aå</TD> </TR> <TR>

290+ <TD>n_structure_lone-invalid-utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>E5 <=> </TD> </TR> <TR>

291+ <TD>n_structure_single_point.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>E9 <=> </TD> </TR> <TR>

292+ <TD>n_structure_whitespace_U+2060_word_joiner.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[E281A0] <=> [⁠]</TD> </TR> <TR>

293+ <TD>n_number_U+FF11_fullwidth_digit_one.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[EFBC91] <=> [１]</TD> </TR> <TR>

294+ <TD>n_array_inner_array_no_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[3[4]]</TD> </TR> <TR>

295+ <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

296+ <TD>n_string_1_surrogate_then_escape u1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\u1"]</TD> </TR> <TR>

297+ <TD>n_string_1_surrogate_then_escape u1x.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\u1x"]</TD> </TR> <TR>

298+ <TD>n_string_incomplete_escaped_character.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u00A"]</TD> </TR> <TR>

299+ <TD>n_string_invalid-utf-8-in-escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uE5"] <=> ["\u"]</TD> </TR> <TR>

300+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

301+ <TD>n_array_unclosed_with_new_lines.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,0A10A,1 <=> [1,

2603021

261303,1</TD> </TR> <TR>

262− <TD>n_array_newlines_unclosed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a",0A40A,1, <=> ["a",

304+ <TD>n_array_newlines_unclosed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a",0A40A,1, <=> ["a",

2633054

264306,1,</TD> </TR> <TR>

265− <TD>y_string_unescaped_char_delete.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["7F"] <=> [""]</TD> </TR> <TR>

266− <TD>y_string_with_del_character.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a7Fa"] <=> ["aa"]</TD> </TR> <TR>

267− <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>FFFE[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

268− <TD>y_string_nonCharacterInUTF-8_U+1FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["F09BBFBF"] <=> ["𛿿"]</TD> </TR> <TR>

269− <TD>y_string_pi.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["CF80"] <=> ["π"]</TD> </TR> <TR>

270− <TD>y_string_u+2028_line_sep.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E280A8"] <=> [" "]</TD> </TR> <TR>

271− <TD>y_string_u+2029_par_sep.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E280A9"] <=> [" "]</TD> </TR> <TR>

272− <TD>y_string_unicode_2.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E28D82E388B4E28D82"] <=> ["⍂㈴⍂"]</TD> </TR> <TR>

273− <TD>y_string_utf8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E282ACF09D849E"] <=> ["€𝄞"]</TD> </TR> <TR>

274− <TD>y_structure_lonely_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>42</TD> </TR> <TR>

275− <TD>y_structure_lonely_negative_real.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>-0.1</TD> </TR> <TR>

276− <TD>y_structure_lonely_true.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>true</TD> </TR> <TR>

277− <TD>y_structure_string_empty.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>""</TD> </TR> <TR>

278− <TD>y_structure_lonely_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>null</TD> </TR> <TR>

279− <TD>y_string_space.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>" "</TD> </TR> <TR>

280− <TD>y_structure_lonely_false.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>false</TD> </TR> <TR>

281− <TD>y_structure_lonely_string.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>"asd"</TD> </TR> <TR>

282− <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

283− <TD>y_string_nonCharacterInUTF-8_U+FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["EFBFBF"] <=> [""]</TD> </TR> <TR>

284− <TD>y_number_0e1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e1]</TD> </TR> <TR>

285− <TD>y_number_0e+1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e+1]</TD> </TR> <TR>

286− <TD>y_object_escaped_null_in_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

287− <TD>y_string_null_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0000"]</TD> </TR> <TR>

288− <TD>y_number_huge_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

289− <TD>y_number_real_pos_overflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123123e100000]</TD> </TR> <TR>

290− <TD>y_number_real_neg_overflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

291− <TD>y_number_too_big_neg_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

292− <TD>y_number_too_big_pos_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

293− <TD>y_number_very_big_negative_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

294− <TD>y_object_long_strings.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x":[{"id": "xxxxxxxxxxxxxxxxxxxxxx(...)</TD> </TR> <TR>

295− <TD>y_object_string_unicode.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"title":"\u041f\u043e\u043b\u0442\u(...)</TD> </TR> <TR>

296− <TD>y_number_double_huge_neg_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

297− <TD>y_number_real_underflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123e-10000000]</TD> </TR> <TR>

298− <TD>y_string_escaped_noncharacter.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uFFFF"]</TD> </TR> <TR>

299− <TD>y_string_last_surrogates_1_and_2.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uDBFF\uDFFF"]</TD> </TR> <TR>

300− <TD>y_array_with_1_and_newline.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[10A] <=> [1

307+ <TD>y_string_unescaped_char_delete.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["7F"] <=> [""]</TD> </TR> <TR>

308+ <TD>y_string_with_del_character.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a7Fa"] <=> ["aa"]</TD> </TR> <TR>

309+ <TD>y_string_nonCharacterInUTF-8_U+1FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["F09BBFBF"] <=> ["𛿿"]</TD> </TR> <TR>

310+ <TD>y_string_pi.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["CF80"] <=> ["π"]</TD> </TR> <TR>

311+ <TD>y_string_u+2028_line_sep.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E280A8"] <=> [" "]</TD> </TR> <TR>

312+ <TD>y_string_u+2029_par_sep.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E280A9"] <=> [" "]</TD> </TR> <TR>

313+ <TD>y_string_unicode_2.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E28D82E388B4E28D82"] <=> ["⍂㈴⍂"]</TD> </TR> <TR>

314+ <TD>y_string_utf8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["E282ACF09D849E"] <=> ["€𝄞"]</TD> </TR> <TR>

315+ <TD>y_structure_lonely_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>42</TD> </TR> <TR>

316+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>-0.1</TD> </TR> <TR>

317+ <TD>y_structure_lonely_true.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>true</TD> </TR> <TR>

318+ <TD>y_structure_string_empty.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>""</TD> </TR> <TR>

319+ <TD>y_structure_lonely_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>null</TD> </TR> <TR>

320+ <TD>y_string_space.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>" "</TD> </TR> <TR>

321+ <TD>y_structure_lonely_false.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>false</TD> </TR> <TR>

322+ <TD>y_structure_lonely_string.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>"asd"</TD> </TR> <TR>

323+ <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

324+ <TD>y_string_nonCharacterInUTF-8_U+FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["EFBFBF"] <=> [""]</TD> </TR> <TR>

325+ <TD>y_number_0e1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e1]</TD> </TR> <TR>

326+ <TD>y_number_0e+1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e+1]</TD> </TR> <TR>

327+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

328+ <TD>y_string_null_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0000"]</TD> </TR> <TR>

329+ <TD>y_number_huge_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

330+ <TD>y_number_real_pos_overflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123123e100000]</TD> </TR> <TR>

331+ <TD>y_number_real_neg_overflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

332+ <TD>y_number_too_big_neg_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

333+ <TD>y_number_too_big_pos_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

334+ <TD>y_number_very_big_negative_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

335+ <TD>y_object_long_strings.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x":[{"id": "xxxxxxxxxxxxxxxxxxxxxx(...)</TD> </TR> <TR>

336+ <TD>y_object_string_unicode.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"title":"\u041f\u043e\u043b\u0442\u(...)</TD> </TR> <TR>

337+ <TD>y_number_double_huge_neg_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

338+ <TD>y_number_real_underflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123e-10000000]</TD> </TR> <TR>

339+ <TD>y_string_escaped_noncharacter.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uFFFF"]</TD> </TR> <TR>

340+ <TD>y_string_last_surrogates_1_and_2.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uDBFF\uDFFF"]</TD> </TR> <TR>

341+ <TD>y_array_with_1_and_newline.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[10A] <=> [1

301342]</TD> </TR> <TR>

302− <TD>y_object_with_newlines.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{0A"a": "b"0A} <=> {

343+ <TD>y_object_with_newlines.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{0A"a": "b"0A} <=> {

303344"a": "b"

304345}</TD> </TR> <TR>

305− <TD>y_string_1_2_3_bytes_UTF-8_sequences.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0060\u012a\u12AB"]</TD> </TR> <TR>

306− <TD>y_string_UTF-16_Surrogates_U+1D11E_MUSICAL_SYMBOL_G_CLEF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD834\uDd1e"]</TD> </TR> <TR>

307− <TD>y_string_accepted_surrogate_pair.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD801\udc37"]</TD> </TR> <TR>

308− <TD>y_string_accepted_surrogate_pairs.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\ud83d\ude39\ud83d\udc8d"]</TD> </TR> <TR>

309− <TD>y_string_allowed_escapes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\"\\\/\b\f\n\r\t"]</TD> </TR> <TR>

310− <TD>y_string_backslash_and_u_escaped_zero.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\\u0000"]</TD> </TR> <TR>

311− <TD>y_string_backslash_doublequotes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\""]</TD> </TR> <TR>

312− <TD>y_string_double_escape_a.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\\a"]</TD> </TR> <TR>

313− <TD>y_string_double_escape_n.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\\n"]</TD> </TR> <TR>

314− <TD>y_string_escaped_control_character.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0012"]</TD> </TR> <TR>

315− <TD>y_string_newline_uescaped.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["new\u00A0line"]</TD> </TR> <TR>

316− <TD>y_string_one-byte-utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u002c"]</TD> </TR> <TR>

317− <TD>y_string_three-byte-utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0821"]</TD> </TR> <TR>

318− <TD>y_string_two-byte-utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0123"]</TD> </TR> <TR>

319− <TD>y_string_uEscape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0061\u30af\u30EA\u30b9"]</TD> </TR> <TR>

320− <TD>y_string_unicode.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uA66D"]</TD> </TR> <TR>

321− <TD>y_string_unicodeEscapedBackslash.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u005C"]</TD> </TR> <TR>

322− <TD>y_string_unicode_U+200B_ZERO_WIDTH_SPACE.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u200B"]</TD> </TR> <TR>

323− <TD>y_string_unicode_U+2064_invisible_plus.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u2064"]</TD> </TR> <TR>

324− <TD>y_string_unicode_escaped_double_quote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0022"]</TD> </TR> <TR>

325− <TD>y_number_neg_int_huge_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-1e+9999]</TD> </TR> <TR>

326− <TD>y_number_real_capital_e_neg_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1E-2]</TD> </TR> <TR>

327− <TD>y_number_real_capital_e_pos_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1E+2]</TD> </TR> <TR>

328− <TD>y_number_real_neg_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1e-2]</TD> </TR> <TR>

329− <TD>y_number_real_pos_exponent.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1e+2]</TD> </TR></TABLE>

346+ <TD>y_string_1_2_3_bytes_UTF-8_sequences.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0060\u012a\u12AB"]</TD> </TR> <TR>

347+ <TD>y_string_accepted_surrogate_pair.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD801\udc37"]</TD> </TR> <TR>

348+ <TD>y_string_accepted_surrogate_pairs.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\ud83d\ude39\ud83d\udc8d"]</TD> </TR> <TR>

349+ <TD>y_string_allowed_escapes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\"\\\/\b\f\n\r\t"]</TD> </TR> <TR>

350+ <TD>y_string_backslash_and_u_escaped_zero.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\\u0000"]</TD> </TR> <TR>

351+ <TD>y_string_backslash_doublequotes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\""]</TD> </TR> <TR>

352+ <TD>y_string_double_escape_a.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\\a"]</TD> </TR> <TR>

353+ <TD>y_string_double_escape_n.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\\n"]</TD> </TR> <TR>

354+ <TD>y_string_escaped_control_character.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0012"]</TD> </TR> <TR>

355+ <TD>y_string_newline_uescaped.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["new\u00A0line"]</TD> </TR> <TR>

356+ <TD>y_string_one-byte-utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u002c"]</TD> </TR> <TR>

357+ <TD>y_string_three-byte-utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0821"]</TD> </TR> <TR>

358+ <TD>y_string_two-byte-utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0123"]</TD> </TR> <TR>

359+ <TD>y_string_uEscape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0061\u30af\u30EA\u30b9"]</TD> </TR> <TR>

360+ <TD>y_string_unicode.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uA66D"]</TD> </TR> <TR>

361+ <TD>y_string_unicodeEscapedBackslash.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u005C"]</TD> </TR> <TR>

362+ <TD>y_string_unicode_U+200B_ZERO_WIDTH_SPACE.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u200B"]</TD> </TR> <TR>

363+ <TD>y_string_unicode_U+2064_invisible_plus.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u2064"]</TD> </TR> <TR>

364+ <TD>y_string_unicode_escaped_double_quote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0022"]</TD> </TR> <TR>

365+ <TD>y_number_neg_int_huge_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-1e+9999]</TD> </TR> <TR>

366+ <TD>y_number_real_capital_e_neg_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1E-2]</TD> </TR> <TR>

367+ <TD>y_number_real_capital_e_pos_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1E+2]</TD> </TR> <TR>

368+ <TD>y_number_real_neg_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1e-2]</TD> </TR> <TR>

369+ <TD>y_number_real_pos_exponent.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1e+2]</TD> </TR> <TR>

370+ <TD>y_string_utf16BE_no_BOM.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>00[00"00E900"00] <=> [""]</TD> </TR> <TR>

371+ <TD>y_string_utf16LE_no_BOM.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[00"00E900"00]00 <=> [""]</TD> </TR></TABLE>

330372<A NAME="results_by_parser"></A>

331373<H4>3. Results by Parser</H4>

332−<A NAME="0"></A><H4>Java nanojson 1.0</H4>

374+<A NAME="0"></A><H4><A HREF="https://github.com/dominictarr/JSON.sh">Bash JSON.sh 2016-08-12</A></H4>

333375<TABLE>

334376 <TR>

335377 <TH></TH>

@@ -337,11 +379,13 @@ line"]</TD> </TR> <TR>

337379 <TH></TH>

338380 </TR>

339381 <TR>

382+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

383+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

340384 <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

341385 <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

342386 <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

343− <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\ud800"]</TD> </TR> <TR>

344− <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\ud800abc"]</TD> </TR> <TR>

387+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

388+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

345389 <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

346390 <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

347391 <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

@@ -354,15 +398,2155 @@ line"]</TD> </TR> <TR>

354398 <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

355399 <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

356400 <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

401+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

402+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

403+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

404+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

405+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

406+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

407+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

408+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

409+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

410+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

411+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

412+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

413+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

414+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

415+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

416+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

417+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

418+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

419+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

420+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

421+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

422+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

423+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

424+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

425+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

426+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

427+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

428+ <TD>n_structure_null-byte-outside-string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[00] <=> []</TD> </TR> <TR>

429+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

430+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

431+ <TD>y_string_unescaped_char_delete.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["7F"] <=> [""]</TD> </TR> <TR>

432+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

433+ <TD>y_string_with_del_character.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["a7Fa"] <=> ["aa"]</TD> </TR></TABLE>

434+

435+

436+<A NAME="1"></A><H4><A HREF="http://www.json.org/JSON_checker/">C JSON Checker</A></H4>

437+<TABLE>

438+ <TR>

439+ <TH></TH>

440+ <TH class="space"><DIV></DIV></TH>

441+ <TH></TH>

442+ </TR>

443+ <TR>

444+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

445+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

446+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

447+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

448+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

449+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

450+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

451+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

452+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

453+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

454+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

455+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

456+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

457+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

458+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

459+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

460+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

461+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

462+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

463+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

464+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

465+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

466+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

467+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

468+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

469+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

470+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

471+ <TD>y_number_0e+1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e+1]</TD> </TR> <TR>

472+ <TD>y_number_0e1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e1]</TD> </TR> <TR>

473+ <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

474+ <TD>y_string_nonCharacterInUTF-8_U+1FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F09BBFBF"] <=> ["𛿿"]</TD> </TR> <TR>

475+ <TD>y_string_nonCharacterInUTF-8_U+FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["EFBFBF"] <=> [""]</TD> </TR> <TR>

476+ <TD>y_string_pi.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["CF80"] <=> ["π"]</TD> </TR> <TR>

477+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

478+ <TD>y_string_u+2028_line_sep.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E280A8"] <=> [" "]</TD> </TR> <TR>

479+ <TD>y_string_u+2029_par_sep.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E280A9"] <=> [" "]</TD> </TR> <TR>

480+ <TD>y_string_unicode_2.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E28D82E388B4E28D82"] <=> ["⍂㈴⍂"]</TD> </TR> <TR>

481+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

482+ <TD>y_string_utf8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E282ACF09D849E"] <=> ["€𝄞"]</TD> </TR> <TR>

483+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

484+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

485+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

486+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

487+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

488+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

489+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

490+

491+

492+<A NAME="2"></A><H4>C JSON Checker 2</H4>

493+<TABLE>

494+ <TR>

495+ <TH></TH>

496+ <TH class="space"><DIV></DIV></TH>

497+ <TH></TH>

498+ </TR>

499+ <TR>

500+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

501+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

502+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

503+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

504+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

505+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

506+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

507+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

508+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

509+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

510+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

511+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

512+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

513+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

514+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

515+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

516+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

517+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

518+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

519+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

520+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

521+ <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

522+ <TD>y_string_nonCharacterInUTF-8_U+1FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F09BBFBF"] <=> ["𛿿"]</TD> </TR> <TR>

523+ <TD>y_string_nonCharacterInUTF-8_U+FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["EFBFBF"] <=> [""]</TD> </TR> <TR>

524+ <TD>y_string_pi.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["CF80"] <=> ["π"]</TD> </TR> <TR>

525+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

526+ <TD>y_string_u+2028_line_sep.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E280A8"] <=> [" "]</TD> </TR> <TR>

527+ <TD>y_string_u+2029_par_sep.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E280A9"] <=> [" "]</TD> </TR> <TR>

528+ <TD>y_string_unicode_2.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E28D82E388B4E28D82"] <=> ["⍂㈴⍂"]</TD> </TR> <TR>

529+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

530+ <TD>y_string_utf8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E282ACF09D849E"] <=> ["€𝄞"]</TD> </TR> <TR>

531+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

532+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

533+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

534+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

535+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

536+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

537+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

538+

539+

540+<A NAME="3"></A><H4><A HREF="https://github.com/udp/json-parser">C JSON Parser by udp</A></H4>

541+<TABLE>

542+ <TR>

543+ <TH></TH>

544+ <TH class="space"><DIV></DIV></TH>

545+ <TH></TH>

546+ </TR>

547+ <TR>

548+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

549+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

550+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

551+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

552+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

553+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

554+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

555+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

556+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

557+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

558+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

559+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

560+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

561+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

562+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

563+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

564+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

565+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

566+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

567+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

568+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

569+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

570+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

571+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

572+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

573+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

574+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

575+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

576+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

577+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

578+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

579+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

580+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

581+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

582+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

583+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

584+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

585+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

586+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

587+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

588+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

589+line"]</TD> </TR> <TR>

590+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

591+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

592+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

593+

594+

595+<A NAME="4"></A><H4><A HREF="https://github.com/DaveGamble/cJSON">C cJSON</A></H4>

596+<TABLE>

597+ <TR>

598+ <TH></TH>

599+ <TH class="space"><DIV></DIV></TH>

600+ <TH></TH>

601+ </TR>

602+ <TR>

603+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

604+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

605+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

606+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

607+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

608+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

609+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

610+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

611+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

612+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

613+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

614+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

615+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

616+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

617+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

618+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

619+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

620+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

621+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

622+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

623+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

624+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

625+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

626+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

627+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

628+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

629+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

630+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

631+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

632+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

633+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

634+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

635+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

636+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

637+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

638+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

639+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

640+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

641+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

642+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

643+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

644+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

645+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

646+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

647+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

648+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

649+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

650+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

651+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

652+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

653+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

654+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

655+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

656+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

657+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

658+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

659+ <TD>n_string_single_doublequote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"</TD> </TR> <TR>

660+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

661+line"]</TD> </TR> <TR>

662+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

663+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

664+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

665+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

666+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

667+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

668+ <TD>n_structure_close_unopened_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>1]</TD> </TR> <TR>

669+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

670+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

671+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

672+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

673+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

674+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

675+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

676+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

677+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

678+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

679+

680+

681+<A NAME="5"></A><H4>C ccan</H4>

682+<TABLE>

683+ <TR>

684+ <TH></TH>

685+ <TH class="space"><DIV></DIV></TH>

686+ <TH></TH>

687+ </TR>

688+ <TR>

689+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

690+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

691+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

692+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

693+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

694+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

695+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

696+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

697+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

698+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

699+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

700+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

701+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

702+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

703+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

704+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

705+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

706+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

707+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

708+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

709+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

710+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

711+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

712+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

713+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

714+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

715+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

716+

717+

718+<A NAME="6"></A><H4>C jansson</H4>

719+<TABLE>

720+ <TR>

721+ <TH></TH>

722+ <TH class="space"><DIV></DIV></TH>

723+ <TH></TH>

724+ </TR>

725+ <TR>

726+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

727+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

728+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

729+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

730+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

731+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

732+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

733+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

734+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

735+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

736+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

737+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

738+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

739+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

740+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

741+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

742+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

743+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

744+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

745+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

746+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

747+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

748+ <TD>y_number_real_neg_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

749+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

750+ <TD>y_number_too_big_neg_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

751+ <TD>y_number_too_big_pos_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

752+ <TD>y_number_very_big_negative_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

753+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

754+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

755+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

756+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

757+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

758+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

759+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

760+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

761+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

762+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

763+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

764+

765+

766+<A NAME="7"></A><H4><A HREF="https://github.com/zserge/jsmn">C jsmn</A></H4>

767+<TABLE>

768+ <TR>

769+ <TH></TH>

770+ <TH class="space"><DIV></DIV></TH>

771+ <TH></TH>

772+ </TR>

773+ <TR>

774+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

775+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

776+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

777+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

778+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

779+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

780+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

781+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

782+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

783+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

784+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

785+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

786+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

787+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

788+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

789+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

790+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

791+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

792+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

793+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

794+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

795+ <TD>n_array_1_true_without_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 true]</TD> </TR> <TR>

796+ <TD>n_array_colon_instead_of_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["": 1]</TD> </TR> <TR>

797+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

798+ <TD>n_array_comma_and_number.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,1]</TD> </TR> <TR>

799+ <TD>n_array_double_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,2]</TD> </TR> <TR>

800+ <TD>n_array_double_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x",,]</TD> </TR> <TR>

801+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

802+ <TD>n_array_items_separated_by_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1:2]</TD> </TR> <TR>

803+ <TD>n_array_just_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,]</TD> </TR> <TR>

804+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

805+ <TD>n_array_missing_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[ , ""]</TD> </TR> <TR>

806+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

807+ <TD>n_array_number_and_several_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,]</TD> </TR> <TR>

808+ <TD>n_array_spaces_vertical_tab_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["0Ba"\f] <=> ["a"\f]</TD> </TR> <TR>

809+ <TD>n_array_star_inside.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[*]</TD> </TR> <TR>

810+ <TD>n_incomplete_false.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[fals]</TD> </TR> <TR>

811+ <TD>n_incomplete_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[nul]</TD> </TR> <TR>

812+ <TD>n_incomplete_true.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[tru]</TD> </TR> <TR>

813+ <TD>n_number_++.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[++1234]</TD> </TR> <TR>

814+ <TD>n_number_+1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[+1]</TD> </TR> <TR>

815+ <TD>n_number_+Inf.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[+Inf]</TD> </TR> <TR>

816+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

817+ <TD>n_number_-1.0..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-1.0.]</TD> </TR> <TR>

818+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

819+ <TD>n_number_-NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-NaN]</TD> </TR> <TR>

820+ <TD>n_number_.-1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.-1]</TD> </TR> <TR>

821+ <TD>n_number_.2e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.2e-3]</TD> </TR> <TR>

822+ <TD>n_number_0.1.2.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.1.2]</TD> </TR> <TR>

823+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

824+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

825+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

826+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

827+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

828+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

829+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

830+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

831+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

832+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

833+ <TD>n_number_1_000.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 000.0]</TD> </TR> <TR>

834+ <TD>n_number_1eE2.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1eE2]</TD> </TR> <TR>

835+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

836+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

837+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

838+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

839+ <TD>n_number_Inf.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Inf]</TD> </TR> <TR>

840+ <TD>n_number_NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[NaN]</TD> </TR> <TR>

841+ <TD>n_number_expression.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1+2]</TD> </TR> <TR>

842+ <TD>n_number_hex_1_digit.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0x1]</TD> </TR> <TR>

843+ <TD>n_number_hex_2_digits.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0x42]</TD> </TR> <TR>

844+ <TD>n_number_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Infinity]</TD> </TR> <TR>

845+ <TD>n_number_invalid+-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+-1]</TD> </TR> <TR>

846+ <TD>n_number_invalid-negative-real.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-123.123foo]</TD> </TR> <TR>

847+ <TD>n_number_minus_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-Infinity]</TD> </TR> <TR>

848+ <TD>n_number_minus_sign_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-foo]</TD> </TR> <TR>

849+ <TD>n_number_minus_space_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[- 1]</TD> </TR> <TR>

850+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

851+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

852+ <TD>n_number_neg_with_garbage_at_end.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-1x]</TD> </TR> <TR>

853+ <TD>n_number_real_garbage_after_e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1ea]</TD> </TR> <TR>

854+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

855+ <TD>n_number_starting_with_dot.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.123]</TD> </TR> <TR>

856+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

857+ <TD>n_number_with_alpha.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.2a-3]</TD> </TR> <TR>

858+ <TD>n_number_with_alpha_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.8011670033376514H-308]</TD> </TR> <TR>

859+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

860+ <TD>n_object_bad_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x", truth]</TD> </TR> <TR>

861+ <TD>n_object_comma_instead_of_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"x", null}</TD> </TR> <TR>

862+ <TD>n_object_double_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"x"::"b"}</TD> </TR> <TR>

863+ <TD>n_object_garbage_at_end.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"a" 123}</TD> </TR> <TR>

864+ <TD>n_object_key_with_single_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{key: 'value'}</TD> </TR> <TR>

865+ <TD>n_object_missing_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a" b}</TD> </TR> <TR>

866+ <TD>n_object_missing_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{:"b"}</TD> </TR> <TR>

867+ <TD>n_object_missing_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a" "b"}</TD> </TR> <TR>

868+ <TD>n_object_non_string_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{1:1}</TD> </TR> <TR>

869+ <TD>n_object_non_string_key_but_huge_number_instead.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{9999E9999:1}</TD> </TR> <TR>

870+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

871+ <TD>n_object_repeated_null_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{null:null,null:null}</TD> </TR> <TR>

872+ <TD>n_object_several_trailing_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,,,,,}</TD> </TR> <TR>

873+ <TD>n_object_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{'a':0}</TD> </TR> <TR>

874+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

875+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

876+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

877+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

878+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

879+ <TD>n_object_two_commas_in_a_row.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b",,"c":"d"}</TD> </TR> <TR>

880+ <TD>n_object_unquoted_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{a: "b"}</TD> </TR> <TR>

881+ <TD>n_object_with_single_string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{ "foo" : "bar", "a" }</TD> </TR> <TR>

882+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

883+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

884+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

885+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

886+ <TD>n_string_leading_uescaped_thinspace.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[\u0020"asd"]</TD> </TR> <TR>

887+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

888+ <TD>n_string_no_quotes_with_bad_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[\n]</TD> </TR> <TR>

889+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

890+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

891+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

892+ <TD>n_string_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>['single quote']</TD> </TR> <TR>

893+ <TD>n_string_single_string_no_double_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>abc</TD> </TR> <TR>

894+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

895+line"]</TD> </TR> <TR>

896+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

897+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

898+ <TD>n_structure_<.>.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD><.></TD> </TR> <TR>

899+ <TD>n_structure_<null>.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[<null>]</TD> </TR> <TR>

900+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

901+ <TD>n_structure_capitalized_True.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[True]</TD> </TR> <TR>

902+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

903+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

904+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

905+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

906+ <TD>n_structure_single_star.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>*</TD> </TR> <TR>

907+ <TD>n_structure_uescaped_LF_before_string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[\u000A""]</TD> </TR> <TR>

908+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

909+ <TD>y_object_long_strings.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"x":[{"id": "xxxxxxxxxxxxxxxxxxxxxx(...)</TD> </TR> <TR>

910+ <TD>y_object_string_unicode.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"title":"\u041f\u043e\u043b\u0442\u(...)</TD> </TR> <TR>

911+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

912+

913+

914+<A NAME="8"></A><H4><A HREF="https://github.com/crystal-lang/crystal">Crystal</A></H4>

915+

916+<A NAME="9"></A><H4>Go 1.7.1</H4>

917+<TABLE>

918+ <TR>

919+ <TH></TH>

920+ <TH class="space"><DIV></DIV></TH>

921+ <TH></TH>

922+ </TR>

923+ <TR>

924+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

925+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

926+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

927+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

928+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

929+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

930+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

931+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

932+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

933+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

934+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

935+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

936+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

937+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

938+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

939+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

940+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

941+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

942+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

943+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

944+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

945+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

946+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

947+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

948+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

949+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

950+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

951+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

952+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

953+ <TD>y_number_real_neg_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

954+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

955+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

956+

957+

958+<A NAME="10"></A><H4><A HREF="https://github.com/bos/aeson">Haskell Aeson 0.11.2.1</A></H4>

959+

960+<A NAME="11"></A><H4>Java Jackson 2.8.4</H4>

961+<TABLE>

962+ <TR>

963+ <TH></TH>

964+ <TH class="space"><DIV></DIV></TH>

965+ <TH></TH>

966+ </TR>

967+ <TR>

968+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

969+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

970+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

971+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

972+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

973+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

974+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

975+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

976+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

977+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

978+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

979+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

980+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

981+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

982+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

983+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

984+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

985+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

986+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

987+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

988+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

989+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

990+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

991+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

992+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

993+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

994+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

995+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

996+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

997+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

998+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

999+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1000+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1001+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1002+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1003+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

1004+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

1005+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

1006+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

1007+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

1008+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

1009+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1010+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1011+

1012+

1013+<A NAME="12"></A><H4>Java com.leastfixedpoint.json 1.0</H4>

1014+<TABLE>

1015+ <TR>

1016+ <TH></TH>

1017+ <TH class="space"><DIV></DIV></TH>

1018+ <TH></TH>

1019+ </TR>

1020+ <TR>

1021+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1022+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1023+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1024+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1025+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1026+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1027+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1028+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1029+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1030+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1031+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1032+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1033+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1034+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1035+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1036+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1037+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1038+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1039+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1040+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1041+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1042+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

1043+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1044+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1045+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1046+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1047+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1048+ <TD>n_number_U+FF11_fullwidth_digit_one.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[EFBC91] <=> [１]</TD> </TR> <TR>

1049+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

1050+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

1051+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1052+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

1053+ <TD>n_object_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{'a':0}</TD> </TR> <TR>

1054+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1055+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1056+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

1057+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1058+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1059+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1060+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1061+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1062+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1063+ <TD>n_string_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>['single quote']</TD> </TR> <TR>

1064+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1065+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1066+line"]</TD> </TR> <TR>

1067+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1068+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

1069+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

1070+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1071+

1072+

1073+<A NAME="13"></A><H4>Java gson 2.7</H4>

1074+<TABLE>

1075+ <TR>

1076+ <TH></TH>

1077+ <TH class="space"><DIV></DIV></TH>

1078+ <TH></TH>

1079+ </TR>

1080+ <TR>

1081+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1082+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1083+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1084+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1085+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1086+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1087+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1088+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1089+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1090+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1091+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1092+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1093+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1094+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1095+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1096+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1097+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1098+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1099+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1100+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1101+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1102+ <TD>n_array_a_invalid_utf8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[aE5] <=> [a]</TD> </TR> <TR>

1103+ <TD>n_array_comma_and_number.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,1]</TD> </TR> <TR>

1104+ <TD>n_array_double_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,2]</TD> </TR> <TR>

1105+ <TD>n_array_double_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x",,]</TD> </TR> <TR>

1106+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1107+ <TD>n_array_invalid_utf8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[FF] <=> []</TD> </TR> <TR>

1108+ <TD>n_array_just_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,]</TD> </TR> <TR>

1109+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

1110+ <TD>n_array_missing_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[ , ""]</TD> </TR> <TR>

1111+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1112+ <TD>n_array_number_and_several_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,]</TD> </TR> <TR>

1113+ <TD>n_array_star_inside.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[*]</TD> </TR> <TR>

1114+ <TD>n_incomplete_false.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[fals]</TD> </TR> <TR>

1115+ <TD>n_incomplete_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[nul]</TD> </TR> <TR>

1116+ <TD>n_incomplete_true.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[tru]</TD> </TR> <TR>

1117+ <TD>n_number_++.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[++1234]</TD> </TR> <TR>

1118+ <TD>n_number_+1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[+1]</TD> </TR> <TR>

1119+ <TD>n_number_+Inf.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[+Inf]</TD> </TR> <TR>

1120+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

1121+ <TD>n_number_-1.0..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-1.0.]</TD> </TR> <TR>

1122+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1123+ <TD>n_number_-NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-NaN]</TD> </TR> <TR>

1124+ <TD>n_number_.-1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.-1]</TD> </TR> <TR>

1125+ <TD>n_number_.2e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.2e-3]</TD> </TR> <TR>

1126+ <TD>n_number_0.1.2.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.1.2]</TD> </TR> <TR>

1127+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

1128+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

1129+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1130+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

1131+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

1132+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

1133+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

1134+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

1135+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

1136+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

1137+ <TD>n_number_1eE2.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1eE2]</TD> </TR> <TR>

1138+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1139+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1140+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1141+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

1142+ <TD>n_number_Inf.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Inf]</TD> </TR> <TR>

1143+ <TD>n_number_NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[NaN]</TD> </TR> <TR>

1144+ <TD>n_number_U+FF11_fullwidth_digit_one.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[EFBC91] <=> [１]</TD> </TR> <TR>

1145+ <TD>n_number_expression.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1+2]</TD> </TR> <TR>

1146+ <TD>n_number_hex_1_digit.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0x1]</TD> </TR> <TR>

1147+ <TD>n_number_hex_2_digits.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0x42]</TD> </TR> <TR>

1148+ <TD>n_number_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Infinity]</TD> </TR> <TR>

1149+ <TD>n_number_invalid+-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+-1]</TD> </TR> <TR>

1150+ <TD>n_number_invalid-negative-real.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-123.123foo]</TD> </TR> <TR>

1151+ <TD>n_number_invalid-utf-8-in-bigger-int.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[123E5] <=> [123]</TD> </TR> <TR>

1152+ <TD>n_number_invalid-utf-8-in-exponent.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1e1E5] <=> [1e1]</TD> </TR> <TR>

1153+ <TD>n_number_invalid-utf-8-in-int.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E5]0A <=> [0]

1154+</TD> </TR> <TR>

1155+ <TD>n_number_minus_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-Infinity]</TD> </TR> <TR>

1156+ <TD>n_number_minus_sign_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-foo]</TD> </TR> <TR>

1157+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

1158+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

1159+ <TD>n_number_neg_with_garbage_at_end.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-1x]</TD> </TR> <TR>

1160+ <TD>n_number_real_garbage_after_e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1ea]</TD> </TR> <TR>

1161+ <TD>n_number_real_with_invalid_utf8_after_e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1eE5] <=> [1e]</TD> </TR> <TR>

1162+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1163+ <TD>n_number_starting_with_dot.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.123]</TD> </TR> <TR>

1164+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

1165+ <TD>n_number_with_alpha.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.2a-3]</TD> </TR> <TR>

1166+ <TD>n_number_with_alpha_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.8011670033376514H-308]</TD> </TR> <TR>

1167+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

1168+ <TD>n_object_bad_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x", truth]</TD> </TR> <TR>

1169+ <TD>n_object_key_with_single_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{key: 'value'}</TD> </TR> <TR>

1170+ <TD>n_object_non_string_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{1:1}</TD> </TR> <TR>

1171+ <TD>n_object_non_string_key_but_huge_number_instead.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{9999E9999:1}</TD> </TR> <TR>

1172+ <TD>n_object_repeated_null_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{null:null,null:null}</TD> </TR> <TR>

1173+ <TD>n_object_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{'a':0}</TD> </TR> <TR>

1174+ <TD>n_object_unquoted_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{a: "b"}</TD> </TR> <TR>

1175+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1176+ <TD>n_string_accentuated_char_no_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[C3A9] <=> [é]</TD> </TR> <TR>

1177+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1178+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1179+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1180+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1181+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1182+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1183+ <TD>n_string_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>['single quote']</TD> </TR> <TR>

1184+ <TD>n_string_single_string_no_double_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>abc</TD> </TR> <TR>

1185+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1186+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1187+line"]</TD> </TR> <TR>

1188+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1189+ <TD>n_structure_<.>.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD><.></TD> </TR> <TR>

1190+ <TD>n_structure_<null>.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[<null>]</TD> </TR> <TR>

1191+ <TD>n_structure_U+2060_word_joined.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[E281A0] <=> [⁠]</TD> </TR> <TR>

1192+ <TD>n_structure_ascii-unicode-identifier.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>aC3A5 <=> aå</TD> </TR> <TR>

1193+ <TD>n_structure_capitalized_True.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[True]</TD> </TR> <TR>

1194+ <TD>n_structure_lone-invalid-utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>E5 <=> </TD> </TR> <TR>

1195+ <TD>n_structure_null-byte-outside-string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[00] <=> []</TD> </TR> <TR>

1196+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

1197+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

1198+ <TD>n_structure_single_point.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>E9 <=> </TD> </TR> <TR>

1199+ <TD>n_structure_single_star.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>*</TD> </TR> <TR>

1200+ <TD>n_structure_unicode-identifier.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>C3A5 <=> å</TD> </TR> <TR>

1201+ <TD>n_structure_whitespace_U+2060_word_joiner.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[E281A0] <=> [⁠]</TD> </TR> <TR>

1202+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1203+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

1204+

1205+

1206+<A NAME="14"></A><H4>Java json-simple 1.1.1</H4>

1207+<TABLE>

1208+ <TR>

1209+ <TH></TH>

1210+ <TH class="space"><DIV></DIV></TH>

1211+ <TH></TH>

1212+ </TR>

1213+ <TR>

1214+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1215+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1216+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1217+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1218+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1219+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1220+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1221+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1222+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1223+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1224+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1225+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1226+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1227+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1228+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1229+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1230+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1231+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1232+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1233+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1234+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1235+ <TD>n_array_1_true_without_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 true]</TD> </TR> <TR>

1236+ <TD>n_array_comma_and_number.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,1]</TD> </TR> <TR>

1237+ <TD>n_array_double_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,2]</TD> </TR> <TR>

1238+ <TD>n_array_double_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x",,]</TD> </TR> <TR>

1239+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1240+ <TD>n_array_inner_array_no_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[3[4]]</TD> </TR> <TR>

1241+ <TD>n_array_just_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,]</TD> </TR> <TR>

1242+ <TD>n_array_missing_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[ , ""]</TD> </TR> <TR>

1243+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1244+ <TD>n_array_number_and_several_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,]</TD> </TR> <TR>

1245+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

1246+ <TD>n_number_1_000.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 000.0]</TD> </TR> <TR>

1247+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

1248+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

1249+ <TD>n_object_double_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"x"::"b"}</TD> </TR> <TR>

1250+ <TD>n_object_missing_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a" "b"}</TD> </TR> <TR>

1251+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

1252+ <TD>n_object_several_trailing_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,,,,,}</TD> </TR> <TR>

1253+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1254+ <TD>n_object_two_commas_in_a_row.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b",,"c":"d"}</TD> </TR> <TR>

1255+ <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

1256+ <TD>n_string_1_surrogate_then_escape u1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1"]</TD> </TR> <TR>

1257+ <TD>n_string_1_surrogate_then_escape u1x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1x"]</TD> </TR> <TR>

1258+ <TD>n_string_UTF-16_incomplete_surrogate.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1259+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1260+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

1261+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

1262+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

1263+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

1264+ <TD>n_string_incomplete_escaped_character.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\u00A"]</TD> </TR> <TR>

1265+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

1266+ <TD>n_string_invalid-utf-8-in-escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uE5"] <=> ["\u"]</TD> </TR> <TR>

1267+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

1268+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

1269+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1270+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

1271+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1272+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1273+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1274+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1275+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1276+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1277+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1278+line"]</TD> </TR> <TR>

1279+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1280+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

1281+ <TD>y_number_too_big_neg_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

1282+ <TD>y_number_too_big_pos_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

1283+ <TD>y_number_very_big_negative_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

1284+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1285+

1286+

1287+<A NAME="15"></A><H4>Java nanojson 1.0</H4>

1288+<TABLE>

1289+ <TR>

1290+ <TH></TH>

1291+ <TH class="space"><DIV></DIV></TH>

1292+ <TH></TH>

1293+ </TR>

1294+ <TR>

1295+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1296+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1297+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1298+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1299+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1300+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1301+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1302+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1303+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1304+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1305+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1306+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1307+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1308+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1309+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1310+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1311+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1312+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1313+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1314+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1315+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1316+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1317+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1318+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1319+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1320+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR></TABLE>

1321+

1322+

1323+<A NAME="16"></A><H4>JavaScript</H4>

1324+<TABLE>

1325+ <TR>

1326+ <TH></TH>

1327+ <TH class="space"><DIV></DIV></TH>

1328+ <TH></TH>

1329+ </TR>

1330+ <TR>

1331+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1332+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1333+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1334+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1335+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1336+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1337+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1338+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1339+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1340+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1341+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1342+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1343+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1344+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1345+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1346+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1347+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1348+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1349+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1350+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1351+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1352+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1353+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1354+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1355+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1356+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1357+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1358+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1359+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1360+

1361+

1362+<A NAME="17"></A><H4><A HREF="http://www.newtonsoft.com/json">Json.NET 9.0.1</A></H4>

1363+

1364+<A NAME="18"></A><H4><A HREF="http://regex.info/blog/lua/json">Lua JSON 20160916.19</A></H4>

1365+<TABLE>

1366+ <TR>

1367+ <TH></TH>

1368+ <TH class="space"><DIV></DIV></TH>

1369+ <TH></TH>

1370+ </TR>

1371+ <TR>

1372+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1373+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1374+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1375+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1376+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1377+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1378+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1379+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1380+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1381+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1382+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1383+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1384+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1385+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1386+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1387+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1388+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1389+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1390+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1391+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1392+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1393+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

1394+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

1395+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1396+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

1397+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1398+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

1399+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

1400+ <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

1401+ <TD>n_string_1_surrogate_then_escape u1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1"]</TD> </TR> <TR>

1402+ <TD>n_string_1_surrogate_then_escape u1x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1x"]</TD> </TR> <TR>

1403+ <TD>n_string_UTF-16_incomplete_surrogate.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1404+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1405+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

1406+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

1407+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

1408+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

1409+ <TD>n_string_incomplete_escaped_character.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\u00A"]</TD> </TR> <TR>

1410+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

1411+ <TD>n_string_invalid-utf-8-in-escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uE5"] <=> ["\u"]</TD> </TR> <TR>

1412+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

1413+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

1414+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1415+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

1416+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1417+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1418+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1419+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1420+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1421+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1422+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1423+line"]</TD> </TR> <TR>

1424+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1425+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

1426+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

1427+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

1428+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

1429+ <TD>n_structure_close_unopened_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>1]</TD> </TR> <TR>

1430+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

1431+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

1432+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

1433+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

1434+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1435+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1436+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

1437+

1438+

1439+<A NAME="19"></A><H4><A HREF="http://dkolf.de/src/dkjson-lua.fsl/home">Lua dkjson</A></H4>

1440+<TABLE>

1441+ <TR>

1442+ <TH></TH>

1443+ <TH class="space"><DIV></DIV></TH>

1444+ <TH></TH>

1445+ </TR>

1446+ <TR>

1447+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1448+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1449+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1450+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1451+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1452+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1453+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1454+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1455+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1456+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1457+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1458+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1459+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1460+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1461+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1462+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1463+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1464+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1465+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1466+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1467+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1468+ <TD>n_array_1_true_without_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 true]</TD> </TR> <TR>

1469+ <TD>n_array_colon_instead_of_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["": 1]</TD> </TR> <TR>

1470+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

1471+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

1472+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1473+ <TD>n_array_inner_array_no_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[3[4]]</TD> </TR> <TR>

1474+ <TD>n_array_items_separated_by_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1:2]</TD> </TR> <TR>

1475+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1476+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

1477+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1478+ <TD>n_number_.2e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.2e-3]</TD> </TR> <TR>

1479+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1480+ <TD>n_number_1_000.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 000.0]</TD> </TR> <TR>

1481+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1482+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1483+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1484+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

1485+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

1486+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1487+ <TD>n_number_starting_with_dot.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.123]</TD> </TR> <TR>

1488+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

1489+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

1490+ <TD>n_object_comma_instead_of_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"x", null}</TD> </TR> <TR>

1491+ <TD>n_object_garbage_at_end.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"a" 123}</TD> </TR> <TR>

1492+ <TD>n_object_missing_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a" "b"}</TD> </TR> <TR>

1493+ <TD>n_object_non_string_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{1:1}</TD> </TR> <TR>

1494+ <TD>n_object_non_string_key_but_huge_number_instead.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{9999E9999:1}</TD> </TR> <TR>

1495+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

1496+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1497+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1498+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

1499+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1500+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

1501+ <TD>n_object_with_single_string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{ "foo" : "bar", "a" }</TD> </TR> <TR>

1502+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

1503+ <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

1504+ <TD>n_string_1_surrogate_then_escape u1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1"]</TD> </TR> <TR>

1505+ <TD>n_string_1_surrogate_then_escape u1x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1x"]</TD> </TR> <TR>

1506+ <TD>n_string_UTF-16_incomplete_surrogate.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1507+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1508+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

1509+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

1510+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

1511+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

1512+ <TD>n_string_incomplete_escaped_character.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\u00A"]</TD> </TR> <TR>

1513+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

1514+ <TD>n_string_invalid-utf-8-in-escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uE5"] <=> ["\u"]</TD> </TR> <TR>

1515+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

1516+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

1517+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1518+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

1519+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1520+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1521+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1522+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1523+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1524+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1525+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1526+line"]</TD> </TR> <TR>

1527+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1528+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

1529+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

1530+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

1531+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

1532+ <TD>n_structure_close_unopened_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>1]</TD> </TR> <TR>

1533+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

1534+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

1535+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

1536+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

1537+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

1538+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1539+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

1540+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1541+

1542+

1543+<A NAME="20"></A><H4>Obj-C Apple NSJSONSerialization</H4>

1544+<TABLE>

1545+ <TR>

1546+ <TH></TH>

1547+ <TH class="space"><DIV></DIV></TH>

1548+ <TH></TH>

1549+ </TR>

1550+ <TR>

1551+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1552+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1553+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1554+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1555+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1556+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1557+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1558+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1559+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1560+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1561+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1562+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1563+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1564+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1565+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1566+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1567+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1568+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1569+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1570+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1571+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1572+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1573+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1574+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1575+ <TD>y_number_double_huge_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

1576+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

1577+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

1578+ <TD>y_number_real_underflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123e-10000000]</TD> </TR></TABLE>

1579+

1580+

1581+<A NAME="21"></A><H4>Obj-C JSONKit</H4>

1582+<TABLE>

1583+ <TR>

1584+ <TH></TH>

1585+ <TH class="space"><DIV></DIV></TH>

1586+ <TH></TH>

1587+ </TR>

1588+ <TR>

1589+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1590+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1591+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1592+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1593+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1594+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1595+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1596+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1597+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1598+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1599+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1600+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1601+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1602+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1603+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1604+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1605+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1606+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1607+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1608+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1609+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1610+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1611+ <TD>n_structure_no_data.json</TD> <TD class="CRASH"></TD> <TD></TD> </TR> <TR>

1612+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

1613+ <TD>y_number_double_huge_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

1614+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

1615+ <TD>y_number_real_neg_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

1616+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

1617+ <TD>y_number_real_underflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123e-10000000]</TD> </TR> <TR>

1618+ <TD>y_number_too_big_neg_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

1619+ <TD>y_number_too_big_pos_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

1620+ <TD>y_number_very_big_negative_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

1621+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

1622+ <TD>y_string_escaped_noncharacter.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uFFFF"]</TD> </TR> <TR>

1623+ <TD>y_string_last_surrogates_1_and_2.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uDBFF\uDFFF"]</TD> </TR> <TR>

1624+ <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

1625+ <TD>y_string_nonCharacterInUTF-8_U+FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["EFBFBF"] <=> [""]</TD> </TR> <TR>

1626+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

1627+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

1628+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1629+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

1630+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

1631+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

1632+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

1633+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

1634+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

1635+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

1636+

1637+

1638+<A NAME="22"></A><H4><A HREF="https://github.com/stig/json-framework">Obj-C SBJSON 4.0.3</A></H4>

1639+<TABLE>

1640+ <TR>

1641+ <TH></TH>

1642+ <TH class="space"><DIV></DIV></TH>

1643+ <TH></TH>

1644+ </TR>

1645+ <TR>

1646+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1647+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1648+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1649+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1650+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1651+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1652+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1653+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="CRASH"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1654+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1655+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1656+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1657+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1658+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1659+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="CRASH"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1660+ <TD>i_string_truncated-utf-8.json</TD> <TD class="CRASH"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1661+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1662+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1663+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1664+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1665+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1666+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1667+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

1668+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

1669+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

1670+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="CRASH"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

1671+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1672+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

1673+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1674+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

1675+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

1676+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="CRASH"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1677+ <TD>n_string_invalid_utf-8.json</TD> <TD class="CRASH"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1678+ <TD>n_string_iso_latin_1.json</TD> <TD class="CRASH"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1679+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="CRASH"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1680+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="CRASH"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1681+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="CRASH"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1682+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="CRASH"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1683+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

1684+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

1685+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

1686+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

1687+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

1688+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1689+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

1690+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1691+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

1692+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

1693+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

1694+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

1695+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

1696+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

1697+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

1698+

1699+

1700+<A NAME="23"></A><H4><A HREF="https://github.com/TouchCode/TouchJSON">Obj-C TouchJSON</A></H4>

1701+<TABLE>

1702+ <TR>

1703+ <TH></TH>

1704+ <TH class="space"><DIV></DIV></TH>

1705+ <TH></TH>

1706+ </TR>

1707+ <TR>

1708+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1709+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1710+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1711+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1712+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1713+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1714+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1715+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1716+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1717+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1718+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1719+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1720+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1721+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1722+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1723+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1724+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1725+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1726+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1727+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1728+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1729+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1730+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1731+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

1732+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1733+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

1734+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

1735+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1736+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

1737+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

1738+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

1739+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

1740+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

1741+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

1742+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

1743+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1744+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1745+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1746+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

1747+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

1748+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

1749+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1750+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

1751+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1752+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1753+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1754+line"]</TD> </TR> <TR>

1755+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1756+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1757+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

1758+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR></TABLE>

1759+

1760+

1761+<A NAME="24"></A><H4>PHP 5.5.36</H4>

1762+<TABLE>

1763+ <TR>

1764+ <TH></TH>

1765+ <TH class="space"><DIV></DIV></TH>

1766+ <TH></TH>

1767+ </TR>

1768+ <TR>

1769+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1770+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1771+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1772+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1773+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1774+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1775+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1776+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1777+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1778+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1779+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1780+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1781+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1782+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1783+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1784+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1785+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1786+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1787+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1788+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1789+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1790+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1791+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1792+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1793+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1794+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1795+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1796+ <TD>n_structure_no_data.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD></TD> </TR> <TR>

1797+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1798+

1799+

1800+<A NAME="25"></A><H4>Perl JSON</H4>

1801+<TABLE>

1802+ <TR>

1803+ <TH></TH>

1804+ <TH class="space"><DIV></DIV></TH>

1805+ <TH></TH>

1806+ </TR>

1807+ <TR>

1808+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1809+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1810+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1811+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1812+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1813+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1814+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1815+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1816+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1817+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1818+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1819+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1820+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1821+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1822+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1823+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1824+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1825+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1826+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1827+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1828+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1829+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1830+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1831+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

1832+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1833+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

1834+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1835+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1836+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1837+ <TD>y_array_with_1_and_newline.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[10A] <=> [1

1838+]</TD> </TR> <TR>

1839+ <TD>y_object_with_newlines.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{0A"a": "b"0A} <=> {

1840+"a": "b"

1841+}</TD> </TR> <TR>

1842+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1843+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

1844+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

1845+

1846+

1847+<A NAME="26"></A><H4><A HREF="http://search.cpan.org/dist/JSON-XS/XS.pm">Perl JSON::XS</A></H4>

1848+<TABLE>

1849+ <TR>

1850+ <TH></TH>

1851+ <TH class="space"><DIV></DIV></TH>

1852+ <TH></TH>

1853+ </TR>

1854+ <TR>

1855+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1856+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1857+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1858+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1859+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1860+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1861+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1862+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1863+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1864+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1865+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1866+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1867+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1868+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1869+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1870+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1871+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1872+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1873+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1874+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1875+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1876+ <TD>n_array_newlines_unclosed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a",0A40A,1, <=> ["a",

1877+4

1878+,1,</TD> </TR> <TR>

1879+ <TD>n_array_unclosed_with_new_lines.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,0A10A,1 <=> [1,

1880+1

1881+,1</TD> </TR> <TR>

1882+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

1883+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1884+ <TD>y_array_with_1_and_newline.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[10A] <=> [1

1885+]</TD> </TR> <TR>

1886+ <TD>y_object_with_newlines.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{0A"a": "b"0A} <=> {

1887+"a": "b"

1888+}</TD> </TR> <TR>

1889+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

1890+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1891+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

1892+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

1893+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

1894+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

1895+

1896+

1897+<A NAME="27"></A><H4>Python 2.7.10</H4>

1898+<TABLE>

1899+ <TR>

1900+ <TH></TH>

1901+ <TH class="space"><DIV></DIV></TH>

1902+ <TH></TH>

1903+ </TR>

1904+ <TR>

1905+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1906+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1907+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1908+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1909+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1910+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1911+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1912+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1913+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1914+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1915+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1916+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1917+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1918+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1919+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1920+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1921+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1922+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1923+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1924+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1925+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1926+ <TD>n_number_NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[NaN]</TD> </TR> <TR>

1927+ <TD>n_number_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Infinity]</TD> </TR> <TR>

1928+ <TD>n_number_minus_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-Infinity]</TD> </TR> <TR>

1929+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1930+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1931+

1932+

1933+<A NAME="28"></A><H4>Qt JSON</H4>

1934+

1935+<A NAME="29"></A><H4>R jsonlite</H4>

1936+<TABLE>

1937+ <TR>

1938+ <TH></TH>

1939+ <TH class="space"><DIV></DIV></TH>

1940+ <TH></TH>

1941+ </TR>

1942+ <TR>

1943+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1944+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1945+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1946+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1947+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1948+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1949+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1950+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1951+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1952+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1953+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1954+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1955+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1956+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1957+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1958+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1959+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1960+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1961+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1962+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1963+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1964+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1965+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1966+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1967+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1968+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

1969+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

1970+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1971+

1972+

1973+<A NAME="30"></A><H4>R rjson</H4>

1974+<TABLE>

1975+ <TR>

1976+ <TH></TH>

1977+ <TH class="space"><DIV></DIV></TH>

1978+ <TH></TH>

1979+ </TR>

1980+ <TR>

1981+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1982+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1983+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1984+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1985+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1986+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1987+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1988+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1989+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1990+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1991+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1992+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1993+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1994+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1995+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1996+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1997+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1998+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1999+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

3572000 <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

3582001 <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2002+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

2003+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

2004+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

2005+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

2006+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

3592007 <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

2008+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

2009+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

3602010 <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

2011+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

2012+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

2013+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

2014+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

2015+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

2016+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

2017+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

3612018 <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

3622019 <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

3632020 <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

2021+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

2022+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

3642023 <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

365− <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR></TABLE>

2024+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

2025+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

2026+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

2027+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

2028+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

2029+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

2030+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

2031+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

2032+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

2033+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

2034+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

2035+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

2036+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

2037+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

2038+line"]</TD> </TR> <TR>

2039+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

2040+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

2041+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

2042+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

2043+ <TD>n_structure_close_unopened_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>1]</TD> </TR> <TR>

2044+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

2045+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

2046+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

2047+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

2048+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

2049+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2050+

2051+

2052+<A NAME="31"></A><H4>Ruby</H4>

2053+<TABLE>

2054+ <TR>

2055+ <TH></TH>

2056+ <TH class="space"><DIV></DIV></TH>

2057+ <TH></TH>

2058+ </TR>

2059+ <TR>

2060+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2061+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2062+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2063+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2064+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2065+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2066+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2067+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2068+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2069+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2070+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2071+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2072+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2073+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2074+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2075+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2076+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2077+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2078+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2079+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2080+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2081+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

2082+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

2083+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

2084+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

2085+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

2086+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

2087+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

2088+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

2089+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

2090+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

2091+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

2092+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

2093+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

2094+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

2095+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

2096+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2097+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

2098+

2099+

2100+<A NAME="32"></A><H4>Ruby regex</H4>

2101+<TABLE>

2102+ <TR>

2103+ <TH></TH>

2104+ <TH class="space"><DIV></DIV></TH>

2105+ <TH></TH>

2106+ </TR>

2107+ <TR>

2108+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2109+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2110+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2111+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2112+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2113+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2114+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2115+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2116+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2117+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2118+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2119+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2120+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2121+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2122+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2123+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2124+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2125+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2126+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2127+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2128+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2129+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

2130+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

2131+line"]</TD> </TR> <TR>

2132+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

2133+ <TD>n_structure_capitalized_True.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[True]</TD> </TR> <TR>

2134+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

2135+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

2136+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

2137+ <TD>y_object_string_unicode.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"title":"\u041f\u043e\u043b\u0442\u(...)</TD> </TR> <TR>

2138+ <TD>y_string_1_2_3_bytes_UTF-8_sequences.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0060\u012a\u12AB"]</TD> </TR> <TR>

2139+ <TD>y_string_UTF-16_Surrogates_U+1D11E_MUSICAL_SYMBOL_G_CLEF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2140+ <TD>y_string_accepted_surrogate_pair.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uD801\udc37"]</TD> </TR> <TR>

2141+ <TD>y_string_accepted_surrogate_pairs.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\ud83d\ude39\ud83d\udc8d"]</TD> </TR> <TR>

2142+ <TD>y_string_allowed_escapes.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\"\\\/\b\f\n\r\t"]</TD> </TR> <TR>

2143+ <TD>y_string_backslash_and_u_escaped_zero.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\\u0000"]</TD> </TR> <TR>

2144+ <TD>y_string_backslash_doublequotes.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\""]</TD> </TR> <TR>

2145+ <TD>y_string_double_escape_a.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\\a"]</TD> </TR> <TR>

2146+ <TD>y_string_double_escape_n.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\\n"]</TD> </TR> <TR>

2147+ <TD>y_string_escaped_control_character.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0012"]</TD> </TR> <TR>

2148+ <TD>y_string_escaped_noncharacter.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uFFFF"]</TD> </TR> <TR>

2149+ <TD>y_string_last_surrogates_1_and_2.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uDBFF\uDFFF"]</TD> </TR> <TR>

2150+ <TD>y_string_newline_uescaped.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["new\u00A0line"]</TD> </TR> <TR>

2151+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

2152+ <TD>y_string_one-byte-utf-8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u002c"]</TD> </TR> <TR>

2153+ <TD>y_string_three-byte-utf-8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0821"]</TD> </TR> <TR>

2154+ <TD>y_string_two-byte-utf-8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0123"]</TD> </TR> <TR>

2155+ <TD>y_string_uEscape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0061\u30af\u30EA\u30b9"]</TD> </TR> <TR>

2156+ <TD>y_string_unicode.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uA66D"]</TD> </TR> <TR>

2157+ <TD>y_string_unicodeEscapedBackslash.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u005C"]</TD> </TR> <TR>

2158+ <TD>y_string_unicode_U+200B_ZERO_WIDTH_SPACE.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u200B"]</TD> </TR> <TR>

2159+ <TD>y_string_unicode_U+2064_invisible_plus.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u2064"]</TD> </TR> <TR>

2160+ <TD>y_string_unicode_escaped_double_quote.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0022"]</TD> </TR> <TR>

2161+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2162+

2163+

2164+<A NAME="33"></A><H4><A HREF="https://github.com/maciejhirsz/json-rust">Rust json-rust</A></H4>

2165+<TABLE>

2166+ <TR>

2167+ <TH></TH>

2168+ <TH class="space"><DIV></DIV></TH>

2169+ <TH></TH>

2170+ </TR>

2171+ <TR>

2172+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2173+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2174+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2175+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2176+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2177+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2178+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2179+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2180+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2181+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2182+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2183+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2184+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2185+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2186+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2187+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2188+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2189+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2190+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2191+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2192+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2193+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

2194+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

2195+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

2196+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

2197+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

2198+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

2199+ <TD>n_string_accentuated_char_no_quotes.json</TD> <TD class="CRASH"></TD> <TD>[C3A9] <=> [é]</TD> </TR> <TR>

2200+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2201+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

2202+ <TD>n_structure_unicode-identifier.json</TD> <TD class="CRASH"></TD> <TD>C3A5 <=> å</TD> </TR> <TR>

2203+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

2204+ <TD>y_number_huge_exp.json</TD> <TD class="CRASH"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

2205+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2206+

2207+

2208+<A NAME="34"></A><H4><A HREF="https://doc.rust-lang.org/rustc-serialize/rustc_serialize/json/index.html">Rust rustc_serialize::json</A></H4>

2209+<TABLE>

2210+ <TR>

2211+ <TH></TH>

2212+ <TH class="space"><DIV></DIV></TH>

2213+ <TH></TH>

2214+ </TR>

2215+ <TR>

2216+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2217+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2218+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2219+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2220+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2221+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2222+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2223+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2224+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2225+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2226+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2227+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2228+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2229+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2230+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2231+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2232+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2233+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2234+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2235+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2236+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2237+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2238+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

2239+ <TD>y_number_huge_exp.json</TD> <TD class="CRASH"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

2240+ <TD>y_number_too_big_neg_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

2241+ <TD>y_number_too_big_pos_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

2242+ <TD>y_number_very_big_negative_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

2243+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2244+

2245+

2246+<A NAME="35"></A><H4><A HREF="https://github.com/serde-rs/json">Rust serde_json</A></H4>

2247+

2248+<A NAME="36"></A><H4><A HREF="http://www.squeaksource.com/JSON.html">Squeak JSON-tonyg</A></H4>

2249+

2250+<A NAME="37"></A><H4>Swift Apple JSONSerialization</H4>

2251+<TABLE>

2252+ <TR>

2253+ <TH></TH>

2254+ <TH class="space"><DIV></DIV></TH>

2255+ <TH></TH>

2256+ </TR>

2257+ <TR>

2258+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2259+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2260+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2261+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2262+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2263+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2264+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2265+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2266+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2267+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2268+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2269+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2270+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2271+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2272+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2273+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2274+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2275+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2276+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2277+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2278+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2279+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

2280+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

2281+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

2282+ <TD>y_number_double_huge_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

2283+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

2284+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

2285+ <TD>y_number_real_underflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123e-10000000]</TD> </TR></TABLE>

2286+

2287+

2288+<A NAME="38"></A><H4>Swift Freddy 2.1.0</H4>

2289+<TABLE>

2290+ <TR>

2291+ <TH></TH>

2292+ <TH class="space"><DIV></DIV></TH>

2293+ <TH></TH>

2294+ </TR>

2295+ <TR>

2296+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2297+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2298+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2299+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2300+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2301+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2302+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2303+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2304+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2305+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2306+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2307+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2308+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2309+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2310+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2311+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2312+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2313+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2314+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2315+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2316+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2317+ <TD>n_array_newlines_unclosed.json</TD> <TD class="CRASH"></TD> <TD>["a",0A40A,1, <=> ["a",

2318+4

2319+,1,</TD> </TR> <TR>

2320+ <TD>n_array_unclosed_trailing_comma.json</TD> <TD class="CRASH"></TD> <TD>[1,</TD> </TR> <TR>

2321+ <TD>n_object_missing_value.json</TD> <TD class="CRASH"></TD> <TD>{"a":</TD> </TR> <TR>

2322+ <TD>n_single_space.json</TD> <TD class="CRASH"></TD> <TD> </TD> </TR> <TR>

2323+ <TD>n_string_start_escape_unclosed.json</TD> <TD class="CRASH"></TD> <TD>["\</TD> </TR> <TR>

2324+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

2325+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

2326+line"]</TD> </TR> <TR>

2327+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

2328+ <TD>n_structure_object_unclosed_no_value.json</TD> <TD class="CRASH"></TD> <TD>{"":</TD> </TR> <TR>

2329+ <TD>y_number_0e+1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e+1]</TD> </TR> <TR>

2330+ <TD>y_number_0e1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e1]</TD> </TR> <TR>

2331+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2332+

2333+

2334+<A NAME="39"></A><H4>Swift Freddy 20160830</H4>

2335+<TABLE>

2336+ <TR>

2337+ <TH></TH>

2338+ <TH class="space"><DIV></DIV></TH>

2339+ <TH></TH>

2340+ </TR>

2341+ <TR>

2342+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2343+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2344+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2345+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2346+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2347+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2348+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2349+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2350+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2351+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2352+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2353+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2354+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2355+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2356+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2357+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2358+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2359+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2360+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2361+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2362+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2363+ <TD>n_string_start_escape_unclosed.json</TD> <TD class="CRASH"></TD> <TD>["\</TD> </TR> <TR>

2364+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

2365+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

2366+line"]</TD> </TR> <TR>

2367+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

2368+ <TD>y_number_0e+1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e+1]</TD> </TR> <TR>

2369+ <TD>y_number_0e1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e1]</TD> </TR> <TR>

2370+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2371+

2372+

2373+<A NAME="40"></A><H4>Swift Freddy 20161018</H4>

2374+<TABLE>

2375+ <TR>

2376+ <TH></TH>

2377+ <TH class="space"><DIV></DIV></TH>

2378+ <TH></TH>

2379+ </TR>

2380+ <TR>

2381+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2382+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2383+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2384+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2385+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2386+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2387+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2388+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2389+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2390+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2391+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2392+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2393+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2394+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2395+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2396+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2397+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2398+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2399+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2400+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2401+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2402+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

2403+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

2404+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

2405+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

2406+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

2407+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

2408+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

2409+ <TD>n_string_start_escape_unclosed.json</TD> <TD class="CRASH"></TD> <TD>["\</TD> </TR> <TR>

2410+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

2411+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

2412+line"]</TD> </TR> <TR>

2413+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

2414+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2415+

2416+

2417+<A NAME="41"></A><H4><A HREF="https://github.com/postmates/PMJSON">Swift PMJSON 1.1</A></H4>

2418+<TABLE>

2419+ <TR>

2420+ <TH></TH>

2421+ <TH class="space"><DIV></DIV></TH>

2422+ <TH></TH>

2423+ </TR>

2424+ <TR>

2425+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="CRASH"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2426+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2427+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2428+ <TD>i_string_UTF-16LE_with_BOM.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>FFFE[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

2429+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2430+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2431+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2432+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2433+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="CRASH"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2434+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2435+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="CRASH"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2436+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="CRASH"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2437+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2438+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2439+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2440+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2441+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2442+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2443+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2444+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2445+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

2446+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

2447+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

2448+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

2449+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

2450+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

2451+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

2452+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

2453+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

2454+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

2455+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

2456+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2457+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

2458+ <TD>y_number_0e+1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e+1]</TD> </TR> <TR>

2459+ <TD>y_number_neg_int_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-1e+9999]</TD> </TR> <TR>

2460+ <TD>y_number_real_capital_e_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[1E-2]</TD> </TR> <TR>

2461+ <TD>y_number_real_capital_e_pos_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[1E+2]</TD> </TR> <TR>

2462+ <TD>y_number_real_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[1e-2]</TD> </TR> <TR>

2463+ <TD>y_number_real_pos_exponent.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[1e+2]</TD> </TR> <TR>

2464+ <TD>y_number_real_underflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123e-10000000]</TD> </TR> <TR>

2465+ <TD>y_string_utf16BE_no_BOM.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>00[00"00E900"00] <=> [""]</TD> </TR> <TR>

2466+ <TD>y_string_utf16LE_no_BOM.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

2467+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

2468+

2469+

2470+<A NAME="42"></A><H4><A HREF="https://github.com/postmates/PMJSON">Swift PMJSON 1.2</A></H4>

2471+<TABLE>

2472+ <TR>

2473+ <TH></TH>

2474+ <TH class="space"><DIV></DIV></TH>

2475+ <TH></TH>

2476+ </TR>

2477+ <TR>

2478+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2479+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2480+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2481+ <TD>i_string_UTF-16LE_with_BOM.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>FFFE[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

2482+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2483+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2484+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2485+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2486+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2487+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2488+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2489+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2490+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2491+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2492+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2493+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2494+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2495+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2496+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2497+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2498+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

2499+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

2500+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

2501+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

2502+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

2503+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

2504+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

2505+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

2506+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

2507+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

2508+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

2509+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

2510+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

2511+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

2512+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

2513+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2514+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

2515+ <TD>y_string_utf16BE_no_BOM.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>00[00"00E900"00] <=> [""]</TD> </TR> <TR>

2516+ <TD>y_string_utf16LE_no_BOM.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

2517+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

2518+

2519+

2520+<A NAME="43"></A><H4>Swift STJSON</H4>

2521+<TABLE>

2522+ <TR>

2523+ <TH></TH>

2524+ <TH class="space"><DIV></DIV></TH>

2525+ <TH></TH>

2526+ </TR>

2527+ <TR>

2528+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2529+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2530+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2531+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2532+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2533+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2534+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2535+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2536+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2537+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2538+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2539+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2540+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2541+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2542+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2543+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2544+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2545+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2546+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2547+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2548+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2549+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

3662550

3672551

3682552

results/parsing_pruned.html+2283−96

@@ -11,13 +11,56 @@

1111 <BODY>

1212 <H1>JSON Parsing Tests</H1>

1313Appendix to: seriot.ch <A HREF="http://www.seriot.ch/parsing_json.php">Parsing JSON is a Minefield</A> http://www.seriot.ch/parsing_json.php

14−<PRE>2016-10-26 23:09:44</PRE>

14+<PRE>2016-10-27 13:18:49</PRE>

1515<H4>Contents</H4>

1616 <OL>

1717 <LI><A HREF="#color_scheme">Color Scheme</A>

1818 <LI><A HREF="#all_results">Full Results</A>

1919 <LI><A HREF="#results_by_parser">Results by Parser</A><UL>

20− <LI><A HREF="#0">Java nanojson 1.0</A>

20+ <LI><A HREF="#0">Bash JSON.sh 2016-08-12</A>

21+ <LI><A HREF="#1">C JSON Checker</A>

22+ <LI><A HREF="#2">C JSON Checker 2</A>

23+ <LI><A HREF="#3">C JSON Parser by udp</A>

24+ <LI><A HREF="#4">C cJSON</A>

25+ <LI><A HREF="#5">C ccan</A>

26+ <LI><A HREF="#6">C jansson</A>

27+ <LI><A HREF="#7">C jsmn</A>

28+ <LI><A HREF="#8">Crystal</A>

29+ <LI><A HREF="#9">Go 1.7.1</A>

30+ <LI><A HREF="#10">Haskell Aeson 0.11.2.1</A>

31+ <LI><A HREF="#11">Java Jackson 2.8.4</A>

32+ <LI><A HREF="#12">Java com.leastfixedpoint.json 1.0</A>

33+ <LI><A HREF="#13">Java gson 2.7</A>

34+ <LI><A HREF="#14">Java json-simple 1.1.1</A>

35+ <LI><A HREF="#15">Java nanojson 1.0</A>

36+ <LI><A HREF="#16">JavaScript</A>

37+ <LI><A HREF="#17">Json.NET 9.0.1</A>

38+ <LI><A HREF="#18">Lua JSON 20160916.19</A>

39+ <LI><A HREF="#19">Lua dkjson</A>

40+ <LI><A HREF="#20">Obj-C Apple NSJSONSerialization</A>

41+ <LI><A HREF="#21">Obj-C JSONKit</A>

42+ <LI><A HREF="#22">Obj-C SBJSON 4.0.3</A>

43+ <LI><A HREF="#23">Obj-C TouchJSON</A>

44+ <LI><A HREF="#24">PHP 5.5.36</A>

45+ <LI><A HREF="#25">Perl JSON</A>

46+ <LI><A HREF="#26">Perl JSON::XS</A>

47+ <LI><A HREF="#27">Python 2.7.10</A>

48+ <LI><A HREF="#28">Qt JSON</A>

49+ <LI><A HREF="#29">R jsonlite</A>

50+ <LI><A HREF="#30">R rjson</A>

51+ <LI><A HREF="#31">Ruby</A>

52+ <LI><A HREF="#32">Ruby regex</A>

53+ <LI><A HREF="#33">Rust json-rust</A>

54+ <LI><A HREF="#34">Rust rustc_serialize::json</A>

55+ <LI><A HREF="#35">Rust serde_json</A>

56+ <LI><A HREF="#36">Squeak JSON-tonyg</A>

57+ <LI><A HREF="#37">Swift Apple JSONSerialization</A>

58+ <LI><A HREF="#38">Swift Freddy 2.1.0</A>

59+ <LI><A HREF="#39">Swift Freddy 20160830</A>

60+ <LI><A HREF="#40">Swift Freddy 20161018</A>

61+ <LI><A HREF="#41">Swift PMJSON 1.1</A>

62+ <LI><A HREF="#42">Swift PMJSON 1.2</A>

63+ <LI><A HREF="#43">Swift STJSON</A>

2164</OL>

2265

2366 <A NAME="color_scheme"></A>

@@ -71,109 +114,111 @@

71114 <TH class="vertical"><DIV>Swift Freddy 2.1.0</DIV></TH>

72115 <TH class="vertical"><DIV>Swift Freddy 20160830</DIV></TH>

73116 <TH class="vertical"><DIV>Swift Freddy 20161018</DIV></TH>

74− <TH class="vertical"><DIV>Swift PMJSON 20161026</DIV></TH>

117+ <TH class="vertical"><DIV>Swift PMJSON 1.1</DIV></TH>

118+ <TH class="vertical"><DIV>Swift PMJSON 1.2</DIV></TH>

75119 <TH class="vertical"><DIV>Swift STJSON</DIV></TH>

76120 <TH></TH>

77121 </TR>

78122 <TR>

83− <TD>n_array_unclosed_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,</TD> </TR> <TR>

84− <TD>n_string_start_escape_unclosed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\</TD> </TR> <TR>

85− <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

86− <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

87− <TD>i_structure_500_nested_arrays.json</TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

88− <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

89− <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

90− <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

91− <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

92− <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

93− <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

94− <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>100 <=> 1</TD> </TR> <TR>

95− <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\x00"]</TD> </TR> <TR>

96− <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

97− <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.3e+]</TD> </TR> <TR>

98− <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

99− <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

100− <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[9.e+]</TD> </TR> <TR>

101− <TD>n_structure_null-byte-outside-string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[00] <=> []</TD> </TR> <TR>

102− <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

103− <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

104− <TD>n_string_invalid_utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

105− <TD>n_string_unescaped_tab.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

106− <TD>n_string_unescaped_newline.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["new0Aline"] <=> ["new

128+ <TD>n_array_unclosed_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,</TD> </TR> <TR>

129+ <TD>n_string_start_escape_unclosed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\</TD> </TR> <TR>

130+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

131+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

132+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

133+ <TD>i_string_UTF-16LE_with_BOM.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>FFFE[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

134+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

135+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

136+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="CRASH"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

137+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

138+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

139+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-2.]</TD> </TR> <TR>

140+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>100 <=> 1</TD> </TR> <TR>

141+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\x00"]</TD> </TR> <TR>

142+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

143+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.3e+]</TD> </TR> <TR>

144+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

145+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

146+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[9.e+]</TD> </TR> <TR>

147+ <TD>n_structure_null-byte-outside-string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[00] <=> []</TD> </TR> <TR>

148+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

149+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

150+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

151+ <TD>n_string_invalid_utf-8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

152+ <TD>n_string_unescaped_tab.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

153+ <TD>n_string_unescaped_newline.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["new0Aline"] <=> ["new

107154line"]</TD> </TR> <TR>

108− <TD>n_array_just_minus.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-]</TD> </TR> <TR>

109− <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

110− <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

111− <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

112− <TD>n_array_extra_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["",]</TD> </TR> <TR>

113− <TD>n_object_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"id":0,}</TD> </TR> <TR>

114− <TD>n_string_single_doublequote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>"</TD> </TR> <TR>

115− <TD>n_number_neg_real_without_int_part.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-.123]</TD> </TR> <TR>

116− <TD>n_object_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

117− <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

118− <TD>n_object_trailing_comment.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

119− <TD>n_array_comma_after_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[""],</TD> </TR> <TR>

120− <TD>n_number_-01.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-01]</TD> </TR> <TR>

121− <TD>n_string_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>""x</TD> </TR> <TR>

122− <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>2@</TD> </TR> <TR>

123− <TD>n_structure_trailing_#.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

124− <TD>n_array_extra_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["x"]]</TD> </TR> <TR>

125− <TD>n_structure_close_unopened_array.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>1]</TD> </TR> <TR>

126− <TD>n_array_spaces_vertical_tab_formfeed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["0Ba"\f] <=> ["a"\f]</TD> </TR> <TR>

127− <TD>n_array_star_inside.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[*]</TD> </TR> <TR>

128− <TD>n_object_single_quote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{'a':0}</TD> </TR> <TR>

129− <TD>n_array_comma_and_number.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[,1]</TD> </TR> <TR>

130− <TD>n_object_double_colon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x"::"b"}</TD> </TR> <TR>

131− <TD>n_array_colon_instead_of_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["": 1]</TD> </TR> <TR>

132− <TD>n_number_.2e-3.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[.2e-3]</TD> </TR> <TR>

133− <TD>n_array_1_true_without_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1 true]</TD> </TR> <TR>

134− <TD>n_structure_object_with_comment.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

135− <TD>n_number_NaN.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[NaN]</TD> </TR> <TR>

136− <TD>n_structure_capitalized_True.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[True]</TD> </TR> <TR>

137− <TD>n_array_a_invalid_utf8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[aE5] <=> [a]</TD> </TR> <TR>

138− <TD>n_number_U+FF11_fullwidth_digit_one.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[EFBC91] <=> [１]</TD> </TR> <TR>

139− <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-2.]</TD> </TR> <TR>

140− <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

141− <TD>n_array_inner_array_no_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[3[4]]</TD> </TR> <TR>

142− <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

143− <TD>n_string_invalid_unicode_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

144− <TD>n_array_unclosed_with_new_lines.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,0A10A,1 <=> [1,

155+ <TD>n_array_just_minus.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-]</TD> </TR> <TR>

156+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

157+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

158+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

159+ <TD>n_array_extra_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["",]</TD> </TR> <TR>

160+ <TD>n_object_trailing_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"id":0,}</TD> </TR> <TR>

161+ <TD>n_string_single_doublequote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>"</TD> </TR> <TR>

162+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-.123]</TD> </TR> <TR>

163+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

164+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

165+ <TD>n_object_trailing_comment.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

166+ <TD>n_array_comma_after_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[""],</TD> </TR> <TR>

167+ <TD>n_number_-01.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-01]</TD> </TR> <TR>

168+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>""x</TD> </TR> <TR>

169+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>2@</TD> </TR> <TR>

170+ <TD>n_structure_trailing_#.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

171+ <TD>n_array_extra_close.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["x"]]</TD> </TR> <TR>

172+ <TD>n_structure_close_unopened_array.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>1]</TD> </TR> <TR>

173+ <TD>n_array_spaces_vertical_tab_formfeed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["0Ba"\f] <=> ["a"\f]</TD> </TR> <TR>

174+ <TD>n_array_star_inside.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[*]</TD> </TR> <TR>

175+ <TD>n_object_single_quote.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{'a':0}</TD> </TR> <TR>

176+ <TD>n_array_comma_and_number.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[,1]</TD> </TR> <TR>

177+ <TD>n_object_double_colon.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x"::"b"}</TD> </TR> <TR>

178+ <TD>n_array_colon_instead_of_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["": 1]</TD> </TR> <TR>

179+ <TD>n_number_.2e-3.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[.2e-3]</TD> </TR> <TR>

180+ <TD>n_array_1_true_without_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1 true]</TD> </TR> <TR>

181+ <TD>n_structure_object_with_comment.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

182+ <TD>n_number_NaN.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[NaN]</TD> </TR> <TR>

183+ <TD>n_structure_capitalized_True.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[True]</TD> </TR> <TR>

184+ <TD>n_array_a_invalid_utf8.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[aE5] <=> [a]</TD> </TR> <TR>

185+ <TD>n_number_U+FF11_fullwidth_digit_one.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[EFBC91] <=> [１]</TD> </TR> <TR>

186+ <TD>n_array_inner_array_no_comma.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[3[4]]</TD> </TR> <TR>

187+ <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

188+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

189+ <TD>n_array_unclosed_with_new_lines.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[1,0A10A,1 <=> [1,

1451901

146191,1</TD> </TR> <TR>

147− <TD>n_array_newlines_unclosed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a",0A40A,1, <=> ["a",

192+ <TD>n_array_newlines_unclosed.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["a",0A40A,1, <=> ["a",

1481934

149194,1,</TD> </TR> <TR>

150− <TD>y_string_unescaped_char_delete.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["7F"] <=> [""]</TD> </TR> <TR>

151− <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>FFFE[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

152− <TD>y_string_nonCharacterInUTF-8_U+1FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["F09BBFBF"] <=> ["𛿿"]</TD> </TR> <TR>

153− <TD>y_structure_lonely_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>42</TD> </TR> <TR>

154− <TD>y_structure_string_empty.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>""</TD> </TR> <TR>

155− <TD>y_structure_lonely_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>null</TD> </TR> <TR>

156− <TD>y_string_space.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>" "</TD> </TR> <TR>

157− <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

158− <TD>y_number_0e1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e1]</TD> </TR> <TR>

159− <TD>y_number_0e+1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e+1]</TD> </TR> <TR>

160− <TD>y_object_escaped_null_in_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

161− <TD>y_number_huge_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

162− <TD>y_number_real_pos_overflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123123e100000]</TD> </TR> <TR>

163− <TD>y_number_real_neg_overflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

164− <TD>y_number_too_big_neg_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

165− <TD>y_object_long_strings.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x":[{"id": "xxxxxxxxxxxxxxxxxxxxxx(...)</TD> </TR> <TR>

166− <TD>y_object_string_unicode.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"title":"\u041f\u043e\u043b\u0442\u(...)</TD> </TR> <TR>

167− <TD>y_number_double_huge_neg_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

168− <TD>y_number_real_underflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123e-10000000]</TD> </TR> <TR>

169− <TD>y_string_escaped_noncharacter.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uFFFF"]</TD> </TR> <TR>

170− <TD>y_array_with_1_and_newline.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[10A] <=> [1

195+ <TD>y_string_unescaped_char_delete.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["7F"] <=> [""]</TD> </TR> <TR>

196+ <TD>y_string_nonCharacterInUTF-8_U+1FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["F09BBFBF"] <=> ["𛿿"]</TD> </TR> <TR>

197+ <TD>y_structure_lonely_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>42</TD> </TR> <TR>

198+ <TD>y_structure_string_empty.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>""</TD> </TR> <TR>

199+ <TD>y_structure_lonely_null.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>null</TD> </TR> <TR>

200+ <TD>y_string_space.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>" "</TD> </TR> <TR>

201+ <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

202+ <TD>y_number_0e1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e1]</TD> </TR> <TR>

203+ <TD>y_number_0e+1.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0e+1]</TD> </TR> <TR>

204+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

205+ <TD>y_number_huge_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="CRASH"></TD> <TD class="CRASH"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

206+ <TD>y_number_real_pos_overflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123123e100000]</TD> </TR> <TR>

207+ <TD>y_number_real_neg_overflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

208+ <TD>y_number_too_big_neg_int.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

209+ <TD>y_object_long_strings.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"x":[{"id": "xxxxxxxxxxxxxxxxxxxxxx(...)</TD> </TR> <TR>

210+ <TD>y_object_string_unicode.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>{"title":"\u041f\u043e\u043b\u0442\u(...)</TD> </TR> <TR>

211+ <TD>y_number_double_huge_neg_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

212+ <TD>y_number_real_underflow.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[123e-10000000]</TD> </TR> <TR>

213+ <TD>y_string_escaped_noncharacter.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\uFFFF"]</TD> </TR> <TR>

214+ <TD>y_array_with_1_and_newline.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[10A] <=> [1

171215]</TD> </TR> <TR>

172− <TD>y_string_1_2_3_bytes_UTF-8_sequences.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0060\u012a\u12AB"]</TD> </TR> <TR>

173− <TD>y_number_neg_int_huge_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-1e+9999]</TD> </TR></TABLE>

216+ <TD>y_string_1_2_3_bytes_UTF-8_sequences.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>["\u0060\u012a\u12AB"]</TD> </TR> <TR>

217+ <TD>y_number_neg_int_huge_exp.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>[-1e+9999]</TD> </TR> <TR>

218+ <TD>y_string_utf16BE_no_BOM.json</TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="EXPECTED_RESULT"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD class="EXPECTED_RESULT"></TD> <TD>00[00"00E900"00] <=> [""]</TD> </TR></TABLE>

174219<A NAME="results_by_parser"></A>

175220<H4>3. Results by Parser</H4>

176−<A NAME="0"></A><H4>Java nanojson 1.0</H4>

221+<A NAME="0"></A><H4><A HREF="https://github.com/dominictarr/JSON.sh">Bash JSON.sh 2016-08-12</A></H4>

177222<TABLE>

178223 <TR>

179224 <TH></TH>

@@ -181,11 +226,13 @@ line"]</TD> </TR> <TR>

181226 <TH></TH>

182227 </TR>

183228 <TR>

229+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

230+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

184231 <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

185232 <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

186233 <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

187− <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\ud800"]</TD> </TR> <TR>

188− <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\ud800abc"]</TD> </TR> <TR>

234+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

235+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

189236 <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

190237 <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

191238 <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

@@ -198,15 +245,2155 @@ line"]</TD> </TR> <TR>

198245 <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

199246 <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

200247 <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

248+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

249+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

250+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

251+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

252+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

253+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

254+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

255+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

256+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

257+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

258+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

259+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

260+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

261+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

262+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

263+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

264+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

265+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

266+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

267+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

268+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

269+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

270+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

271+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

272+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

273+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

274+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

275+ <TD>n_structure_null-byte-outside-string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[00] <=> []</TD> </TR> <TR>

276+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

277+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

278+ <TD>y_string_unescaped_char_delete.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["7F"] <=> [""]</TD> </TR> <TR>

279+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

280+ <TD>y_string_with_del_character.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["a7Fa"] <=> ["aa"]</TD> </TR></TABLE>

281+

282+

283+<A NAME="1"></A><H4><A HREF="http://www.json.org/JSON_checker/">C JSON Checker</A></H4>

284+<TABLE>

285+ <TR>

286+ <TH></TH>

287+ <TH class="space"><DIV></DIV></TH>

288+ <TH></TH>

289+ </TR>

290+ <TR>

291+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

292+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

293+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

294+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

295+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

296+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

297+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

298+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

299+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

300+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

301+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

302+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

303+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

304+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

305+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

306+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

307+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

308+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

309+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

310+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

311+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

312+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

313+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

314+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

315+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

316+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

317+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

318+ <TD>y_number_0e+1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e+1]</TD> </TR> <TR>

319+ <TD>y_number_0e1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e1]</TD> </TR> <TR>

320+ <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

321+ <TD>y_string_nonCharacterInUTF-8_U+1FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F09BBFBF"] <=> ["𛿿"]</TD> </TR> <TR>

322+ <TD>y_string_nonCharacterInUTF-8_U+FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["EFBFBF"] <=> [""]</TD> </TR> <TR>

323+ <TD>y_string_pi.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["CF80"] <=> ["π"]</TD> </TR> <TR>

324+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

325+ <TD>y_string_u+2028_line_sep.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E280A8"] <=> [" "]</TD> </TR> <TR>

326+ <TD>y_string_u+2029_par_sep.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E280A9"] <=> [" "]</TD> </TR> <TR>

327+ <TD>y_string_unicode_2.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E28D82E388B4E28D82"] <=> ["⍂㈴⍂"]</TD> </TR> <TR>

328+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

329+ <TD>y_string_utf8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E282ACF09D849E"] <=> ["€𝄞"]</TD> </TR> <TR>

330+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

331+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

332+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

333+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

334+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

335+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

336+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

337+

338+

339+<A NAME="2"></A><H4>C JSON Checker 2</H4>

340+<TABLE>

341+ <TR>

342+ <TH></TH>

343+ <TH class="space"><DIV></DIV></TH>

344+ <TH></TH>

345+ </TR>

346+ <TR>

347+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

348+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

349+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

350+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

351+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

352+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

353+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

354+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

355+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

356+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

357+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

358+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

359+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

360+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

361+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

362+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

363+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

364+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

365+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

366+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

367+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

368+ <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

369+ <TD>y_string_nonCharacterInUTF-8_U+1FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F09BBFBF"] <=> ["𛿿"]</TD> </TR> <TR>

370+ <TD>y_string_nonCharacterInUTF-8_U+FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["EFBFBF"] <=> [""]</TD> </TR> <TR>

371+ <TD>y_string_pi.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["CF80"] <=> ["π"]</TD> </TR> <TR>

372+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

373+ <TD>y_string_u+2028_line_sep.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E280A8"] <=> [" "]</TD> </TR> <TR>

374+ <TD>y_string_u+2029_par_sep.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E280A9"] <=> [" "]</TD> </TR> <TR>

375+ <TD>y_string_unicode_2.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E28D82E388B4E28D82"] <=> ["⍂㈴⍂"]</TD> </TR> <TR>

376+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

377+ <TD>y_string_utf8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["E282ACF09D849E"] <=> ["€𝄞"]</TD> </TR> <TR>

378+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

379+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

380+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

381+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

382+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

383+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

384+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

385+

386+

387+<A NAME="3"></A><H4><A HREF="https://github.com/udp/json-parser">C JSON Parser by udp</A></H4>

388+<TABLE>

389+ <TR>

390+ <TH></TH>

391+ <TH class="space"><DIV></DIV></TH>

392+ <TH></TH>

393+ </TR>

394+ <TR>

395+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

396+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

397+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

398+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

399+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

400+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

401+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

402+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

403+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

404+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

405+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

406+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

407+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

408+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

409+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

410+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

411+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

412+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

413+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

414+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

415+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

416+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

417+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

418+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

419+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

420+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

421+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

422+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

423+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

424+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

425+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

426+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

427+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

428+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

429+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

430+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

431+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

432+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

433+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

434+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

435+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

436+line"]</TD> </TR> <TR>

437+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

438+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

439+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

440+

441+

442+<A NAME="4"></A><H4><A HREF="https://github.com/DaveGamble/cJSON">C cJSON</A></H4>

443+<TABLE>

444+ <TR>

445+ <TH></TH>

446+ <TH class="space"><DIV></DIV></TH>

447+ <TH></TH>

448+ </TR>

449+ <TR>

450+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

451+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

452+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

453+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

454+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

455+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

456+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

457+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

458+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

459+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

460+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

461+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

462+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

463+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

464+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

465+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

466+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

467+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

468+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

469+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

470+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

471+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

472+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

473+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

474+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

475+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

476+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

477+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

478+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

479+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

480+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

481+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

482+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

483+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

484+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

485+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

486+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

487+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

488+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

489+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

490+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

491+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

492+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

493+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

494+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

495+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

496+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

497+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

498+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

499+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

500+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

501+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

502+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

503+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

504+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

505+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

506+ <TD>n_string_single_doublequote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"</TD> </TR> <TR>

507+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

508+line"]</TD> </TR> <TR>

509+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

510+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

511+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

512+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

513+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

514+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

515+ <TD>n_structure_close_unopened_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>1]</TD> </TR> <TR>

516+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

517+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

518+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

519+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

520+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

521+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

522+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

523+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

524+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

525+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

526+

527+

528+<A NAME="5"></A><H4>C ccan</H4>

529+<TABLE>

530+ <TR>

531+ <TH></TH>

532+ <TH class="space"><DIV></DIV></TH>

533+ <TH></TH>

534+ </TR>

535+ <TR>

536+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

537+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

538+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

539+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

540+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

541+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

542+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

543+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

544+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

545+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

546+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

547+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

548+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

549+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

550+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

551+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

552+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

553+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

554+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

555+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

556+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

557+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

558+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

559+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

560+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

561+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

562+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

563+

564+

565+<A NAME="6"></A><H4>C jansson</H4>

566+<TABLE>

567+ <TR>

568+ <TH></TH>

569+ <TH class="space"><DIV></DIV></TH>

570+ <TH></TH>

571+ </TR>

572+ <TR>

573+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

574+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

575+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

576+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

577+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

578+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

579+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

580+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

581+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

582+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

583+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

584+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

585+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

586+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

587+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

588+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

589+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

590+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

591+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

592+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

593+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

594+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

595+ <TD>y_number_real_neg_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

596+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

597+ <TD>y_number_too_big_neg_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

598+ <TD>y_number_too_big_pos_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

599+ <TD>y_number_very_big_negative_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

600+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

601+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

602+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

603+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

604+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

605+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

606+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

607+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

608+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

609+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

610+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

611+

612+

613+<A NAME="7"></A><H4><A HREF="https://github.com/zserge/jsmn">C jsmn</A></H4>

614+<TABLE>

615+ <TR>

616+ <TH></TH>

617+ <TH class="space"><DIV></DIV></TH>

618+ <TH></TH>

619+ </TR>

620+ <TR>

621+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

622+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

623+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

624+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

625+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

626+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

627+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

628+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

629+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

630+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

631+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

632+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

633+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

634+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

635+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

636+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

637+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

638+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

639+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

640+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

641+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

642+ <TD>n_array_1_true_without_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 true]</TD> </TR> <TR>

643+ <TD>n_array_colon_instead_of_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["": 1]</TD> </TR> <TR>

644+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

645+ <TD>n_array_comma_and_number.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,1]</TD> </TR> <TR>

646+ <TD>n_array_double_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,2]</TD> </TR> <TR>

647+ <TD>n_array_double_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x",,]</TD> </TR> <TR>

648+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

649+ <TD>n_array_items_separated_by_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1:2]</TD> </TR> <TR>

650+ <TD>n_array_just_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,]</TD> </TR> <TR>

651+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

652+ <TD>n_array_missing_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[ , ""]</TD> </TR> <TR>

653+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

654+ <TD>n_array_number_and_several_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,]</TD> </TR> <TR>

655+ <TD>n_array_spaces_vertical_tab_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["0Ba"\f] <=> ["a"\f]</TD> </TR> <TR>

656+ <TD>n_array_star_inside.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[*]</TD> </TR> <TR>

657+ <TD>n_incomplete_false.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[fals]</TD> </TR> <TR>

658+ <TD>n_incomplete_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[nul]</TD> </TR> <TR>

659+ <TD>n_incomplete_true.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[tru]</TD> </TR> <TR>

660+ <TD>n_number_++.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[++1234]</TD> </TR> <TR>

661+ <TD>n_number_+1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[+1]</TD> </TR> <TR>

662+ <TD>n_number_+Inf.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[+Inf]</TD> </TR> <TR>

663+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

664+ <TD>n_number_-1.0..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-1.0.]</TD> </TR> <TR>

665+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

666+ <TD>n_number_-NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-NaN]</TD> </TR> <TR>

667+ <TD>n_number_.-1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.-1]</TD> </TR> <TR>

668+ <TD>n_number_.2e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.2e-3]</TD> </TR> <TR>

669+ <TD>n_number_0.1.2.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.1.2]</TD> </TR> <TR>

670+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

671+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

672+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

673+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

674+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

675+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

676+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

677+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

678+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

679+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

680+ <TD>n_number_1_000.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 000.0]</TD> </TR> <TR>

681+ <TD>n_number_1eE2.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1eE2]</TD> </TR> <TR>

682+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

683+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

684+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

685+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

686+ <TD>n_number_Inf.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Inf]</TD> </TR> <TR>

687+ <TD>n_number_NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[NaN]</TD> </TR> <TR>

688+ <TD>n_number_expression.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1+2]</TD> </TR> <TR>

689+ <TD>n_number_hex_1_digit.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0x1]</TD> </TR> <TR>

690+ <TD>n_number_hex_2_digits.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0x42]</TD> </TR> <TR>

691+ <TD>n_number_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Infinity]</TD> </TR> <TR>

692+ <TD>n_number_invalid+-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+-1]</TD> </TR> <TR>

693+ <TD>n_number_invalid-negative-real.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-123.123foo]</TD> </TR> <TR>

694+ <TD>n_number_minus_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-Infinity]</TD> </TR> <TR>

695+ <TD>n_number_minus_sign_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-foo]</TD> </TR> <TR>

696+ <TD>n_number_minus_space_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[- 1]</TD> </TR> <TR>

697+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

698+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

699+ <TD>n_number_neg_with_garbage_at_end.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-1x]</TD> </TR> <TR>

700+ <TD>n_number_real_garbage_after_e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1ea]</TD> </TR> <TR>

701+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

702+ <TD>n_number_starting_with_dot.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.123]</TD> </TR> <TR>

703+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

704+ <TD>n_number_with_alpha.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.2a-3]</TD> </TR> <TR>

705+ <TD>n_number_with_alpha_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.8011670033376514H-308]</TD> </TR> <TR>

706+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

707+ <TD>n_object_bad_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x", truth]</TD> </TR> <TR>

708+ <TD>n_object_comma_instead_of_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"x", null}</TD> </TR> <TR>

709+ <TD>n_object_double_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"x"::"b"}</TD> </TR> <TR>

710+ <TD>n_object_garbage_at_end.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"a" 123}</TD> </TR> <TR>

711+ <TD>n_object_key_with_single_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{key: 'value'}</TD> </TR> <TR>

712+ <TD>n_object_missing_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a" b}</TD> </TR> <TR>

713+ <TD>n_object_missing_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{:"b"}</TD> </TR> <TR>

714+ <TD>n_object_missing_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a" "b"}</TD> </TR> <TR>

715+ <TD>n_object_non_string_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{1:1}</TD> </TR> <TR>

716+ <TD>n_object_non_string_key_but_huge_number_instead.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{9999E9999:1}</TD> </TR> <TR>

717+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

718+ <TD>n_object_repeated_null_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{null:null,null:null}</TD> </TR> <TR>

719+ <TD>n_object_several_trailing_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,,,,,}</TD> </TR> <TR>

720+ <TD>n_object_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{'a':0}</TD> </TR> <TR>

721+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

722+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

723+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

724+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

725+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

726+ <TD>n_object_two_commas_in_a_row.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b",,"c":"d"}</TD> </TR> <TR>

727+ <TD>n_object_unquoted_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{a: "b"}</TD> </TR> <TR>

728+ <TD>n_object_with_single_string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{ "foo" : "bar", "a" }</TD> </TR> <TR>

729+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

730+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

731+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

732+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

733+ <TD>n_string_leading_uescaped_thinspace.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[\u0020"asd"]</TD> </TR> <TR>

734+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

735+ <TD>n_string_no_quotes_with_bad_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[\n]</TD> </TR> <TR>

736+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

737+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

738+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

739+ <TD>n_string_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>['single quote']</TD> </TR> <TR>

740+ <TD>n_string_single_string_no_double_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>abc</TD> </TR> <TR>

741+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

742+line"]</TD> </TR> <TR>

743+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

744+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

745+ <TD>n_structure_<.>.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD><.></TD> </TR> <TR>

746+ <TD>n_structure_<null>.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[<null>]</TD> </TR> <TR>

747+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

748+ <TD>n_structure_capitalized_True.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[True]</TD> </TR> <TR>

749+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

750+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

751+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

752+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

753+ <TD>n_structure_single_star.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>*</TD> </TR> <TR>

754+ <TD>n_structure_uescaped_LF_before_string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[\u000A""]</TD> </TR> <TR>

755+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

756+ <TD>y_object_long_strings.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"x":[{"id": "xxxxxxxxxxxxxxxxxxxxxx(...)</TD> </TR> <TR>

757+ <TD>y_object_string_unicode.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"title":"\u041f\u043e\u043b\u0442\u(...)</TD> </TR> <TR>

758+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

759+

760+

761+<A NAME="8"></A><H4><A HREF="https://github.com/crystal-lang/crystal">Crystal</A></H4>

762+

763+<A NAME="9"></A><H4>Go 1.7.1</H4>

764+<TABLE>

765+ <TR>

766+ <TH></TH>

767+ <TH class="space"><DIV></DIV></TH>

768+ <TH></TH>

769+ </TR>

770+ <TR>

771+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

772+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

773+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

774+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

775+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

776+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

777+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

778+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

779+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

780+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

781+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

782+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

783+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

784+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

785+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

786+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

787+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

788+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

789+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

790+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

791+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

792+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

793+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

794+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

795+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

796+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

797+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

798+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

799+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

800+ <TD>y_number_real_neg_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

801+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

802+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

803+

804+

805+<A NAME="10"></A><H4><A HREF="https://github.com/bos/aeson">Haskell Aeson 0.11.2.1</A></H4>

806+

807+<A NAME="11"></A><H4>Java Jackson 2.8.4</H4>

808+<TABLE>

809+ <TR>

810+ <TH></TH>

811+ <TH class="space"><DIV></DIV></TH>

812+ <TH></TH>

813+ </TR>

814+ <TR>

815+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

816+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

817+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

818+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

819+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

820+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

821+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

822+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

823+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

824+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

825+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

826+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

827+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

828+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

829+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

830+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

831+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

832+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

833+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

834+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

835+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

836+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

837+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

838+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

839+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

840+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

841+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

842+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

843+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

844+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

845+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

846+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

847+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

848+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

849+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

850+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

851+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

852+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

853+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

854+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

855+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

856+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

857+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

858+

859+

860+<A NAME="12"></A><H4>Java com.leastfixedpoint.json 1.0</H4>

861+<TABLE>

862+ <TR>

863+ <TH></TH>

864+ <TH class="space"><DIV></DIV></TH>

865+ <TH></TH>

866+ </TR>

867+ <TR>

868+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

869+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

870+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

871+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

872+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

873+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

874+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

875+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

876+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

877+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

878+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

879+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

880+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

881+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

882+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

883+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

884+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

885+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

886+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

887+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

888+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

889+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

890+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

891+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

892+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

893+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

894+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

895+ <TD>n_number_U+FF11_fullwidth_digit_one.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[EFBC91] <=> [１]</TD> </TR> <TR>

896+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

897+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

898+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

899+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

900+ <TD>n_object_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{'a':0}</TD> </TR> <TR>

901+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

902+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

903+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

904+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

905+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

906+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

907+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

908+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

909+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

910+ <TD>n_string_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>['single quote']</TD> </TR> <TR>

911+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

912+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

913+line"]</TD> </TR> <TR>

914+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

915+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

916+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

917+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

918+

919+

920+<A NAME="13"></A><H4>Java gson 2.7</H4>

921+<TABLE>

922+ <TR>

923+ <TH></TH>

924+ <TH class="space"><DIV></DIV></TH>

925+ <TH></TH>

926+ </TR>

927+ <TR>

928+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

929+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

930+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

931+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

932+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

933+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

934+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

935+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

936+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

937+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

938+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

939+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

940+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

941+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

942+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

943+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

944+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

945+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

946+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

947+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

948+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

949+ <TD>n_array_a_invalid_utf8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[aE5] <=> [a]</TD> </TR> <TR>

950+ <TD>n_array_comma_and_number.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,1]</TD> </TR> <TR>

951+ <TD>n_array_double_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,2]</TD> </TR> <TR>

952+ <TD>n_array_double_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x",,]</TD> </TR> <TR>

953+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

954+ <TD>n_array_invalid_utf8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[FF] <=> []</TD> </TR> <TR>

955+ <TD>n_array_just_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,]</TD> </TR> <TR>

956+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

957+ <TD>n_array_missing_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[ , ""]</TD> </TR> <TR>

958+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

959+ <TD>n_array_number_and_several_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,]</TD> </TR> <TR>

960+ <TD>n_array_star_inside.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[*]</TD> </TR> <TR>

961+ <TD>n_incomplete_false.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[fals]</TD> </TR> <TR>

962+ <TD>n_incomplete_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[nul]</TD> </TR> <TR>

963+ <TD>n_incomplete_true.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[tru]</TD> </TR> <TR>

964+ <TD>n_number_++.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[++1234]</TD> </TR> <TR>

965+ <TD>n_number_+1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[+1]</TD> </TR> <TR>

966+ <TD>n_number_+Inf.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[+Inf]</TD> </TR> <TR>

967+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

968+ <TD>n_number_-1.0..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-1.0.]</TD> </TR> <TR>

969+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

970+ <TD>n_number_-NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-NaN]</TD> </TR> <TR>

971+ <TD>n_number_.-1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.-1]</TD> </TR> <TR>

972+ <TD>n_number_.2e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.2e-3]</TD> </TR> <TR>

973+ <TD>n_number_0.1.2.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.1.2]</TD> </TR> <TR>

974+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

975+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

976+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

977+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

978+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

979+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

980+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

981+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

982+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

983+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

984+ <TD>n_number_1eE2.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1eE2]</TD> </TR> <TR>

985+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

986+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

987+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

988+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

989+ <TD>n_number_Inf.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Inf]</TD> </TR> <TR>

990+ <TD>n_number_NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[NaN]</TD> </TR> <TR>

991+ <TD>n_number_U+FF11_fullwidth_digit_one.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[EFBC91] <=> [１]</TD> </TR> <TR>

992+ <TD>n_number_expression.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1+2]</TD> </TR> <TR>

993+ <TD>n_number_hex_1_digit.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0x1]</TD> </TR> <TR>

994+ <TD>n_number_hex_2_digits.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0x42]</TD> </TR> <TR>

995+ <TD>n_number_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Infinity]</TD> </TR> <TR>

996+ <TD>n_number_invalid+-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+-1]</TD> </TR> <TR>

997+ <TD>n_number_invalid-negative-real.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-123.123foo]</TD> </TR> <TR>

998+ <TD>n_number_invalid-utf-8-in-bigger-int.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[123E5] <=> [123]</TD> </TR> <TR>

999+ <TD>n_number_invalid-utf-8-in-exponent.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1e1E5] <=> [1e1]</TD> </TR> <TR>

1000+ <TD>n_number_invalid-utf-8-in-int.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E5]0A <=> [0]

1001+</TD> </TR> <TR>

1002+ <TD>n_number_minus_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-Infinity]</TD> </TR> <TR>

1003+ <TD>n_number_minus_sign_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-foo]</TD> </TR> <TR>

1004+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

1005+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

1006+ <TD>n_number_neg_with_garbage_at_end.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-1x]</TD> </TR> <TR>

1007+ <TD>n_number_real_garbage_after_e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1ea]</TD> </TR> <TR>

1008+ <TD>n_number_real_with_invalid_utf8_after_e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1eE5] <=> [1e]</TD> </TR> <TR>

1009+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1010+ <TD>n_number_starting_with_dot.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.123]</TD> </TR> <TR>

1011+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

1012+ <TD>n_number_with_alpha.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.2a-3]</TD> </TR> <TR>

1013+ <TD>n_number_with_alpha_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.8011670033376514H-308]</TD> </TR> <TR>

1014+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

1015+ <TD>n_object_bad_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x", truth]</TD> </TR> <TR>

1016+ <TD>n_object_key_with_single_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{key: 'value'}</TD> </TR> <TR>

1017+ <TD>n_object_non_string_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{1:1}</TD> </TR> <TR>

1018+ <TD>n_object_non_string_key_but_huge_number_instead.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{9999E9999:1}</TD> </TR> <TR>

1019+ <TD>n_object_repeated_null_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{null:null,null:null}</TD> </TR> <TR>

1020+ <TD>n_object_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{'a':0}</TD> </TR> <TR>

1021+ <TD>n_object_unquoted_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{a: "b"}</TD> </TR> <TR>

1022+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1023+ <TD>n_string_accentuated_char_no_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[C3A9] <=> [é]</TD> </TR> <TR>

1024+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1025+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1026+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1027+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1028+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1029+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1030+ <TD>n_string_single_quote.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>['single quote']</TD> </TR> <TR>

1031+ <TD>n_string_single_string_no_double_quotes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>abc</TD> </TR> <TR>

1032+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1033+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1034+line"]</TD> </TR> <TR>

1035+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1036+ <TD>n_structure_<.>.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD><.></TD> </TR> <TR>

1037+ <TD>n_structure_<null>.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[<null>]</TD> </TR> <TR>

1038+ <TD>n_structure_U+2060_word_joined.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[E281A0] <=> [⁠]</TD> </TR> <TR>

1039+ <TD>n_structure_ascii-unicode-identifier.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>aC3A5 <=> aå</TD> </TR> <TR>

1040+ <TD>n_structure_capitalized_True.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[True]</TD> </TR> <TR>

1041+ <TD>n_structure_lone-invalid-utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>E5 <=> </TD> </TR> <TR>

1042+ <TD>n_structure_null-byte-outside-string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[00] <=> []</TD> </TR> <TR>

1043+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

1044+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

1045+ <TD>n_structure_single_point.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>E9 <=> </TD> </TR> <TR>

1046+ <TD>n_structure_single_star.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>*</TD> </TR> <TR>

1047+ <TD>n_structure_unicode-identifier.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>C3A5 <=> å</TD> </TR> <TR>

1048+ <TD>n_structure_whitespace_U+2060_word_joiner.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[E281A0] <=> [⁠]</TD> </TR> <TR>

1049+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1050+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

1051+

1052+

1053+<A NAME="14"></A><H4>Java json-simple 1.1.1</H4>

1054+<TABLE>

1055+ <TR>

1056+ <TH></TH>

1057+ <TH class="space"><DIV></DIV></TH>

1058+ <TH></TH>

1059+ </TR>

1060+ <TR>

1061+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1062+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1063+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1064+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1065+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1066+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1067+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1068+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1069+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1070+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1071+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1072+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1073+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1074+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1075+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1076+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1077+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1078+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1079+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1080+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1081+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1082+ <TD>n_array_1_true_without_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 true]</TD> </TR> <TR>

1083+ <TD>n_array_comma_and_number.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,1]</TD> </TR> <TR>

1084+ <TD>n_array_double_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,2]</TD> </TR> <TR>

1085+ <TD>n_array_double_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x",,]</TD> </TR> <TR>

1086+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1087+ <TD>n_array_inner_array_no_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[3[4]]</TD> </TR> <TR>

1088+ <TD>n_array_just_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[,]</TD> </TR> <TR>

1089+ <TD>n_array_missing_value.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[ , ""]</TD> </TR> <TR>

1090+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1091+ <TD>n_array_number_and_several_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,,]</TD> </TR> <TR>

1092+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

1093+ <TD>n_number_1_000.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 000.0]</TD> </TR> <TR>

1094+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

1095+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

1096+ <TD>n_object_double_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"x"::"b"}</TD> </TR> <TR>

1097+ <TD>n_object_missing_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a" "b"}</TD> </TR> <TR>

1098+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

1099+ <TD>n_object_several_trailing_commas.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,,,,,}</TD> </TR> <TR>

1100+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1101+ <TD>n_object_two_commas_in_a_row.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b",,"c":"d"}</TD> </TR> <TR>

1102+ <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

1103+ <TD>n_string_1_surrogate_then_escape u1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1"]</TD> </TR> <TR>

1104+ <TD>n_string_1_surrogate_then_escape u1x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1x"]</TD> </TR> <TR>

1105+ <TD>n_string_UTF-16_incomplete_surrogate.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1106+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1107+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

1108+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

1109+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

1110+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

1111+ <TD>n_string_incomplete_escaped_character.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\u00A"]</TD> </TR> <TR>

1112+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

1113+ <TD>n_string_invalid-utf-8-in-escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uE5"] <=> ["\u"]</TD> </TR> <TR>

1114+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

1115+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

1116+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1117+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

1118+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1119+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1120+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1121+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1122+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1123+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1124+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1125+line"]</TD> </TR> <TR>

1126+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1127+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

1128+ <TD>y_number_too_big_neg_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

1129+ <TD>y_number_too_big_pos_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

1130+ <TD>y_number_very_big_negative_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

1131+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1132+

1133+

1134+<A NAME="15"></A><H4>Java nanojson 1.0</H4>

1135+<TABLE>

1136+ <TR>

1137+ <TH></TH>

1138+ <TH class="space"><DIV></DIV></TH>

1139+ <TH></TH>

1140+ </TR>

1141+ <TR>

1142+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1143+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1144+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1145+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1146+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1147+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1148+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1149+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1150+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1151+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1152+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1153+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1154+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1155+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1156+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1157+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1158+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1159+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1160+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1161+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1162+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1163+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1164+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1165+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1166+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1167+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR></TABLE>

1168+

1169+

1170+<A NAME="16"></A><H4>JavaScript</H4>

1171+<TABLE>

1172+ <TR>

1173+ <TH></TH>

1174+ <TH class="space"><DIV></DIV></TH>

1175+ <TH></TH>

1176+ </TR>

1177+ <TR>

1178+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1179+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1180+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1181+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1182+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1183+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1184+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1185+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1186+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1187+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1188+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1189+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1190+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1191+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1192+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1193+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1194+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1195+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1196+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1197+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1198+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1199+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1200+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1201+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1202+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1203+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1204+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1205+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1206+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1207+

1208+

1209+<A NAME="17"></A><H4><A HREF="http://www.newtonsoft.com/json">Json.NET 9.0.1</A></H4>

1210+

1211+<A NAME="18"></A><H4><A HREF="http://regex.info/blog/lua/json">Lua JSON 20160916.19</A></H4>

1212+<TABLE>

1213+ <TR>

1214+ <TH></TH>

1215+ <TH class="space"><DIV></DIV></TH>

1216+ <TH></TH>

1217+ </TR>

1218+ <TR>

1219+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1220+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1221+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1222+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1223+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1224+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1225+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1226+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1227+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1228+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1229+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1230+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1231+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1232+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1233+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1234+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1235+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1236+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1237+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1238+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1239+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1240+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

1241+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

1242+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1243+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

1244+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1245+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

1246+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

1247+ <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

1248+ <TD>n_string_1_surrogate_then_escape u1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1"]</TD> </TR> <TR>

1249+ <TD>n_string_1_surrogate_then_escape u1x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1x"]</TD> </TR> <TR>

1250+ <TD>n_string_UTF-16_incomplete_surrogate.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1251+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1252+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

1253+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

1254+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

1255+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

1256+ <TD>n_string_incomplete_escaped_character.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\u00A"]</TD> </TR> <TR>

1257+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

1258+ <TD>n_string_invalid-utf-8-in-escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uE5"] <=> ["\u"]</TD> </TR> <TR>

1259+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

1260+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

1261+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1262+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

1263+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1264+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1265+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1266+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1267+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1268+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1269+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1270+line"]</TD> </TR> <TR>

1271+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1272+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

1273+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

1274+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

1275+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

1276+ <TD>n_structure_close_unopened_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>1]</TD> </TR> <TR>

1277+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

1278+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

1279+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

1280+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

1281+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1282+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1283+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

1284+

1285+

1286+<A NAME="19"></A><H4><A HREF="http://dkolf.de/src/dkjson-lua.fsl/home">Lua dkjson</A></H4>

1287+<TABLE>

1288+ <TR>

1289+ <TH></TH>

1290+ <TH class="space"><DIV></DIV></TH>

1291+ <TH></TH>

1292+ </TR>

1293+ <TR>

1294+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1295+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1296+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1297+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1298+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1299+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1300+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1301+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1302+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1303+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1304+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1305+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1306+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1307+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1308+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1309+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1310+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1311+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1312+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1313+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1314+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1315+ <TD>n_array_1_true_without_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 true]</TD> </TR> <TR>

1316+ <TD>n_array_colon_instead_of_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["": 1]</TD> </TR> <TR>

1317+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

1318+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

1319+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1320+ <TD>n_array_inner_array_no_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[3[4]]</TD> </TR> <TR>

1321+ <TD>n_array_items_separated_by_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1:2]</TD> </TR> <TR>

1322+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1323+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

1324+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1325+ <TD>n_number_.2e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.2e-3]</TD> </TR> <TR>

1326+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1327+ <TD>n_number_1_000.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1 000.0]</TD> </TR> <TR>

1328+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1329+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1330+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1331+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

1332+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

1333+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1334+ <TD>n_number_starting_with_dot.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[.123]</TD> </TR> <TR>

1335+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

1336+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

1337+ <TD>n_object_comma_instead_of_colon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"x", null}</TD> </TR> <TR>

1338+ <TD>n_object_garbage_at_end.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"a" 123}</TD> </TR> <TR>

1339+ <TD>n_object_missing_semicolon.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a" "b"}</TD> </TR> <TR>

1340+ <TD>n_object_non_string_key.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{1:1}</TD> </TR> <TR>

1341+ <TD>n_object_non_string_key_but_huge_number_instead.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{9999E9999:1}</TD> </TR> <TR>

1342+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

1343+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1344+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1345+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

1346+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1347+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

1348+ <TD>n_object_with_single_string.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{ "foo" : "bar", "a" }</TD> </TR> <TR>

1349+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

1350+ <TD>n_string_1_surrogate_then_escape u.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u"]</TD> </TR> <TR>

1351+ <TD>n_string_1_surrogate_then_escape u1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1"]</TD> </TR> <TR>

1352+ <TD>n_string_1_surrogate_then_escape u1x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\u1x"]</TD> </TR> <TR>

1353+ <TD>n_string_UTF-16_incomplete_surrogate.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1354+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1355+ <TD>n_string_backslash_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\00"] <=> ["\"]</TD> </TR> <TR>

1356+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

1357+ <TD>n_string_escaped_ctrl_char_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\09"] <=> ["\ "]</TD> </TR> <TR>

1358+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

1359+ <TD>n_string_incomplete_escaped_character.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\u00A"]</TD> </TR> <TR>

1360+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

1361+ <TD>n_string_invalid-utf-8-in-escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uE5"] <=> ["\u"]</TD> </TR> <TR>

1362+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

1363+ <TD>n_string_invalid_unicode_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uqqqq"]</TD> </TR> <TR>

1364+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1365+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

1366+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1367+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1368+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1369+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1370+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1371+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1372+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1373+line"]</TD> </TR> <TR>

1374+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1375+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

1376+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

1377+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

1378+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

1379+ <TD>n_structure_close_unopened_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>1]</TD> </TR> <TR>

1380+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

1381+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

1382+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

1383+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

1384+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

1385+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1386+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

1387+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1388+

1389+

1390+<A NAME="20"></A><H4>Obj-C Apple NSJSONSerialization</H4>

1391+<TABLE>

1392+ <TR>

1393+ <TH></TH>

1394+ <TH class="space"><DIV></DIV></TH>

1395+ <TH></TH>

1396+ </TR>

1397+ <TR>

1398+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1399+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1400+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1401+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1402+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1403+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1404+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1405+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1406+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1407+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1408+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1409+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1410+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1411+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1412+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1413+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1414+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1415+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1416+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1417+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1418+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1419+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1420+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1421+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1422+ <TD>y_number_double_huge_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

1423+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

1424+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

1425+ <TD>y_number_real_underflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123e-10000000]</TD> </TR></TABLE>

1426+

1427+

1428+<A NAME="21"></A><H4>Obj-C JSONKit</H4>

1429+<TABLE>

1430+ <TR>

1431+ <TH></TH>

1432+ <TH class="space"><DIV></DIV></TH>

1433+ <TH></TH>

1434+ </TR>

1435+ <TR>

1436+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1437+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1438+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1439+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1440+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1441+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1442+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1443+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1444+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1445+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1446+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1447+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1448+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1449+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1450+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1451+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1452+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1453+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1454+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1455+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1456+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1457+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1458+ <TD>n_structure_no_data.json</TD> <TD class="CRASH"></TD> <TD></TD> </TR> <TR>

1459+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

1460+ <TD>y_number_double_huge_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

1461+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

1462+ <TD>y_number_real_neg_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123e100000]</TD> </TR> <TR>

1463+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

1464+ <TD>y_number_real_underflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123e-10000000]</TD> </TR> <TR>

1465+ <TD>y_number_too_big_neg_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

1466+ <TD>y_number_too_big_pos_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

1467+ <TD>y_number_very_big_negative_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

1468+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

1469+ <TD>y_string_escaped_noncharacter.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uFFFF"]</TD> </TR> <TR>

1470+ <TD>y_string_last_surrogates_1_and_2.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uDBFF\uDFFF"]</TD> </TR> <TR>

1471+ <TD>y_string_nonCharacterInUTF-8_U+10FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["F48FBFBF"] <=> ["􏿿"]</TD> </TR> <TR>

1472+ <TD>y_string_nonCharacterInUTF-8_U+FFFF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["EFBFBF"] <=> [""]</TD> </TR> <TR>

1473+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

1474+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

1475+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1476+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

1477+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

1478+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

1479+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

1480+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

1481+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

1482+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

1483+

1484+

1485+<A NAME="22"></A><H4><A HREF="https://github.com/stig/json-framework">Obj-C SBJSON 4.0.3</A></H4>

1486+<TABLE>

1487+ <TR>

1488+ <TH></TH>

1489+ <TH class="space"><DIV></DIV></TH>

1490+ <TH></TH>

1491+ </TR>

1492+ <TR>

1493+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1494+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1495+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1496+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1497+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1498+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1499+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1500+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="CRASH"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1501+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1502+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1503+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1504+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1505+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1506+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="CRASH"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1507+ <TD>i_string_truncated-utf-8.json</TD> <TD class="CRASH"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1508+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1509+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1510+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1511+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1512+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1513+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1514+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

1515+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

1516+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

1517+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="CRASH"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

1518+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1519+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

1520+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1521+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

1522+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

1523+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="CRASH"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1524+ <TD>n_string_invalid_utf-8.json</TD> <TD class="CRASH"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1525+ <TD>n_string_iso_latin_1.json</TD> <TD class="CRASH"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1526+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="CRASH"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1527+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="CRASH"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1528+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="CRASH"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1529+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="CRASH"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1530+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

1531+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

1532+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

1533+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

1534+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

1535+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1536+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

1537+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1538+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

1539+ <TD>y_structure_lonely_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>42</TD> </TR> <TR>

1540+ <TD>y_structure_lonely_negative_real.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>-0.1</TD> </TR> <TR>

1541+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

1542+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

1543+ <TD>y_structure_lonely_true.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>true</TD> </TR> <TR>

1544+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

1545+

1546+

1547+<A NAME="23"></A><H4><A HREF="https://github.com/TouchCode/TouchJSON">Obj-C TouchJSON</A></H4>

1548+<TABLE>

1549+ <TR>

1550+ <TH></TH>

1551+ <TH class="space"><DIV></DIV></TH>

1552+ <TH></TH>

1553+ </TR>

1554+ <TR>

1555+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1556+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1557+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1558+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1559+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1560+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1561+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1562+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1563+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1564+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1565+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1566+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1567+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1568+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1569+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1570+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1571+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1572+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1573+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1574+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1575+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1576+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1577+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1578+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

1579+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1580+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

1581+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

1582+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1583+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

1584+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

1585+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

1586+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

1587+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

1588+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

1589+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

1590+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1591+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1592+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1593+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

1594+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

1595+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

1596+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1597+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

1598+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1599+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1600+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1601+line"]</TD> </TR> <TR>

1602+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1603+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1604+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

1605+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR></TABLE>

1606+

1607+

1608+<A NAME="24"></A><H4>PHP 5.5.36</H4>

1609+<TABLE>

1610+ <TR>

1611+ <TH></TH>

1612+ <TH class="space"><DIV></DIV></TH>

1613+ <TH></TH>

1614+ </TR>

1615+ <TR>

1616+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1617+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1618+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1619+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1620+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1621+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1622+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1623+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1624+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1625+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1626+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1627+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1628+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1629+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1630+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1631+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1632+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1633+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1634+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1635+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1636+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1637+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1638+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1639+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

1640+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

1641+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1642+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

1643+ <TD>n_structure_no_data.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD></TD> </TR> <TR>

1644+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1645+

1646+

1647+<A NAME="25"></A><H4>Perl JSON</H4>

1648+<TABLE>

1649+ <TR>

1650+ <TH></TH>

1651+ <TH class="space"><DIV></DIV></TH>

1652+ <TH></TH>

1653+ </TR>

1654+ <TR>

1655+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1656+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1657+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1658+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1659+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1660+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1661+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1662+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1663+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1664+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1665+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1666+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1667+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1668+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1669+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1670+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1671+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1672+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1673+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1674+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1675+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1676+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1677+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

1678+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

1679+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

1680+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

1681+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1682+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1683+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1684+ <TD>y_array_with_1_and_newline.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[10A] <=> [1

1685+]</TD> </TR> <TR>

1686+ <TD>y_object_with_newlines.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{0A"a": "b"0A} <=> {

1687+"a": "b"

1688+}</TD> </TR> <TR>

1689+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1690+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

1691+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

1692+

1693+

1694+<A NAME="26"></A><H4><A HREF="http://search.cpan.org/dist/JSON-XS/XS.pm">Perl JSON::XS</A></H4>

1695+<TABLE>

1696+ <TR>

1697+ <TH></TH>

1698+ <TH class="space"><DIV></DIV></TH>

1699+ <TH></TH>

1700+ </TR>

1701+ <TR>

1702+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1703+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1704+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1705+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1706+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1707+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1708+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1709+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1710+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1711+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1712+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1713+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1714+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1715+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1716+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1717+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1718+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1719+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1720+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1721+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1722+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1723+ <TD>n_array_newlines_unclosed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a",0A40A,1, <=> ["a",

1724+4

1725+,1,</TD> </TR> <TR>

1726+ <TD>n_array_unclosed_with_new_lines.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,0A10A,1 <=> [1,

1727+1

1728+,1</TD> </TR> <TR>

1729+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

1730+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1731+ <TD>y_array_with_1_and_newline.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[10A] <=> [1

1732+]</TD> </TR> <TR>

1733+ <TD>y_object_with_newlines.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{0A"a": "b"0A} <=> {

1734+"a": "b"

1735+}</TD> </TR> <TR>

1736+ <TD>y_string_space.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>" "</TD> </TR> <TR>

1737+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1738+ <TD>y_structure_lonely_false.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>false</TD> </TR> <TR>

1739+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR> <TR>

1740+ <TD>y_structure_lonely_string.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>"asd"</TD> </TR> <TR>

1741+ <TD>y_structure_string_empty.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>""</TD> </TR></TABLE>

1742+

1743+

1744+<A NAME="27"></A><H4>Python 2.7.10</H4>

1745+<TABLE>

1746+ <TR>

1747+ <TH></TH>

1748+ <TH class="space"><DIV></DIV></TH>

1749+ <TH></TH>

1750+ </TR>

1751+ <TR>

1752+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1753+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1754+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1755+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1756+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1757+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1758+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1759+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1760+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1761+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1762+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1763+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1764+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1765+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1766+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1767+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1768+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1769+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1770+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1771+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1772+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1773+ <TD>n_number_NaN.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[NaN]</TD> </TR> <TR>

1774+ <TD>n_number_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[Infinity]</TD> </TR> <TR>

1775+ <TD>n_number_minus_infinity.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-Infinity]</TD> </TR> <TR>

1776+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1777+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1778+

1779+

1780+<A NAME="28"></A><H4>Qt JSON</H4>

1781+

1782+<A NAME="29"></A><H4>R jsonlite</H4>

1783+<TABLE>

1784+ <TR>

1785+ <TH></TH>

1786+ <TH class="space"><DIV></DIV></TH>

1787+ <TH></TH>

1788+ </TR>

1789+ <TR>

1790+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1791+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1792+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1793+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1794+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1795+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1796+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1797+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1798+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1799+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1800+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1801+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1802+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1803+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1804+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1805+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1806+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1807+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1808+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1809+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1810+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1811+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1812+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1813+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1814+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1815+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

1816+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

1817+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1818+

1819+

1820+<A NAME="30"></A><H4>R rjson</H4>

1821+<TABLE>

1822+ <TR>

1823+ <TH></TH>

1824+ <TH class="space"><DIV></DIV></TH>

1825+ <TH></TH>

1826+ </TR>

1827+ <TR>

1828+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1829+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1830+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1831+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1832+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1833+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1834+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1835+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1836+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1837+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1838+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1839+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1840+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1841+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1842+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1843+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1844+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1845+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1846+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2011847 <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2021848 <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1849+ <TD>n_array_comma_after_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[""],</TD> </TR> <TR>

1850+ <TD>n_array_extra_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["x"]]</TD> </TR> <TR>

1851+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

1852+ <TD>n_array_just_minus.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-]</TD> </TR> <TR>

1853+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

2031854 <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

1855+ <TD>n_number_0.3e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e+]</TD> </TR> <TR>

1856+ <TD>n_number_0.3e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.3e]</TD> </TR> <TR>

2041857 <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

1858+ <TD>n_number_0_capital_E+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E+]</TD> </TR> <TR>

1859+ <TD>n_number_0_capital_E.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0E]</TD> </TR> <TR>

1860+ <TD>n_number_0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e+]</TD> </TR> <TR>

1861+ <TD>n_number_0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0e]</TD> </TR> <TR>

1862+ <TD>n_number_1.0e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e+]</TD> </TR> <TR>

1863+ <TD>n_number_1.0e-.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e-]</TD> </TR> <TR>

1864+ <TD>n_number_1.0e.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.0e]</TD> </TR> <TR>

2051865 <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

2061866 <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

2071867 <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

1868+ <TD>n_number_9.e+.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[9.e+]</TD> </TR> <TR>

1869+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

2081870 <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

209− <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR></TABLE>

1871+ <TD>n_number_then_00.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>100 <=> 1</TD> </TR> <TR>

1872+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1873+ <TD>n_object_trailing_comment_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**//</TD> </TR> <TR>

1874+ <TD>n_object_trailing_comment_slash_open.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}//</TD> </TR> <TR>

1875+ <TD>n_object_trailing_comment_slash_open_incomplete.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/</TD> </TR> <TR>

1876+ <TD>n_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#</TD> </TR> <TR>

1877+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1878+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1879+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1880+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1881+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1882+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1883+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1884+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1885+line"]</TD> </TR> <TR>

1886+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1887+ <TD>n_string_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>""x</TD> </TR> <TR>

1888+ <TD>n_structure_array_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]x</TD> </TR> <TR>

1889+ <TD>n_structure_array_with_extra_array_close.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1]]</TD> </TR> <TR>

1890+ <TD>n_structure_close_unopened_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>1]</TD> </TR> <TR>

1891+ <TD>n_structure_double_array.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[][]</TD> </TR> <TR>

1892+ <TD>n_structure_number_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>2@</TD> </TR> <TR>

1893+ <TD>n_structure_object_followed_by_closing_object.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{}}</TD> </TR> <TR>

1894+ <TD>n_structure_object_with_trailing_garbage.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a": true} "x"</TD> </TR> <TR>

1895+ <TD>n_structure_trailing_#.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}#{}</TD> </TR> <TR>

1896+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

1897+

1898+

1899+<A NAME="31"></A><H4>Ruby</H4>

1900+<TABLE>

1901+ <TR>

1902+ <TH></TH>

1903+ <TH class="space"><DIV></DIV></TH>

1904+ <TH></TH>

1905+ </TR>

1906+ <TR>

1907+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1908+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1909+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1910+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1911+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1912+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1913+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1914+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1915+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1916+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1917+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1918+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1919+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1920+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1921+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1922+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1923+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1924+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1925+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1926+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1927+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1928+ <TD>n_object_trailing_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":"b"}/**/</TD> </TR> <TR>

1929+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

1930+ <TD>n_string_escape_x.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\x00"]</TD> </TR> <TR>

1931+ <TD>n_string_escaped_emoji.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\F09F8C80"] <=> ["\🌀"]</TD> </TR> <TR>

1932+ <TD>n_string_incomplete_surrogate_escape_invalid.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\uD800\uD800\x"]</TD> </TR> <TR>

1933+ <TD>n_string_invalid_backslash_esc.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\a"]</TD> </TR> <TR>

1934+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

1935+ <TD>n_string_invalid_utf8_after_escape.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["\E5"] <=> ["\"]</TD> </TR> <TR>

1936+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

1937+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

1938+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

1939+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

1940+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

1941+ <TD>n_string_unicode_CapitalU.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>"\UA66D"</TD> </TR> <TR>

1942+ <TD>n_structure_object_with_comment.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"a":/*comment*/"b"}</TD> </TR> <TR>

1943+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1944+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

1945+

1946+

1947+<A NAME="32"></A><H4>Ruby regex</H4>

1948+<TABLE>

1949+ <TR>

1950+ <TH></TH>

1951+ <TH class="space"><DIV></DIV></TH>

1952+ <TH></TH>

1953+ </TR>

1954+ <TR>

1955+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1956+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1957+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

1958+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

1959+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

1960+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1961+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1962+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

1963+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

1964+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

1965+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

1966+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

1967+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

1968+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

1969+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

1970+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

1971+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

1972+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

1973+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

1974+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

1975+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

1976+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

1977+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

1978+line"]</TD> </TR> <TR>

1979+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

1980+ <TD>n_structure_capitalized_True.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[True]</TD> </TR> <TR>

1981+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

1982+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

1983+ <TD>y_object_escaped_null_in_key.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"foo\u0000bar": 42}</TD> </TR> <TR>

1984+ <TD>y_object_string_unicode.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>{"title":"\u041f\u043e\u043b\u0442\u(...)</TD> </TR> <TR>

1985+ <TD>y_string_1_2_3_bytes_UTF-8_sequences.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0060\u012a\u12AB"]</TD> </TR> <TR>

1986+ <TD>y_string_UTF-16_Surrogates_U+1D11E_MUSICAL_SYMBOL_G_CLEF.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

1987+ <TD>y_string_accepted_surrogate_pair.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uD801\udc37"]</TD> </TR> <TR>

1988+ <TD>y_string_accepted_surrogate_pairs.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\ud83d\ude39\ud83d\udc8d"]</TD> </TR> <TR>

1989+ <TD>y_string_allowed_escapes.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\"\\\/\b\f\n\r\t"]</TD> </TR> <TR>

1990+ <TD>y_string_backslash_and_u_escaped_zero.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\\u0000"]</TD> </TR> <TR>

1991+ <TD>y_string_backslash_doublequotes.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\""]</TD> </TR> <TR>

1992+ <TD>y_string_double_escape_a.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\\a"]</TD> </TR> <TR>

1993+ <TD>y_string_double_escape_n.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\\n"]</TD> </TR> <TR>

1994+ <TD>y_string_escaped_control_character.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0012"]</TD> </TR> <TR>

1995+ <TD>y_string_escaped_noncharacter.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uFFFF"]</TD> </TR> <TR>

1996+ <TD>y_string_last_surrogates_1_and_2.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uDBFF\uDFFF"]</TD> </TR> <TR>

1997+ <TD>y_string_newline_uescaped.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["new\u00A0line"]</TD> </TR> <TR>

1998+ <TD>y_string_null_escape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0000"]</TD> </TR> <TR>

1999+ <TD>y_string_one-byte-utf-8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u002c"]</TD> </TR> <TR>

2000+ <TD>y_string_three-byte-utf-8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0821"]</TD> </TR> <TR>

2001+ <TD>y_string_two-byte-utf-8.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0123"]</TD> </TR> <TR>

2002+ <TD>y_string_uEscape.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0061\u30af\u30EA\u30b9"]</TD> </TR> <TR>

2003+ <TD>y_string_unicode.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\uA66D"]</TD> </TR> <TR>

2004+ <TD>y_string_unicodeEscapedBackslash.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u005C"]</TD> </TR> <TR>

2005+ <TD>y_string_unicode_U+200B_ZERO_WIDTH_SPACE.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u200B"]</TD> </TR> <TR>

2006+ <TD>y_string_unicode_U+2064_invisible_plus.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u2064"]</TD> </TR> <TR>

2007+ <TD>y_string_unicode_escaped_double_quote.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>["\u0022"]</TD> </TR> <TR>

2008+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2009+

2010+

2011+<A NAME="33"></A><H4><A HREF="https://github.com/maciejhirsz/json-rust">Rust json-rust</A></H4>

2012+<TABLE>

2013+ <TR>

2014+ <TH></TH>

2015+ <TH class="space"><DIV></DIV></TH>

2016+ <TH></TH>

2017+ </TR>

2018+ <TR>

2019+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2020+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2021+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2022+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2023+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2024+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2025+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2026+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2027+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2028+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2029+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2030+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2031+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2032+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2033+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2034+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2035+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2036+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2037+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2038+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2039+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2040+ <TD>n_number_-2..json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-2.]</TD> </TR> <TR>

2041+ <TD>n_number_0.e1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0.e1]</TD> </TR> <TR>

2042+ <TD>n_number_2.e+3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e+3]</TD> </TR> <TR>

2043+ <TD>n_number_2.e-3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e-3]</TD> </TR> <TR>

2044+ <TD>n_number_2.e3.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[2.e3]</TD> </TR> <TR>

2045+ <TD>n_number_real_without_fractional_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1.]</TD> </TR> <TR>

2046+ <TD>n_string_accentuated_char_no_quotes.json</TD> <TD class="CRASH"></TD> <TD>[C3A9] <=> [é]</TD> </TR> <TR>

2047+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2048+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

2049+ <TD>n_structure_unicode-identifier.json</TD> <TD class="CRASH"></TD> <TD>C3A5 <=> å</TD> </TR> <TR>

2050+ <TD>n_structure_whitespace_formfeed.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[0C] <=> []</TD> </TR> <TR>

2051+ <TD>y_number_huge_exp.json</TD> <TD class="CRASH"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

2052+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2053+

2054+

2055+<A NAME="34"></A><H4><A HREF="https://doc.rust-lang.org/rustc-serialize/rustc_serialize/json/index.html">Rust rustc_serialize::json</A></H4>

2056+<TABLE>

2057+ <TR>

2058+ <TH></TH>

2059+ <TH class="space"><DIV></DIV></TH>

2060+ <TH></TH>

2061+ </TR>

2062+ <TR>

2063+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2064+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2065+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2066+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2067+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2068+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2069+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2070+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2071+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2072+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2073+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2074+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2075+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2076+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2077+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2078+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2079+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2080+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2081+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2082+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2083+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2084+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2085+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

2086+ <TD>y_number_huge_exp.json</TD> <TD class="CRASH"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

2087+ <TD>y_number_too_big_neg_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-123123123123123123123123123123]</TD> </TR> <TR>

2088+ <TD>y_number_too_big_pos_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[100000000000000000000]</TD> </TR> <TR>

2089+ <TD>y_number_very_big_negative_int.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-2374623746732768942798327498324234(...)</TD> </TR> <TR>

2090+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2091+

2092+

2093+<A NAME="35"></A><H4><A HREF="https://github.com/serde-rs/json">Rust serde_json</A></H4>

2094+

2095+<A NAME="36"></A><H4><A HREF="http://www.squeaksource.com/JSON.html">Squeak JSON-tonyg</A></H4>

2096+

2097+<A NAME="37"></A><H4>Swift Apple JSONSerialization</H4>

2098+<TABLE>

2099+ <TR>

2100+ <TH></TH>

2101+ <TH class="space"><DIV></DIV></TH>

2102+ <TH></TH>

2103+ </TR>

2104+ <TR>

2105+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2106+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2107+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2108+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2109+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2110+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2111+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2112+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2113+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2114+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2115+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2116+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2117+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2118+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2119+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2120+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2121+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2122+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2123+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2124+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2125+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2126+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

2127+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

2128+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

2129+ <TD>y_number_double_huge_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123.456e-789]</TD> </TR> <TR>

2130+ <TD>y_number_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0.4e0066999999999999999999999999999(...)</TD> </TR> <TR>

2131+ <TD>y_number_real_pos_overflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123123e100000]</TD> </TR> <TR>

2132+ <TD>y_number_real_underflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123e-10000000]</TD> </TR></TABLE>

2133+

2134+

2135+<A NAME="38"></A><H4>Swift Freddy 2.1.0</H4>

2136+<TABLE>

2137+ <TR>

2138+ <TH></TH>

2139+ <TH class="space"><DIV></DIV></TH>

2140+ <TH></TH>

2141+ </TR>

2142+ <TR>

2143+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2144+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2145+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2146+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2147+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2148+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2149+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2150+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2151+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2152+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2153+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2154+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2155+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2156+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2157+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2158+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2159+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2160+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2161+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2162+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2163+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2164+ <TD>n_array_newlines_unclosed.json</TD> <TD class="CRASH"></TD> <TD>["a",0A40A,1, <=> ["a",

2165+4

2166+,1,</TD> </TR> <TR>

2167+ <TD>n_array_unclosed_trailing_comma.json</TD> <TD class="CRASH"></TD> <TD>[1,</TD> </TR> <TR>

2168+ <TD>n_object_missing_value.json</TD> <TD class="CRASH"></TD> <TD>{"a":</TD> </TR> <TR>

2169+ <TD>n_single_space.json</TD> <TD class="CRASH"></TD> <TD> </TD> </TR> <TR>

2170+ <TD>n_string_start_escape_unclosed.json</TD> <TD class="CRASH"></TD> <TD>["\</TD> </TR> <TR>

2171+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

2172+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

2173+line"]</TD> </TR> <TR>

2174+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

2175+ <TD>n_structure_object_unclosed_no_value.json</TD> <TD class="CRASH"></TD> <TD>{"":</TD> </TR> <TR>

2176+ <TD>y_number_0e+1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e+1]</TD> </TR> <TR>

2177+ <TD>y_number_0e1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e1]</TD> </TR> <TR>

2178+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2179+

2180+

2181+<A NAME="39"></A><H4>Swift Freddy 20160830</H4>

2182+<TABLE>

2183+ <TR>

2184+ <TH></TH>

2185+ <TH class="space"><DIV></DIV></TH>

2186+ <TH></TH>

2187+ </TR>

2188+ <TR>

2189+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2190+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2191+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2192+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2193+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2194+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2195+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2196+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2197+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2198+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2199+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2200+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2201+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2202+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2203+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2204+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2205+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2206+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2207+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2208+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2209+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2210+ <TD>n_string_start_escape_unclosed.json</TD> <TD class="CRASH"></TD> <TD>["\</TD> </TR> <TR>

2211+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

2212+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

2213+line"]</TD> </TR> <TR>

2214+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

2215+ <TD>y_number_0e+1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e+1]</TD> </TR> <TR>

2216+ <TD>y_number_0e1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e1]</TD> </TR> <TR>

2217+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2218+

2219+

2220+<A NAME="40"></A><H4>Swift Freddy 20161018</H4>

2221+<TABLE>

2222+ <TR>

2223+ <TH></TH>

2224+ <TH class="space"><DIV></DIV></TH>

2225+ <TH></TH>

2226+ </TR>

2227+ <TR>

2228+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2229+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2230+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2231+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2232+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2233+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2234+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2235+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2236+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2237+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2238+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2239+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2240+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2241+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2242+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2243+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2244+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2245+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2246+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2247+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2248+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2249+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

2250+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

2251+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

2252+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

2253+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

2254+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

2255+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

2256+ <TD>n_string_start_escape_unclosed.json</TD> <TD class="CRASH"></TD> <TD>["\</TD> </TR> <TR>

2257+ <TD>n_string_unescaped_crtl_char.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["a00a"] <=> ["aa"]</TD> </TR> <TR>

2258+ <TD>n_string_unescaped_newline.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["new0Aline"] <=> ["new

2259+line"]</TD> </TR> <TR>

2260+ <TD>n_string_unescaped_tab.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["09"] <=> [" "]</TD> </TR> <TR>

2261+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2262+

2263+

2264+<A NAME="41"></A><H4><A HREF="https://github.com/postmates/PMJSON">Swift PMJSON 1.1</A></H4>

2265+<TABLE>

2266+ <TR>

2267+ <TH></TH>

2268+ <TH class="space"><DIV></DIV></TH>

2269+ <TH></TH>

2270+ </TR>

2271+ <TR>

2272+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="CRASH"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2273+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2274+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2275+ <TD>i_string_UTF-16LE_with_BOM.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>FFFE[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

2276+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2277+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2278+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2279+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2280+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="CRASH"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2281+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2282+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="CRASH"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2283+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="CRASH"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2284+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2285+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2286+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2287+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2288+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2289+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2290+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2291+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2292+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

2293+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

2294+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

2295+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

2296+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

2297+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

2298+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

2299+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

2300+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

2301+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

2302+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

2303+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2304+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

2305+ <TD>y_number_0e+1.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[0e+1]</TD> </TR> <TR>

2306+ <TD>y_number_neg_int_huge_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[-1e+9999]</TD> </TR> <TR>

2307+ <TD>y_number_real_capital_e_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[1E-2]</TD> </TR> <TR>

2308+ <TD>y_number_real_capital_e_pos_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[1E+2]</TD> </TR> <TR>

2309+ <TD>y_number_real_neg_exp.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[1e-2]</TD> </TR> <TR>

2310+ <TD>y_number_real_pos_exponent.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[1e+2]</TD> </TR> <TR>

2311+ <TD>y_number_real_underflow.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[123e-10000000]</TD> </TR> <TR>

2312+ <TD>y_string_utf16BE_no_BOM.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>00[00"00E900"00] <=> [""]</TD> </TR> <TR>

2313+ <TD>y_string_utf16LE_no_BOM.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

2314+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

2315+

2316+

2317+<A NAME="42"></A><H4><A HREF="https://github.com/postmates/PMJSON">Swift PMJSON 1.2</A></H4>

2318+<TABLE>

2319+ <TR>

2320+ <TH></TH>

2321+ <TH class="space"><DIV></DIV></TH>

2322+ <TH></TH>

2323+ </TR>

2324+ <TR>

2325+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2326+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2327+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2328+ <TD>i_string_UTF-16LE_with_BOM.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>FFFE[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

2329+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2330+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2331+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2332+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2333+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2334+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2335+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2336+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2337+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2338+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2339+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2340+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2341+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2342+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2343+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2344+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2345+ <TD>n_array_extra_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["",]</TD> </TR> <TR>

2346+ <TD>n_array_number_and_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[1,]</TD> </TR> <TR>

2347+ <TD>n_number_-01.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-01]</TD> </TR> <TR>

2348+ <TD>n_number_neg_int_starting_with_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-012]</TD> </TR> <TR>

2349+ <TD>n_number_neg_real_without_int_part.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[-.123]</TD> </TR> <TR>

2350+ <TD>n_number_with_leading_zero.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>[012]</TD> </TR> <TR>

2351+ <TD>n_object_pi_in_key_and_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"B9":"0",} <=> {"":"0",}</TD> </TR> <TR>

2352+ <TD>n_object_trailing_comma.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>{"id":0,}</TD> </TR> <TR>

2353+ <TD>n_string_UTF8_surrogate_U+D800.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["EDA080"] <=> [""]</TD> </TR> <TR>

2354+ <TD>n_string_invalid_utf-8.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FF"] <=> [""]</TD> </TR> <TR>

2355+ <TD>n_string_iso_latin_1.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["E9"] <=> [""]</TD> </TR> <TR>

2356+ <TD>n_string_lone_utf8_continuation_byte.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["81"] <=> [""]</TD> </TR> <TR>

2357+ <TD>n_string_overlong_sequence_2_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["C0AF"] <=> [""]</TD> </TR> <TR>

2358+ <TD>n_string_overlong_sequence_6_bytes.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC83BFBFBFBF"] <=> [""]</TD> </TR> <TR>

2359+ <TD>n_string_overlong_sequence_6_bytes_null.json</TD> <TD class="SHOULD_HAVE_FAILED"></TD> <TD>["FC8080808080"] <=> [""]</TD> </TR> <TR>

2360+ <TD>n_structure_100000_opening_arrays.json</TD> <TD class="CRASH"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2361+ <TD>n_structure_open_array_object.json</TD> <TD class="CRASH"></TD> <TD>[{"":[{"":[{"":[{"":[{"":[{"":[{"":[(...)</TD> </TR> <TR>

2362+ <TD>y_string_utf16BE_no_BOM.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>00[00"00E900"00] <=> [""]</TD> </TR> <TR>

2363+ <TD>y_string_utf16LE_no_BOM.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>[00"00E900"00]00 <=> [""]</TD> </TR> <TR>

2364+ <TD>y_structure_lonely_null.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>null</TD> </TR></TABLE>

2365+

2366+

2367+<A NAME="43"></A><H4>Swift STJSON</H4>

2368+<TABLE>

2369+ <TR>

2370+ <TH></TH>

2371+ <TH class="space"><DIV></DIV></TH>

2372+ <TH></TH>

2373+ </TR>

2374+ <TR>

2375+ <TD>i_number_neg_int_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2376+ <TD>i_number_pos_double_huge_exp.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2377+ <TD>i_object_key_lone_2nd_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>{"\uDFAA":0}</TD> </TR> <TR>

2378+ <TD>i_string_1st_surrogate_but_2nd_missing.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDADA"]</TD> </TR> <TR>

2379+ <TD>i_string_1st_valid_surrogate_2nd_invalid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD888\u1234"]</TD> </TR> <TR>

2380+ <TD>i_string_UTF-16_invalid_lonely_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2381+ <TD>i_string_UTF-16_invalid_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>(MISSING FILE)</TD> </TR> <TR>

2382+ <TD>i_string_UTF-8_invalid_sequence.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E697A5D188FA"] <=> ["日ш"]</TD> </TR> <TR>

2383+ <TD>i_string_incomplete_surrogate_and_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\n"]</TD> </TR> <TR>

2384+ <TD>i_string_incomplete_surrogate_pair.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1ea"]</TD> </TR> <TR>

2385+ <TD>i_string_incomplete_surrogates_escape_valid.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD800\uD800\n"]</TD> </TR> <TR>

2386+ <TD>i_string_inverted_surrogates_U+1D11E.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDd1e\uD834"]</TD> </TR> <TR>

2387+ <TD>i_string_lone_second_surrogate.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDFAA"]</TD> </TR> <TR>

2388+ <TD>i_string_not_in_unicode_range.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["F4BFBFBF"] <=> [""]</TD> </TR> <TR>

2389+ <TD>i_string_truncated-utf-8.json</TD> <TD class="IMPLEMENTATION_FAIL"></TD> <TD>["E0FF"] <=> [""]</TD> </TR> <TR>

2390+ <TD>i_string_unicode_U+10FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uDBFF\uDFFE"]</TD> </TR> <TR>

2391+ <TD>i_string_unicode_U+1FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uD83F\uDFFE"]</TD> </TR> <TR>

2392+ <TD>i_string_unicode_U+FDD0_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFDD0"]</TD> </TR> <TR>

2393+ <TD>i_string_unicode_U+FFFE_nonchar.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>["\uFFFE"]</TD> </TR> <TR>

2394+ <TD>i_structure_500_nested_arrays.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[(...)</TD> </TR> <TR>

2395+ <TD>i_structure_UTF-8_BOM_empty_object.json</TD> <TD class="IMPLEMENTATION_PASS"></TD> <TD>EFBBBF{} <=> {}</TD> </TR> <TR>

2396+ <TD>y_string_utf16.json</TD> <TD class="SHOULD_HAVE_PASSED"></TD> <TD>(MISSING FILE)</TD> </TR></TABLE>

2102397

2112398

2122399

run_tests.py+7−2

@@ -122,10 +122,15 @@ programs = {

122122 "url":"",

123123 "commands":[os.path.join(PARSERS_DIR, "test_Freddy_20161018/bin/test_Freddy")]

124124 },

125− "Swift PMJSON 20161026":

125+ "Swift PMJSON 1.1":

126126 {

127127 "url":"https://github.com/postmates/PMJSON",

128− "commands":[os.path.join(PARSERS_DIR, "test_PMJSON_20161026/bin/test_PMJSON")]

128+ "commands":[os.path.join(PARSERS_DIR, "test_PMJSON_1_1_0/bin/test_PMJSON")]

129+ },

130+ "Swift PMJSON 1.2":

131+ {

132+ "url":"https://github.com/postmates/PMJSON",

133+ "commands":[os.path.join(PARSERS_DIR, "test_PMJSON_1_2_0/bin/test_PMJSON")]

129134 },

130135 "Swift STJSON":

131136 {