Unified variant and variant_ref to basic_variant.

Added is_* and as_* member functions to basic_variant.
Added tests.

example/boost/msgpack_variant_mapbased.cpp

@@ -35,9 +35,9 @@ struct proc:boost::static_visitor<void> {
         std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::iterator it = v.begin();
         std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref>::iterator end = v.end();
         while(it != end) {
-            boost::string_ref const& key = boost::get<boost::string_ref>(it->first);
+            boost::string_ref const& key = it->first.as_boost_string_ref();
             if (key == "name") {
-                boost::string_ref const& value = boost::get<boost::string_ref>(it->second);
+                boost::string_ref const& value = it->second.as_boost_string_ref();
                 if (value == "Takatoshi Kondo") {
                     // You can add values to msgpack::type::variant_ref.
                     v.insert(
@@ -67,7 +67,7 @@ struct proc:boost::static_visitor<void> {
                 // "Tokyo" -> "Tokyo, JAPAN"
                 // Use msgpack::type::variant instead of msgpack::type::variant_ref
                 // or do as follows:
-                boost::string_ref const& value = boost::get<boost::string_ref>(it->second);
+                boost::string_ref const& value = it->second.as_boost_string_ref();
                 it->second = std::string(&value.front(), value.size()) + ", JAPAN";
                 ++it;
             }

include/msgpack/adaptor/boost/msgpack_variant.hpp

@@ -47,10 +47,10 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace type {
 
-struct variant;
 
-namespace detail {
+template <typename STR, typename BIN, typename EXT>
-typedef boost::variant<
+struct basic_variant :
+    boost::variant<
         nil,               // NIL
         bool,              // BOOL
         int64_t,           // NEGATIVE_INTEGER
@@ -64,63 +64,12 @@ typedef boost::variant<
         msgpack::type::raw_ref, // BIN
         ext,               // EXT
         ext_ref,           // EXT
-    boost::recursive_wrapper<std::vector<variant> >, // ARRAY
+        boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY
-    boost::recursive_wrapper<std::map<variant, variant> >, // MAP
+        boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP
-    boost::recursive_wrapper<std::multimap<variant, variant> >// MAP
+        boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP
-> variant_imp;
+    >,
-
+    private boost::totally_ordered<basic_variant<STR, BIN, EXT> > {
-} // namespace detail
+    typedef boost::variant<
-
-struct variant : detail::variant_imp, private boost::totally_ordered<variant> {
-    typedef detail::variant_imp base;
-    variant() {}
-    template <typename T>
-    variant(T const& t):base(t) {}
-    variant(char const* p):base(std::string(p)) {}
-    variant(char v) {
-        int_init(v);
-    }
-    variant(signed char v) {
-        int_init(v);
-    }
-    variant(unsigned char v):base(uint64_t(v)) {}
-    variant(signed int v) {
-        int_init(v);
-    }
-    variant(unsigned int v):base(uint64_t(v)) {}
-    variant(signed long v) {
-        int_init(v);
-    }
-    variant(unsigned long v):base(uint64_t(v)) {}
-    variant(signed long long v) {
-        int_init(v);
-    }
-    variant(unsigned long long v):base(uint64_t(v)) {}
-private:
-    template <typename T>
-    void int_init(T v) {
-        if (v < 0) {
-            static_cast<base&>(*this) = int64_t(v);
-        }
-        else {
-            static_cast<base&>(*this) = uint64_t(v);
-        }
-    }
-};
-
-inline bool operator<(variant const& lhs, variant const& rhs) {
-    return static_cast<variant::base const&>(lhs) < static_cast<variant::base const&>(rhs);
-}
-
-inline bool operator==(variant const& lhs, variant const& rhs) {
-    return static_cast<variant::base const&>(lhs) == static_cast<variant::base const&>(rhs);
-}
-
-
-struct variant_ref;
-
-namespace detail {
-typedef boost::variant<
         nil,               // NIL
         bool,              // BOOL
         int64_t,           // NEGATIVE_INTEGER
@@ -134,38 +83,153 @@ typedef boost::variant<
         msgpack::type::raw_ref, // BIN
         ext,               // EXT
         ext_ref,           // EXT
-    boost::recursive_wrapper<std::vector<variant_ref> >, // ARRAY
+        boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY
-    boost::recursive_wrapper<std::map<variant_ref, variant_ref> >, // MAP
+        boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP
-    boost::recursive_wrapper<std::multimap<variant_ref, variant_ref> >// MAP
+        boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP
-> variant_ref_imp;
+    > base;
-
+    basic_variant() {}
-} // namespace detail
-
-struct variant_ref : detail::variant_ref_imp, private boost::totally_ordered<variant_ref>  {
-    typedef detail::variant_ref_imp base;
-    variant_ref() {}
     template <typename T>
-    variant_ref(T const& t):base(t) {}
+    basic_variant(T const& t):base(t) {}
-    variant_ref(char const* p):base(std::string(p)) {}
+    basic_variant(char const* p):base(std::string(p)) {}
-    variant_ref(char v) {
+    basic_variant(char v) {
         int_init(v);
     }
-    variant_ref(signed char v) {
+    basic_variant(signed char v) {
         int_init(v);
     }
-    variant_ref(unsigned char v):base(uint64_t(v)) {}
+    basic_variant(unsigned char v):base(uint64_t(v)) {}
-    variant_ref(signed int v) {
+    basic_variant(signed int v) {
         int_init(v);
     }
-    variant_ref(unsigned int v):base(uint64_t(v)) {}
+    basic_variant(unsigned int v):base(uint64_t(v)) {}
-    variant_ref(signed long v) {
+    basic_variant(signed long v) {
         int_init(v);
     }
-    variant_ref(unsigned long v):base(uint64_t(v)) {}
+    basic_variant(unsigned long v):base(uint64_t(v)) {}
-    variant_ref(signed long long v) {
+    basic_variant(signed long long v) {
         int_init(v);
     }
-    variant_ref(unsigned long long v):base(uint64_t(v)) {}
+    basic_variant(unsigned long long v):base(uint64_t(v)) {}
+
+    bool is_nil() const {
+        return boost::get<nil>(this);
+    }
+    bool is_bool() const {
+        return boost::get<bool>(this);
+    }
+    bool is_int64_t() const {
+        return boost::get<int64_t>(this);
+    }
+    bool is_uint64_t() const {
+        return boost::get<uint64_t>(this);
+    }
+    bool is_double() const {
+        return boost::get<double>(this);
+    }
+    bool is_string() const {
+        return boost::get<std::string>(this);
+    }
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    bool is_boost_string_ref() const {
+        return boost::get<boost::string_ref>(this);
+    }
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    bool is_vector_char() const {
+        return boost::get<std::vector<char> >(this);
+    }
+    bool is_vector_char() {
+        return boost::get<std::vector<char> >(this);
+    }
+    bool is_raw_ref() const {
+        return boost::get<raw_ref>(this);
+    }
+    bool is_ext() const {
+        return boost::get<ext>(this);
+    }
+    bool is_ext_ref() const {
+        return boost::get<ext_ref>(this);
+    }
+    bool is_vector() const {
+        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(this);
+    }
+    bool is_map() const {
+        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this);
+    }
+    bool is_multimap() const {
+        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this);
+    }
+
+    bool as_bool() const {
+        return boost::get<bool>(*this);
+    }
+    int64_t as_int64_t() const {
+        return boost::get<int64_t>(*this);
+    }
+    int64_t& as_int64_t() {
+        return boost::get<int64_t>(*this);
+    }
+    uint64_t as_uint64_t() const {
+        return boost::get<uint64_t>(*this);
+    }
+    uint64_t& as_uint64_t() {
+        return boost::get<uint64_t>(*this);
+    }
+    double as_double() const {
+        return boost::get<double>(*this);
+    }
+    double& as_double() {
+        return boost::get<double>(*this);
+    }
+    std::string const& as_string() const {
+        return boost::get<std::string>(*this);
+    }
+    std::string& as_string() {
+        return boost::get<std::string>(*this);
+    }
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    boost::string_ref const& as_boost_string_ref() const {
+        return boost::get<boost::string_ref>(*this);
+    }
+    boost::string_ref& as_boost_string_ref() {
+        return boost::get<boost::string_ref>(*this);
+    }
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    std::vector<char> const& as_vector_char() const {
+        return boost::get<std::vector<char> >(*this);
+    }
+    std::vector<char>& as_vector_char() {
+        return boost::get<std::vector<char> >(*this);
+    }
+    raw_ref const& as_raw_ref() const {
+        return boost::get<raw_ref>(*this);
+    }
+    ext const& as_ext() const {
+        return boost::get<ext>(*this);
+    }
+    ext& as_ext() {
+        return boost::get<ext>(*this);
+    }
+    ext_ref const& as_ext_ref() const {
+        return boost::get<ext_ref>(*this);
+    }
+    std::vector<basic_variant<STR, BIN, EXT> > const& as_vector() const {
+        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::vector<basic_variant<STR, BIN, EXT> >& as_vector() {
+        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_map() const {
+        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_map() {
+        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_multimap() const {
+        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
+    }
+    std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_multimap() {
+        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
+    }
 private:
     template <typename T>
     void int_init(T v) {
@@ -178,24 +242,38 @@ private:
     }
 };
 
-inline bool operator<(variant_ref const& lhs, variant_ref const& rhs) {
+template <typename STR, typename BIN, typename EXT>
-    return static_cast<variant_ref::base const&>(lhs) < static_cast<variant_ref::base const&>(rhs);
+inline bool operator<(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) {
+    return
+        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) <
+        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs);
 }
 
-inline bool operator==(variant_ref const& lhs, variant_ref const& rhs) {
+template <typename STR, typename BIN, typename EXT>
-    return static_cast<variant_ref::base const&>(lhs) == static_cast<variant_ref::base const&>(rhs);
+inline bool operator==(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) {
+    return
+        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) ==
+        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs);
 }
 
+typedef basic_variant<std::string, std::vector<char>, ext> variant;
+typedef basic_variant<
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    boost::string_ref,
+#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    std::string,
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    raw_ref, ext_ref> variant_ref;
+
 } // namespace type
 
-
 namespace adaptor {
 
 #if !defined (MSGPACK_USE_CPP03)
 
-template <>
+template <typename STR, typename BIN, typename EXT>
-struct as<msgpack::type::variant> {
+struct as<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    msgpack::type::variant operator()(msgpack::object const& o) const {
+    msgpack::type::basic_variant<STR, BIN, EXT> operator()(msgpack::object const& o) const {
         switch(o.type) {
         case type::NIL:
             return o.as<msgpack::type::nil>();
@@ -208,30 +286,30 @@ struct as<msgpack::type::variant> {
         case type::FLOAT:
             return o.as<double>();
         case type::STR:
-            return o.as<std::string>();
+            return o.as<STR>();
         case type::BIN:
-            return o.as<std::vector<char> >();
+            return o.as<BIN>();
         case type::EXT:
-            return o.as<msgpack::type::ext>();
+            return o.as<EXT>();
         case type::ARRAY:
-            return o.as<std::vector<msgpack::type::variant> >();
+            return o.as<std::vector<msgpack::type::basic_variant<STR, BIN, EXT> > >();
         case type::MAP:
-            return o.as<std::multimap<msgpack::type::variant, msgpack::type::variant> >();
+            return o.as<std::multimap<msgpack::type::basic_variant<STR, BIN, EXT>, msgpack::type::basic_variant<STR, BIN, EXT> > >();
         default:
             break;
         }
-        return msgpack::type::variant();
+        return msgpack::type::basic_variant<STR, BIN, EXT>();
     }
 };
 
 #endif // !defined (MSGPACK_USE_CPP03)
 
 
-template <>
+template <typename STR, typename BIN, typename EXT>
-struct convert<msgpack::type::variant> {
+struct convert<msgpack::type::basic_variant<STR, BIN, EXT> > {
     msgpack::object const& operator()(
         msgpack::object const& o,
-        msgpack::type::variant& v) const {
+        msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
         switch(o.type) {
         case type::NIL:
             v = o.as<msgpack::type::nil>();
@@ -249,19 +327,19 @@ struct convert<msgpack::type::variant> {
             v = o.as<double>();
             break;
         case type::STR:
-            v = o.as<std::string>();
+            v = o.as<STR>();
             break;
         case type::BIN:
-            v = o.as<std::vector<char> >();
+            v = o.as<BIN>();
             break;
         case type::EXT:
-            v = o.as<msgpack::type::ext>();
+            v = o.as<EXT>();
             break;
         case type::ARRAY:
-            v = o.as<std::vector<msgpack::type::variant> >();
+            v = o.as<std::vector<msgpack::type::basic_variant<STR, BIN, EXT> > >();
             break;
         case type::MAP:
-            v = o.as<std::multimap<msgpack::type::variant, msgpack::type::variant> >();
+            v = o.as<std::multimap<msgpack::type::basic_variant<STR, BIN, EXT>, msgpack::type::basic_variant<STR, BIN, EXT> > >();
             break;
         default:
             break;
@@ -284,10 +362,10 @@ struct pack_imp:boost::static_visitor<void> {
 
 } // namespace detail
 
-template <>
+template <typename STR, typename BIN, typename EXT>
-struct pack<msgpack::type::variant> {
+struct pack<msgpack::type::basic_variant<STR, BIN, EXT> > {
     template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::variant& v) const {
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
         boost::apply_visitor(detail::pack_imp<Stream>(o), v);
         return o;
     }
@@ -321,9 +399,9 @@ struct object_imp:boost::static_visitor<void> {
 
 } // namespace detail
 
-template <>
+template <typename STR, typename BIN, typename EXT>
-struct object<msgpack::type::variant> {
+struct object<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    void operator()(msgpack::object& o, const msgpack::type::variant& v) const {
+    void operator()(msgpack::object& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
         boost::apply_visitor(detail::object_imp(o), v);
     }
 };
@@ -341,119 +419,9 @@ struct object_with_zone_imp:boost::static_visitor<void> {
 
 } // namespace detail
 
-template <>
+template <typename STR, typename BIN, typename EXT>
-struct object_with_zone<msgpack::type::variant> {
+struct object_with_zone<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    void operator()(msgpack::object::with_zone& o, const msgpack::type::variant& v) const {
+    void operator()(msgpack::object::with_zone& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
-        boost::apply_visitor(detail::object_with_zone_imp(o), v);
-    }
-};
-
-#if !defined (MSGPACK_USE_CPP03)
-
-template <>
-struct as<msgpack::type::variant_ref> {
-    msgpack::type::variant_ref operator()(msgpack::object const& o) const {
-        switch(o.type) {
-        case type::NIL:
-            return o.as<msgpack::type::nil>();
-        case type::BOOLEAN:
-            return o.as<bool>();
-        case type::POSITIVE_INTEGER:
-            return o.as<uint64_t>();
-        case type::NEGATIVE_INTEGER:
-            return o.as<int64_t>();
-        case type::FLOAT:
-            return o.as<double>();
-        case type::STR:
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-            return o.as<boost::string_ref>();
-#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-            return o.as<std::string>();
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-        case type::BIN:
-            return o.as<msgpack::type::raw_ref>();
-        case type::EXT:
-            return o.as<msgpack::type::ext_ref>();
-        case type::ARRAY:
-            return o.as<std::vector<msgpack::type::variant_ref> >();
-        case type::MAP:
-            return o.as<std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref> >();
-        default:
-            break;
-        }
-        return msgpack::type::variant_ref();
-    }
-};
-
-#endif // !defined (MSGPACK_USE_CPP03)
-
-
-template <>
-struct convert<msgpack::type::variant_ref> {
-    msgpack::object const& operator()(
-        msgpack::object const& o,
-        msgpack::type::variant_ref& v) const {
-        switch(o.type) {
-        case type::NIL:
-            v = o.as<msgpack::type::nil>();
-            break;
-        case type::BOOLEAN:
-            v = o.as<bool>();
-            break;
-        case type::POSITIVE_INTEGER:
-            v = o.as<uint64_t>();
-            break;
-        case type::NEGATIVE_INTEGER:
-            v = o.as<int64_t>();
-            break;
-        case type::FLOAT:
-            v = o.as<double>();
-            break;
-        case type::STR:
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-            v = o.as<boost::string_ref>();
-#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-            v = o.as<std::string>();
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-            break;
-        case type::BIN:
-            v = o.as<msgpack::type::raw_ref>();
-            break;
-        case type::EXT:
-            v = o.as<msgpack::type::ext_ref>();
-            break;
-        case type::ARRAY:
-            v = o.as<std::vector<msgpack::type::variant_ref> >();
-            break;
-        case type::MAP:
-            v = o.as<std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref> >();
-            break;
-        default:
-            break;
-        }
-        return o;
-    }
-};
-
-template <>
-struct pack<msgpack::type::variant_ref> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::variant_ref& v) const {
-        boost::apply_visitor(detail::pack_imp<Stream>(o), v);
-        return o;
-    }
-};
-
-template <>
-struct object<msgpack::type::variant_ref> {
-    void operator()(msgpack::object& o, const msgpack::type::variant_ref& v) const {
-        boost::apply_visitor(detail::object_imp(o), v);
-    }
-};
-
-template <>
-struct object_with_zone<msgpack::type::variant_ref> {
-    void operator()(msgpack::object::with_zone& o, const msgpack::type::variant_ref& v) const {
         boost::apply_visitor(detail::object_with_zone_imp(o), v);
     }
 };

test/boost_variant.cpp

@@ -1,3 +1,4 @@
+#include <cmath>
 #include <msgpack.hpp>
 #include <sstream>
 #include <iterator>
@@ -9,26 +10,31 @@
 
 #if defined(MSGPACK_USE_BOOST)
 
+const double kEPS = 1e-10;
+
 // nil
 
 TEST(MSGPACK_BOOST, pack_convert_variant_nil)
 {
     std::stringstream ss;
     msgpack::type::variant val1 = msgpack::type::nil();
-
+    EXPECT_TRUE(val1.is_nil());
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
 }
 
 TEST(MSGPACK_BOOST, object_variant_nil)
 {
     msgpack::type::variant val1 = msgpack::type::nil();
+    EXPECT_TRUE(val1.is_nil());
     msgpack::object obj(val1);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
 }
 
@@ -36,8 +42,10 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_nil)
 {
     msgpack::zone z;
     msgpack::type::variant val1 = msgpack::type::nil();
+    EXPECT_TRUE(val1.is_nil());
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
 }
 
@@ -47,20 +55,24 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil_default)
 {
     std::stringstream ss;
     msgpack::type::variant val1;
+    EXPECT_TRUE(val1.is_nil());
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
 }
 
 TEST(MSGPACK_BOOST, object_variant_nil_default)
 {
     msgpack::type::variant val1;
+    EXPECT_TRUE(val1.is_nil());
     msgpack::object obj(val1);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
 }
 
@@ -68,8 +80,10 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_nil_default)
 {
     msgpack::zone z;
     msgpack::type::variant val1;
+    EXPECT_TRUE(val1.is_nil());
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
 }
 
@@ -79,12 +93,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool)
 {
     std::stringstream ss;
     msgpack::type::variant val1 = true;
+    EXPECT_TRUE(val1.is_bool());
+    EXPECT_TRUE(val1.as_bool());
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_bool());
+    EXPECT_TRUE(val2.as_bool());
     EXPECT_NO_THROW(boost::get<bool>(val2));
     EXPECT_TRUE(val1 == val2);
     // Tests for totally ordered
@@ -98,8 +116,12 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool)
 TEST(MSGPACK_BOOST, object_variant_bool)
 {
     msgpack::type::variant val1 = true;
+    EXPECT_TRUE(val1.is_bool());
+    EXPECT_TRUE(val1.as_bool());
     msgpack::object obj(val1);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_bool());
+    EXPECT_TRUE(val2.as_bool());
     EXPECT_NO_THROW(boost::get<bool>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -108,8 +130,12 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_bool)
 {
     msgpack::zone z;
     msgpack::type::variant val1 = true;
+    EXPECT_TRUE(val1.is_bool());
+    EXPECT_TRUE(val1.as_bool());
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_bool());
+    EXPECT_TRUE(val2.as_bool());
     EXPECT_NO_THROW(boost::get<bool>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -120,12 +146,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer)
 {
     std::stringstream ss;
     msgpack::type::variant val1 = 123;
+    EXPECT_TRUE(val1.is_uint64_t());
+    EXPECT_EQ(val1.as_uint64_t(), 123);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_uint64_t());
+    EXPECT_EQ(val2.as_uint64_t(), 123);
     EXPECT_NO_THROW(boost::get<uint64_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -133,8 +163,12 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer)
 TEST(MSGPACK_BOOST, object_variant_positive_integer)
 {
     msgpack::type::variant val1 = 123;
+    EXPECT_TRUE(val1.is_uint64_t());
+    EXPECT_EQ(val1.as_uint64_t(), 123);
     msgpack::object obj(val1);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_uint64_t());
+    EXPECT_EQ(val2.as_uint64_t(), 123);
     EXPECT_NO_THROW(boost::get<uint64_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -143,8 +177,12 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_positive_integer)
 {
     msgpack::zone z;
     msgpack::type::variant val1 = 123;
+    EXPECT_TRUE(val1.is_uint64_t());
+    EXPECT_EQ(val1.as_uint64_t(), 123);
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_uint64_t());
+    EXPECT_EQ(val2.as_uint64_t(), 123);
     EXPECT_NO_THROW(boost::get<uint64_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -155,12 +193,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer)
 {
     std::stringstream ss;
     msgpack::type::variant val1 = -123;
+    EXPECT_TRUE(val1.is_int64_t());
+    EXPECT_EQ(val1.as_int64_t(), -123);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_int64_t());
+    EXPECT_EQ(val2.as_int64_t(), -123);
     EXPECT_NO_THROW(boost::get<int64_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -168,8 +210,12 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer)
 TEST(MSGPACK_BOOST, object_variant_negative_integer)
 {
     msgpack::type::variant val1 = -123;
+    EXPECT_TRUE(val1.is_int64_t());
+    EXPECT_EQ(val1.as_int64_t(), -123);
     msgpack::object obj(val1);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_int64_t());
+    EXPECT_EQ(val2.as_int64_t(), -123);
     EXPECT_NO_THROW(boost::get<int64_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -178,8 +224,12 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_negative_integer)
 {
     msgpack::zone z;
     msgpack::type::variant val1 = -123;
+    EXPECT_TRUE(val1.is_int64_t());
+    EXPECT_EQ(val1.as_int64_t(), -123);
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_int64_t());
+    EXPECT_EQ(val2.as_int64_t(), -123);
     EXPECT_NO_THROW(boost::get<int64_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -190,33 +240,45 @@ TEST(MSGPACK_BOOST, pack_convert_variant_float)
 {
     std::stringstream ss;
     msgpack::type::variant val1 = 12.34;
+    EXPECT_TRUE(val1.is_double());
+    EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_double());
+    EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
     EXPECT_NO_THROW(boost::get<double>(val2));
-    EXPECT_TRUE(val1 == val2);
+    EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS);
 }
 
 TEST(MSGPACK_BOOST, object_variant_float)
 {
     msgpack::type::variant val1 = 12.34;
+    EXPECT_TRUE(val1.is_double());
+    EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS);
     msgpack::object obj(val1);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_double());
+    EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
     EXPECT_NO_THROW(boost::get<double>(val2));
-    EXPECT_TRUE(val1 == val2);
+    EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS);
 }
 
 TEST(MSGPACK_BOOST, object_with_zone_variant_float)
 {
     msgpack::zone z;
     msgpack::type::variant val1 = 12.34;
+    EXPECT_TRUE(val1.is_double());
+    EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS);
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_double());
+    EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
     EXPECT_NO_THROW(boost::get<double>(val2));
-    EXPECT_TRUE(val1 == val2);
+    EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS);
 }
 
 // str
@@ -225,28 +287,58 @@ TEST(MSGPACK_BOOST, pack_convert_variant_str)
 {
     std::stringstream ss;
     msgpack::type::variant val1 = "ABC";
+    EXPECT_TRUE(val1.is_string());
+    EXPECT_EQ(val1.as_string(), "ABC");
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_string());
+    EXPECT_EQ(val2.as_string(), "ABC");
     EXPECT_NO_THROW(boost::get<std::string>(val2));
     EXPECT_TRUE(val1 == val2);
 }
 
 
-
 TEST(MSGPACK_BOOST, object_with_zone_variant_str)
 {
     msgpack::zone z;
     msgpack::type::variant val1 = "ABC";
+    EXPECT_TRUE(val1.is_string());
+    EXPECT_EQ(val1.as_string(), "ABC");
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_string());
+    EXPECT_EQ(val2.as_string(), "ABC");
     EXPECT_NO_THROW(boost::get<std::string>(val2));
     EXPECT_TRUE(val1 == val2);
 }
 
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+
+TEST(MSGPACK_BOOST, object_with_zone_variant_str_ref)
+{
+    // You can use boost::string_ref with msgpack::type::variant.
+    msgpack::zone z;
+    std::string s = "ABC";
+    boost::string_ref sr(s);
+    msgpack::type::variant val1(sr);
+    EXPECT_TRUE(val1.is_boost_string_ref());
+    EXPECT_EQ(val1.as_boost_string_ref(), "ABC");
+    msgpack::object obj(val1, z);
+    msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    // Coverted as std::string.
+    EXPECT_TRUE(val2.is_string());
+    EXPECT_EQ(val2.as_string(), "ABC");
+    EXPECT_NO_THROW(boost::get<std::string>(val2));
+    // boost::string_ref and std::string are different.
+    EXPECT_FALSE(val1 == val2);
+}
+
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+
 // bin
 
 TEST(MSGPACK_BOOST, pack_convert_variant_bin)
@@ -257,12 +349,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bin)
     v.push_back('b');
     v.push_back('c');
     msgpack::type::variant val1 = v;
+    EXPECT_TRUE(val1.is_vector_char());
+    EXPECT_EQ(val1.as_vector_char(), v);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_vector_char());
+    EXPECT_EQ(val2.as_vector_char(), v);
     EXPECT_NO_THROW(boost::get<std::vector<char> >(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -277,12 +373,42 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_bin)
     v.push_back('b');
     v.push_back('c');
     msgpack::type::variant val1 = v;
+    EXPECT_TRUE(val1.is_vector_char());
+    EXPECT_EQ(val1.as_vector_char(), v);
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_vector_char());
+    EXPECT_EQ(val2.as_vector_char(), v);
     EXPECT_NO_THROW(boost::get<std::vector<char> >(val2));
     EXPECT_TRUE(val1 == val2);
 }
 
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+
+TEST(MSGPACK_BOOST, object_with_zone_variant_raw_ref)
+{
+    // You can use boost::string_ref with msgpack::type::variant.
+    msgpack::zone z;
+    std::vector<char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+    msgpack::type::raw_ref rr(&v.front(), v.size());
+    msgpack::type::variant val1 = rr;
+    EXPECT_TRUE(val1.is_raw_ref());
+    EXPECT_EQ(val1.as_raw_ref(), msgpack::type::raw_ref(&v.front(), v.size()));
+    msgpack::object obj(val1, z);
+    msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    // Coverted as std::vector<char>.
+    EXPECT_TRUE(val2.is_vector_char());
+    EXPECT_EQ(val2.as_vector_char(), v);
+    EXPECT_NO_THROW(boost::get<std::vector<char> >(val2));
+     // msgpack::type::raw_ref and std::vector<char> are different.
+   EXPECT_FALSE(val1 == val2);
+}
+
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+
 // ext
 
 TEST(MSGPACK_BOOST, pack_convert_variant_ext)
@@ -292,13 +418,18 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ext)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::variant val1(msgpack::type::ext(42, v.data(), v.size()));
+    msgpack::type::ext e(42, v.data(), v.size());
+    msgpack::type::variant val1(e);
+    EXPECT_TRUE(val1.is_ext());
+    EXPECT_EQ(val1.as_ext(), e);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_ext());
+    EXPECT_EQ(val2.as_ext(), e);
     EXPECT_NO_THROW(boost::get<msgpack::type::ext>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -312,13 +443,40 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ext)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::variant val1(msgpack::type::ext(42, v.data(), v.size()));
+    msgpack::type::ext e(42, v.data(), v.size());
+    msgpack::type::variant val1(e);
+    EXPECT_TRUE(val1.is_ext());
+    EXPECT_EQ(val1.as_ext(), e);
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_ext());
+    EXPECT_EQ(val2.as_ext(), e);
     EXPECT_NO_THROW(boost::get<msgpack::type::ext>(val2));
     EXPECT_TRUE(val1 == val2);
 }
 
