dymokomi/luce-browser-foundation
Source of release 0.6.0
0.6.0 / src / ak / tests_json_2.lucb
#==============================================================================================
#
# tests_json_2 - tests of JsonArray, JsonValue conversions and invalid input
#
# DESCRIPTION:
# The second half of the port of Tests/AK/TestJSON.cpp (Ladybird 47c82b38d0); the
# helpers are tests_json's.
#
#==============================================================================================
# mark: JsonArray ===============================================================================
test "json_array_is_empty":
var json_value = parse_json("[]")
var array = json_array_clone(json_value2_as_array(&json_value))
assert(json_array_is_empty(&array))
json_value = parse_json("[1, 2]")
array = json_array_clone(json_value2_as_array(&json_value))
assert(not json_array_is_empty(&array))
## setup_json_array: [1, 2, "WHF", 802.11, 16].
func setup_json_array() -> JsonArray:
var json_value = parse_json("[1, 2, \"WHF\", 802.11, 16]")
return json_array_clone(json_value2_as_array(&json_value))
test "json_array_size":
var array = setup_json_array()
assert(json_array_size(&array) == 5)
var empty = parse_json("[]")
array = json_array_clone(json_value2_as_array(&empty))
assert(json_array_size(&array) == 0)
test "json_array_at":
let array = setup_json_array()
let element = json_array_at_const(&array, 1)
assert(json_value2_as_integer_u8(element) == 2)
test "json_array_subscript_operator":
let array = setup_json_array()
let element = json_array_at_const_2(&array, 1)
assert(json_value2_as_integer_u8(element) == 2)
test "json_array_take":
var array = setup_json_array()
let element = json_array_take(&array, 2)
assert(json_array_size(&array) == 4)
assert(text_of_string(json_value2_as_string(&element)) == "WHF")
test "json_array_must_append":
var array = setup_json_array()
json_array_must_append(&array, parse_json("32"))
assert(json_array_size(&array) == 6)
assert(json_value2_as_integer_u8(json_array_at_const(&array, json_array_size(&array) - 1)) == 32)
test "json_array_try_append":
var array = setup_json_array()
json_array_append(&array, parse_json("32")) else trap("MUST")
assert(json_array_size(&array) == 6)
assert(json_value2_as_integer_u8(json_array_at_const(&array, json_array_size(&array) - 1)) == 32)
test "json_array_clear":
var array = setup_json_array()
json_array_clear(&array)
assert(json_array_is_empty(&array))
test "json_array_set":
var array = setup_json_array()
json_array_set(&array, 1, parse_json("-32"))
assert(json_array_size(&array) == 5)
assert(json_value2_as_integer_i8(json_array_at_const(&array, 1)) == -32)
test "json_array_ensure_capacity":
var array = setup_json_array()
let new_capacity: usize = 16
json_array_ensure_capacity(&array, new_capacity)
assert(vector_capacity(json_array_values_const(&array)) == new_capacity)
## The counting lambda of json_array_for_each: `context` is the count.
func count_json_array_element(context: void*?, value: const JsonValue2*):
let count = (usize*)(context else trap("VERIFY_NOT_REACHED"))
*count += 1
assert((usize)json_value2_as_integer_u8(value) == *count)
test "json_array_for_each":
var json_value = parse_json("[1, 2, 3, 4]")
let array = json_array_clone(json_value2_as_array(&json_value))
var count: usize = 0
json_array_for_each_const(&array, count_json_array_element, &count)
assert(json_array_size(&array) == count)
test "json_array_serialized":
let raw_json = "[\"Hello\",2,3.14,4,\"World\"]"
var json_value = parse_json(raw_json)
let array = json_array_clone(json_value2_as_array(&json_value))
let serialized_json = json_array_serialized(&array)
assert(text_of_string(serialized_json) == raw_json)
test "json_array_serialize":
let raw_json = "[\"Hello\",2,3.14,4,\"World\"]"
var json_value = parse_json(raw_json)
let array = json_array_clone(json_value2_as_array(&json_value))
var builder: StringBuilder
string_builder_construct(&builder)
json_array_serialize(&array, &builder)
assert(text_of(string_builder_string_view(&builder)) == raw_json)
test "json_array_values":
var json_value = parse_json("[1, 2, 3, 4]")
let array = json_array_clone(json_value2_as_array(&json_value))
let values = json_array_values_const(&array)
assert(vector_size(values) == 4)
for i in 0..<vector_size(values):
assert((usize)json_value2_as_integer_u8(json_array_at_const(&array, i)) == i + 1)
## check_is_valid_for_all_types of json_value_as_integer.
func check_is_valid_for_all_types(value: const JsonValue2*):
assert(json_value2_is_integer_u8(value))
assert(json_value2_as_integer_u8(value) == 42)
assert(json_value2_is_integer_u16(value))
assert(json_value2_as_integer_u16(value) == 42)
assert(json_value2_is_integer_u32(value))
assert(json_value2_as_integer_u32(value) == 42)
assert(json_value2_is_integer_u64(value))
assert(json_value2_as_integer_u64(value) == 42)
assert(json_value2_is_integer_i8(value))
assert(json_value2_as_integer_i8(value) == 42)
assert(json_value2_is_integer_i16(value))
assert(json_value2_as_integer_i16(value) == 42)
assert(json_value2_is_integer_i32(value))
assert(json_value2_as_integer_i32(value) == 42)
assert(json_value2_is_integer_i64(value))
assert(json_value2_as_integer_i64(value) == 42)
test "json_value_as_integer":
# is_integer() should validate based on the value, not the underlying type.
var value_int = json_value2_create()
json_value2_construct_i32(&value_int, 42)
var value_unsigned = json_value2_create()
json_value2_construct_u32(&value_unsigned, 42)
var value_long = json_value2_create()
json_value2_construct_i64(&value_long, 42)
var value_long_unsigned = json_value2_create()
json_value2_construct_u64(&value_long_unsigned, 42)
var value_long_long = json_value2_create()
json_value2_construct_i64_2(&value_long_long, 42)
var value_long_long_unsigned = json_value2_create()
json_value2_construct_u64_2(&value_long_long_unsigned, 42)
check_is_valid_for_all_types(&value_int)
check_is_valid_for_all_types(&value_unsigned)
check_is_valid_for_all_types(&value_long)
check_is_valid_for_all_types(&value_long_unsigned)
check_is_valid_for_all_types(&value_long_long)
check_is_valid_for_all_types(&value_long_long_unsigned)
# Negative values should only fit in signed types.
var negative_value = json_value2_create()
json_value2_construct_i32(&negative_value, -42)
assert(not json_value2_is_integer_u8(&negative_value))
assert(not json_value2_is_integer_u16(&negative_value))
assert(not json_value2_is_integer_u32(&negative_value))
assert(not json_value2_is_integer_u64(&negative_value))
assert(json_value2_is_integer_i8(&negative_value))
assert(json_value2_is_integer_i16(&negative_value))
assert(json_value2_is_integer_i32(&negative_value))
assert(json_value2_is_integer_i64(&negative_value))
# 64-bit only
var very_large_value = json_value2_create()
json_value2_construct_i64_2(&very_large_value, 9223372036854775807)
assert(not json_value2_is_integer_u8(&very_large_value))
assert(not json_value2_is_integer_u16(&very_large_value))
assert(not json_value2_is_integer_u32(&very_large_value))
assert(json_value2_is_integer_u64(&very_large_value))
assert(not json_value2_is_integer_i8(&very_large_value))
assert(not json_value2_is_integer_i16(&very_large_value))
assert(not json_value2_is_integer_i32(&very_large_value))
assert(json_value2_is_integer_i64(&very_large_value))
test "json_object_move_from_value":
var array: JsonArray
var false_value = json_value2_create()
json_value2_json_value(&false_value, false)
json_array_must_append(&array, false_value)
json_array_must_append(&array, json_string_value("string"))
var object: JsonObject
json_object_construct(&object)
json_object_set_string_view(&object, sv("foo"), json_string_value("bar"))
var array_value = json_value2_create()
json_value2_construct_json_array_2(&array_value, array)
json_object_set_string_view(&object, sv("baz"), array_value)
var value = json_value2_create()
json_value2_construct_json_object_2(&value, object)
object = *json_value2_as_object(&value)
assert(json_value2_is_object(&value))
assert(json_object_size(&object) == 2)
assert(text_of_string(json_object_get_string(&object, sv("foo")) else trap("no foo")) == "bar")
let array2 = json_object_get_array_const(&object, sv("baz")) else trap("no baz")
assert(json_value2_as_bool(json_array_at_const(array2, 0)) == false)
assert(text_of_string(json_value2_as_string(json_array_at_const(array2, 1))) == "string")
test "invalid_utf8":
# Incomplete 2-byte sequence
assert(parse_json_fails_bytes(b"{\"key\": \"value\xcf\"}"))
assert(parse_json_fails_bytes(b"{\"key\xcf\": \"value\"}"))
# Incomplete 3-byte sequence
assert(parse_json_fails_bytes(b"{\"key\": \"value\xef\xbf\"}"))
assert(parse_json_fails_bytes(b"{\"key\xef\xbf\": \"value\"}"))
# Invalid start byte
assert(parse_json_fails_bytes(b"{\"key\": \"value\xf8\"}"))
assert(parse_json_fails_bytes(b"{\"key\xf8\": \"value\"}"))
# Invalid continuation byte
assert(parse_json_fails_bytes(b"{\"key\": \"value\xc3\x28\"}"))
assert(parse_json_fails_bytes(b"{\"key\xc3\x28\": \"value\"}"))
# Multiple invalid bytes
assert(parse_json_fails_bytes(b"{\"key\": \"value\xff\xff\"}"))
assert(parse_json_fails_bytes(b"{\"key\xff\xff\": \"value\"}"))