Merge branch 'develop' of https://github.com/nlohmann/json into feature/optional

test/src/fuzzer-driver_afl.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 This file implements a driver for American Fuzzy Lop (afl-fuzz). It relies on

test/src/fuzzer-parse_bson.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 This file implements a parser test suitable for fuzz testing. Given a byte

test/src/fuzzer-parse_cbor.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 This file implements a parser test suitable for fuzz testing. Given a byte

test/src/fuzzer-parse_json.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 This file implements a parser test suitable for fuzz testing. Given a byte

test/src/fuzzer-parse_msgpack.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 This file implements a parser test suitable for fuzz testing. Given a byte

test/src/fuzzer-parse_ubjson.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (fuzz test support)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 This file implements a parser test suitable for fuzz testing. Given a byte
@@ -11,6 +11,12 @@ array data, it performs the following steps:
 - vec = to_ubjson(j1)
 - j2 = from_ubjson(vec)
 - assert(j1 == j2)
+- vec2 = to_ubjson(j1, use_size = true, use_type = false)
+- j3 = from_ubjson(vec2)
+- assert(j1 == j3)
+- vec3 = to_ubjson(j1, use_size = true, use_type = true)
+- j4 = from_ubjson(vec3)
+- assert(j1 == j4)
 
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
@@ -35,14 +41,24 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 
         try
         {
-            // step 2: round trip
-            std::vector<uint8_t> vec2 = json::to_ubjson(j1);
+            // step 2.1: round trip without adding size annotations to container types
+            std::vector<uint8_t> vec2 = json::to_ubjson(j1, false, false);
+
+            // step 2.2: round trip with adding size annotations but without adding type annonations to container types
+            std::vector<uint8_t> vec3 = json::to_ubjson(j1, true, false);
+
+            // step 2.3: round trip with adding size as well as type annotations to container types
+            std::vector<uint8_t> vec4 = json::to_ubjson(j1, true, true);
 
             // parse serialization
             json j2 = json::from_ubjson(vec2);
+            json j3 = json::from_ubjson(vec3);
+            json j4 = json::from_ubjson(vec4);
 
             // serializations must match
-            assert(json::to_ubjson(j2) == vec2);
+            assert(json::to_ubjson(j2, false, false) == vec2);
+            assert(json::to_ubjson(j3, true, false) == vec3);
+            assert(json::to_ubjson(j4, true, true) == vec4);
         }
         catch (const json::parse_error&)
         {

test/src/test_utils.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdint> // uint8_t
+#include <fstream> // ifstream, istreambuf_iterator, ios
+#include <vector> // vector
+
+namespace utils
+{
+
+inline std::vector<std::uint8_t> read_binary_file(const std::string& filename)
+{
+    std::ifstream file(filename, std::ios::binary);
+    file.unsetf(std::ios::skipws);
+
+    file.seekg(0, std::ios::end);
+    const auto size = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    std::vector<std::uint8_t> byte_vector;
+    byte_vector.reserve(static_cast<std::size_t>(size));
+    byte_vector.insert(byte_vector.begin(), std::istream_iterator<std::uint8_t>(file), std::istream_iterator<std::uint8_t>());
+    return byte_vector;
+}
+
+} // namespace utils

test/src/unit-algorithms.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -55,7 +55,7 @@ TEST_CASE("algorithms")
         {
             CHECK(std::any_of(j_array.begin(), j_array.end(), [](const json & value)
             {
-                return value.is_string() and value.get<std::string>() == "foo";
+                return value.is_string() && value.get<std::string>() == "foo";
             }));
             CHECK(std::any_of(j_object.begin(), j_object.end(), [](const json & value)
             {
@@ -139,14 +139,14 @@ TEST_CASE("algorithms")
             {
                 CHECK(std::equal(j_array.begin(), j_array.end(), j_array.begin()));
                 CHECK(std::equal(j_object.begin(), j_object.end(), j_object.begin()));
-                CHECK(not std::equal(j_array.begin(), j_array.end(), j_object.begin()));
+                CHECK(!std::equal(j_array.begin(), j_array.end(), j_object.begin()));
             }
 
             SECTION("using user-defined comparison")
             {
                 // compare objects only by size of its elements
                 json j_array2 = {13, 29, 3, {"Hello", "World"}, true, false, {{"one", 1}, {"two", 2}, {"three", 3}}, "foo", "baz"};
-                CHECK(not std::equal(j_array.begin(), j_array.end(), j_array2.begin()));
+                CHECK(!std::equal(j_array.begin(), j_array.end(), j_array2.begin()));
                 CHECK(std::equal(j_array.begin(), j_array.end(), j_array2.begin(),
                                  [](const json & a, const json & b)
                 {
@@ -213,7 +213,7 @@ TEST_CASE("algorithms")
                 return v.is_string();
             });
             CHECK(std::distance(j_array.begin(), it) == 2);
-            CHECK(not it[2].is_string());
+            CHECK(!it[2].is_string());
         }
     }
 

test/src/unit-allocator.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-alt-string.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -225,9 +225,9 @@ TEST_CASE("alternative string type")
 
         {
             alt_json doc;
-            doc["list"] = { 1, 0, 2 };
+            doc["object"] = { {"currency", "USD"}, {"value", 42.99} };
             alt_string dump = doc.dump();
-            CHECK(dump == R"({"list":[1,0,2]})");
+            CHECK(dump == R"({"object":{"currency":"USD","value":42.99}})");
         }
     }
 

test/src/unit-assert_macro.cpp

@@ -0,0 +1,65 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++ (test suite)
+|  |  |__   |  |  | | | |  version 3.9.1
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+// avoid warning when assert does not abort
+#if defined(__GNUC__)
+    #pragma GCC diagnostic ignored "-Wstrict-overflow"
+#endif
+
+#include "doctest_compatibility.h"
+
+/// global variable to record side effect of assert calls
+static int assert_counter;
+
+/// set failure variable to true instead of calling assert(x)
+#define JSON_ASSERT(x) {if (!(x)) ++assert_counter; }
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+
+// the test assumes exceptions to work
+#if !defined(JSON_NOEXCEPTION)
+TEST_CASE("JSON_ASSERT(x)")
+{
+    SECTION("basic_json(first, second)")
+    {
+        assert_counter = 0;
+        CHECK(assert_counter == 0);
+
+        json::iterator it;
+        json j;
+
+        // in case assertions do not abort execution, an exception is thrown
+        CHECK_THROWS_WITH_AS(json(it, j.end()), "[json.exception.invalid_iterator.201] iterators are not compatible", json::invalid_iterator);
+
+        // check that assertion actually happened
+        CHECK(assert_counter == 1);
+    }
+}
+#endif

test/src/unit-bson.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -35,6 +35,7 @@ using nlohmann::json;
 #include <fstream>
 #include <sstream>
 #include <test_data.hpp>
+#include "test_utils.hpp"
 
 TEST_CASE("BSON")
 {
@@ -766,7 +767,7 @@ TEST_CASE("Incomplete BSON Input")
         CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
 
         SaxCountdown scp(0);
-        CHECK(not json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
+        CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
     }
 
     SECTION("Incomplete BSON Input 2")
@@ -784,7 +785,7 @@ TEST_CASE("Incomplete BSON Input")
         CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
 
         SaxCountdown scp(0);
-        CHECK(not json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
+        CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
     }
 
     SECTION("Incomplete BSON Input 3")
@@ -808,7 +809,7 @@ TEST_CASE("Incomplete BSON Input")
         CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
 
         SaxCountdown scp(1);
-        CHECK(not json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
+        CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
     }
 
     SECTION("Incomplete BSON Input 4")
@@ -825,7 +826,7 @@ TEST_CASE("Incomplete BSON Input")
         CHECK(json::from_bson(incomplete_bson, true, false).is_discarded());
 
         SaxCountdown scp(0);
-        CHECK(not json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
+        CHECK(!json::sax_parse(incomplete_bson, &scp, json::input_format_t::bson));
     }
 
     SECTION("Improve coverage")
@@ -835,7 +836,7 @@ TEST_CASE("Incomplete BSON Input")
             json j = {{"key", "value"}};
             auto bson_vec = json::to_bson(j);
             SaxCountdown scp(2);
-            CHECK(not json::sax_parse(bson_vec, &scp, json::input_format_t::bson));
+            CHECK(!json::sax_parse(bson_vec, &scp, json::input_format_t::bson));
         }
 
         SECTION("array")
@@ -846,7 +847,7 @@ TEST_CASE("Incomplete BSON Input")
             };
             auto bson_vec = json::to_bson(j);
             SaxCountdown scp(2);
-            CHECK(not json::sax_parse(bson_vec, &scp, json::input_format_t::bson));
+            CHECK(!json::sax_parse(bson_vec, &scp, json::input_format_t::bson));
         }
     }
 }
@@ -887,7 +888,7 @@ TEST_CASE("Unsupported BSON input")
     CHECK(json::from_bson(bson, true, false).is_discarded());
 
     SaxCountdown scp(0);
-    CHECK(not json::sax_parse(bson, &scp, json::input_format_t::bson));
+    CHECK(!json::sax_parse(bson, &scp, json::input_format_t::bson));
 }
 
 TEST_CASE("BSON numerical data")
@@ -1263,10 +1264,7 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                 json j1 = json::parse(f_json);
 
                 // parse BSON file
-                std::ifstream f_bson(filename + ".bson", std::ios::binary);
-                std::vector<std::uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_bson)),
-                    std::istreambuf_iterator<char>());
+                auto packed = utils::read_binary_file(filename + ".bson");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_bson(packed));
 
@@ -1296,10 +1294,7 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                 json j1 = json::parse(f_json);
 
                 // parse BSON file
-                std::ifstream f_bson(filename + ".bson", std::ios::binary);
-                std::vector<std::uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_bson)),
-                    std::istreambuf_iterator<char>());
+                auto packed = utils::read_binary_file(filename + ".bson");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_bson({packed.data(), packed.size()}));
 
@@ -1314,10 +1309,7 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                 json j1 = json::parse(f_json);
 
                 // parse BSON file
-                std::ifstream f_bson(filename + ".bson", std::ios::binary);
-                std::vector<std::uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_bson)),
-                    std::istreambuf_iterator<char>());
+                auto packed = utils::read_binary_file(filename + ".bson");
 
                 {
                     INFO_WITH_TEMP(filename + ": output adapters: std::vector<std::uint8_t>");

test/src/unit-capacity.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-cbor.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -39,6 +39,7 @@ using nlohmann::json;
 #include <iostream>
 #include <set>
 #include <test_data.hpp>
+#include "test_utils.hpp"
 
 namespace
 {
@@ -1011,21 +1012,21 @@ TEST_CASE("CBOR")
                     SECTION("0 (0 00000 0000000000)")
                     {
                         json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x00, 0x00}));
-                        json::number_float_t d = j;
+                        json::number_float_t d{j};
                         CHECK(d == 0.0);
                     }
 
                     SECTION("-0 (1 00000 0000000000)")
                     {
                         json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x80, 0x00}));
-                        json::number_float_t d = j;
+                        json::number_float_t d{j};
                         CHECK(d == -0.0);
                     }
 
                     SECTION("2**-24 (0 00000 0000000001)")
                     {
                         json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x00, 0x01}));
-                        json::number_float_t d = j;
+                        json::number_float_t d{j};
                         CHECK(d == std::pow(2.0, -24.0));
                     }
                 }
@@ -1035,7 +1036,7 @@ TEST_CASE("CBOR")
                     SECTION("infinity (0 11111 0000000000)")
                     {
                         json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c, 0x00}));
-                        json::number_float_t d = j;
+                        json::number_float_t d{j};
                         CHECK(d == std::numeric_limits<json::number_float_t>::infinity());
                         CHECK(j.dump() == "null");
                     }
@@ -1043,7 +1044,7 @@ TEST_CASE("CBOR")
                     SECTION("-infinity (1 11111 0000000000)")
                     {
                         json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0xfc, 0x00}));
-                        json::number_float_t d = j;
+                        json::number_float_t d{j};
                         CHECK(d == -std::numeric_limits<json::number_float_t>::infinity());
                         CHECK(j.dump() == "null");
                     }
@@ -1054,21 +1055,21 @@ TEST_CASE("CBOR")
                     SECTION("1 (0 01111 0000000000)")
                     {
                         json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x3c, 0x00}));
-                        json::number_float_t d = j;
+                        json::number_float_t d{j};
                         CHECK(d == 1);
                     }
 
                     SECTION("-2 (1 10000 0000000000)")
                     {
                         json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0xc0, 0x00}));
-                        json::number_float_t d = j;
+                        json::number_float_t d{j};
                         CHECK(d == -2);
                     }
 
                     SECTION("65504 (0 11110 1111111111)")
                     {
                         json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7b, 0xff}));
-                        json::number_float_t d = j;
+                        json::number_float_t d{j};
                         CHECK(d == 65504);
                     }
                 }
@@ -1076,15 +1077,15 @@ TEST_CASE("CBOR")
                 SECTION("infinity")
                 {
                     json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c, 0x00}));
-                    json::number_float_t d = j;
-                    CHECK(not std::isfinite(d));
+                    json::number_float_t d{j};
+                    CHECK(!std::isfinite(d));
                     CHECK(j.dump() == "null");
                 }
 
                 SECTION("NaN")
                 {
                     json j = json::from_cbor(std::vector<uint8_t>({0xf9, 0x7e, 0x00}));
-                    json::number_float_t d = j;
+                    json::number_float_t d{j};
                     CHECK(std::isnan(d));
                     CHECK(j.dump() == "null");
                 }
@@ -1869,7 +1870,7 @@ TEST_CASE("CBOR")
             {
                 const auto result = json::from_cbor(vec, false);
                 CHECK(result == json());
-                CHECK(not json::from_cbor(vec, false, false).is_discarded());
+                CHECK(!json::from_cbor(vec, false, false).is_discarded());
             }
 
             SECTION("strict mode")
@@ -1889,21 +1890,21 @@ TEST_CASE("CBOR")
         {
             std::vector<uint8_t> v = {0x83, 0x01, 0x02, 0x03};
             SaxCountdown scp(0);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::cbor));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::cbor));
         }
 
         SECTION("start_object(len)")
         {
             std::vector<uint8_t> v = {0xA1, 0x63, 0x66, 0x6F, 0x6F, 0xF4};
             SaxCountdown scp(0);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::cbor));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::cbor));
         }
 
         SECTION("key()")
         {
             std::vector<uint8_t> v = {0xA1, 0x63, 0x66, 0x6F, 0x6F, 0xF4};
             SaxCountdown scp(1);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::cbor));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::cbor));
         }
     }
 }
@@ -1920,9 +1921,7 @@ TEST_CASE("single CBOR roundtrip")
         json j1 = json::parse(f_json);
 
         // parse CBOR file
-        std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
-        std::vector<uint8_t> packed((std::istreambuf_iterator<char>(f_cbor)),
-                                    std::istreambuf_iterator<char>());
+        auto packed = utils::read_binary_file(filename + ".cbor");
         json j2;
         CHECK_NOTHROW(j2 = json::from_cbor(packed));
 
@@ -1954,7 +1953,7 @@ TEST_CASE("single CBOR roundtrip")
     }
 }
 
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
 TEST_CASE("CBOR regressions")
 {
     SECTION("fuzz test results")
@@ -1994,10 +1993,7 @@ TEST_CASE("CBOR regressions")
             try
             {
                 // parse CBOR file
-                std::ifstream f_cbor(filename, std::ios::binary);
-                std::vector<uint8_t> vec1(
-                    (std::istreambuf_iterator<char>(f_cbor)),
-                    std::istreambuf_iterator<char>());
+                auto vec1 = utils::read_binary_file(filename);
                 json j1 = json::from_cbor(vec1);
 
                 try
@@ -2204,10 +2200,7 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
                 json j1 = json::parse(f_json);
 
                 // parse CBOR file
-                std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
-                std::vector<uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_cbor)),
-                    std::istreambuf_iterator<char>());
+                auto packed = utils::read_binary_file(filename + ".cbor");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_cbor(packed));
 
@@ -2237,10 +2230,7 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
                 json j1 = json::parse(f_json);
 
                 // parse CBOR file
-                std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
-                std::vector<uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_cbor)),
-                    std::istreambuf_iterator<char>());
+                auto packed = utils::read_binary_file(filename + ".cbor");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_cbor({packed.data(), packed.size()}));
 
@@ -2255,10 +2245,7 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
                 json j1 = json::parse(f_json);
 
                 // parse CBOR file
-                std::ifstream f_cbor(filename + ".cbor", std::ios::binary);
-                std::vector<uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_cbor)),
-                    std::istreambuf_iterator<char>());
+                auto packed = utils::read_binary_file(filename + ".cbor");
 
                 if (!exclude_packed.count(filename))
                 {
@@ -2274,7 +2261,7 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
     }
 }
 
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
 TEST_CASE("all CBOR first bytes")
 {
     // these bytes will fail immediately with exception parse_error.112
@@ -2493,16 +2480,14 @@ TEST_CASE("examples from RFC 7049 Appendix A")
 
     SECTION("byte arrays")
     {
-        std::ifstream f_cbor(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.cbor", std::ios::binary);
-        std::vector<uint8_t> packed((std::istreambuf_iterator<char>(f_cbor)),
-                                    std::istreambuf_iterator<char>());
+        auto packed = utils::read_binary_file(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.cbor");
         json j;
         CHECK_NOTHROW(j = json::from_cbor(packed));
 
-        std::ifstream f_bin(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.out", std::ios::binary);
-        std::vector<uint8_t> expected((std::istreambuf_iterator<char>(f_bin)),
-                                      std::istreambuf_iterator<char>());
+        auto expected = utils::read_binary_file(TEST_DATA_DIRECTORY "/binary_data/cbor_binary.out");
         CHECK(j == json::binary(expected));
+
+        CHECK(json::to_cbor(json::binary(std::vector<uint8_t> {}, 0x42)) == std::vector<uint8_t> {0xd8, 0x42, 0x40});
     }
 
     SECTION("arrays")
@@ -2548,3 +2533,197 @@ TEST_CASE("examples from RFC 7049 Appendix A")
         CHECK(json::parse("{\"Fun\": true, \"Amt\": -2}") == json::from_cbor(std::vector<uint8_t>({0xbf, 0x63, 0x46, 0x75, 0x6e, 0xf5, 0x63, 0x41, 0x6d, 0x74, 0x21, 0xff})));
     }
 }
+
+TEST_CASE("Tagged values")
+{
+    json j = "s";
+    auto v = json::to_cbor(j);
+
+    SECTION("0xC6..0xD4")
+    {
+        for (auto b : std::vector<std::uint8_t>
+    {
+        0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4
+    })
+        {
+            // add tag to value
+            auto v_tagged = v;
+            v_tagged.insert(v_tagged.begin(), b);
+
+            // check that parsing fails in error mode
+            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+            // check that parsing succeeds and gets original value in ignore mode
+            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+            CHECK(j_tagged == j);
+        }
+    }
+
+    SECTION("0xD8 - 1 byte follows")
+    {
+        SECTION("success")
+        {
+            // add tag to value
+            auto v_tagged = v;
+            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0xD8); // tag
+
+            // check that parsing fails in error mode
+            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+            // check that parsing succeeds and gets original value in ignore mode
+            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+            CHECK(j_tagged == j);
+        }
+
+        SECTION("missing byte after tag")
+        {
+            // add tag to value
+            auto v_tagged = v;
+            v_tagged.insert(v_tagged.begin(), 0xD8); // tag
+
+            // check that parsing fails in all modes
+            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
+        }
+    }
+
+    SECTION("0xD9 - 2 byte follow")
+    {
+        SECTION("success")
+        {
+            // add tag to value
+            auto v_tagged = v;
+            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0xD9); // tag
+
+            // check that parsing fails in error mode
+            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+            // check that parsing succeeds and gets original value in ignore mode
+            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+            CHECK(j_tagged == j);
+        }
+
+        SECTION("missing byte after tag")
+        {
+            // add tag to value
+            auto v_tagged = v;
+            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0xD9); // tag
+
+            // check that parsing fails in all modes
+            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
+        }
+    }
+
+    SECTION("0xDA - 4 bytes follow")
+    {
+        SECTION("success")
+        {
+            // add tag to value
+            auto v_tagged = v;
+            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0xDA); // tag
+
+            // check that parsing fails in error mode
+            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+            // check that parsing succeeds and gets original value in ignore mode
+            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+            CHECK(j_tagged == j);
+        }
+
+        SECTION("missing bytes after tag")
+        {
+            // add tag to value
+            auto v_tagged = v;
+            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0xDA); // tag
+
+            // check that parsing fails in all modes
+            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
+        }
+    }
+
+    SECTION("0xDB - 8 bytes follow")
+    {
+        SECTION("success")
+        {
+            // add tag to value
+            auto v_tagged = v;
+            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0xDB); // tag
+
+            // check that parsing fails in error mode
+            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+
+            // check that parsing succeeds and gets original value in ignore mode
+            auto j_tagged = json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore);
+            CHECK(j_tagged == j);
+        }
+
+        SECTION("missing byte after tag")
+        {
+            // add tag to value
+            auto v_tagged = v;
+            v_tagged.insert(v_tagged.begin(), 0x42); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x23); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x22); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0x11); // 1 byte
+            v_tagged.insert(v_tagged.begin(), 0xDB); // tag
+
+            // check that parsing fails in all modes
+            CHECK_THROWS_AS(json::from_cbor(v_tagged), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::error), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(v_tagged, true, true, json::cbor_tag_handler_t::ignore), json::parse_error);
+        }
+    }
+
+    SECTION("tagged binary")
+    {
+        // create a binary value of subtype 42
+        json j_binary;
+        j_binary["binary"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);
+
+        // convert to CBOR
+        const auto vec = json::to_cbor(j_binary);
+        CHECK(vec == std::vector<std::uint8_t> {0xA1, 0x66, 0x62, 0x69, 0x6E, 0x61, 0x72, 0x79, 0xD8, 0x2A, 0x44, 0xCA, 0xFE, 0xBA, 0xBE});
+
+        // parse error when parsing tagged value
+        CHECK_THROWS_AS(json::from_cbor(vec), json::parse_error);
+        CHECK_THROWS_WITH(json::from_cbor(vec), "[json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: invalid byte: 0xD8");
+
+        // binary without subtype when tags are ignored
+        json jb = json::from_cbor(vec, true, true, json::cbor_tag_handler_t::ignore);
+        CHECK(jb.is_object());
+        CHECK(jb["binary"].is_binary());
+        CHECK(!jb["binary"].get_binary().has_subtype());
+    }
+}

