Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

tests/abi/config/default.cpp

@@ -48,6 +48,10 @@ TEST_CASE("default namespace")
         expected += "_sbu8";
 #endif
 
+#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
+        expected += "_ekmo";
+#endif
+
         expected += "_v" STRINGIZE(NLOHMANN_JSON_VERSION_MAJOR);
         expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_MINOR);
         expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_PATCH) "::basic_json";

tests/abi/config/noversion.cpp

@@ -49,6 +49,10 @@ TEST_CASE("default namespace without version component")
         expected += "_sbu8";
 #endif
 
+#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
+        expected += "_ekmo";
+#endif
+
         expected += "::basic_json";
 
         // fallback for Clang

tests/src/unit-binary_formats.cpp

@@ -11,7 +11,12 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
+#include <cmath>
 #include <fstream>
+#include <limits>
+#include <map>
+#include <string>
+#include <vector>
 #include "make_test_data_available.hpp"
 
 TEST_CASE("Binary Formats" * doctest::skip())
@@ -224,3 +229,139 @@ TEST_CASE("Binary Formats" * doctest::skip())
         CHECK((100.0 * double(ubjson_3_size) / double(json_size)) == Approx(89.450));
     }
 }
+
+namespace
+{
+// the binary formats as function pointers for "Binary formats with narrow number types";
+// named functions rather than lambdas, because clang 3.5 cannot convert a lambda
+// to a function pointer in the braced initializer of the format table
+using narrow_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int32_t, std::uint32_t, float>;
+using bytes = std::vector<std::uint8_t>;
+
+bytes encode_cbor(const json& j)
+{
+    return json::to_cbor(j);
+}
+narrow_json decode_cbor(const bytes& v, bool allow_exceptions)
+{
+    return narrow_json::from_cbor(v, true, allow_exceptions);
+}
+
+bytes encode_msgpack(const json& j)
+{
+    return json::to_msgpack(j);
+}
+narrow_json decode_msgpack(const bytes& v, bool allow_exceptions)
+{
+    return narrow_json::from_msgpack(v, true, allow_exceptions);
+}
+
+bytes encode_ubjson(const json& j)
+{
+    return json::to_ubjson(j);
+}
+narrow_json decode_ubjson(const bytes& v, bool allow_exceptions)
+{
+    return narrow_json::from_ubjson(v, true, allow_exceptions);
+}
+
+bytes encode_bjdata(const json& j)
+{
+    return json::to_bjdata(j);
+}
+narrow_json decode_bjdata(const bytes& v, bool allow_exceptions)
+{
+    return narrow_json::from_bjdata(v, true, allow_exceptions);
+}
+
+// BSON can only store numbers as object members
+bytes encode_bson(const json& j)
+{
+    return json::to_bson(json{{"a", j}});
+}
+narrow_json decode_bson(const bytes& v, bool allow_exceptions)
+{
+    const auto result = narrow_json::from_bson(v, true, allow_exceptions);
+    return result.is_discarded() ? result : result.at("a");
+}
+
+bytes encode_bon8(const json& j)
+{
+    return json::to_bon8(j);
+}
+narrow_json decode_bon8(const bytes& v, bool allow_exceptions)
+{
+    return narrow_json::from_bon8(v, true, allow_exceptions);
+}
+
+} // namespace
+
+TEST_CASE("Binary formats with narrow number types")
+{
+    // Numbers that do not fit the number types are handled like the lexer
+    // handles them in JSON text: an integer that fits neither integer type is
+    // stored as a floating-point number, and a finite floating-point number
+    // that overflows number_float_t is rejected with out_of_range.406.
+    struct binary_format
+    {
+        const char* name;
+        bytes (*encode)(const json&);
+        narrow_json (*decode)(const bytes&, bool);
+    };
+
+    const std::vector<binary_format> formats =
+    {
+        {"CBOR", encode_cbor, decode_cbor},
+        {"MessagePack", encode_msgpack, decode_msgpack},
+        {"UBJSON", encode_ubjson, decode_ubjson},
+        {"BJData", encode_bjdata, decode_bjdata},
+        {"BSON", encode_bson, decode_bson},
+        {"BON8", encode_bon8, decode_bon8},
+    };
+
+    for (const auto& format : formats)
+    {
+        const std::string name = format.name;
+        INFO("format := ", name);
+        const auto roundtrip = [&format](const json & j)
+        {
+            return format.decode(format.encode(j), true);
+        };
+
+        // integers that fit keep their type
+        CHECK(roundtrip(json(-5)).is_number_integer());
+        CHECK(roundtrip(json(-5)).get<std::int32_t>() == -5);
+        CHECK(roundtrip(json(3000000000u)).is_number_unsigned());
+        CHECK(roundtrip(json(3000000000u)).get<std::uint32_t>() == 3000000000u);
+
+        // integers that fit neither integer type are stored as float
+        CHECK(roundtrip(json(5000000000u)).is_number_float());
+        CHECK(roundtrip(json(5000000000u)).get<float>() == 5000000000.0f);
+        if (name != "BON8") // BON8 cannot encode integers above INT64_MAX
+        {
+            CHECK(roundtrip(json(10000000000000000000u)).is_number_float());
+            CHECK(roundtrip(json(10000000000000000000u)).get<float>() == 10000000000000000000.0f);
+        }
+        CHECK(roundtrip(json(-3000000000LL)).is_number_float());
+        CHECK(roundtrip(json(-3000000000LL)).get<float>() == -3000000000.0f);
+        CHECK(roundtrip(json(-5000000000LL)).is_number_float());
+        CHECK(roundtrip(json(-5000000000LL)).get<float>() == -5000000000.0f);
+
+        // floating-point numbers that fit
+        CHECK(roundtrip(json(1.5)).get<float>() == 1.5f);
+        const auto just_above_max = std::nextafter(static_cast<double>((std::numeric_limits<float>::max)()),
+                                    std::numeric_limits<double>::infinity());
+        CHECK(roundtrip(json(just_above_max)).get<float>() == (std::numeric_limits<float>::max)());
+
+        // infinity and NaN are passed on
+        CHECK(std::isinf(roundtrip(json(std::numeric_limits<double>::infinity())).get<float>()));
+        CHECK(std::isnan(roundtrip(json(std::numeric_limits<double>::quiet_NaN())).get<float>()));
+
+        // finite floating-point numbers that overflow number_float_t are rejected
+        const std::string message = "[json.exception.out_of_range.406] syntax error while parsing " + name
+                                    + " value: number overflow";
+        CHECK_THROWS_WITH_AS(roundtrip(json(1e300)), message.c_str(), narrow_json::out_of_range&);
+        CHECK_THROWS_WITH_AS(roundtrip(json(-1e300)), message.c_str(), narrow_json::out_of_range&);
+        CHECK(format.decode(format.encode(json(1e300)), false).is_discarded());
+    }
+}

