generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-05-19 12:49:08 +02:00
Code Issues Projects Releases Wiki Activity

Restored the test cases using pointer based interfaces.

Browse Source 
It assures that we can use the same interfaces as the original version(0.5.6).
To support both C++03 and C++11, I introduced msgpack::unique_ptr and msgpack::move() in test codes.
This commit is contained in:
Takatoshi Kondo 2013-09-05 11:42:32 +09:00
parent 9bd339baf8
commit 4ef69da25d
6 changed files with 81 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
example/speed_test.cc
View File

@ -31,7 +31,7 @@ void test_map_pack_unpack() {
std::cout << "Start unpacking..." << std::endl; std::cout << "Start unpacking..." << std::endl;
{ {
boost::timer::cpu_timer timer; boost::timer::cpu_timer timer;
msgpack::unpack(str.data(), str.size(), NULL, mempool, deserialized); msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized);
std::string result = timer.format(); std::string result = timer.format();
std::cout << result << std::endl; std::cout << result << std::endl;
} }
@ -41,11 +41,20 @@ void test_map_pack_unpack() {
std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl;
{ {
boost::timer::cpu_timer timer; boost::timer::cpu_timer timer;
msgpack::unpack(unpacked, str.data(), str.size()); msgpack::unpack(&unpacked, str.data(), str.size());
std::string result = timer.format(); std::string result = timer.format();
std::cout << result << std::endl; std::cout << result << std::endl;
} }
std::cout << "Unpack finished..." << std::endl; std::cout << "Unpack finished..." << std::endl;
std::map<int, int> m2;
std::cout << "Start converting..." << std::endl;
{
boost::timer::cpu_timer timer;
deserialized.convert(&m2);
std::string result = timer.format();
std::cout << result << std::endl;
}
std::cout << "Convert finished..." << std::endl;
} }

6
test/convert.cc
View File

@ -20,7 +20,7 @@ TEST(convert, compatibility_less)
msgpack::object obj(src, &z); msgpack::object obj(src, &z);
compatibility c; compatibility c;
EXPECT_NO_THROW( obj.convert(c) ); EXPECT_NO_THROW( obj.convert(&c) );
EXPECT_EQ("kumofs", c.str1); EXPECT_EQ("kumofs", c.str1);
EXPECT_EQ("default", c.str2); EXPECT_EQ("default", c.str2);
@ -37,7 +37,7 @@ TEST(convert, compatibility_more)
msgpack::object obj(src, &z); msgpack::object obj(src, &z);
compatibility to; compatibility to;
EXPECT_NO_THROW( obj.convert(to) ); EXPECT_NO_THROW( obj.convert(&to) );
EXPECT_EQ("kumofs", to.str1); EXPECT_EQ("kumofs", to.str1);
EXPECT_EQ("mpio", to.str2); EXPECT_EQ("mpio", to.str2);
@ -69,7 +69,7 @@ TEST(convert, enum_member)
msgpack::object obj(src, &z); msgpack::object obj(src, &z);
enum_member to; enum_member to;
EXPECT_NO_THROW( obj.convert(to) ); EXPECT_NO_THROW( obj.convert(&to) );
EXPECT_EQ(enum_member::B, to.flag); EXPECT_EQ(enum_member::B, to.flag);
} }

4
test/fixint.cc
View File