test/src/unit-class_const_iterator.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -224,7 +224,7 @@ TEST_CASE("const_iterator class")
                 json::const_iterator it = j.cbegin();
                 CHECK((it.m_it.primitive_iterator.m_it == 1));
                 it++;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("number")
@@ -235,7 +235,7 @@ TEST_CASE("const_iterator class")
                 it++;
                 CHECK((it.m_it.primitive_iterator.m_it == 1));
                 it++;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("object")
@@ -275,7 +275,7 @@ TEST_CASE("const_iterator class")
                 json::const_iterator it = j.cbegin();
                 CHECK((it.m_it.primitive_iterator.m_it == 1));
                 ++it;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("number")
@@ -286,7 +286,7 @@ TEST_CASE("const_iterator class")
                 ++it;
                 CHECK((it.m_it.primitive_iterator.m_it == 1));
                 ++it;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("object")
@@ -335,7 +335,7 @@ TEST_CASE("const_iterator class")
                 it--;
                 CHECK((it.m_it.primitive_iterator.m_it == 0));
                 it--;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("object")
@@ -384,7 +384,7 @@ TEST_CASE("const_iterator class")
                 --it;
                 CHECK((it.m_it.primitive_iterator.m_it == 0));
                 --it;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("object")

test/src/unit-class_iterator.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -208,7 +208,7 @@ TEST_CASE("iterator class")
                 json::iterator it = j.begin();
                 CHECK((it.m_it.primitive_iterator.m_it == 1));
                 it++;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("number")
@@ -219,7 +219,7 @@ TEST_CASE("iterator class")
                 it++;
                 CHECK((it.m_it.primitive_iterator.m_it == 1));
                 it++;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("object")
@@ -259,7 +259,7 @@ TEST_CASE("iterator class")
                 json::iterator it = j.begin();
                 CHECK((it.m_it.primitive_iterator.m_it == 1));
                 ++it;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("number")
@@ -270,7 +270,7 @@ TEST_CASE("iterator class")
                 ++it;
                 CHECK((it.m_it.primitive_iterator.m_it == 1));
                 ++it;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("object")
@@ -319,7 +319,7 @@ TEST_CASE("iterator class")
                 it--;
                 CHECK((it.m_it.primitive_iterator.m_it == 0));
                 it--;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("object")
@@ -368,7 +368,7 @@ TEST_CASE("iterator class")
                 --it;
                 CHECK((it.m_it.primitive_iterator.m_it == 0));
                 --it;
-                CHECK((it.m_it.primitive_iterator.m_it != 0 and it.m_it.primitive_iterator.m_it != 1));
+                CHECK((it.m_it.primitive_iterator.m_it != 0 && it.m_it.primitive_iterator.m_it != 1));
             }
 
             SECTION("object")

test/src/unit-class_lexer.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -37,14 +37,23 @@ using nlohmann::json;
 namespace
 {
 // shortcut to scan a string literal
-json::lexer::token_type scan_string(const char* s);
-json::lexer::token_type scan_string(const char* s)
+json::lexer::token_type scan_string(const char* s, const bool ignore_comments = false);
+json::lexer::token_type scan_string(const char* s, const bool ignore_comments)
 {
     auto ia = nlohmann::detail::input_adapter(s);
-    return nlohmann::detail::lexer<json, decltype(ia)>(std::move(ia)).scan();
+    return nlohmann::detail::lexer<json, decltype(ia)>(std::move(ia), ignore_comments).scan();
 }
 }
 
