diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp
index 08027497..affe6f7f 100644
--- a/test/msgpack_test.cpp
+++ b/test/msgpack_test.cpp
@@ -35,14 +35,9 @@ const double kEPS = 1e-10;
       msgpack::sbuffer sbuf;                                          \
       test_type val1 = v[i];                                          \
       msgpack::pack(sbuf, val1);                                      \
-      msgpack::zone z;                                                \
-      msgpack::object obj;                                            \
-      msgpack::unpack_return ret =                                    \
-        msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);            \
-      EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);                        \
-      test_type val2;                                                 \
-      obj.convert(&val2);                                             \
-      EXPECT_EQ(val1, val2);                                          \
+      msgpack::unpacked ret;                                          \
+      msgpack::unpack(ret, sbuf.data(), sbuf.size());                 \
+      EXPECT_EQ(val1, ret.get().as<test_type>());                     \
     }                                                                 \
 } while(0)
 
@@ -162,13 +157,9 @@ TEST(MSGPACK, simple_buffer_float)
     msgpack::sbuffer sbuf;
     float val1 = v[i];
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    float val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    float val2 = ret.get().as<float>();
 
     if (std::isnan(val1))
       EXPECT_TRUE(std::isnan(val2));
@@ -210,13 +201,9 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
     msgpack::sbuffer sbuf;
     integer_type val1 = v[i];
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    float_type val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    float_type val2 = ret.get().as<float_type>();
     EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
   }
 }
@@ -252,13 +239,9 @@ TEST(MSGPACK, simple_buffer_double)
     msgpack::sbuffer sbuf;
     double val1 = v[i];
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    double val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    double val2 = ret.get().as<double>();
 
     if (std::isnan(val1))
       EXPECT_TRUE(std::isnan(val2));
@@ -274,13 +257,9 @@ TEST(MSGPACK, simple_buffer_true)
   msgpack::sbuffer sbuf;
   bool val1 = true;
   msgpack::pack(sbuf, val1);
-  msgpack::zone z;
-  msgpack::object obj;
-  msgpack::unpack_return ret =
-    msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-  EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-  bool val2;
-  obj.convert(&val2);
+  msgpack::unpacked ret;
+  msgpack::unpack(ret, sbuf.data(), sbuf.size());
+  bool val2 = ret.get().as<bool>();
   EXPECT_EQ(val1, val2);
 }
 
@@ -289,13 +268,9 @@ TEST(MSGPACK, simple_buffer_false)
   msgpack::sbuffer sbuf;
   bool val1 = false;
   msgpack::pack(sbuf, val1);
-  msgpack::zone z;
-  msgpack::object obj;
-  msgpack::unpack_return ret =
-    msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-  EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-  bool val2;
-  obj.convert(&val2);
+  msgpack::unpacked ret;
+  msgpack::unpack(ret, sbuf.data(), sbuf.size());
+  bool val2 = ret.get().as<bool>();
   EXPECT_EQ(val1, val2);
 }
 
@@ -311,13 +286,9 @@ TEST(MSGPACK_STL, simple_buffer_string)
       val1 += 'a' + rand() % 26;
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    string val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    string val2 = ret.get().as<string>();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_EQ(val1, val2);
   }