+TEST(MSGPACK_BOOST, object_with_zone_variant_ext_ref)
+{
+    // You can use msgpack::type::ext_ref with msgpack::type::variant.
+    msgpack::zone z;
+    std::vector<char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+    msgpack::type::ext_ref e(v.data(), v.size());
+    msgpack::type::variant val1(e);
+    EXPECT_TRUE(val1.is_ext_ref());
+    EXPECT_EQ(val1.as_ext_ref(), e);
+    msgpack::object obj(val1, z);
+    msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    // Coverted as msgpack::type::ext.
+    EXPECT_TRUE(val2.is_ext());
+    EXPECT_EQ(val2.as_ext(), e);
+    EXPECT_NO_THROW(boost::get<msgpack::type::ext>(val2));
+     // msgpack::type::ext_ref and msgpack::type::ext are different.
+    EXPECT_FALSE(val1 == val2);
+}
+
 // array
 
 TEST(MSGPACK_BOOST, pack_convert_variant_array)
@@ -327,15 +485,18 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array)
     std::vector<msgpack::type::variant> v;
     v.push_back(msgpack::type::variant(1));
     v.push_back(msgpack::type::variant(-1));
-    v.push_back(msgpack::type::variant(23.4));
     v.push_back(msgpack::type::variant("ABC"));
     msgpack::type::variant val1 = v;