tests/src/unit-cbor.cpp

@@ -3185,7 +3185,8 @@ TEST_CASE("Tagged values")
         // CBOR encodes negative integers as: result = -1 - n
         // For type 0x3B, n is an 8-byte uint64_t. Valid range for n with
         // the default int64_t is [0, INT64_MAX], producing results in [INT64_MIN, -1].
-        // When n > INT64_MAX, the result exceeds int64_t range and is rejected.
+        // When n > INT64_MAX, the result exceeds int64_t range and is stored
+        // as a floating-point number, as the lexer does for JSON text.
 
         SECTION("n = 0 is valid (result = -1)")
         {
@@ -3206,33 +3207,34 @@ TEST_CASE("Tagged values")
             CHECK(result.get<int64_t>() == (std::numeric_limits<int64_t>::min)());
         }
 
-        SECTION("n = INT64_MAX + 1 is rejected (overflow)")
+        SECTION("n = INT64_MAX + 1 is stored as float")
         {
             // n = INT64_MAX + 1 (0x8000000000000000)
-            // result = -1 - n = -9223372036854775809, which exceeds int64_t range
+            // result = -1 - n = -9223372036854775809, which exceeds int64_t range;
+            // the nearest double is -9223372036854775808.0
             const std::vector<uint8_t> input = {0x3B, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-            json _;
-            CHECK_THROWS_WITH_AS(_ = json::from_cbor(input),
-                                 "[json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow",
-                                 json::parse_error);
+            const auto result = json::from_cbor(input);
+            CHECK(result.is_number_float());
+            CHECK(result.get<double>() == -9223372036854775808.0);
+            CHECK(result == json::parse("-9223372036854775809"));
         }
 
-        SECTION("n = UINT64_MAX is rejected (overflow)")
+        SECTION("n = UINT64_MAX is stored as float")
         {
             // n = UINT64_MAX (0xFFFFFFFFFFFFFFFF)
             // result = -1 - n = -18446744073709551616, which exceeds int64_t range
             const std::vector<uint8_t> input = {0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
-            json _;
-            CHECK_THROWS_WITH_AS(_ = json::from_cbor(input),
-                                 "[json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow",
-                                 json::parse_error);
+            const auto result = json::from_cbor(input);
+            CHECK(result.is_number_float());
+            CHECK(result.get<double>() == -18446744073709551616.0);
+            CHECK(result == json::parse("-18446744073709551616"));
         }
 
-        SECTION("overflow with allow_exceptions=false returns discarded")
+        SECTION("overflow with allow_exceptions=false is not an error")
         {
             const std::vector<uint8_t> input = {0x3B, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
             const auto result = json::from_cbor(input, true, false);
-            CHECK(result.is_discarded());
+            CHECK(result.is_number_float());
         }
     }
 

tests/src/unit-enum_keyed_maps.cpp

@@ -0,0 +1,246 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#include "doctest_compatibility.h"
+
+// skip tests if JSON_DisableEnumSerialization=ON (#4384)
+#if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)
+    #define SKIP_TESTS_FOR_ENUM_SERIALIZATION
+#endif
+
+// This file tests the opt-in JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS, so it defines
+// the macro itself rather than relying on a -D flag, and runs in every build.
+// The default behavior is tested in unit-enum_keyed_maps_default.cpp.
+#ifdef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
+    #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
+#endif
+
+#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 1
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+using nlohmann::ordered_json;
+
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#define STRINGIZE_EX(x) #x
+#define STRINGIZE(x) STRINGIZE_EX(x)
+
+// NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
+DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
+
+namespace
+{
+// std::hash is only required for enums since C++14
+struct enum_hash
+{
+    template<typename T>
+    std::size_t operator()(T t) const noexcept
+    {
+        return static_cast<std::size_t>(t);
+    }
+};
+} // namespace
+
+// the example from #4378
+enum TaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
+{
+    TS_STOPPED,
+    TS_RUNNING,
+    TS_COMPLETED,
+    TS_INVALID = -1,
+};
+
+// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM(TaskState,
+{
+    {TS_INVALID, nullptr},
+    {TS_STOPPED, "stopped"},
+    {TS_RUNNING, "running"},
+    {TS_COMPLETED, "completed"},
+})
+
+enum class color {red, green, blue}; // blue is not mapped and falls back to "red"
+
+// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM(color,
+{
+    {color::red, "red"},
+    {color::green, "green"},
+})
+
+enum class strict_color {red, green, blue}; // blue is not mapped
+
+// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_color,
+{
+    {strict_color::red, "red"},
+    {strict_color::green, "green"},
+})
+
+enum class digit {zero, one};
+
+// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM(digit,
+{
+    {digit::zero, 0},
+    {digit::one, 1},
+})
+
+#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
+enum class plain {zero, one}; // serialized as integer
+#endif
+
+TEST_CASE("JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS")
+{
+    SECTION("the macro is part of the ABI tag")
+    {
+        const std::string ns = STRINGIZE(NLOHMANN_JSON_NAMESPACE);
+        CHECK(ns.find("_ekmo") != std::string::npos);
+    }
+
+    SECTION("std::map (#4378)")
+    {
+        using task_map = std::map<TaskState, std::string>;
+        const task_map m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
+        const json j = m;
+        CHECK(j == json::parse(R"({"stopped":"aa","completed":"bb"})"));
+        CHECK(j.get<task_map>() == m);
+
+        json j2;
+        j2["x"] = m;
+        CHECK(j2.dump() == R"({"x":{"completed":"bb","stopped":"aa"}})");
+    }
+
+    SECTION("std::map with custom comparator")
+    {
+        using task_map = std::map<TaskState, int, std::greater<TaskState>>;
+        const task_map m = {{TS_STOPPED, 1}, {TS_RUNNING, 2}};
+        const json j = m;
+        CHECK(j == json::parse(R"({"stopped":1,"running":2})"));
+        CHECK(j.get<task_map>() == m);
+    }
+
+    SECTION("std::unordered_map")
+    {
+        using task_map = std::unordered_map<TaskState, int, enum_hash>;
+        const task_map m = {{TS_STOPPED, 1}, {TS_RUNNING, 2}};
+        const json j = m;
+        CHECK(j == json::parse(R"({"stopped":1,"running":2})"));
+        CHECK(j.get<task_map>() == m);
+    }
+
+    SECTION("nested maps")
+    {
+        using nested_map = std::map<color, std::map<TaskState, int>>;
+        const nested_map m = {{color::green, {{TS_RUNNING, 1}}}, {color::red, {}}};
+        const json j = m;
+        CHECK(j == json::parse(R"({"green":{"running":1},"red":{}})"));
+        CHECK(j.get<nested_map>() == m);
+    }
+
+    SECTION("ordered_json keeps the order of the map")
+    {
+        using task_map = std::map<TaskState, int>;
+        const task_map m = {{TS_STOPPED, 1}, {TS_RUNNING, 2}, {TS_COMPLETED, 3}};
+        const ordered_json j = m;
+        CHECK(j.dump() == R"({"stopped":1,"running":2,"completed":3})");
+        CHECK(j.get<task_map>() == m);
+    }
+
+    SECTION("empty map")
+    {
+        const json j = std::map<TaskState, int>();
+        CHECK(j.is_object());
+        CHECK(j.empty());
+    }
+
+    SECTION("NLOHMANN_JSON_SERIALIZE_ENUM_STRICT")
+    {
+        using color_map = std::map<strict_color, int>;
+        const color_map m = {{strict_color::red, 1}, {strict_color::green, 2}};
+        const json j = m;
+        CHECK(j == json::parse(R"({"red":1,"green":2})"));
+        CHECK(j.get<color_map>() == m);
+
+        const color_map unmapped = {{strict_color::blue, 1}};
+        json _;
+        CHECK_THROWS_WITH_AS(_ = unmapped,
+                             "[json.exception.out_of_range.410] enum value out of range for strict_color", json::out_of_range&);
+    }
+
+    SECTION("arrays of [key, value] pairs are still read")
+    {
+        using task_map = std::map<TaskState, int>;
+        const task_map m = {{TS_STOPPED, 1}};
+        CHECK(json::parse(R"([["stopped",1]])").get<task_map>() == m);
+    }
+
+    SECTION("other containers are not affected")
+    {
+        const std::vector<std::pair<TaskState, int>> pairs = {{TS_STOPPED, 1}};
+        const std::map<std::string, TaskState> string_keys = {{"a", TS_STOPPED}};
+        const std::map<int, int> int_keys = {{1, 2}};
+        CHECK(json(pairs) == json::parse(R"([["stopped",1]])"));
+        CHECK(json(string_keys) == json::parse(R"({"a":"stopped"})"));
+        CHECK(json(int_keys) == json::parse("[[1,2]]"));
+    }
+
+    SECTION("maps with non-unique keys are still stored as arrays of pairs")
+    {
+        const std::multimap<TaskState, int> mm = {{TS_STOPPED, 1}, {TS_STOPPED, 2}};
+        const std::unordered_multimap<TaskState, int, enum_hash> umm = {{TS_RUNNING, 3}, {TS_RUNNING, 3}};
+        CHECK(json(mm) == json::parse(R"([["stopped",1],["stopped",2]])"));
+        CHECK(json(umm) == json::parse(R"([["running",3],["running",3]])"));
+    }
+
+    SECTION("keys that do not serialize to strings")
+    {
+        const std::map<TaskState, int> null_key = {{TS_INVALID, 1}};
+        const std::map<digit, int> number_key = {{digit::zero, 1}};
+        json j = "unchanged";
+
+        // mapped to null
+        CHECK_THROWS_WITH_AS(j = null_key,
+                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
+
+        // mapped to a number
+        CHECK_THROWS_WITH_AS(j = number_key,
+                             "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
+
+#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
+        // enum without NLOHMANN_JSON_SERIALIZE_ENUM
+        const std::map<plain, int> plain_key = {{plain::zero, 1}};
+        CHECK_THROWS_WITH_AS(j = plain_key,
+                             "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
+#endif
+
+        CHECK(j == "unchanged");
+    }
+
+    SECTION("keys that serialize to the same string")
+    {
+        const std::map<color, int> m = {{color::red, 1}, {color::blue, 2}};
+        json j = "unchanged";
+
+        // color::blue is not mapped and falls back to "red"
+        CHECK_THROWS_WITH_AS(j = m,
+                             "[json.exception.type_error.318] duplicate object key 'red'", json::type_error&);
+
+        CHECK(j == "unchanged");
+    }
+}
+
+DOCTEST_CLANG_SUPPRESS_WARNING_POP

tests/src/unit-enum_keyed_maps_default.cpp

@@ -0,0 +1,144 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#include "doctest_compatibility.h"
+
+// This file tests maps with enum keys with the default setting of
+// JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS (or whatever a -D flag sets it to).
+// unit-enum_keyed_maps.cpp tests JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS=1.
+// These tests are not part of unit-conversions.cpp, because that object file
+// is already too big for the MinGW linker of some compilers.
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <string>
+#include <unordered_map>
+
+// NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
+DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
+DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
+
+enum class cards {kreuz, pik, herz, karo};
+
+// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM(cards,
+{
+    {cards::kreuz, "kreuz"},
+    {cards::pik, "pik"},
+    {cards::herz, "herz"},
+    {cards::karo, "karo"}
+})
+
+enum TaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
+{
+    TS_STOPPED,
+    TS_RUNNING,
+    TS_COMPLETED,
+    TS_INVALID = -1,
+};
+
+// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM(TaskState,
+{
+    {TS_INVALID, nullptr},
+    {TS_STOPPED, "stopped"},
+    {TS_RUNNING, "running"},
+    {TS_COMPLETED, "completed"},
+})
+
+enum class strict_cards {kreuz, pik, herz, karo, andere}; // andere not included in mapping
+
+// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
+NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_cards,
+{
+    {strict_cards::kreuz, "kreuz"},
+    {strict_cards::pik, "pik"},
+    {strict_cards::herz, "herz"},
+    {strict_cards::karo, "karo"}
+})
+
+namespace
+{
+// std::hash is only required for enums since C++14
+struct enum_hash
+{
+    template<typename T>
+    std::size_t operator()(T t) const noexcept
+    {
+        return static_cast<std::size_t>(t);
+    }
+};
+} // namespace
+
+// see unit-enum_keyed_maps.cpp for JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS=1
+TEST_CASE("maps with enum keys")
+{
+    using task_map = std::map<TaskState, std::string>;
+    using task_umap = std::unordered_map<TaskState, std::string, enum_hash>;
+    using task_gmap = std::map<TaskState, std::string, std::greater<TaskState>>;
+    using nested_map = std::map<cards, std::map<TaskState, int>>;
+    using strict_map = std::map<strict_cards, int>;
+    using int_map = std::map<int, int>;
+    using int_umap = std::unordered_map<int, int>;
+
+    const task_map m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
+
+#if !JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
+    SECTION("stored as array of pairs")
+    {
+        CHECK(json(m) == json::parse(R"([["stopped","aa"],["completed","bb"]])"));
+        CHECK(json(task_umap {{TS_RUNNING, "cc"}}) == json::parse(R"([["running","cc"]])"));
+    }
+#endif
+
+    SECTION("read from array of pairs")
+    {
+        CHECK(json::parse(R"([["stopped","aa"],["completed","bb"]])").get<task_map>() == m);
+    }
+
+    SECTION("read from object (#4378)")
+    {
+        const json j = json::parse(R"({"stopped":"aa","completed":"bb"})");
+        CHECK(j.get<task_map>() == m);
+        CHECK(j.get<task_umap>() == task_umap(m.begin(), m.end()));
+        CHECK(j.get<task_gmap>() == task_gmap(m.begin(), m.end()));
+        CHECK(json::parse(R"({"kreuz":{"stopped":1}})").get<nested_map>() == nested_map {{cards::kreuz, {{TS_STOPPED, 1}}}});
+        CHECK(nlohmann::ordered_json::parse(R"({"stopped":"aa","completed":"bb"})").get<task_map>() == m);
+
+        // object keys go through the enum's from_json
+        strict_map sm;
+        CHECK_THROWS_WITH_AS(json::parse(R"({"what?":1})").get_to(sm),
+                             "[json.exception.out_of_range.410] enum value out of range for strict_cards: \"what?\"", json::out_of_range&);
+    }
+
+    SECTION("objects are only read for enum keys")
+    {
+        // built rather than parsed, so that the messages do not gain a byte
+        // range with JSON_DIAGNOSTIC_POSITIONS
+        const json j = {{"1", 2}};
+        int_map im;
+        int_umap ium;
+        CHECK_THROWS_WITH_AS(j.get_to(im),
+                             "[json.exception.type_error.302] type must be array, but is object", json::type_error&);
+        CHECK_THROWS_WITH_AS(j.get_to(ium),
+                             "[json.exception.type_error.302] type must be array, but is object", json::type_error&);
+    }
+
+    SECTION("other types are rejected")
+    {
+        task_map tm;
+        CHECK_THROWS_WITH_AS(json("stopped").get_to(tm),
+                             "[json.exception.type_error.302] type must be array, but is string", json::type_error&);
+    }
+}
+
+DOCTEST_CLANG_SUPPRESS_WARNING_POP

