--- /dev/null
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@file:Suppress("NOTHING_TO_INLINE")
+
+package com.google.flatbuffers.kotlin
+
+import com.google.flatbuffers.kotlin.FlexBuffersBuilder.Companion.SHARE_KEYS_AND_STRINGS
+import kotlin.experimental.and
+import kotlin.math.pow
+
+/**
+ * Returns a minified version of this FlexBuffer as a JSON.
+ */
+public fun Reference.toJson(): String = ArrayReadWriteBuffer(1024).let {
+ toJson(it)
+ val data = it.data() // it.getString(0, it.writePosition)
+ return data.decodeToString(0, it.writePosition)
+}
+
+/**
+ * Returns a minified version of this FlexBuffer as a JSON.
+ * @param out [ReadWriteBuffer] the JSON will be written.
+ */
+public fun Reference.toJson(out: ReadWriteBuffer) {
+ when (type) {
+ T_STRING -> {
+ val start = buffer.indirect(end, parentWidth)
+ val size = buffer.readULong(start - byteWidth, byteWidth).toInt()
+ out.jsonEscape(buffer, start, size)
+ }
+ T_KEY -> {
+ val start = buffer.indirect(end, parentWidth)
+ val end = buffer.findFirst(0.toByte(), start)
+ out.jsonEscape(buffer, start, end - start)
+ }
+ T_BLOB -> {
+ val blob = toBlob()
+ out.jsonEscape(out, blob.end, blob.size)
+ }
+ T_INT -> out.put(toLong().toString())
+ T_UINT -> out.put(toULong().toString())
+ T_FLOAT -> out.put(toDouble().toString())
+ T_NULL -> out.put("null")
+ T_BOOL -> out.put(toBoolean().toString())
+ T_MAP -> toMap().toJson(out)
+ T_VECTOR, T_VECTOR_BOOL, T_VECTOR_FLOAT, T_VECTOR_INT,
+ T_VECTOR_UINT, T_VECTOR_KEY, T_VECTOR_STRING_DEPRECATED -> toVector().toJson(out)
+ else -> error("Unable to convert type ${type.typeToString()} to JSON")
+ }
+}
+
+/**
+ * Returns a minified version of this FlexBuffer as a JSON.
+ */
+public fun Map.toJson(): String = ArrayReadWriteBuffer(1024).let { toJson(it); it.toString() }
+
+/**
+ * Returns a minified version of this FlexBuffer as a JSON.
+ * @param out [ReadWriteBuffer] the JSON will be written.
+ */
+public fun Map.toJson(out: ReadWriteBuffer) {
+ out.put('{'.toByte())
+ // key values pairs
+ for (i in 0 until size) {
+ val key = keyAt(i)
+ out.jsonEscape(buffer, key.start, key.sizeInBytes)
+ out.put(':'.toByte())
+ get(i).toJson(out)
+ if (i != size - 1) {
+ out.put(','.toByte())
+ }
+ }
+ // close bracket
+ out.put('}'.toByte())
+}
+
+/**
+ * Returns a minified version of this FlexBuffer as a JSON.
+ */
+public fun Vector.toJson(): String = ArrayReadWriteBuffer(1024).let { toJson(it); it.toString() }
+
+/**
+ * Returns a minified version of this FlexBuffer as a JSON.
+ * @param out that the JSON is being concatenated.
+ */
+public fun Vector.toJson(out: ReadWriteBuffer) {
+ out.put('['.toByte())
+ for (i in 0 until size) {
+ get(i).toJson(out)
+ if (i != size - 1) {
+ out.put(','.toByte())
+ }
+ }
+ out.put(']'.toByte())
+}
+
+/**
+ * JSONParser class is used to parse a JSON as FlexBuffers. Calling [JSONParser.parse] fiils [output]
+ * and returns a [Reference] ready to be used.
+ */
+public class JSONParser(public var output: FlexBuffersBuilder = FlexBuffersBuilder(1024, SHARE_KEYS_AND_STRINGS)) {
+ private var readPos = 0
+ private var scopes = ScopeStack()
+
+ /**
+ * Parse a json as [String] and returns a [Reference] to a FlexBuffer.
+ */
+ public fun parse(data: String): Reference = parse(ArrayReadBuffer(data.encodeToByteArray()))
+
+ /**
+ * Parse a json as [ByteArray] and returns a [Reference] to a FlexBuffer.
+ */
+ public fun parse(data: ByteArray): Reference = parse(ArrayReadBuffer(data))
+
+ /**
+ * Parse a json as [ReadBuffer] and returns a [Reference] to a FlexBuffer.
+ */
+ public fun parse(data: ReadBuffer): Reference {
+ reset()
+ parseValue(data, nextToken(data), null)
+ if (readPos < data.limit) {
+ val tok = skipWhitespace(data)
+ if (tok != CHAR_EOF) {
+ makeError(data, "Extraneous charaters after parse has finished", tok)
+ }
+ }
+ output.finish()
+ return getRoot(output.buffer)
+ }
+
+ private fun parseValue(data: ReadBuffer, token: Token, key: String? = null): FlexBufferType {
+ return when (token) {
+ TOK_BEGIN_OBJECT -> parseObject(data, key)
+ TOK_BEGIN_ARRAY -> parseArray(data, key)
+ TOK_TRUE -> T_BOOL.also { output[key] = true }
+ TOK_FALSE -> T_BOOL.also { output[key] = false }
+ TOK_NULL -> T_NULL.also { output.putNull(key) }
+ TOK_BEGIN_QUOTE -> parseString(data, key)
+ TOK_NUMBER -> parseNumber(data, data.data(), key)
+ else -> makeError(data, "Unexpected Character while parsing", 'x'.toByte())
+ }
+ }
+
+ private fun parseObject(data: ReadBuffer, key: String? = null): FlexBufferType {
+ this.scopes.push(SCOPE_OBJ_EMPTY)
+
+ val fPos = output.startMap()
+ val limit = data.limit
+ while (readPos <= limit) {
+ when (val tok = nextToken(data)) {
+ TOK_END_OBJECT -> {
+ this.scopes.pop()
+ output.endMap(fPos, key); return T_MAP
+ }
+ TOK_BEGIN_QUOTE -> {
+ val childKey = readString(data)
+ parseValue(data, nextToken(data), childKey)
+ }
+ else -> makeError(data, "Expecting start of object key", tok)
+ }
+ }
+ makeError(data, "Unable to parse the object", "x".toByte())
+ }
+
+ private fun parseArray(data: ReadBuffer, key: String? = null): FlexBufferType {
+ this.scopes.push(SCOPE_ARRAY_EMPTY)
+ val fPos = output.startVector()
+ var elementType = T_INVALID
+ var multiType = false
+ val limit = data.limit
+
+ while (readPos <= limit) {
+ when (val tok = nextToken(data)) {
+ TOK_END_ARRAY -> {
+ this.scopes.pop()
+ return if (!multiType && elementType.isScalar()) {
+ output.endTypedVector(fPos, key)
+ elementType.toElementTypedVector()
+ } else {
+ output.endVector(key, fPos)
+ T_VECTOR
+ }
+ }
+
+ else -> {
+ val newType = parseValue(data, tok, null)
+
+ if (elementType == T_INVALID) {
+ elementType = newType
+ } else if (newType != elementType) {
+ multiType = true
+ }
+ }
+ }
+ }
+ makeError(data, "Unable to parse the array")
+ }
+
+ private fun parseNumber(data: ReadBuffer, array: ByteArray, key: String?): FlexBufferType {
+ val ary = array
+ var cursor = readPos
+ var c = data[readPos++]
+ var useDouble = false
+ val limit = ary.size
+ var sign = 1
+ var double = 0.0
+ var long = 0L
+ var digits = 0
+
+ if (c == CHAR_MINUS) {
+ cursor++
+ checkEOF(data, cursor)
+ c = ary[cursor]
+ sign = -1
+ }
+
+ // peek first byte
+ when (c) {
+ CHAR_0 -> {
+ cursor++
+ if (cursor != limit) {
+ c = ary[cursor]
+ }
+ }
+ !in CHAR_0..CHAR_9 -> makeError(data, "Invalid Number", c)
+ else -> {
+ do {
+ val digit = c - CHAR_0
+ // double = 10.0 * double + digit
+ long = 10 * long + digit
+ digits++
+ cursor++
+ if (cursor == limit) break
+ c = ary[cursor]
+ } while (c in CHAR_0..CHAR_9)
+ }
+ }
+
+ var exponent = 0
+ // If we find '.' we need to convert to double
+ if (c == CHAR_DOT) {
+ useDouble = true
+ checkEOF(data, cursor)
+ c = ary[++cursor]
+ if (c < CHAR_0 || c > CHAR_9) {
+ makeError(data, "Invalid Number", c)
+ }
+ do {
+ // double = double * 10 + (tok - CHAR_0)
+ long = 10 * long + (c - CHAR_0)
+ digits++
+ --exponent
+ cursor++
+ if (cursor == limit) break
+ c = ary[cursor]
+ } while (c in CHAR_0..CHAR_9)
+ }
+
+ // If we find 'e' we need to convert to double
+ if (c == CHAR_e || c == CHAR_E) {
+ useDouble = true
+ ++cursor
+ checkEOF(data, cursor)
+ c = ary[cursor]
+ var negativeExponent = false
+ if (c == CHAR_MINUS) {
+ ++cursor
+ checkEOF(data, cursor)
+ negativeExponent = true
+ c = ary[cursor]
+ } else if (c == CHAR_PLUS) {
+ ++cursor
+ checkEOF(data, cursor)
+ c = ary[cursor]
+ }
+ if (c < CHAR_0 || c > CHAR_9) {
+ makeError(data, "Missing exponent", c)
+ }
+ var exp = 0
+ do {
+ val digit = c - CHAR_0
+ exp = 10 * exp + digit
+ ++cursor
+ if (cursor == limit) break
+ c = ary[cursor]
+ } while (c in CHAR_0..CHAR_9)
+
+ exponent += if (negativeExponent) -exp else exp
+ }
+
+ if (digits > 17 || exponent < -19 || exponent > 19) {
+ // if the float number is not simple enough
+ // we use language's Double parsing, which is slower but
+ // produce more expected results for extreme numbers.
+ val firstPos = readPos - 1
+ val str = data.getString(firstPos, cursor - firstPos)
+ if (useDouble) {
+ double = str.toDouble()
+ output[key] = double
+ } else {
+ long = str.toLong()
+ output[key] = long
+ }
+ } else {
+ // this happens on single numbers outside any object
+ // or array
+ if (useDouble || exponent != 0) {
+ double = if (long == 0L) 0.0 else long.toDouble() * 10.0.pow(exponent)
+ double *= sign
+ output[key] = double
+ } else {
+ long *= sign
+ output[key] = long
+ }
+ }
+ readPos = cursor
+ return if (useDouble) T_FLOAT else T_INT
+ }
+
+ private fun parseString(data: ReadBuffer, key: String?): FlexBufferType {
+ output[key] = readString(data)
+ return T_STRING
+ }
+
+ private fun readString(data: ReadBuffer): String {
+ val limit = data.limit
+ if (data is ArrayReadBuffer) {
+ val ary = data.data()
+ // enables range check elimination
+ return readString(data, limit) { ary[it] }
+ }
+ return readString(data, limit) { data[it] }
+ }
+
+ private inline fun readString(data: ReadBuffer, limit: Int, crossinline fetch: (Int) -> Byte): String {
+ var cursorPos = readPos
+ var foundEscape = false
+ var currentChar: Byte = 0
+ // we loop over every 4 bytes until find any non-plain char
+ while (limit - cursorPos >= 4) {
+ currentChar = fetch(cursorPos)
+ if (!isPlainStringChar(currentChar)) {
+ foundEscape = true
+ break
+ }
+ currentChar = fetch(cursorPos + 1)
+ if (!isPlainStringChar(currentChar)) {
+ cursorPos += 1
+ foundEscape = true
+ break
+ }
+ currentChar = fetch(cursorPos + 2)
+ if (!isPlainStringChar(currentChar)) {
+ cursorPos += 2
+ foundEscape = true
+ break
+ }
+ currentChar = fetch(cursorPos + 3)
+ if (!isPlainStringChar(currentChar)) {
+ cursorPos += 3
+ foundEscape = true
+ break
+ }
+ cursorPos += 4
+ }
+ if (!foundEscape) {
+ // if non-plain string char is not found we loop over
+ // the remaining bytes
+ while (true) {
+ if (cursorPos >= limit) {
+ error("Unexpected end of string")
+ }
+ currentChar = fetch(cursorPos)
+ if (!isPlainStringChar(currentChar)) {
+ break
+ }
+ ++cursorPos
+ }
+ }
+ if (currentChar == CHAR_DOUBLE_QUOTE) {
+ val str = data.getString(readPos, cursorPos - readPos)
+ readPos = cursorPos + 1
+ return str
+ }
+ if (currentChar in 0..0x1f) {
+ error("Illegal Codepoint")
+ } else {
+ // backslash or >0x7f
+ return readStringSlow(data, currentChar, cursorPos)
+ }
+ }
+
+ private fun readStringSlow(data: ReadBuffer, first: Byte, lastPos: Int): String {
+ var cursorPos = lastPos
+
+ var endOfString = lastPos
+ while (true) {
+ val pos = data.findFirst(CHAR_DOUBLE_QUOTE, endOfString)
+ when {
+ pos == -1 -> makeError(data, "Unexpected EOF, missing end of string '\"'", first)
+ data[pos - 1] == CHAR_BACKSLASH && data[pos - 2] != CHAR_BACKSLASH -> {
+ // here we are checking for double quotes preceded by backslash. eg \"
+ // we have to look past pos -2 to make sure that the backlash is not
+ // part of a previous escape, eg "\\"
+ endOfString = pos + 1
+ }
+ else -> {
+ endOfString = pos; break
+ }
+ }
+ }
+ // copy everything before the escape
+ val builder = StringBuilder(data.getString(readPos, lastPos - readPos))
+ while (true) {
+ when (val pos = data.findFirst(CHAR_BACKSLASH, cursorPos, endOfString)) {
+ -1 -> {
+ val doubleQuotePos = data.findFirst(CHAR_DOUBLE_QUOTE, cursorPos)
+ if (doubleQuotePos == -1) makeError(data, "Reached EOF before enclosing string", first)
+ val rest = data.getString(cursorPos, doubleQuotePos - cursorPos)
+ builder.append(rest)
+ readPos = doubleQuotePos + 1
+ return builder.toString()
+ }
+
+ else -> {
+ // we write everything up to \
+ builder.append(data.getString(cursorPos, pos - cursorPos))
+ val c = data[pos + 1]
+ builder.append(readEscapedChar(data, c, pos))
+ cursorPos = pos + if (c == CHAR_u) 6 else 2
+ }
+ }
+ }
+ }
+
+ private inline fun isPlainStringChar(c: Byte): Boolean {
+ val flags = parseFlags
+ // return c in 0x20..0x7f && c != 0x22.toByte() && c != 0x5c.toByte()
+ return (flags[c.toInt() and 0xFF] and 1) != 0.toByte()
+ }
+
+ private inline fun isWhitespace(c: Byte): Boolean {
+ val flags = parseFlags
+ // return c == '\r'.toByte() || c == '\n'.toByte() || c == '\t'.toByte() || c == ' '.toByte()
+ return (flags[c.toInt() and 0xFF] and 2) != 0.toByte()
+ }
+
+ private fun reset() {
+ readPos = 0
+ output.clear()
+ scopes.reset()
+ }
+
+ private fun nextToken(data: ReadBuffer): Token {
+ val scope = this.scopes.last
+
+ when (scope) {
+ SCOPE_ARRAY_EMPTY -> this.scopes.last = SCOPE_ARRAY_FILLED
+ SCOPE_ARRAY_FILLED -> {
+ when (val c = skipWhitespace(data)) {
+ CHAR_CLOSE_ARRAY -> return TOK_END_ARRAY
+ CHAR_COMMA -> Unit
+ else -> makeError(data, "Unfinished Array", c)
+ }
+ }
+ SCOPE_OBJ_EMPTY, SCOPE_OBJ_FILLED -> {
+ this.scopes.last = SCOPE_OBJ_KEY
+ // Look for a comma before the next element.
+ if (scope == SCOPE_OBJ_FILLED) {
+ when (val c = skipWhitespace(data)) {
+ CHAR_CLOSE_OBJECT -> return TOK_END_OBJECT
+ CHAR_COMMA -> Unit
+ else -> makeError(data, "Unfinished Object", c)
+ }
+ }
+ return when (val c = skipWhitespace(data)) {
+ CHAR_DOUBLE_QUOTE -> TOK_BEGIN_QUOTE
+ CHAR_CLOSE_OBJECT -> if (scope != SCOPE_OBJ_FILLED) {
+ TOK_END_OBJECT
+ } else {
+ makeError(data, "Expected Key", c)
+ }
+ else -> {
+ makeError(data, "Expected Key/Value", c)
+ }
+ }
+ }
+ SCOPE_OBJ_KEY -> {
+ this.scopes.last = SCOPE_OBJ_FILLED
+ when (val c = skipWhitespace(data)) {
+ CHAR_COLON -> Unit
+ else -> makeError(data, "Expect ${CHAR_COLON.print()}", c)
+ }
+ }
+ SCOPE_DOC_EMPTY -> this.scopes.last = SCOPE_DOC_FILLED
+ SCOPE_DOC_FILLED -> {
+ val c = skipWhitespace(data)
+ if (c != CHAR_EOF)
+ makeError(data, "Root object already finished", c)
+ return TOK_EOF
+ }
+ }
+
+ val c = skipWhitespace(data)
+ when (c) {
+ CHAR_CLOSE_ARRAY -> if (scope == SCOPE_ARRAY_EMPTY) return TOK_END_ARRAY
+ CHAR_COLON -> makeError(data, "Unexpected character", c)
+ CHAR_DOUBLE_QUOTE -> return TOK_BEGIN_QUOTE
+ CHAR_OPEN_ARRAY -> return TOK_BEGIN_ARRAY
+ CHAR_OPEN_OBJECT -> return TOK_BEGIN_OBJECT
+ CHAR_t -> {
+ checkEOF(data, readPos + 2)
+ // 0x65757274 is equivalent to ['t', 'r', 'u', 'e' ] as a 4 byte Int
+ if (data.getInt(readPos - 1) != 0x65757274) {
+ makeError(data, "Expecting keyword \"true\"", c)
+ }
+ readPos += 3
+ return TOK_TRUE
+ }
+ CHAR_n -> {
+ checkEOF(data, readPos + 2)
+ // 0x6c6c756e is equivalent to ['n', 'u', 'l', 'l' ] as a 4 byte Int
+ if (data.getInt(readPos - 1) != 0x6c6c756e) {
+ makeError(data, "Expecting keyword \"null\"", c)
+ }
+ readPos += 3
+ return TOK_NULL
+ }
+ CHAR_f -> {
+ checkEOF(data, readPos + 3)
+ // 0x65736c61 is equivalent to ['a', 'l', 's', 'e' ] as a 4 byte Int
+ if (data.getInt(readPos) != 0x65736c61) {
+ makeError(data, "Expecting keyword \"false\"", c)
+ }
+ readPos += 4
+ return TOK_FALSE
+ }
+ CHAR_0, CHAR_1, CHAR_2, CHAR_3, CHAR_4, CHAR_5,
+ CHAR_6, CHAR_7, CHAR_8, CHAR_9, CHAR_MINUS -> return TOK_NUMBER.also {
+ readPos-- // rewind one position so we don't lose first digit
+ }
+ }
+ makeError(data, "Expecting element", c)
+ }
+
+ // keeps increasing [readPos] until finds a non-whitespace byte
+ private inline fun skipWhitespace(data: ReadBuffer): Byte {
+ val limit = data.limit
+ if (data is ArrayReadBuffer) {
+ // enables range check elimination
+ val ary = data.data()
+ return skipWhitespace(limit) { ary[it] }
+ }
+ return skipWhitespace(limit) { data[it] }
+ }
+
+ private inline fun skipWhitespace(limit: Int, crossinline fetch: (Int) -> Byte): Byte {
+ var pos = readPos
+ while (pos < limit) {
+ val d = fetch(pos++)
+ if (!isWhitespace(d)) {
+ readPos = pos
+ return d
+ }
+ }
+ readPos = limit
+ return CHAR_EOF
+ }
+
+ // byte1 is expected to be first char before `\`
+ private fun readEscapedChar(data: ReadBuffer, byte1: Byte, cursorPos: Int): Char {
+ return when (byte1) {
+ CHAR_u -> {
+ checkEOF(data, cursorPos + 1 + 4)
+ var result: Char = 0.toChar()
+ var i = cursorPos + 2 // cursorPos is on '\\', cursorPos + 1 is 'u'
+ val end = i + 4
+ while (i < end) {
+ val part: Byte = data[i]
+ result = (result.toInt() shl 4).toChar()
+ result += when (part) {
+ in CHAR_0..CHAR_9 -> part - CHAR_0
+ in CHAR_a..CHAR_f -> part - CHAR_a + 10
+ in CHAR_A..CHAR_F -> part - CHAR_A + 10
+ else -> makeError(data, "Invalid utf8 escaped character", -1)
+ }
+ i++
+ }
+ result
+ }
+ CHAR_b -> '\b'
+ CHAR_t -> '\t'
+ CHAR_r -> '\r'
+ CHAR_n -> '\n'
+ CHAR_f -> 12.toChar() // '\f'
+ CHAR_DOUBLE_QUOTE, CHAR_BACKSLASH, CHAR_FORWARDSLASH -> byte1.toChar()
+ else -> makeError(data, "Invalid escape sequence.", byte1)
+ }
+ }
+
+ private fun Byte.print(): String = when (this) {
+ in 0x21..0x7E -> "'${this.toChar()}'" // visible ascii chars
+ CHAR_EOF -> "EOF"
+ else -> "'0x${this.toString(16)}'"
+ }
+
+ private inline fun makeError(data: ReadBuffer, msg: String, tok: Byte? = null): Nothing {
+ val (line, column) = calculateErrorPosition(data, readPos)
+ if (tok != null) {
+ error("Error At ($line, $column): $msg, got ${tok.print()}")
+ } else {
+ error("Error At ($line, $column): $msg")
+ }
+ }
+
+ private inline fun makeError(data: ReadBuffer, msg: String, tok: Token): Nothing {
+ val (line, column) = calculateErrorPosition(data, readPos)
+ error("Error At ($line, $column): $msg, got ${tok.print()}")
+ }
+
+ private inline fun checkEOF(data: ReadBuffer, pos: Int) {
+ if (pos >= data.limit)
+ makeError(data, "Unexpected end of file", -1)
+ }
+
+ private fun calculateErrorPosition(data: ReadBuffer, endPos: Int): Pair<Int, Int> {
+ var line = 1
+ var column = 1
+ var current = 0
+ while (current < endPos - 1) {
+ if (data[current++] == CHAR_NEWLINE) {
+ ++line
+ column = 1
+ } else {
+ ++column
+ }
+ }
+ return Pair(line, column)
+ }
+}
+
+internal inline fun Int.toPaddedHex(): String = "\\u${this.toString(16).padStart(4, '0')}"
+
+private inline fun ReadWriteBuffer.jsonEscape(data: ReadBuffer, start: Int, size: Int) {
+ val replacements = JSON_ESCAPE_CHARS
+ put(CHAR_DOUBLE_QUOTE)
+ var last = start
+ val length: Int = size
+ val ary = data.data()
+ for (i in start until start + length) {
+ val c = ary[i].toUByte()
+ var replacement: ByteArray?
+ if (c.toInt() < 128) {
+ replacement = replacements[c.toInt()]
+ if (replacement == null) {
+ continue
+ }
+ } else {
+ continue
+ }
+ if (last < i) {
+ put(ary, last, i - last)
+ }
+ put(replacement, 0, replacement.size)
+ last = i + 1
+ }
+ if (last < (last + length)) {
+ put(ary, last, (start + length) - last)
+ }
+ put(CHAR_DOUBLE_QUOTE)
+}
+
+// Following escape strategy defined in RFC7159.
+private val JSON_ESCAPE_CHARS: Array<ByteArray?> = arrayOfNulls<ByteArray>(128).apply {
+ this['\n'.toInt()] = "\\n".encodeToByteArray()
+ this['\t'.toInt()] = "\\t".encodeToByteArray()
+ this['\r'.toInt()] = "\\r".encodeToByteArray()
+ this['\b'.toInt()] = "\\b".encodeToByteArray()
+ this[0x0c] = "\\f".encodeToByteArray()
+ this['"'.toInt()] = "\\\"".encodeToByteArray()
+ this['\\'.toInt()] = "\\\\".encodeToByteArray()
+ for (i in 0..0x1f) {
+ this[i] = "\\u${i.toPaddedHex()}".encodeToByteArray()
+ }
+}
+
+// Scope is used to the define current space that the scanner is operating.
+private inline class Scope(val id: Int)
+private val SCOPE_DOC_EMPTY = Scope(0)
+private val SCOPE_DOC_FILLED = Scope(1)
+private val SCOPE_OBJ_EMPTY = Scope(2)
+private val SCOPE_OBJ_KEY = Scope(3)
+private val SCOPE_OBJ_FILLED = Scope(4)
+private val SCOPE_ARRAY_EMPTY = Scope(5)
+private val SCOPE_ARRAY_FILLED = Scope(6)
+
+// Keeps the stack state of the scopes being scanned. Currently defined to have a
+// max stack size of 22, as per tests cases defined in http://json.org/JSON_checker/
+private class ScopeStack(
+ private val ary: IntArray = IntArray(22) { SCOPE_DOC_EMPTY.id },
+ var lastPos: Int = 0
+) {
+ var last: Scope
+ get() = Scope(ary[lastPos])
+ set(x) {
+ ary[lastPos] = x.id
+ }
+
+ fun reset() {
+ lastPos = 0
+ ary[0] = SCOPE_DOC_EMPTY.id
+ }
+
+ fun pop(): Scope {
+ // println("Popping: ${last.print()}")
+ return Scope(ary[lastPos--])
+ }
+
+ fun push(scope: Scope): Scope {
+ if (lastPos == ary.size - 1)
+ error("Too much nesting reached. Max nesting is ${ary.size} levels")
+ // println("PUSHING : ${scope.print()}")
+ ary[++lastPos] = scope.id
+ return scope
+ }
+}
+
+private inline class Token(val id: Int) {
+ fun print(): String = when (this) {
+ TOK_EOF -> "TOK_EOF"
+ TOK_NONE -> "TOK_NONE"
+ TOK_BEGIN_OBJECT -> "TOK_BEGIN_OBJECT"
+ TOK_END_OBJECT -> "TOK_END_OBJECT"
+ TOK_BEGIN_ARRAY -> "TOK_BEGIN_ARRAY"
+ TOK_END_ARRAY -> "TOK_END_ARRAY"
+ TOK_NUMBER -> "TOK_NUMBER"
+ TOK_TRUE -> "TOK_TRUE"
+ TOK_FALSE -> "TOK_FALSE"
+ TOK_NULL -> "TOK_NULL"
+ TOK_BEGIN_QUOTE -> "TOK_BEGIN_QUOTE"
+ else -> this.toString()
+ }
+}
+
+private val TOK_EOF = Token(-1)
+private val TOK_NONE = Token(0)
+private val TOK_BEGIN_OBJECT = Token(1)
+private val TOK_END_OBJECT = Token(2)
+private val TOK_BEGIN_ARRAY = Token(3)
+private val TOK_END_ARRAY = Token(4)
+private val TOK_NUMBER = Token(5)
+private val TOK_TRUE = Token(6)
+private val TOK_FALSE = Token(7)
+private val TOK_NULL = Token(8)
+private val TOK_BEGIN_QUOTE = Token(9)
+
+private const val CHAR_NEWLINE = '\n'.toByte()
+private const val CHAR_OPEN_OBJECT = '{'.toByte()
+private const val CHAR_COLON = ':'.toByte()
+private const val CHAR_CLOSE_OBJECT = '}'.toByte()
+private const val CHAR_OPEN_ARRAY = '['.toByte()
+private const val CHAR_CLOSE_ARRAY = ']'.toByte()
+private const val CHAR_DOUBLE_QUOTE = '"'.toByte()
+private const val CHAR_BACKSLASH = '\\'.toByte()
+private const val CHAR_FORWARDSLASH = '/'.toByte()
+private const val CHAR_f = 'f'.toByte()
+private const val CHAR_a = 'a'.toByte()
+private const val CHAR_r = 'r'.toByte()
+private const val CHAR_t = 't'.toByte()
+private const val CHAR_n = 'n'.toByte()
+private const val CHAR_b = 'b'.toByte()
+private const val CHAR_e = 'e'.toByte()
+private const val CHAR_E = 'E'.toByte()
+private const val CHAR_u = 'u'.toByte()
+private const val CHAR_A = 'A'.toByte()
+private const val CHAR_F = 'F'.toByte()
+private const val CHAR_EOF = (-1).toByte()
+private const val CHAR_COMMA = ','.toByte()
+private const val CHAR_0 = '0'.toByte()
+private const val CHAR_1 = '1'.toByte()
+private const val CHAR_2 = '2'.toByte()
+private const val CHAR_3 = '3'.toByte()
+private const val CHAR_4 = '4'.toByte()
+private const val CHAR_5 = '5'.toByte()
+private const val CHAR_6 = '6'.toByte()
+private const val CHAR_7 = '7'.toByte()
+private const val CHAR_8 = '8'.toByte()
+private const val CHAR_9 = '9'.toByte()
+private const val CHAR_MINUS = '-'.toByte()
+private const val CHAR_PLUS = '+'.toByte()
+private const val CHAR_DOT = '.'.toByte()
+
+// This template utilizes the One Definition Rule to create global arrays in a
+// header. As seen in:
+// https://github.com/chadaustin/sajson/blob/master/include/sajson.h
+// bit 0 (1) - set if: plain ASCII string character
+// bit 1 (2) - set if: whitespace
+// bit 4 (0x10) - set if: 0-9 e E .
+private val parseFlags = byteArrayOf(
+// 0 1 2 3 4 5 6 7 8 9 A B C D E F
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 2, 0, 0, // 0
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1
+ 3, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0x11, 1, // 2
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 1, 1, 1, 1, 1, 1, // 3
+ 1, 1, 1, 1, 1, 0x11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 5
+ 1, 1, 1, 1, 1, 0x11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
+
+ // 128-255
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+)
--- /dev/null
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.flatbuffers.kotlin
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class JSONTest {
+
+ @Test
+ fun parse2Test() {
+ val dataStr = """
+ { "myKey" : [1, "yay"] }
+ """.trimIndent()
+ val data = dataStr.encodeToByteArray()
+ val buffer = ArrayReadWriteBuffer(data, writePosition = data.size)
+ val parser = JSONParser()
+ val root = parser.parse(buffer)
+ println(root.toJson())
+ }
+
+ @Test
+ fun parseSample() {
+ val dataStr = """
+ {
+ "ary" : [1, 2, 3],
+ "boolean_false": false,
+"boolean_true": true, "double": 1.2E33,
+ "hello":"world"
+ ,"interesting": "value",
+
+ "null_value": null,
+
+
+ "object" : {
+ "field1": "hello"
+ }
+ }
+ """
+ val data = dataStr.encodeToByteArray()
+ val root = JSONParser().parse(ArrayReadWriteBuffer(data, writePosition = data.size))
+ println(root.toJson())
+ val map = root.toMap()
+
+ val minified = data.filterNot { it == ' '.toByte() || it == '\n'.toByte() }.toByteArray().decodeToString()
+ assertEquals(8, map.size)
+ assertEquals("world", map["hello"].toString())
+ assertEquals("value", map["interesting"].toString())
+ assertEquals(12e32, map["double"].toDouble())
+ assertArrayEquals(intArrayOf(1, 2, 3), map["ary"].toIntArray())
+ assertEquals(true, map["boolean_true"].toBoolean())
+ assertEquals(false, map["boolean_false"].toBoolean())
+ assertEquals(true, map["null_value"].isNull)
+ assertEquals("hello", map["object"]["field1"].toString())
+
+ val obj = map["object"]
+ assertEquals(true, obj.isMap)
+ assertEquals("{\"field1\":\"hello\"}", obj.toJson())
+ assertEquals(minified, root.toJson())
+ }
+
+ @Test
+ fun testDoubles() {
+ val values = arrayOf(
+ "-0.0",
+ "1.0",
+ "1.7976931348613157",
+ "0.0",
+ "-0.5",
+ "3.141592653589793",
+ "2.718281828459045E-3",
+ "2.2250738585072014E-308",
+ "4.9E-15",
+ )
+ val parser = JSONParser()
+ assertEquals(-0.0, parser.parse(values[0]).toDouble())
+ assertEquals(1.0, parser.parse(values[1]).toDouble())
+ assertEquals(1.7976931348613157, parser.parse(values[2]).toDouble())
+ assertEquals(0.0, parser.parse(values[3]).toDouble())
+ assertEquals(-0.5, parser.parse(values[4]).toDouble())
+ assertEquals(3.141592653589793, parser.parse(values[5]).toDouble())
+ assertEquals(2.718281828459045e-3, parser.parse(values[6]).toDouble())
+ assertEquals(2.2250738585072014E-308, parser.parse(values[7]).toDouble())
+ assertEquals(4.9E-15, parser.parse(values[8]).toDouble())
+ }
+
+ @Test
+ fun testInts() {
+ val values = arrayOf(
+ "-0",
+ "0",
+ "-1",
+ "${Int.MAX_VALUE}",
+ "${Int.MIN_VALUE}",
+ "${Long.MAX_VALUE}",
+ "${Long.MIN_VALUE}",
+ )
+ val parser = JSONParser()
+
+ assertEquals(parser.parse(values[0]).toInt(), 0)
+ assertEquals(parser.parse(values[1]).toInt(), 0)
+ assertEquals(parser.parse(values[2]).toInt(), -1)
+ assertEquals(parser.parse(values[3]).toInt(), Int.MAX_VALUE)
+ assertEquals(parser.parse(values[4]).toInt(), Int.MIN_VALUE)
+ assertEquals(parser.parse(values[5]).toLong(), Long.MAX_VALUE)
+ assertEquals(parser.parse(values[6]).toLong(), Long.MIN_VALUE)
+ }
+
+ @Test
+ fun testBooleansAndNull() {
+ val values = arrayOf(
+ "true",
+ "false",
+ "null"
+ )
+ val parser = JSONParser()
+
+ assertEquals(true, parser.parse(values[0]).toBoolean())
+ assertEquals(false, parser.parse(values[1]).toBoolean())
+ assertEquals(true, parser.parse(values[2]).isNull)
+ }
+
+ @Test
+ fun testStrings() {
+ val values = arrayOf(
+ "\"\"",
+ "\"a\"",
+ "\"hello world\"",
+ "\"\\\"\\\\\\/\\b\\f\\n\\r\\t cool\"",
+ "\"\\u0000\"",
+ "\"\\u0021\"",
+ "\"hell\\u24AC\\n\\ro wor \\u0021 ld\"",
+ "\"\\/_\\\\_\\\"_\\uCAFE\\uBABE\\uAB98\\uFCDE\\ubcda\\uef4A\\b\\n\\r\\t`1~!@#\$%^&*()_+-=[]{}|;:',./<>?\"",
+ )
+ val parser = JSONParser()
+
+ // empty
+ var ref = parser.parse(values[0])
+ assertEquals(true, ref.isString)
+ assertEquals("", ref.toString())
+ // a
+ ref = parser.parse(values[1])
+ assertEquals(true, ref.isString)
+ assertEquals("a", ref.toString())
+ // hello world
+ ref = parser.parse(values[2])
+ assertEquals(true, ref.isString)
+ assertEquals("hello world", ref.toString())
+ // "\\\"\\\\\\/\\b\\f\\n\\r\\t\""
+ ref = parser.parse(values[3])
+ assertEquals(true, ref.isString)
+ assertEquals("\"\\/\b${12.toChar()}\n\r\t cool", ref.toString())
+ // 0
+ ref = parser.parse(values[4])
+ assertEquals(true, ref.isString)
+ assertEquals(0.toChar().toString(), ref.toString())
+ // u0021
+ ref = parser.parse(values[5])
+ assertEquals(true, ref.isString)
+ assertEquals(0x21.toChar().toString(), ref.toString())
+ // "\"hell\\u24AC\\n\\ro wor \\u0021 ld\"",
+ ref = parser.parse(values[6])
+ assertEquals(true, ref.isString)
+ assertEquals("hell${0x24AC.toChar()}\n\ro wor ${0x21.toChar()} ld", ref.toString())
+
+ ref = parser.parse(values[7])
+ println(ref.toJson())
+ assertEquals(true, ref.isString)
+ assertEquals("/_\\_\"_쫾몾ꮘﳞ볚\b\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?", ref.toString())
+ }
+
+ @Test
+ fun testUnicode() {
+ // took from test/unicode_test.json
+ val data = """
+ {
+ "name": "unicode_test",
+ "testarrayofstring": [
+ "Цлїςσδε",
+ "ﾌﾑｱﾑｶﾓｹﾓ",
+ "フムヤムカモケモ",
+ "㊀㊁㊂㊃㊄",
+ "☳☶☲",
+ "𡇙𝌆"
+ ],
+ "testarrayoftables": [
+ {
+ "name": "Цлїςσδε"
+ },
+ {
+ "name": "☳☶☲"
+ },
+ {
+ "name": "フムヤムカモケモ"
+ },
+ {
+ "name": "㊀㊁㊂㊃㊄"
+ },
+ {
+ "name": "ﾌﾑｱﾑｶﾓｹﾓ"
+ },
+ {
+ "name": "𡇙𝌆"
+ }
+ ]
+ }
+ """.trimIndent()
+ val parser = JSONParser()
+ val ref = parser.parse(data)
+
+ // name
+ assertEquals(3, ref.toMap().size)
+ assertEquals("unicode_test", ref["name"].toString())
+ // testarrayofstring
+ assertEquals(6, ref["testarrayofstring"].toVector().size)
+ assertEquals("Цлїςσδε", ref["testarrayofstring"][0].toString())
+ assertEquals("ﾌﾑｱﾑｶﾓｹﾓ", ref["testarrayofstring"][1].toString())
+ assertEquals("フムヤムカモケモ", ref["testarrayofstring"][2].toString())
+ assertEquals("㊀㊁㊂㊃㊄", ref["testarrayofstring"][3].toString())
+ assertEquals("☳☶☲", ref["testarrayofstring"][4].toString())
+ assertEquals("𡇙𝌆", ref["testarrayofstring"][5].toString())
+ // testarrayoftables
+ assertEquals(6, ref["testarrayoftables"].toVector().size)
+ assertEquals("Цлїςσδε", ref["testarrayoftables"][0]["name"].toString())
+ assertEquals("☳☶☲", ref["testarrayoftables"][1]["name"].toString())
+ assertEquals("フムヤムカモケモ", ref["testarrayoftables"][2]["name"].toString())
+ assertEquals("㊀㊁㊂㊃㊄", ref["testarrayoftables"][3]["name"].toString())
+ assertEquals("ﾌﾑｱﾑｶﾓｹﾓ", ref["testarrayoftables"][4]["name"].toString())
+ assertEquals("𡇙𝌆", ref["testarrayoftables"][5]["name"].toString())
+ }
+
+ @Test
+ fun testArrays() {
+ val values = arrayOf(
+ "[]",
+ "[1]",
+ "[0,1, 2,3 , 4 ]",
+ "[1.0, 2.2250738585072014E-308, 4.9E-320]",
+ "[1.0, 2, \"hello world\"] ",
+ "[ 1.1, 2, [ \"hello\" ] ]",
+ "[[[1]]]"
+ )
+ val parser = JSONParser()
+
+ // empty
+ var ref = parser.parse(values[0])
+ assertEquals(true, ref.isVector)
+ assertEquals(0, parser.parse(values[0]).toVector().size)
+ // single
+ ref = parser.parse(values[1])
+ assertEquals(true, ref.isTypedVector)
+ assertEquals(1, ref[0].toInt())
+ // ints
+ ref = parser.parse(values[2])
+ assertEquals(true, ref.isTypedVector)
+ assertEquals(T_VECTOR_INT, ref.type)
+ assertEquals(5, ref.toVector().size)
+ for (i in 0..4) {
+ assertEquals(i, ref[i].toInt())
+ }
+ // floats
+ ref = parser.parse(values[3])
+ assertEquals(true, ref.isTypedVector)
+ assertEquals(T_VECTOR_FLOAT, ref.type)
+ assertEquals(3, ref.toVector().size)
+ assertEquals(1.0, ref[0].toDouble())
+ assertEquals(2.2250738585072014E-308, ref[1].toDouble())
+ assertEquals(4.9E-320, ref[2].toDouble())
+ // mixed
+ ref = parser.parse(values[4])
+ assertEquals(false, ref.isTypedVector)
+ assertEquals(T_VECTOR, ref.type)
+ assertEquals(1.0, ref[0].toDouble())
+ assertEquals(2, ref[1].toInt())
+ assertEquals("hello world", ref[2].toString())
+ // nester array
+ ref = parser.parse(values[5])
+ assertEquals(false, ref.isTypedVector)
+ assertEquals(T_VECTOR, ref.type)
+ assertEquals(1.1, ref[0].toDouble())
+ assertEquals(2, ref[1].toInt())
+ assertEquals("hello", ref[2][0].toString())
+ }
+
+ /**
+ * Several test cases provided by json.org
+ * For more details, see: http://json.org/JSON_checker/, with only
+ * one exception. Single strings are considered accepted, whereas on
+ * the test suit is should fail.
+ */
+ @Test
+ fun testParseMustFail() {
+ val failList = listOf(
+ "[\"Unclosed array\"",
+ "{unquoted_key: \"keys must be quoted\"}",
+ "[\"extra comma\",]",
+ "[\"double extra comma\",,]",
+ "[ , \"<-- missing value\"]",
+ "[\"Comma after the close\"],",
+ "[\"Extra close\"]]",
+ "{\"Extra comma\": true,}",
+ "{\"Extra value after close\": true} \"misplaced quoted value\"",
+ "{\"Illegal expression\": 1 + 2}",
+ "{\"Illegal invocation\": alert()}",
+ "{\"Numbers cannot have leading zeroes\": 013}",
+ "{\"Numbers cannot be hex\": 0x14}",
+ "[\"Illegal backslash escape: \\x15\"]",
+ "[\\naked]",
+ "[\"Illegal backslash escape: \\017\"]",
+ "[[[[[[[[[[[[[[[[[[[[[[[\"Too deep\"]]]]]]]]]]]]]]]]]]]]]]]",
+ "{\"Missing colon\" null}",
+ "{\"Double colon\":: null}",
+ "{\"Comma instead of colon\", null}",
+ "[\"Colon instead of comma\": false]",
+ "[\"Bad value\", truth]",
+ "['single quote']",
+ "[\"\ttab\tcharacter\tin\tstring\t\"]",
+ "[\"tab\\ character\\ in\\ string\\ \"]",
+ "[\"line\nbreak\"]",
+ "[\"line\\\nbreak\"]",
+ "[0e]",
+ "[0e+]",
+ "[0e+-1]",
+ "{\"Comma instead if closing brace\": true,",
+ "[\"mismatch\"}"
+ )
+ for (data in failList) {
+ try {
+ JSONParser().parse(ArrayReadBuffer(data.encodeToByteArray()))
+ assertTrue(false, "SHOULD NOT PASS: $data")
+ } catch (e: IllegalStateException) {
+ println("FAIL $e")
+ }
+ }
+ }
+
+ @Test
+ fun testParseMustPass() {
+ val passList = listOf(
+ "[\n" +
+ " \"JSON Test Pattern pass1\",\n" +
+ " {\"object with 1 member\":[\"array with 1 element\"]},\n" +
+ " {},\n" +
+ " [],\n" +
+ " -42,\n" +
+ " true,\n" +
+ " false,\n" +
+ " null,\n" +
+ " {\n" +
+ " \"integer\": 1234567890,\n" +
+ " \"real\": -9876.543210,\n" +
+ " \"e\": 0.123456789e-12,\n" +
+ " \"E\": 1.234567890E+34,\n" +
+ " \"\": 23456789012E66,\n" +
+ " \"zero\": 0,\n" +
+ " \"one\": 1,\n" +
+ " \"space\": \" \",\n" +
+ " \"quote\": \"\\\"\",\n" +
+ " \"backslash\": \"\\\\\",\n" +
+ " \"controls\": \"\\b\\f\\n\\r\\t\",\n" +
+ " \"slash\": \"/ & \\/\",\n" +
+ " \"alpha\": \"abcdefghijklmnopqrstuvwyz\",\n" +
+ " \"ALPHA\": \"ABCDEFGHIJKLMNOPQRSTUVWYZ\",\n" +
+ " \"digit\": \"0123456789\",\n" +
+ " \"0123456789\": \"digit\",\n" +
+ " \"special\": \"`1~!@#\$%^&*()_+-={':[,]}|;.</>?\",\n" +
+ " \"hex\": \"\\u0123\\u4567\\u89AB\\uCDEF\\uabcd\\uef4A\",\n" +
+ " \"true\": true,\n" +
+ " \"false\": false,\n" +
+ " \"null\": null,\n" +
+ " \"array\":[ ],\n" +
+ " \"object\":{ },\n" +
+ " \"address\": \"50 St. James Street\",\n" +
+ " \"url\": \"http://www.JSON.org/\",\n" +
+ " \"comment\": \"// /* <!-- --\",\n" +
+ " \"# -- --> */\": \" \",\n" +
+ " \" s p a c e d \" :[1,2 , 3\n" +
+ "\n" +
+ ",\n" +
+ "\n" +
+ "4 , 5 , 6 ,7 ],\"compact\":[1,2,3,4,5,6,7],\n" +
+ " \"jsontext\": \"{\\\"object with 1 member\\\":[\\\"array with 1 element\\\"]}\",\n" +
+ " \"quotes\": \"" \\u0022 %22 0x22 034 "\",\n" +
+ " \"\\/\\\\\\\"\\uCAFE\\uBABE\\uAB98\\uFCDE\\ubcda\\uef4A\\b\\f\\n\\r\\t`1~!@#\$%^&*()_+-=[]{}|;:',./<>?\"\n" +
+ ": \"A key can be any string\"\n" +
+ " },\n" +
+ " 0.5 ,98.6\n" +
+ ",\n" +
+ "99.44\n" +
+ ",\n" +
+ "\n" +
+ "1066,\n" +
+ "1e1,\n" +
+ "0.1e1,\n" +
+ "1e-1,\n" +
+ "1e00,2e+00,2e-00\n" +
+ ",\"rosebud\"]",
+ "{\n" +
+ " \"JSON Test Pattern pass3\": {\n" +
+ " \"The outermost value\": \"must be an object or array.\",\n" +
+ " \"In this test\": \"It is an object.\"\n" +
+ " }\n" +
+ "}",
+ "[[[[[[[[[[[[[[[[[[[\"Not too deep\"]]]]]]]]]]]]]]]]]]]",
+ )
+ for (data in passList) {
+ JSONParser().parse(ArrayReadBuffer(data.encodeToByteArray()))
+ }
+ }
+}
projects / platform / upstream / flatbuffers.git / commitdiff