/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibTest/TestCase.h>
#include <AK/ByteString.h>
#include <AK/HashMap.h>
#include <AK/JsonObject.h>
#include <AK/JsonValue.h>
#include <AK/StringBuilder.h>
TEST_CASE(load_form)
{
ByteString raw_form_json = R"(
{
"name": "Form1",
"widgets": [
{
"enabled": true,
"forecolor": "#000000ff",
"ruler_visible": false,
"autofill": false,
"x": 155,
"tooltip": null,
"height": 121,
"width": 126,
"y": 10,
"class": "GTextEditor",
"text": "Hi",
"backcolor": "#c0c0c0ff",
"visible":true
}
]
})";
JsonValue form_json = JsonValue::from_string(raw_form_json).value();
EXPECT(form_json.is_object());
auto name = form_json.as_object().get_byte_string("name"sv);
EXPECT(name.has_value());
EXPECT_EQ(name.value(), "Form1");
auto widgets = form_json.as_object().get_array("widgets"sv);
EXPECT(widgets.has_value());
widgets->for_each([&](JsonValue const& widget_value) {
auto& widget_object = widget_value.as_object();
auto widget_class = widget_object.get_byte_string("class"sv).value();
widget_object.for_each_member([&]([[maybe_unused]] auto& property_name, [[maybe_unused]] JsonValue const& property_value) {
});
});
}
TEST_CASE(json_empty_string)
{
auto json = JsonValue::from_string("\"\""sv).value();
EXPECT_EQ(json.type(), JsonValue::Type::String);
EXPECT_EQ(json.as_string().is_empty(), true);
}
TEST_CASE(json_string)
{
auto json = JsonValue::from_string("\"A\""sv).value();
EXPECT_EQ(json.type(), JsonValue::Type::String);
EXPECT_EQ(json.as_string().length(), size_t { 1 });
EXPECT_EQ(json.as_string() == "A", true);
}
TEST_CASE(json_utf8_character)
{
auto json = JsonValue::from_string("\"\\u0041\""sv).value();
EXPECT_EQ(json.type(), JsonValue::Type::String);
EXPECT_EQ(json.as_string().length(), size_t { 1 });
EXPECT_EQ(json.as_string() == "A", true);
}
TEST_CASE(json_encoded_surrogates)
{
{
auto json = JsonValue::from_string("\"\\uD83E\\uDD13\""sv).value();
EXPECT_EQ(json.type(), JsonValue::Type::String);
EXPECT_EQ(json.as_string().length(), 4u);
EXPECT_EQ(json.as_string(), "🤓"sv);
}
{
auto json = JsonValue::from_string("\"\\uD83E\""sv).value();
EXPECT_EQ(json.type(), JsonValue::Type::String);
EXPECT_EQ(json.as_string().length(), 3u);
EXPECT_EQ(json.as_string(), "\xED\xA0\xBE"sv);
}
{
auto json = JsonValue::from_string("\"\\uDD13\""sv).value();
EXPECT_EQ(json.type(), JsonValue::Type::String);
EXPECT_EQ(json.as_string().length(), 3u);
EXPECT_EQ(json.as_string(), "\xED\xB4\x93"sv);
}
}
/*
FIXME: Parse JSON from a Utf8View
TEST_CASE(json_utf8_multibyte)
{
auto json_or_error = JsonValue::from_string("\"Å¡\"");
EXPECT_EQ(json_or_error.is_error(), false);
auto& json = json_or_error.value();
EXPECT_EQ(json.type(), JsonValue::Type::String);
EXPECT_EQ(json.as_string().length(), size_t { 2 });
EXPECT_EQ(json.as_string() == "Å¡", true);
EXPECT_EQ(json.as_string() == "\xc5\xa1", true);
}
*/
TEST_CASE(json_64_bit_value)
{
auto big_value = 0x12345678aabbccddull;
JsonValue big_json_value(big_value);
EXPECT(big_json_value.is_integer<u64>());
EXPECT_EQ(big_json_value.as_integer<u64>(), big_value);
JsonValue big_json_value_copy = big_json_value;
EXPECT(big_json_value.equals(big_json_value_copy));
}
TEST_CASE(json_64_bit_value_coerced_to_32_bit)
{
{
auto min = NumericLimits<i64>::min();
auto max = NumericLimits<i64>::max();
auto json = TRY_OR_FAIL(JsonValue::from_string(String::number(min)));
EXPECT_EQ(json.get_integer<i64>(), min);
EXPECT(!json.is_integer<i32>());
json = TRY_OR_FAIL(JsonValue::from_string(String::number(max)));
EXPECT_EQ(json.get_integer<i64>(), max);
EXPECT(!json.is_integer<i32>());
}
{
auto min = NumericLimits<u64>::min();
auto max = NumericLimits<u64>::max();
auto json = TRY_OR_FAIL(JsonValue::from_string(String::number(min)));
EXPECT_EQ(json.get_integer<u64>(), min);
EXPECT_EQ(json.get_integer<u32>(), min);
json = TRY_OR_FAIL(JsonValue::from_string(String::number(max)));
EXPECT_EQ(json.get_integer<u64>(), max);
EXPECT(!json.is_integer<u32>());
}
}
TEST_CASE(json_duplicate_keys)
{
JsonObject json;
json.set("test", "foo");
json.set("test", "bar");
json.set("test", "baz");
EXPECT_EQ(json.to_byte_string(), "{\"test\":\"baz\"}");
}
TEST_CASE(json_u64_roundtrip)
{
auto big_value = 0xffffffffffffffffull;
auto json = JsonValue(big_value).serialized<StringBuilder>();
auto value = JsonValue::from_string(json);
EXPECT_EQ_FORCE(value.is_error(), false);
EXPECT_EQ(value.value().as_integer<u64>(), big_value);
}
TEST_CASE(json_parse_empty_string)
{
auto value = JsonValue::from_string(""sv);
EXPECT_EQ(value.is_error(), true);
}
TEST_CASE(json_parse_long_decimals)
{
auto value = JsonValue::from_string("1644452550.6489999294281"sv);
EXPECT_EQ(value.value().get_double_with_precision_loss(), 1644452550.6489999294281);
}
TEST_CASE(json_parse_number_with_exponent)
{
auto value_without_fraction = JsonValue::from_string("10e5"sv);
EXPECT_EQ(value_without_fraction.value().get_double_with_precision_loss(), 1000000.0);
auto value_with_fraction = JsonValue::from_string("10.5e5"sv);
EXPECT_EQ(value_with_fraction.value().get_double_with_precision_loss(), 1050000.0);
}
TEST_CASE(json_parse_special_numbers)
{
#define EXPECT_TO_MATCH_NUMBER_BIT_WISE(string_input, double_input) \
do { \
auto value_or_error = JsonValue::from_string(string_input##sv); \
VERIFY(!value_or_error.is_error()); \
if (value_or_error.is_error()) \
dbgln("got {}", value_or_error.error()); \
auto value = value_or_error.release_value(); \
EXPECT(value.is_number()); \
auto value_as_double = value.get_double_with_precision_loss().value(); \
EXPECT_EQ(bit_cast<u64>(value_as_double), bit_cast<u64>(static_cast<double>(double_input))); \
} while (false)
EXPECT_TO_MATCH_NUMBER_BIT_WISE("-0", -0.);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("-0.0", -0.0);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("-0.00", -0.00);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("-0e0", -0e0);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("-0e1", -0e1);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("-0e2", -0e2);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("-0e1000", -0e1000);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("-0e-1000", -0e-1000);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("0", 0.);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("0.0", 0.0);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("0.00", 0.00);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("0e0", 0e0);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("0e1", 0e1);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("0e2", 0e2);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("0e1000", 0e1000);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("0e-1000", 0e-1000);
// These technically can be non zero, but not in doubles
EXPECT_TO_MATCH_NUMBER_BIT_WISE("-1e-2000", -0.);
EXPECT_TO_MATCH_NUMBER_BIT_WISE("1e-2000", 0.);
#undef EXPECT_TO_MATCH_NUMBER_BIT_WISE
}
TEST_CASE(json_parse_fails_on_invalid_number)
{
#define EXPECT_JSON_PARSE_TO_FAIL(value) \
EXPECT(JsonValue::from_string(value##sv).is_error());
EXPECT_JSON_PARSE_TO_FAIL("-");
EXPECT_JSON_PARSE_TO_FAIL("00");
EXPECT_JSON_PARSE_TO_FAIL("01");
EXPECT_JSON_PARSE_TO_FAIL("-01");
EXPECT_JSON_PARSE_TO_FAIL(".1");
EXPECT_JSON_PARSE_TO_FAIL("-.1");
EXPECT_JSON_PARSE_TO_FAIL("-,1");
EXPECT_JSON_PARSE_TO_FAIL(".1e1");
EXPECT_JSON_PARSE_TO_FAIL(".1e-1");
EXPECT_JSON_PARSE_TO_FAIL("-.1e1");
EXPECT_JSON_PARSE_TO_FAIL("-.1e-1");
EXPECT_JSON_PARSE_TO_FAIL("1.e1");
EXPECT_JSON_PARSE_TO_FAIL("1.e-1");
EXPECT_JSON_PARSE_TO_FAIL("-1.e1");
EXPECT_JSON_PARSE_TO_FAIL("-1.e-1");
EXPECT_JSON_PARSE_TO_FAIL("1e");
EXPECT_JSON_PARSE_TO_FAIL("1e+");
EXPECT_JSON_PARSE_TO_FAIL("1e-");
EXPECT_JSON_PARSE_TO_FAIL("1e-f");
EXPECT_JSON_PARSE_TO_FAIL("1.e");
EXPECT_JSON_PARSE_TO_FAIL("1.e+");
EXPECT_JSON_PARSE_TO_FAIL("1.e-");
EXPECT_JSON_PARSE_TO_FAIL("1.e-f");
EXPECT_JSON_PARSE_TO_FAIL("1p2");
EXPECT_JSON_PARSE_TO_FAIL("1.p2");
EXPECT_JSON_PARSE_TO_FAIL("0x1.0p2");
EXPECT_JSON_PARSE_TO_FAIL("0x1");
EXPECT_JSON_PARSE_TO_FAIL("0x7");
EXPECT_JSON_PARSE_TO_FAIL("0xA");
EXPECT_JSON_PARSE_TO_FAIL("0x");
EXPECT_JSON_PARSE_TO_FAIL("-0x");
EXPECT_JSON_PARSE_TO_FAIL("0x");
EXPECT_JSON_PARSE_TO_FAIL("1x");
EXPECT_JSON_PARSE_TO_FAIL("100x");
EXPECT_JSON_PARSE_TO_FAIL("1000000000000000000000x");
EXPECT_JSON_PARSE_TO_FAIL("0e2x");
EXPECT_JSON_PARSE_TO_FAIL("0.1e2x");
EXPECT_JSON_PARSE_TO_FAIL("0.1x");
EXPECT_JSON_PARSE_TO_FAIL("1e2x");
EXPECT_JSON_PARSE_TO_FAIL("1.2x");
EXPECT_JSON_PARSE_TO_FAIL("1.2e2x");
EXPECT_JSON_PARSE_TO_FAIL(".0");
EXPECT_JSON_PARSE_TO_FAIL(".e1");
EXPECT_JSON_PARSE_TO_FAIL("-.0");
EXPECT_JSON_PARSE_TO_FAIL("-.e1");
EXPECT_JSON_PARSE_TO_FAIL("+0");
EXPECT_JSON_PARSE_TO_FAIL("+0.0");
EXPECT_JSON_PARSE_TO_FAIL("+0.00");
EXPECT_JSON_PARSE_TO_FAIL("+0e0");
EXPECT_JSON_PARSE_TO_FAIL("+0e1");
EXPECT_JSON_PARSE_TO_FAIL("+0e2");
EXPECT_JSON_PARSE_TO_FAIL("+0e1000");
EXPECT_JSON_PARSE_TO_FAIL("+0e-1000");
EXPECT_JSON_PARSE_TO_FAIL("+10");
EXPECT_JSON_PARSE_TO_FAIL("+10e1");
EXPECT_JSON_PARSE_TO_FAIL("+10.3");
EXPECT_JSON_PARSE_TO_FAIL("+10.3e1");
EXPECT_JSON_PARSE_TO_FAIL("0x1");
EXPECT_JSON_PARSE_TO_FAIL("0x2");
EXPECT_JSON_PARSE_TO_FAIL("0xA");
EXPECT_JSON_PARSE_TO_FAIL("0xB");
EXPECT_JSON_PARSE_TO_FAIL("0xF");
EXPECT_JSON_PARSE_TO_FAIL("0Xf");
EXPECT_JSON_PARSE_TO_FAIL("0X3");
EXPECT_JSON_PARSE_TO_FAIL("10ee1");
EXPECT_JSON_PARSE_TO_FAIL("1e1e1");
// These could be valid within an array but not as the top level value
EXPECT_JSON_PARSE_TO_FAIL("0,0");
EXPECT_JSON_PARSE_TO_FAIL(",1");
EXPECT_JSON_PARSE_TO_FAIL("10e1,");
EXPECT_JSON_PARSE_TO_FAIL("10e,1");
EXPECT_JSON_PARSE_TO_FAIL("10,e1");
EXPECT_JSON_PARSE_TO_FAIL("1,0e1");
EXPECT_JSON_PARSE_TO_FAIL(",10e1");
#undef EXPECT_JSON_PARSE_TO_FAIL
}
struct CustomError {
};
template<typename T>
class CustomErrorOr {
public:
using ResultType = T;
using ErrorType = CustomError;
CustomErrorOr(T)
: m_is_error(false)
{
}
CustomErrorOr(CustomError)
: m_is_error(true)
{
}
bool is_error() const { return m_is_error; }
CustomError release_error() { return CustomError {}; }
T release_value() { return T {}; }
private:
bool m_is_error { false };
};
TEST_CASE(fallible_json_object_for_each)
{
ByteString raw_json = R"(
{
"name": "anon",
"home": "/home/anon",
"default_browser": "Ladybird"
})";
auto json = JsonValue::from_string(raw_json).value();
auto const& object = json.as_object();
MUST(object.try_for_each_member([](auto const&, auto const&) -> ErrorOr<void> {
return {};
}));
auto result1 = object.try_for_each_member([](auto const&, auto const&) -> ErrorOr<void> {
return Error::from_string_literal("nanananana");
});
EXPECT(result1.is_error());
EXPECT_EQ(result1.error().string_literal(), "nanananana"sv);
auto result2 = object.try_for_each_member([](auto const&, auto const&) -> ErrorOr<void, CustomError> {
return CustomError {};
});
EXPECT(result2.is_error());
static_assert((IsSame<decltype(result2.release_error()), CustomError&&>));
auto result3 = object.try_for_each_member([](auto const&, auto const&) -> CustomErrorOr<int> {
return 42;
});
EXPECT(!result3.is_error());
auto result4 = object.try_for_each_member([](auto const&, auto const&) -> CustomErrorOr<int> {
return CustomError {};
});
EXPECT(result4.is_error());
static_assert((IsSame<decltype(result4.release_error()), CustomError&&>));
}
TEST_CASE(fallible_json_array_for_each)
{
ByteString raw_json = R"(
[
"anon",
"/home/anon",
"Ladybird"
])";
auto json = JsonValue::from_string(raw_json).value();
auto const& array = json.as_array();
MUST(array.try_for_each([](auto const&) -> ErrorOr<void> {
return {};
}));
auto result1 = array.try_for_each([](auto const&) -> ErrorOr<void> {
return Error::from_string_literal("nanananana");
});
EXPECT(result1.is_error());
EXPECT_EQ(result1.error().string_literal(), "nanananana"sv);
auto result2 = array.try_for_each([](auto const&) -> ErrorOr<void, CustomError> {
return CustomError {};
});
EXPECT(result2.is_error());
static_assert((IsSame<decltype(result2.release_error()), CustomError&&>));
auto result3 = array.try_for_each([](auto const&) -> CustomErrorOr<int> {
return 42;
});
EXPECT(!result3.is_error());
auto result4 = array.try_for_each([](auto const&) -> CustomErrorOr<int> {
return CustomError {};
});
EXPECT(result4.is_error());
static_assert((IsSame<decltype(result4.release_error()), CustomError&&>));
}
TEST_CASE(json_array_is_empty)
{
auto raw_json = "[]"sv;
auto json_value = MUST(JsonValue::from_string(raw_json));
auto array = json_value.as_array();
EXPECT(array.is_empty());
raw_json = "[1, 2]"sv;
json_value = MUST(JsonValue::from_string(raw_json));
array = json_value.as_array();
EXPECT(!array.is_empty());
}
static JsonArray setup_json_array()
{
auto raw_json = R"([1, 2, "WHF", 802.11, 16])"sv;
auto json_value = MUST(JsonValue::from_string(raw_json));
return json_value.as_array();
}
TEST_CASE(json_array_size)
{
auto array = setup_json_array();
EXPECT_EQ(array.size(), size_t { 5 });
auto empty_json_arr_sv = "[]"sv;
array = MUST(JsonValue::from_string(empty_json_arr_sv)).as_array();
EXPECT_EQ(array.size(), size_t { 0 });
}
TEST_CASE(json_array_at)
{
auto array = setup_json_array();
auto const& element = array.at(1);
EXPECT_EQ(element.as_integer<u8>(), 2);
}
TEST_CASE(json_array_subscript_operator)
{
auto array = setup_json_array();
auto const& element = array[1];
EXPECT_EQ(element.as_integer<u8>(), 2);
}
TEST_CASE(json_array_take)
{
auto array = setup_json_array();
auto const& element = array.take(2);
EXPECT_EQ(array.size(), size_t { 4 });
EXPECT_EQ(element.as_string(), "WHF");
}
TEST_CASE(json_array_must_append)
{
auto array = setup_json_array();
array.must_append(MUST(JsonValue::from_string("32"sv)));
EXPECT_EQ(array.size(), size_t { 6 });
EXPECT_EQ(array.at(array.size() - 1).as_integer<u8>(), 32);
}
TEST_CASE(json_array_try_append)
{
auto array = setup_json_array();
MUST(array.append(MUST(JsonValue::from_string("32"sv))));
EXPECT_EQ(array.size(), size_t { 6 });
EXPECT_EQ(array.at(array.size() - 1).as_integer<u8>(), 32);
}
TEST_CASE(json_array_clear)
{
auto array = setup_json_array();
array.clear();
EXPECT(array.is_empty());
}
TEST_CASE(json_array_set)
{
auto array = setup_json_array();
array.set(1, MUST(JsonValue::from_string("-32"sv)));
EXPECT_EQ(array.size(), size_t { 5 });
EXPECT_EQ(array.at(1).as_integer<i8>(), -32);
}
TEST_CASE(json_array_ensure_capacity)
{
auto array = setup_json_array();
size_t new_capacity { 16 };
array.ensure_capacity(new_capacity);
EXPECT_EQ(array.values().capacity(), new_capacity);
}
TEST_CASE(json_array_for_each)
{
auto raw_json = "[1, 2, 3, 4]"sv;
auto json_value = MUST(JsonValue::from_string(raw_json));
auto array = json_value.as_array();
size_t count { 0 };
array.for_each([&count](JsonValue const& value) {
EXPECT_EQ(value.as_integer<u8>(), ++count);
});
EXPECT_EQ(array.size(), count);
}
TEST_CASE(json_array_serialized)
{
auto raw_json = R"(["Hello",2,3.14,4,"World"])"sv;
auto json_value = MUST(JsonValue::from_string(raw_json));
auto array = json_value.as_array();
auto const& serialized_json = array.serialized<StringBuilder>();
EXPECT_EQ(serialized_json, raw_json);
}
TEST_CASE(json_array_serialize)
{
auto raw_json = R"(["Hello",2,3.14,4,"World"])"sv;
auto json_value = MUST(JsonValue::from_string(raw_json));
auto array = json_value.as_array();
StringBuilder builder {};
array.serialize(builder);
EXPECT_EQ(builder.to_byte_string(), raw_json);
}
TEST_CASE(json_array_values)
{
auto raw_json = "[1, 2, 3, 4]"sv;
auto json_value = MUST(JsonValue::from_string(raw_json));
auto array = json_value.as_array();
auto const& values = array.values();
EXPECT_EQ(values.size(), size_t { 4 });
for (size_t i = 0; i < values.size(); i++)
EXPECT_EQ(array.at(i).as_integer<u8>(), i + 1);
}
TEST_CASE(json_value_as_integer)
{
// is_integer() should validate based on the value, not the underlying type.
JsonValue value_int { static_cast<int>(42) };
JsonValue value_unsigned { static_cast<unsigned>(42) };
JsonValue value_long { static_cast<long>(42) };
JsonValue value_long_unsigned { static_cast<long unsigned>(42) };
JsonValue value_long_long { static_cast<long long>(42) };
JsonValue value_long_long_unsigned { static_cast<long long unsigned>(42) };
auto check_is_valid_for_all_types = [](JsonValue& value) {
EXPECT(value.is_integer<u8>());
EXPECT_EQ(value.as_integer<u8>(), static_cast<u8>(42));
EXPECT(value.is_integer<u16>());
EXPECT_EQ(value.as_integer<u16>(), static_cast<u16>(42));
EXPECT(value.is_integer<u32>());
EXPECT_EQ(value.as_integer<u32>(), static_cast<u32>(42));
EXPECT(value.is_integer<u64>());
EXPECT_EQ(value.as_integer<u64>(), static_cast<u64>(42));
EXPECT(value.is_integer<i8>());
EXPECT_EQ(value.as_integer<i8>(), static_cast<i8>(42));
EXPECT(value.is_integer<i16>());
EXPECT_EQ(value.as_integer<i16>(), static_cast<i16>(42));
EXPECT(value.is_integer<i32>());
EXPECT_EQ(value.as_integer<i32>(), static_cast<i32>(42));
EXPECT(value.is_integer<i64>());
EXPECT_EQ(value.as_integer<i64>(), static_cast<i64>(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.
JsonValue negative_value { -42 };
EXPECT(!negative_value.is_integer<u8>());
EXPECT(!negative_value.is_integer<u16>());
EXPECT(!negative_value.is_integer<u32>());
EXPECT(!negative_value.is_integer<u64>());
EXPECT(negative_value.is_integer<i8>());
EXPECT(negative_value.is_integer<i16>());
EXPECT(negative_value.is_integer<i32>());
EXPECT(negative_value.is_integer<i64>());
// 64-bit only
JsonValue very_large_value { INT64_MAX };
EXPECT(!very_large_value.is_integer<u8>());
EXPECT(!very_large_value.is_integer<u16>());
EXPECT(!very_large_value.is_integer<u32>());
EXPECT(very_large_value.is_integer<u64>());
EXPECT(!very_large_value.is_integer<i8>());
EXPECT(!very_large_value.is_integer<i16>());
EXPECT(!very_large_value.is_integer<i32>());
EXPECT(very_large_value.is_integer<i64>());
}
