increase serialization coverage

Author: grisumbras

test/serializer.cpp

@@ -17,6 +17,7 @@
 #include <iostream>
 #include <map>
 #include <vector>
+#include <limits.h>
 
 #include "parse-vectors.hpp"
 #include "test.hpp"
@@ -90,20 +91,57 @@ class serializer_test
         }
     }
 
+    template<class T>
+    void
+    grind_one(string_view s, T const& t, string_view name = {})
+    {
+        {
+            auto const s1 = serialize(t);
+            if( !BOOST_TEST(s == s1) )
+            {
+                if(name.empty())
+                    log <<
+                        " " << s << "\n"
+                        " " << s1 <<
+                        std::endl;
+                else
+                    log << name << ":\n"
+                        " " << s << "\n"
+                        " " << s1 <<
+                        std::endl;
+            }
+        }
+
+        // large buffer
+        {
+            error_code ec;
+            serializer sr;
+            sr.reset(&t);
+            string js;
+            js.reserve(4096);
+            js.grow(sr.read(
+                js.data(), js.capacity()).size());
+
+            auto const s1 = serialize(t);
+            BOOST_TEST( s == s1 );
+        }
+    }
+
+    template<class T>
     void
     grind(
         string_view s0,
-        value const& jv,
+        T const& t,
         string_view name = {})
     {
-        grind_one(s0, jv, name);
+        grind_one(s0, t, name);
 
-        auto const s1 = serialize(jv);
+        auto const s1 = serialize(t);
         for(std::size_t i = 1;
             i < s1.size(); ++i)
         {
             serializer sr;
-            sr.reset(&jv);
+            sr.reset(&t);
             string s2;
             s2.reserve(s1.size());
             s2.grow(sr.read(
@@ -143,6 +181,18 @@ class serializer_test
                 break;
             }
         }
+        {
+            string s2;
+            s2.reserve( s1.size() );
+            serializer sr;
+            sr.reset(&t);
+            for(std::size_t i = 0; i < s1.size(); ++i)
+            {
+                BOOST_TEST( sr.read(s2.data() + i, 1).size() == 1 );
+                s2.grow(1);
+            }
+            BOOST_TEST(s2 == s1);
+        }
     }
 
     //------------------------------------------------------
@@ -500,6 +550,23 @@ class serializer_test
         }
     }
 
+    template<class T>
+    void
+    check_udt(
+        T const& t,
+        string_view s,
+        string_view name = {})
+    {
+        try
+        {
+            grind(s, t, name);
+        }
+        catch(std::exception const&)
+        {
+            BOOST_TEST_FAIL();
+        }
+    }
+
     void
     testVectors()
     {
@@ -682,35 +749,43 @@ class serializer_test
     testUDT()
     {
         {
-            std::vector<int> v{1, 2, 3};
+            std::uint64_t u = 1;
+            check_udt(u, "1");
 
-            serializer sr;
-            sr.reset(&v);
+            u = std::numeric_limits<std::int64_t>::max();
+            u += 1;
+            check_udt(u, "9223372036854775808");
 
-            char buf[32];
-            BOOST_TEST( sr.read(buf) == "[1,2,3]" );
+            std::int64_t i = -1;
+            check_udt(i, "-1");
+
+            double d = 3.12;
+            check_udt(d, "3.12E0");
+
+#ifdef BOOST_HAS_INT128
+            boost::int128_type ii = std::numeric_limits<std::uint64_t>::max();
+            ii += 1;
+            d = ii;
+            check_udt( ii, serialize(value(d)) );
+
+            ii = std::numeric_limits<std::int64_t>::min();
+            ii -= 1;
+            d = ii;
+            check_udt( ii, serialize(value(d)) );
+#endif
+        }
+        {
+            std::vector<int> v{1, 2, 3};
+            check_udt(v, "[1,2,3]");
         }
         {
             std::vector<double> v{3.5, -14, 7711.1};
-
-            serializer sr;
-            sr.reset(&v);
-
-            char buf[32];
-            BOOST_TEST( sr.read(buf) == "[3.5E0,-1.4E1,7.7111E3]" );
+            check_udt(v, "[3.5E0,-1.4E1,7.7111E3]");
         }
         {
             std::map<std::string, int> m{
                 {"one", 1}, {"two", 2}, {"three", 3} };
-
-            serializer sr;
-            sr.reset(&m);
-
-            char buf[32];
-            string_view output = sr.read(buf);
-            BOOST_TEST((
-                parse(output) ==
-                value{ {"one", 1}, {"two", 2}, {"three", 3} } ));
+            check_udt( m, R"({"one":1,"three":3,"two":2})" );
         }
     }