Feature/unordered map conversion
Add conversion for `std::unordered_map`, when `KeyType != basic_json<>::string_t`

Fixes #1133 

* * *

## Pull request checklist

Read the [Contribution Guidelines](https://github.com/nlohmann/json/blob/develop/.github/CONTRIBUTING.md) for detailed information.

- [x]  Changes are described in the pull request, or an [existing issue is referenced](https://github.com/nlohmann/json/issues).
- [ ]  The test suite [compiles and runs](https://github.com/nlohmann/json/blob/develop/README.md#execute-unit-tests) without error.
- [ ]  [Code coverage](https://coveralls.io/github/nlohmann/json) is 100%. Test cases can be added by editing the [test suite](https://github.com/nlohmann/json/tree/develop/test/src).
- [x]  The source code is amalgamated; that is, after making changes to the sources in the `include/nlohmann` directory, run `make amalgamate` to create the single-header file `single_include/nlohmann/json.hpp`. The whole process is described [here](https://github.com/nlohmann/json/blob/develop/.github/CONTRIBUTING.md#files-to-change).

{"label": "nlohmann:develop", "ref": "develop", "sha": "e830bc502fe38852654a1f03f963001fecb54a86"}
- What is the issue you have?
		
Cannot build deserialization code for a std::unordered_map. Following the example in the README at https://github.com/nlohmann/json#arbitrary-types-conversions


- Please describe the steps to reproduce the issue. Can you provide a small but working code example?


      #include <unordered_map>
      #include <vector>
      #include <string>
      #include <nlohmann/json.hpp>

      struct myStruct{
        std::string structName;
      }
				
      struct myStructCollection {
        std::unordered_map<int, myStruct> myStructs;
        myStructCollection(std::unordered_map<int, myStruct> myStructs) : myStructs (myStructs){}
      };

      void from_json(const json& j, myStructCollection& p) {
        p.myStructs = j.at("myStructs").get<std::unordered_map<int, myStruct>>();
      }

- What is the expected behavior?

Builds. According to https://github.com/nlohmann/json#conversion-from-stl-containers, std::unordered_map is supported.

- And what is the actual behavior instead?

Error at line 269 of "utility": 

      pair& operator=(pair&& _Right)
        _NOEXCEPT_COND(is_nothrow_move_assignable_v<_Ty1>
        && is_nothrow_move_assignable_v<_Ty2>)
      {	// assign from moved pair
        first = _STD forward<_Ty1>(_Right.first); // ERROR ON THIS LINE!!!!
        second = _STD forward<_Ty2>(_Right.second);
        return (*this);
      }

Error	 C2166	"l-value specifies const object	"


- Which compiler and operating system are you using? Is it a [supported compiler](https://github.com/nlohmann/json#supported-compilers)?

MSVC compiler 19.14.26430, Windows 10, Visual Studio 2017 (version 15.7.2), v141 toolset.

- Did you use a released version of the library or the version from the `develop` branch?

Used vcpkg to install.

- If you experience a compilation error: can you [compile and run the unit tests](https://github.com/nlohmann/json#execute-unit-tests)?

std::unordered_map in struct, serialization
diff --git a/include/nlohmann/detail/conversions/from_json.hpp b/include/nlohmann/detail/conversions/from_json.hpp
index ac4cea5f09..7fe19f5766 100644
--- a/include/nlohmann/detail/conversions/from_json.hpp
+++ b/include/nlohmann/detail/conversions/from_json.hpp
@@ -9,6 +9,7 @@
 #include <string> // string
 #include <tuple> // tuple, make_tuple
 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
 #include <utility> // pair, declval
 #include <valarray> // valarray
 
@@ -278,10 +279,29 @@ void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
     from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
 }
 
-template <typename BasicJsonType, typename Key, typename Value,
+template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
           typename = enable_if_t<not std::is_constructible<
                                      typename BasicJsonType::string_t, Key>::value>>
-void from_json(const BasicJsonType& j, std::map<Key, Value>& m)
+void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    for (const auto& p : j)
+    {
+        if (JSON_UNLIKELY(not p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+          typename = enable_if_t<not std::is_constructible<
+                                     typename BasicJsonType::string_t, Key>::value>>
+void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
 {
     if (JSON_UNLIKELY(not j.is_array()))
     {
diff --git a/include/nlohmann/detail/output/serializer.hpp b/include/nlohmann/detail/output/serializer.hpp
index 19ab9894ac..c0f8177663 100644
--- a/include/nlohmann/detail/output/serializer.hpp
+++ b/include/nlohmann/detail/output/serializer.hpp
@@ -414,7 +414,7 @@ class serializer
         else
         {
             // we finish reading, but do not accept: string was incomplete
-            std::string sn(3,'\0');
+            std::string sn(3, '\0');
             snprintf(&sn[0], sn.size(), "%.2X", static_cast<uint8_t>(s.back()));
             JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
         }
diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp
index 2b387a8b6b..2921cba873 100644
--- a/single_include/nlohmann/json.hpp
+++ b/single_include/nlohmann/json.hpp
@@ -913,6 +913,7 @@ inline bool operator<(const value_t lhs, const value_t rhs) noexcept
 #include <string> // string
 #include <tuple> // tuple, make_tuple
 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
 #include <utility> // pair, declval
 #include <valarray> // valarray
 
@@ -1186,10 +1187,29 @@ void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
     from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
 }
 
-template <typename BasicJsonType, typename Key, typename Value,
+template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
           typename = enable_if_t<not std::is_constructible<
                                      typename BasicJsonType::string_t, Key>::value>>
-void from_json(const BasicJsonType& j, std::map<Key, Value>& m)
+void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    for (const auto& p : j)
+    {
+        if (JSON_UNLIKELY(not p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+          typename = enable_if_t<not std::is_constructible<
+                                     typename BasicJsonType::string_t, Key>::value>>
+void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
 {
     if (JSON_UNLIKELY(not j.is_array()))
     {
@@ -1973,10 +1993,8 @@ class input_adapter
 #include <clocale> // localeconv
 #include <cstddef> // size_t
 #include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <cstdio> // snprintf
 #include <initializer_list> // initializer_list
-#include <ios> // hex, uppercase
-#include <iomanip> // setw, setfill
-#include <sstream> // stringstream
 #include <string> // char_traits, string
 #include <vector> // vector
 
@@ -3146,10 +3164,9 @@ class lexer
             if ('\x00' <= c and c <= '\x1F')
             {
                 // escape control characters
-                std::stringstream ss;
-                ss << "<U+" << std::setw(4) << std::uppercase << std::setfill('0')
-                   << std::hex << static_cast<int>(c) << ">";
-                result += ss.str();
+                char cs[9];
+                snprintf(cs, 9, "<U+%.4X>", c);
+                result += cs;
             }
             else
             {
@@ -5619,12 +5636,10 @@ class output_adapter
 #include <cmath> // ldexp
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
 #include <cstring> // memcpy
-#include <iomanip> // setw, setfill
-#include <ios> // hex
 #include <iterator> // back_inserter
 #include <limits> // numeric_limits
-#include <sstream> // stringstream
 #include <string> // char_traits, string
 #include <utility> // make_pair, move
 
@@ -7283,9 +7298,9 @@ class binary_reader
     */
     std::string get_token_string() const
     {
-        std::stringstream ss;
-        ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
-        return ss.str();
+        char cr[3];
+        snprintf(cr, 3, "%.2X", current);
+        return std::string{cr};
     }
 
   private:
@@ -8272,11 +8287,8 @@ class binary_writer
 #include <cstddef> // size_t, ptrdiff_t
 #include <cstdint> // uint8_t
 #include <cstdio> // snprintf
-#include <iomanip> // setfill
-#include <iterator> // next
 #include <limits> // numeric_limits
 #include <string> // string
-#include <sstream> // stringstream
 #include <type_traits> // is_same
 
 // #include <nlohmann/detail/exceptions.hpp>
@@ -9753,9 +9765,9 @@ class serializer
 
                 case UTF8_REJECT:  // decode found invalid UTF-8 byte
                 {
-                    std::stringstream ss;
-                    ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << static_cast<int>(byte);
-                    JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + ss.str()));
+                    std::string sn(3, '\0');
+                    snprintf(&sn[0], sn.size(), "%.2X", byte);
+                    JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
                 }
 
                 default:  // decode found yet incomplete multi-byte code point
@@ -9781,9 +9793,9 @@ class serializer
         else
         {
             // we finish reading, but do not accept: string was incomplete
-            std::stringstream ss;
-            ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << static_cast<int>(static_cast<uint8_t>(s.back()));
-            JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + ss.str()));
+            std::string sn(3, '\0');
+            snprintf(&sn[0], sn.size(), "%.2X", static_cast<uint8_t>(s.back()));
+            JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
         }
     }
 

diff --git a/test/src/unit-conversions.cpp b/test/src/unit-conversions.cpp
index 79ccf68106..061a24582c 100644
--- a/test/src/unit-conversions.cpp
+++ b/test/src/unit-conversions.cpp
@@ -40,11 +40,25 @@ using nlohmann::json;
 #include <unordered_set>
 #include <valarray>
 
+namespace
+{
+template <typename MapType>
+void map_type_conversion_checks()
+{
+}
+}
+
 TEST_CASE("value conversion")
 {
     SECTION("get an object (explicit)")
     {
-        json::object_t o_reference = {{"object", json::object()}, {"array", {1, 2, 3, 4}}, {"number", 42}, {"boolean", false}, {"null", nullptr}, {"string", "Hello world"} };
+        json::object_t o_reference = {{"object", json::object()},
+            {"array", {1, 2, 3, 4}},
+            {"number", 42},
+            {"boolean", false},
+            {"null", nullptr},
+            {"string", "Hello world"}
+        };
         json j(o_reference);
 
         SECTION("json::object_t")
@@ -55,19 +69,22 @@ TEST_CASE("value conversion")
 
         SECTION("std::map<json::string_t, json>")
         {
-            std::map<json::string_t, json> o = j.get<std::map<json::string_t, json>>();
+            std::map<json::string_t, json> o =
+                j.get<std::map<json::string_t, json>>();
             CHECK(json(o) == j);
         }
 
         SECTION("std::multimap<json::string_t, json>")
         {
-            std::multimap<json::string_t, json> o = j.get<std::multimap<json::string_t, json>>();
+            std::multimap<json::string_t, json> o =
+                j.get<std::multimap<json::string_t, json>>();
             CHECK(json(o) == j);
         }
 
         SECTION("std::unordered_map<json::string_t, json>")
         {
-            std::unordered_map<json::string_t, json> o = j.get<std::unordered_map<json::string_t, json>>();
+            std::unordered_map<json::string_t, json> o =
+                j.get<std::unordered_map<json::string_t, json>>();
             CHECK(json(o) == j);
         }
 
@@ -80,34 +97,55 @@ TEST_CASE("value conversion")
 
         SECTION("exception in case of a non-object type")
         {
-            CHECK_THROWS_AS(json(json::value_t::null).get<json::object_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::array).get<json::object_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::string).get<json::object_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::boolean).get<json::object_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_integer).get<json::object_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_unsigned).get<json::object_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_float).get<json::object_t>(), json::type_error&);
-
-            CHECK_THROWS_WITH(json(json::value_t::null).get<json::object_t>(),
-                              "[json.exception.type_error.302] type must be object, but is null");
-            CHECK_THROWS_WITH(json(json::value_t::array).get<json::object_t>(),
-                              "[json.exception.type_error.302] type must be object, but is array");
-            CHECK_THROWS_WITH(json(json::value_t::string).get<json::object_t>(),
-                              "[json.exception.type_error.302] type must be object, but is string");
+            CHECK_THROWS_AS(json(json::value_t::null).get<json::object_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::array).get<json::object_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::string).get<json::object_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::boolean).get<json::object_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::number_integer).get<json::object_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(
+                json(json::value_t::number_unsigned).get<json::object_t>(),
+                json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::number_float).get<json::object_t>(),
+                            json::type_error&);
+
+            CHECK_THROWS_WITH(
+                json(json::value_t::null).get<json::object_t>(),
+                "[json.exception.type_error.302] type must be object, but is null");
+            CHECK_THROWS_WITH(
+                json(json::value_t::array).get<json::object_t>(),
+                "[json.exception.type_error.302] type must be object, but is array");
+            CHECK_THROWS_WITH(
+                json(json::value_t::string).get<json::object_t>(),
+                "[json.exception.type_error.302] type must be object, but is string");
             CHECK_THROWS_WITH(json(json::value_t::boolean).get<json::object_t>(),
-                              "[json.exception.type_error.302] type must be object, but is boolean");
-            CHECK_THROWS_WITH(json(json::value_t::number_integer).get<json::object_t>(),
-                              "[json.exception.type_error.302] type must be object, but is number");
-            CHECK_THROWS_WITH(json(json::value_t::number_unsigned).get<json::object_t>(),
-                              "[json.exception.type_error.302] type must be object, but is number");
-            CHECK_THROWS_WITH(json(json::value_t::number_float).get<json::object_t>(),
-                              "[json.exception.type_error.302] type must be object, but is number");
+                              "[json.exception.type_error.302] type must be object, "
+                              "but is boolean");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_integer).get<json::object_t>(),
+                "[json.exception.type_error.302] type must be object, but is number");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_unsigned).get<json::object_t>(),
+                "[json.exception.type_error.302] type must be object, but is number");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_float).get<json::object_t>(),
+                "[json.exception.type_error.302] type must be object, but is number");
         }
     }
 
     SECTION("get an object (implicit)")
     {
-        json::object_t o_reference = {{"object", json::object()}, {"array", {1, 2, 3, 4}}, {"number", 42}, {"boolean", false}, {"null", nullptr}, {"string", "Hello world"} };
+        json::object_t o_reference = {{"object", json::object()},
+            {"array", {1, 2, 3, 4}},
+            {"number", 42},
+            {"boolean", false},
+            {"null", nullptr},
+            {"string", "Hello world"}
+        };
         json j(o_reference);
 
         SECTION("json::object_t")
@@ -143,7 +181,8 @@ TEST_CASE("value conversion")
 
     SECTION("get an array (explicit)")
     {
-        json::array_t a_reference {json(1), json(1u), json(2.2), json(false), json("string"), json()};
+        json::array_t a_reference{json(1),     json(1u),       json(2.2),
+                                  json(false), json("string"), json()};
         json j(a_reference);
 
         SECTION("json::array_t")
@@ -163,9 +202,11 @@ TEST_CASE("value conversion")
             std::forward_list<json> a = j.get<std::forward_list<json>>();
             CHECK(json(a) == j);
 
-            CHECK_THROWS_AS(json(json::value_t::null).get<std::forward_list<json>>(), json::type_error&);
-            CHECK_THROWS_WITH(json(json::value_t::null).get<std::forward_list<json>>(),
-                              "[json.exception.type_error.302] type must be array, but is null");
+            CHECK_THROWS_AS(json(json::value_t::null).get<std::forward_list<json>>(),
+                            json::type_error&);
+            CHECK_THROWS_WITH(
+                json(json::value_t::null).get<std::forward_list<json>>(),
+                "[json.exception.type_error.302] type must be array, but is null");
         }
 
         SECTION("std::vector<json>")
@@ -173,9 +214,11 @@ TEST_CASE("value conversion")
             std::vector<json> a = j.get<std::vector<json>>();
             CHECK(json(a) == j);
 
-            CHECK_THROWS_AS(json(json::value_t::null).get<std::vector<json>>(), json::type_error&);
-            CHECK_THROWS_WITH(json(json::value_t::null).get<std::vector<json>>(),
-                              "[json.exception.type_error.302] type must be array, but is null");
+            CHECK_THROWS_AS(json(json::value_t::null).get<std::vector<json>>(),
+                            json::type_error&);
+            CHECK_THROWS_WITH(
+                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)
             SECTION("reserve is called on containers that supports it")
@@ -214,36 +257,52 @@ TEST_CASE("value conversion")
 
         SECTION("exception in case of a non-array type")
         {
-            CHECK_THROWS_AS(json(json::value_t::null).get<json::array_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::object).get<json::array_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::string).get<json::array_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::boolean).get<json::array_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_integer).get<json::array_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_unsigned).get<json::array_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_float).get<json::array_t>(), json::type_error&);
-
-            CHECK_THROWS_WITH(json(json::value_t::object).get<std::vector<int>>(),
-                              "[json.exception.type_error.302] type must be array, but is object");
-            CHECK_THROWS_WITH(json(json::value_t::null).get<json::array_t>(),
-                              "[json.exception.type_error.302] type must be array, but is null");
-            CHECK_THROWS_WITH(json(json::value_t::object).get<json::array_t>(),
-                              "[json.exception.type_error.302] type must be array, but is object");
-            CHECK_THROWS_WITH(json(json::value_t::string).get<json::array_t>(),
-                              "[json.exception.type_error.302] type must be array, but is string");
-            CHECK_THROWS_WITH(json(json::value_t::boolean).get<json::array_t>(),
-                              "[json.exception.type_error.302] type must be array, but is boolean");
-            CHECK_THROWS_WITH(json(json::value_t::number_integer).get<json::array_t>(),
-                              "[json.exception.type_error.302] type must be array, but is number");
-            CHECK_THROWS_WITH(json(json::value_t::number_unsigned).get<json::array_t>(),
-                              "[json.exception.type_error.302] type must be array, but is number");
-            CHECK_THROWS_WITH(json(json::value_t::number_float).get<json::array_t>(),
-                              "[json.exception.type_error.302] type must be array, but is number");
+            CHECK_THROWS_AS(json(json::value_t::null).get<json::array_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::object).get<json::array_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::string).get<json::array_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::boolean).get<json::array_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::number_integer).get<json::array_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::number_unsigned).get<json::array_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::number_float).get<json::array_t>(),
+                            json::type_error&);
+
+            CHECK_THROWS_WITH(
+                json(json::value_t::object).get<std::vector<int>>(),
+                "[json.exception.type_error.302] type must be array, but is object");
+            CHECK_THROWS_WITH(
+                json(json::value_t::null).get<json::array_t>(),
+                "[json.exception.type_error.302] type must be array, but is null");
+            CHECK_THROWS_WITH(
+                json(json::value_t::object).get<json::array_t>(),
+                "[json.exception.type_error.302] type must be array, but is object");
+            CHECK_THROWS_WITH(
+                json(json::value_t::string).get<json::array_t>(),
+                "[json.exception.type_error.302] type must be array, but is string");
+            CHECK_THROWS_WITH(
+                json(json::value_t::boolean).get<json::array_t>(),
+                "[json.exception.type_error.302] type must be array, but is boolean");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_integer).get<json::array_t>(),
+                "[json.exception.type_error.302] type must be array, but is number");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_unsigned).get<json::array_t>(),
+                "[json.exception.type_error.302] type must be array, but is number");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_float).get<json::array_t>(),
+                "[json.exception.type_error.302] type must be array, but is number");
         }
     }
 
     SECTION("get an array (implicit)")
     {
-        json::array_t a_reference {json(1), json(1u), json(2.2), json(false), json("string"), json()};
+        json::array_t a_reference{json(1),     json(1u),       json(2.2),
+                                  json(false), json("string"), json()};
         json j(a_reference);
 
         SECTION("json::array_t")
@@ -279,7 +338,7 @@ TEST_CASE("value conversion")
 
     SECTION("get a string (explicit)")
     {
-        json::string_t s_reference {"Hello world"};
+        json::string_t s_reference{"Hello world"};
         json j(s_reference);
 
         SECTION("string_t")
@@ -296,34 +355,49 @@ TEST_CASE("value conversion")
 
         SECTION("exception in case of a non-string type")
         {
-            CHECK_THROWS_AS(json(json::value_t::null).get<json::string_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::object).get<json::string_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::array).get<json::string_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::boolean).get<json::string_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_integer).get<json::string_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_unsigned).get<json::string_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_float).get<json::string_t>(), json::type_error&);
-
-            CHECK_THROWS_WITH(json(json::value_t::null).get<json::string_t>(),
-                              "[json.exception.type_error.302] type must be string, but is null");
-            CHECK_THROWS_WITH(json(json::value_t::object).get<json::string_t>(),
-                              "[json.exception.type_error.302] type must be string, but is object");
-            CHECK_THROWS_WITH(json(json::value_t::array).get<json::string_t>(),
-                              "[json.exception.type_error.302] type must be string, but is array");
+            CHECK_THROWS_AS(json(json::value_t::null).get<json::string_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::object).get<json::string_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::array).get<json::string_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::boolean).get<json::string_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::number_integer).get<json::string_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(
+                json(json::value_t::number_unsigned).get<json::string_t>(),
+                json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::number_float).get<json::string_t>(),
+                            json::type_error&);
+
+            CHECK_THROWS_WITH(
+                json(json::value_t::null).get<json::string_t>(),
+                "[json.exception.type_error.302] type must be string, but is null");
+            CHECK_THROWS_WITH(
+                json(json::value_t::object).get<json::string_t>(),
+                "[json.exception.type_error.302] type must be string, but is object");
+            CHECK_THROWS_WITH(
+                json(json::value_t::array).get<json::string_t>(),
+                "[json.exception.type_error.302] type must be string, but is array");
             CHECK_THROWS_WITH(json(json::value_t::boolean).get<json::string_t>(),
-                              "[json.exception.type_error.302] type must be string, but is boolean");
-            CHECK_THROWS_WITH(json(json::value_t::number_integer).get<json::string_t>(),
-                              "[json.exception.type_error.302] type must be string, but is number");
-            CHECK_THROWS_WITH(json(json::value_t::number_unsigned).get<json::string_t>(),
-                              "[json.exception.type_error.302] type must be string, but is number");
-            CHECK_THROWS_WITH(json(json::value_t::number_float).get<json::string_t>(),
-                              "[json.exception.type_error.302] type must be string, but is number");
+                              "[json.exception.type_error.302] type must be string, "
+                              "but is boolean");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_integer).get<json::string_t>(),
+                "[json.exception.type_error.302] type must be string, but is number");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_unsigned).get<json::string_t>(),
+                "[json.exception.type_error.302] type must be string, but is number");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_float).get<json::string_t>(),
+                "[json.exception.type_error.302] type must be string, but is number");
         }
     }
 
     SECTION("get a string (implicit)")
     {
-        json::string_t s_reference {"Hello world"};
+        json::string_t s_reference{"Hello world"};
         json j(s_reference);
 
         SECTION("string_t")
@@ -341,7 +415,7 @@ TEST_CASE("value conversion")
 
     SECTION("get a boolean (explicit)")
     {
-        json::boolean_t b_reference {true};
+        json::boolean_t b_reference{true};
         json j(b_reference);
 
         SECTION("boolean_t")
@@ -358,34 +432,53 @@ TEST_CASE("value conversion")
 
         SECTION("exception in case of a non-string type")
         {
-            CHECK_THROWS_AS(json(json::value_t::null).get<json::boolean_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::object).get<json::boolean_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::array).get<json::boolean_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::string).get<json::boolean_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_integer).get<json::boolean_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_unsigned).get<json::boolean_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::number_float).get<json::boolean_t>(), json::type_error&);
-
-            CHECK_THROWS_WITH(json(json::value_t::null).get<json::boolean_t>(),
-                              "[json.exception.type_error.302] type must be boolean, but is null");
+            CHECK_THROWS_AS(json(json::value_t::null).get<json::boolean_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::object).get<json::boolean_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::array).get<json::boolean_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::string).get<json::boolean_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(
+                json(json::value_t::number_integer).get<json::boolean_t>(),
+                json::type_error&);
+            CHECK_THROWS_AS(
+                json(json::value_t::number_unsigned).get<json::boolean_t>(),
+                json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::number_float).get<json::boolean_t>(),
+                            json::type_error&);
+
+            CHECK_THROWS_WITH(
+                json(json::value_t::null).get<json::boolean_t>(),
+                "[json.exception.type_error.302] type must be boolean, but is null");
             CHECK_THROWS_WITH(json(json::value_t::object).get<json::boolean_t>(),
-                              "[json.exception.type_error.302] type must be boolean, but is object");
-            CHECK_THROWS_WITH(json(json::value_t::array).get<json::boolean_t>(),
-                              "[json.exception.type_error.302] type must be boolean, but is array");
+                              "[json.exception.type_error.302] type must be boolean, "
+                              "but is object");
+            CHECK_THROWS_WITH(
+                json(json::value_t::array).get<json::boolean_t>(),
+                "[json.exception.type_error.302] type must be boolean, but is array");
             CHECK_THROWS_WITH(json(json::value_t::string).get<json::boolean_t>(),
-                              "[json.exception.type_error.302] type must be boolean, but is string");
-            CHECK_THROWS_WITH(json(json::value_t::number_integer).get<json::boolean_t>(),
-                              "[json.exception.type_error.302] type must be boolean, but is number");
-            CHECK_THROWS_WITH(json(json::value_t::number_unsigned).get<json::boolean_t>(),
-                              "[json.exception.type_error.302] type must be boolean, but is number");
-            CHECK_THROWS_WITH(json(json::value_t::number_float).get<json::boolean_t>(),
-                              "[json.exception.type_error.302] type must be boolean, but is number");
+                              "[json.exception.type_error.302] type must be boolean, "
+                              "but is string");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_integer).get<json::boolean_t>(),
+                "[json.exception.type_error.302] type must be boolean, but is "
+                "number");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_unsigned).get<json::boolean_t>(),
+                "[json.exception.type_error.302] type must be boolean, but is "
+                "number");
+            CHECK_THROWS_WITH(
+                json(json::value_t::number_float).get<json::boolean_t>(),
+                "[json.exception.type_error.302] type must be boolean, but is "
+                "number");
         }
     }
 
     SECTION("get a boolean (implicit)")
     {
-        json::boolean_t b_reference {true};
+        json::boolean_t b_reference{true};
         json j(b_reference);
 
         SECTION("boolean_t")
@@ -403,9 +496,9 @@ TEST_CASE("value conversion")
 
     SECTION("get an integer number (explicit)")
     {
-        json::number_integer_t n_reference {42};
+        json::number_integer_t n_reference{42};
         json j(n_reference);
-        json::number_unsigned_t n_unsigned_reference {42u};
+        json::number_unsigned_t n_unsigned_reference{42u};
         json j_unsigned(n_unsigned_reference);
 
         SECTION("number_integer_t")
@@ -614,33 +707,47 @@ TEST_CASE("value conversion")
 
         SECTION("exception in case of a non-number type")
         {
-            CHECK_THROWS_AS(json(json::value_t::null).get<json::number_integer_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::object).get<json::number_integer_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::array).get<json::number_integer_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::string).get<json::number_integer_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::boolean).get<json::number_integer_t>(), json::type_error&);
-
-            CHECK_THROWS_WITH(json(json::value_t::null).get<json::number_integer_t>(),
-                              "[json.exception.type_error.302] type must be number, but is null");
-            CHECK_THROWS_WITH(json(json::value_t::object).get<json::number_integer_t>(),
-                              "[json.exception.type_error.302] type must be number, but is object");
-            CHECK_THROWS_WITH(json(json::value_t::array).get<json::number_integer_t>(),
-                              "[json.exception.type_error.302] type must be number, but is array");
-            CHECK_THROWS_WITH(json(json::value_t::string).get<json::number_integer_t>(),
-                              "[json.exception.type_error.302] type must be number, but is string");
-            CHECK_THROWS_WITH(json(json::value_t::boolean).get<json::number_integer_t>(),
-                              "[json.exception.type_error.302] type must be number, but is boolean");
-
-            CHECK_NOTHROW(json(json::value_t::number_float).get<json::number_integer_t>());
-            CHECK_NOTHROW(json(json::value_t::number_float).get<json::number_unsigned_t>());
+            CHECK_THROWS_AS(json(json::value_t::null).get<json::number_integer_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::object).get<json::number_integer_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::array).get<json::number_integer_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::string).get<json::number_integer_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(
+                json(json::value_t::boolean).get<json::number_integer_t>(),
+                json::type_error&);
+
+            CHECK_THROWS_WITH(
+                json(json::value_t::null).get<json::number_integer_t>(),
+                "[json.exception.type_error.302] type must be number, but is null");
+            CHECK_THROWS_WITH(
+                json(json::value_t::object).get<json::number_integer_t>(),
+                "[json.exception.type_error.302] type must be number, but is object");
+            CHECK_THROWS_WITH(
+                json(json::value_t::array).get<json::number_integer_t>(),
+                "[json.exception.type_error.302] type must be number, but is array");
+            CHECK_THROWS_WITH(
+                json(json::value_t::string).get<json::number_integer_t>(),
+                "[json.exception.type_error.302] type must be number, but is string");
+            CHECK_THROWS_WITH(
+                json(json::value_t::boolean).get<json::number_integer_t>(),
+                "[json.exception.type_error.302] type must be number, but is "
+                "boolean");
+
+            CHECK_NOTHROW(
+                json(json::value_t::number_float).get<json::number_integer_t>());
+            CHECK_NOTHROW(
+                json(json::value_t::number_float).get<json::number_unsigned_t>());
         }
     }
 
     SECTION("get an integer number (implicit)")
     {
-        json::number_integer_t n_reference {42};
+        json::number_integer_t n_reference{42};
         json j(n_reference);
-        json::number_unsigned_t n_unsigned_reference {42u};
+        json::number_unsigned_t n_unsigned_reference{42u};
         json j_unsigned(n_unsigned_reference);
 
         SECTION("number_integer_t")
@@ -850,7 +957,7 @@ TEST_CASE("value conversion")
 
     SECTION("get a floating-point number (explicit)")
     {
-        json::number_float_t n_reference {42.23};
+        json::number_float_t n_reference{42.23};
         json j(n_reference);
 
         SECTION("number_float_t")
@@ -873,31 +980,44 @@ TEST_CASE("value conversion")
 
         SECTION("exception in case of a non-string type")
         {
-            CHECK_THROWS_AS(json(json::value_t::null).get<json::number_float_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::object).get<json::number_float_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::array).get<json::number_float_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::string).get<json::number_float_t>(), json::type_error&);
-            CHECK_THROWS_AS(json(json::value_t::boolean).get<json::number_float_t>(), json::type_error&);
-
-            CHECK_THROWS_WITH(json(json::value_t::null).get<json::number_float_t>(),
-                              "[json.exception.type_error.302] type must be number, but is null");
-            CHECK_THROWS_WITH(json(json::value_t::object).get<json::number_float_t>(),
-                              "[json.exception.type_error.302] type must be number, but is object");
-            CHECK_THROWS_WITH(json(json::value_t::array).get<json::number_float_t>(),
-                              "[json.exception.type_error.302] type must be number, but is array");
-            CHECK_THROWS_WITH(json(json::value_t::string).get<json::number_float_t>(),
-                              "[json.exception.type_error.302] type must be number, but is string");
-            CHECK_THROWS_WITH(json(json::value_t::boolean).get<json::number_float_t>(),
-                              "[json.exception.type_error.302] type must be number, but is boolean");
-
-            CHECK_NOTHROW(json(json::value_t::number_integer).get<json::number_float_t>());
-            CHECK_NOTHROW(json(json::value_t::number_unsigned).get<json::number_float_t>());
+            CHECK_THROWS_AS(json(json::value_t::null).get<json::number_float_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::object).get<json::number_float_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::array).get<json::number_float_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::string).get<json::number_float_t>(),
+                            json::type_error&);
+            CHECK_THROWS_AS(json(json::value_t::boolean).get<json::number_float_t>(),
+                            json::type_error&);
+
+            CHECK_THROWS_WITH(
+                json(json::value_t::null).get<json::number_float_t>(),
+                "[json.exception.type_error.302] type must be number, but is null");
+            CHECK_THROWS_WITH(
+                json(json::value_t::object).get<json::number_float_t>(),
+                "[json.exception.type_error.302] type must be number, but is object");
+            CHECK_THROWS_WITH(
+                json(json::value_t::array).get<json::number_float_t>(),
+                "[json.exception.type_error.302] type must be number, but is array");
+            CHECK_THROWS_WITH(
+                json(json::value_t::string).get<json::number_float_t>(),
+                "[json.exception.type_error.302] type must be number, but is string");
+            CHECK_THROWS_WITH(
+                json(json::value_t::boolean).get<json::number_float_t>(),
+                "[json.exception.type_error.302] type must be number, but is "
+                "boolean");
+
+            CHECK_NOTHROW(
+                json(json::value_t::number_integer).get<json::number_float_t>());
+            CHECK_NOTHROW(
+                json(json::value_t::number_unsigned).get<json::number_float_t>());
         }
     }
 
     SECTION("get a floating-point number (implicit)")
     {
-        json::number_float_t n_reference {42.23};
+        json::number_float_t n_reference{42.23};
         json j(n_reference);
 
         SECTION("number_float_t")
@@ -954,7 +1074,7 @@ TEST_CASE("value conversion")
                 j3.get<std::unordered_map<std::string, double>>();
                 j4.get<std::unordered_map<std::string, bool>>();
                 j5.get<std::unordered_map<std::string, std::string>>();
-                //CHECK(m5["one"] == "eins");
+                // CHECK(m5["one"] == "eins");
             }
 
             SECTION("std::multimap")