@ -30,10 +30,10 @@ void check_convert() {
msgpack::pack(sbuf, v1); msgpack::pack(sbuf, v1);
msgpack::unpacked msg; msgpack::unpacked msg;
msgpack::unpack(msg, sbuf.data(), sbuf.size()); msgpack::unpack(&msg, sbuf.data(), sbuf.size());
T v2; T v2;
msg.get().convert(v2); msg.get().convert(&v2);
EXPECT_EQ(v1.get(), v2.get()); EXPECT_EQ(v1.get(), v2.get());

110
test/msgpack_test.cpp
View File

@ -38,10 +38,10 @@ const double kEPS = 1e-10;
msgpack::zone z; \ msgpack::zone z; \
msgpack::object obj; \ msgpack::object obj; \
msgpack::unpack_return ret = \ msgpack::unpack_return ret = \
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \
test_type val2; \ test_type val2; \
obj.convert(val2); \ obj.convert(&val2); \
EXPECT_EQ(val1, val2); \ EXPECT_EQ(val1, val2); \
} \ } \
} while(0) } while(0)
@ -165,10 +165,10 @@ TEST(MSGPACK, simple_buffer_float)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
float val2; float val2;
obj.convert(val2); obj.convert(&val2);
if (std::isnan(val1)) if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2)); EXPECT_TRUE(std::isnan(val2));
@ -255,10 +255,10 @@ TEST(MSGPACK, simple_buffer_double)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
double val2; double val2;
obj.convert(val2); obj.convert(&val2);
if (std::isnan(val1)) if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2)); EXPECT_TRUE(std::isnan(val2));
@ -277,10 +277,10 @@ TEST(MSGPACK, simple_buffer_true)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
bool val2; bool val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -292,10 +292,10 @@ TEST(MSGPACK, simple_buffer_false)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
bool val2; bool val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -314,10 +314,10 @@ TEST(MSGPACK_STL, simple_buffer_string)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
string val2; string val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -334,10 +334,10 @@ TEST(MSGPACK_STL, simple_buffer_vector)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
vector<int> val2; vector<int> val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
} }
@ -354,10 +354,10 @@ TEST(MSGPACK_STL, simple_buffer_map)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
map<int, int> val2; map<int, int> val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
} }
@ -374,10 +374,10 @@ TEST(MSGPACK_STL, simple_buffer_deque)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
deque<int> val2; deque<int> val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
} }
@ -394,10 +394,10 @@ TEST(MSGPACK_STL, simple_buffer_list)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
list<int> val2; list<int> val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
} }
@ -414,10 +414,10 @@ TEST(MSGPACK_STL, simple_buffer_set)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
set<int> val2; set<int> val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
} }
@ -432,10 +432,10 @@ TEST(MSGPACK_STL, simple_buffer_pair)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
pair<int, int> val2; pair<int, int> val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.first, val2.first); EXPECT_EQ(val1.first, val2.first);
EXPECT_EQ(val1.second, val2.second); EXPECT_EQ(val1.second, val2.second);
} }
@ -455,10 +455,10 @@ TEST(MSGPACK_STL, simple_buffer_multimap)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
multimap<int, int> val2; multimap<int, int> val2;
obj.convert(val2); obj.convert(&val2);
vector<pair<int, int> > v1, v2; vector<pair<int, int> > v1, v2;
multimap<int, int>::const_iterator it; multimap<int, int>::const_iterator it;
@ -485,10 +485,10 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
multiset<int> val2; multiset<int> val2;
obj.convert(val2); obj.convert(&val2);
vector<int> v1, v2; vector<int> v1, v2;
multiset<int>::const_iterator it; multiset<int>::const_iterator it;
@ -520,10 +520,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
tr1::unordered_map<int, int> val2; tr1::unordered_map<int, int> val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
tr1::unordered_map<int, int>::const_iterator it; tr1::unordered_map<int, int>::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it) { for (it = val1.begin(); it != val1.end(); ++it) {
@ -547,10 +547,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
tr1::unordered_multimap<int, int> val2; tr1::unordered_multimap<int, int> val2;
obj.convert(val2); obj.convert(&val2);
vector<pair<int, int> > v1, v2; vector<pair<int, int> > v1, v2;
tr1::unordered_multimap<int, int>::const_iterator it; tr1::unordered_multimap<int, int>::const_iterator it;
@ -581,10 +581,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
tr1::unordered_set<int> val2; tr1::unordered_set<int> val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
tr1::unordered_set<int>::const_iterator it; tr1::unordered_set<int>::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it) for (it = val1.begin(); it != val1.end(); ++it)
@ -603,10 +603,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
tr1::unordered_multiset<int> val2; tr1::unordered_multiset<int> val2;
obj.convert(val2); obj.convert(&val2);
vector<int> v1, v2; vector<int> v1, v2;
tr1::unordered_multiset<int>::const_iterator it; tr1::unordered_multiset<int>::const_iterator it;
@ -760,12 +760,12 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
TestClass val2; TestClass val2;
val2.i = -1; val2.i = -1;
val2.s = ""; val2.s = "";
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s); EXPECT_EQ(val1.s, val2.s);
} }
@ -793,13 +793,13 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
TestClass2 val2; TestClass2 val2;
val2.i = -1; val2.i = -1;
val2.s = ""; val2.s = "";
val2.v = vector<int>(); val2.v = vector<int>();
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s); EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(val2.s.empty()); EXPECT_FALSE(val2.s.empty());
@ -815,12 +815,12 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
TestClass val2; TestClass val2;
val2.i = -1; val2.i = -1;
val2.s = ""; val2.s = "";
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s); EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(val2.s.empty()); EXPECT_FALSE(val2.s.empty());
@ -856,13 +856,13 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
TestEnumMemberClass val2; TestEnumMemberClass val2;
val2.t1 = TestEnumMemberClass::STATE_INVALID; val2.t1 = TestEnumMemberClass::STATE_INVALID;
val2.t2 = TestEnumMemberClass::STATE_INVALID; val2.t2 = TestEnumMemberClass::STATE_INVALID;
val2.t3 = TestEnumMemberClass::STATE_INVALID; val2.t3 = TestEnumMemberClass::STATE_INVALID;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t1, val2.t1);
EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t2, val2.t2);
EXPECT_EQ(val1.t3, val2.t3); EXPECT_EQ(val1.t3, val2.t3);
@ -899,13 +899,13 @@ public:
void msgpack_unpack(msgpack::object o) void msgpack_unpack(msgpack::object o)
{ {
msgpack::type::tuple<bool, msgpack::object> tuple; msgpack::type::tuple<bool, msgpack::object> tuple;
o.convert(tuple); o.convert(&tuple);
is_double = msgpack::type::get<0>(tuple); is_double = tuple.get<0>();
if (is_double) if (is_double)
msgpack::type::get<1>(tuple).convert(value.f); tuple.get<1>().convert(&value.f);
else else
msgpack::type::get<1>(tuple).convert(value.i); tuple.get<1>().convert(&value.i);
} }
}; };
@ -919,10 +919,10 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
TestUnionMemberClass val2; TestUnionMemberClass val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_EQ(val1.is_double, val2.is_double);
EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
} }
@ -934,10 +934,10 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
msgpack::zone z; msgpack::zone z;
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
TestUnionMemberClass val2; TestUnionMemberClass val2;
obj.convert(val2); obj.convert(&val2);
EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_EQ(val1.is_double, val2.is_double);
EXPECT_EQ(val1.value.i, 1); EXPECT_EQ(val1.value.i, 1);
EXPECT_EQ(val1.value.i, val2.value.i); EXPECT_EQ(val1.value.i, val2.value.i);
@ -962,10 +962,10 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
msgpack::zone z; \ msgpack::zone z; \
msgpack::object obj; \ msgpack::object obj; \
msgpack::unpack_return ret = \ msgpack::unpack_return ret = \
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \
test_type val2; \ test_type val2; \
obj.convert(val2); \ obj.convert(&val2); \
EXPECT_EQ(val1, val2); \ EXPECT_EQ(val1, val2); \
} \ } \
} while(0); } while(0);
@ -1094,7 +1094,7 @@ TEST(MSGPACK, vrefbuffer_int64)
EXPECT_TRUE(life != NULL); \ EXPECT_TRUE(life != NULL); \
pac.reset(); \ pac.reset(); \
vec_type::value_type val; \ vec_type::value_type val; \
obj.convert(val); \ obj.convert(&val); \
EXPECT_EQ(*it, val); \ EXPECT_EQ(*it, val); \
++it; \ ++it; \
msgpack::zone::destroy(life); \ msgpack::zone::destroy(life); \