+std::string get_error_message(const char* s, const bool ignore_comments = false);
+std::string get_error_message(const char* s, const bool ignore_comments)
+{
+    auto ia = nlohmann::detail::input_adapter(s);
+    auto lexer = nlohmann::detail::lexer<json, decltype(ia)>(std::move(ia), ignore_comments);
+    lexer.scan();
+    return lexer.get_error_message();
+}
+
 TEST_CASE("lexer class")
 {
     SECTION("scan")
@@ -127,6 +136,8 @@ TEST_CASE("lexer class")
             // store scan() result
             const auto res = scan_string(s.c_str());
 
+            CAPTURE(s);
+
             switch (c)
             {
                 // single characters that are valid tokens
@@ -179,4 +190,59 @@ TEST_CASE("lexer class")
         s += "\"";
         CHECK((scan_string(s.c_str()) == json::lexer::token_type::value_string));
     }
+
+    SECTION("fail on comments")
+    {
+        CHECK((scan_string("/", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/", false) == "invalid literal");
+
+        CHECK((scan_string("/!", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/!", false) == "invalid literal");
+        CHECK((scan_string("/*", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/*", false) == "invalid literal");
+        CHECK((scan_string("/**", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/**", false) == "invalid literal");
+
+        CHECK((scan_string("//", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("//", false) == "invalid literal");
+        CHECK((scan_string("/**/", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/**/", false) == "invalid literal");
+        CHECK((scan_string("/** /", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/** /", false) == "invalid literal");
+
+        CHECK((scan_string("/***/", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/***/", false) == "invalid literal");
+        CHECK((scan_string("/* true */", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/* true */", false) == "invalid literal");
+        CHECK((scan_string("/*/**/", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/*/**/", false) == "invalid literal");
+        CHECK((scan_string("/*/* */", false) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/*/* */", false) == "invalid literal");
+    }
+
+    SECTION("ignore comments")
+    {
+        CHECK((scan_string("/", true) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/", true) == "invalid comment; expecting '/' or '*' after '/'");
+
+        CHECK((scan_string("/!", true) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/!", true) == "invalid comment; expecting '/' or '*' after '/'");
+        CHECK((scan_string("/*", true) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/*", true) == "invalid comment; missing closing '*/'");
+        CHECK((scan_string("/**", true) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/**", true) == "invalid comment; missing closing '*/'");
+
+        CHECK((scan_string("//", true) == json::lexer::token_type::end_of_input));
+        CHECK((scan_string("/**/", true) == json::lexer::token_type::end_of_input));
+        CHECK((scan_string("/** /", true) == json::lexer::token_type::parse_error));
+        CHECK(get_error_message("/** /", true) == "invalid comment; missing closing '*/'");
+
+        CHECK((scan_string("/***/", true) == json::lexer::token_type::end_of_input));
+        CHECK((scan_string("/* true */", true) == json::lexer::token_type::end_of_input));
+        CHECK((scan_string("/*/**/", true) == json::lexer::token_type::end_of_input));
+        CHECK((scan_string("/*/* */", true) == json::lexer::token_type::end_of_input));
+
+        CHECK((scan_string("//\n//\n", true) == json::lexer::token_type::end_of_input));
+        CHECK((scan_string("/**//**//**/", true) == json::lexer::token_type::end_of_input));
+    }
 }

test/src/unit-class_parser.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -224,6 +224,7 @@ class SaxCountdown : public nlohmann::json::json_sax_t
 
 json parser_helper(const std::string& s);
 bool accept_helper(const std::string& s);
+void comments_helper(const std::string& s);
 
 json parser_helper(const std::string& s)
 {
@@ -241,6 +242,8 @@ json parser_helper(const std::string& s)
     json::sax_parse(s, &sdp);
     CHECK(j_sax == j);
 
+    comments_helper(s);
+
     return j;
 }
 
@@ -251,7 +254,7 @@ bool accept_helper(const std::string& s)
     // 1. parse s without exceptions
     json j;
     CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter(s), nullptr, false).parse(true, j));
-    const bool ok_noexcept = not j.is_discarded();
+    const bool ok_noexcept = !j.is_discarded();
 
     // 2. accept s
     const bool ok_accept = json::parser(nlohmann::detail::input_adapter(s)).accept(true);
@@ -262,7 +265,7 @@ bool accept_helper(const std::string& s)
     // 4. parse with SAX (compare with relaxed accept result)
     SaxEventLogger el;
     CHECK_NOTHROW(json::sax_parse(s, &el, json::input_format_t::json, false));
-    CHECK(json::parser(nlohmann::detail::input_adapter(s)).accept(false) == not el.errored);
+    CHECK(json::parser(nlohmann::detail::input_adapter(s)).accept(false) == !el.errored);
 
     // 5. parse with simple callback
     json::parser_callback_t cb = [](int, json::parse_event_t, json&)
@@ -270,16 +273,56 @@ bool accept_helper(const std::string& s)
         return true;
     };
     json j_cb = json::parse(s, cb, false);
-    const bool ok_noexcept_cb = not j_cb.is_discarded();
+    const bool ok_noexcept_cb = !j_cb.is_discarded();
 
     // 6. check if this approach came to the same result
     CHECK(ok_noexcept == ok_noexcept_cb);
 
-    // 7. return result
+    // 7. check if comments are properly ignored
+    if (ok_accept)
+    {
+        comments_helper(s);
+    }
+
+    // 8. return result
     return ok_accept;
 }
+
+void comments_helper(const std::string& s)
+{
+    json _;
+
+    // parse/accept with default parser
+    CHECK_NOTHROW(_ = json::parse(s));
+    CHECK(json::accept(s));
+
+    // parse/accept while skipping comments
+    CHECK_NOTHROW(_ = json::parse(s, nullptr, false, true));
+    CHECK(json::accept(s, true));
+
+    std::vector<std::string> json_with_comments;
+
+    // start with a comment
+    json_with_comments.push_back(std::string("// this is a comment\n") + s);
+    json_with_comments.push_back(std::string("/* this is a comment */") + s);
+    // end with a comment
+    json_with_comments.push_back(s + "// this is a comment");
+    json_with_comments.push_back(s + "/* this is a comment */");
+
+    // check all strings
+    for (const auto& json_with_comment : json_with_comments)
+    {
+        CAPTURE(json_with_comment)
+        CHECK_THROWS_AS(_ = json::parse(json_with_comment), json::parse_error);
+        CHECK(!json::accept(json_with_comment));
+
+        CHECK_NOTHROW(_ = json::parse(json_with_comment, nullptr, true, true));
+        CHECK(json::accept(json_with_comment, true));
+    }
 }
 
+} // namespace
+
 TEST_CASE("parser class")
 {
     SECTION("parse")
@@ -898,7 +941,7 @@ TEST_CASE("parser class")
             SECTION("overflow")
             {
                 // overflows during parsing
-                CHECK(not accept_helper("1.18973e+4932"));
+                CHECK(!accept_helper("1.18973e+4932"));
             }
 
             SECTION("invalid numbers")
@@ -1489,6 +1532,18 @@ TEST_CASE("parser class")
             [1,2,[3,4,5],4,5]
         )";
 
+        auto structured_array = R"(
+            [
+                1,
+                {
+                     "foo": "bar"
+                },
+                {
+                     "qux": "baz"
+                }
+            ]
+        )";
+
         SECTION("filter nothing")
         {
             json j_object = json::parse(s_object, [](int, json::parse_event_t, const json&)
@@ -1557,6 +1612,41 @@ TEST_CASE("parser class")
             CHECK (j_array == json({1, {3, 4, 5}, 4, 5}));
         }
 
+        SECTION("filter object in array")
+        {
+            json j_filtered1 = json::parse(structured_array, [](int, json::parse_event_t e, const json & parsed)
+            {
+                if (e == json::parse_event_t::object_end && parsed.contains("foo"))
+                {
+                    return false;
+                }
+                else
+                {
+                    return true;
+                }
+            });
+
+            // the specified object will be discarded, and removed.
+            CHECK (j_filtered1.size() == 2);
+            CHECK (j_filtered1 == json({1, {{"qux", "baz"}}}));
+
+            json j_filtered2 = json::parse(structured_array, [](int, json::parse_event_t e, const json& /*parsed*/)
+            {
+                if (e == json::parse_event_t::object_end)
+                {
+                    return false;
+                }
+                else
+                {
+                    return true;
+                }
+            });
+
+            // removed all objects in array.
+            CHECK (j_filtered2.size() == 1);
+            CHECK (j_filtered2 == json({1}));
+        }
+
         SECTION("filter specific events")
         {
             SECTION("first closing event")
@@ -1565,7 +1655,7 @@ TEST_CASE("parser class")
                     json j_object = json::parse(s_object, [](int, json::parse_event_t e, const json&)
                     {
                         static bool first = true;
-                        if (e == json::parse_event_t::object_end and first)
+                        if (e == json::parse_event_t::object_end && first)
                         {
                             first = false;
                             return false;
@@ -1584,7 +1674,7 @@ TEST_CASE("parser class")
                     json j_array = json::parse(s_array, [](int, json::parse_event_t e, const json&)
                     {
                         static bool first = true;
-                        if (e == json::parse_event_t::array_end and first)
+                        if (e == json::parse_event_t::array_end && first)
                         {
                             first = false;
                             return false;
@@ -1787,4 +1877,10 @@ TEST_CASE("parser class")
             }
         }
     }
+
+    SECTION("error messages for comments")
+    {
+        CHECK_THROWS_WITH_AS(json::parse("/a", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid comment; expecting '/' or '*' after '/'; last read: '/a'", json::parse_error);
+        CHECK_THROWS_WITH_AS(json::parse("/*", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid comment; missing closing '*/'; last read: '/*<U+0000>'", json::parse_error);
+    }
 }

test/src/unit-comparison.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -165,7 +165,7 @@ TEST_CASE("lexicographical comparison operators")
                     CAPTURE(i)
                     CAPTURE(j)
                     // check definition
-                    CHECK( (j_values[i] != j_values[j]) == not(j_values[i] == j_values[j]) );
+                    CHECK( (j_values[i] != j_values[j]) == !(j_values[i] == j_values[j]) );
                 }
             }
 
@@ -173,8 +173,8 @@ TEST_CASE("lexicographical comparison operators")
             json j_null;
             CHECK( (j_null != nullptr) == false);
             CHECK( (nullptr != j_null) == false);
-            CHECK( (j_null != nullptr) == not(j_null == nullptr));
-            CHECK( (nullptr != j_null) == not(nullptr == j_null));
+            CHECK( (j_null != nullptr) == !(j_null == nullptr));
+            CHECK( (nullptr != j_null) == !(nullptr == j_null));
         }
 
         SECTION("comparison: less")
@@ -234,7 +234,7 @@ TEST_CASE("lexicographical comparison operators")
                     CAPTURE(i)
                     CAPTURE(j)
                     // check definition
-                    CHECK( (j_values[i] <= j_values[j]) == not(j_values[j] < j_values[i]) );
+                    CHECK( (j_values[i] <= j_values[j]) == !(j_values[j] < j_values[i]) );
                 }
             }
         }
@@ -262,7 +262,7 @@ TEST_CASE("lexicographical comparison operators")
                     CAPTURE(i)
                     CAPTURE(j)
                     // check definition
-                    CHECK( (j_values[i] >= j_values[j]) == not(j_values[i] < j_values[j]) );
+                    CHECK( (j_values[i] >= j_values[j]) == !(j_values[i] < j_values[j]) );
                 }
             }
         }

test/src/unit-concepts.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -154,7 +154,7 @@ TEST_CASE("concepts")
                 json j {1, 2, 3};
                 json::iterator it1 = j.begin();
                 json::iterator it2 = j.end();
-                std::swap(it1, it2);
+                swap(it1, it2);
                 CHECK(it1 == j.end());
                 CHECK(it2 == j.begin());
             }
@@ -162,7 +162,7 @@ TEST_CASE("concepts")
                 json j {1, 2, 3};
                 json::const_iterator it1 = j.cbegin();
                 json::const_iterator it2 = j.cend();
-                std::swap(it1, it2);
+                swap(it1, it2);
                 CHECK(it1 == j.end());
                 CHECK(it2 == j.begin());
             }

test/src/unit-constructor1.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -341,7 +341,7 @@ TEST_CASE("constructors")
             CHECK(j.type() == json::value_t::array);
             CHECK(j == json({1, 2, 3, 4, 5}));
 
-            std::valarray<int> jva = j;
+            auto jva = j.get<std::valarray<int>>();
             CHECK(jva.size() == va.size());
             for (size_t i = 0; i < jva.size(); ++i)
             {
@@ -356,7 +356,7 @@ TEST_CASE("constructors")
             CHECK(j.type() == json::value_t::array);
             CHECK(j == json({1.2, 2.3, 3.4, 4.5, 5.6}));
 
-            std::valarray<double> jva = j;
+            auto jva = j.get<std::valarray<double>>();
             CHECK(jva.size() == va.size());
             for (size_t i = 0; i < jva.size(); ++i)
             {
@@ -846,8 +846,8 @@ TEST_CASE("constructors")
             CHECK(j.type() == json::value_t::number_float);
 
             // check round trip of NaN
-            json::number_float_t d = j;
-            CHECK((std::isnan(d) and std::isnan(n)) == true);
+            json::number_float_t d{j};
+            CHECK((std::isnan(d) && std::isnan(n)) == true);
 
             // check that NaN is serialized to null
             CHECK(j.dump() == "null");
@@ -861,7 +861,7 @@ TEST_CASE("constructors")
             CHECK(j.type() == json::value_t::number_float);
 
             // check round trip of infinity
-            json::number_float_t d = j;
+            json::number_float_t d{j};
             CHECK(d == n);
 
             // check that inf is serialized to null

test/src/unit-constructor2.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-convenience.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-conversions.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -197,6 +197,7 @@ TEST_CASE("value conversion")
         }
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("get an object (implicit)")
     {
         json::object_t o_reference = {{"object", json::object()},
@@ -238,6 +239,7 @@ TEST_CASE("value conversion")
             CHECK(json(o) == j);
         }
     }
+#endif
 
     SECTION("get an array (explicit)")
     {
@@ -280,11 +282,12 @@ TEST_CASE("value conversion")
                 json(json::value_t::null).get<std::vector<json>>(),
                 "[json.exception.type_error.302] type must be array, but is null");
 
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
             SECTION("reserve is called on containers that supports it")
             {
                 // make sure all values are properly copied
-                std::vector<int> v2 = json({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+                json j2({1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+                auto v2 = j2.get<std::vector<int>>();
                 CHECK(v2.size() == 10);
             }
 #endif
@@ -413,6 +416,7 @@ TEST_CASE("value conversion")
         }
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("get an array (implicit)")
     {
         json::array_t a_reference{json(1),     json(1u),       json(2.2),
@@ -449,6 +453,7 @@ TEST_CASE("value conversion")
             CHECK(json(a) == j);
         }
     }
+#endif
 
     SECTION("get a string (explicit)")
     {
@@ -606,6 +611,7 @@ TEST_CASE("value conversion")
 
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("get a string (implicit)")
     {
         json::string_t s_reference{"Hello world"};
@@ -631,6 +637,7 @@ TEST_CASE("value conversion")
             CHECK(json(s) == j);
         }
     }
+#endif
 
     SECTION("get a boolean (explicit)")
     {
@@ -703,6 +710,7 @@ TEST_CASE("value conversion")
         }
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("get a boolean (implicit)")
     {
         json::boolean_t b_reference{true};
@@ -720,6 +728,7 @@ TEST_CASE("value conversion")
             CHECK(json(b) == j);
         }
     }
+#endif
 
     SECTION("get an integer number (explicit)")
     {
@@ -970,6 +979,7 @@ TEST_CASE("value conversion")
         }
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("get an integer number (implicit)")
     {
         json::number_integer_t n_reference{42};
@@ -1181,6 +1191,7 @@ TEST_CASE("value conversion")
             CHECK(json(n) == j_unsigned);
         }
     }
+#endif
 
     SECTION("get a floating-point number (explicit)")
     {
@@ -1242,6 +1253,7 @@ TEST_CASE("value conversion")
         }
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("get a floating-point number (implicit)")
     {
         json::number_float_t n_reference{42.23};
@@ -1265,6 +1277,7 @@ TEST_CASE("value conversion")
             CHECK(json(n).m_value.number_float == Approx(j.m_value.number_float));
         }
     }
+#endif
 
     SECTION("get a binary value (explicit)")
     {
@@ -1372,6 +1385,7 @@ TEST_CASE("value conversion")
         }
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("get a binary value (implicit)")
     {
         json::binary_t n_reference{{1, 2, 3}};
@@ -1383,6 +1397,7 @@ TEST_CASE("value conversion")
             CHECK(*json(b).m_value.binary == *j.m_value.binary);
         }
     }
+#endif
 
     SECTION("get an enum")
     {
@@ -1489,15 +1504,15 @@ TEST_CASE("value conversion")
                 SECTION("std::array is larger than JSON")
                 {
                     std::array<int, 6> arr6 = {{1, 2, 3, 4, 5, 6}};
-                    CHECK_THROWS_AS(arr6 = j1, json::out_of_range&);
-                    CHECK_THROWS_WITH(arr6 = j1, "[json.exception.out_of_range.401] "
+                    CHECK_THROWS_AS(j1.get_to(arr6), json::out_of_range&);
+                    CHECK_THROWS_WITH(j1.get_to(arr6), "[json.exception.out_of_range.401] "
                                       "array index 4 is out of range");
                 }
 
                 SECTION("std::array is smaller than JSON")
                 {
                     std::array<int, 2> arr2 = {{8, 9}};
-                    arr2 = j1;
+                    j1.get_to(arr2);
                     CHECK(arr2[0] == 1);
                     CHECK(arr2[1] == 2);
                 }

test/src/unit-deserialization.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -289,14 +289,14 @@ TEST_CASE("deserialization")
             CHECK_THROWS_AS(_ = json::parse(ss1), json::parse_error&);
             CHECK_THROWS_WITH(_ = json::parse(ss2),
                               "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'");
-            CHECK(not json::accept(ss3));
+            CHECK(!json::accept(ss3));
 
             json j_error;
             CHECK_NOTHROW(j_error = json::parse(ss4, nullptr, false));
             CHECK(j_error.is_discarded());
 
             SaxEventLogger l;
-            CHECK(not json::sax_parse(ss5, &l));
+            CHECK(!json::sax_parse(ss5, &l));
             CHECK(l.events.size() == 11);
             CHECK(l.events == std::vector<std::string>(
             {
@@ -314,14 +314,14 @@ TEST_CASE("deserialization")
             CHECK_THROWS_AS(_ = json::parse(s), json::parse_error&);
             CHECK_THROWS_WITH(_ = json::parse(s),
                               "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'");
-            CHECK(not json::accept(s));
+            CHECK(!json::accept(s));
 
             json j_error;
             CHECK_NOTHROW(j_error = json::parse(s, nullptr, false));
             CHECK(j_error.is_discarded());
 
             SaxEventLogger l;
-            CHECK(not json::sax_parse(s, &l));
+            CHECK(!json::sax_parse(s, &l));
             CHECK(l.events.size() == 11);
             CHECK(l.events == std::vector<std::string>(
             {
@@ -450,10 +450,10 @@ TEST_CASE("deserialization")
                 std::vector<uint8_t> v;
                 json _;
                 CHECK_THROWS_AS(_ = json::parse(v), json::parse_error&);
-                CHECK(not json::accept(v));
+                CHECK(!json::accept(v));
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(v, &l));
+                CHECK(!json::sax_parse(v, &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(1)"}));
             }
@@ -538,10 +538,10 @@ TEST_CASE("deserialization")
             {
                 std::vector<uint8_t> v;
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(1)"}));
             }
@@ -554,14 +554,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u'};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(10)"}));
             }
@@ -570,14 +570,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1'};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(11)"}));
             }
@@ -586,14 +586,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1', '1', '1', '1', '1', '1', '1', '1'};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(18)"}));
             }
@@ -602,14 +602,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', 'u', '1', '1', '1', '1', '1', '1', '1', '1', '\\'};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(18)"}));
             }
@@ -618,14 +618,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xC1};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(3)"}));
             }
@@ -637,14 +637,14 @@ TEST_CASE("deserialization")
                 CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                 CHECK_THROWS_WITH(_ = json::parse(std::begin(v), std::end(v)),
                                   "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"\x7f\xdf\x7f'");
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -653,14 +653,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xDF, 0xC0};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -669,14 +669,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xE0, 0x9F};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -685,14 +685,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xEF, 0xC0};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -701,14 +701,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xED, 0x7F};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -717,14 +717,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xF0, 0x8F};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -733,14 +733,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xF0, 0xC0};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -749,14 +749,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xF3, 0x7F};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -765,14 +765,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xF3, 0xC0};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -781,14 +781,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'\"', 0x7F, 0xF4, 0x7F};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 1);
                 CHECK(l.events == std::vector<std::string>({"parse_error(4)"}));
             }
@@ -797,14 +797,14 @@ TEST_CASE("deserialization")
             {
                 uint8_t v[] = {'{', '\"', '\"', ':', '1', '1'};
                 CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
-                CHECK(not json::accept(std::begin(v), std::end(v)));
+                CHECK(!json::accept(std::begin(v), std::end(v)));
 
                 json j_error;
                 CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                 CHECK(j_error.is_discarded());
 
                 SaxEventLogger l;
-                CHECK(not json::sax_parse(std::begin(v), std::end(v), &l));
+                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                 CHECK(l.events.size() == 4);
                 CHECK(l.events == std::vector<std::string>(
                 {
@@ -831,7 +831,7 @@ TEST_CASE("deserialization")
                               "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal");
 
             SaxEventLogger l;
-            CHECK(not json::sax_parse(bom, &l));
+            CHECK(!json::sax_parse(bom, &l));
             CHECK(l.events.size() == 1);
             CHECK(l.events == std::vector<std::string>(
             {
@@ -871,8 +871,8 @@ TEST_CASE("deserialization")
                               "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF\xBB'");
 
             SaxEventLogger l1, l2;
-            CHECK(not json::sax_parse(std::istringstream(bom.substr(0, 2)), &l1));
-            CHECK(not json::sax_parse(bom.substr(0, 2), &l2));
+            CHECK(!json::sax_parse(std::istringstream(bom.substr(0, 2)), &l1));
+            CHECK(!json::sax_parse(bom.substr(0, 2), &l2));
             CHECK(l1.events.size() == 1);
             CHECK(l1.events == std::vector<std::string>(
             {
@@ -897,8 +897,8 @@ TEST_CASE("deserialization")
                               "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF'");
 
             SaxEventLogger l1, l2;
-            CHECK(not json::sax_parse(std::istringstream(bom.substr(0, 1)), &l1));
-            CHECK(not json::sax_parse(bom.substr(0, 1), &l2));
+            CHECK(!json::sax_parse(std::istringstream(bom.substr(0, 1)), &l1));
+            CHECK(!json::sax_parse(bom.substr(0, 1), &l2));
             CHECK(l1.events.size() == 1);
             CHECK(l1.events == std::vector<std::string>(
             {
@@ -931,7 +931,7 @@ TEST_CASE("deserialization")
                         s.push_back(static_cast<char>(bom[1] + i1));
                         s.push_back(static_cast<char>(bom[2] + i2));
 
-                        if (i0 == 0 and i1 == 0 and i2 == 0)
+                        if (i0 == 0 && i1 == 0 && i2 == 0)
                         {
                             // without any variation, we skip the BOM
                             CHECK(json::parse(s + "null") == json());
@@ -953,7 +953,7 @@ TEST_CASE("deserialization")
                             CHECK_THROWS_AS(_ = json::parse(std::istringstream(s + "null")), json::parse_error&);
 
                             SaxEventLogger l;
-                            CHECK(not json::sax_parse(s + "null", &l));
+                            CHECK(!json::sax_parse(s + "null", &l));
                             CHECK(l.events.size() == 1);
 
                             if (i0 != 0)
@@ -1039,3 +1039,60 @@ TEST_CASE("deserialization")
         }));
     }
 }
+
+TEST_CASE_TEMPLATE("deserialization of different character types (ASCII)", T,
+                   char, unsigned char, signed char,
+                   wchar_t,
+                   char16_t, char32_t,
+                   std::uint8_t, std::int8_t,
+                   std::int16_t, std::uint16_t,
+                   std::int32_t, std::uint32_t)
+{
+    std::vector<T> v = {'t', 'r', 'u', 'e'};
+    CHECK(json::parse(v) == json(true));
+    CHECK(json::accept(v));
+
+    SaxEventLogger l;
+    CHECK(json::sax_parse(v, &l));
+    CHECK(l.events.size() == 1);
+    CHECK(l.events == std::vector<std::string>({"boolean(true)"}));
+}
+
+TEST_CASE_TEMPLATE("deserialization of different character types (UTF-8)", T,
+                   char, unsigned char, std::uint8_t)
+{
+    // a star emoji
+    std::vector<T> v = {'"', static_cast<T>(0xe2), static_cast<T>(0xad), static_cast<T>(0x90), static_cast<T>(0xef), static_cast<T>(0xb8), static_cast<T>(0x8f), '"'};
+    CHECK(json::parse(v).dump(-1, ' ', true) == "\"\\u2b50\\ufe0f\"");
+    CHECK(json::accept(v));
+
+    SaxEventLogger l;
+    CHECK(json::sax_parse(v, &l));
+    CHECK(l.events.size() == 1);
+}
+
+TEST_CASE_TEMPLATE("deserialization of different character types (UTF-16)", T,
+                   char16_t, std::uint16_t)
+{
+    // a star emoji
+    std::vector<T> v = {static_cast<T>('"'), static_cast<T>(0x2b50), static_cast<T>(0xfe0f), static_cast<T>('"')};
+    CHECK(json::parse(v).dump(-1, ' ', true) == "\"\\u2b50\\ufe0f\"");
+    CHECK(json::accept(v));
+
+    SaxEventLogger l;
+    CHECK(json::sax_parse(v, &l));
+    CHECK(l.events.size() == 1);
+}
+
+TEST_CASE_TEMPLATE("deserialization of different character types (UTF-32)", T,
+                   char32_t, std::uint32_t)
+{
+    // a star emoji
+    std::vector<T> v = {static_cast<T>('"'), static_cast<T>(0x2b50), static_cast<T>(0xfe0f), static_cast<T>('"')};
+    CHECK(json::parse(v).dump(-1, ' ', true) == "\"\\u2b50\\ufe0f\"");
+    CHECK(json::accept(v));
+
+    SaxEventLogger l;
+    CHECK(json::sax_parse(v, &l));
+    CHECK(l.events.size() == 1);
+}

test/src/unit-element_access1.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-element_access2.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1072,7 +1072,7 @@ TEST_CASE("element access 2")
     }
 }
 
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
 TEST_CASE("element access 2 (throwing tests)")
 {
     SECTION("object")

test/src/unit-hash.cpp

@@ -0,0 +1,84 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++ (test suite)
+|  |  |__   |  |  | | | |  version 3.9.1
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+using json = nlohmann::json;
+
+#include <set>
+
+TEST_CASE("hash")
+{
+    // Collect hashes for different JSON values and make sure that they are distinct
+    // We cannot compare against fixed values, because the implementation of
+    // std::hash may differ between compilers.
+
+    std::set<std::size_t> hashes;
+
+    // null
+    hashes.insert(std::hash<json> {}(json(nullptr)));
+
+    // boolean
+    hashes.insert(std::hash<json> {}(json(true)));
+    hashes.insert(std::hash<json> {}(json(false)));
+
+    // string
+    hashes.insert(std::hash<json> {}(json("")));
+    hashes.insert(std::hash<json> {}(json("foo")));
+
+    // number
+    hashes.insert(std::hash<json> {}(json(0)));
+    hashes.insert(std::hash<json> {}(json(unsigned(0))));
+
+    hashes.insert(std::hash<json> {}(json(-1)));
+    hashes.insert(std::hash<json> {}(json(0.0)));
+    hashes.insert(std::hash<json> {}(json(42.23)));
+
+    // array
+    hashes.insert(std::hash<json> {}(json::array()));
+    hashes.insert(std::hash<json> {}(json::array({1, 2, 3})));
+
+    // object
+    hashes.insert(std::hash<json> {}(json::object()));
+    hashes.insert(std::hash<json> {}(json::object({{"foo", "bar"}})));
+
+    // binary
+    hashes.insert(std::hash<json> {}(json::binary({})));
+    hashes.insert(std::hash<json> {}(json::binary({}, 0)));
+    hashes.insert(std::hash<json> {}(json::binary({}, 42)));
+    hashes.insert(std::hash<json> {}(json::binary({1, 2, 3})));
+    hashes.insert(std::hash<json> {}(json::binary({1, 2, 3}, 0)));
+    hashes.insert(std::hash<json> {}(json::binary({1, 2, 3}, 42)));
+
+    // discarded
+    hashes.insert(std::hash<json> {}(json(json::value_t::discarded)));
+
+    CHECK(hashes.size() == 21);
+}

test/src/unit-inspection.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -43,36 +43,36 @@ TEST_CASE("object inspection")
         SECTION("object")
         {
             json j {{"foo", 1}, {"bar", false}};
-            CHECK(not j.is_null());
-            CHECK(not j.is_boolean());
-            CHECK(not j.is_number());
-            CHECK(not j.is_number_integer());
-            CHECK(not j.is_number_unsigned());
-            CHECK(not j.is_number_float());
-            CHECK(not j.is_binary());
+            CHECK(!j.is_null());
+            CHECK(!j.is_boolean());
+            CHECK(!j.is_number());
+            CHECK(!j.is_number_integer());
+            CHECK(!j.is_number_unsigned());
+            CHECK(!j.is_number_float());
+            CHECK(!j.is_binary());
             CHECK(j.is_object());
-            CHECK(not j.is_array());
-            CHECK(not j.is_string());
-            CHECK(not j.is_discarded());
-            CHECK(not j.is_primitive());
+            CHECK(!j.is_array());
+            CHECK(!j.is_string());
+            CHECK(!j.is_discarded());
+            CHECK(!j.is_primitive());
             CHECK(j.is_structured());
         }
 
         SECTION("array")
         {
             json j {"foo", 1, 1u, 42.23, false};
-            CHECK(not j.is_null());
-            CHECK(not j.is_boolean());
-            CHECK(not j.is_number());
-            CHECK(not j.is_number_integer());
-            CHECK(not j.is_number_unsigned());
-            CHECK(not j.is_number_float());
-            CHECK(not j.is_binary());
-            CHECK(not j.is_object());
+            CHECK(!j.is_null());
+            CHECK(!j.is_boolean());
+            CHECK(!j.is_number());
+            CHECK(!j.is_number_integer());
+            CHECK(!j.is_number_unsigned());
+            CHECK(!j.is_number_float());
+            CHECK(!j.is_binary());
+            CHECK(!j.is_object());
             CHECK(j.is_array());
-            CHECK(not j.is_string());
-            CHECK(not j.is_discarded());
-            CHECK(not j.is_primitive());
+            CHECK(!j.is_string());
+            CHECK(!j.is_discarded());
+            CHECK(!j.is_primitive());
             CHECK(j.is_structured());
         }
 
@@ -80,144 +80,144 @@ TEST_CASE("object inspection")
         {
             json j(nullptr);
             CHECK(j.is_null());
-            CHECK(not j.is_boolean());
-            CHECK(not j.is_number());
-            CHECK(not j.is_number_integer());
-            CHECK(not j.is_number_unsigned());
-            CHECK(not j.is_number_float());
-            CHECK(not j.is_binary());
-            CHECK(not j.is_object());
-            CHECK(not j.is_array());
-            CHECK(not j.is_string());
-            CHECK(not j.is_discarded());
+            CHECK(!j.is_boolean());
+            CHECK(!j.is_number());
+            CHECK(!j.is_number_integer());
+            CHECK(!j.is_number_unsigned());
+            CHECK(!j.is_number_float());
+            CHECK(!j.is_binary());
+            CHECK(!j.is_object());
+            CHECK(!j.is_array());
+            CHECK(!j.is_string());
+            CHECK(!j.is_discarded());
             CHECK(j.is_primitive());
-            CHECK(not j.is_structured());
+            CHECK(!j.is_structured());
         }
 
         SECTION("boolean")
         {
             json j(true);
-            CHECK(not j.is_null());
+            CHECK(!j.is_null());
             CHECK(j.is_boolean());
-            CHECK(not j.is_number());
-            CHECK(not j.is_number_integer());
-            CHECK(not j.is_number_unsigned());
-            CHECK(not j.is_number_float());
-            CHECK(not j.is_binary());
-            CHECK(not j.is_object());
-            CHECK(not j.is_array());
-            CHECK(not j.is_string());
-            CHECK(not j.is_discarded());
+            CHECK(!j.is_number());
+            CHECK(!j.is_number_integer());
+            CHECK(!j.is_number_unsigned());
+            CHECK(!j.is_number_float());
+            CHECK(!j.is_binary());
+            CHECK(!j.is_object());
+            CHECK(!j.is_array());
+            CHECK(!j.is_string());
+            CHECK(!j.is_discarded());
             CHECK(j.is_primitive());
-            CHECK(not j.is_structured());
+            CHECK(!j.is_structured());
         }
 
         SECTION("string")
         {
             json j("Hello world");
-            CHECK(not j.is_null());
-            CHECK(not j.is_boolean());
-            CHECK(not j.is_number());
-            CHECK(not j.is_number_integer());
-            CHECK(not j.is_number_unsigned());
-            CHECK(not j.is_number_float());
-            CHECK(not j.is_binary());
-            CHECK(not j.is_object());
-            CHECK(not j.is_array());
+            CHECK(!j.is_null());
+            CHECK(!j.is_boolean());
+            CHECK(!j.is_number());
+            CHECK(!j.is_number_integer());
+            CHECK(!j.is_number_unsigned());
+            CHECK(!j.is_number_float());
+            CHECK(!j.is_binary());
+            CHECK(!j.is_object());
+            CHECK(!j.is_array());
             CHECK(j.is_string());
-            CHECK(not j.is_discarded());
+            CHECK(!j.is_discarded());
             CHECK(j.is_primitive());
-            CHECK(not j.is_structured());
+            CHECK(!j.is_structured());
         }
 
         SECTION("number (integer)")
         {
             json j(42);
-            CHECK(not j.is_null());
-            CHECK(not j.is_boolean());
+            CHECK(!j.is_null());
+            CHECK(!j.is_boolean());
             CHECK(j.is_number());
             CHECK(j.is_number_integer());
-            CHECK(not j.is_number_unsigned());
-            CHECK(not j.is_number_float());
-            CHECK(not j.is_binary());
-            CHECK(not j.is_object());
-            CHECK(not j.is_array());
-            CHECK(not j.is_string());
-            CHECK(not j.is_discarded());
+            CHECK(!j.is_number_unsigned());
+            CHECK(!j.is_number_float());
+            CHECK(!j.is_binary());
+            CHECK(!j.is_object());
+            CHECK(!j.is_array());
+            CHECK(!j.is_string());
+            CHECK(!j.is_discarded());
             CHECK(j.is_primitive());
-            CHECK(not j.is_structured());
+            CHECK(!j.is_structured());
         }
 
         SECTION("number (unsigned)")
         {
             json j(42u);
-            CHECK(not j.is_null());
-            CHECK(not j.is_boolean());
+            CHECK(!j.is_null());
+            CHECK(!j.is_boolean());
             CHECK(j.is_number());
             CHECK(j.is_number_integer());
             CHECK(j.is_number_unsigned());
-            CHECK(not j.is_number_float());
-            CHECK(not j.is_binary());
-            CHECK(not j.is_object());
-            CHECK(not j.is_array());
-            CHECK(not j.is_string());
-            CHECK(not j.is_discarded());
+            CHECK(!j.is_number_float());
+            CHECK(!j.is_binary());
+            CHECK(!j.is_object());
+            CHECK(!j.is_array());
+            CHECK(!j.is_string());
+            CHECK(!j.is_discarded());
             CHECK(j.is_primitive());
-            CHECK(not j.is_structured());
+            CHECK(!j.is_structured());
         }
 
         SECTION("number (floating-point)")
         {
             json j(42.23);
-            CHECK(not j.is_null());
-            CHECK(not j.is_boolean());
+            CHECK(!j.is_null());
+            CHECK(!j.is_boolean());
             CHECK(j.is_number());
-            CHECK(not j.is_number_integer());
-            CHECK(not j.is_number_unsigned());
+            CHECK(!j.is_number_integer());
+            CHECK(!j.is_number_unsigned());
             CHECK(j.is_number_float());
-            CHECK(not j.is_binary());
-            CHECK(not j.is_object());
-            CHECK(not j.is_array());
-            CHECK(not j.is_string());
-            CHECK(not j.is_discarded());
+            CHECK(!j.is_binary());
+            CHECK(!j.is_object());
+            CHECK(!j.is_array());
+            CHECK(!j.is_string());
+            CHECK(!j.is_discarded());
             CHECK(j.is_primitive());
-            CHECK(not j.is_structured());
+            CHECK(!j.is_structured());
         }
 
         SECTION("binary")
         {
             json j(json::value_t::binary);
-            CHECK(not j.is_null());
-            CHECK(not j.is_boolean());
-            CHECK(not j.is_number());
-            CHECK(not j.is_number_integer());
-            CHECK(not j.is_number_unsigned());
-            CHECK(not j.is_number_float());
+            CHECK(!j.is_null());
+            CHECK(!j.is_boolean());
+            CHECK(!j.is_number());
+            CHECK(!j.is_number_integer());
+            CHECK(!j.is_number_unsigned());
+            CHECK(!j.is_number_float());
             CHECK(j.is_binary());
-            CHECK(not j.is_object());
-            CHECK(not j.is_array());
-            CHECK(not j.is_string());
-            CHECK(not j.is_discarded());
+            CHECK(!j.is_object());
+            CHECK(!j.is_array());
+            CHECK(!j.is_string());
+            CHECK(!j.is_discarded());
             CHECK(j.is_primitive());
-            CHECK(not j.is_structured());
+            CHECK(!j.is_structured());
         }
 
         SECTION("discarded")
         {
             json j(json::value_t::discarded);
-            CHECK(not j.is_null());
-            CHECK(not j.is_boolean());
-            CHECK(not j.is_number());
-            CHECK(not j.is_number_integer());
-            CHECK(not j.is_number_unsigned());
-            CHECK(not j.is_number_float());
-            CHECK(not j.is_binary());
-            CHECK(not j.is_object());
-            CHECK(not j.is_array());
-            CHECK(not j.is_string());
+            CHECK(!j.is_null());
+            CHECK(!j.is_boolean());
+            CHECK(!j.is_number());
+            CHECK(!j.is_number_integer());
+            CHECK(!j.is_number_unsigned());
+            CHECK(!j.is_number_float());
+            CHECK(!j.is_binary());
+            CHECK(!j.is_object());
+            CHECK(!j.is_array());
+            CHECK(!j.is_string());
             CHECK(j.is_discarded());
-            CHECK(not j.is_primitive());
-            CHECK(not j.is_structured());
+            CHECK(!j.is_primitive());
+            CHECK(!j.is_structured());
         }
     }
 

test/src/unit-items.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-iterators1.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -231,12 +231,12 @@ TEST_CASE("iterators 1")
             {
                 SECTION("!(begin != begin)")
                 {
-                    CHECK(not(j.begin() != j.begin()));
+                    CHECK(!(j.begin() != j.begin()));
                 }
 
                 SECTION("!(end != end)")
                 {
-                    CHECK(not(j.end() != j.end()));
+                    CHECK(!(j.end() != j.end()));
                 }
 
                 SECTION("begin < end")
@@ -286,7 +286,7 @@ TEST_CASE("iterators 1")
 
                 SECTION("!(begin == end)")
                 {
-                    CHECK(not(j.begin() == j.end()));
+                    CHECK(!(j.begin() == j.end()));
                 }
 
                 SECTION("begin != end")

test/src/unit-iterators2.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -56,26 +56,26 @@ TEST_CASE("iterators 2")
             // comparison: equal
             {
                 CHECK(it1 == it1);
-                CHECK(not (it1 == it2));
-                CHECK(not (it1 == it3));
-                CHECK(not (it2 == it3));
+                CHECK(!(it1 == it2));
+                CHECK(!(it1 == it3));
+                CHECK(!(it2 == it3));
                 CHECK(it1_c == it1_c);
-                CHECK(not (it1_c == it2_c));
-                CHECK(not (it1_c == it3_c));
-                CHECK(not (it2_c == it3_c));
+                CHECK(!(it1_c == it2_c));
+                CHECK(!(it1_c == it3_c));
+                CHECK(!(it2_c == it3_c));
             }
 
             // comparison: not equal
             {
                 // check definition
-                CHECK( (it1 != it1) == not(it1 == it1) );
-                CHECK( (it1 != it2) == not(it1 == it2) );
-                CHECK( (it1 != it3) == not(it1 == it3) );
-                CHECK( (it2 != it3) == not(it2 == it3) );
-                CHECK( (it1_c != it1_c) == not(it1_c == it1_c) );
-                CHECK( (it1_c != it2_c) == not(it1_c == it2_c) );
-                CHECK( (it1_c != it3_c) == not(it1_c == it3_c) );
-                CHECK( (it2_c != it3_c) == not(it2_c == it3_c) );
+                CHECK( (it1 != it1) == !(it1 == it1) );
+                CHECK( (it1 != it2) == !(it1 == it2) );
+                CHECK( (it1 != it3) == !(it1 == it3) );
+                CHECK( (it2 != it3) == !(it2 == it3) );
+                CHECK( (it1_c != it1_c) == !(it1_c == it1_c) );
+                CHECK( (it1_c != it2_c) == !(it1_c == it2_c) );
+                CHECK( (it1_c != it3_c) == !(it1_c == it3_c) );
+                CHECK( (it2_c != it3_c) == !(it2_c == it3_c) );
             }
 
             // comparison: smaller
@@ -101,11 +101,11 @@ TEST_CASE("iterators 2")
                 }
                 else
                 {
-                    CHECK(not (it1 < it1));
+                    CHECK(!(it1 < it1));
                     CHECK(it1 < it2);
                     CHECK(it1 < it3);
                     CHECK(it2 < it3);
-                    CHECK(not (it1_c < it1_c));
+                    CHECK(!(it1_c < it1_c));
                     CHECK(it1_c < it2_c);
                     CHECK(it1_c < it3_c);
                     CHECK(it2_c < it3_c);
@@ -136,14 +136,14 @@ TEST_CASE("iterators 2")
                 else
                 {
                     // check definition
-                    CHECK( (it1 <= it1) == not(it1 < it1) );
-                    CHECK( (it1 <= it2) == not(it2 < it1) );
-                    CHECK( (it1 <= it3) == not(it3 < it1) );
-                    CHECK( (it2 <= it3) == not(it3 < it2) );
-                    CHECK( (it1_c <= it1_c) == not(it1_c < it1_c) );
-                    CHECK( (it1_c <= it2_c) == not(it2_c < it1_c) );
-                    CHECK( (it1_c <= it3_c) == not(it3_c < it1_c) );
-                    CHECK( (it2_c <= it3_c) == not(it3_c < it2_c) );
+                    CHECK( (it1 <= it1) == !(it1 < it1) );
+                    CHECK( (it1 <= it2) == !(it2 < it1) );
+                    CHECK( (it1 <= it3) == !(it3 < it1) );
+                    CHECK( (it2 <= it3) == !(it3 < it2) );
+                    CHECK( (it1_c <= it1_c) == !(it1_c < it1_c) );
+                    CHECK( (it1_c <= it2_c) == !(it2_c < it1_c) );
+                    CHECK( (it1_c <= it3_c) == !(it3_c < it1_c) );
+                    CHECK( (it2_c <= it3_c) == !(it3_c < it2_c) );
                 }
             }
 
@@ -206,14 +206,14 @@ TEST_CASE("iterators 2")
                 else
                 {
                     // check definition
-                    CHECK( (it1 >= it1) == not(it1 < it1) );
-                    CHECK( (it1 >= it2) == not(it1 < it2) );
-                    CHECK( (it1 >= it3) == not(it1 < it3) );
-                    CHECK( (it2 >= it3) == not(it2 < it3) );
-                    CHECK( (it1_c >= it1_c) == not(it1_c < it1_c) );
-                    CHECK( (it1_c >= it2_c) == not(it1_c < it2_c) );
-                    CHECK( (it1_c >= it3_c) == not(it1_c < it3_c) );
-                    CHECK( (it2_c >= it3_c) == not(it2_c < it3_c) );
+                    CHECK( (it1 >= it1) == !(it1 < it1) );
+                    CHECK( (it1 >= it2) == !(it1 < it2) );
+                    CHECK( (it1 >= it3) == !(it1 < it3) );
+                    CHECK( (it2 >= it3) == !(it2 < it3) );
+                    CHECK( (it1_c >= it1_c) == !(it1_c < it1_c) );
+                    CHECK( (it1_c >= it2_c) == !(it1_c < it2_c) );
+                    CHECK( (it1_c >= it3_c) == !(it1_c < it3_c) );
+                    CHECK( (it2_c >= it3_c) == !(it2_c < it3_c) );
                 }
             }
         }
@@ -491,26 +491,26 @@ TEST_CASE("iterators 2")
             // comparison: equal
             {
                 CHECK(it1 == it1);
-                CHECK(not (it1 == it2));
-                CHECK(not (it1 == it3));
-                CHECK(not (it2 == it3));
+                CHECK(!(it1 == it2));
+                CHECK(!(it1 == it3));
+                CHECK(!(it2 == it3));
                 CHECK(it1_c == it1_c);
-                CHECK(not (it1_c == it2_c));
-                CHECK(not (it1_c == it3_c));
-                CHECK(not (it2_c == it3_c));
+                CHECK(!(it1_c == it2_c));
+                CHECK(!(it1_c == it3_c));
+                CHECK(!(it2_c == it3_c));
             }
 
             // comparison: not equal
             {
                 // check definition
-                CHECK( (it1 != it1) == not(it1 == it1) );
-                CHECK( (it1 != it2) == not(it1 == it2) );
-                CHECK( (it1 != it3) == not(it1 == it3) );
-                CHECK( (it2 != it3) == not(it2 == it3) );
-                CHECK( (it1_c != it1_c) == not(it1_c == it1_c) );
-                CHECK( (it1_c != it2_c) == not(it1_c == it2_c) );
-                CHECK( (it1_c != it3_c) == not(it1_c == it3_c) );
-                CHECK( (it2_c != it3_c) == not(it2_c == it3_c) );
+                CHECK( (it1 != it1) == !(it1 == it1) );
+                CHECK( (it1 != it2) == !(it1 == it2) );
+                CHECK( (it1 != it3) == !(it1 == it3) );
+                CHECK( (it2 != it3) == !(it2 == it3) );
+                CHECK( (it1_c != it1_c) == !(it1_c == it1_c) );
+                CHECK( (it1_c != it2_c) == !(it1_c == it2_c) );
+                CHECK( (it1_c != it3_c) == !(it1_c == it3_c) );
+                CHECK( (it2_c != it3_c) == !(it2_c == it3_c) );
             }
 
             // comparison: smaller
@@ -536,11 +536,11 @@ TEST_CASE("iterators 2")
                 }
                 else
                 {
-                    CHECK(not (it1 < it1));
+                    CHECK(!(it1 < it1));
                     CHECK(it1 < it2);
                     CHECK(it1 < it3);
                     CHECK(it2 < it3);
-                    CHECK(not (it1_c < it1_c));
+                    CHECK(!(it1_c < it1_c));
                     CHECK(it1_c < it2_c);
                     CHECK(it1_c < it3_c);
                     CHECK(it2_c < it3_c);
@@ -571,14 +571,14 @@ TEST_CASE("iterators 2")
                 else
                 {
                     // check definition
-                    CHECK( (it1 <= it1) == not(it1 < it1) );
-                    CHECK( (it1 <= it2) == not(it2 < it1) );
-                    CHECK( (it1 <= it3) == not(it3 < it1) );
-                    CHECK( (it2 <= it3) == not(it3 < it2) );
-                    CHECK( (it1_c <= it1_c) == not(it1_c < it1_c) );
-                    CHECK( (it1_c <= it2_c) == not(it2_c < it1_c) );
-                    CHECK( (it1_c <= it3_c) == not(it3_c < it1_c) );
-                    CHECK( (it2_c <= it3_c) == not(it3_c < it2_c) );
+                    CHECK( (it1 <= it1) == !(it1 < it1) );
+                    CHECK( (it1 <= it2) == !(it2 < it1) );
+                    CHECK( (it1 <= it3) == !(it3 < it1) );
+                    CHECK( (it2 <= it3) == !(it3 < it2) );
+                    CHECK( (it1_c <= it1_c) == !(it1_c < it1_c) );
+                    CHECK( (it1_c <= it2_c) == !(it2_c < it1_c) );
+                    CHECK( (it1_c <= it3_c) == !(it3_c < it1_c) );
+                    CHECK( (it2_c <= it3_c) == !(it3_c < it2_c) );
                 }
             }
 
@@ -641,14 +641,14 @@ TEST_CASE("iterators 2")
                 else
                 {
                     // check definition
-                    CHECK( (it1 >= it1) == not(it1 < it1) );
-                    CHECK( (it1 >= it2) == not(it1 < it2) );
-                    CHECK( (it1 >= it3) == not(it1 < it3) );
-                    CHECK( (it2 >= it3) == not(it2 < it3) );
-                    CHECK( (it1_c >= it1_c) == not(it1_c < it1_c) );
-                    CHECK( (it1_c >= it2_c) == not(it1_c < it2_c) );
-                    CHECK( (it1_c >= it3_c) == not(it1_c < it3_c) );
-                    CHECK( (it2_c >= it3_c) == not(it2_c < it3_c) );
+                    CHECK( (it1 >= it1) == !(it1 < it1) );
+                    CHECK( (it1 >= it2) == !(it1 < it2) );
+                    CHECK( (it1 >= it3) == !(it1 < it3) );
+                    CHECK( (it2 >= it3) == !(it2 < it3) );
+                    CHECK( (it1_c >= it1_c) == !(it1_c < it1_c) );
+                    CHECK( (it1_c >= it2_c) == !(it1_c < it2_c) );
+                    CHECK( (it1_c >= it3_c) == !(it1_c < it3_c) );
+                    CHECK( (it2_c >= it3_c) == !(it2_c < it3_c) );
                 }
             }
         }

test/src/unit-json_patch.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-json_pointer.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -101,10 +101,10 @@ TEST_CASE("JSON pointers")
             CHECK(j["/foo/1"_json_pointer] == j["foo"][1]);
             CHECK(j.contains(json::json_pointer("/foo/0")));
             CHECK(j.contains(json::json_pointer("/foo/1")));
-            CHECK(not j.contains(json::json_pointer("/foo/3")));
-            CHECK(not j.contains(json::json_pointer("/foo/+")));
-            CHECK(not j.contains(json::json_pointer("/foo/1+2")));
-            CHECK(not j.contains(json::json_pointer("/foo/-")));
+            CHECK(!j.contains(json::json_pointer("/foo/3")));
+            CHECK(!j.contains(json::json_pointer("/foo/+")));
+            CHECK(!j.contains(json::json_pointer("/foo/1+2")));
+            CHECK(!j.contains(json::json_pointer("/foo/-")));
 
             // checked array access
             CHECK(j.at(json::json_pointer("/foo/0")) == j["foo"][0]);
@@ -147,19 +147,19 @@ TEST_CASE("JSON pointers")
 
             // unescaped access
             // access to nonexisting values yield object creation
-            CHECK(not j.contains(json::json_pointer("/a/b")));
+            CHECK(!j.contains(json::json_pointer("/a/b")));
             CHECK_NOTHROW(j[json::json_pointer("/a/b")] = 42);
             CHECK(j.contains(json::json_pointer("/a/b")));
             CHECK(j["a"]["b"] == json(42));
 
-            CHECK(not j.contains(json::json_pointer("/a/c/1")));
+            CHECK(!j.contains(json::json_pointer("/a/c/1")));
             CHECK_NOTHROW(j[json::json_pointer("/a/c/1")] = 42);
             CHECK(j["a"]["c"] == json({nullptr, 42}));
             CHECK(j.contains(json::json_pointer("/a/c/1")));
 
-            CHECK(not j.contains(json::json_pointer("/a/d/-")));
+            CHECK(!j.contains(json::json_pointer("/a/d/-")));
             CHECK_NOTHROW(j[json::json_pointer("/a/d/-")] = 42);
-            CHECK(not j.contains(json::json_pointer("/a/d/-")));
+            CHECK(!j.contains(json::json_pointer("/a/d/-")));
             CHECK(j["a"]["d"] == json::array({42}));
             // "/a/b" works for JSON {"a": {"b": 42}}
             CHECK(json({{"a", {{"b", 42}}}})[json::json_pointer("/a/b")] == json(42));
@@ -172,7 +172,7 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_AS(j_primitive.at("/foo"_json_pointer), json::out_of_range&);
             CHECK_THROWS_WITH(j_primitive.at("/foo"_json_pointer),
                               "[json.exception.out_of_range.404] unresolved reference token 'foo'");
-            CHECK(not j_primitive.contains(json::json_pointer("/foo")));
+            CHECK(!j_primitive.contains(json::json_pointer("/foo")));
         }
 
         SECTION("const access")
@@ -272,7 +272,7 @@ TEST_CASE("JSON pointers")
             CHECK(j.contains("/foo"_json_pointer));
             CHECK(j.contains("/foo/0"_json_pointer));
             CHECK(j.contains("/foo/1"_json_pointer));
-            CHECK(not j.contains("/foo/-"_json_pointer));
+            CHECK(!j.contains("/foo/-"_json_pointer));
         }
     }
 
@@ -314,10 +314,10 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_WITH(j_const.at("/01"_json_pointer),
                               "[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'");
 
-            CHECK(not j.contains("/01"_json_pointer));
-            CHECK(not j.contains("/01"_json_pointer));
-            CHECK(not j_const.contains("/01"_json_pointer));
-            CHECK(not j_const.contains("/01"_json_pointer));
+            CHECK(!j.contains("/01"_json_pointer));
+            CHECK(!j.contains("/01"_json_pointer));
+            CHECK(!j_const.contains("/01"_json_pointer));
+            CHECK(!j_const.contains("/01"_json_pointer));
 
             // error with incorrect numbers
             CHECK_THROWS_AS(j["/one"_json_pointer] = 1, json::parse_error&);
@@ -348,12 +348,29 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_WITH(j_const["/1+1"_json_pointer] == 1,
                               "[json.exception.out_of_range.404] unresolved reference token '1+1'");
 
-            CHECK_THROWS_AS(j["/111111111111111111111111"_json_pointer] = 1, json::out_of_range&);
-            CHECK_THROWS_WITH(j["/111111111111111111111111"_json_pointer] = 1,
-                              "[json.exception.out_of_range.404] unresolved reference token '111111111111111111111111'");
-            CHECK_THROWS_AS(j_const["/111111111111111111111111"_json_pointer] == 1, json::out_of_range&);
-            CHECK_THROWS_WITH(j_const["/111111111111111111111111"_json_pointer] == 1,
-                              "[json.exception.out_of_range.404] unresolved reference token '111111111111111111111111'");
+            {
+                auto too_large_index = std::to_string((std::numeric_limits<unsigned long long>::max)()) + "1";
+                json::json_pointer jp(std::string("/") + too_large_index);
+                std::string throw_msg = std::string("[json.exception.out_of_range.404] unresolved reference token '") + too_large_index + "'";
+
+                CHECK_THROWS_AS(j[jp] = 1, json::out_of_range&);
+                CHECK_THROWS_WITH(j[jp] = 1, throw_msg.c_str());
+                CHECK_THROWS_AS(j_const[jp] == 1, json::out_of_range&);
+                CHECK_THROWS_WITH(j_const[jp] == 1, throw_msg.c_str());
+            }
+
+            if (sizeof(typename json::size_type) < sizeof(unsigned long long))
+            {
+                auto size_type_max_uul = static_cast<unsigned long long>((std::numeric_limits<json::size_type>::max)());
+                auto too_large_index = std::to_string(size_type_max_uul);
+                json::json_pointer jp(std::string("/") + too_large_index);
+                std::string throw_msg = std::string("[json.exception.out_of_range.410] array index ") + too_large_index + " exceeds size_type";
+
+                CHECK_THROWS_AS(j[jp] = 1, json::out_of_range&);
+                CHECK_THROWS_WITH(j[jp] = 1, throw_msg.c_str());
+                CHECK_THROWS_AS(j_const[jp] == 1, json::out_of_range&);
+                CHECK_THROWS_WITH(j_const[jp] == 1, throw_msg.c_str());
+            }
 
             CHECK_THROWS_AS(j.at("/one"_json_pointer) = 1, json::parse_error&);
             CHECK_THROWS_WITH(j.at("/one"_json_pointer) = 1,
@@ -362,10 +379,10 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_WITH(j_const.at("/one"_json_pointer) == 1,
                               "[json.exception.parse_error.109] parse error: array index 'one' is not a number");
 
-            CHECK(not j.contains("/one"_json_pointer));
-            CHECK(not j.contains("/one"_json_pointer));
-            CHECK(not j_const.contains("/one"_json_pointer));
-            CHECK(not j_const.contains("/one"_json_pointer));
+            CHECK(!j.contains("/one"_json_pointer));
+            CHECK(!j.contains("/one"_json_pointer));
+            CHECK(!j_const.contains("/one"_json_pointer));
+            CHECK(!j_const.contains("/one"_json_pointer));
 
             CHECK_THROWS_AS(json({{"/list/0", 1}, {"/list/1", 2}, {"/list/three", 3}}).unflatten(), json::parse_error&);
             CHECK_THROWS_WITH(json({{"/list/0", 1}, {"/list/1", 2}, {"/list/three", 3}}).unflatten(),
@@ -379,7 +396,7 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_AS(j_const["/-"_json_pointer], json::out_of_range&);
             CHECK_THROWS_WITH(j_const["/-"_json_pointer],
                               "[json.exception.out_of_range.402] array index '-' (3) is out of range");
-            CHECK(not j_const.contains("/-"_json_pointer));
+            CHECK(!j_const.contains("/-"_json_pointer));
 
             // error when using "-" with at
             CHECK_THROWS_AS(j.at("/-"_json_pointer), json::out_of_range&);
@@ -388,7 +405,7 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_AS(j_const.at("/-"_json_pointer), json::out_of_range&);
             CHECK_THROWS_WITH(j_const.at("/-"_json_pointer),
                               "[json.exception.out_of_range.402] array index '-' (3) is out of range");
-            CHECK(not j_const.contains("/-"_json_pointer));
+            CHECK(!j_const.contains("/-"_json_pointer));
         }
 
         SECTION("const access")
@@ -404,13 +421,13 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_AS(j.at("/3"_json_pointer), json::out_of_range&);
             CHECK_THROWS_WITH(j.at("/3"_json_pointer),
                               "[json.exception.out_of_range.401] array index 3 is out of range");
-            CHECK(not j.contains("/3"_json_pointer));
+            CHECK(!j.contains("/3"_json_pointer));
 
             // assign to nonexisting index (with gap)
             CHECK_THROWS_AS(j.at("/5"_json_pointer), json::out_of_range&);
             CHECK_THROWS_WITH(j.at("/5"_json_pointer),
                               "[json.exception.out_of_range.401] array index 5 is out of range");
-            CHECK(not j.contains("/5"_json_pointer));
+            CHECK(!j.contains("/5"_json_pointer));
 
             // assign to "-"
             CHECK_THROWS_AS(j["/-"_json_pointer], json::out_of_range&);
@@ -419,7 +436,7 @@ TEST_CASE("JSON pointers")
             CHECK_THROWS_AS(j.at("/-"_json_pointer), json::out_of_range&);
             CHECK_THROWS_WITH(j.at("/-"_json_pointer),
                               "[json.exception.out_of_range.402] array index '-' (3) is out of range");
-            CHECK(not j.contains("/-"_json_pointer));
+            CHECK(!j.contains("/-"_json_pointer));
         }
     }
 

test/src/unit-large_json.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-merge_patch.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-meta.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -39,14 +39,14 @@ TEST_CASE("version information")
         json j = json::meta();
 
         CHECK(j["name"] == "JSON for Modern C++");
-        CHECK(j["copyright"] == "(C) 2013-2017 Niels Lohmann");
+        CHECK(j["copyright"] == "(C) 2013-2020 Niels Lohmann");
         CHECK(j["url"] == "https://github.com/nlohmann/json");
         CHECK(j["version"] == json(
         {
-            {"string", "3.7.3"},
+            {"string", "3.9.1"},
             {"major", 3},
-            {"minor", 7},
-            {"patch", 3}
+            {"minor", 9},
+            {"patch", 1}
         }));
 
         CHECK(j.find("platform") != j.end());

test/src/unit-modifiers.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -114,7 +114,7 @@ TEST_CASE("modifiers")
                 json k = j;
 
                 j.clear();
-                CHECK(not j.empty());
+                CHECK(!j.empty());
                 CHECK(j == json(json::value_t::binary));
                 CHECK(j == json(k.type()));
             }
@@ -125,7 +125,7 @@ TEST_CASE("modifiers")
                 json k = j;
 
                 j.clear();
-                CHECK(not j.empty());
+                CHECK(!j.empty());
                 CHECK(j == json(json::value_t::binary));
                 CHECK(j == json(k.type()));
             }