tests/src/unit-regression2.cpp

@@ -944,10 +944,11 @@ namespace
 {
 /// builds a value from SAX events, asks the parser to recover from its first
 /// 100 errors, and checks that the events are balanced (see #3989)
-class RecoveringParser
+template<typename BasicJsonType>
+class BasicRecoveringParser
 {
   public:
-    explicit RecoveringParser(json& j)
+    explicit BasicRecoveringParser(BasicJsonType& j)
         : dom(j, false)
     {}
 
@@ -963,19 +964,19 @@ class RecoveringParser
         return dom.boolean(val);
     }
 
-    bool number_integer(json::number_integer_t val)
+    bool number_integer(typename BasicJsonType::number_integer_t val)
     {
         value();
         return dom.number_integer(val);
     }
 
-    bool number_unsigned(json::number_unsigned_t val)
+    bool number_unsigned(typename BasicJsonType::number_unsigned_t val)
     {
         value();
         return dom.number_unsigned(val);
     }
 
-    bool number_float(json::number_float_t val, const std::string& s)
+    bool number_float(typename BasicJsonType::number_float_t val, const std::string& s)
     {
         value();
         return dom.number_float(val, s);
@@ -987,7 +988,7 @@ class RecoveringParser
         return dom.string(val);
     }
 
-    bool binary(json::binary_t& val)
+    bool binary(typename BasicJsonType::binary_t& val)
     {
         value();
         return dom.binary(val);
@@ -1055,7 +1056,7 @@ class RecoveringParser
     }
 
     /// builds the value
-    nlohmann::detail::json_sax_dom_parser<json> dom;
+    nlohmann::detail::json_sax_dom_parser<BasicJsonType> dom;
     std::size_t errors = 0;
     std::vector<std::string> messages {}; // NOLINT(readability-redundant-member-init)
     std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
@@ -1079,6 +1080,8 @@ class RecoveringParser
 
 };
 