@@ -964,7 +1084,7 @@ TEST_CASE("value conversion")
                 j3.get<std::multimap<std::string, double>>();
                 j4.get<std::multimap<std::string, bool>>();
                 j5.get<std::multimap<std::string, std::string>>();
-                //CHECK(m5["one"] == "eins");
+                // CHECK(m5["one"] == "eins");
             }
 
             SECTION("std::unordered_multimap")
@@ -974,13 +1094,16 @@ TEST_CASE("value conversion")
                 j3.get<std::unordered_multimap<std::string, double>>();
                 j4.get<std::unordered_multimap<std::string, bool>>();
                 j5.get<std::unordered_multimap<std::string, std::string>>();
-                //CHECK(m5["one"] == "eins");
+                // CHECK(m5["one"] == "eins");
             }
 
             SECTION("exception in case of a non-object type")
             {
-                CHECK_THROWS_AS((json().get<std::map<std::string, int>>()), json::type_error&);
-                CHECK_THROWS_WITH((json().get<std::map<std::string, int>>()), "[json.exception.type_error.302] type must be object, but is null");
+                CHECK_THROWS_AS((json().get<std::map<std::string, int>>()),
+                                json::type_error&);
+                CHECK_THROWS_WITH(
+                    (json().get<std::map<std::string, int>>()),
+                    "[json.exception.type_error.302] type must be object, but is null");
             }
         }
 
