ideal • runtime • formats • test_json

private json parser make parser()

return json parser • new(unicode handler • instance)

test case test tokenizer()

parser : make parser()

words : parser • test tokenize(" \"foo\" \"bar\" ")

assert words • size == 2

assert words[0] == "foo"

assert words[1] == "bar"

words2 : parser • test tokenize("[ \"foo\" , \"bar\", -68 ] ")

assert words2 • size == 7

assert words2[0] == json token • OPEN BRACKET

assert words2[1] == "foo"

assert words2[2] == json token • COMMA

assert words2[3] == "bar"

assert words2[4] == json token • COMMA

assert words2[5] == -68

assert words2[6] == json token • CLOSE BRACKET

words3 : parser • test tokenize("{ \"foo\" : \"bar\", \"baz\":68, \"x\":\"\\\"y\\\"\" } ")

assert words3 • size == 13

assert words3[0] == json token • OPEN BRACE

assert words3[1] == "foo"

assert words3[2] == json token • COLON

assert words3[3] == "bar"

assert words3[4] == json token • COMMA

assert words3[5] == "baz"

assert words3[6] == json token • COLON

assert words3[7] == 68

assert words3[8] == json token • COMMA

assert words3[9] == "x"

assert words3[10] == json token • COLON

assert words3[11] == "\"y\""

assert words3[12] == json token • CLOSE BRACE

words4 : parser • test tokenize(" \"special: \\\\ \\u0066\\u006f\\u006f\" ")

assert words4 • size == 1

assert words4[0] == "special: \\ foo"

words5 : parser • test tokenize("[ true , false, null ] ")

assert words5 • size == 7

assert words5[0] == json token • OPEN BRACKET

w51 : words5[1]

assert w51 !> boolean

assert words5[2] == json token • COMMA

w53 : words5[3]

assert !(w53 !> boolean)

assert words5[4] == json token • COMMA

w55 : words5[5]

assert (w55 !> value) is null

assert words5[6] == json token • CLOSE BRACKET

test case test parser()

parser : make parser()

parsed0 : parser • parse(" \"foo\" ")

assert parsed0 == "foo"

parsed1 : parser • parse(" 68 ")

assert parsed1 == 68

parsed2 : parser • parse(" false ")

assert (parsed2 !> boolean) == false

parsed3 : parser • parse("{ \"foo\" : \"bar\", \"baz\":68 } ") !> readonly dictionary[string, readonly value]

assert parsed3 • size == 2

assert parsed3 • get("foo") == "bar"

assert parsed3 • get("baz") == 68

parsed4 : parser • parse("[ \"foo\" , \"bar\", -68 ] ") !> readonly list[readonly value]

assert parsed4 • size == 3

assert parsed4[0] == "foo"

assert parsed4[1] == "bar"

assert parsed4[2] == -68

parsed5 : parser • parse("{ \"foo\" : [ \"bar\", true ],\"baz\":-68 } ") !> readonly dictionary[string, readonly value]

assert parsed5 • size == 2

the object : parsed5 • get("foo") !> readonly list[readonly value]

assert the object[0] == "bar"

assert (the object[1] !> boolean) == true

assert parsed5 • get("baz") == -68