@@ -878,7 +878,8 @@ TEST_CASE("modifiers")
                 json j("hello world");
                 json k(42.23);
 
-                std::swap(j, k);
+                using std::swap;
+                swap(j, k);
 
                 CHECK(j == json(42.23));
                 CHECK(k == json("hello world"));

test/src/unit-msgpack.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -37,6 +37,7 @@ using nlohmann::json;
 #include <iomanip>
 #include <set>
 #include <test_data.hpp>
+#include "test_utils.hpp"
 
 namespace
 {
@@ -514,7 +515,7 @@ TEST_CASE("MessagePack")
                                             (static_cast<uint32_t>(result[2]) << 020) +
                                             (static_cast<uint32_t>(result[3]) << 010) +
                                             static_cast<uint32_t>(result[4]);
-                        CHECK(restored == i);
+                        CHECK(static_cast<std::int32_t>(restored) == i);
 
                         // roundtrip
                         CHECK(json::from_msgpack(result) == j);
@@ -783,6 +784,40 @@ TEST_CASE("MessagePack")
                     CHECK(json::from_msgpack(result) == v);
                     CHECK(json::from_msgpack(result, true, false) == j);
                 }
+
+                SECTION("1.0")
+                {
+                    double v = 1.0;
+                    json j = v;
+                    std::vector<uint8_t> expected =
+                    {
+                        0xca, 0x3f, 0x80, 0x00, 0x00
+                    };
+                    const auto result = json::to_msgpack(j);
+                    CHECK(result == expected);
+
+                    // roundtrip
+                    CHECK(json::from_msgpack(result) == j);
+                    CHECK(json::from_msgpack(result) == v);
+                    CHECK(json::from_msgpack(result, true, false) == j);
+                }
+
+                SECTION("128.128")
+                {
+                    double v = 128.1280059814453125;
+                    json j = v;
+                    std::vector<uint8_t> expected =
+                    {
+                        0xca, 0x43, 0x00, 0x20, 0xc5
+                    };
+                    const auto result = json::to_msgpack(j);
+                    CHECK(result == expected);
+
+                    // roundtrip
+                    CHECK(json::from_msgpack(result) == j);
+                    CHECK(json::from_msgpack(result) == v);
+                    CHECK(json::from_msgpack(result, true, false) == j);
+                }
             }
         }
 