@@ -331,13 +302,9 @@ TEST(MSGPACK_STL, simple_buffer_vector)
       val1.push_back(rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    vector<int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    vector<int> val2 = ret.get().as<vector<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -351,13 +318,9 @@ TEST(MSGPACK_STL, simple_buffer_map)
       val1[rand()] = rand();
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    map<int, int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    map<int, int> val2 = ret.get().as<map<int, int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -371,13 +334,9 @@ TEST(MSGPACK_STL, simple_buffer_deque)
       val1.push_back(rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    deque<int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    deque<int> val2 = ret.get().as<deque<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -391,13 +350,9 @@ TEST(MSGPACK_STL, simple_buffer_list)
       val1.push_back(rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    list<int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    list<int> val2 = ret.get().as<list<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -411,13 +366,9 @@ TEST(MSGPACK_STL, simple_buffer_set)
       val1.insert(rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    set<int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    set<int> val2 = ret.get().as<set<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -429,13 +380,9 @@ TEST(MSGPACK_STL, simple_buffer_pair)
     pair<int, int> val1 = make_pair(rand(), rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    pair<int, int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    pair<int, int> val2 = ret.get().as<pair<int, int> >();
     EXPECT_EQ(val1.first, val2.first);
     EXPECT_EQ(val1.second, val2.second);
   }
@@ -452,13 +399,9 @@ TEST(MSGPACK_STL, simple_buffer_multimap)
     }
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    multimap<int, int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    multimap<int, int> val2 = ret.get().as<multimap<int, int> >();
 
     vector<pair<int, int> > v1, v2;
     multimap<int, int>::const_iterator it;
@@ -482,13 +425,9 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
       val1.insert(rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    multiset<int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    multiset<int> val2 = ret.get().as<multiset<int> >();
 
     vector<int> v1, v2;
     multiset<int>::const_iterator it;
@@ -517,13 +456,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
       val1[rand()] = rand();
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    tr1::unordered_map<int, int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    tr1::unordered_map<int, int> val2 = ret.get().as<tr1::unordered_map<int, int> >();
     EXPECT_EQ(val1.size(), val2.size());
     tr1::unordered_map<int, int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it) {
@@ -544,13 +479,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
     }
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    tr1::unordered_multimap<int, int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    tr1::unordered_multimap<int, int> val2 = ret.get().as<tr1::unordered_multimap<int, int> >();
 
     vector<pair<int, int> > v1, v2;
     tr1::unordered_multimap<int, int>::const_iterator it;
@@ -578,13 +509,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
       val1.insert(rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    tr1::unordered_set<int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    tr1::unordered_set<int> val2 = ret.get().as<tr1::unordered_set<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     tr1::unordered_set<int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it)
@@ -600,13 +527,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
       val1.insert(rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    tr1::unordered_multiset<int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    tr1::unordered_multiset<int> val2 = ret.get().as<tr1::unordered_multiset<int> >();
 
     vector<int> v1, v2;
     tr1::unordered_multiset<int>::const_iterator it;
@@ -634,13 +557,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map)
       val1[rand()] = rand();
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    unordered_map<int, int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    unordered_map<int, int> val2 = ret.get().as<unordered_map<int, int> >();
     EXPECT_EQ(val1.size(), val2.size());
     unordered_map<int, int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it) {
@@ -661,13 +580,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
     }
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    unordered_multimap<int, int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    unordered_multimap<int, int> val2 = ret.get().as<unordered_multimap<int, int> >();
 
     vector<pair<int, int> > v1, v2;
     unordered_multimap<int, int>::const_iterator it;
@@ -695,13 +610,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set)
       val1.insert(rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    unordered_set<int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    unordered_set<int> val2 = ret.get().as<unordered_set<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     unordered_set<int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it)
@@ -717,13 +628,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
       val1.insert(rand());
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    unordered_multiset<int> val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    unordered_multiset<int> val2 = ret.get().as<unordered_multiset<int> >();
 
     vector<int> v1, v2;
     unordered_multiset<int>::const_iterator it;
@@ -748,13 +655,9 @@ TEST(MSGPACK_CPP11, simple_tuple)
   msgpack::sbuffer sbuf;
   std::tuple<bool, std::string, double> val1(true, "kzk", 12.3);
   msgpack::pack(sbuf, val1);
-  msgpack::zone z;
-  msgpack::object obj;
-  msgpack::unpack_return ret =
-    msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-  EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-  std::tuple<bool, std::string, double> val2;
-  obj.convert(&val2);
+  msgpack::unpacked ret;
+  msgpack::unpack(ret, sbuf.data(), sbuf.size());
+  std::tuple<bool, std::string, double> val2 = ret.get().as<std::tuple<bool, std::string, double> >();
   EXPECT_EQ(val1, val2);
 }
 
@@ -777,15 +680,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
     TestClass val1;
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    TestClass val2;
-    val2.i = -1;
-    val2.s = "";
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    TestClass val2 = ret.get().as<TestClass>();
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
   }
@@ -832,15 +729,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
     TestClass2 val1;
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    TestClass val2;
-    val2.i = -1;
-    val2.s = "";
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    TestClass val2 = ret.get().as<TestClass>();
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
     EXPECT_FALSE(val2.s.empty());
