script_core 0.1.1 → 0.2.0

data/ext/enterprise_script_service/msgpack/test/msgpack_cpp11.cpp

@@ -1,7 +1,12 @@
 #include <msgpack.hpp>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -1044,4 +1049,158 @@ TEST(MSGPACK_CHRONO, system_clock_impl_now)
     EXPECT_EQ(val1, val3);
 }
 
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_zero)
+{
+    std::stringstream ss;
+    timespec val1{ 0, 0 };
+
+    msgpack::pack(ss, val1);
+    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd6));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_zero)
+{
+    msgpack::zone z;
+    timespec val1{ 0, 0 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_32bit_sec)
+{
+    std::stringstream ss;
+    timespec val1{ 0xffffffffUL, 0 };
+
+    msgpack::pack(ss, val1);
+    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd6));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_32bit_sec)
+{
+    msgpack::zone z;
+    timespec val1{ 0xffffffffUL, 0 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_max_nano)
+{
+    std::stringstream ss;
+    timespec val1{ 0, 999999999 };
+
+    msgpack::pack(ss, val1);
+    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd7));
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_max_nano)
+{
+    msgpack::zone z;
+    timespec val1{ 0, 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_34bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    std::stringstream ss;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x3ffffffffULL), 999999999 };
+
+    msgpack::pack(ss, val1);
+    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd7));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_34bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    msgpack::zone z;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x3ffffffffULL), 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_35bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    std::stringstream ss;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x7ffffffffULL), 999999999 };
+
+    msgpack::pack(ss, val1);
+    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xc7));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_35bit_sec_max_nano)
+{
+    if (sizeof(decltype(std::declval<timespec>().tv_sec)) <= 4) return;
+    msgpack::zone z;
+    timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x7ffffffffULL), 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_pack_convert_64bit_sec_max_nano)
+{
+    std::stringstream ss;
+    timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::max(), 999999999 };
+
+    msgpack::pack(ss, val1);
+    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xc7));
+
+    msgpack::object_handle oh;
+    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    timespec val2 = oh.get().as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+TEST(MSGPACK_TIMESPEC, timespec_object_with_zone_64bit_sec_max_nano)
+{
+    msgpack::zone z;
+    timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::max(), 999999999 };
+    msgpack::object obj(val1, z);
+    timespec val2 = obj.as<timespec>();
+    EXPECT_EQ(val1.tv_sec, val2.tv_sec);
+    EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
+}
+
+
 #endif // !defined(MSGPACK_USE_CPP03)

data/ext/enterprise_script_service/msgpack/test/msgpack_cpp17.cpp

@@ -1,7 +1,12 @@
 #include <msgpack.hpp>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif

data/ext/enterprise_script_service/msgpack/test/msgpack_stream.cpp

@@ -9,8 +9,13 @@
 #include <list>
 #include <limits>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -26,8 +31,8 @@ const unsigned int kLoop = 1000;
         msgpack::packer<msgpack::sbuffer> pk(sbuf);                     \
         typedef std::vector<test_type> vec_type;                        \
         vec_type vec;                                                   \