@@ -1544,21 +1579,21 @@ TEST_CASE("MessagePack")
         {
             std::vector<uint8_t> v = {0x93, 0x01, 0x02, 0x03};
             SaxCountdown scp(0);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::msgpack));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
         }
 
         SECTION("start_object(len)")
         {
             std::vector<uint8_t> v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
             SaxCountdown scp(0);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::msgpack));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
         }
 
         SECTION("key()")
         {
             std::vector<uint8_t> v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
             SaxCountdown scp(1);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::msgpack));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
         }
     }
 }
@@ -1575,9 +1610,7 @@ TEST_CASE("single MessagePack roundtrip")
         json j1 = json::parse(f_json);
 
         // parse MessagePack file
-        std::ifstream f_msgpack(filename + ".msgpack", std::ios::binary);
-        std::vector<uint8_t> packed((std::istreambuf_iterator<char>(f_msgpack)),
-                                    std::istreambuf_iterator<char>());
+        auto packed = utils::read_binary_file(filename + ".msgpack");
         json j2;
         CHECK_NOTHROW(j2 = json::from_msgpack(packed));
 
@@ -1790,10 +1823,7 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
                 json j1 = json::parse(f_json);
 
                 // parse MessagePack file
-                std::ifstream f_msgpack(filename + ".msgpack", std::ios::binary);
-                std::vector<uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_msgpack)),
-                    std::istreambuf_iterator<char>());
+                auto packed = utils::read_binary_file(filename + ".msgpack");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_msgpack(packed));
 
@@ -1823,10 +1853,7 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
                 json j1 = json::parse(f_json);
 
                 // parse MessagePack file
-                std::ifstream f_msgpack(filename + ".msgpack", std::ios::binary);
-                std::vector<uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_msgpack)),
-                    std::istreambuf_iterator<char>());
+                auto packed = utils::read_binary_file(filename + ".msgpack");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_msgpack({packed.data(), packed.size()}));
 
@@ -1841,10 +1868,7 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
                 json j1 = json::parse(f_json);
 
                 // parse MessagePack file
-                std::ifstream f_msgpack(filename + ".msgpack", std::ios::binary);
-                std::vector<uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_msgpack)),
-                    std::istreambuf_iterator<char>());
+                auto packed = utils::read_binary_file(filename + ".msgpack");
 
                 if (!exclude_packed.count(filename))
                 {

test/src/unit-noexcept.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -59,12 +59,12 @@ static_assert(noexcept(nlohmann::to_json(*j, 2.5)), "");
 static_assert(noexcept(nlohmann::to_json(*j, true)), "");
 static_assert(noexcept(nlohmann::to_json(*j, test{})), "");
 static_assert(noexcept(nlohmann::to_json(*j, pod{})), "");
-static_assert(not noexcept(nlohmann::to_json(*j, pod_bis{})), "");
+static_assert(!noexcept(nlohmann::to_json(*j, pod_bis{})), "");
 static_assert(noexcept(json(2)), "");
 static_assert(noexcept(json(test{})), "");
 static_assert(noexcept(json(pod{})), "");
 static_assert(noexcept(j->get<pod>()), "");
-static_assert(not noexcept(j->get<pod_bis>()), "");
+static_assert(!noexcept(j->get<pod_bis>()), "");
 static_assert(noexcept(json(pod{})), "");
 }
 

test/src/unit-ordered_json.cpp

@@ -0,0 +1,79 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++ (test suite)
+|  |  |__   |  |  | | | |  version 3.9.1
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+using nlohmann::ordered_json;
+
+
+TEST_CASE("ordered_json")
+{
+    json j;
+    ordered_json oj;
+
+    j["element3"] = 3;
+    j["element1"] = 1;
+    j["element2"] = 2;
+
+    oj["element3"] = 3;
+    oj["element1"] = 1;
+    oj["element2"] = 2;
+
+    CHECK(j.dump() == "{\"element1\":1,\"element2\":2,\"element3\":3}");
+    CHECK(oj.dump() == "{\"element3\":3,\"element1\":1,\"element2\":2}");
+
+    CHECK(j == json(oj));
+    CHECK(ordered_json(json(oj)) == ordered_json(j));
+
+    j.erase("element1");
+    oj.erase("element1");
+
+    CHECK(j.dump() == "{\"element2\":2,\"element3\":3}");
+    CHECK(oj.dump() == "{\"element3\":3,\"element2\":2}");
+
+    // remove again and nothing changes
+    j.erase("element1");
+    oj.erase("element1");
+
+    CHECK(j.dump() == "{\"element2\":2,\"element3\":3}");
+    CHECK(oj.dump() == "{\"element3\":3,\"element2\":2}");
+
+    // There are no dup keys cause constructor calls emplace...
+    json multi {{"z", 1}, {"m", 2}, {"m", 3}, {"y", 4}, {"m", 5}};
+    CHECK(multi.size() == 3);
+    CHECK(multi.dump() == "{\"m\":2,\"y\":4,\"z\":1}");
+
+    ordered_json multi_ordered {{"z", 1}, {"m", 2}, {"m", 3}, {"y", 4}, {"m", 5}};
+    CHECK(multi_ordered.size() == 3);
+    CHECK(multi_ordered.dump() == "{\"z\":1,\"m\":2,\"y\":4}");
+    CHECK(multi_ordered.erase("m") == 1);
+    CHECK(multi_ordered.dump() == "{\"z\":1,\"y\":4}");
+}

test/src/unit-ordered_map.cpp

@@ -0,0 +1,292 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++ (test suite)
+|  |  |__   |  |  | | | |  version 3.9.1
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+using nlohmann::ordered_map;
+
+
+TEST_CASE("ordered_map")
+{
+    SECTION("constructor")
+    {
+        SECTION("constructor from iterator range")
+        {
+            std::map<std::string, std::string> m {{"eins", "one"}, {"zwei", "two"}, {"drei", "three"}};
+            ordered_map<std::string, std::string> om(m.begin(), m.end());
+            CHECK(om.size() == 3);
+        }
+
+        SECTION("copy assignment")
+        {
+            std::map<std::string, std::string> m {{"eins", "one"}, {"zwei", "two"}, {"drei", "three"}};
+            ordered_map<std::string, std::string> om(m.begin(), m.end());
+            const auto com = om;
+            CHECK(com.size() == 3);
+        }
+    }
+
+    SECTION("at")
+    {
+        std::map<std::string, std::string> m {{"eins", "one"}, {"zwei", "two"}, {"drei", "three"}};
+        ordered_map<std::string, std::string> om(m.begin(), m.end());
+        const auto com = om;
+
+        SECTION("with Key&&")
+        {
+            CHECK(om.at(std::string("eins")) == std::string("one"));
+            CHECK(com.at(std::string("eins")) == std::string("one"));
+            CHECK_THROWS_AS(om.at(std::string("vier")), std::out_of_range);
+            CHECK_THROWS_AS(com.at(std::string("vier")), std::out_of_range);
+        }
+
+        SECTION("with const Key&&")
+        {
+            const std::string eins = "eins";
+            const std::string vier = "vier";
+            CHECK(om.at(eins) == std::string("one"));
+            CHECK(com.at(eins) == std::string("one"));
+            CHECK_THROWS_AS(om.at(vier), std::out_of_range);
+            CHECK_THROWS_AS(com.at(vier), std::out_of_range);
+        }
+
+        SECTION("with string literal")
+        {
+            CHECK(om.at("eins") == std::string("one"));
+            CHECK(com.at("eins") == std::string("one"));
+            CHECK_THROWS_AS(om.at("vier"), std::out_of_range);
+            CHECK_THROWS_AS(com.at("vier"), std::out_of_range);
+        }
+    }
+
+    SECTION("operator[]")
+    {
+        std::map<std::string, std::string> m {{"eins", "one"}, {"zwei", "two"}, {"drei", "three"}};
+        ordered_map<std::string, std::string> om(m.begin(), m.end());
+        const auto com = om;
+
+        SECTION("with Key&&")
+        {
+            CHECK(om[std::string("eins")] == std::string("one"));
+            CHECK(com[std::string("eins")] == std::string("one"));
+
+            CHECK(om[std::string("vier")] == std::string(""));
+            CHECK(om.size() == 4);
+        }
+
+        SECTION("with const Key&&")
+        {
+            const std::string eins = "eins";
+            const std::string vier = "vier";
+
+            CHECK(om[eins] == std::string("one"));
+            CHECK(com[eins] == std::string("one"));
+
+            CHECK(om[vier] == std::string(""));
+            CHECK(om.size() == 4);
+        }
+
+        SECTION("with string literal")
+        {
+            CHECK(om["eins"] == std::string("one"));
+            CHECK(com["eins"] == std::string("one"));
+
+            CHECK(om["vier"] == std::string(""));
+            CHECK(om.size() == 4);
+        }
+    }
+
+    SECTION("erase")
+    {
+        ordered_map<std::string, std::string> om;
+        om["eins"] = "one";
+        om["zwei"] = "two";
+        om["drei"] = "three";
+
+        {
+            auto it = om.begin();
+            CHECK(it->first == "eins");
+            ++it;
+            CHECK(it->first == "zwei");
+            ++it;
+            CHECK(it->first == "drei");
+            ++it;
+            CHECK(it == om.end());
+        }
+
+        SECTION("with Key&&")
+        {
+            CHECK(om.size() == 3);
+            CHECK(om.erase(std::string("eins")) == 1);
+            CHECK(om.size() == 2);
+            CHECK(om.erase(std::string("vier")) == 0);
+            CHECK(om.size() == 2);
+
+            auto it = om.begin();
+            CHECK(it->first == "zwei");
+            ++it;
+            CHECK(it->first == "drei");
+            ++it;
+            CHECK(it == om.end());
+        }
+
+        SECTION("with const Key&&")
+        {
+            const std::string eins = "eins";
+            const std::string vier = "vier";
+            CHECK(om.size() == 3);
+            CHECK(om.erase(eins) == 1);
+            CHECK(om.size() == 2);
+            CHECK(om.erase(vier) == 0);
+            CHECK(om.size() == 2);
+
+            auto it = om.begin();
+            CHECK(it->first == "zwei");
+            ++it;
+            CHECK(it->first == "drei");
+            ++it;
+            CHECK(it == om.end());
+        }
+
+        SECTION("with string literal")
+        {
+            CHECK(om.size() == 3);
+            CHECK(om.erase("eins") == 1);
+            CHECK(om.size() == 2);
+            CHECK(om.erase("vier") == 0);
+            CHECK(om.size() == 2);
+
+            auto it = om.begin();
+            CHECK(it->first == "zwei");
+            ++it;
+            CHECK(it->first == "drei");
+            ++it;
+            CHECK(it == om.end());
+        }
+
+        SECTION("with iterator")
+        {
+            CHECK(om.size() == 3);
+            CHECK(om.begin()->first == "eins");
+            CHECK(std::next(om.begin(), 1)->first == "zwei");
+            CHECK(std::next(om.begin(), 2)->first == "drei");
+
+            auto it = om.erase(om.begin());
+            CHECK(it->first == "zwei");
+            CHECK(om.size() == 2);
+
+            auto it2 = om.begin();
+            CHECK(it2->first == "zwei");
+            ++it2;
+            CHECK(it2->first == "drei");
+            ++it2;
+            CHECK(it2 == om.end());
+        }
+    }
+
+    SECTION("count")
+    {
+        ordered_map<std::string, std::string> om;
+        om["eins"] = "one";
+        om["zwei"] = "two";
+        om["drei"] = "three";
+
+        const std::string eins("eins");
+        const std::string vier("vier");
+        CHECK(om.count("eins") == 1);
+        CHECK(om.count(std::string("eins")) == 1);
+        CHECK(om.count(eins) == 1);
+        CHECK(om.count("vier") == 0);
+        CHECK(om.count(std::string("vier")) == 0);
+        CHECK(om.count(vier) == 0);
+    }
+
+    SECTION("find")
+    {
+        ordered_map<std::string, std::string> om;
+        om["eins"] = "one";
+        om["zwei"] = "two";
+        om["drei"] = "three";
+        const auto com = om;
+
+        const std::string eins("eins");
+        const std::string vier("vier");
+        CHECK(om.find("eins") == om.begin());
+        CHECK(om.find(std::string("eins")) == om.begin());
+        CHECK(om.find(eins) == om.begin());
+        CHECK(om.find("vier") == om.end());
+        CHECK(om.find(std::string("vier")) == om.end());
+        CHECK(om.find(vier) == om.end());
+
+        CHECK(com.find("eins") == com.begin());
+        CHECK(com.find(std::string("eins")) == com.begin());
+        CHECK(com.find(eins) == com.begin());
+        CHECK(com.find("vier") == com.end());
+        CHECK(com.find(std::string("vier")) == com.end());
+        CHECK(com.find(vier) == com.end());
+    }
+
+    SECTION("insert")
+    {
+        ordered_map<std::string, std::string> om;
+        om["eins"] = "one";
+        om["zwei"] = "two";
+        om["drei"] = "three";
+
+        SECTION("const value_type&")
+        {
+            ordered_map<std::string, std::string>::value_type vt1 {"eins", "1"};
+            ordered_map<std::string, std::string>::value_type vt4 {"vier", "four"};
+
+            auto res1 = om.insert(vt1);
+            CHECK(res1.first == om.begin());
+            CHECK(res1.second == false);
+            CHECK(om.size() == 3);
+
+            auto res4 = om.insert(vt4);
+            CHECK(res4.first == om.begin() + 3);
+            CHECK(res4.second == true);
+            CHECK(om.size() == 4);
+        }
+
+        SECTION("value_type&&")
+        {
+            auto res1 = om.insert({"eins", "1"});
+            CHECK(res1.first == om.begin());
+            CHECK(res1.second == false);
+            CHECK(om.size() == 3);
+
+            auto res4 = om.insert({"vier", "four"});
+            CHECK(res4.first == om.begin() + 3);
+            CHECK(res4.second == true);
+            CHECK(om.size() == 4);
+        }
+    }
+}

test/src/unit-pointer_access.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-readme.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -174,9 +174,9 @@ TEST_CASE("README" * doctest::skip())
             }
 
             // getter/setter
-            const std::string tmp = j[0];
+            const auto tmp = j[0].get<std::string>();
             j[1] = 42;
-            bool foo = j.at(2);
+            bool foo{j.at(2)};
             CHECK(foo == true);
 
             // other stuff
@@ -258,18 +258,18 @@ TEST_CASE("README" * doctest::skip())
             // strings
             std::string s1 = "Hello, world!";
             json js = s1;
-            std::string s2 = js;
+            auto s2 = js.get<std::string>();
 
             // Booleans
             bool b1 = true;
             json jb = b1;
-            bool b2 = jb;
+            bool b2{jb};
             CHECK(b2 == true);
 
             // numbers
             int i = 42;
             json jn = i;
-            double f = jn;
+            double f{jn};
             CHECK(f == 42);
 
             // etc.

test/src/unit-reference_access.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-regression1.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -128,83 +128,9 @@ struct nocopy
         j = {{"val", n.val}};
     }
 };
-
-struct Data
-{
-    Data() = default;
-    Data(const std::string& a_, const std::string b_) : a(a_), b(b_) {}
-    std::string a {};
-    std::string b {};
-};
-
-void from_json(const json& j, Data& data)
-{
-    j["a"].get_to(data.a);
-    j["b"].get_to(data.b);
 }
 
-bool operator==(Data const& lhs, Data const& rhs)
-{
-    return lhs.a == rhs.a && lhs.b == rhs.b;
-}
-
-//bool operator!=(Data const& lhs, Data const& rhs)
-//{
-//    return !(lhs == rhs);
-//}
-}
-
-/////////////////////////////////////////////////////////////////////
-// for #1021
-/////////////////////////////////////////////////////////////////////
-
-using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
-
-/////////////////////////////////////////////////////////////////////
-// for #1647
-/////////////////////////////////////////////////////////////////////
-namespace
-{
-struct NonDefaultFromJsonStruct { };
-
-inline bool operator== (NonDefaultFromJsonStruct const&, NonDefaultFromJsonStruct const&)
-{
-    return true;
-}
-
-enum class for_1647 { one, two };
-
-NLOHMANN_JSON_SERIALIZE_ENUM(for_1647,
-{
-    {for_1647::one, "one"},
-    {for_1647::two, "two"},
-})
-}
-
-namespace nlohmann
-{
-template <>
-struct adl_serializer<NonDefaultFromJsonStruct>
-{
-    static NonDefaultFromJsonStruct from_json (json const&) noexcept
-    {
-        return {};
-    }
-};
-}
-
-/////////////////////////////////////////////////////////////////////
-// for #1805
-/////////////////////////////////////////////////////////////////////
-
-struct NotSerializableData
-{
-    int mydata;
-    float myfloat;
-};
-
-
-TEST_CASE("regression tests")
+TEST_CASE("regression tests 1")
 {
     SECTION("issue #60 - Double quotation mark is not parsed correctly")
     {
@@ -240,12 +166,12 @@ TEST_CASE("regression tests")
         {
             json j1 = NAN;
             CHECK(j1.is_number_float());
-            json::number_float_t f1 = j1;
+            json::number_float_t f1{j1};
             CHECK(std::isnan(f1));
 
             json j2 = json::number_float_t(NAN);
             CHECK(j2.is_number_float());
-            json::number_float_t f2 = j2;
+            json::number_float_t f2{j2};
             CHECK(std::isnan(f2));
         }
 
@@ -253,13 +179,13 @@ TEST_CASE("regression tests")
         {
             json j1 = INFINITY;
             CHECK(j1.is_number_float());
-            json::number_float_t f1 = j1;
-            CHECK(not std::isfinite(f1));
+            json::number_float_t f1{j1};
+            CHECK(!std::isfinite(f1));
 
             json j2 = json::number_float_t(INFINITY);
             CHECK(j2.is_number_float());
-            json::number_float_t f2 = j2;
-            CHECK(not std::isfinite(f2));
+            json::number_float_t f2{j2};
+            CHECK(!std::isfinite(f2));
         }
     }
 
@@ -332,11 +258,11 @@ TEST_CASE("regression tests")
         json j;
         ss >> j;
 
-        std::string test = j["Test"];
+        auto test = j["Test"].get<std::string>();
         CHECK(test == "Test1");
-        int number = j["Number"];
+        int number{j["Number"]};
         CHECK(number == 100);
-        float foo = j["Foo"];
+        float foo{j["Foo"]};
         CHECK(static_cast<double>(foo) == Approx(42.42));
     }
 