+using RecoveringParser = BasicRecoveringParser<json>;
+
 struct BinaryParseResult
 {
     json value;
@@ -1395,11 +1398,17 @@ TEST_CASE("regression test - #3989 SAX parse_error() returning true")
 
     SECTION("binary formats repair numbers that are out of range")
     {
-        // CBOR: a negative integer below the range of number_integer_t
-        const auto cbor = parse_binary_recovering({0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, json::input_format_t::cbor);
-        CHECK(cbor.errors == 1);
-        CHECK(cbor.value.is_number_float());
-        CHECK(cbor.value.get<double>() == -18446744073709551616.0);
+        // CBOR: a double too large for a float number_float_t
+        using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
+        float_json cbor;
+        BasicRecoveringParser<float_json> sax(cbor);
+        const std::vector<std::uint8_t> cbor_input = {0x82, 0xFB, 0x7E, 0x37, 0xE4, 0x3C, 0x88, 0x00, 0x75, 0x9C, 0x01}; // [1e300, 1]
+        CHECK(!float_json::sax_parse(cbor_input, &sax, float_json::input_format_t::cbor));
+        CHECK(sax.errors == 1);
+        CHECK(sax.messages.front() == "[json.exception.out_of_range.406] syntax error while parsing CBOR value: number overflow");
+        REQUIRE(cbor.size() == 2);
+        CHECK(std::isinf(cbor[0].get<float>()));
+        CHECK(cbor[1] == 1);
 
         // UBJSON: a high-precision number too large for number_float_t
         const auto ubjson = parse_binary_recovering({'H', 'i', 5, '1', 'e', '9', '9', '9'}, json::input_format_t::ubjson);