@@ -1022,7 +1145,8 @@ TEST_CASE("value conversion")
                 {
                     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] array index 4 is out of range");
+                    CHECK_THROWS_WITH(arr6 = j1, "[json.exception.out_of_range.401] "
+                                      "array index 4 is out of range");
                 }
 
                 SECTION("std::array is smaller than JSON")
@@ -1088,14 +1212,48 @@ TEST_CASE("value conversion")
                 CHECK(m == m2);
 
                 json j7 = {0, 1, 2, 3};
+                json j8 = 2;
                 CHECK_THROWS_AS((j7.get<std::map<int, int>>()), json::type_error&);
-                CHECK_THROWS_WITH((j7.get<std::map<int, int>>()), "[json.exception.type_error.302] type must be array, but is number");
+                CHECK_THROWS_AS((j8.get<std::map<int, int>>()), json::type_error&);
+                CHECK_THROWS_WITH((j7.get<std::map<int, int>>()),
+                                  "[json.exception.type_error.302] type must be array, "
+                                  "but is number");
+                CHECK_THROWS_WITH((j8.get<std::map<int, int>>()),
+                                  "[json.exception.type_error.302] type must be array, "
+                                  "but is number");
+
+                SECTION("superfluous entries")
+                {
+                    json j9 = {{0, 1, 2}, {1, 2, 3}, {2, 3, 4}};
+                    m2 = j9.get<std::map<int, int>>();
+                    CHECK(m == m2);
+                }
+            }
+
+            SECTION("std::unordered_map (array of pairs)")
+            {
+                std::unordered_map<int, int> m{{0, 1}, {1, 2}, {2, 3}};
+                json j6 = m;
+
+                auto m2 = j6.get<std::unordered_map<int, int>>();
+                CHECK(m == m2);
+
+                json j7 = {0, 1, 2, 3};
+                json j8 = 2;
+                CHECK_THROWS_AS((j7.get<std::unordered_map<int, int>>()), json::type_error&);
+                CHECK_THROWS_AS((j8.get<std::unordered_map<int, int>>()), json::type_error&);
+                CHECK_THROWS_WITH((j7.get<std::unordered_map<int, int>>()),
+                                  "[json.exception.type_error.302] type must be array, "
+                                  "but is number");
+                CHECK_THROWS_WITH((j8.get<std::unordered_map<int, int>>()),
+                                  "[json.exception.type_error.302] type must be array, "
+                                  "but is number");
 
                 SECTION("superfluous entries")
                 {
-                  json j8 = {{0, 1, 2}, {1, 2, 3}, {2, 3, 4}};
-                  m2 = j8.get<std::map<int, int>>();
-                  CHECK(m == m2);
+                    json j9{{0, 1, 2}, {1, 2, 3}, {2, 3, 4}};
+                    m2 = j9.get<std::unordered_map<int, int>>();
+                    CHECK(m == m2);
                 }
             }
 