@@ -453,6 +379,7 @@ TEST_CASE("regression tests")
         CHECK(j["string"] == "\u0007\u0007");
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("issue #144 - implicit assignment to std::string fails")
     {
         json o = {{"name", "value"}};
@@ -470,6 +397,7 @@ TEST_CASE("regression tests")
         CHECK_THROWS_AS(s2 = o["int"], json::type_error);
         CHECK_THROWS_WITH(s2 = o["int"], "[json.exception.type_error.302] type must be string, but is number");
     }
+#endif
 
     SECTION("issue #146 - character following a surrogate pair is skipped")
     {
@@ -689,7 +617,7 @@ TEST_CASE("regression tests")
             {"object", {{"key1", 1}, {"key2", 2}}},
         };
 
-        int at_integer = j.at("/object/key2"_json_pointer);
+        int at_integer{j.at("/object/key2"_json_pointer)};
         int val_integer = j.value("/object/key2"_json_pointer, 0);
 
         CHECK(at_integer == val_integer);
@@ -1233,6 +1161,7 @@ TEST_CASE("regression tests")
         CHECK(j["double_value"].is_number_float());
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("issue #464 - VS2017 implicit to std::string conversion fix")
     {
         json v = "test";
@@ -1240,6 +1169,7 @@ TEST_CASE("regression tests")
         test = v;
         CHECK(v == "test");
     }
+#endif
 
     SECTION("issue #465 - roundtrip error while parsing 1000000000000000010E5")
     {
@@ -1250,6 +1180,7 @@ TEST_CASE("regression tests")
         CHECK(s1 == s2);
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("issue #473 - inconsistent behavior in conversion to array type")
     {
         json j_array = {1, 2, 3, 4};
@@ -1298,6 +1229,7 @@ TEST_CASE("regression tests")
             CHECK_THROWS_WITH(create(j_null), "[json.exception.type_error.302] type must be array, but is null");
         }
     }
+#endif
 
     SECTION("issue #486 - json::value_t can't be a map's key type in VC++ 2015")
     {
@@ -1350,10 +1282,10 @@ TEST_CASE("regression tests")
         CHECK(j["a"] >  3);
 
 
-        CHECK(not(j["a"] <= 4));
-        CHECK(not(j["a"] <  4));
-        CHECK(not(j["a"] >= 6));
-        CHECK(not(j["a"] >  6));
+        CHECK(!(j["a"] <= 4));
+        CHECK(!(j["a"] <  4));
+        CHECK(!(j["a"] >= 6));
+        CHECK(!(j["a"] >  6));
 
         // scalar op json
         CHECK(5 == j["a"]);
@@ -1364,10 +1296,10 @@ TEST_CASE("regression tests")
         CHECK(3 <= j["a"]);
         CHECK(3 <  j["a"]);
 
-        CHECK(not(4 >= j["a"]));
-        CHECK(not(4 >  j["a"]));
-        CHECK(not(6 <= j["a"]));
-        CHECK(not(6 <  j["a"]));
+        CHECK(!(4 >= j["a"]));
+        CHECK(!(4 >  j["a"]));
+        CHECK(!(6 <= j["a"]));
+        CHECK(!(6 <  j["a"]));
     }
 
     SECTION("issue #575 - heap-buffer-overflow (OSS-Fuzz 1400)")
@@ -1377,6 +1309,7 @@ TEST_CASE("regression tests")
         CHECK_THROWS_AS(_ = json::parse(vec), json::parse_error&);
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("issue #600 - how does one convert a map in Json back to std::map?")
     {
         SECTION("example 1")
@@ -1409,6 +1342,7 @@ TEST_CASE("regression tests")
             CHECK(m1 == m2);
         }
     }
+#endif
 
     SECTION("issue #602 - BOM not skipped when using json:parse(iterator)")
     {
@@ -1417,6 +1351,7 @@ TEST_CASE("regression tests")
         CHECK_NOTHROW(_ = json::parse(i.begin(), i.end()));
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("issue #702 - conversion from valarray<double> to json fails to build")
     {
         SECTION("original example")
@@ -1445,6 +1380,7 @@ TEST_CASE("regression tests")
                               "[json.exception.type_error.302] type must be array, but is null");
         }
     }
+#endif
 
     SECTION("issue #367 - Behavior of operator>> should more closely resemble that of built-in overloads.")
     {
@@ -1456,9 +1392,9 @@ TEST_CASE("regression tests")
             i1_2_3 >> j2;
             i1_2_3 >> j3;
 
-            std::map<std::string, std::string> m1 = j1;
-            std::map<std::string, std::string> m2 = j2;
-            int i3 = j3;
+            auto m1 = j1.get<std::map<std::string, std::string>>();
+            auto m2 = j2.get<std::map<std::string, std::string>>();
+            int i3{j3};
 
             CHECK( m1 == ( std::map<std::string, std::string> {{ "first",  "one" }} ));
             CHECK( m2 == ( std::map<std::string, std::string> {{ "second", "two" }} ));
@@ -1506,13 +1442,14 @@ TEST_CASE("regression tests")
 
     SECTION("issue #838 - incorrect parse error with binary data in keys")
     {
-        uint8_t key1[] = { 103, 92, 117, 48, 48, 48, 55, 92, 114, 215, 126, 214, 95, 92, 34, 174, 40, 71, 38, 174, 40, 71, 38, 223, 134, 247, 127 };
-        std::string key1_str(key1, key1 + sizeof(key1) / sizeof(key1[0]));
+        uint8_t key1[] = { 103, 92, 117, 48, 48, 48, 55, 92, 114, 215, 126, 214, 95, 92, 34, 174, 40, 71, 38, 174, 40, 71, 38, 223, 134, 247, 127, 0 };
+        std::string key1_str(reinterpret_cast<char*>(key1));
         json j = key1_str;
         CHECK_THROWS_AS(j.dump(), json::type_error&);
         CHECK_THROWS_WITH(j.dump(), "[json.exception.type_error.316] invalid UTF-8 byte at index 10: 0x7E");
     }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
     SECTION("issue #843 - converting to array not working")
     {
         json j;
@@ -1520,6 +1457,7 @@ TEST_CASE("regression tests")
         j = ar;
         ar = j;
     }
+#endif
 
     SECTION("issue #894 - invalid RFC6902 copy operation succeeds")
     {
@@ -1608,7 +1546,7 @@ TEST_CASE("regression tests")
         json::parser_callback_t cb = [](int /*depth*/, json::parse_event_t event, json & parsed)
         {
             // skip object elements with key "Thumbnail"
-            if (event == json::parse_event_t::key and parsed == json("Thumbnail"))
+            if (event == json::parse_event_t::key && parsed == json("Thumbnail"))
             {
                 return false;
             }
@@ -1632,300 +1570,16 @@ TEST_CASE("regression tests")
     SECTION("issue #977 - Assigning between different json types")
     {
         foo_json lj = ns::foo{3};
-        ns::foo ff = lj;
+        ns::foo ff(lj);
         CHECK(lj.is_object());
         CHECK(lj.size() == 1);
         CHECK(lj["x"] == 3);
         CHECK(ff.x == 3);
         nlohmann::json nj = lj;                // This line works as expected
     }
-
-    SECTION("issue #1001 - Fix memory leak during parser callback")
-    {
-        auto geojsonExample = R"(
-          { "type": "FeatureCollection",
-            "features": [
-              { "type": "Feature",
-                "geometry": {"type": "Point", "coordinates": [102.0, 0.5]},
-                "properties": {"prop0": "value0"}
-                },
-              { "type": "Feature",
-                "geometry": {
-                  "type": "LineString",
-                  "coordinates": [
-                    [102.0, 0.0], [103.0, 1.0], [104.0, 0.0], [105.0, 1.0]
-                    ]
-                  },
-                "properties": {
-                  "prop0": "value0",
-                  "prop1": 0.0
-                  }
-                },
-              { "type": "Feature",
-                 "geometry": {
-                   "type": "Polygon",
-                   "coordinates": [
-                     [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
-                       [100.0, 1.0], [100.0, 0.0] ]
-                     ]
-                 },
-                 "properties": {
-                   "prop0": "value0",
-                   "prop1": {"this": "that"}
-                   }
-                 }
-               ]
-             })";
-
-        json::parser_callback_t cb = [&](int, json::parse_event_t event, json & parsed)
-        {
-            // skip uninteresting events
-            if (event == json::parse_event_t::value and !parsed.is_primitive())
-            {
-                return false;
-            }
-
-            switch (event)
-            {
-                case json::parse_event_t::key:
-                    {
-                        return true;
-                    }
-                case json::parse_event_t::value:
-                    {
-                        return false;
-                    }
-                case json::parse_event_t::object_start:
-                    {
-                        return true;
-                    }
-                case json::parse_event_t::object_end:
-                    {
-                        return false;
-                    }
-                case json::parse_event_t::array_start:
-                    {
-                        return true;
-                    }
-                case json::parse_event_t::array_end:
-                    {
-                        return false;
-                    }
-
-                default:
-                    {
-                        return true;
-                    }
-            }
-        };
-
-        auto j = json::parse(geojsonExample, cb, true);
-        CHECK(j == json());
-    }
-
-    SECTION("issue #1021 - to/from_msgpack only works with standard typization")
-    {
-        float_json j = 1000.0;
-        CHECK(float_json::from_cbor(float_json::to_cbor(j)) == j);
-        CHECK(float_json::from_msgpack(float_json::to_msgpack(j)) == j);
-        CHECK(float_json::from_ubjson(float_json::to_ubjson(j)) == j);
-
-        float_json j2 = {1000.0, 2000.0, 3000.0};
-        CHECK(float_json::from_ubjson(float_json::to_ubjson(j2, true, true)) == j2);
-    }
-
-    SECTION("issue #1045 - Using STL algorithms with JSON containers with expected results?")
-    {
-        json diffs = nlohmann::json::array();
-        json m1{{"key1", 42}};
-        json m2{{"key2", 42}};
-        auto p1 = m1.items();
-        auto p2 = m2.items();
-
-        using it_type = decltype(p1.begin());
-
-        std::set_difference(
-            p1.begin(), p1.end(),
-            p2.begin(), p2.end(),
-            std::inserter(diffs, diffs.end()), [&](const it_type & e1, const it_type & e2) -> bool
-        {
-            using comper_pair = std::pair<std::string, decltype(e1.value())>; // Trying to avoid unneeded copy
-            return comper_pair(e1.key(), e1.value()) < comper_pair(e2.key(), e2.value()); // Using pair comper
-        });
-
-        CHECK(diffs.size() == 1); // Note the change here, was 2
-    }
-
-#ifdef JSON_HAS_CPP_17
-    SECTION("issue #1292 - Serializing std::variant causes stack overflow")
-    {
-        static_assert(
-            not std::is_constructible<json, std::variant<int, float>>::value, "");
-    }
-#endif
-
-    SECTION("issue #1299 - compile error in from_json converting to container "
-            "with std::pair")
-    {
-        json j =
-        {
-            {"1", {{"a", "testa_1"}, {"b", "testb_1"}}},
-            {"2", {{"a", "testa_2"}, {"b", "testb_2"}}},
-            {"3", {{"a", "testa_3"}, {"b", "testb_3"}}},
-        };
-
-        std::map<std::string, Data> expected
-        {
-            {"1", {"testa_1", "testb_1"}},
-            {"2", {"testa_2", "testb_2"}},
-            {"3", {"testa_3", "testb_3"}},
-        };
-        const auto data = j.get<decltype(expected)>();
-        CHECK(expected == data);
-    }
-
-    SECTION("issue #1445 - buffer overflow in dumping invalid utf-8 strings")
-    {
-        SECTION("a bunch of -1, ensure_ascii=true")
-        {
-            const auto length = 300;
-
-            json dump_test;
-            dump_test["1"] = std::string(length, -1);
-
-            std::string expected = "{\"1\":\"";
-            for (int i = 0; i < length; ++i)
-            {
-                expected += "\\ufffd";
-            }
-            expected += "\"}";
-
-            auto s = dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);
-            CHECK(s == expected);
-        }
-        SECTION("a bunch of -2, ensure_ascii=false")
-        {
-            const auto length = 500;
-
-            json dump_test;
-            dump_test["1"] = std::string(length, -2);
-
-            std::string expected = "{\"1\":\"";
-            for (int i = 0; i < length; ++i)
-            {
-                expected += "\xEF\xBF\xBD";
-            }
-            expected += "\"}";
-
-            auto s = dump_test.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace);
-            CHECK(s == expected);
-        }
-        SECTION("test case in issue #1445")
-        {
-            nlohmann::json dump_test;
-            const int data[] =
-            {
-                109,  108,  103,  125,  -122, -53,  115,
-                18,   3,    0,    102,  19,   1,    15,
-                -110, 13,   -3,   -1,   -81,  32,   2,
-                0,    0,    0,    0,    0,    0,    0,
-                8,    0,    0,    0,    0,    0,    0,
-                0,    0,    0,    0,    0,    -80,  2,
-                0,    0,    96,   -118, 46,   -116, 46,
-                109,  -84,  -87,  108,  14,   109,  -24,
-                -83,  13,   -18,  -51,  -83,  -52,  -115,
-                14,   6,    32,   0,    0,    0,    0,
-                0,    0,    0,    0,    0,    0,    0,
-                64,   3,    0,    0,    0,    35,   -74,
-                -73,  55,   57,   -128, 0,    0,    0,
-                0,    0,    0,    0,    0,    0,    0,
-                0,    0,    33,   0,    0,    0,    -96,
-                -54,  -28,  -26
-            };
-            std::string s;
-            for (unsigned i = 0; i < sizeof(data) / sizeof(int); i++)
-            {
-                s += static_cast<char>(data[i]);
-            }
-            dump_test["1"] = s;
-            dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);
-        }
-    }
-
-    SECTION("issue #1447 - Integer Overflow (OSS-Fuzz 12506)")
-    {
-        json j = json::parse("[-9223372036854775808]");
-        CHECK(j.dump() == "[-9223372036854775808]");
-    }
-
-    SECTION("issue #1708 - minimum value of int64_t can be outputted")
-    {
-        constexpr auto smallest = (std::numeric_limits<int64_t>::min)();
-        json j = smallest;
-        CHECK(j.dump() == std::to_string(smallest));
-    }
-
-    SECTION("issue #1727 - Contains with non-const lvalue json_pointer picks the wrong overload")
-    {
-        json j = {{"root", {{"settings", {{"logging", true}}}}}};
-
-        auto jptr1 = "/root/settings/logging"_json_pointer;
-        auto jptr2 = json::json_pointer{"/root/settings/logging"};
-
-        CHECK(j.contains(jptr1));
-        CHECK(j.contains(jptr2));
-    }
-
-    SECTION("issue #1647 - compile error when deserializing enum if both non-default from_json and non-member operator== exists for other type")
-    {
-        {
-            json j;
-            NonDefaultFromJsonStruct x = j;
-            NonDefaultFromJsonStruct y;
-            CHECK(x == y);
-        }
-
-        auto val = nlohmann::json("one").get<for_1647>();
-        CHECK(val == for_1647::one);
-        json j = val;
-    }
-
-    SECTION("issue #1805 - A pair<T1, T2> is json constructible only if T1 and T2 are json constructible")
-    {
-        static_assert(!std::is_constructible<json, std::pair<std::string, NotSerializableData>>::value, "");
-        static_assert(!std::is_constructible<json, std::pair<NotSerializableData, std::string>>::value, "");
-        static_assert(std::is_constructible<json, std::pair<int, std::string>>::value, "");
-    }
-    SECTION("issue #1825 - A tuple<Args..> is json constructible only if all T in Args are json constructible")
-    {
-        static_assert(!std::is_constructible<json, std::tuple<std::string, NotSerializableData>>::value, "");
-        static_assert(!std::is_constructible<json, std::tuple<NotSerializableData, std::string>>::value, "");
-        static_assert(std::is_constructible<json, std::tuple<int, std::string>>::value, "");
-    }
-
-    SECTION("issue #1983 - JSON patch diff for op=add formation is not as per standard (RFC 6902)")
-    {
-        const auto source = R"({ "foo": [ "1", "2" ] })"_json;
-        const auto target = R"({"foo": [ "1", "2", "3" ]})"_json;
-        const auto result = json::diff(source, target);
-        CHECK(result.dump() == R"([{"op":"add","path":"/foo/-","value":"3"}])");
-    }
-
-    SECTION("issue #2067 - cannot serialize binary data to text JSON")
-    {
-        const unsigned char data[] = {0x81, 0xA4, 0x64, 0x61, 0x74, 0x61, 0xC4, 0x0F, 0x33, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x31, 0x30, 0x37, 0x30, 0x35, 0x30, 0x31, 0x30};
-        json j = json::from_msgpack(data, sizeof(data) / sizeof(data[0]));
-        CHECK_NOTHROW(
-            j.dump(4,                              // Indent
-                   ' ',                            // Indent char
-                   false,                          // Ensure ascii
-                   json::error_handler_t::strict  // Error
-                  )
-        );
-    }
 }
 
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
 TEST_CASE("regression tests, exceptions dependent")
 {
     SECTION("issue #1340 - eof not set on exhausted input stream")
@@ -1943,9 +1597,14 @@ TEST_CASE("regression tests, exceptions dependent")
 /////////////////////////////////////////////////////////////////////
 // for #1642
 /////////////////////////////////////////////////////////////////////
+
+// the code below fails with Clang on Windows, so we need to exclude it there
+#if defined(__clang__) && (defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__))
+#else
 template <typename T> class array {};
 template <typename T> class object {};
 template <typename T> class string {};
 template <typename T> class number_integer {};
 template <typename T> class number_unsigned {};
 template <typename T> class number_float {};
+#endif

test/src/unit-regression2.cpp

@@ -0,0 +1,488 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++ (test suite)
+|  |  |__   |  |  | | | |  version 3.9.1
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "doctest_compatibility.h"
+DOCTEST_GCC_SUPPRESS_WARNING("-Wfloat-equal")
+
+// for some reason including this after the json header leads to linker errors with VS 2017...
+#include <locale>
+
+#define private public
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+#undef private
+
+#include <fstream>
+#include <sstream>
+#include <list>
+#include <cstdio>
+#include <test_data.hpp>
+
+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+    #define JSON_HAS_CPP_17
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #include <variant>
+#endif
+
+/////////////////////////////////////////////////////////////////////
+// for #1021
+/////////////////////////////////////////////////////////////////////
+
+using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
+
+/////////////////////////////////////////////////////////////////////
+// for #1647
+/////////////////////////////////////////////////////////////////////
+namespace
+{
+struct NonDefaultFromJsonStruct { };
+
+inline bool operator== (NonDefaultFromJsonStruct const&, NonDefaultFromJsonStruct const&)
+{
+    return true;
+}
+
+enum class for_1647 { one, two };
+
+NLOHMANN_JSON_SERIALIZE_ENUM(for_1647,
+{
+    {for_1647::one, "one"},
+    {for_1647::two, "two"},
+})
+}
+
+/////////////////////////////////////////////////////////////////////
+// for #1299
+/////////////////////////////////////////////////////////////////////
+
+struct Data
+{
+    Data() = default;
+    Data(const std::string& a_, const std::string b_) : a(a_), b(b_) {}
+    std::string a {};
+    std::string b {};
+};
+
+void from_json(const json& j, Data& data)
+{
+    j["a"].get_to(data.a);
+    j["b"].get_to(data.b);
+}
+
+bool operator==(Data const& lhs, Data const& rhs)
+{
+    return lhs.a == rhs.a && lhs.b == rhs.b;
+}
+
+//bool operator!=(Data const& lhs, Data const& rhs)
+//{
+//    return !(lhs == rhs);
+//}
+
+namespace nlohmann
+{
+template <>
+struct adl_serializer<NonDefaultFromJsonStruct>
+{
+    static NonDefaultFromJsonStruct from_json (json const&) noexcept
+    {
+        return {};
+    }
+};
+}
+
+/////////////////////////////////////////////////////////////////////
+// for #1805
+/////////////////////////////////////////////////////////////////////
+
+struct NotSerializableData
+{
+    int mydata;
+    float myfloat;
+};
+
+
+TEST_CASE("regression tests 2")
+{
+    SECTION("issue #1001 - Fix memory leak during parser callback")
+    {
+        auto geojsonExample = R"(
+          { "type": "FeatureCollection",
+            "features": [
+              { "type": "Feature",
+                "geometry": {"type": "Point", "coordinates": [102.0, 0.5]},
+                "properties": {"prop0": "value0"}
+                },
+              { "type": "Feature",
+                "geometry": {
+                  "type": "LineString",
+                  "coordinates": [
+                    [102.0, 0.0], [103.0, 1.0], [104.0, 0.0], [105.0, 1.0]
+                    ]
+                  },
+                "properties": {
+                  "prop0": "value0",
+                  "prop1": 0.0
+                  }
+                },
+              { "type": "Feature",
+                 "geometry": {
+                   "type": "Polygon",
+                   "coordinates": [
+                     [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
+                       [100.0, 1.0], [100.0, 0.0] ]
+                     ]
+                 },
+                 "properties": {
+                   "prop0": "value0",
+                   "prop1": {"this": "that"}
+                   }
+                 }
+               ]
+             })";
+
+        json::parser_callback_t cb = [&](int, json::parse_event_t event, json & parsed)
+        {
+            // skip uninteresting events
+            if (event == json::parse_event_t::value && !parsed.is_primitive())
+            {
+                return false;
+            }
+
+            switch (event)
+            {
+                case json::parse_event_t::key:
+                {
+                    return true;
+                }
+                case json::parse_event_t::value:
+                {
+                    return false;
+                }
+                case json::parse_event_t::object_start:
+                {
+                    return true;
+                }
+                case json::parse_event_t::object_end:
+                {
+                    return false;
+                }
+                case json::parse_event_t::array_start:
+                {
+                    return true;
+                }
+                case json::parse_event_t::array_end:
+                {
+                    return false;
+                }
+
+                default:
+                {
+                    return true;
+                }
+            }
+        };
+
+        auto j = json::parse(geojsonExample, cb, true);
+        CHECK(j == json());
+    }
+
+    SECTION("issue #1021 - to/from_msgpack only works with standard typization")
+    {
+        float_json j = 1000.0;
+        CHECK(float_json::from_cbor(float_json::to_cbor(j)) == j);
+        CHECK(float_json::from_msgpack(float_json::to_msgpack(j)) == j);
+        CHECK(float_json::from_ubjson(float_json::to_ubjson(j)) == j);
+
+        float_json j2 = {1000.0, 2000.0, 3000.0};
+        CHECK(float_json::from_ubjson(float_json::to_ubjson(j2, true, true)) == j2);
+    }
+
+    SECTION("issue #1045 - Using STL algorithms with JSON containers with expected results?")
+    {
+        json diffs = nlohmann::json::array();
+        json m1{{"key1", 42}};
+        json m2{{"key2", 42}};
+        auto p1 = m1.items();
+        auto p2 = m2.items();
+
+        using it_type = decltype(p1.begin());
+
+        std::set_difference(
+            p1.begin(), p1.end(),
+            p2.begin(), p2.end(),
+            std::inserter(diffs, diffs.end()), [&](const it_type & e1, const it_type & e2) -> bool
+        {
+            using comper_pair = std::pair<std::string, decltype(e1.value())>; // Trying to avoid unneeded copy
+            return comper_pair(e1.key(), e1.value()) < comper_pair(e2.key(), e2.value()); // Using pair comper
+        });
+
+        CHECK(diffs.size() == 1); // Note the change here, was 2
+    }
+
+#ifdef JSON_HAS_CPP_17
+    SECTION("issue #1292 - Serializing std::variant causes stack overflow")
+    {
+        static_assert(
+            !std::is_constructible<json, std::variant<int, float>>::value, "");
+    }
+#endif
+
+    SECTION("issue #1299 - compile error in from_json converting to container "
+            "with std::pair")
+    {
+        json j =
+        {
+            {"1", {{"a", "testa_1"}, {"b", "testb_1"}}},
+            {"2", {{"a", "testa_2"}, {"b", "testb_2"}}},
+            {"3", {{"a", "testa_3"}, {"b", "testb_3"}}},
+        };
+
+        std::map<std::string, Data> expected
+        {
+            {"1", {"testa_1", "testb_1"}},
+            {"2", {"testa_2", "testb_2"}},
+            {"3", {"testa_3", "testb_3"}},
+        };
+        const auto data = j.get<decltype(expected)>();
+        CHECK(expected == data);
+    }
+
+    SECTION("issue #1445 - buffer overflow in dumping invalid utf-8 strings")
+    {
+        SECTION("a bunch of -1, ensure_ascii=true")
+        {
+            const auto length = 300;
+
+            json dump_test;
+            dump_test["1"] = std::string(length, -1);
+
+            std::string expected = "{\"1\":\"";
+            for (int i = 0; i < length; ++i)
+            {
+                expected += "\\ufffd";
+            }
+            expected += "\"}";
+
+            auto s = dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);
+            CHECK(s == expected);
+        }
+        SECTION("a bunch of -2, ensure_ascii=false")
+        {
+            const auto length = 500;
+
+            json dump_test;
+            dump_test["1"] = std::string(length, -2);
+
+            std::string expected = "{\"1\":\"";
+            for (int i = 0; i < length; ++i)
+            {
+                expected += "\xEF\xBF\xBD";
+            }
+            expected += "\"}";
+
+            auto s = dump_test.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace);
+            CHECK(s == expected);
+        }
+        SECTION("test case in issue #1445")
+        {
+            nlohmann::json dump_test;
+            const int data[] =
+            {
+                109,  108,  103,  125,  -122, -53,  115,
+                18,   3,    0,    102,  19,   1,    15,
+                -110, 13,   -3,   -1,   -81,  32,   2,
+                0,    0,    0,    0,    0,    0,    0,
+                8,    0,    0,    0,    0,    0,    0,
+                0,    0,    0,    0,    0,    -80,  2,
+                0,    0,    96,   -118, 46,   -116, 46,
+                109,  -84,  -87,  108,  14,   109,  -24,
+                -83,  13,   -18,  -51,  -83,  -52,  -115,
+                14,   6,    32,   0,    0,    0,    0,
+                0,    0,    0,    0,    0,    0,    0,
+                64,   3,    0,    0,    0,    35,   -74,
+                -73,  55,   57,   -128, 0,    0,    0,
+                0,    0,    0,    0,    0,    0,    0,
+                0,    0,    33,   0,    0,    0,    -96,
+                -54,  -28,  -26
+            };
+            std::string s;
+            for (unsigned i = 0; i < sizeof(data) / sizeof(int); i++)
+            {
+                s += static_cast<char>(data[i]);
+            }
+            dump_test["1"] = s;
+            dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);
+        }
+    }
+
+    SECTION("issue #1447 - Integer Overflow (OSS-Fuzz 12506)")
+    {
+        json j = json::parse("[-9223372036854775808]");
+        CHECK(j.dump() == "[-9223372036854775808]");
+    }
+
+    SECTION("issue #1708 - minimum value of int64_t can be outputted")
+    {
+        constexpr auto smallest = (std::numeric_limits<int64_t>::min)();
+        json j = smallest;
+        CHECK(j.dump() == std::to_string(smallest));
+    }
+
+    SECTION("issue #1727 - Contains with non-const lvalue json_pointer picks the wrong overload")
+    {
+        json j = {{"root", {{"settings", {{"logging", true}}}}}};
+
+        auto jptr1 = "/root/settings/logging"_json_pointer;
+        auto jptr2 = json::json_pointer{"/root/settings/logging"};
+
+        CHECK(j.contains(jptr1));
+        CHECK(j.contains(jptr2));
+    }
+
+    SECTION("issue #1647 - compile error when deserializing enum if both non-default from_json and non-member operator== exists for other type")
+    {
+        {
+            json j;
+            NonDefaultFromJsonStruct x(j);
+            NonDefaultFromJsonStruct y;
+            CHECK(x == y);
+        }
+
+        auto val = nlohmann::json("one").get<for_1647>();
+        CHECK(val == for_1647::one);
+        json j = val;
+    }
+
+    SECTION("issue #1715 - json::from_cbor does not respect allow_exceptions = false when input is string literal")
+    {
+        SECTION("string literal")
+        {
+            json cbor = json::from_cbor("B", true, false);
+            CHECK(cbor.is_discarded());
+        }
+
+        SECTION("string array")
+        {
+            const char input[] = { 'B', 0x00 };
+            json cbor = json::from_cbor(input, true, false);
+            CHECK(cbor.is_discarded());
+        }
+
+        SECTION("std::string")
+        {
+            json cbor = json::from_cbor(std::string("B"), true, false);
+            CHECK(cbor.is_discarded());
+        }
+    }
+
+    SECTION("issue #1805 - A pair<T1, T2> is json constructible only if T1 and T2 are json constructible")
+    {
+        static_assert(!std::is_constructible<json, std::pair<std::string, NotSerializableData>>::value, "");
+        static_assert(!std::is_constructible<json, std::pair<NotSerializableData, std::string>>::value, "");
+        static_assert(std::is_constructible<json, std::pair<int, std::string>>::value, "");
+    }
+    SECTION("issue #1825 - A tuple<Args..> is json constructible only if all T in Args are json constructible")
+    {
+        static_assert(!std::is_constructible<json, std::tuple<std::string, NotSerializableData>>::value, "");
+        static_assert(!std::is_constructible<json, std::tuple<NotSerializableData, std::string>>::value, "");
+        static_assert(std::is_constructible<json, std::tuple<int, std::string>>::value, "");
+    }
+
+    SECTION("issue #1983 - JSON patch diff for op=add formation is not as per standard (RFC 6902)")
+    {
+        const auto source = R"({ "foo": [ "1", "2" ] })"_json;
+        const auto target = R"({"foo": [ "1", "2", "3" ]})"_json;
+        const auto result = json::diff(source, target);
+        CHECK(result.dump() == R"([{"op":"add","path":"/foo/-","value":"3"}])");
+    }
+
+    SECTION("issue #2067 - cannot serialize binary data to text JSON")
+    {
+        const unsigned char data[] = {0x81, 0xA4, 0x64, 0x61, 0x74, 0x61, 0xC4, 0x0F, 0x33, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x31, 0x30, 0x37, 0x30, 0x35, 0x30, 0x31, 0x30};
+        json j = json::from_msgpack(data, sizeof(data) / sizeof(data[0]));
+        CHECK_NOTHROW(
+            j.dump(4,                              // Indent
+                   ' ',                            // Indent char
+                   false,                          // Ensure ascii
+                   json::error_handler_t::strict  // Error
+                  )
+        );
+    }
+
+    SECTION("PR #2181 - regression bug with lvalue")
+    {
+        // see https://github.com/nlohmann/json/pull/2181#issuecomment-653326060
+        json j{{"x", "test"}};
+        std::string defval = "default value";
+        auto val = j.value("x", defval);
+        auto val2 = j.value("y", defval);
+    }
+
+    SECTION("issue #2293 - eof doesnt cause parsing to stop")
+    {
+        std::vector<uint8_t> data =
+        {
+            0x7B, 0x6F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x20, 0x4F, 0x42
+        };
+        json result = json::from_cbor(data, true, false);
+        CHECK(result.is_discarded());
+    }
+
+    SECTION("issue #2315 - json.update and vector<pair>does not work with ordered_json")
+    {
+        nlohmann::ordered_json jsonAnimals = {{"animal", "dog"}};
+        nlohmann::ordered_json jsonCat = {{"animal", "cat"}};
+        jsonAnimals.update(jsonCat);
+        CHECK(jsonAnimals["animal"] == "cat");
+
+        auto jsonAnimals_parsed = nlohmann::ordered_json::parse(jsonAnimals.dump());
+        CHECK(jsonAnimals == jsonAnimals_parsed);
+
+        std::vector<std::pair<std::string, int64_t>> intData = {std::make_pair("aaaa", 11),
+                                                                std::make_pair("bbb", 222)
+                                                               };
+        nlohmann::ordered_json jsonObj;
+        for (const auto& data : intData)
+        {
+            jsonObj[data.first] = data.second;
+        }
+        CHECK(jsonObj["aaaa"] == 11);
+        CHECK(jsonObj["bbb"] == 222);
+    }
+
+    SECTION("issue #2330 - ignore_comment=true fails on multiple consecutive lines starting with comments")
+    {
+        std::string ss = "//\n//\n{\n}\n";
+        json j = json::parse(ss, nullptr, true, true);
+        CHECK(j.dump() == "{}");
+    }
+}