-        for(unsigned int i = 0; i < rand() % kLoop; ++i) {              \
-            vec_type::value_type r = rand();                            \
+        for(unsigned int i = 0; i < static_cast<unsigned int>(rand()) % kLoop; ++i) { \
+            vec_type::value_type r = static_cast<test_type>(rand());    \
             vec.push_back(r);                                           \
             pk.pack(r);                                                 \
         }                                                               \
@@ -36,7 +41,7 @@ const unsigned int kLoop = 1000;
         const char *p = sbuf.data();                                    \
         const char * const pend = p + sbuf.size();                      \
         while (p < pend) {                                              \
-            const size_t sz = std::min<size_t>(pend - p, rand() % 128); \
+            const size_t sz = std::min<size_t>(static_cast<std::size_t>(pend - p), static_cast<std::size_t>(rand() % 128)); \
             pac.reserve_buffer(sz);                                     \
             memcpy(pac.buffer(), p, sz);                                \
             pac.buffer_consumed(sz);                                    \

data/ext/enterprise_script_service/msgpack/test/msgpack_tuple.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 
 TEST(msgpack_tuple, member_get)
 {

data/ext/enterprise_script_service/msgpack/test/msgpack_vref.cpp

@@ -9,8 +9,13 @@
 #include <list>
 #include <limits>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif

data/ext/enterprise_script_service/msgpack/test/msgpack_x3_parse.cpp

@@ -4,8 +4,13 @@
 #include <limits>
 #include <cmath>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 // To avoid link error
 TEST(MSGPACK_X3_PARSE, dummy)
 {
@@ -169,7 +174,7 @@ TEST(MSGPACK_X3_PARSE, uint64_2)
 
 TEST(MSGPACK_X3_PARSE, int8_1)
 {
-    int8_t v = 0b11011111;
+    int8_t v = static_cast<int8_t>(0b11011111);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -179,7 +184,7 @@ TEST(MSGPACK_X3_PARSE, int8_1)
 
 TEST(MSGPACK_X3_PARSE, int8_2)
 {
-    int8_t v = 0b10000000;
+    int8_t v = static_cast<int8_t>(0b10000000);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -189,7 +194,7 @@ TEST(MSGPACK_X3_PARSE, int8_2)
 
 TEST(MSGPACK_X3_PARSE, int16_1)
 {
-    int16_t v = 0xff00;
+    int16_t v = static_cast<int16_t>(0xff00);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -199,7 +204,7 @@ TEST(MSGPACK_X3_PARSE, int16_1)
 
 TEST(MSGPACK_X3_PARSE, int16_2)
 {
-    int16_t v = 0x8000;
+    int16_t v = static_cast<int16_t>(0x8000);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -209,7 +214,7 @@ TEST(MSGPACK_X3_PARSE, int16_2)
 
 TEST(MSGPACK_X3_PARSE, int32_1)
 {
-    int32_t v = 0xff000000L;
+    int32_t v = static_cast<int32_t>(0xff000000L);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -219,7 +224,7 @@ TEST(MSGPACK_X3_PARSE, int32_1)
 
 TEST(MSGPACK_X3_PARSE, int32_2)
 {
-    int32_t v = 0x80000000L;
+    int32_t v = static_cast<int32_t>(0x80000000L);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -229,7 +234,7 @@ TEST(MSGPACK_X3_PARSE, int32_2)
 
 TEST(MSGPACK_X3_PARSE, int64_1)
 {
-    int64_t v = 0xff00000000000000LL;
+    int64_t v = static_cast<int64_t>(0xff00000000000000LL);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -239,7 +244,7 @@ TEST(MSGPACK_X3_PARSE, int64_1)
 
 TEST(MSGPACK_X3_PARSE, int64_2)
 {
-    int64_t v = 0x8000000000000000LL;
+    int64_t v = static_cast<int64_t>(0x8000000000000000LL);
     std::stringstream ss;
     msgpack::pack(ss, v);
 
@@ -445,7 +450,7 @@ TEST(MSGPACK_X3_PARSE, string_2)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -458,7 +463,7 @@ TEST(MSGPACK_X3_PARSE, string_3)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -471,7 +476,7 @@ TEST(MSGPACK_X3_PARSE, string_4)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -484,7 +489,7 @@ TEST(MSGPACK_X3_PARSE, string_5)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -497,7 +502,7 @@ TEST(MSGPACK_X3_PARSE, string_6)
 {
     std::string v;
 
-    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back('0'+(i%10));
+    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(static_cast<char>('0'+(i%10)));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -520,7 +525,7 @@ TEST(MSGPACK_X3_PARSE, bin_2)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -533,7 +538,7 @@ TEST(MSGPACK_X3_PARSE, bin_3)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -546,7 +551,7 @@ TEST(MSGPACK_X3_PARSE, bin_4)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -559,7 +564,7 @@ TEST(MSGPACK_X3_PARSE, bin_5)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);
@@ -572,7 +577,7 @@ TEST(MSGPACK_X3_PARSE, bin_6)
 {
     std::vector<char> v;
 
-    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(i%0xff);
+    for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(static_cast<char>(i%0xff));
 
     std::stringstream ss;
     msgpack::pack(ss, v);

data/ext/enterprise_script_service/msgpack/test/object.cpp

@@ -1,6 +1,12 @@
 #include <msgpack.hpp>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+
 #include <gtest/gtest.h>
 
+#pragma GCC diagnostic pop
+
 
 enum enum_test {
     elem
@@ -361,67 +367,93 @@ TEST(object, clone_int)
 
 TEST(object, clone_str)
 {
-    msgpack::zone z;
+    msgpack::object_handle oh;
     std::string v = "123456789";
-    msgpack::object obj(v, z);
-    std::size_t sz1 = msgpack::aligned_zone_size(obj);
-    msgpack::object_handle h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
-    h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    {
+        msgpack::zone z;
+        msgpack::object obj(v, z);
+        std::size_t sz1 = msgpack::aligned_zone_size(obj);
+        msgpack::object_handle h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        oh = msgpack::move(h);
+    }
+    EXPECT_EQ(v, oh.get().as<std::string>());
 }
 
 TEST(object, clone_bin)
 {
-    msgpack::zone z;
+    msgpack::object_handle oh;
     std::vector<char> v;
-    v.push_back('A');
-    v.push_back('B');
-    v.push_back('C');
-    msgpack::object obj(v, z);
-    std::size_t sz1 = msgpack::aligned_zone_size(obj);
-    msgpack::object_handle h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
-    h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    {
+        msgpack::zone z;
+        v.push_back('A');
+        v.push_back('B');
+        v.push_back('C');
+        msgpack::object obj(v, z);
+        std::size_t sz1 = msgpack::aligned_zone_size(obj);
+        msgpack::object_handle h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        oh = msgpack::move(h);
+    }
+    std::vector<char> v2 = oh.get().as<std::vector<char> >();
+    EXPECT_EQ(v.size(), v2.size());
+    EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
 }
 
 TEST(object, clone_array)
 {
-    msgpack::zone z;
+    msgpack::object_handle oh;
     std::vector<int> v;
-    v.push_back(1);
-    v.push_back(2);
-    v.push_back(3);
-    msgpack::object obj(v, z);
-    std::size_t sz1 = msgpack::aligned_zone_size(obj);
-    msgpack::object_handle h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
-    h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    {
+        msgpack::zone z;
+        v.push_back(1);
+        v.push_back(2);
+        v.push_back(3);
+        msgpack::object obj(v, z);
+        std::size_t sz1 = msgpack::aligned_zone_size(obj);
+        msgpack::object_handle h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        oh = msgpack::move(h);
+    }
+    std::vector<int> v2 = oh.get().as<std::vector<int> >();
+    EXPECT_EQ(v.size(), v2.size());
+    EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
 }
 
 TEST(object, clone_map)
 {
-    msgpack::zone z;
+    msgpack::object_handle oh;
     std::map<int, std::string> v;
-    v.insert(std::map<int, std::string>::value_type(1, "ABC"));
-    v.insert(std::map<int, std::string>::value_type(2, "DEF"));
-    v.insert(std::map<int, std::string>::value_type(3, "GHI"));
-    msgpack::object obj(v, z);
-    std::size_t sz1 = msgpack::aligned_zone_size(obj);
-    msgpack::object_handle h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
-    h = msgpack::clone(obj);
-    EXPECT_EQ(h.get(), obj);
-    EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+    {
+        msgpack::zone z;
+        v.insert(std::map<int, std::string>::value_type(1, "ABC"));
+        v.insert(std::map<int, std::string>::value_type(2, "DEF"));
+        v.insert(std::map<int, std::string>::value_type(3, "GHI"));
+        msgpack::object obj(v, z);
+        std::size_t sz1 = msgpack::aligned_zone_size(obj);
+        msgpack::object_handle h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        h = msgpack::clone(obj);
+        EXPECT_EQ(h.get(), obj);
+        EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
+        oh = msgpack::move(h);
+    }
+    std::map<int, std::string> v2 = oh.get().as<std::map<int, std::string> >();
+    EXPECT_EQ(v.size(), v2.size());
+    EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
 }
 
 TEST(object, pack_float)