@@ -1109,12 +1267,24 @@ TEST_CASE("value conversion")
 
                 // does type really must be an array? or it rather must not be null?
                 // that's what I thought when other test like this one broke
-                CHECK_THROWS_WITH((json().get<std::list<int>>()), "[json.exception.type_error.302] type must be array, but is null");
-                CHECK_THROWS_WITH((json().get<std::vector<int>>()), "[json.exception.type_error.302] type must be array, but is null");
-                CHECK_THROWS_WITH((json().get<std::vector<json>>()), "[json.exception.type_error.302] type must be array, but is null");
-                CHECK_THROWS_WITH((json().get<std::list<json>>()), "[json.exception.type_error.302] type must be array, but is null");
-                CHECK_THROWS_WITH((json().get<std::valarray<int>>()), "[json.exception.type_error.302] type must be array, but is null");
-                CHECK_THROWS_WITH((json().get<std::map<int, int>>()), "[json.exception.type_error.302] type must be array, but is null");
+                CHECK_THROWS_WITH(
+                    (json().get<std::list<int>>()),
+                    "[json.exception.type_error.302] type must be array, but is null");
+                CHECK_THROWS_WITH(
+                    (json().get<std::vector<int>>()),
+                    "[json.exception.type_error.302] type must be array, but is null");
+                CHECK_THROWS_WITH(
+                    (json().get<std::vector<json>>()),
+                    "[json.exception.type_error.302] type must be array, but is null");
+                CHECK_THROWS_WITH(
+                    (json().get<std::list<json>>()),
+                    "[json.exception.type_error.302] type must be array, but is null");
+                CHECK_THROWS_WITH(
+                    (json().get<std::valarray<int>>()),
+                    "[json.exception.type_error.302] type must be array, but is null");
+                CHECK_THROWS_WITH(
+                    (json().get<std::map<int, int>>()),
+                    "[json.exception.type_error.302] type must be array, but is null");
             }
         }
     }

