| // __ _____ _____ _____ |
| // __| | __| | | | JSON for Modern C++ (supporting code) |
| // | | |__ | | | | | | version 3.11.3 |
| // |_____|_____|_____|_|___| https://github.com/nlohmann/json |
| // |
| // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> |
| // SPDX-License-Identifier: MIT |
| |
| #include "doctest_compatibility.h" |
| |
| #include <nlohmann/json.hpp> |
| using nlohmann::json; |
| |
| #include "make_test_data_available.hpp" |
| #include "test_utils.hpp" |
| #include <fstream> |
| #include <limits> |
| #include <sstream> |
| |
| TEST_CASE("BSON") |
| { |
| SECTION("individual values not supported") |
| { |
| SECTION("null") |
| { |
| json const j = nullptr; |
| CHECK_THROWS_WITH_AS(json::to_bson(j), |
| "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is null", |
| json::type_error&); |
| } |
| |
| SECTION("boolean") |
| { |
| SECTION("true") |
| { |
| json const j = true; |
| CHECK_THROWS_WITH_AS(json::to_bson(j), |
| "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is boolean", |
| json::type_error&); |
| } |
| |
| SECTION("false") |
| { |
| json const j = false; |
| CHECK_THROWS_WITH_AS(json::to_bson(j), |
| "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is boolean", |
| json::type_error&); |
| } |
| } |
| |
| SECTION("number") |
| { |
| json const j = 42; |
| CHECK_THROWS_WITH_AS(json::to_bson(j), |
| "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is number", |
| json::type_error&); |
| } |
| |
| SECTION("float") |
| { |
| json const j = 4.2; |
| CHECK_THROWS_WITH_AS(json::to_bson(j), |
| "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is number", |
| json::type_error&); |
| } |
| |
| SECTION("string") |
| { |
| json const j = "not supported"; |
| CHECK_THROWS_WITH_AS(json::to_bson(j), |
| "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is string", |
| json::type_error&); |
| } |
| |
| SECTION("array") |
| { |
| json const j = std::vector<int>{ 1, 2, 3, 4, 5, 6, 7 }; |
| CHECK_THROWS_WITH_AS(json::to_bson(j), |
| "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is array", |
| json::type_error&); |
| } |
| } |
| |
| SECTION("keys containing code-point U+0000 cannot be serialized to BSON") |
| { |
| json const j = { { std::string("en\0try", 6), true } }; |
| #if JSON_DIAGNOSTICS |
| CHECK_THROWS_WITH_AS(json::to_bson(j), |
| "[json.exception.out_of_range.409] (/en) BSON key cannot contain code point U+0000 (at byte 2)", |
| json::out_of_range&); |
| #else |
| CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.out_of_range.409] BSON key cannot contain code point U+0000 (at byte 2)", json::out_of_range&); |
| #endif |
| } |
| |
| SECTION("string length must be at least 1") |
| { |
| // from https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=11175 |
| std::vector<std::uint8_t> const v = { 0x20, 0x20, 0x20, 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x80 }; |
| json _; |
| CHECK_THROWS_WITH_AS( |
| _ = json::from_bson(v), |
| "[json.exception.parse_error.112] parse error at byte 10: syntax error while parsing BSON string: string length must be at least 1, is -2147483648", |
| json::parse_error&); |
| } |
| |
| SECTION("objects") |
| { |
| SECTION("empty object") |
| { |
| json const j = json::object(); |
| std::vector<std::uint8_t> const expected = { |
| 0x05, |
| 0x00, |
| 0x00, |
| 0x00, // size (little endian) |
| // no entries |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with bool") |
| { |
| json const j = { { "entry", true } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x0D, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x08, // entry: boolean |
| 'e', 'n', 't', 'r', 'y', '\x00', |
| 0x01, // value = true |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with bool") |
| { |
| json const j = { { "entry", false } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x0D, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x08, // entry: boolean |
| 'e', 'n', 't', 'r', 'y', '\x00', |
| 0x00, // value = false |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with double") |
| { |
| json const j = { { "entry", 4.2 } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x14, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x01, /// entry: double |
| 'e', 'n', 't', 'r', 'y', '\x00', 0xcd, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x10, 0x40, |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with string") |
| { |
| json const j = { { "entry", "bsonstr" } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x18, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x02, /// entry: string (UTF-8) |
| 'e', 'n', 't', 'r', 'y', '\x00', 0x08, 0x00, 0x00, 0x00, 'b', 's', 'o', 'n', 's', 't', 'r', '\x00', |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with null member") |
| { |
| json const j = { { "entry", nullptr } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x0C, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x0A, /// entry: null |
| 'e', 'n', 't', 'r', 'y', '\x00', |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with integer (32-bit) member") |
| { |
| json const j = { { "entry", std::int32_t{ 0x12345678 } } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x10, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x10, /// entry: int32 |
| 'e', 'n', 't', 'r', 'y', '\x00', 0x78, 0x56, 0x34, 0x12, |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with integer (64-bit) member") |
| { |
| json const j = { { "entry", std::int64_t{ 0x1234567804030201 } } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x14, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x12, /// entry: int64 |
| 'e', 'n', 't', 'r', 'y', '\x00', 0x01, 0x02, 0x03, 0x04, 0x78, 0x56, 0x34, 0x12, |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with negative integer (32-bit) member") |
| { |
| json const j = { { "entry", std::int32_t{ -1 } } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x10, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x10, /// entry: int32 |
| 'e', 'n', 't', 'r', 'y', '\x00', 0xFF, 0xFF, 0xFF, 0xFF, |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with negative integer (64-bit) member") |
| { |
| json const j = { { "entry", std::int64_t{ -1 } } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x10, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x10, /// entry: int32 |
| 'e', 'n', 't', 'r', 'y', '\x00', 0xFF, 0xFF, 0xFF, 0xFF, |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with unsigned integer (64-bit) member") |
| { |
| // directly encoding uint64 is not supported in bson (only for timestamp values) |
| json const j = { { "entry", std::uint64_t{ 0x1234567804030201 } } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x14, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x12, /// entry: int64 |
| 'e', 'n', 't', 'r', 'y', '\x00', 0x01, 0x02, 0x03, 0x04, 0x78, 0x56, 0x34, 0x12, |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with small unsigned integer member") |
| { |
| json const j = { { "entry", std::uint64_t{ 0x42 } } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x10, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x10, /// entry: int32 |
| 'e', 'n', 't', 'r', 'y', '\x00', 0x42, 0x00, 0x00, 0x00, |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with object member") |
| { |
| json const j = { { "entry", json::object() } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x11, |
| 0x00, |
| 0x00, |
| 0x00, // size (little endian) |
| 0x03, /// entry: embedded document |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| '\x00', |
| |
| 0x05, |
| 0x00, |
| 0x00, |
| 0x00, // size (little endian) |
| // no entries |
| 0x00, // end marker (embedded document) |
| |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with array member") |
| { |
| json const j = { { "entry", json::array() } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x11, |
| 0x00, |
| 0x00, |
| 0x00, // size (little endian) |
| 0x04, /// entry: embedded document |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| '\x00', |
| |
| 0x05, |
| 0x00, |
| 0x00, |
| 0x00, // size (little endian) |
| // no entries |
| 0x00, // end marker (embedded document) |
| |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with non-empty array member") |
| { |
| json const j = { { "entry", json::array({ 1, 2, 3, 4, 5, 6, 7, 8 }) } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x49, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x04, /// entry: embedded document |
| 'e', 'n', 't', 'r', 'y', '\x00', |
| |
| 0x3D, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x10, '0', 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, '1', 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, '2', 0x00, 0x03, 0x00, |
| 0x00, 0x00, 0x10, '3', 0x00, 0x04, 0x00, 0x00, 0x00, 0x10, '4', 0x00, 0x05, 0x00, 0x00, 0x00, 0x10, '5', 0x00, |
| 0x06, 0x00, 0x00, 0x00, 0x10, '6', 0x00, 0x07, 0x00, 0x00, 0x00, 0x10, '7', 0x00, 0x08, 0x00, 0x00, 0x00, |
| 0x00, // end marker (embedded document) |
| |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with binary member") |
| { |
| const size_t N = 10; |
| const auto s = std::vector<std::uint8_t>(N, 'x'); |
| json const j = { { "entry", json::binary(s, 0) } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x1B, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x05, // entry: binary |
| 'e', 'n', 't', 'r', 'y', '\x00', |
| |
| 0x0A, 0x00, 0x00, |
| 0x00, // size of binary (little endian) |
| 0x00, // Generic binary subtype |
| 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, |
| |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("non-empty object with binary member with subtype") |
| { |
| // an MD5 hash |
| const std::vector<std::uint8_t> md5hash = { 0xd7, 0x7e, 0x27, 0x54, 0xbe, 0x12, 0x37, 0xfe, 0xd6, 0x0c, 0x33, 0x98, 0x30, 0x3b, 0x8d, 0xc4 }; |
| json const j = { { "entry", json::binary(md5hash, 5) } }; |
| |
| std::vector<std::uint8_t> const expected = { |
| 0x21, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x05, // entry: binary |
| 'e', 'n', 't', 'r', 'y', '\x00', |
| |
| 0x10, 0x00, 0x00, |
| 0x00, // size of binary (little endian) |
| 0x05, // MD5 binary subtype |
| 0xd7, 0x7e, 0x27, 0x54, 0xbe, 0x12, 0x37, 0xfe, 0xd6, 0x0c, 0x33, 0x98, 0x30, 0x3b, 0x8d, 0xc4, |
| |
| 0x00 // end marker |
| }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| |
| SECTION("Some more complex document") |
| { |
| // directly encoding uint64 is not supported in bson (only for timestamp values) |
| json const j = { { "double", 42.5 }, { "entry", 4.2 }, { "number", 12345 }, { "object", { { "string", "value" } } } }; |
| |
| std::vector<std::uint8_t> const expected = { /*size */ 0x4f, |
| 0x00, |
| 0x00, |
| 0x00, |
| /*entry*/ 0x01, |
| 'd', |
| 'o', |
| 'u', |
| 'b', |
| 'l', |
| 'e', |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x40, |
| 0x45, |
| 0x40, |
| /*entry*/ 0x01, |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| 0x00, |
| 0xcd, |
| 0xcc, |
| 0xcc, |
| 0xcc, |
| 0xcc, |
| 0xcc, |
| 0x10, |
| 0x40, |
| /*entry*/ 0x10, |
| 'n', |
| 'u', |
| 'm', |
| 'b', |
| 'e', |
| 'r', |
| 0x00, |
| 0x39, |
| 0x30, |
| 0x00, |
| 0x00, |
| /*entry*/ 0x03, |
| 'o', |
| 'b', |
| 'j', |
| 'e', |
| 'c', |
| 't', |
| 0x00, |
| /*entry: obj-size */ 0x17, |
| 0x00, |
| 0x00, |
| 0x00, |
| /*entry: obj-entry*/ 0x02, |
| 's', |
| 't', |
| 'r', |
| 'i', |
| 'n', |
| 'g', |
| 0x00, |
| 0x06, |
| 0x00, |
| 0x00, |
| 0x00, |
| 'v', |
| 'a', |
| 'l', |
| 'u', |
| 'e', |
| 0, |
| /*entry: obj-term.*/ 0x00, |
| /*obj-term*/ 0x00 }; |
| |
| const auto result = json::to_bson(j); |
| CHECK(result == expected); |
| |
| // roundtrip |
| CHECK(json::from_bson(result) == j); |
| CHECK(json::from_bson(result, true, false) == j); |
| } |
| } |
| |
| SECTION("Examples from https://bsonspec.org/faq.html") |
| { |
| SECTION("Example 1") |
| { |
| std::vector<std::uint8_t> input = { 0x16, 0x00, 0x00, 0x00, 0x02, 'h', 'e', 'l', 'l', 'o', 0x00, |
| 0x06, 0x00, 0x00, 0x00, 'w', 'o', 'r', 'l', 'd', 0x00, 0x00 }; |
| json parsed = json::from_bson(input); |
| json expected = { { "hello", "world" } }; |
| CHECK(parsed == expected); |
| auto dumped = json::to_bson(parsed); |
| CHECK(dumped == input); |
| CHECK(json::from_bson(dumped) == expected); |
| } |
| |
| SECTION("Example 2") |
| { |
| std::vector<std::uint8_t> input = { 0x31, 0x00, 0x00, 0x00, 0x04, 'B', 'S', 'O', 'N', 0x00, 0x26, 0x00, 0x00, 0x00, 0x02, 0x30, 0x00, |
| 0x08, 0x00, 0x00, 0x00, 'a', 'w', 'e', 's', 'o', 'm', 'e', 0x00, 0x01, 0x31, 0x00, 0x33, 0x33, |
| 0x33, 0x33, 0x33, 0x33, 0x14, 0x40, 0x10, 0x32, 0x00, 0xc2, 0x07, 0x00, 0x00, 0x00, 0x00 }; |
| json parsed = json::from_bson(input); |
| json expected = { { "BSON", { "awesome", 5.05, 1986 } } }; |
| CHECK(parsed == expected); |
| auto dumped = json::to_bson(parsed); |
| CHECK(dumped == input); |
| CHECK(json::from_bson(dumped) == expected); |
| } |
| } |
| } |
| |
| TEST_CASE("BSON input/output_adapters") |
| { |
| json json_representation = { { "double", 42.5 }, { "entry", 4.2 }, { "number", 12345 }, { "object", { { "string", "value" } } } }; |
| |
| std::vector<std::uint8_t> const bson_representation = { /*size */ 0x4f, |
| 0x00, |
| 0x00, |
| 0x00, |
| /*entry*/ 0x01, |
| 'd', |
| 'o', |
| 'u', |
| 'b', |
| 'l', |
| 'e', |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x00, |
| 0x40, |
| 0x45, |
| 0x40, |
| /*entry*/ 0x01, |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| 0x00, |
| 0xcd, |
| 0xcc, |
| 0xcc, |
| 0xcc, |
| 0xcc, |
| 0xcc, |
| 0x10, |
| 0x40, |
| /*entry*/ 0x10, |
| 'n', |
| 'u', |
| 'm', |
| 'b', |
| 'e', |
| 'r', |
| 0x00, |
| 0x39, |
| 0x30, |
| 0x00, |
| 0x00, |
| /*entry*/ 0x03, |
| 'o', |
| 'b', |
| 'j', |
| 'e', |
| 'c', |
| 't', |
| 0x00, |
| /*entry: obj-size */ 0x17, |
| 0x00, |
| 0x00, |
| 0x00, |
| /*entry: obj-entry*/ 0x02, |
| 's', |
| 't', |
| 'r', |
| 'i', |
| 'n', |
| 'g', |
| 0x00, |
| 0x06, |
| 0x00, |
| 0x00, |
| 0x00, |
| 'v', |
| 'a', |
| 'l', |
| 'u', |
| 'e', |
| 0, |
| /*entry: obj-term.*/ 0x00, |
| /*obj-term*/ 0x00 }; |
| |
| json j2; |
| CHECK_NOTHROW(j2 = json::from_bson(bson_representation)); |
| |
| // compare parsed JSON values |
| CHECK(json_representation == j2); |
| |
| SECTION("roundtrips") |
| { |
| SECTION("std::ostringstream") |
| { |
| std::basic_ostringstream<std::uint8_t> ss; |
| json::to_bson(json_representation, ss); |
| json j3 = json::from_bson(ss.str()); |
| CHECK(json_representation == j3); |
| } |
| |
| SECTION("std::string") |
| { |
| std::string s; |
| json::to_bson(json_representation, s); |
| json j3 = json::from_bson(s); |
| CHECK(json_representation == j3); |
| } |
| |
| SECTION("std::vector") |
| { |
| std::vector<std::uint8_t> v; |
| json::to_bson(json_representation, v); |
| json j3 = json::from_bson(v); |
| CHECK(json_representation == j3); |
| } |
| } |
| } |
| |
| namespace |
| { |
| class SaxCountdown |
| { |
| public: |
| explicit SaxCountdown(const int count) |
| : events_left(count) |
| {} |
| |
| bool null() |
| { |
| return events_left-- > 0; |
| } |
| |
| bool boolean(bool /*unused*/) |
| { |
| return events_left-- > 0; |
| } |
| |
| bool number_integer(json::number_integer_t /*unused*/) |
| { |
| return events_left-- > 0; |
| } |
| |
| bool number_unsigned(json::number_unsigned_t /*unused*/) |
| { |
| return events_left-- > 0; |
| } |
| |
| bool number_float(json::number_float_t /*unused*/, const std::string& /*unused*/) |
| { |
| return events_left-- > 0; |
| } |
| |
| bool string(std::string& /*unused*/) |
| { |
| return events_left-- > 0; |
| } |
| |
| bool binary(std::vector<std::uint8_t>& /*unused*/) |
| { |
| return events_left-- > 0; |
| } |
| |
| bool start_object(std::size_t /*unused*/) |
| { |
| return events_left-- > 0; |
| } |
| |
| bool key(std::string& /*unused*/) |
| { |
| return events_left-- > 0; |
| } |
| |
| bool end_object() |
| { |
| return events_left-- > 0; |
| } |
| |
| bool start_array(std::size_t /*unused*/) |
| { |
| return events_left-- > 0; |
| } |
| |
| bool end_array() |
| { |
| return events_left-- > 0; |
| } |
| |
| bool parse_error(std::size_t /*unused*/, |
| const std::string& /*unused*/, |
| const json::exception& /*unused*/) // NOLINT(readability-convert-member-functions-to-static) |
| { |
| return false; |
| } |
| |
| private: |
| int events_left = 0; |
| }; |
| } // namespace |
| |
| TEST_CASE("Incomplete BSON Input") |
| { |
| SECTION("Incomplete BSON Input 1") |
| { |
| std::vector<std::uint8_t> const incomplete_bson = { |
| 0x0D, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x08, // entry: boolean |
| 'e', 'n', |
| 't' // unexpected EOF |
| }; |
| |
| json _; |
| CHECK_THROWS_WITH_AS(_ = json::from_bson(incomplete_bson), |
| "[json.exception.parse_error.110] parse error at byte 9: syntax error while parsing BSON cstring: unexpected end of input", |
| json::parse_error&); |
| |
| CHECK(json::from_bson(incomplete_bson, true, false).is_discarded()); |
| |
| SaxCountdown scp(0); |
| CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson)); |
| } |
| |
| SECTION("Incomplete BSON Input 2") |
| { |
| std::vector<std::uint8_t> const incomplete_bson = { |
| 0x0D, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x08, // entry: boolean, unexpected EOF |
| }; |
| |
| json _; |
| CHECK_THROWS_WITH_AS(_ = json::from_bson(incomplete_bson), |
| "[json.exception.parse_error.110] parse error at byte 6: syntax error while parsing BSON cstring: unexpected end of input", |
| json::parse_error&); |
| CHECK(json::from_bson(incomplete_bson, true, false).is_discarded()); |
| |
| SaxCountdown scp(0); |
| CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson)); |
| } |
| |
| SECTION("Incomplete BSON Input 3") |
| { |
| std::vector<std::uint8_t> const incomplete_bson = { |
| 0x41, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x04, /// entry: embedded document |
| 'e', 'n', 't', 'r', 'y', '\x00', |
| |
| 0x35, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, |
| 0x00, 0x02, 0x00, 0x00, 0x00 |
| // missing input data... |
| }; |
| |
| json _; |
| CHECK_THROWS_WITH_AS(_ = json::from_bson(incomplete_bson), |
| "[json.exception.parse_error.110] parse error at byte 28: syntax error while parsing BSON element list: unexpected end of input", |
| json::parse_error&); |
| CHECK(json::from_bson(incomplete_bson, true, false).is_discarded()); |
| |
| SaxCountdown scp(1); |
| CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson)); |
| } |
| |
| SECTION("Incomplete BSON Input 4") |
| { |
| std::vector<std::uint8_t> const incomplete_bson = { |
| 0x0D, |
| 0x00, // size (incomplete), unexpected EOF |
| }; |
| |
| json _; |
| CHECK_THROWS_WITH_AS(_ = json::from_bson(incomplete_bson), |
| "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing BSON number: unexpected end of input", |
| json::parse_error&); |
| CHECK(json::from_bson(incomplete_bson, true, false).is_discarded()); |
| |
| SaxCountdown scp(0); |
| CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson)); |
| } |
| |
| SECTION("Improve coverage") |
| { |
| SECTION("key") |
| { |
| json const j = { { "key", "value" } }; |
| auto bson_vec = json::to_bson(j); |
| SaxCountdown scp(2); |
| CHECK(!json::sax_parse(bson_vec, &scp, json::input_format_t::bson)); |
| } |
| |
| SECTION("array") |
| { |
| json const j = { { "entry", json::array() } }; |
| auto bson_vec = json::to_bson(j); |
| SaxCountdown scp(2); |
| CHECK(!json::sax_parse(bson_vec, &scp, json::input_format_t::bson)); |
| } |
| } |
| } |
| |
| TEST_CASE("Negative size of binary value") |
| { |
| // invalid BSON: the size of the binary value is -1 |
| std::vector<std::uint8_t> const input = { |
| 0x21, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0x05, // entry: binary |
| 'e', 'n', 't', 'r', 'y', '\x00', |
| |
| 0xFF, 0xFF, 0xFF, |
| 0xFF, // size of binary (little endian) |
| 0x05, // MD5 binary subtype |
| 0xd7, 0x7e, 0x27, 0x54, 0xbe, 0x12, 0x37, 0xfe, 0xd6, 0x0c, 0x33, 0x98, 0x30, 0x3b, 0x8d, 0xc4, |
| |
| 0x00 // end marker |
| }; |
| json _; |
| CHECK_THROWS_WITH_AS( |
| _ = json::from_bson(input), |
| "[json.exception.parse_error.112] parse error at byte 15: syntax error while parsing BSON binary: byte array length cannot be negative, is -1", |
| json::parse_error); |
| } |
| |
| TEST_CASE("Unsupported BSON input") |
| { |
| std::vector<std::uint8_t> const bson = { |
| 0x0C, 0x00, 0x00, |
| 0x00, // size (little endian) |
| 0xFF, // entry type: Min key (not supported yet) |
| 'e', 'n', 't', 'r', 'y', '\x00', |
| 0x00 // end marker |
| }; |
| |
| json _; |
| CHECK_THROWS_WITH_AS(_ = json::from_bson(bson), |
| "[json.exception.parse_error.114] parse error at byte 5: Unsupported BSON record type 0xFF", |
| json::parse_error&); |
| CHECK(json::from_bson(bson, true, false).is_discarded()); |
| |
| SaxCountdown scp(0); |
| CHECK(!json::sax_parse(bson, &scp, json::input_format_t::bson)); |
| } |
| |
| TEST_CASE("BSON numerical data") |
| { |
| SECTION("number") |
| { |
| SECTION("signed") |
| { |
| SECTION("std::int64_t: INT64_MIN .. INT32_MIN-1") |
| { |
| std::vector<int64_t> const numbers{ |
| (std::numeric_limits<int64_t>::min)(), |
| -1000000000000000000LL, |
| -100000000000000000LL, |
| -10000000000000000LL, |
| -1000000000000000LL, |
| -100000000000000LL, |
| -10000000000000LL, |
| -1000000000000LL, |
| -100000000000LL, |
| -10000000000LL, |
| static_cast<std::int64_t>((std::numeric_limits<std::int32_t>::min)()) - 1, |
| }; |
| |
| for (const auto i : numbers) |
| { |
| CAPTURE(i) |
| |
| json const j = { { "entry", i } }; |
| CHECK(j.at("entry").is_number_integer()); |
| |
| std::uint64_t const iu = *reinterpret_cast<const std::uint64_t*>(&i); |
| std::vector<std::uint8_t> const expected_bson = { |
| 0x14u, |
| 0x00u, |
| 0x00u, |
| 0x00u, // size (little endian) |
| 0x12u, /// entry: int64 |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| '\x00', |
| static_cast<std::uint8_t>((iu >> (8u * 0u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 1u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 2u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 3u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 4u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 5u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 6u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 7u)) & 0xffu), |
| 0x00u // end marker |
| }; |
| |
| const auto bson = json::to_bson(j); |
| CHECK(bson == expected_bson); |
| |
| auto j_roundtrip = json::from_bson(bson); |
| |
| CHECK(j_roundtrip.at("entry").is_number_integer()); |
| CHECK(j_roundtrip == j); |
| CHECK(json::from_bson(bson, true, false) == j); |
| } |
| } |
| |
| SECTION("signed std::int32_t: INT32_MIN .. INT32_MAX") |
| { |
| std::vector<int32_t> const numbers{ (std::numeric_limits<int32_t>::min)(), |
| -2147483647L, |
| -1000000000L, |
| -100000000L, |
| -10000000L, |
| -1000000L, |
| -100000L, |
| -10000L, |
| -1000L, |
| -100L, |
| -10L, |
| -1L, |
| 0L, |
| 1L, |
| 10L, |
| 100L, |
| 1000L, |
| 10000L, |
| 100000L, |
| 1000000L, |
| 10000000L, |
| 100000000L, |
| 1000000000L, |
| 2147483646L, |
| (std::numeric_limits<int32_t>::max)() }; |
| |
| for (const auto i : numbers) |
| { |
| CAPTURE(i) |
| |
| json const j = { { "entry", i } }; |
| CHECK(j.at("entry").is_number_integer()); |
| |
| std::uint32_t const iu = *reinterpret_cast<const std::uint32_t*>(&i); |
| std::vector<std::uint8_t> const expected_bson = { |
| 0x10u, |
| 0x00u, |
| 0x00u, |
| 0x00u, // size (little endian) |
| 0x10u, /// entry: int32 |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| '\x00', |
| static_cast<std::uint8_t>((iu >> (8u * 0u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 1u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 2u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 3u)) & 0xffu), |
| 0x00u // end marker |
| }; |
| |
| const auto bson = json::to_bson(j); |
| CHECK(bson == expected_bson); |
| |
| auto j_roundtrip = json::from_bson(bson); |
| |
| CHECK(j_roundtrip.at("entry").is_number_integer()); |
| CHECK(j_roundtrip == j); |
| CHECK(json::from_bson(bson, true, false) == j); |
| } |
| } |
| |
| SECTION("signed std::int64_t: INT32_MAX+1 .. INT64_MAX") |
| { |
| std::vector<int64_t> const numbers{ |
| (std::numeric_limits<int64_t>::max)(), |
| 1000000000000000000LL, |
| 100000000000000000LL, |
| 10000000000000000LL, |
| 1000000000000000LL, |
| 100000000000000LL, |
| 10000000000000LL, |
| 1000000000000LL, |
| 100000000000LL, |
| 10000000000LL, |
| static_cast<std::int64_t>((std::numeric_limits<int32_t>::max)()) + 1, |
| }; |
| |
| for (const auto i : numbers) |
| { |
| CAPTURE(i) |
| |
| json const j = { { "entry", i } }; |
| CHECK(j.at("entry").is_number_integer()); |
| |
| std::uint64_t const iu = *reinterpret_cast<const std::uint64_t*>(&i); |
| std::vector<std::uint8_t> const expected_bson = { |
| 0x14u, |
| 0x00u, |
| 0x00u, |
| 0x00u, // size (little endian) |
| 0x12u, /// entry: int64 |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| '\x00', |
| static_cast<std::uint8_t>((iu >> (8u * 0u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 1u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 2u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 3u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 4u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 5u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 6u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 7u)) & 0xffu), |
| 0x00u // end marker |
| }; |
| |
| const auto bson = json::to_bson(j); |
| CHECK(bson == expected_bson); |
| |
| auto j_roundtrip = json::from_bson(bson); |
| |
| CHECK(j_roundtrip.at("entry").is_number_integer()); |
| CHECK(j_roundtrip == j); |
| CHECK(json::from_bson(bson, true, false) == j); |
| } |
| } |
| } |
| |
| SECTION("unsigned") |
| { |
| SECTION("unsigned std::uint64_t: 0 .. INT32_MAX") |
| { |
| std::vector<std::uint64_t> const numbers{ 0ULL, |
| 1ULL, |
| 10ULL, |
| 100ULL, |
| 1000ULL, |
| 10000ULL, |
| 100000ULL, |
| 1000000ULL, |
| 10000000ULL, |
| 100000000ULL, |
| 1000000000ULL, |
| 2147483646ULL, |
| static_cast<std::uint64_t>((std::numeric_limits<int32_t>::max)()) }; |
| |
| for (const auto i : numbers) |
| { |
| CAPTURE(i) |
| |
| json const j = { { "entry", i } }; |
| |
| auto iu = i; |
| std::vector<std::uint8_t> const expected_bson = { |
| 0x10u, |
| 0x00u, |
| 0x00u, |
| 0x00u, // size (little endian) |
| 0x10u, /// entry: int32 |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| '\x00', |
| static_cast<std::uint8_t>((iu >> (8u * 0u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 1u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 2u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 3u)) & 0xffu), |
| 0x00u // end marker |
| }; |
| |
| const auto bson = json::to_bson(j); |
| CHECK(bson == expected_bson); |
| |
| auto j_roundtrip = json::from_bson(bson); |
| |
| CHECK(j.at("entry").is_number_unsigned()); |
| CHECK(j_roundtrip.at("entry").is_number_integer()); |
| CHECK(j_roundtrip == j); |
| CHECK(json::from_bson(bson, true, false) == j); |
| } |
| } |
| |
| SECTION("unsigned std::uint64_t: INT32_MAX+1 .. INT64_MAX") |
| { |
| std::vector<std::uint64_t> const numbers{ |
| static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()) + 1, |
| 4000000000ULL, |
| static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()), |
| 10000000000ULL, |
| 100000000000ULL, |
| 1000000000000ULL, |
| 10000000000000ULL, |
| 100000000000000ULL, |
| 1000000000000000ULL, |
| 10000000000000000ULL, |
| 100000000000000000ULL, |
| 1000000000000000000ULL, |
| static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()), |
| }; |
| |
| for (const auto i : numbers) |
| { |
| CAPTURE(i) |
| |
| json const j = { { "entry", i } }; |
| |
| auto iu = i; |
| std::vector<std::uint8_t> const expected_bson = { |
| 0x14u, |
| 0x00u, |
| 0x00u, |
| 0x00u, // size (little endian) |
| 0x12u, /// entry: int64 |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| '\x00', |
| static_cast<std::uint8_t>((iu >> (8u * 0u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 1u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 2u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 3u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 4u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 5u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 6u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 7u)) & 0xffu), |
| 0x00u // end marker |
| }; |
| |
| const auto bson = json::to_bson(j); |
| CHECK(bson == expected_bson); |
| |
| auto j_roundtrip = json::from_bson(bson); |
| |
| CHECK(j.at("entry").is_number_unsigned()); |
| CHECK(j_roundtrip.at("entry").is_number_integer()); |
| CHECK(j_roundtrip == j); |
| CHECK(json::from_bson(bson, true, false) == j); |
| } |
| } |
| |
| SECTION("unsigned std::uint64_t: INT64_MAX+1 .. UINT64_MAX") |
| { |
| std::vector<std::uint64_t> const numbers{ |
| static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()) + 1ULL, |
| 10000000000000000000ULL, |
| 18000000000000000000ULL, |
| (std::numeric_limits<std::uint64_t>::max)() - 1ULL, |
| (std::numeric_limits<std::uint64_t>::max)(), |
| }; |
| |
| for (const auto i : numbers) |
| { |
| CAPTURE(i) |
| |
| json const j = { { "entry", i } }; |
| |
| auto iu = i; |
| std::vector<std::uint8_t> const expected_bson = { |
| 0x14u, |
| 0x00u, |
| 0x00u, |
| 0x00u, // size (little endian) |
| 0x12u, /// entry: int64 |
| 'e', |
| 'n', |
| 't', |
| 'r', |
| 'y', |
| '\x00', |
| static_cast<std::uint8_t>((iu >> (8u * 0u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 1u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 2u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 3u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 4u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 5u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 6u)) & 0xffu), |
| static_cast<std::uint8_t>((iu >> (8u * 7u)) & 0xffu), |
| 0x00u // end marker |
| }; |
| |
| CHECK_THROWS_AS(json::to_bson(j), json::out_of_range&); |
| #if JSON_DIAGNOSTICS |
| CHECK_THROWS_WITH_STD_STR(json::to_bson(j), |
| "[json.exception.out_of_range.407] (/entry) integer number " + std::to_string(i) + |
| " cannot be represented by BSON as it does not fit int64"); |
| #else |
| CHECK_THROWS_WITH_STD_STR(json::to_bson(j), |
| "[json.exception.out_of_range.407] integer number " + std::to_string(i) + |
| " cannot be represented by BSON as it does not fit int64"); |
| #endif |
| } |
| } |
| } |
| } |
| } |
| |
| TEST_CASE("BSON roundtrips" * doctest::skip()) |
| { |
| SECTION("reference files") |
| { |
| for (const std::string filename : { TEST_DATA_DIRECTORY "/json.org/1.json", |
| TEST_DATA_DIRECTORY "/json.org/2.json", |
| TEST_DATA_DIRECTORY "/json.org/3.json", |
| TEST_DATA_DIRECTORY "/json.org/4.json", |
| TEST_DATA_DIRECTORY "/json.org/5.json" }) |
| { |
| CAPTURE(filename) |
| |
| { |
| INFO_WITH_TEMP(filename + ": std::vector<std::uint8_t>"); |
| // parse JSON file |
| std::ifstream f_json(filename); |
| json j1 = json::parse(f_json); |
| |
| // parse BSON file |
| auto packed = utils::read_binary_file(filename + ".bson"); |
| json j2; |
| CHECK_NOTHROW(j2 = json::from_bson(packed)); |
| |
| // compare parsed JSON values |
| CHECK(j1 == j2); |
| } |
| |
| { |
| INFO_WITH_TEMP(filename + ": std::ifstream"); |
| // parse JSON file |
| std::ifstream f_json(filename); |
| json j1 = json::parse(f_json); |
| |
| // parse BSON file |
| std::ifstream f_bson(filename + ".bson", std::ios::binary); |
| json j2; |
| CHECK_NOTHROW(j2 = json::from_bson(f_bson)); |
| |
| // compare parsed JSON values |
| CHECK(j1 == j2); |
| } |
| |
| { |
| INFO_WITH_TEMP(filename + ": uint8_t* and size"); |
| // parse JSON file |
| std::ifstream f_json(filename); |
| json j1 = json::parse(f_json); |
| |
| // parse BSON file |
| auto packed = utils::read_binary_file(filename + ".bson"); |
| json j2; |
| CHECK_NOTHROW(j2 = json::from_bson({ packed.data(), packed.size() })); |
| |
| // compare parsed JSON values |
| CHECK(j1 == j2); |
| } |
| |
| { |
| INFO_WITH_TEMP(filename + ": output to output adapters"); |
| // parse JSON file |
| std::ifstream f_json(filename); |
| json const j1 = json::parse(f_json); |
| |
| // parse BSON file |
| auto packed = utils::read_binary_file(filename + ".bson"); |
| |
| { |
| INFO_WITH_TEMP(filename + ": output adapters: std::vector<std::uint8_t>"); |
| std::vector<std::uint8_t> vec; |
| json::to_bson(j1, vec); |
| |
| if (vec != packed) |
| { |
| // the exact serializations may differ due to the order of |
| // object keys; in these cases, just compare whether both |
| // serializations create the same JSON value |
| CHECK(json::from_bson(vec) == json::from_bson(packed)); |
| } |
| } |
| } |
| } |
| } |
| } |