+    EXPECT_TRUE(val1.is_vector());
+    EXPECT_EQ(val1.as_vector(), v);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_vector());
+    EXPECT_EQ(val2.as_vector(), v);
     EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant> >(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -346,11 +507,14 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_array)
     std::vector<msgpack::type::variant> v;
     v.push_back(msgpack::type::variant(1));
     v.push_back(msgpack::type::variant(-1));
-    v.push_back(msgpack::type::variant(23.4));
     v.push_back(msgpack::type::variant("ABC"));
     msgpack::type::variant val1 = v;
+    EXPECT_TRUE(val1.is_vector());
+    EXPECT_EQ(val1.as_vector(), v);
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_vector());
+    EXPECT_EQ(val2.as_vector(), v);
     EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant> >(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -363,14 +527,18 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map)
     typedef std::multimap<msgpack::type::variant, msgpack::type::variant> multimap_t;
     multimap_t v;
     v.insert(multimap_t::value_type(msgpack::type::variant(1), msgpack::type::variant(-1)));
-    v.insert(multimap_t::value_type(msgpack::type::variant(23.4), msgpack::type::variant("ABC")));
+    v.insert(multimap_t::value_type(msgpack::type::variant("ABC"), msgpack::type::variant("DEF")));
     msgpack::type::variant val1 = v;