{"test-json_pointer_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-regression_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-element_access2_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-items_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-modifiers_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-constructor1_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-reference_access_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-comparison_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_lexer_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_const_iterator_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-wstring_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_iterator_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-udt_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_const_iterator_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-constructor2_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-cbor_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-allocator_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-inspection_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-algorithms_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-testsuites_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-comparison_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-to_chars_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-constructor2_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-meta_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-allocator_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-readme_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-concepts_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-unicode_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-pointer_access_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-serialization_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-msgpack_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-msgpack_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-regression_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-convenience_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-conversions_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_parser_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-element_access1_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-wstring_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-readme_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-noexcept_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-element_access1_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-inspection_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_iterator_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-algorithms_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-unicode_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-alt-string_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-alt-string_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-items_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-conversions_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-noexcept_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-concepts_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-merge_patch_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-iterators2_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-pointer_access_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-iterators1_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-constructor1_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-cbor_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-modifiers_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-json_patch_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-to_chars_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-capacity_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-element_access2_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-ubjson_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-serialization_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-testsuites_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-iterators1_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-udt_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-reference_access_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_lexer_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-capacity_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-json_patch_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-json_pointer_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_parser_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-merge_patch_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-iterators2_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-deserialization_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-ubjson_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-convenience_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-meta_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-deserialization_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}}
{"test-json_pointer_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-regression_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-element_access2_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-items_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-modifiers_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-constructor1_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-reference_access_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-comparison_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_lexer_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_const_iterator_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-wstring_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_iterator_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-udt_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_const_iterator_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-constructor2_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-cbor_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-allocator_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-inspection_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-algorithms_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-testsuites_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-comparison_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-to_chars_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-constructor2_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-meta_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-allocator_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-readme_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-concepts_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-unicode_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-pointer_access_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-serialization_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-msgpack_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-msgpack_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-regression_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-convenience_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-conversions_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_parser_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-element_access1_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-wstring_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-readme_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-noexcept_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-element_access1_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-inspection_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_iterator_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-algorithms_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-unicode_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-alt-string_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-alt-string_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-items_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-conversions_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-noexcept_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-concepts_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-merge_patch_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-iterators2_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-pointer_access_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-iterators1_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-constructor1_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-cbor_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-modifiers_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-json_patch_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-to_chars_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-capacity_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-element_access2_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-ubjson_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-serialization_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-testsuites_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-iterators1_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-udt_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-reference_access_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_lexer_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-capacity_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-json_patch_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-json_pointer_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-class_parser_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-merge_patch_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-iterators2_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-deserialization_all": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-ubjson_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-convenience_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-meta_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "test-deserialization_default": {"run": "PASS", "test": "NONE", "fix": "PASS"}}
{"passed_count": 80, "failed_count": 0, "skipped_count": 0, "passed_tests": ["test-regression_all", "test-element_access2_default", "test-items_all", "test-reference_access_default", "test-comparison_default", "test-class_const_iterator_all", "test-wstring_default", "test-udt_all", "test-class_const_iterator_default", "test-constructor2_default", "test-cbor_all", "test-allocator_default", "test-testsuites_default", "test-to_chars_all", "test-allocator_all", "test-readme_all", "test-pointer_access_default", "test-msgpack_all", "test-regression_default", "test-conversions_default", "test-wstring_all", "test-readme_default", "test-noexcept_default", "test-class_iterator_default", "test-algorithms_default", "test-alt-string_all", "test-alt-string_default", "test-items_default", "test-merge_patch_default", "test-constructor1_default", "test-cbor_default", "test-iterators1_default", "test-udt_default", "test-reference_access_all", "test-capacity_default", "test-meta_default", "test-json_pointer_default", "test-modifiers_all", "test-constructor1_all", "test-class_lexer_default", "test-class_iterator_all", "test-inspection_all", "test-algorithms_all", "test-comparison_all", "test-constructor2_all", "test-meta_all", "test-concepts_all", "test-unicode_default", "test-serialization_all", "test-msgpack_default", "test-convenience_all", "test-class_parser_default", "test-element_access1_all", "test-element_access1_default", "test-inspection_default", "test-unicode_all", "test-conversions_all", "test-noexcept_all", "test-concepts_default", "test-iterators2_all", "test-pointer_access_all", "test-iterators1_all", "test-modifiers_default", "test-json_patch_all", "test-to_chars_default", "test-capacity_all", "test-element_access2_all", "test-ubjson_all", "test-serialization_default", "test-testsuites_all", "test-class_lexer_all", "test-json_patch_default", "test-json_pointer_all", "test-class_parser_all", "test-merge_patch_all", "test-iterators2_default", "test-deserialization_all", "test-ubjson_default", "test-convenience_default", "test-deserialization_default"], "failed_tests": [], "skipped_tests": []}
{"passed_count": 0, "failed_count": 0, "skipped_count": 0, "passed_tests": [], "failed_tests": [], "skipped_tests": []}
{"passed_count": 80, "failed_count": 0, "skipped_count": 0, "passed_tests": ["test-regression_all", "test-element_access2_default", "test-items_all", "test-reference_access_default", "test-comparison_default", "test-class_const_iterator_all", "test-wstring_default", "test-udt_all", "test-class_const_iterator_default", "test-constructor2_default", "test-cbor_all", "test-allocator_default", "test-testsuites_default", "test-to_chars_all", "test-allocator_all", "test-readme_all", "test-pointer_access_default", "test-msgpack_all", "test-regression_default", "test-conversions_default", "test-wstring_all", "test-readme_default", "test-noexcept_default", "test-class_iterator_default", "test-algorithms_default", "test-alt-string_all", "test-alt-string_default", "test-items_default", "test-merge_patch_default", "test-constructor1_default", "test-cbor_default", "test-iterators1_default", "test-udt_default", "test-reference_access_all", "test-capacity_default", "test-meta_default", "test-json_pointer_default", "test-modifiers_all", "test-constructor1_all", "test-class_lexer_default", "test-class_iterator_all", "test-inspection_all", "test-algorithms_all", "test-comparison_all", "test-constructor2_all", "test-meta_all", "test-concepts_all", "test-unicode_default", "test-serialization_all", "test-msgpack_default", "test-convenience_all", "test-class_parser_default", "test-element_access1_all", "test-element_access1_default", "test-inspection_default", "test-unicode_all", "test-conversions_all", "test-noexcept_all", "test-concepts_default", "test-iterators2_all", "test-pointer_access_all", "test-iterators1_all", "test-modifiers_default", "test-json_patch_all", "test-to_chars_default", "test-capacity_all", "test-element_access2_all", "test-ubjson_all", "test-serialization_default", "test-testsuites_all", "test-class_lexer_all", "test-json_patch_default", "test-json_pointer_all", "test-class_parser_all", "test-merge_patch_all", "test-iterators2_default", "test-deserialization_all", "test-ubjson_default", "test-convenience_default", "test-deserialization_default"], "failed_tests": [], "skipped_tests": []}