mirror of
https://github.com/nlohmann/json.git
synced 2026-10-07 15:07:13 +00:00
363 lines
18 KiB
C++
363 lines
18 KiB
C++
// __ _____ _____ _____
|
|
// __| | __| | | | JSON for Modern C++ (supporting code)
|
|
// | | |__ | | | | | | version 3.12.0
|
|
// |_____|_____|_____|_|___| https://github.com/nlohmann/json
|
|
//
|
|
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
#include "doctest_compatibility.h"
|
|
|
|
#include <nlohmann/json.hpp>
|
|
using nlohmann::json;
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace
|
|
{
|
|
|
|
struct ill_formed_case
|
|
{
|
|
const char* name;
|
|
std::string bytes;
|
|
};
|
|
|
|
// RFC 3629 ill-formed sequences used throughout this file, plus one
|
|
// well-formed sequence for contrast
|
|
const std::vector<ill_formed_case> ill_formed_cases =
|
|
{
|
|
{"overlong", "\xC0\xAE"},
|
|
{"lone_0xFF", "\xFF"},
|
|
{"truncated", "\xE2\x82"},
|
|
{"surrogate", "\xED\xA0\x80"},
|
|
};
|
|
|
|
const std::string valid_sequence = "\xC3\xA9"; // U+00E9, "é"
|
|
|
|
using eh = json::error_handler_t;
|
|
const std::vector<eh> all_handlers = {eh::strict, eh::replace, eh::ignore, eh::keep};
|
|
|
|
// what dump()+parse() produces for a sanitizing error_handler; this is the
|
|
// ground truth every binary writer/reader is checked against
|
|
std::string dump_and_parse(const std::string& raw, eh error_handler)
|
|
{
|
|
return json::parse(json(raw).dump(-1, ' ', false, error_handler)).get<std::string>();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
TEST_CASE("UTF-8 error_handler for the binary readers and writers")
|
|
{
|
|
SECTION("writers: string value")
|
|
{
|
|
for (const auto& c : ill_formed_cases)
|
|
{
|
|
CAPTURE(c.name);
|
|
const json jval = c.bytes;
|
|
|
|
CHECK_THROWS_AS(json::to_cbor(jval, eh::strict), json::type_error&);
|
|
CHECK_THROWS_AS(json::to_msgpack(jval, eh::strict), json::type_error&);
|
|
CHECK_THROWS_AS(json::to_ubjson(jval, false, false, eh::strict), json::type_error&);
|
|
CHECK_THROWS_AS(json::to_bjdata(jval, false, false, json::bjdata_version_t::draft2, eh::strict), json::type_error&);
|
|
{
|
|
json jobj;
|
|
jobj["k"] = jval;
|
|
CHECK_THROWS_AS(json::to_bson(jobj, eh::strict), json::type_error&);
|
|
}
|
|
|
|
for (const auto h :
|
|
{
|
|
eh::replace, eh::ignore
|
|
})
|
|
{
|
|
CAPTURE(static_cast<int>(h));
|
|
const std::string expected = dump_and_parse(c.bytes, h);
|
|
|
|
CHECK(json::from_cbor(json::to_cbor(jval, h)).get<std::string>() == expected);
|
|
CHECK(json::from_msgpack(json::to_msgpack(jval, h)).get<std::string>() == expected);
|
|
CHECK(json::from_ubjson(json::to_ubjson(jval, false, false, h)).get<std::string>() == expected);
|
|
CHECK(json::from_bjdata(json::to_bjdata(jval, false, false, json::bjdata_version_t::draft2, h)).get<std::string>() == expected);
|
|
{
|
|
json jobj;
|
|
jobj["k"] = jval;
|
|
const auto bytes = json::to_bson(jobj, h);
|
|
CHECK(json::from_bson(bytes)["k"].get<std::string>() == expected);
|
|
}
|
|
}
|
|
|
|
// keep: the writer passes the ill-formed bytes through unchanged,
|
|
// exactly as every binary writer did before this parameter existed
|
|
CHECK(json::from_cbor(json::to_cbor(jval, eh::keep)).get<std::string>() == c.bytes);
|
|
CHECK(json::from_msgpack(json::to_msgpack(jval, eh::keep)).get<std::string>() == c.bytes);
|
|
CHECK(json::from_ubjson(json::to_ubjson(jval, false, false, eh::keep)).get<std::string>() == c.bytes);
|
|
CHECK(json::from_bjdata(json::to_bjdata(jval, false, false, json::bjdata_version_t::draft2, eh::keep)).get<std::string>() == c.bytes);
|
|
{
|
|
json jobj;
|
|
jobj["k"] = jval;
|
|
const auto bytes = json::to_bson(jobj, eh::keep);
|
|
CHECK(json::from_bson(bytes)["k"].get<std::string>() == c.bytes);
|
|
}
|
|
}
|
|
}
|
|
|
|
SECTION("writers: object key")
|
|
{
|
|
for (const auto& c : ill_formed_cases)
|
|
{
|
|
CAPTURE(c.name);
|
|
json jobj;
|
|
jobj[c.bytes] = 1;
|
|
|
|
CHECK_THROWS_AS(json::to_cbor(jobj, eh::strict), json::type_error&);
|
|
CHECK_THROWS_AS(json::to_msgpack(jobj, eh::strict), json::type_error&);
|
|
CHECK_THROWS_AS(json::to_ubjson(jobj, false, false, eh::strict), json::type_error&);
|
|
CHECK_THROWS_AS(json::to_bjdata(jobj, false, false, json::bjdata_version_t::draft2, eh::strict), json::type_error&);
|
|
CHECK_THROWS_AS(json::to_bson(jobj, eh::strict), json::type_error&);
|
|
|
|
for (const auto h :
|
|
{
|
|
eh::replace, eh::ignore
|
|
})
|
|
{
|
|
CAPTURE(static_cast<int>(h));
|
|
const std::string expected = dump_and_parse(c.bytes, h);
|
|
|
|
CHECK(json::from_cbor(json::to_cbor(jobj, h)).begin().key() == expected);
|
|
CHECK(json::from_msgpack(json::to_msgpack(jobj, h)).begin().key() == expected);
|
|
CHECK(json::from_ubjson(json::to_ubjson(jobj, false, false, h)).begin().key() == expected);
|
|
CHECK(json::from_bjdata(json::to_bjdata(jobj, false, false, json::bjdata_version_t::draft2, h)).begin().key() == expected);
|
|
CHECK(json::from_bson(json::to_bson(jobj, h)).begin().key() == expected);
|
|
}
|
|
|
|
// keep: object keys round-trip unchanged too
|
|
CHECK(json::from_cbor(json::to_cbor(jobj, eh::keep)).begin().key() == c.bytes);
|
|
CHECK(json::from_msgpack(json::to_msgpack(jobj, eh::keep)).begin().key() == c.bytes);
|
|
CHECK(json::from_ubjson(json::to_ubjson(jobj, false, false, eh::keep)).begin().key() == c.bytes);
|
|
CHECK(json::from_bjdata(json::to_bjdata(jobj, false, false, json::bjdata_version_t::draft2, eh::keep)).begin().key() == c.bytes);
|
|
CHECK(json::from_bson(json::to_bson(jobj, eh::keep)).begin().key() == c.bytes);
|
|
}
|
|
}
|
|
|
|
SECTION("readers: string value")
|
|
{
|
|
for (const auto& c : ill_formed_cases)
|
|
{
|
|
CAPTURE(c.name);
|
|
|
|
// bytes produced the lenient (keep) way, as any binary reader
|
|
// accepted them before this parameter existed
|
|
const auto cbor_bytes = json::to_cbor(json(c.bytes), eh::keep);
|
|
const auto msgpack_bytes = json::to_msgpack(json(c.bytes)); // to_msgpack has no error_handler; always pass-through
|
|
const auto ubjson_bytes = json::to_ubjson(json(c.bytes), false, false, eh::keep);
|
|
const auto bjdata_bytes = json::to_bjdata(json(c.bytes), false, false, json::bjdata_version_t::draft2, eh::keep);
|
|
const auto bson_bytes = [&c]
|
|
{
|
|
json jobj;
|
|
jobj["k"] = c.bytes;
|
|
return json::to_bson(jobj, eh::keep);
|
|
}();
|
|
|
|
// keep (the default): bytes are kept unchanged
|
|
CHECK(json::from_cbor(cbor_bytes).get<std::string>() == c.bytes);
|
|
CHECK(json::from_msgpack(msgpack_bytes).get<std::string>() == c.bytes);
|
|
CHECK(json::from_ubjson(ubjson_bytes).get<std::string>() == c.bytes);
|
|
CHECK(json::from_bjdata(bjdata_bytes).get<std::string>() == c.bytes);
|
|
CHECK(json::from_bson(bson_bytes)["k"].get<std::string>() == c.bytes);
|
|
|
|
// strict: parse_error.113, discarded (not thrown) when allow_exceptions is false
|
|
CHECK_THROWS_AS(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, eh::strict), json::parse_error&);
|
|
CHECK(json::from_cbor(cbor_bytes, true, false, json::cbor_tag_handler_t::error, eh::strict).is_discarded());
|
|
CHECK_THROWS_AS(json::from_msgpack(msgpack_bytes, true, true, eh::strict), json::parse_error&);
|
|
CHECK(json::from_msgpack(msgpack_bytes, true, false, eh::strict).is_discarded());
|
|
CHECK_THROWS_AS(json::from_ubjson(ubjson_bytes, true, true, eh::strict), json::parse_error&);
|
|
CHECK(json::from_ubjson(ubjson_bytes, true, false, eh::strict).is_discarded());
|
|
CHECK_THROWS_AS(json::from_bjdata(bjdata_bytes, true, true, eh::strict), json::parse_error&);
|
|
CHECK(json::from_bjdata(bjdata_bytes, true, false, eh::strict).is_discarded());
|
|
CHECK_THROWS_AS(json::from_bson(bson_bytes, true, true, eh::strict), json::parse_error&);
|
|
CHECK(json::from_bson(bson_bytes, true, false, eh::strict).is_discarded());
|
|
|
|
// replace / ignore: match what dump() would have sanitized the same bytes to
|
|
for (const auto h :
|
|
{
|
|
eh::replace, eh::ignore
|
|
})
|
|
{
|
|
CAPTURE(static_cast<int>(h));
|
|
const std::string expected = dump_and_parse(c.bytes, h);
|
|
|
|
CHECK(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, h).get<std::string>() == expected);
|
|
CHECK(json::from_msgpack(msgpack_bytes, true, true, h).get<std::string>() == expected);
|
|
CHECK(json::from_ubjson(ubjson_bytes, true, true, h).get<std::string>() == expected);
|
|
CHECK(json::from_bjdata(bjdata_bytes, true, true, h).get<std::string>() == expected);
|
|
CHECK(json::from_bson(bson_bytes, true, true, h)["k"].get<std::string>() == expected);
|
|
}
|
|
}
|
|
}
|
|
|
|
SECTION("readers: object key")
|
|
{
|
|
for (const auto& c : ill_formed_cases)
|
|
{
|
|
CAPTURE(c.name);
|
|
|
|
json jobj;
|
|
jobj[c.bytes] = 1;
|
|
const auto cbor_bytes = json::to_cbor(jobj, eh::keep);
|
|
const auto msgpack_bytes = json::to_msgpack(jobj);
|
|
const auto ubjson_bytes = json::to_ubjson(jobj, false, false, eh::keep);
|
|
const auto bjdata_bytes = json::to_bjdata(jobj, false, false, json::bjdata_version_t::draft2, eh::keep);
|
|
const auto bson_bytes = json::to_bson(jobj, eh::keep);
|
|
|
|
CHECK(json::from_cbor(cbor_bytes).begin().key() == c.bytes);
|
|
CHECK(json::from_msgpack(msgpack_bytes).begin().key() == c.bytes);
|
|
CHECK(json::from_ubjson(ubjson_bytes).begin().key() == c.bytes);
|
|
CHECK(json::from_bjdata(bjdata_bytes).begin().key() == c.bytes);
|
|
CHECK(json::from_bson(bson_bytes).begin().key() == c.bytes);
|
|
|
|
CHECK_THROWS_AS(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, eh::strict), json::parse_error&);
|
|
CHECK_THROWS_AS(json::from_msgpack(msgpack_bytes, true, true, eh::strict), json::parse_error&);
|
|
CHECK_THROWS_AS(json::from_ubjson(ubjson_bytes, true, true, eh::strict), json::parse_error&);
|
|
CHECK_THROWS_AS(json::from_bjdata(bjdata_bytes, true, true, eh::strict), json::parse_error&);
|
|
CHECK_THROWS_AS(json::from_bson(bson_bytes, true, true, eh::strict), json::parse_error&);
|
|
|
|
for (const auto h :
|
|
{
|
|
eh::replace, eh::ignore
|
|
})
|
|
{
|
|
CAPTURE(static_cast<int>(h));
|
|
const std::string expected = dump_and_parse(c.bytes, h);
|
|
|
|
CHECK(json::from_cbor(cbor_bytes, true, true, json::cbor_tag_handler_t::error, h).begin().key() == expected);
|
|
CHECK(json::from_msgpack(msgpack_bytes, true, true, h).begin().key() == expected);
|
|
CHECK(json::from_ubjson(ubjson_bytes, true, true, h).begin().key() == expected);
|
|
CHECK(json::from_bjdata(bjdata_bytes, true, true, h).begin().key() == expected);
|
|
CHECK(json::from_bson(bson_bytes, true, true, h).begin().key() == expected);
|
|
}
|
|
}
|
|
}
|
|
|
|
SECTION("well-formed UTF-8 is unaffected by error_handler")
|
|
{
|
|
const json jval = valid_sequence;
|
|
json jobj;
|
|
jobj[valid_sequence] = valid_sequence;
|
|
|
|
for (const auto h : all_handlers)
|
|
{
|
|
CAPTURE(static_cast<int>(h));
|
|
|
|
CHECK(json::from_cbor(json::to_cbor(jval, h)).get<std::string>() == valid_sequence);
|
|
CHECK(json::from_msgpack(json::to_msgpack(jval, h)).get<std::string>() == valid_sequence);
|
|
CHECK(json::from_ubjson(json::to_ubjson(jval, false, false, h)).get<std::string>() == valid_sequence);
|
|
CHECK(json::from_bjdata(json::to_bjdata(jval, false, false, json::bjdata_version_t::draft2, h)).get<std::string>() == valid_sequence);
|
|
CHECK(json::from_bson(json::to_bson(jobj, h)).begin().key() == valid_sequence);
|
|
|
|
CHECK(json::from_cbor(json::to_cbor(jval, eh::keep), true, true, json::cbor_tag_handler_t::error, h).get<std::string>() == valid_sequence);
|
|
CHECK(json::from_msgpack(json::to_msgpack(jval), true, true, h).get<std::string>() == valid_sequence);
|
|
}
|
|
}
|
|
|
|
SECTION("dump() with error_handler_t::keep writes raw bytes as is")
|
|
{
|
|
for (const auto& c : ill_formed_cases)
|
|
{
|
|
CAPTURE(c.name);
|
|
|
|
const json jval = c.bytes;
|
|
const std::string dumped = jval.dump(-1, ' ', false, eh::keep);
|
|
CHECK(dumped.find(c.bytes) != std::string::npos);
|
|
|
|
// even with ensure_ascii, the ill-formed bytes are written as is
|
|
const std::string dumped_ascii = jval.dump(-1, ' ', true, eh::keep);
|
|
CHECK(dumped_ascii.find(c.bytes) != std::string::npos);
|
|
}
|
|
|
|
// well-formed characters around an ill-formed sequence are still
|
|
// escaped as usual under ensure_ascii
|
|
const json mixed = valid_sequence + ill_formed_cases[1].bytes; // "é" + lone 0xFF
|
|
const std::string dumped_mixed = mixed.dump(-1, ' ', true, eh::keep);
|
|
CHECK(dumped_mixed.find("\\u00e9") != std::string::npos);
|
|
CHECK(dumped_mixed.find(ill_formed_cases[1].bytes) != std::string::npos);
|
|
|
|
// the byte that ends an ill-formed sequence is read again, so a quote,
|
|
// a backslash, or a control character after it is still escaped, and
|
|
// a well-formed code point after it is escaped under ensure_ascii
|
|
for (const bool ensure_ascii :
|
|
{
|
|
false, true
|
|
})
|
|
{
|
|
CAPTURE(ensure_ascii);
|
|
CHECK(json("\xC3\"").dump(-1, ' ', ensure_ascii, eh::keep) == "\"\xC3\\\"\"");
|
|
CHECK(json("\xC3\\").dump(-1, ' ', ensure_ascii, eh::keep) == "\"\xC3\\\\\"");
|
|
CHECK(json("\xC3\n").dump(-1, ' ', ensure_ascii, eh::keep) == "\"\xC3\\n\"");
|
|
CHECK(json("\xE2\x82\"").dump(-1, ' ', ensure_ascii, eh::keep) == "\"\xE2\x82\\\"\"");
|
|
CHECK(json("\xFF\"").dump(-1, ' ', ensure_ascii, eh::keep) == "\"\xFF\\\"\"");
|
|
CHECK(json("a\xE2\x82").dump(-1, ' ', ensure_ascii, eh::keep) == "\"a\xE2\x82\"");
|
|
}
|
|
CHECK(json("\xC3\xC3\xA9").dump(-1, ' ', false, eh::keep) == "\"\xC3\xC3\xA9\"");
|
|
CHECK(json("\xC3\xC3\xA9").dump(-1, ' ', true, eh::keep) == "\"\xC3\\u00e9\"");
|
|
}
|
|
|
|
SECTION("to_msgpack defaults to keep; to_bon8 is not affected by error_handler")
|
|
{
|
|
const json jval = ill_formed_cases[1].bytes; // lone 0xFF
|
|
|
|
// to_msgpack's error_handler defaults to keep, as MessagePack's spec
|
|
// allows any bytes in a str, so the bytes are passed through
|
|
CHECK(json::to_msgpack(jval) == json::to_msgpack(jval, eh::keep));
|
|
CHECK(json::from_msgpack(json::to_msgpack(jval)).get<std::string>() == ill_formed_cases[1].bytes);
|
|
|
|
// the diagnostics context of an ill-formed key is the object
|
|
json jobj;
|
|
jobj["\xFF"] = 1;
|
|
CHECK_THROWS_WITH_AS(json::to_msgpack(jobj, eh::strict), "[json.exception.type_error.316] invalid UTF-8 byte at index 0: 0xFF", json::type_error&);
|
|
|
|
// to_bon8 has no error_handler parameter; UTF-8 is structural for
|
|
// BON8, so it always rejects ill-formed input
|
|
CHECK_THROWS_AS(json::to_bon8(jval), json::type_error&);
|
|
}
|
|
|
|
SECTION("allow_exceptions=false with error_handler_t::strict discards the value")
|
|
{
|
|
const auto bytes = json::to_cbor(json(ill_formed_cases[0].bytes), eh::keep);
|
|
const json result = json::from_cbor(bytes, true, false, json::cbor_tag_handler_t::error, eh::strict);
|
|
CHECK(result.is_discarded());
|
|
}
|
|
|
|
SECTION("default parameters are unchanged")
|
|
{
|
|
const json jval = ill_formed_cases[0].bytes;
|
|
|
|
// to_*: the default error_handler is keep, so ill-formed bytes are
|
|
// written unchanged, exactly as in release 3.12.0 (it is strict only
|
|
// if JSON_STRICT_BINARY_UTF8 is enabled, see
|
|
// unit-binary_utf8_strict.cpp)
|
|
CHECK(json::to_cbor(jval) == json::to_cbor(jval, eh::keep));
|
|
CHECK(json::to_ubjson(jval) == json::to_ubjson(jval, false, false, eh::keep));
|
|
CHECK(json::to_bjdata(jval) == json::to_bjdata(jval, false, false, json::bjdata_version_t::draft2, eh::keep));
|
|
{
|
|
json jobj;
|
|
jobj["k"] = jval;
|
|
CHECK(json::to_bson(jobj) == json::to_bson(jobj, eh::keep));
|
|
}
|
|
|
|
// from_*: the default error_handler is keep, so ill-formed bytes are
|
|
// still accepted unchanged, exactly as in release 3.12.0
|
|
const auto cbor_bytes = json::to_cbor(jval, eh::keep);
|
|
CHECK(json::from_cbor(cbor_bytes).get<std::string>() == ill_formed_cases[0].bytes);
|
|
const auto ubjson_bytes = json::to_ubjson(jval, false, false, eh::keep);
|
|
CHECK(json::from_ubjson(ubjson_bytes).get<std::string>() == ill_formed_cases[0].bytes);
|
|
const auto bjdata_bytes = json::to_bjdata(jval, false, false, json::bjdata_version_t::draft2, eh::keep);
|
|
CHECK(json::from_bjdata(bjdata_bytes).get<std::string>() == ill_formed_cases[0].bytes);
|
|
const auto msgpack_bytes = json::to_msgpack(jval);
|
|
CHECK(json::from_msgpack(msgpack_bytes).get<std::string>() == ill_formed_cases[0].bytes);
|
|
json bson_obj;
|
|
bson_obj["k"] = jval;
|
|
const auto bson_bytes = json::to_bson(bson_obj, eh::keep);
|
|
CHECK(json::from_bson(bson_bytes)["k"].get<std::string>() == ill_formed_cases[0].bytes);
|
|
}
|
|
}
|