@@ -873,16 +764,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
   TestEnumMemberClass val1;
   msgpack::sbuffer sbuf;
   msgpack::pack(sbuf, val1);
-  msgpack::zone z;
-  msgpack::object obj;
-  msgpack::unpack_return ret =
-    msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-  EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-  TestEnumMemberClass val2;
-  val2.t1 = TestEnumMemberClass::STATE_INVALID;
-  val2.t2 = TestEnumMemberClass::STATE_INVALID;
-  val2.t3 = TestEnumMemberClass::STATE_INVALID;
-  obj.convert(&val2);
+  msgpack::unpacked ret;
+  msgpack::unpack(ret, sbuf.data(), sbuf.size());
+  TestEnumMemberClass val2 = ret.get().as<TestEnumMemberClass>();
   EXPECT_EQ(val1.t1, val2.t1);
   EXPECT_EQ(val1.t2, val2.t2);
   EXPECT_EQ(val1.t3, val2.t3);
@@ -916,16 +800,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member)
   TestEnumClassMemberClass val1;
   msgpack::sbuffer sbuf;
   msgpack::pack(sbuf, val1);
-  msgpack::zone z;
-  msgpack::object obj;
-  msgpack::unpack_return ret =
-    msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-  EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-  TestEnumClassMemberClass val2;
-  val2.t1 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID;
-  val2.t2 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID;
-  val2.t3 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID;
-  obj.convert(&val2);
+  msgpack::unpacked ret;
+  msgpack::unpack(ret, sbuf.data(), sbuf.size());
+  TestEnumClassMemberClass val2 = ret.get().as<TestEnumClassMemberClass>();
   EXPECT_EQ(val1.t1, val2.t1);
   EXPECT_EQ(val1.t2, val2.t2);
   EXPECT_EQ(val1.t3, val2.t3);
@@ -981,13 +858,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
     TestUnionMemberClass val1(1.0);
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    TestUnionMemberClass val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    TestUnionMemberClass val2 = ret.get().as<TestUnionMemberClass>();
     EXPECT_EQ(val1.is_double, val2.is_double);
     EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
   }
@@ -996,13 +869,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
     TestUnionMemberClass val1(1);
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, val1);
-    msgpack::zone z;
-    msgpack::object obj;
-    msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
-    TestUnionMemberClass val2;
-    obj.convert(&val2);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    TestUnionMemberClass val2 = ret.get().as<TestUnionMemberClass>();
     EXPECT_EQ(val1.is_double, val2.is_double);
     EXPECT_EQ(val1.value.i, 1);
     EXPECT_EQ(val1.value.i, val2.value.i);
@@ -1024,13 +893,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
       const struct iovec* end = cur + vbuf.vector_size();               \
       for(; cur != end; ++cur)                                          \
         sbuf.write((const char*)cur->iov_base, cur->iov_len);           \
-      msgpack::zone z;                                                  \
-      msgpack::object obj;                                              \
-      msgpack::unpack_return ret =                                      \
-        msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);              \
-      EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);                          \
-      test_type val2;                                                   \
-      obj.convert(&val2);                                               \
+      msgpack::unpacked ret;                                            \
+      msgpack::unpack(ret, sbuf.data(), sbuf.size());                   \
+      test_type val2 = ret.get().as<test_type>();                       \
       EXPECT_EQ(val1, val2);                                            \
     }                                                                   \
   } while(0);
diff --git a/test/object.cc b/test/object.cc
index 8742179f..88490fb5 100644
--- a/test/object.cc
+++ b/test/object.cc
@@ -33,15 +33,11 @@ TEST(object, convert)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, m1);
 
-    msgpack::zone z;
-    msgpack::object obj;
-
-    msgpack::unpack_return ret =
-        msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
 
     myclass m2;
-    obj.convert(&m2);
+    ret.get().convert(&m2);
 
     EXPECT_EQ(m1, m2);
 }
@@ -54,14 +50,10 @@ TEST(object, as)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, m1);
 
-    msgpack::zone z;
-    msgpack::object obj;
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
 
-    msgpack::unpack_return ret =
-        msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
-    EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
-
-    EXPECT_EQ(m1, obj.as<myclass>());
+    EXPECT_EQ(m1, ret.get().as<myclass>());
 }