+    EXPECT_TRUE(val1.is_multimap());
+    EXPECT_EQ(val1.as_multimap(), v);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_multimap());
+    EXPECT_EQ(val2.as_multimap(), v);
     EXPECT_NO_THROW(boost::get<multimap_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -381,233 +549,40 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_map)
     typedef std::multimap<msgpack::type::variant, msgpack::type::variant> multimap_t;
     multimap_t v;
     v.insert(multimap_t::value_type(msgpack::type::variant(1), msgpack::type::variant(-1)));
-    v.insert(multimap_t::value_type(msgpack::type::variant(23.4), msgpack::type::variant("ABC")));
+    v.insert(multimap_t::value_type(msgpack::type::variant("ABC"), msgpack::type::variant("DEF")));
     msgpack::type::variant val1 = v;
+    EXPECT_TRUE(val1.is_multimap());
+    EXPECT_EQ(val1.as_multimap(), v);
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
+    EXPECT_TRUE(val2.is_multimap());
+    EXPECT_EQ(val2.as_multimap(), v);
     EXPECT_NO_THROW(boost::get<multimap_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
 
 // variant_ref
 
-// nil
-
-TEST(MSGPACK_BOOST, pack_convert_variant_ref_nil)
-{
-    std::stringstream ss;
-    msgpack::type::variant_ref val1 = msgpack::type::nil();
-
-    msgpack::pack(ss, val1);
-
-    msgpack::unpacked ret;
-    msgpack::unpack(ret, ss.str().data(), ss.str().size());
-    msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
-}
-
-TEST(MSGPACK_BOOST, object_variant_ref_nil)
-{
-    msgpack::type::variant_ref val1 = msgpack::type::nil();
-    msgpack::object obj(val1);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
-}
-
-TEST(MSGPACK_BOOST, object_with_zone_variant_ref_nil)
-{
-    msgpack::zone z;
-    msgpack::type::variant_ref val1 = msgpack::type::nil();
-    msgpack::object obj(val1, z);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
-}
-
-// nil (default constructor)
-
-TEST(MSGPACK_BOOST, pack_convert_variant_ref_nil_default)
-{
-    std::stringstream ss;
-    msgpack::type::variant_ref val1;
-
-    msgpack::pack(ss, val1);
-
-    msgpack::unpacked ret;
-    msgpack::unpack(ret, ss.str().data(), ss.str().size());
-    msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
-}
-
-TEST(MSGPACK_BOOST, object_variant_ref_nil_default)
-{
-    msgpack::type::variant_ref val1;
-    msgpack::object obj(val1);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
-}
-
-TEST(MSGPACK_BOOST, object_with_zone_variant_ref_nil_default)
-{
-    msgpack::zone z;
-    msgpack::type::variant_ref val1;
-    msgpack::object obj(val1, z);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<msgpack::type::nil>(val2));
-}
-
-// bool
-
-TEST(MSGPACK_BOOST, pack_convert_variant_ref_bool)
-{
-    std::stringstream ss;
-    msgpack::type::variant_ref val1 = true;
-
-    msgpack::pack(ss, val1);
-
-    msgpack::unpacked ret;
-    msgpack::unpack(ret, ss.str().data(), ss.str().size());
-    msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<bool>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-TEST(MSGPACK_BOOST, object_variant_ref_bool)
-{
-    msgpack::type::variant_ref val1 = true;
-    msgpack::object obj(val1);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<bool>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-TEST(MSGPACK_BOOST, object_with_zone_variant_ref_bool)
-{
-    msgpack::zone z;
-    msgpack::type::variant_ref val1 = true;
-    msgpack::object obj(val1, z);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<bool>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-// positive integer
-
-TEST(MSGPACK_BOOST, pack_convert_variant_ref_positive_integer)
-{
-    std::stringstream ss;
-    msgpack::type::variant_ref val1 = 123;
-
-    msgpack::pack(ss, val1);
-
-    msgpack::unpacked ret;
-    msgpack::unpack(ret, ss.str().data(), ss.str().size());
-    msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<uint64_t>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-TEST(MSGPACK_BOOST, object_variant_ref_positive_integer)
-{
-    msgpack::type::variant_ref val1 = 123;
-    msgpack::object obj(val1);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<uint64_t>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-TEST(MSGPACK_BOOST, object_with_zone_variant_ref_positive_integer)
-{
-    msgpack::zone z;
-    msgpack::type::variant_ref val1 = 123;
-    msgpack::object obj(val1, z);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<uint64_t>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-// negative integer
-
-TEST(MSGPACK_BOOST, pack_convert_variant_ref_negative_integer)
-{
-    std::stringstream ss;
-    msgpack::type::variant_ref val1 = -123;
-
-    msgpack::pack(ss, val1);
-
-    msgpack::unpacked ret;
-    msgpack::unpack(ret, ss.str().data(), ss.str().size());
-    msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<int64_t>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-TEST(MSGPACK_BOOST, object_variant_ref_negative_integer)
-{
-    msgpack::type::variant_ref val1 = -123;
-    msgpack::object obj(val1);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<int64_t>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-TEST(MSGPACK_BOOST, object_with_zone_variant_ref_negative_integer)
-{
-    msgpack::zone z;
-    msgpack::type::variant_ref val1 = -123;
-    msgpack::object obj(val1, z);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<int64_t>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-// float
-
-TEST(MSGPACK_BOOST, pack_convert_variant_ref_float)
-{
-    std::stringstream ss;
-    msgpack::type::variant_ref val1 = 12.34;
-
-    msgpack::pack(ss, val1);
-
-    msgpack::unpacked ret;
-    msgpack::unpack(ret, ss.str().data(), ss.str().size());
-    msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<double>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-TEST(MSGPACK_BOOST, object_variant_ref_float)
-{
-    msgpack::type::variant_ref val1 = 12.34;
-    msgpack::object obj(val1);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<double>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
-TEST(MSGPACK_BOOST, object_with_zone_variant_ref_float)
-{
-    msgpack::zone z;
-    msgpack::type::variant_ref val1 = 12.34;
-    msgpack::object obj(val1, z);
-    msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
-    EXPECT_NO_THROW(boost::get<double>(val2));
-    EXPECT_TRUE(val1 == val2);
-}
-
 // str
 
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+
 TEST(MSGPACK_BOOST, pack_convert_variant_ref_str)
 {
     std::stringstream ss;
     std::string s("ABC");
-    msgpack::type::variant_ref val1 = boost::string_ref(s);
+    boost::string_ref sr(s);
+    msgpack::type::variant_ref val1 = sr;
+    EXPECT_TRUE(val1.is_boost_string_ref());
+    EXPECT_EQ(val1.as_boost_string_ref(), sr);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
+    EXPECT_TRUE(val2.is_boost_string_ref());
+    EXPECT_EQ(val2.as_boost_string_ref(), sr);
     EXPECT_NO_THROW(boost::get<boost::string_ref>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -618,13 +593,20 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_str)
 {
     msgpack::zone z;
     std::string s("ABC");
-    msgpack::type::variant_ref val1 = boost::string_ref(s);
+    boost::string_ref sr(s);
+    msgpack::type::variant_ref val1 = sr;
+    EXPECT_TRUE(val1.is_boost_string_ref());
+    EXPECT_EQ(val1.as_boost_string_ref(), sr);
     msgpack::object obj(val1, z);
     msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
+    EXPECT_TRUE(val2.is_boost_string_ref());
+    EXPECT_EQ(val2.as_boost_string_ref(), sr);
     EXPECT_NO_THROW(boost::get<boost::string_ref>(val2));
     EXPECT_TRUE(val1 == val2);
 }
 
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+
 // bin
 
 TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin)
@@ -634,13 +616,18 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::variant_ref val1 = msgpack::type::raw_ref(v.data(), v.size());
+    msgpack::type::raw_ref rr(v.data(), v.size());
+    msgpack::type::variant_ref val1 = rr;
+    EXPECT_TRUE(val1.is_raw_ref());
+    EXPECT_EQ(val1.as_raw_ref(), rr);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
+    EXPECT_TRUE(val2.is_raw_ref());
+    EXPECT_EQ(val2.as_raw_ref(), rr);
     EXPECT_NO_THROW(boost::get<msgpack::type::raw_ref>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -654,9 +641,14 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_bin)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::variant_ref val1 = msgpack::type::raw_ref(v.data(), v.size());
+    msgpack::type::raw_ref rr(v.data(), v.size());
+    msgpack::type::variant_ref val1 = rr;
+    EXPECT_TRUE(val1.is_raw_ref());
+    EXPECT_EQ(val1.as_raw_ref(), rr);
     msgpack::object obj(val1, z);
     msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
+    EXPECT_TRUE(val2.is_raw_ref());
+    EXPECT_EQ(val2.as_raw_ref(), rr);
     EXPECT_NO_THROW(boost::get<msgpack::type::raw_ref>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -671,7 +663,10 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::variant_ref val1(msgpack::type::ext_ref(v.data(), v.size()));
+    msgpack::type::ext_ref er(v.data(), v.size());
+    msgpack::type::variant_ref val1(er);
+    EXPECT_TRUE(val1.is_ext_ref());
+    EXPECT_EQ(val1.as_ext_ref(), er);
 
     msgpack::pack(ss, val1);
 
@@ -679,11 +674,12 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext)
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
     EXPECT_NO_THROW(boost::get<msgpack::type::ext_ref>(val2));
+    EXPECT_TRUE(val2.is_ext_ref());
+    EXPECT_EQ(val2.as_ext_ref(), er);
     EXPECT_TRUE(val1 == val2);
 }
 
 
-
 TEST(MSGPACK_BOOST, object_with_zone_variant_ref_ext)
 {
     msgpack::zone z;
@@ -692,9 +688,14 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_ext)
     v.push_back('a');
     v.push_back('b');
     v.push_back('c');
-    msgpack::type::variant_ref val1(msgpack::type::ext_ref(v.data(), v.size()));
+    msgpack::type::ext_ref er(v.data(), v.size());
+    msgpack::type::variant_ref val1(er);
+    EXPECT_TRUE(val1.is_ext_ref());
+    EXPECT_EQ(val1.as_ext_ref(), er);
     msgpack::object obj(val1, z);
     msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
+    EXPECT_TRUE(val2.is_ext_ref());
+    EXPECT_EQ(val2.as_ext_ref(), er);
     EXPECT_NO_THROW(boost::get<msgpack::type::ext_ref>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -707,16 +708,23 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array)
     std::vector<msgpack::type::variant_ref> v;
     v.push_back(msgpack::type::variant_ref(1));
     v.push_back(msgpack::type::variant_ref(-1));
-    v.push_back(msgpack::type::variant_ref(23.4));
     std::string s("ABC");
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
     v.push_back(msgpack::type::variant_ref(boost::string_ref(s)));
+#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    v.push_back(msgpack::type::variant_ref(s));
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
     msgpack::type::variant_ref val1 = v;
+    EXPECT_TRUE(val1.is_vector());
+    EXPECT_EQ(val1.as_vector(), v);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
+    EXPECT_TRUE(val2.is_vector());
+    EXPECT_EQ(val2.as_vector(), v);
     EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant_ref> >(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -727,12 +735,19 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_array)
     std::vector<msgpack::type::variant_ref> v;
     v.push_back(msgpack::type::variant_ref(1));
     v.push_back(msgpack::type::variant_ref(-1));
-    v.push_back(msgpack::type::variant_ref(23.4));
     std::string s("ABC");
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
     v.push_back(msgpack::type::variant_ref(boost::string_ref(s)));
+#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    v.push_back(msgpack::type::variant_ref(s));
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
     msgpack::type::variant_ref val1 = v;
+    EXPECT_TRUE(val1.is_vector());
+    EXPECT_EQ(val1.as_vector(), v);
     msgpack::object obj(val1, z);
     msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
+    EXPECT_TRUE(val2.is_vector());
+    EXPECT_EQ(val2.as_vector(), v);
     EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant_ref> >(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -745,15 +760,24 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map)
     typedef std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref> multimap_t;
     multimap_t v;
     v.insert(multimap_t::value_type(msgpack::type::variant_ref(1), msgpack::type::variant_ref(-1)));
-    std::string s("ABC");
+    std::string s1("ABC");
-    v.insert(multimap_t::value_type(msgpack::type::variant_ref(23.4), msgpack::type::variant_ref(boost::string_ref(s))));
+    std::string s2("DEF");
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    v.insert(multimap_t::value_type(msgpack::type::variant_ref(boost::string_ref(s1)), msgpack::type::variant_ref(boost::string_ref(s2))));
+#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    v.insert(multimap_t::value_type(msgpack::type::variant_ref(s1), msgpack::type::variant_ref(s2)));
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
     msgpack::type::variant_ref val1 = v;
+    EXPECT_TRUE(val1.is_multimap());
+    EXPECT_EQ(val1.as_multimap(), v);
 
     msgpack::pack(ss, val1);
 
     msgpack::unpacked ret;
     msgpack::unpack(ret, ss.str().data(), ss.str().size());
     msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>();
+    EXPECT_TRUE(val2.is_multimap());
+    EXPECT_EQ(val2.as_multimap(), v);
     EXPECT_NO_THROW(boost::get<multimap_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
@@ -764,13 +788,23 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_map)
     typedef std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref> multimap_t;
     multimap_t v;
     v.insert(multimap_t::value_type(msgpack::type::variant_ref(1), msgpack::type::variant_ref(-1)));
-    std::string s("ABC");
+    std::string s1("ABC");
-    v.insert(multimap_t::value_type(msgpack::type::variant_ref(23.4), msgpack::type::variant_ref(boost::string_ref(s))));
+    std::string s2("DEF");
+#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    v.insert(multimap_t::value_type(msgpack::type::variant_ref(boost::string_ref(s1)), msgpack::type::variant_ref(boost::string_ref(s2))));
+#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
+    v.insert(multimap_t::value_type(msgpack::type::variant_ref(s1), msgpack::type::variant_ref(s2)));
+#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
     msgpack::type::variant_ref val1 = v;
+    EXPECT_TRUE(val1.is_multimap());
+    EXPECT_EQ(val1.as_multimap(), v);
     msgpack::object obj(val1, z);
     msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
+    EXPECT_TRUE(val2.is_multimap());
+    EXPECT_EQ(val2.as_multimap(), v);
     EXPECT_NO_THROW(boost::get<multimap_t>(val2));
     EXPECT_TRUE(val1 == val2);
 }
 
+
 #endif // defined(MSGPACK_USE_BOOST)