6
test/object.cc
View File

@ -37,11 +37,11 @@ TEST(object, convert)
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
myclass m2; myclass m2;
obj.convert(m2); obj.convert(&m2);
EXPECT_EQ(m1, m2); EXPECT_EQ(m1, m2);
} }
@ -58,7 +58,7 @@ TEST(object, as)
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
EXPECT_EQ(m1, obj.as<myclass>()); EXPECT_EQ(m1, obj.as<myclass>());

14
test/pack_unpack.cc
View File

@ -60,7 +60,7 @@ TEST(unpack, myclass)
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret = msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
@ -81,13 +81,13 @@ TEST(unpack, sequence)
msgpack::unpacked msg; msgpack::unpacked msg;
msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset); msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, msg.get().as<int>());
msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset); msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
EXPECT_EQ(2, msg.get().as<int>()); EXPECT_EQ(2, msg.get().as<int>());
msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset); msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
EXPECT_EQ(3, msg.get().as<int>()); EXPECT_EQ(3, msg.get().as<int>());
} }
@ -105,17 +105,17 @@ TEST(unpack, sequence_compat)
msgpack::object obj; msgpack::object obj;
msgpack::unpack_return ret; msgpack::unpack_return ret;
ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj);
EXPECT_TRUE(ret >= 0); EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
EXPECT_EQ(1, obj.as<int>()); EXPECT_EQ(1, obj.as<int>());
ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj);
EXPECT_TRUE(ret >= 0); EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
EXPECT_EQ(2, obj.as<int>()); EXPECT_EQ(2, obj.as<int>());
ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj);
EXPECT_TRUE(ret >= 0); EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
EXPECT_EQ(3, obj.as<int>()); EXPECT_EQ(3, obj.as<int>());