Merge pull request #887 from redboltz/impl_886

Added steady_clock and high_resolution_clock support.

include/msgpack/v1/adaptor/cpp11/chrono.hpp

@@ -25,12 +25,13 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace adaptor {
 
-template <>
+namespace detail {
-struct as<std::chrono::system_clock::time_point> {
+
-    typename std::chrono::system_clock::time_point operator()(msgpack::object const& o) const {
+template <typename T>
+typename T::time_point chrono_as(msgpack::object const& o) {
     if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); }
     if(o.via.ext.type() != -1) { throw msgpack::type_error(); }
-        std::chrono::system_clock::time_point tp;
+    typename T::time_point tp;
     switch(o.via.ext.size) {
     case 4: {
         uint32_t sec;
@@ -42,7 +43,7 @@ struct as<std::chrono::system_clock::time_point> {
         _msgpack_load64(uint64_t, o.via.ext.data(), &value);
         uint32_t nanosec = static_cast<uint32_t>(value >> 34);
         uint64_t sec = value & 0x00000003ffffffffLL;
-            tp += std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        tp += std::chrono::duration_cast<typename T::duration>(
             std::chrono::nanoseconds(nanosec));
         tp += std::chrono::seconds(sec);
     } break;
@@ -51,7 +52,7 @@ struct as<std::chrono::system_clock::time_point> {
         _msgpack_load32(uint32_t, o.via.ext.data(), &nanosec);
         int64_t sec;
         _msgpack_load64(int64_t, o.via.ext.data() + 4, &sec);
-            tp += std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        tp += std::chrono::duration_cast<typename T::duration>(
             std::chrono::nanoseconds(nanosec));
         tp += std::chrono::seconds(sec);
     } break;
@@ -60,14 +61,12 @@ struct as<std::chrono::system_clock::time_point> {
     }
     return tp;
 }
-};
 
-template <>
+template <typename T>
-struct convert<std::chrono::system_clock::time_point> {
+msgpack::object const& chrono_convert(msgpack::object const& o, typename T::time_point& v) {
-    msgpack::object const& operator()(msgpack::object const& o, std::chrono::system_clock::time_point& v) const {
     if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); }
     if(o.via.ext.type() != -1) { throw msgpack::type_error(); }
-        std::chrono::system_clock::time_point tp;
+    typename T::time_point tp;
     switch(o.via.ext.size) {
     case 4: {
         uint32_t sec;
@@ -80,7 +79,7 @@ struct convert<std::chrono::system_clock::time_point> {
         _msgpack_load64(uint64_t, o.via.ext.data(), &value);
         uint32_t nanosec = static_cast<uint32_t>(value >> 34);
         uint64_t sec = value & 0x00000003ffffffffLL;
-            tp += std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        tp += std::chrono::duration_cast<typename T::duration>(
             std::chrono::nanoseconds(nanosec));
         tp += std::chrono::seconds(sec);
         v = tp;
@@ -90,7 +89,7 @@ struct convert<std::chrono::system_clock::time_point> {
         _msgpack_load32(uint32_t, o.via.ext.data(), &nanosec);
         int64_t sec;
         _msgpack_load64(int64_t, o.via.ext.data() + 4, &sec);
-            tp += std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        tp += std::chrono::duration_cast<typename T::duration>(
             std::chrono::nanoseconds(nanosec));
         tp += std::chrono::seconds(sec);
         v = tp;
@@ -100,17 +99,14 @@ struct convert<std::chrono::system_clock::time_point> {
     }
     return o;
 }
-};
 
-template <>
+template <typename T, typename Stream>
-struct pack<std::chrono::system_clock::time_point> {
+msgpack::packer<Stream>& chrono_pack(msgpack::packer<Stream>& o, const typename T::time_point& v) {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::chrono::system_clock::time_point& v) const {
     int64_t count = static_cast<int64_t>(v.time_since_epoch().count());
 
     int64_t nano_num =
-            std::chrono::system_clock::duration::period::ratio::num *
+        T::duration::period::ratio::num *
-            (1000000000 / std::chrono::system_clock::duration::period::ratio::den);
+        (1000000000 / T::duration::period::ratio::den);
 
     int64_t nanosec = count % (1000000000 / nano_num) * nano_num;
     int64_t sec = 0;
@@ -119,8 +115,8 @@ struct pack<std::chrono::system_clock::time_point> {
         --sec;
     }
     sec += count
-            * std::chrono::system_clock::duration::period::ratio::num
+        * T::duration::period::ratio::num
-            / std::chrono::system_clock::duration::period::ratio::den;
+        / T::duration::period::ratio::den;
     if ((sec >> 34) == 0) {
         uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec);
         if ((data64 & 0xffffffff00000000L) == 0) {
@@ -149,16 +145,14 @@ struct pack<std::chrono::system_clock::time_point> {
     }
     return o;
 }
-};
 
-template <>
+template <typename T>
-struct object_with_zone<std::chrono::system_clock::time_point> {
+void chrono_object_with_zone(msgpack::object::with_zone& o, const typename T::time_point& v) {
-    void operator()(msgpack::object::with_zone& o, const std::chrono::system_clock::time_point& v) const {
     int64_t count = static_cast<int64_t>(v.time_since_epoch().count());
 
     int64_t nano_num =
-            std::chrono::system_clock::duration::period::ratio::num *
+        T::duration::period::ratio::num *
-            (1000000000 / std::chrono::system_clock::duration::period::ratio::den);
+        (1000000000 / T::duration::period::ratio::den);
 
     int64_t nanosec = count % (1000000000 / nano_num) * nano_num;
     int64_t sec = 0;
@@ -167,8 +161,8 @@ struct object_with_zone<std::chrono::system_clock::time_point> {
         --sec;
     }
     sec += count
-            * std::chrono::system_clock::duration::period::ratio::num
+        * T::duration::period::ratio::num
-            / std::chrono::system_clock::duration::period::ratio::den;
+        / T::duration::period::ratio::den;
     if ((sec >> 34) == 0) {
         uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec);
         if ((data64 & 0xffffffff00000000L) == 0) {
@@ -202,6 +196,128 @@ struct object_with_zone<std::chrono::system_clock::time_point> {
         o.via.ext.ptr = p;
     }
 }
+
+} // namespace detail
+
+template <>
+struct as<std::chrono::system_clock::time_point> {
+    typename std::chrono::system_clock::time_point operator()(msgpack::object const& o) const {
+        return detail::chrono_as<std::chrono::system_clock>(o);
+    }
+};
+
+template <>
+struct convert<std::chrono::system_clock::time_point> {
+    msgpack::object const& operator()(msgpack::object const& o, std::chrono::system_clock::time_point& v) const {
+        return detail::chrono_convert<std::chrono::system_clock>(o, v);
+    }
+};
+
+template <>
+struct pack<std::chrono::system_clock::time_point> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::chrono::system_clock::time_point& v) const {
+        return detail::chrono_pack<std::chrono::system_clock>(o, v);
+    }
+};
+
+template <>
+struct object_with_zone<std::chrono::system_clock::time_point> {
+    void operator()(msgpack::object::with_zone& o, const std::chrono::system_clock::time_point& v) const {
+        detail::chrono_object_with_zone<std::chrono::system_clock>(o, v);
+    }
+};
+
+
+template <>
+struct as<std::chrono::steady_clock::time_point> {
+    typename std::chrono::steady_clock::time_point operator()(msgpack::object const& o) const {
+        return detail::chrono_as<std::chrono::steady_clock>(o);
+    }
+};
+
+template <>
+struct convert<std::chrono::steady_clock::time_point> {
+    msgpack::object const& operator()(msgpack::object const& o, std::chrono::steady_clock::time_point& v) const {
+        return detail::chrono_convert<std::chrono::steady_clock>(o, v);
+    }
+};
+
+template <>
+struct pack<std::chrono::steady_clock::time_point> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::chrono::steady_clock::time_point& v) const {
+        return detail::chrono_pack<std::chrono::steady_clock>(o, v);
+    }
+};
+
+template <>
+struct object_with_zone<std::chrono::steady_clock::time_point> {
+    void operator()(msgpack::object::with_zone& o, const std::chrono::steady_clock::time_point& v) const {
+        detail::chrono_object_with_zone<std::chrono::steady_clock>(o, v);
+    }
+};
+
+
+template <>
+struct as<
+    std::chrono::high_resolution_clock::time_point,
+    typename std::conditional<
+        !std::is_same<std::chrono::high_resolution_clock, std::chrono::system_clock>::value &&
+        !std::is_same<std::chrono::high_resolution_clock, std::chrono::steady_clock>::value,
+        void,
+        std::nullptr_t
+    >::type
+> {
+    typename std::chrono::high_resolution_clock::time_point operator()(msgpack::object const& o) const {
+        return detail::chrono_as<std::chrono::high_resolution_clock>(o);
+    }
+};
+
+template <>
+struct convert<
+    std::chrono::high_resolution_clock::time_point,
+    typename std::conditional<
+        !std::is_same<std::chrono::high_resolution_clock, std::chrono::system_clock>::value &&
+        !std::is_same<std::chrono::high_resolution_clock, std::chrono::steady_clock>::value,
+        void,
+        std::nullptr_t
+    >::type
+> {
+    msgpack::object const& operator()(msgpack::object const& o, std::chrono::high_resolution_clock::time_point& v) const {
+        return detail::chrono_convert<std::chrono::high_resolution_clock>(o, v);
+    }
+};
+
+template <>
+struct pack<
+    std::chrono::high_resolution_clock::time_point,
+    typename std::conditional<
+        !std::is_same<std::chrono::high_resolution_clock, std::chrono::system_clock>::value &&
+        !std::is_same<std::chrono::high_resolution_clock, std::chrono::steady_clock>::value,
+        void,
+        std::nullptr_t
+    >::type
+> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::chrono::high_resolution_clock::time_point& v) const {
+        return detail::chrono_pack<std::chrono::high_resolution_clock>(o, v);
+    }
+};
+
+template <>
+struct object_with_zone<
+    std::chrono::high_resolution_clock::time_point,
+    typename std::conditional<
+        !std::is_same<std::chrono::high_resolution_clock, std::chrono::system_clock>::value &&
+        !std::is_same<std::chrono::high_resolution_clock, std::chrono::steady_clock>::value,
+        void,
+        std::nullptr_t
+    >::type
+> {
+    void operator()(msgpack::object::with_zone& o, const std::chrono::high_resolution_clock::time_point& v) const {
+        detail::chrono_object_with_zone<std::chrono::high_resolution_clock>(o, v);
+    }
 };
 
 } // namespace adaptor

test/msgpack_cpp11.cpp

@@ -1053,6 +1053,385 @@ TEST(MSGPACK_CHRONO, system_clock_impl_now)
     EXPECT_EQ(val1, val3);
 }
 
+
+TEST(MSGPACK_CHRONO, steady_clock)
+{
+    std::chrono::steady_clock::time_point val1;
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::steady_clock::time_point val2 = oh.get().as<std::chrono::steady_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::steady_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, steady_clock_32)
+{
+    std::chrono::steady_clock::time_point val1(std::chrono::seconds(0x12345678L));
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    char packed[] = {
+        static_cast<char>(0xd6u),
+        static_cast<char>(-1),
+        static_cast<char>(0x12),
+        static_cast<char>(0x34),
+        static_cast<char>(0x56),
+        static_cast<char>(0x78)
+    };
+    EXPECT_EQ(memcmp(sbuf.data(), packed, sizeof(packed)), 0);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::steady_clock::time_point val2 = oh.get().as<std::chrono::steady_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::steady_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, steady_clock_32_max)
+{
+    std::chrono::steady_clock::time_point val1(std::chrono::seconds(0xffffffffL));
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    char packed[] = {
+        static_cast<char>(0xd6u),
+        static_cast<char>(-1),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu)
+    };
+    EXPECT_EQ(memcmp(sbuf.data(), packed, sizeof(packed)), 0);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::steady_clock::time_point val2 = oh.get().as<std::chrono::steady_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::steady_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+
+TEST(MSGPACK_CHRONO, steady_clock_64)
+{
+    std::chrono::steady_clock::time_point val1(std::chrono::seconds(0x31234567L));
+    val1 +=
+        std::chrono::duration_cast<std::chrono::steady_clock::duration>(
+            std::chrono::nanoseconds(0x312345678L)
+        );
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::steady_clock::time_point val2 = oh.get().as<std::chrono::steady_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::steady_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, steady_clock_64_max)
+{
+    std::chrono::steady_clock::time_point val1(std::chrono::seconds(0xffffffffL));
+
+    val1 +=
+        std::chrono::duration_cast<std::chrono::steady_clock::duration>(
+            std::chrono::nanoseconds(0x3b9ac9ffL) // 999,999,999
+        );
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    char packed_nano[] = {
+        static_cast<char>(0xd7u),
+        static_cast<char>(-1),
+        static_cast<char>(0xeeu), // 999,999,999 << 2
+        static_cast<char>(0x6b),
+        static_cast<char>(0x27),
+        static_cast<char>(0xfcu),
+        static_cast<char>(0xffu), // 32 bit sec
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu)
+    };
+    char packed_micro[] = {
+        static_cast<char>(0xd7u),
+        static_cast<char>(-1),
+        static_cast<char>(0xeeu), // 999,999,000 << 2
+        static_cast<char>(0x6b),
+        static_cast<char>(0x18),
+        static_cast<char>(0x60),
+        static_cast<char>(0xffu), // 32 bit sec
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu)
+    };
+    if (std::chrono::steady_clock::duration::period::ratio::den == 1000000000) {
+        EXPECT_EQ(memcmp(sbuf.data(), packed_nano, sizeof(packed_nano)), 0);
+    }
+    else if (std::chrono::steady_clock::duration::period::ratio::den == 1000000) {
+        EXPECT_EQ(memcmp(sbuf.data(), packed_micro, sizeof(packed_micro)), 0);
+    }
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::steady_clock::time_point val2 = oh.get().as<std::chrono::steady_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::steady_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, steady_clock_impl_min)
+{
+    std::chrono::steady_clock::time_point val1(std::chrono::steady_clock::time_point::min());
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::steady_clock::time_point val2 = oh.get().as<std::chrono::steady_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::steady_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, steady_clock_impl_max)
+{
+    std::chrono::steady_clock::time_point val1(std::chrono::steady_clock::time_point::max());
+
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::steady_clock::time_point val2 = oh.get().as<std::chrono::steady_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::steady_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, steady_clock_impl_now)
+{
+    std::chrono::steady_clock::time_point val1(std::chrono::steady_clock::now());
+
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::steady_clock::time_point val2 = oh.get().as<std::chrono::steady_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::steady_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+
+TEST(MSGPACK_CHRONO, high_resolution_clock)
+{
+    std::chrono::high_resolution_clock::time_point val1;
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::high_resolution_clock::time_point val2 = oh.get().as<std::chrono::high_resolution_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::high_resolution_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, high_resolution_clock_32)
+{
+    std::chrono::high_resolution_clock::time_point val1(std::chrono::seconds(0x12345678L));
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    char packed[] = {
+        static_cast<char>(0xd6u),
+        static_cast<char>(-1),
+        static_cast<char>(0x12),
+        static_cast<char>(0x34),
+        static_cast<char>(0x56),
+        static_cast<char>(0x78)
+    };
+    EXPECT_EQ(memcmp(sbuf.data(), packed, sizeof(packed)), 0);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::high_resolution_clock::time_point val2 = oh.get().as<std::chrono::high_resolution_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::high_resolution_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, high_resolution_clock_32_max)
+{
+    std::chrono::high_resolution_clock::time_point val1(std::chrono::seconds(0xffffffffL));
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    char packed[] = {
+        static_cast<char>(0xd6u),
+        static_cast<char>(-1),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu)
+    };
+    EXPECT_EQ(memcmp(sbuf.data(), packed, sizeof(packed)), 0);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::high_resolution_clock::time_point val2 = oh.get().as<std::chrono::high_resolution_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::high_resolution_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+
+TEST(MSGPACK_CHRONO, high_resolution_clock_64)
+{
+    std::chrono::high_resolution_clock::time_point val1(std::chrono::seconds(0x31234567L));
+    val1 +=
+        std::chrono::duration_cast<std::chrono::high_resolution_clock::duration>(
+            std::chrono::nanoseconds(0x312345678L)
+        );
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::high_resolution_clock::time_point val2 = oh.get().as<std::chrono::high_resolution_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::high_resolution_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, high_resolution_clock_64_max)
+{
+    std::chrono::high_resolution_clock::time_point val1(std::chrono::seconds(0xffffffffL));
+
+    val1 +=
+        std::chrono::duration_cast<std::chrono::high_resolution_clock::duration>(
+            std::chrono::nanoseconds(0x3b9ac9ffL) // 999,999,999
+        );
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    char packed_nano[] = {
+        static_cast<char>(0xd7u),
+        static_cast<char>(-1),
+        static_cast<char>(0xeeu), // 999,999,999 << 2
+        static_cast<char>(0x6b),
+        static_cast<char>(0x27),
+        static_cast<char>(0xfcu),
+        static_cast<char>(0xffu), // 32 bit sec
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu)
+    };
+    char packed_micro[] = {
+        static_cast<char>(0xd7u),
+        static_cast<char>(-1),
+        static_cast<char>(0xeeu), // 999,999,000 << 2
+        static_cast<char>(0x6b),
+        static_cast<char>(0x18),
+        static_cast<char>(0x60),
+        static_cast<char>(0xffu), // 32 bit sec
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu),
+        static_cast<char>(0xffu)
+    };
+    if (std::chrono::high_resolution_clock::duration::period::ratio::den == 1000000000) {
+        EXPECT_EQ(memcmp(sbuf.data(), packed_nano, sizeof(packed_nano)), 0);
+    }
+    else if (std::chrono::high_resolution_clock::duration::period::ratio::den == 1000000) {
+        EXPECT_EQ(memcmp(sbuf.data(), packed_micro, sizeof(packed_micro)), 0);
+    }
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::high_resolution_clock::time_point val2 = oh.get().as<std::chrono::high_resolution_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::high_resolution_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, high_resolution_clock_impl_min)
+{
+    std::chrono::high_resolution_clock::time_point val1(std::chrono::high_resolution_clock::time_point::min());
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::high_resolution_clock::time_point val2 = oh.get().as<std::chrono::high_resolution_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::high_resolution_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, high_resolution_clock_impl_max)
+{
+    std::chrono::high_resolution_clock::time_point val1(std::chrono::high_resolution_clock::time_point::max());
+
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::high_resolution_clock::time_point val2 = oh.get().as<std::chrono::high_resolution_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::high_resolution_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+TEST(MSGPACK_CHRONO, high_resolution_clock_impl_now)
+{
+    std::chrono::high_resolution_clock::time_point val1(std::chrono::high_resolution_clock::now());
+
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::chrono::high_resolution_clock::time_point val2 = oh.get().as<std::chrono::high_resolution_clock::time_point>();
+    EXPECT_EQ(val1, val2);
+
+    std::chrono::high_resolution_clock::time_point val3;
+    oh.get().convert(val3);
+    EXPECT_EQ(val1, val3);
+}
+
+
 TEST(MSGPACK_TIMESPEC, timespec_pack_convert_zero)
 {
     std::stringstream ss;