test/src/unit-serialization.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit-testsuites.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -1235,7 +1235,7 @@ TEST_CASE("nst's JSONTestSuite (2)")
                 json _;
                 CHECK_THROWS_AS(_ = json::parse(f), json::parse_error&);
                 std::ifstream f2(filename);
-                CHECK(not json::accept(f2));
+                CHECK(!json::accept(f2));
             }
         }
 
@@ -1250,7 +1250,7 @@ TEST_CASE("nst's JSONTestSuite (2)")
             {
                 CAPTURE(filename)
                 std::ifstream f(filename);
-                CHECK(not json::accept(f));
+                CHECK(!json::accept(f));
             }
         }
 
@@ -1352,7 +1352,7 @@ TEST_CASE("nst's JSONTestSuite (2)")
                 json _;
                 CHECK_THROWS_AS(_ = json::parse(f), json::exception&); // could be parse_error or out_of_range
                 std::ifstream f2(filename);
-                CHECK(not json::accept(f2));
+                CHECK(!json::accept(f2));
             }
         }
     }

test/src/unit-to_chars.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -359,9 +359,9 @@ TEST_CASE("formatting")
     {
         auto check_float = [](float number, const std::string & expected)
         {
-            char buf[33];
-            char* end = nlohmann::detail::to_chars(buf, buf + 32, number);
-            std::string actual(buf, end);
+            std::array<char, 33> buf{};
+            char* end = nlohmann::detail::to_chars(buf.data(), buf.data() + 32, number);
+            std::string actual(buf.data(), end);
 
             CHECK(actual == expected);
         };
@@ -419,9 +419,9 @@ TEST_CASE("formatting")
     {
         auto check_double = [](double number, const std::string & expected)
         {
-            char buf[33];
-            char* end = nlohmann::detail::to_chars(buf, buf + 32, number);
-            std::string actual(buf, end);
+            std::array<char, 33> buf{};
+            char* end = nlohmann::detail::to_chars(buf.data(), buf.data() + 32, number);
+            std::string actual(buf.data(), end);
 
             CHECK(actual == expected);
         };

test/src/unit-ubjson.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -32,9 +32,11 @@ SOFTWARE.
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
+#include <iostream>
 #include <fstream>
 #include <set>
 #include <test_data.hpp>
+#include "test_utils.hpp"
 
 namespace
 {
@@ -767,6 +769,65 @@ TEST_CASE("UBJSON")
                     CHECK(json::from_ubjson(result, true, false) == j);
                 }
             }
+
+            SECTION("high-precision number")
+            {
+                SECTION("unsigned integer number")
+                {
+                    std::vector<uint8_t> vec = {'H', 'i', 0x14, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
+                    const auto j = json::from_ubjson(vec);
+                    CHECK(j.is_number_unsigned());
+                    CHECK(j.dump() == "12345678901234567890");
+                }
+
+                SECTION("signed integer number")
+                {
+                    std::vector<uint8_t> vec = {'H', 'i', 0x13, '-', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8'};
+                    const auto j = json::from_ubjson(vec);
+                    CHECK(j.is_number_integer());
+                    CHECK(j.dump() == "-123456789012345678");
+                }
+
+                SECTION("floating-point number")
+                {
+                    std::vector<uint8_t> vec = {'H', 'i', 0x16, '3', '.', '1', '4', '1', '5', '9',  '2', '6', '5', '3', '5', '8', '9',  '7', '9', '3', '2', '3', '8', '4',  '6'};
+                    const auto j = json::from_ubjson(vec);
+                    CHECK(j.is_number_float());
+                    CHECK(j.dump() == "3.141592653589793");
+                }
+
+                SECTION("errors")
+                {
+                    // error while parsing length
+                    std::vector<uint8_t> vec0 = {'H', 'i'};
+                    CHECK(json::from_ubjson(vec0, true, false).is_discarded());
+                    // error while parsing string
+                    std::vector<uint8_t> vec1 = {'H', 'i', '1'};
+                    CHECK(json::from_ubjson(vec1, true, false).is_discarded());
+
+                    std::vector<uint8_t> vec2 = {'H', 'i', 2, '1', 'A', '3'};
+                    CHECK_THROWS_WITH_AS(json::from_ubjson(vec2), "[json.exception.parse_error.115] parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A", json::parse_error);
+                    std::vector<uint8_t> vec3 = {'H', 'i', 2, '1', '.'};
+                    CHECK_THROWS_WITH_AS(json::from_ubjson(vec3), "[json.exception.parse_error.115] parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1.", json::parse_error);
+                    std::vector<uint8_t> vec4 = {'H', 2, '1', '0'};
+                    CHECK_THROWS_WITH_AS(json::from_ubjson(vec4), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON size: expected length type specification (U, i, I, l, L) after '#'; last byte: 0x02", json::parse_error);
+                }
+
+                SECTION("serialization")
+                {
+                    // number that does not fit int64
+                    json j = 11111111111111111111ULL;
+                    CHECK(j.is_number_unsigned());
+
+                    // number will be serialized to high-precision number
+                    const auto vec = json::to_ubjson(j);
+                    std::vector<uint8_t> expected = {'H', 'i', 0x14, '1',  '1',  '1',  '1',  '1', '1',  '1',  '1',  '1',  '1', '1',  '1',  '1',  '1',  '1', '1',  '1',  '1',  '1',  '1'};
+                    CHECK(vec == expected);
+
+                    // roundtrip
+                    CHECK(json::from_ubjson(vec) == j);
+                }
+            }
         }
 
         SECTION("string")
@@ -1539,15 +1600,6 @@ TEST_CASE("UBJSON")
             }
         }
 
-        SECTION("number out of range")
-        {
-            // larger than max int64
-            json j = 9223372036854775808llu;
-            json _;
-            CHECK_THROWS_AS(_ = json::to_ubjson(j), json::out_of_range&);
-            CHECK_THROWS_WITH(_ = json::to_ubjson(j), "[json.exception.out_of_range.407] integer number 9223372036854775808 cannot be represented by UBJSON as it does not fit int64");
-        }
-
         SECTION("excessive size")
         {
             SECTION("array")
@@ -1586,42 +1638,42 @@ TEST_CASE("UBJSON")
         {
             std::vector<uint8_t> v = {'[', 'T', 'F', ']'};
             SaxCountdown scp(0);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
         }
 
         SECTION("start_object()")
         {
             std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'};
             SaxCountdown scp(0);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
         }
 
         SECTION("key() in object")
         {
             std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'};
             SaxCountdown scp(1);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
         }
 
         SECTION("start_array(len)")
         {
             std::vector<uint8_t> v = {'[', '#', 'i', '2', 'T', 'F'};
             SaxCountdown scp(0);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
         }
 
         SECTION("start_object(len)")
         {
             std::vector<uint8_t> v = {'{', '#', 'i', '1', 3, 'f', 'o', 'o', 'F'};
             SaxCountdown scp(0);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
         }
 
         SECTION("key() in object with length")
         {
             std::vector<uint8_t> v = {'{', 'i', 3, 'f', 'o', 'o', 'F', '}'};
             SaxCountdown scp(1);
-            CHECK(not json::sax_parse(v, &scp, json::input_format_t::ubjson));
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::ubjson));
         }
     }
 
@@ -2363,13 +2415,13 @@ TEST_CASE("Universal Binary JSON Specification Examples 1")
     }
 }
 
-#if not defined(JSON_NOEXCEPTION)
+#if !defined(JSON_NOEXCEPTION)
 TEST_CASE("all UBJSON first bytes")
 {
     // these bytes will fail immediately with exception parse_error.112
     std::set<uint8_t> supported =
     {
-        'T', 'F', 'Z', 'U', 'i', 'I', 'l', 'L', 'd', 'D', 'C', 'S', '[', '{', 'N'
+        'T', 'F', 'Z', 'U', 'i', 'I', 'l', 'L', 'd', 'D', 'C', 'S', '[', '{', 'N', 'H'
     };
 
     for (auto i = 0; i < 256; ++i)
@@ -2457,11 +2509,8 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
                 std::ifstream f_json(filename);
                 json j1 = json::parse(f_json);
 
-                // parse MessagePack file
-                std::ifstream f_ubjson(filename + ".ubjson", std::ios::binary);
-                std::vector<uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_ubjson)),
-                    std::istreambuf_iterator<char>());
+                // parse UBJSON file
+                auto packed = utils::read_binary_file(filename + ".ubjson");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_ubjson(packed));
 
@@ -2475,7 +2524,7 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
                 std::ifstream f_json(filename);
                 json j1 = json::parse(f_json);
 
-                // parse MessagePack file
+                // parse UBJSON file
                 std::ifstream f_ubjson(filename + ".ubjson", std::ios::binary);
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_ubjson(f_ubjson));
@@ -2490,11 +2539,8 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
                 std::ifstream f_json(filename);
                 json j1 = json::parse(f_json);
 
-                // parse MessagePack file
-                std::ifstream f_ubjson(filename + ".ubjson", std::ios::binary);
-                std::vector<uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_ubjson)),
-                    std::istreambuf_iterator<char>());
+                // parse UBJSON file
+                auto packed = utils::read_binary_file(filename + ".ubjson");
                 json j2;
                 CHECK_NOTHROW(j2 = json::from_ubjson({packed.data(), packed.size()}));
 
