✅ added more tests

src/json.hpp

@@ -4549,7 +4549,7 @@ class binary_reader
         const auto res = parse_ubjson_internal();
         if (strict)
         {
-            get();
+            get_ignore_noop();
             check_eof(true);
         }
         return res;
@@ -5591,11 +5591,9 @@ class binary_reader
 
         get_ignore_noop();
 
-        switch (current)
+        if (current == '$')
         {
-            case '$':
-            {
-                get_ignore_noop();
+            get();  // must not ignore 'N', because 'N' maybe the type
             check_eof();
             tc = current;
 
@@ -5605,21 +5603,13 @@ class binary_reader
                 assert(false);
             }
             sz = parse_ubjson_internal();
-                break;
         }
-
-            case '#':
+        else if (current == '#')
         {
             sz = parse_ubjson_internal();
-                break;
-            }
-
-            default:
-                break;
         }
 
         return std::make_pair(sz, tc);
-
     }
 
     BasicJsonType get_ubjson_value(const int prefix)
@@ -5656,6 +5646,7 @@ class binary_reader
             {
                 get();
                 check_eof();
+                assert(0 <= current and current <= 127);
                 return std::string(1, static_cast<char>(current));
             }
 
@@ -5683,16 +5674,22 @@ class binary_reader
 
         if (size_and_type.first != std::string::npos)
         {
-            for (std::size_t i = 0; i < size_and_type.first; ++i)
-            {
             if (size_and_type.second != 0)
             {
-                    result.push_back(get_ubjson_value(size_and_type.second));
+                if (size_and_type.second != 'N')
+                    std::generate_n(std::back_inserter(*result.m_value.array),
+                                    size_and_type.first, [this, size_and_type]()
+                {
+                    return get_ubjson_value(size_and_type.second);
+                });
             }
             else
             {
-                    result.push_back(parse_ubjson_internal());
-                }
+                std::generate_n(std::back_inserter(*result.m_value.array),
+                                size_and_type.first, [this]()
+                {
+                    return parse_ubjson_internal();
+                });
             }
         }
         else
@@ -5714,17 +5711,28 @@ class binary_reader
 
         if (size_and_type.first != std::string::npos)
         {
-            for (std::size_t i = 0; i < size_and_type.first; ++i)
-            {
-                auto key = get_ubjson_string();
             if (size_and_type.second != 0)
             {
-                    result[std::move(key)] = get_ubjson_value(size_and_type.second);
+                if (size_and_type.second != 'N')
+                    std::generate_n(std::inserter(*result.m_value.object,
+                                                  result.m_value.object->end()),
+                                    size_and_type.first, [this, size_and_type]()
+                {
+                    auto key = get_ubjson_string();
+                    auto val = get_ubjson_value(size_and_type.second);
+                    return std::make_pair(std::move(key), std::move(val));
+                });
             }
             else
             {
-                    result[std::move(key)] = parse_ubjson_internal();
-                }
+                std::generate_n(std::inserter(*result.m_value.object,
+                                              result.m_value.object->end()),
+                                size_and_type.first, [this]()
+                {
+                    auto key = get_ubjson_string();
+                    auto val = parse_ubjson_internal();
+                    return std::make_pair(std::move(key), std::move(val));
+                });
             }
         }
         else
@@ -6282,10 +6290,8 @@ class binary_writer
     @param[in] use_type    whether to use '$' prefixes (optimized format)
     @param[in] add_prefix  whether prefixes need to be used for this value
     */
-    void write_ubjson(const BasicJsonType& j,
-                      const bool use_count = false,
-                      const bool use_type = false,
-                      const bool add_prefix = true)
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true)
     {
         switch (j.type())
         {
@@ -6348,6 +6354,7 @@ class binary_writer
                 bool prefix_required = true;
                 if (use_type and not j.m_value.array->empty())
                 {
+                    assert(use_count);
                     const char first_prefix = ubjson_prefix(j.front());
                     const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
                                                          [this, first_prefix](const BasicJsonType & v)
@@ -6392,6 +6399,7 @@ class binary_writer
                 bool prefix_required = true;
                 if (use_type and not j.m_value.object->empty())
                 {
+                    assert(use_count);
                     const char first_prefix = ubjson_prefix(j.front());
                     const bool same_prefix = std::all_of(j.begin(), j.end(),
                                                          [this, first_prefix](const BasicJsonType & v)
@@ -6463,7 +6471,8 @@ class binary_writer
     }
 
     template<typename NumberType>
-    void write_number_with_ubjson_prefix(const NumberType n, const bool add_prefix)
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
     {
         if (std::is_floating_point<NumberType>::value)
         {
@@ -6608,23 +6617,23 @@ class binary_writer
 
             case value_t::number_unsigned:
             {
-                if ((std::numeric_limits<int8_t>::min)() <= j.m_value.number_unsigned and j.m_value.number_unsigned <= (std::numeric_limits<int8_t>::max)())
+                if (j.m_value.number_unsigned <= (std::numeric_limits<int8_t>::max)())
                 {
                     return 'i';
                 }
-                else if ((std::numeric_limits<uint8_t>::min)() <= j.m_value.number_unsigned and j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())
                 {
                     return 'U';
                 }
-                else if ((std::numeric_limits<int16_t>::min)() <= j.m_value.number_unsigned and j.m_value.number_unsigned <= (std::numeric_limits<int16_t>::max)())
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<int16_t>::max)())
                 {
                     return 'I';
                 }
-                else if ((std::numeric_limits<int32_t>::min)() <= j.m_value.number_unsigned and j.m_value.number_unsigned <= (std::numeric_limits<int32_t>::max)())
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<int32_t>::max)())
                 {
                     return 'l';
                 }
-                else if ((std::numeric_limits<int64_t>::min)() <= j.m_value.number_unsigned and j.m_value.number_unsigned <= (std::numeric_limits<int64_t>::max)())
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<int64_t>::max)())
                 {
                     return 'L';
                 }
@@ -14103,21 +14112,24 @@ class basic_json
         binary_writer<char>(o).write_msgpack(j);
     }
 
-    static std::vector<uint8_t> to_ubjson(const basic_json& j)
+    static std::vector<uint8_t> to_ubjson(const basic_json& j,
+                                          const bool use_size = false, const bool use_type = false)
     {
         std::vector<uint8_t> result;
-        to_ubjson(j, result);
+        to_ubjson(j, result, use_size, use_type);
         return result;
     }
 
-    static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o)
+    static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
     {
-        binary_writer<uint8_t>(o).write_ubjson(j);
+        binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
     }
 
-    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o)
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
     {
-        binary_writer<char>(o).write_ubjson(j);
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
     }
 
     /*!