@@ -2508,11 +2554,8 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
                 std::ifstream f_json(filename);
                 json j1 = json::parse(f_json);
 
-                // parse MessagePack file
-                std::ifstream f_ubjson(filename + ".ubjson", std::ios::binary);
-                std::vector<uint8_t> packed(
-                    (std::istreambuf_iterator<char>(f_ubjson)),
-                    std::istreambuf_iterator<char>());
+                // parse UBJSON file
+                auto packed = utils::read_binary_file(filename + ".ubjson");
 
                 {
                     INFO_WITH_TEMP(filename + ": output adapters: std::vector<uint8_t>");

test/src/unit-udt.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -312,6 +312,7 @@ TEST_CASE("basic usage" * doctest::test_suite("udt"))
             CHECK(name.m_val == "new name");
         }
 
+#if JSON_USE_IMPLICIT_CONVERSIONS
         SECTION("implicit conversions")
         {
             const udt::contact_book parsed_book = big_json;
@@ -335,6 +336,7 @@ TEST_CASE("basic usage" * doctest::test_suite("udt"))
             CHECK(book_name == udt::name{"C++"});
             CHECK(book == parsed_book);
         }
+#endif
     }
 }
 
@@ -551,7 +553,7 @@ struct pod_serializer
     template <
         typename BasicJsonType, typename U = T,
         typename std::enable_if <
-            not(std::is_pod<U>::value and std::is_class<U>::value), int >::type = 0 >
+            !(std::is_pod<U>::value && std::is_class<U>::value), int >::type = 0 >
     static void from_json(const BasicJsonType& j, U& t)
     {
         using nlohmann::from_json;
@@ -559,9 +561,9 @@ struct pod_serializer
     }
 
     // special behaviour for pods
-    template <typename BasicJsonType, typename U = T,
-              typename std::enable_if<
-                  std::is_pod<U>::value and std::is_class<U>::value, int>::type = 0>
+    template < typename BasicJsonType, typename U = T,
+               typename std::enable_if <
+                   std::is_pod<U>::value && std::is_class<U>::value, int >::type = 0 >
     static void from_json(const  BasicJsonType& j, U& t)
     {
         std::uint64_t value;
@@ -587,16 +589,16 @@ struct pod_serializer
     template <
         typename BasicJsonType, typename U = T,
         typename std::enable_if <
-            not(std::is_pod<U>::value and std::is_class<U>::value), int >::type = 0 >
+            !(std::is_pod<U>::value && std::is_class<U>::value), int >::type = 0 >
     static void to_json(BasicJsonType& j, const  T& t)
     {
         using nlohmann::to_json;
         to_json(j, t);
     }
 
-    template <typename BasicJsonType, typename U = T,
-              typename std::enable_if<
-                  std::is_pod<U>::value and std::is_class<U>::value, int>::type = 0>
+    template < typename BasicJsonType, typename U = T,
+               typename std::enable_if <
+                   std::is_pod<U>::value && std::is_class<U>::value, int >::type = 0 >
     static void to_json(BasicJsonType& j, const  T& t) noexcept
     {
         auto bytes = static_cast< const unsigned char*>(static_cast<const void*>(&t));
@@ -805,7 +807,7 @@ struct is_constructible_patched<T, decltype(void(json(std::declval<T>())))> : st
 
 TEST_CASE("an incomplete type does not trigger a compiler error in non-evaluated context" * doctest::test_suite("udt"))
 {
-    static_assert(not is_constructible_patched<json, incomplete>::value, "");
+    static_assert(!is_constructible_patched<json, incomplete>::value, "");
 }
 
 namespace
@@ -839,5 +841,5 @@ TEST_CASE("Issue #924")
 TEST_CASE("Issue #1237")
 {
     struct non_convertible_type {};
-    static_assert(not std::is_convertible<json, non_convertible_type>::value, "");
+    static_assert(!std::is_convertible<json, non_convertible_type>::value, "");
 }

test/src/unit-udt_macro.cpp

@@ -0,0 +1,330 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++ (test suite)
+|  |  |__   |  |  | | | |  version 3.9.1
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <string>
+#include <vector>
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+
+namespace persons
+{
+class person_with_private_data
+{
+  private:
+    std::string name = "";
+    int age = 0;
+    json metadata = nullptr;
+
+  public:
+    bool operator==(const person_with_private_data& rhs) const
+    {
+        return name == rhs.name && age == rhs.age && metadata == rhs.metadata;
+    }
+
+    person_with_private_data() = default;
+    person_with_private_data(std::string name_, int age_, json metadata_)
+        : name(std::move(name_))
+        , age(age_)
+        , metadata(std::move(metadata_))
+    {}
+
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE(person_with_private_data, age, name, metadata)
+};
+
+class person_without_private_data_1
+{
+  public:
+    std::string name = "";
+    int age = 0;
+    json metadata = nullptr;
+
+    bool operator==(const person_without_private_data_1& rhs) const
+    {
+        return name == rhs.name && age == rhs.age && metadata == rhs.metadata;
+    }
+
+    person_without_private_data_1() = default;
+    person_without_private_data_1(std::string name_, int age_, json metadata_)
+        : name(std::move(name_))
+        , age(age_)
+        , metadata(std::move(metadata_))
+    {}
+
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE(person_without_private_data_1, age, name, metadata)
+};
+
+class person_without_private_data_2
+{
+  public:
+    std::string name = "";
+    int age = 0;
+    json metadata = nullptr;
+
+    bool operator==(const person_without_private_data_2& rhs) const
+    {
+        return name == rhs.name && age == rhs.age && metadata == rhs.metadata;
+    }
+
+    person_without_private_data_2() = default;
+    person_without_private_data_2(std::string name_, int age_, json metadata_)
+        : name(std::move(name_))
+        , age(age_)
+        , metadata(std::move(metadata_))
+    {}
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person_without_private_data_2, age, name, metadata)
+
+class person_with_private_alphabet
+{
+  public:
+    bool operator==(const person_with_private_alphabet& other)
+    {
+        return  a == other.a &&
+                b == other.b &&
+                c == other.c &&
+                d == other.d &&
+                e == other.e &&
+                f == other.f &&
+                g == other.g &&
+                h == other.h &&
+                i == other.i &&
+                j == other.j &&
+                k == other.k &&
+                l == other.l &&
+                m == other.m &&
+                n == other.n &&
+                o == other.o &&
+                p == other.p &&
+                q == other.q &&
+                r == other.r &&
+                s == other.s &&
+                t == other.t &&
+                u == other.u &&
+                v == other.v &&
+                w == other.w &&
+                x == other.x &&
+                y == other.y &&
+                z == other.z;
+    }
+
+  private:
+    int a = 0;
+    int b = 0;
+    int c = 0;
+    int d = 0;
+    int e = 0;
+    int f = 0;
+    int g = 0;
+    int h = 0;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    int l = 0;
+    int m = 0;
+    int n = 0;
+    int o = 0;
+    int p = 0;
+    int q = 0;
+    int r = 0;
+    int s = 0;
+    int t = 0;
+    int u = 0;
+    int v = 0;
+    int w = 0;
+    int x = 0;
+    int y = 0;
+    int z = 0;
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE(person_with_private_alphabet, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
+};
+
+class person_with_public_alphabet
+{
+  public:
+    bool operator==(const person_with_public_alphabet& other)
+    {
+        return  a == other.a &&
+                b == other.b &&
+                c == other.c &&
+                d == other.d &&
+                e == other.e &&
+                f == other.f &&
+                g == other.g &&
+                h == other.h &&
+                i == other.i &&
+                j == other.j &&
+                k == other.k &&
+                l == other.l &&
+                m == other.m &&
+                n == other.n &&
+                o == other.o &&
+                p == other.p &&
+                q == other.q &&
+                r == other.r &&
+                s == other.s &&
+                t == other.t &&
+                u == other.u &&
+                v == other.v &&
+                w == other.w &&
+                x == other.x &&
+                y == other.y &&
+                z == other.z;
+    }
+
+    int a = 0;
+    int b = 0;
+    int c = 0;
+    int d = 0;
+    int e = 0;
+    int f = 0;
+    int g = 0;
+    int h = 0;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    int l = 0;
+    int m = 0;
+    int n = 0;
+    int o = 0;
+    int p = 0;
+    int q = 0;
+    int r = 0;
+    int s = 0;
+    int t = 0;
+    int u = 0;
+    int v = 0;
+    int w = 0;
+    int x = 0;
+    int y = 0;
+    int z = 0;
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person_with_public_alphabet, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
+
+} // namespace persons
+
+TEST_CASE_TEMPLATE("Serialization/deserialization via NLOHMANN_DEFINE_TYPE_INTRUSIVE", T,
+                   persons::person_with_private_data,
+                   persons::person_without_private_data_1,
+                   persons::person_without_private_data_2)
+{
+    SECTION("person")
+    {
+        // serialization
+        T p1("Erik", 1, {{"haircuts", 2}});
+        CHECK(json(p1).dump() == "{\"age\":1,\"metadata\":{\"haircuts\":2},\"name\":\"Erik\"}");
+
+        // deserialization
+        auto p2 = json(p1).get<T>();
+        CHECK(p2 == p1);
+
+        // roundtrip
+        CHECK(T(json(p1)) == p1);
+        CHECK(json(T(json(p1))) == json(p1));
+
+        // check exception in case of missing field
+        json j = json(p1);
+        j.erase("age");
+        CHECK_THROWS_WITH_AS(j.get<T>(), "[json.exception.out_of_range.403] key 'age' not found", json::out_of_range);
+    }
+}
+
+TEST_CASE_TEMPLATE("Serialization/deserialization of classes with 26 public/private member variables via NLOHMANN_DEFINE_TYPE_INTRUSIVE and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE", T,
+                   persons::person_with_private_alphabet,
+                   persons::person_with_public_alphabet)
+{
+    SECTION("alphabet")
+    {
+        {
+            T obj1;
+            nlohmann::json j = obj1; //via json object
+            T obj2;
+            j.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json j1 = obj1; //via json string
+            std::string s = j1.dump();
+            nlohmann::json j2 = nlohmann::json::parse(s);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json j1 = obj1; //via msgpack
+            std::vector<uint8_t> buf = nlohmann::json::to_msgpack(j1);
+            nlohmann::json j2 = nlohmann::json::from_msgpack(buf);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json j1 = obj1; //via bson
+            std::vector<uint8_t> buf = nlohmann::json::to_bson(j1);
+            nlohmann::json j2 = nlohmann::json::from_bson(buf);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json j1 = obj1; //via cbor
+            std::vector<uint8_t> buf = nlohmann::json::to_cbor(j1);
+            nlohmann::json j2 = nlohmann::json::from_cbor(buf);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+
+        {
+            T obj1;
+            nlohmann::json j1 = obj1; //via ubjson
+            std::vector<uint8_t> buf = nlohmann::json::to_ubjson(j1);
+            nlohmann::json j2 = nlohmann::json::from_ubjson(buf);
+            T obj2;
+            j2.get_to(obj2);
+            bool ok = (obj1 == obj2);
+            CHECK(ok);
+        }
+    }
+}

test/src/unit-unicode.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -217,7 +217,7 @@ TEST_CASE("Unicode" * doctest::skip())
                 for (int byte1 = 0x00; byte1 <= 0x7F; ++byte1)
                 {
                     // unescaped control characters are parse errors in JSON
-                    if (0x00 <= byte1 and byte1 <= 0x1F)
+                    if (0x00 <= byte1 && byte1 <= 0x1F)
                     {
                         check_utf8string(false, byte1);
                         continue;
@@ -274,7 +274,7 @@ TEST_CASE("Unicode" * doctest::skip())
                     for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
                     {
                         // skip correct second byte
-                        if (0x80 <= byte2 and byte2 <= 0xBF)
+                        if (0x80 <= byte2 && byte2 <= 0xBF)
                         {
                             continue;
                         }
@@ -331,7 +331,7 @@ TEST_CASE("Unicode" * doctest::skip())
                     for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
                     {
                         // skip correct second byte
-                        if (0xA0 <= byte2 and byte2 <= 0xBF)
+                        if (0xA0 <= byte2 && byte2 <= 0xBF)
                         {
                             continue;
                         }
@@ -354,7 +354,7 @@ TEST_CASE("Unicode" * doctest::skip())
                         for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
                         {
                             // skip correct third byte
-                            if (0x80 <= byte3 and byte3 <= 0xBF)
+                            if (0x80 <= byte3 && byte3 <= 0xBF)
                             {
                                 continue;
                             }
@@ -412,7 +412,7 @@ TEST_CASE("Unicode" * doctest::skip())
                     for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
                     {
                         // skip correct second byte
-                        if (0x80 <= byte2 and byte2 <= 0xBF)
+                        if (0x80 <= byte2 && byte2 <= 0xBF)
                         {
                             continue;
                         }
@@ -435,7 +435,7 @@ TEST_CASE("Unicode" * doctest::skip())
                         for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
                         {
                             // skip correct third byte
-                            if (0x80 <= byte3 and byte3 <= 0xBF)
+                            if (0x80 <= byte3 && byte3 <= 0xBF)
                             {
                                 continue;
                             }
@@ -493,7 +493,7 @@ TEST_CASE("Unicode" * doctest::skip())
                     for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
                     {
                         // skip correct second byte
-                        if (0x80 <= byte2 and byte2 <= 0x9F)
+                        if (0x80 <= byte2 && byte2 <= 0x9F)
                         {
                             continue;
                         }
@@ -516,7 +516,7 @@ TEST_CASE("Unicode" * doctest::skip())
                         for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
                         {
                             // skip correct third byte
-                            if (0x80 <= byte3 and byte3 <= 0xBF)
+                            if (0x80 <= byte3 && byte3 <= 0xBF)
                             {
                                 continue;
                             }
@@ -574,7 +574,7 @@ TEST_CASE("Unicode" * doctest::skip())
                     for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
                     {
                         // skip correct second byte
-                        if (0x80 <= byte2 and byte2 <= 0xBF)
+                        if (0x80 <= byte2 && byte2 <= 0xBF)
                         {
                             continue;
                         }
@@ -597,7 +597,7 @@ TEST_CASE("Unicode" * doctest::skip())
                         for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
                         {
                             // skip correct third byte
-                            if (0x80 <= byte3 and byte3 <= 0xBF)
+                            if (0x80 <= byte3 && byte3 <= 0xBF)
                             {
                                 continue;
                             }
@@ -673,7 +673,7 @@ TEST_CASE("Unicode" * doctest::skip())
                     for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
                     {
                         // skip correct second byte
-                        if (0x90 <= byte2 and byte2 <= 0xBF)
+                        if (0x90 <= byte2 && byte2 <= 0xBF)
                         {
                             continue;
                         }
@@ -699,7 +699,7 @@ TEST_CASE("Unicode" * doctest::skip())
                         for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
                         {
                             // skip correct third byte
-                            if (0x80 <= byte3 and byte3 <= 0xBF)
+                            if (0x80 <= byte3 && byte3 <= 0xBF)
                             {
                                 continue;
                             }
@@ -725,7 +725,7 @@ TEST_CASE("Unicode" * doctest::skip())
                             for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
                             {
                                 // skip fourth second byte
-                                if (0x80 <= byte3 and byte3 <= 0xBF)
+                                if (0x80 <= byte3 && byte3 <= 0xBF)
                                 {
                                     continue;
                                 }
@@ -802,7 +802,7 @@ TEST_CASE("Unicode" * doctest::skip())
                     for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
                     {
                         // skip correct second byte
-                        if (0x80 <= byte2 and byte2 <= 0xBF)
+                        if (0x80 <= byte2 && byte2 <= 0xBF)
                         {
                             continue;
                         }
@@ -828,7 +828,7 @@ TEST_CASE("Unicode" * doctest::skip())
                         for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
                         {
                             // skip correct third byte
-                            if (0x80 <= byte3 and byte3 <= 0xBF)
+                            if (0x80 <= byte3 && byte3 <= 0xBF)
                             {
                                 continue;
                             }
@@ -854,7 +854,7 @@ TEST_CASE("Unicode" * doctest::skip())
                             for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
                             {
                                 // skip correct fourth byte
-                                if (0x80 <= byte3 and byte3 <= 0xBF)
+                                if (0x80 <= byte3 && byte3 <= 0xBF)
                                 {
                                     continue;
                                 }
@@ -931,7 +931,7 @@ TEST_CASE("Unicode" * doctest::skip())
                     for (int byte2 = 0x00; byte2 <= 0xFF; ++byte2)
                     {
                         // skip correct second byte
-                        if (0x80 <= byte2 and byte2 <= 0x8F)
+                        if (0x80 <= byte2 && byte2 <= 0x8F)
                         {
                             continue;
                         }
@@ -957,7 +957,7 @@ TEST_CASE("Unicode" * doctest::skip())
                         for (int byte3 = 0x00; byte3 <= 0xFF; ++byte3)
                         {
                             // skip correct third byte
-                            if (0x80 <= byte3 and byte3 <= 0xBF)
+                            if (0x80 <= byte3 && byte3 <= 0xBF)
                             {
                                 continue;
                             }
@@ -983,7 +983,7 @@ TEST_CASE("Unicode" * doctest::skip())
                             for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
                             {
                                 // skip correct fourth byte
-                                if (0x80 <= byte3 and byte3 <= 0xBF)
+                                if (0x80 <= byte3 && byte3 <= 0xBF)
                                 {
                                     continue;
                                 }
@@ -1030,7 +1030,7 @@ TEST_CASE("Unicode" * doctest::skip())
                     // they will never be assigned a character, so there should be no
                     // reason to encode them. The official Unicode standard says that
                     // no UTF forms, including UTF-16, can encode these code points.
-                    if (cp >= 0xD800u and cp <= 0xDFFFu)
+                    if (cp >= 0xD800u && cp <= 0xDFFFu)
                     {
                         // if we would not skip these code points, we would get a
                         // "missing low surrogate" exception
@@ -1117,7 +1117,7 @@ TEST_CASE("Unicode" * doctest::skip())
                 {
                     for (std::size_t cp2 = 0x0000u; cp2 <= 0xFFFFu; ++cp2)
                     {
-                        if (0xDC00u <= cp2 and cp2 <= 0xDFFFu)
+                        if (0xDC00u <= cp2 && cp2 <= 0xDFFFu)
                         {
                             continue;
                         }
@@ -1163,12 +1163,12 @@ TEST_CASE("Unicode" * doctest::skip())
             for (auto s : j)
             {
                 // skip non-string JSON values
-                if (not s.is_string())
+                if (!s.is_string())
                 {
                     continue;
                 }
 
-                std::string ptr = s;
+                auto ptr = s.get<std::string>();
 
                 // tilde must be followed by 0 or 1
                 if (ptr == "~")

test/src/unit-user_defined_input.cpp

@@ -0,0 +1,119 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++ (test suite)
+|  |  |__   |  |  | | | |  version 3.9.1
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+
+#include <list>
+
+namespace
+{
+TEST_CASE("Use arbitrary stdlib container")
+{
+    std::string raw_data = "[1,2,3,4]";
+    std::list<char> data(raw_data.begin(), raw_data.end());
+
+    json as_json = json::parse(data.begin(), data.end());
+    CHECK(as_json.at(0) == 1);
+    CHECK(as_json.at(1) == 2);
+    CHECK(as_json.at(2) == 3);
+    CHECK(as_json.at(3) == 4);
+}
+
+struct MyContainer
+{
+    const char* data;
+};
+
+const char* begin(const MyContainer& c)
+{
+    return c.data;
+}
+
+const char* end(const MyContainer& c)
+{
+    return c.data + strlen(c.data);
+}
+
+TEST_CASE("Custom container")
+{
+
+    MyContainer data{"[1,2,3,4]"};
+    json as_json = json::parse(data);
+    CHECK(as_json.at(0) == 1);
+    CHECK(as_json.at(1) == 2);
+    CHECK(as_json.at(2) == 3);
+    CHECK(as_json.at(3) == 4);
+
+}
+
+TEST_CASE("Custom iterator")
+{
+    const char* raw_data = "[1,2,3,4]";
+
+    struct MyIterator
+    {
+        using difference_type = std::size_t;
+        using value_type = char;
+        using pointer = const char*;
+        using reference = const char&;
+        using iterator_category = std::input_iterator_tag;
+
+        MyIterator& operator++()
+        {
+            ++ptr;
+            return *this;
+        }
+
+        reference operator*() const
+        {
+            return *ptr;
+        }
+
+        bool operator!=(const MyIterator& rhs) const
+        {
+            return ptr != rhs.ptr;
+        }
+
+        const char* ptr;
+    };
+
+    MyIterator begin{raw_data};
+    MyIterator end{raw_data + strlen(raw_data)};
+
+    json as_json = json::parse(begin, end);
+    CHECK(as_json.at(0) == 1);
+    CHECK(as_json.at(1) == 2);
+    CHECK(as_json.at(2) == 3);
+    CHECK(as_json.at(3) == 4);
+}
+
+} // namespace

test/src/unit-wstring.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.

test/src/unit.cpp

@@ -1,7 +1,7 @@
 /*
     __ _____ _____ _____
  __|  |   __|     |   | |  JSON for Modern C++ (test suite)
-|  |  |__   |  |  | | | |  version 3.7.3
+|  |  |__   |  |  | | | |  version 3.9.1
 |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 
 Licensed under the MIT License <http://opensource.org/licenses/MIT>.