generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-06-26 06:25:22 +02:00
Code Issues Projects Releases Wiki Activity

Merge pull request #448 from redboltz/replace_unpacked_with_object_handle

Browse Source 
Replaced msgpack::unpacked with msgpack::object_handle.
This commit is contained in:
Takatoshi Kondo 2016-03-21 17:27:15 +09:00
commit a83e43a52f
43 changed files with 2357 additions and 2359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
QUICKSTART-CPP.md
View File

@ -31,11 +31,11 @@ int main(void) {
msgpack::pack(sbuf, vec); msgpack::pack(sbuf, vec);
// deserialize it. // deserialize it.
msgpack::unpacked msg; msgpack::object_handle oh =
msgpack::unpack(&msg, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
// print the deserialized object. // print the deserialized object.
msgpack::object obj = msg.get(); msgpack::object obj = oh.get();
std::cout << obj << std::endl; //=> ["Hello", "MessagePack"] std::cout << obj << std::endl; //=> ["Hello", "MessagePack"]
// convert it into statically typed object. // convert it into statically typed object.
@ -79,9 +79,9 @@ int main(void) {
pac.buffer_consumed(buffer.size()); pac.buffer_consumed(buffer.size());
// now starts streaming deserialization. // now starts streaming deserialization.
msgpack::unpacked result; msgpack::object_handle oh;
while(pac.next(&result)) { while(pac.next(&oh)) {
std::cout << result.get() << std::endl; std::cout << oh.get() << std::endl;
} }
// results: // results:
@ -151,10 +151,10 @@ int main(void) {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, vec); msgpack::pack(sbuf, vec);
msgpack::unpacked msg; msgpack::object_handle oh =
msgpack::unpack(&msg, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::object obj = msg.get(); msgpack::object obj = oh.get();
// you can convert object to myclass directly // you can convert object to myclass directly
std::vector<myclass> rvec; std::vector<myclass> rvec;

9
README.md
View File

@ -83,12 +83,11 @@ int main(void)
// deserialize the buffer into msgpack::object instance. // deserialize the buffer into msgpack::object instance.
std::string str(buffer.str()); std::string str(buffer.str());
msgpack::unpacked result; msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::unpack(result, str.data(), str.size()); // deserialized object is valid during the msgpack::object_handle instance is alive.
msgpack::object deserialized = oh.get();
// deserialized object is valid during the msgpack::unpacked instance alive.
msgpack::object deserialized = result.get();
// msgpack::object supports ostream. // msgpack::object supports ostream.
std::cout << deserialized << std::endl; std::cout << deserialized << std::endl;

8
example/boost/msgpack_variant_capitalize.cpp
View File

@ -73,8 +73,8 @@ int main() {
msgpack::pack(ss1, u); msgpack::pack(ss1, u);
print(ss1.str()); print(ss1.str());
msgpack::unpacked unp1 = msgpack::unpack(ss1.str().data(), ss1.str().size()); msgpack::object_handle oh1 = msgpack::unpack(ss1.str().data(), ss1.str().size());
msgpack::object const& obj1 = unp1.get(); msgpack::object const& obj1 = oh1.get();
std::cout << "Unpacked msgpack object." << std::endl; std::cout << "Unpacked msgpack object." << std::endl;
std::cout << obj1 << std::endl; std::cout << obj1 << std::endl;
@ -87,8 +87,8 @@ int main() {
msgpack::pack(ss2, v); msgpack::pack(ss2, v);
print(ss2.str()); print(ss2.str());
msgpack::unpacked unp2 = msgpack::unpack(ss2.str().data(), ss2.str().size()); msgpack::object_handle oh2 = msgpack::unpack(ss2.str().data(), ss2.str().size());
msgpack::object const& obj2 = unp2.get(); msgpack::object const& obj2 = oh2.get();
std::cout << "Modified msgpack object." << std::endl; std::cout << "Modified msgpack object." << std::endl;
std::cout << obj2 << std::endl; std::cout << obj2 << std::endl;
} }

4
example/boost/msgpack_variant_mapbased.cpp
View File

@ -79,8 +79,8 @@ int main() {
u.address = "Tokyo"; u.address = "Tokyo";
msgpack::pack(ss, u); msgpack::pack(ss, u);
msgpack::unpacked unp = msgpack::unpack(ss.str().data(), ss.str().size()); msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::object const& obj = unp.get(); msgpack::object const& obj = oh.get();
std::cout << "Unpacked msgpack object." << std::endl; std::cout << "Unpacked msgpack object." << std::endl;
std::cout << obj << std::endl; std::cout << obj << std::endl;
msgpack::type::variant_ref v = obj.as<msgpack::type::variant_ref>(); msgpack::type::variant_ref v = obj.as<msgpack::type::variant_ref>();

6
example/cpp03/class_intrusive.cpp
View File

@ -84,9 +84,9 @@ int main() {
print(ss.str()); print(ss.str());
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::object obj = unp.get(); msgpack::object obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<my_class>() == my); assert(obj.as<my_class>() == my);
} }

6
example/cpp03/class_intrusive_map.cpp
View File

@ -59,9 +59,9 @@ int main() {
print(ss.str()); print(ss.str());
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::object obj = unp.get(); msgpack::object obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<my_class>() == my); assert(obj.as<my_class>() == my);
} }

6
example/cpp03/class_non_intrusive.cpp
View File

@ -102,9 +102,9 @@ int main() {
print(ss.str()); print(ss.str());
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::object obj = unp.get(); msgpack::object obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<my_class>() == my); assert(obj.as<my_class>() == my);
} }

12
example/cpp03/custom.cpp
View File

@ -40,9 +40,9 @@ int main(void)
std::stringstream sbuf; std::stringstream sbuf;
msgpack::pack(sbuf, oc); msgpack::pack(sbuf, oc);
msgpack::unpacked result; msgpack::object_handle oh =
msgpack::unpack(result, sbuf.str().data(), sbuf.str().size()); msgpack::unpack(sbuf.str().data(), sbuf.str().size());
msgpack::object obj = result.get(); msgpack::object obj = oh.get();
obj.convert(nc); obj.convert(nc);
@ -56,9 +56,9 @@ int main(void)
std::stringstream sbuf; std::stringstream sbuf;
msgpack::pack(sbuf, nc); msgpack::pack(sbuf, nc);
msgpack::unpacked result; msgpack::object_handle oh =
msgpack::unpack(result, sbuf.str().data(), sbuf.str().size()); msgpack::unpack(sbuf.str().data(), sbuf.str().size());
msgpack::object obj = result.get(); msgpack::object obj = oh.get();
obj.convert(oc); obj.convert(oc);

20
example/cpp03/enum.cpp
View File

@ -30,20 +30,20 @@ int main(void)
my_enum e3 = elem3; my_enum e3 = elem3;
msgpack::pack(sbuf, e3); msgpack::pack(sbuf, e3);
msgpack::unpacked result; msgpack::object_handle oh;
std::size_t off = 0; std::size_t off = 0;
msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off); msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
std::cout << result.get().as<my_enum>() << std::endl; std::cout << oh.get().as<my_enum>() << std::endl;
assert(result.get().as<my_enum>() == elem1); assert(oh.get().as<my_enum>() == elem1);
msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off); msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
std::cout << result.get().as<my_enum>() << std::endl; std::cout << oh.get().as<my_enum>() << std::endl;
assert(result.get().as<my_enum>() == elem2); assert(oh.get().as<my_enum>() == elem2);
msgpack::unpack(result, sbuf.str().data(), sbuf.str().size(), off); msgpack::unpack(oh, sbuf.str().data(), sbuf.str().size(), off);
std::cout << result.get().as<my_enum>() << std::endl; std::cout << oh.get().as<my_enum>() << std::endl;
assert(result.get().as<my_enum>() == elem3); assert(oh.get().as<my_enum>() == elem3);
} }
{ // create object without zone { // create object without zone
msgpack::object obj(elem2); msgpack::object obj(elem2);

4
example/cpp03/map_based_versionup.cpp
View File

@ -71,9 +71,9 @@ int main() {
print(ss.str()); print(ss.str());
msgpack::unpacked unp = msgpack::unpack(ss.str().data(), ss.str().size()); msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::object obj = unp.get(); msgpack::object obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
v2 newv = obj.as<v2>(); v2 newv = obj.as<v2>();

12
example/cpp03/protocol.cpp
View File

@ -57,9 +57,9 @@ int main(void)
{ {
std::string buffer(stream.str()); std::string buffer(stream.str());
msgpack::unpacked result; msgpack::object_handle oh =
msgpack::unpack(result, buffer.data(), buffer.size()); msgpack::unpack(buffer.data(), buffer.size());
msgpack::object o = result.get(); msgpack::object o = oh.get();
myprotocol::Get req; myprotocol::Get req;
o.convert(req); o.convert(req);
@ -85,9 +85,9 @@ int main(void)
{ {
std::string buffer(stream.str()); std::string buffer(stream.str());
msgpack::unpacked result; msgpack::object_handle oh =
msgpack::unpack(result, buffer.data(), buffer.size()); msgpack::unpack(buffer.data(), buffer.size());
msgpack::object o = result.get(); msgpack::object o = oh.get();
myprotocol::MultiGet req; myprotocol::MultiGet req;

12
example/cpp03/protocol_new.cpp
View File

@ -44,9 +44,9 @@ int main(void)
{ {
std::string buffer(stream.str()); std::string buffer(stream.str());
msgpack::unpacked result; msgpack::object_handle oh =
msgpack::unpack(result, buffer.data(), buffer.size()); msgpack::unpack(buffer.data(), buffer.size());
msgpack::object o = result.get(); msgpack::object o = oh.get();
myprotocol::Get req; myprotocol::Get req;
o.convert(req); o.convert(req);
@ -72,9 +72,9 @@ int main(void)
{ {
std::string buffer(stream.str()); std::string buffer(stream.str());
msgpack::unpacked result; msgpack::object_handle oh =
msgpack::unpack(result, buffer.data(), buffer.size()); msgpack::unpack(buffer.data(), buffer.size());
msgpack::object o = result.get(); msgpack::object o = oh.get();
myprotocol::MultiGet req; myprotocol::MultiGet req;

8
example/cpp03/simple.cpp
View File

@ -27,12 +27,10 @@ int main(void)
// deserialize the buffer into msgpack::object instance. // deserialize the buffer into msgpack::object instance.
std::string str(buffer.str()); std::string str(buffer.str());
msgpack::unpacked result; msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
msgpack::unpack(result, str.data(), str.size()); // deserialized object is valid during the msgpack::object_handle instance alive.
msgpack::object deserialized = oh.get();
// deserialized object is valid during the msgpack::unpacked instance alive.
msgpack::object deserialized = result.get();
// msgpack::object supports ostream. // msgpack::object supports ostream.
std::cout << deserialized << std::endl; std::cout << deserialized << std::endl;

8
example/cpp03/speed_test.cpp
View File

@ -37,11 +37,11 @@ void test_map_pack_unpack() {
buffer.seekg(0); buffer.seekg(0);
std::string str(buffer.str()); std::string str(buffer.str());
msgpack::unpacked unpacked; msgpack::object_handle oh;
std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl; std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
{ {
boost::timer::cpu_timer timer; boost::timer::cpu_timer timer;
msgpack::unpack(unpacked, str.data(), str.size()); msgpack::unpack(oh, str.data(), str.size());
std::string result = timer.format(); std::string result = timer.format();
std::cout << result << std::endl; std::cout << result << std::endl;
} }
@ -50,7 +50,7 @@ void test_map_pack_unpack() {
std::cout << "Start converting..." << std::endl; std::cout << "Start converting..." << std::endl;
{ {
boost::timer::cpu_timer timer; boost::timer::cpu_timer timer;
unpacked.get().convert(m2); oh.get().convert(m2);
std::string result = timer.format(); std::string result = timer.format();
std::cout << result << std::endl; std::cout << result << std::endl;
} }

8
example/cpp03/speed_test_nested_array.cpp
View File

@ -60,11 +60,11 @@ void test_array_of_array() {
buffer.seekg(0); buffer.seekg(0);
std::string str(buffer.str()); std::string str(buffer.str());
msgpack::unpacked unpacked; msgpack::object_handle oh;
std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl; std::cout << "Start unpacking...by void unpack(object_handle& oh, const char* data, size_t len)" << std::endl;
{ {
boost::timer::cpu_timer timer; boost::timer::cpu_timer timer;
msgpack::unpack(unpacked, str.data(), str.size()); msgpack::unpack(oh, str.data(), str.size());
std::string result = timer.format(); std::string result = timer.format();
std::cout << result << std::endl; std::cout << result << std::endl;
} }
@ -73,7 +73,7 @@ void test_array_of_array() {
std::cout << "Start converting..." << std::endl; std::cout << "Start converting..." << std::endl;
{ {
boost::timer::cpu_timer timer; boost::timer::cpu_timer timer;
unpacked.get().convert(v2); oh.get().convert(v2);
std::string result = timer.format(); std::string result = timer.format();
std::cout << result << std::endl; std::cout << result << std::endl;
} }

8
example/cpp03/stream.cpp
View File

@ -43,10 +43,10 @@ public:
m_pac.buffer_consumed(count); m_pac.buffer_consumed(count);
msgpack::unpacked result; msgpack::object_handle oh;
while (m_pac.next(&result)) { while (m_pac.next(&oh)) {
msgpack::object msg = result.get(); msgpack::object msg = oh.get();
unique_zone& life = result.zone(); unique_zone& life = oh.zone();
process_message(msg, life); process_message(msg, life);
} }

40
example/cpp11/container.cpp
View File

@ -25,8 +25,8 @@ void array() {
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, a); msgpack::pack(ss, a);
msgpack::unpacked und = msgpack::unpack(ss.str().data(), ss.str().size()); msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::object obj = und.get(); msgpack::object obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert((obj.as<std::array<int, 5>>()) == a); assert((obj.as<std::array<int, 5>>()) == a);
@ -37,8 +37,8 @@ void tuple() {
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, t); msgpack::pack(ss, t);
auto und = msgpack::unpack(ss.str().data(), ss.str().size()); auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
auto obj = und.get(); auto obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<decltype(t)>() == t); assert(obj.as<decltype(t)>() == t);
@ -49,8 +49,8 @@ void unordered_map() {
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, m); msgpack::pack(ss, m);
auto und = msgpack::unpack(ss.str().data(), ss.str().size()); auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::object obj = und.get(); msgpack::object obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<decltype(m)>() == m); assert(obj.as<decltype(m)>() == m);
@ -61,8 +61,8 @@ void unordered_set() {
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, s); msgpack::pack(ss, s);
auto und = msgpack::unpack(ss.str().data(), ss.str().size()); auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
auto obj = und.get(); auto obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<decltype(s)>() == s); assert(obj.as<decltype(s)>() == s);
@ -74,8 +74,8 @@ void forward_list() {
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, f); msgpack::pack(ss, f);
auto und = msgpack::unpack(ss.str().data(), ss.str().size()); auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
auto obj = und.get(); auto obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<type>() == f); assert(obj.as<type>() == f);
@ -98,40 +98,40 @@ void combi() {
std::size_t offset = 0; std::size_t offset = 0;
std::cout << "offset: " << offset << std::endl; std::cout << "offset: " << offset << std::endl;
{ {
auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset); auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
auto obj = und.get(); auto obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<decltype(a)>() == a); assert(obj.as<decltype(a)>() == a);
} }
std::cout << "offset: " << offset << std::endl; std::cout << "offset: " << offset << std::endl;
{ {
auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset); auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
auto obj = und.get(); auto obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<decltype(t)>() == t); assert(obj.as<decltype(t)>() == t);
} }
std::cout << "offset: " << offset << std::endl; std::cout << "offset: " << offset << std::endl;
{ {
auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset); auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
auto obj = und.get(); auto obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<decltype(m)>() == m); assert(obj.as<decltype(m)>() == m);
} }
std::cout << "offset: " << offset << std::endl; std::cout << "offset: " << offset << std::endl;
{ {
auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset); auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
auto obj = und.get(); auto obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<decltype(s)>() == s); assert(obj.as<decltype(s)>() == s);
} }
std::cout << "offset: " << offset << std::endl; std::cout << "offset: " << offset << std::endl;
{ {
auto und = msgpack::unpack(ss.str().data(), ss.str().size(), offset); auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
auto obj = und.get(); auto obj = oh.get();
std::cout << obj << std::endl; std::cout << obj << std::endl;
assert(obj.as<decltype(f)>() == f); assert(obj.as<decltype(f)>() == f);

36
include/msgpack/v1/unpack.hpp
View File

@ -1003,7 +1003,7 @@ public:
* This function is obsolete. Use the reference inteface version of next() function instead of * This function is obsolete. Use the reference inteface version of next() function instead of
* the pointer interface version. * the pointer interface version.
*/ */
bool next(unpacked* result); bool next(object_handle* result);
/// Unpack one msgpack::object. /// Unpack one msgpack::object.
/** /**
@ -1019,7 +1019,7 @@ public:
* See: * See:
* https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer * https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer
*/ */
bool next(unpacked& result, bool& referenced); bool next(object_handle& result, bool& referenced);
/// Unpack one msgpack::object. /// Unpack one msgpack::object.
/** /**
@ -1033,7 +1033,7 @@ public:
* See: * See:
* https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer * https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer
*/ */
bool next(unpacked& result); bool next(object_handle& result);
/// Get message size. /// Get message size.
/** /**
@ -1281,7 +1281,7 @@ inline void unpacker::buffer_consumed(std::size_t size)
m_free -= size; m_free -= size;
} }
inline bool unpacker::next(unpacked& result, bool& referenced) inline bool unpacker::next(object_handle& result, bool& referenced)
{ {
referenced = false; referenced = false;
int ret = execute_imp(); int ret = execute_imp();
@ -1303,13 +1303,13 @@ inline bool unpacker::next(unpacked& result, bool& referenced)
} }
} }
inline bool unpacker::next(unpacked& result) inline bool unpacker::next(object_handle& result)
{ {
bool referenced; bool referenced;
return next(result, referenced); return next(result, referenced);
} }
inline bool unpacker::next(unpacked* result) inline bool unpacker::next(object_handle* result)
{ {
return next(*result); return next(*result);
} }
@ -1461,7 +1461,7 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off,
// reference version // reference version
inline unpacked unpack( inline object_handle unpack(
const char* data, std::size_t len, std::size_t& off, bool& referenced, const char* data, std::size_t len, std::size_t& off, bool& referenced,
unpack_reference_func f, void* user_data, unpack_reference_func f, void* user_data,
unpack_limit const& limit unpack_limit const& limit
@ -1477,20 +1477,20 @@ inline unpacked unpack(
switch(ret) { switch(ret) {
case UNPACK_SUCCESS: case UNPACK_SUCCESS:
off = noff; off = noff;
return unpacked(obj, msgpack::move(z)); return object_handle(obj, msgpack::move(z));
case UNPACK_EXTRA_BYTES: case UNPACK_EXTRA_BYTES:
off = noff; off = noff;
return unpacked(obj, msgpack::move(z)); return object_handle(obj, msgpack::move(z));
case UNPACK_CONTINUE: case UNPACK_CONTINUE:
throw msgpack::insufficient_bytes("insufficient bytes"); throw msgpack::insufficient_bytes("insufficient bytes");
case UNPACK_PARSE_ERROR: case UNPACK_PARSE_ERROR:
default: default:
throw msgpack::parse_error("parse error"); throw msgpack::parse_error("parse error");
} }
return unpacked(); return object_handle();
} }
inline unpacked unpack( inline object_handle unpack(
const char* data, std::size_t len, std::size_t& off, const char* data, std::size_t len, std::size_t& off,
unpack_reference_func f, void* user_data, unpack_reference_func f, void* user_data,
unpack_limit const& limit) unpack_limit const& limit)
@ -1499,7 +1499,7 @@ inline unpacked unpack(
return unpack(data, len, off, referenced, f, user_data, limit); return unpack(data, len, off, referenced, f, user_data, limit);
} }
inline unpacked unpack( inline object_handle unpack(
const char* data, std::size_t len, bool& referenced, const char* data, std::size_t len, bool& referenced,
unpack_reference_func f, void* user_data, unpack_reference_func f, void* user_data,
unpack_limit const& limit) unpack_limit const& limit)
@ -1508,7 +1508,7 @@ inline unpacked unpack(
return unpack(data, len, off, referenced, f, user_data, limit); return unpack(data, len, off, referenced, f, user_data, limit);
} }
inline unpacked unpack( inline object_handle unpack(
const char* data, std::size_t len, const char* data, std::size_t len,
unpack_reference_func f, void* user_data, unpack_reference_func f, void* user_data,
unpack_limit const& limit) unpack_limit const& limit)
@ -1519,7 +1519,7 @@ inline unpacked unpack(
} }
inline void unpack( inline void unpack(
unpacked& result, object_handle& result,
const char* data, std::size_t len, std::size_t& off, bool& referenced, const char* data, std::size_t len, std::size_t& off, bool& referenced,
unpack_reference_func f, void* user_data, unpack_reference_func f, void* user_data,
unpack_limit const& limit) unpack_limit const& limit)
@ -1551,7 +1551,7 @@ inline void unpack(
} }
inline void unpack( inline void unpack(
unpacked& result, object_handle& result,
const char* data, std::size_t len, std::size_t& off, const char* data, std::size_t len, std::size_t& off,
unpack_reference_func f, void* user_data, unpack_reference_func f, void* user_data,
unpack_limit const& limit) unpack_limit const& limit)
@ -1561,7 +1561,7 @@ inline void unpack(
} }
inline void unpack( inline void unpack(
unpacked& result, object_handle& result,
const char* data, std::size_t len, bool& referenced, const char* data, std::size_t len, bool& referenced,
unpack_reference_func f, void* user_data, unpack_reference_func f, void* user_data,
unpack_limit const& limit) unpack_limit const& limit)
@ -1571,7 +1571,7 @@ inline void unpack(
} }
inline void unpack( inline void unpack(
unpacked& result, object_handle& result,
const char* data, std::size_t len, const char* data, std::size_t len,
unpack_reference_func f, void* user_data, unpack_reference_func f, void* user_data,
unpack_limit const& limit) unpack_limit const& limit)
@ -1644,7 +1644,7 @@ inline msgpack::object unpack(
// obsolete // obsolete
// pointer version // pointer version
inline void unpack( inline void unpack(
unpacked* result, object_handle* result,
const char* data, std::size_t len, std::size_t* off, bool* referenced, const char* data, std::size_t len, std::size_t* off, bool* referenced,
unpack_reference_func f, void* user_data, unpack_reference_func f, void* user_data,
unpack_limit const& limit) unpack_limit const& limit)

36
include/msgpack/v1/unpack_decl.hpp
View File

@ -218,10 +218,10 @@ class unpacker;
* @param user_data This parameter is passed to f. * @param user_data This parameter is passed to f.
* @param limit The size limit information of msgpack::object. * @param limit The size limit information of msgpack::object.
* *
* @return unpacked object that contains unpacked data. * @return object_handle that contains unpacked data.
* *
*/ */
unpacked unpack( object_handle unpack(
const char* data, std::size_t len, std::size_t& off, bool& referenced, const char* data, std::size_t len, std::size_t& off, bool& referenced,
unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit()); unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit());
@ -234,10 +234,10 @@ unpacked unpack(
* @param user_data This parameter is passed to f. * @param user_data This parameter is passed to f.
* @param limit The size limit information of msgpack::object. * @param limit The size limit information of msgpack::object.
* *
* @return unpacked object that contains unpacked data. * @return object_handle that contains unpacked data.
* *
*/ */
unpacked unpack( object_handle unpack(
const char* data, std::size_t len, std::size_t& off, const char* data, std::size_t len, std::size_t& off,
unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit()); unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit());
@ -250,10 +250,10 @@ unpacked unpack(
* @param user_data This parameter is passed to f. * @param user_data This parameter is passed to f.
* @param limit The size limit information of msgpack::object. * @param limit The size limit information of msgpack::object.
* *
* @return unpacked object that contains unpacked data. * @return object_handle that contains unpacked data.
* *
*/ */
unpacked unpack( object_handle unpack(
const char* data, std::size_t len, bool& referenced, const char* data, std::size_t len, bool& referenced,
unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit()); unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit());
@ -265,17 +265,17 @@ unpacked unpack(
* @param user_data This parameter is passed to f. * @param user_data This parameter is passed to f.
* @param limit The size limit information of msgpack::object. * @param limit The size limit information of msgpack::object.
* *
* @return unpacked object that contains unpacked data. * @return object_handle that contains unpacked data.
* *
*/ */
unpacked unpack( object_handle unpack(
const char* data, std::size_t len, const char* data, std::size_t len,
unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit()); unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit());
/// Unpack msgpack::object from a buffer. /// Unpack msgpack::object from a buffer.
/** /**
* @param result The object that contains unpacked data. * @param result The object_handle that contains unpacked data.
* @param data The pointer to the buffer. * @param data The pointer to the buffer.
* @param len The length of the buffer. * @param len The length of the buffer.
* @param off The offset position of the buffer. It is read and overwritten. * @param off The offset position of the buffer. It is read and overwritten.
@ -287,13 +287,13 @@ unpacked unpack(
* *
*/ */
void unpack( void unpack(
unpacked& result, object_handle& result,
const char* data, std::size_t len, std::size_t& off, bool& referenced, const char* data, std::size_t len, std::size_t& off, bool& referenced,
unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit()); unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit());
/// Unpack msgpack::object from a buffer. /// Unpack msgpack::object from a buffer.
/** /**
* @param result The object that contains unpacked data. * @param result The object_handle that contains unpacked data.
* @param data The pointer to the buffer. * @param data The pointer to the buffer.
* @param len The length of the buffer. * @param len The length of the buffer.
* @param off The offset position of the buffer. It is read and overwritten. * @param off The offset position of the buffer. It is read and overwritten.
@ -304,13 +304,13 @@ void unpack(
* *
*/ */
void unpack( void unpack(
unpacked& result, object_handle& result,
const char* data, std::size_t len, std::size_t& off, const char* data, std::size_t len, std::size_t& off,
unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit()); unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit());
/// Unpack msgpack::object from a buffer. /// Unpack msgpack::object from a buffer.
/** /**
* @param result The object that contains unpacked data. * @param result The object_handle that contains unpacked data.
* @param data The pointer to the buffer. * @param data The pointer to the buffer.
* @param len The length of the buffer. * @param len The length of the buffer.
* @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false. * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false.
@ -321,13 +321,13 @@ void unpack(
* *
*/ */
void unpack( void unpack(
unpacked& result, object_handle& result,
const char* data, std::size_t len, bool& referenced, const char* data, std::size_t len, bool& referenced,
unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit()); unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit());
/// Unpack msgpack::object from a buffer. /// Unpack msgpack::object from a buffer.
/** /**
* @param result The object that contains unpacked data. * @param result The object_handle that contains unpacked data.
* @param data The pointer to the buffer. * @param data The pointer to the buffer.
* @param len The length of the buffer. * @param len The length of the buffer.
* @param f A judging function that msgpack::object refer to the buffer. * @param f A judging function that msgpack::object refer to the buffer.
@ -337,7 +337,7 @@ void unpack(
* *
*/ */
void unpack( void unpack(
unpacked& result, object_handle& result,
const char* data, std::size_t len, const char* data, std::size_t len,
unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit()); unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit());
@ -416,7 +416,7 @@ msgpack::object unpack(
/// Unpack msgpack::object from a buffer. [obsolete] /// Unpack msgpack::object from a buffer. [obsolete]
/** /**
* @param result The object that contains unpacked data. * @param result The object_handle that contains unpacked data.
* @param data The pointer to the buffer. * @param data The pointer to the buffer.
* @param len The length of the buffer. * @param len The length of the buffer.
* @param off The offset position of the buffer. It is read and overwritten. * @param off The offset position of the buffer. It is read and overwritten.
@ -428,7 +428,7 @@ msgpack::object unpack(
* This function is obsolete. Use the reference inteface version of unpack functions instead of the pointer interface version. * This function is obsolete. Use the reference inteface version of unpack functions instead of the pointer interface version.
*/ */
void unpack( void unpack(
unpacked* result, object_handle* result,
const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr, const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr,
unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit()); unpack_reference_func f = nullptr, void* user_data = nullptr, unpack_limit const& limit = unpack_limit());

64
test/array_ref.cpp
View File

@ -20,12 +20,12 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char)
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, ar1); msgpack::pack(ss, ar1);
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
EXPECT_EQ(upd.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::vector<char> v2; std::vector<char> v2;
msgpack::type::array_ref<std::vector<char> > ar2(v2); msgpack::type::array_ref<std::vector<char> > ar2(v2);
upd.get().convert(ar2); oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2); EXPECT_TRUE(ar1 == ar2);
} }
@ -42,12 +42,12 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char_const)
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, ar1); msgpack::pack(ss, ar1);
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
EXPECT_EQ(upd.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::vector<char> v2; std::vector<char> v2;
msgpack::type::array_ref<std::vector<char> > ar2(v2); msgpack::type::array_ref<std::vector<char> > ar2(v2);
upd.get().convert(ar2); oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2); EXPECT_TRUE(ar1 == ar2);
} }
@ -62,12 +62,12 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char)
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, ar1); msgpack::pack(ss, ar1);
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
EXPECT_EQ(upd.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::vector<unsigned char> v2; std::vector<unsigned char> v2;
msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2); msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
upd.get().convert(ar2); oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2); EXPECT_TRUE(ar1 == ar2);
} }
@ -84,12 +84,12 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char_const)
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, ar1); msgpack::pack(ss, ar1);
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
EXPECT_EQ(upd.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::vector<unsigned char> v2; std::vector<unsigned char> v2;
msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2); msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
upd.get().convert(ar2); oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2); EXPECT_TRUE(ar1 == ar2);
} }
@ -179,12 +179,12 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char)
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, ar1); msgpack::pack(ss, ar1);
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
EXPECT_EQ(upd.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::array<char, 3> v2; std::array<char, 3> v2;
msgpack::type::array_ref<std::array<char, 3> > ar2(v2); msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
upd.get().convert(ar2); oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2); EXPECT_TRUE(ar1 == ar2);
} }
@ -198,12 +198,12 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char_const)
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, ar1); msgpack::pack(ss, ar1);
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
EXPECT_EQ(upd.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::array<char, 3> v2; std::array<char, 3> v2;
msgpack::type::array_ref<std::array<char, 3> > ar2(v2); msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
upd.get().convert(ar2); oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2); EXPECT_TRUE(ar1 == ar2);
} }
@ -215,12 +215,12 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char)
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, ar1); msgpack::pack(ss, ar1);
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
EXPECT_EQ(upd.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::array<unsigned char, 3> v2; std::array<unsigned char, 3> v2;
msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2); msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
upd.get().convert(ar2); oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2); EXPECT_TRUE(ar1 == ar2);
} }
@ -234,12 +234,12 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char_const)
std::stringstream ss; std::stringstream ss;
msgpack::pack(ss, ar1); msgpack::pack(ss, ar1);
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
EXPECT_EQ(upd.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::array<unsigned char, 3> v2; std::array<unsigned char, 3> v2;
msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2); msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
upd.get().convert(ar2); oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2); EXPECT_TRUE(ar1 == ar2);
} }

32
test/boost_fusion.cpp
View File

@ -21,7 +21,7 @@ BOOST_FUSION_DEFINE_STRUCT(
mystruct, mystruct,
(int, f1) (int, f1)
(double, f2) (double, f2)
) )
TEST(MSGPACK_BOOST, fusion_pack_unpack_convert) TEST(MSGPACK_BOOST, fusion_pack_unpack_convert)
{ {
@ -30,9 +30,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert)
val1.f1 = 42; val1.f1 = 42;
val1.f2 = 123.45; val1.f2 = 123.45;
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
mystruct val2 = ret.get().as<mystruct>(); mystruct val2 = oh.get().as<mystruct>();
EXPECT_TRUE(val1.f1 == val2.f1); EXPECT_TRUE(val1.f1 == val2.f1);
EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS); EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
} }
@ -84,27 +84,27 @@ inline bool operator!=(no_def_con2 const& lhs, no_def_con2 const& rhs) {
namespace msgpack { namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor { namespace adaptor {
template <> template <>
struct as<no_def_con1> { struct as<no_def_con1> {
no_def_con1 operator()(msgpack::object const& o) const { no_def_con1 operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error(); if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error(); if (o.via.array.size != 1) throw msgpack::type_error();
return no_def_con1(o.via.array.ptr[0].as<int>()); return no_def_con1(o.via.array.ptr[0].as<int>());
} }
}; };
template <> template <>
struct as<no_def_con2> { struct as<no_def_con2> {
no_def_con2 operator()(msgpack::object const& o) const { no_def_con2 operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error(); if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error(); if (o.via.array.size != 1) throw msgpack::type_error();
return no_def_con2(o.via.array.ptr[0].as<int>()); return no_def_con2(o.via.array.ptr[0].as<int>());
} }
}; };
} // adaptor } // adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // msgpack } // msgpack
@ -138,7 +138,7 @@ BOOST_FUSION_ADAPT_STRUCT(
f1, // *1 f1, // *1
f2, // *2 f2, // *2
f3 // *3 f3 // *3
) )
// MSVC2015's std::tuple requires default constructor during 'as' process. // MSVC2015's std::tuple requires default constructor during 'as' process.
@ -151,9 +151,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
std::stringstream ss; std::stringstream ss;
mystruct_no_def_con val1(no_def_con1(1), no_def_con2(2), no_def_con1(3)); mystruct_no_def_con val1(no_def_con1(1), no_def_con2(2), no_def_con1(3));
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
mystruct_no_def_con val2 = ret.get().as<mystruct_no_def_con>(); mystruct_no_def_con val2 = oh.get().as<mystruct_no_def_con>();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }

46
test/boost_optional.cpp
View File

@ -14,9 +14,9 @@ TEST(MSGPACK_BOOST, pack_convert_nil)
std::stringstream ss; std::stringstream ss;
boost::optional<int> val1; boost::optional<int> val1;
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
boost::optional<int> val2 = ret.get().as<boost::optional<int> >(); boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }
@ -25,9 +25,9 @@ TEST(MSGPACK_BOOST, pack_convert_int)
std::stringstream ss; std::stringstream ss;
boost::optional<int> val1 = 1; boost::optional<int> val1 = 1;
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
boost::optional<int> val2 = ret.get().as<boost::optional<int> >(); boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }
@ -42,9 +42,9 @@ TEST(MSGPACK_BOOST, pack_convert_vector)
v.push_back(3); v.push_back(3);
val1 = v; val1 = v;
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
ovi_t val2 = ret.get().as<ovi_t>(); ovi_t val2 = oh.get().as<ovi_t>();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }
@ -57,9 +57,9 @@ TEST(MSGPACK_BOOST, pack_convert_vector_optional)
val1[0] = 1; val1[0] = 1;
val1[2] = 3; val1[2] = 3;
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
voi_t val2 = ret.get().as<voi_t>(); voi_t val2 = oh.get().as<voi_t>();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }
@ -81,8 +81,8 @@ TEST(MSGPACK_BOOST, object_int)
// Compile error as expected // Compile error as expected
/* /*
TEST(MSGPACK_BOOST, object_vector) TEST(MSGPACK_BOOST, object_vector)
{ {
typedef boost::optional<std::vector<int> > ovi_t; typedef boost::optional<std::vector<int> > ovi_t;
ovi_t val1; ovi_t val1;
std::vector<int> v; std::vector<int> v;
@ -93,7 +93,7 @@ TEST(MSGPACK_BOOST, object_vector)
msgpack::object obj(val1); msgpack::object obj(val1);
ovi_t val2 = obj.as<ovi_t>(); ovi_t val2 = obj.as<ovi_t>();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }
*/ */
TEST(MSGPACK_BOOST, object_with_zone_nil) TEST(MSGPACK_BOOST, object_with_zone_nil)
@ -146,16 +146,16 @@ inline bool operator!=(no_def_con const& lhs, no_def_con const& rhs) {
namespace msgpack { namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor { namespace adaptor {
template <> template <>
struct as<no_def_con> { struct as<no_def_con> {
no_def_con operator()(msgpack::object const& o) const { no_def_con operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error(); if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error(); if (o.via.array.size != 1) throw msgpack::type_error();
return no_def_con(o.via.array.ptr[0].as<int>()); return no_def_con(o.via.array.ptr[0].as<int>());
} }
}; };
} // adaptor } // adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // msgpack } // msgpack
@ -164,9 +164,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
std::stringstream ss; std::stringstream ss;
boost::optional<no_def_con> val1 = no_def_con(1); boost::optional<no_def_con> val1 = no_def_con(1);
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
boost::optional<no_def_con> val2 = ret.get().as<boost::optional<no_def_con>>(); boost::optional<no_def_con> val2 = oh.get().as<boost::optional<no_def_con>>();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }

6
test/boost_string_ref.cpp
View File

@ -18,9 +18,9 @@ TEST(MSGPACK_BOOST, pack_convert_string_ref)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh;
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(oh, ss.str().data(), ss.str().size());
boost::string_ref val2 = ret.get().as<boost::string_ref>(); boost::string_ref val2 = oh.get().as<boost::string_ref>();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }

96
test/boost_variant.cpp
View File

@ -21,9 +21,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil)
EXPECT_TRUE(val1.is_nil()); EXPECT_TRUE(val1.is_nil());
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_nil()); EXPECT_TRUE(val2.is_nil());
EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2)); EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
} }
@ -59,9 +59,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil_default)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_nil()); EXPECT_TRUE(val2.is_nil());
EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2)); EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
} }
@ -98,9 +98,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_bool()); EXPECT_TRUE(val2.is_bool());
EXPECT_TRUE(val2.as_bool()); EXPECT_TRUE(val2.as_bool());
EXPECT_NO_THROW(boost::get<bool>(val2)); EXPECT_NO_THROW(boost::get<bool>(val2));
@ -151,9 +151,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_uint64_t()); EXPECT_TRUE(val2.is_uint64_t());
EXPECT_EQ(val2.as_uint64_t(), 123U); EXPECT_EQ(val2.as_uint64_t(), 123U);
EXPECT_NO_THROW(boost::get<uint64_t>(val2)); EXPECT_NO_THROW(boost::get<uint64_t>(val2));
@ -198,9 +198,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_int64_t()); EXPECT_TRUE(val2.is_int64_t());
EXPECT_EQ(val2.as_int64_t(), -123); EXPECT_EQ(val2.as_int64_t(), -123);
EXPECT_NO_THROW(boost::get<int64_t>(val2)); EXPECT_NO_THROW(boost::get<int64_t>(val2));
@ -245,9 +245,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_float)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_double()); EXPECT_TRUE(val2.is_double());
EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS); EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
EXPECT_NO_THROW(boost::get<double>(val2)); EXPECT_NO_THROW(boost::get<double>(val2));
@ -292,9 +292,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_str)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_string()); EXPECT_TRUE(val2.is_string());
EXPECT_EQ(val2.as_string(), "ABC"); EXPECT_EQ(val2.as_string(), "ABC");
EXPECT_NO_THROW(boost::get<std::string>(val2)); EXPECT_NO_THROW(boost::get<std::string>(val2));
@ -354,9 +354,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bin)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_vector_char()); EXPECT_TRUE(val2.is_vector_char());
EXPECT_EQ(val2.as_vector_char(), v); EXPECT_EQ(val2.as_vector_char(), v);
EXPECT_NO_THROW(boost::get<std::vector<char> >(val2)); EXPECT_NO_THROW(boost::get<std::vector<char> >(val2));
@ -425,9 +425,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ext)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_ext()); EXPECT_TRUE(val2.is_ext());
EXPECT_EQ(val2.as_ext(), e); EXPECT_EQ(val2.as_ext(), e);
EXPECT_NO_THROW(boost::get<msgpack::type::ext>(val2)); EXPECT_NO_THROW(boost::get<msgpack::type::ext>(val2));
@ -492,9 +492,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_vector()); EXPECT_TRUE(val2.is_vector());
EXPECT_EQ(val2.as_vector(), v); EXPECT_EQ(val2.as_vector(), v);
EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant> >(val2)); EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant> >(val2));
@ -534,9 +534,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant val2 = ret.get().as<msgpack::type::variant>(); msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_multimap()); EXPECT_TRUE(val2.is_multimap());
EXPECT_EQ(val2.as_multimap(), v); EXPECT_EQ(val2.as_multimap(), v);
EXPECT_NO_THROW(boost::get<multimap_t>(val2)); EXPECT_NO_THROW(boost::get<multimap_t>(val2));
@ -578,9 +578,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_str)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>(); msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_boost_string_ref()); EXPECT_TRUE(val2.is_boost_string_ref());
EXPECT_EQ(val2.as_boost_string_ref(), sr); EXPECT_EQ(val2.as_boost_string_ref(), sr);
EXPECT_NO_THROW(boost::get<boost::string_ref>(val2)); EXPECT_NO_THROW(boost::get<boost::string_ref>(val2));
@ -623,9 +623,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>(); msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_raw_ref()); EXPECT_TRUE(val2.is_raw_ref());
EXPECT_EQ(val2.as_raw_ref(), rr); EXPECT_EQ(val2.as_raw_ref(), rr);
EXPECT_NO_THROW(boost::get<msgpack::type::raw_ref>(val2)); EXPECT_NO_THROW(boost::get<msgpack::type::raw_ref>(val2));
@ -670,9 +670,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>(); msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_NO_THROW(boost::get<msgpack::type::ext_ref>(val2)); EXPECT_NO_THROW(boost::get<msgpack::type::ext_ref>(val2));
EXPECT_TRUE(val2.is_ext_ref()); EXPECT_TRUE(val2.is_ext_ref());
EXPECT_EQ(val2.as_ext_ref(), er); EXPECT_EQ(val2.as_ext_ref(), er);
@ -720,9 +720,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>(); msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_vector()); EXPECT_TRUE(val2.is_vector());
EXPECT_EQ(val2.as_vector(), v); EXPECT_EQ(val2.as_vector(), v);
EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant_ref> >(val2)); EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant_ref> >(val2));
@ -773,9 +773,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map)
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::variant_ref val2 = ret.get().as<msgpack::type::variant_ref>(); msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_multimap()); EXPECT_TRUE(val2.is_multimap());
EXPECT_EQ(val2.as_multimap(), v); EXPECT_EQ(val2.as_multimap(), v);
EXPECT_NO_THROW(boost::get<multimap_t>(val2)); EXPECT_NO_THROW(boost::get<multimap_t>(val2));

12
test/cases.cpp
View File

@ -26,12 +26,12 @@ TEST(cases, format)
feed_file(pac, "cases.mpac"); feed_file(pac, "cases.mpac");
feed_file(pac_compact, "cases_compact.mpac"); feed_file(pac_compact, "cases_compact.mpac");
msgpack::unpacked result; msgpack::object_handle oh;
while(pac.next(&result)) { while(pac.next(&oh)) {
msgpack::unpacked result_compact; msgpack::object_handle oh_compact;
EXPECT_TRUE( pac_compact.next(&result_compact) ); EXPECT_TRUE( pac_compact.next(&oh_compact) );
EXPECT_EQ(result_compact.get(), result.get()); EXPECT_EQ(oh_compact.get(), oh.get());
} }
EXPECT_FALSE( pac_compact.next(&result) ); EXPECT_FALSE( pac_compact.next(&oh) );
} }

8
test/fixint.cpp
View File

@ -29,15 +29,15 @@ void check_convert() {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, v1); msgpack::pack(sbuf, v1);
msgpack::unpacked msg; msgpack::object_handle oh =
msgpack::unpack(&msg, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
T v2; T v2;
msg.get().convert(v2); oh.get().convert(v2);
EXPECT_EQ(v1.get(), v2.get()); EXPECT_EQ(v1.get(), v2.get());
EXPECT_EQ(msg.get(), msgpack::object(T(v1.get()))); EXPECT_EQ(oh.get(), msgpack::object(T(v1.get())));
} }
TEST(fixint, convert) TEST(fixint, convert)

12
test/iterator_cpp11.cpp
View File

@ -26,10 +26,10 @@ TEST(iterator, vector)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, vec); msgpack::pack(sbuf, vec);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
auto const& msgarr = ret.get().via.array; auto const& msgarr = oh.get().via.array;
auto dist = std::distance(begin(msgarr), end(msgarr)); auto dist = std::distance(begin(msgarr), end(msgarr));
auto vecSize = vec.size(); auto vecSize = vec.size();
EXPECT_EQ(dist, vecSize); EXPECT_EQ(dist, vecSize);
@ -52,10 +52,10 @@ TEST(iterator, map)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, map); msgpack::pack(sbuf, map);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
auto const& msgmap = ret.get().via.map; auto const& msgmap = oh.get().via.map;
auto dist = std::distance(begin(msgmap), end(msgmap)); auto dist = std::distance(begin(msgmap), end(msgmap));
auto mapSize = map.size(); auto mapSize = map.size();
EXPECT_EQ(dist, mapSize); EXPECT_EQ(dist, mapSize);

68
test/limit.cpp
View File

@ -11,8 +11,8 @@ TEST(limit, unpack_array_no_over)
v.push_back(3); v.push_back(3);
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(3, 0, 0, 0, 0)); msgpack::unpack_limit(3, 0, 0, 0, 0));
EXPECT_TRUE(true); EXPECT_TRUE(true);
} }
@ -33,8 +33,8 @@ TEST(limit, unpack_array_over)
v.push_back(3); v.push_back(3);
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
} }
@ -55,8 +55,8 @@ TEST(limit, unpack_map_no_over)
m[3] = 3; m[3] = 3;
msgpack::pack(ss, m); msgpack::pack(ss, m);
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(0, 3, 0, 0, 0)); msgpack::unpack_limit(0, 3, 0, 0, 0));
EXPECT_TRUE(true); EXPECT_TRUE(true);
} }
@ -77,8 +77,8 @@ TEST(limit, unpack_map_over)
m[3] = 3; m[3] = 3;
msgpack::pack(ss, m); msgpack::pack(ss, m);
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(0, 2, 0, 0, 0)); msgpack::unpack_limit(0, 2, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
} }
@ -96,8 +96,8 @@ TEST(limit, unpack_str_no_over)
std::string s("123"); std::string s("123");
msgpack::pack(ss, s); msgpack::pack(ss, s);
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(0, 0, 3, 0, 0)); msgpack::unpack_limit(0, 0, 3, 0, 0));
EXPECT_TRUE(true); EXPECT_TRUE(true);
} }
@ -115,8 +115,8 @@ TEST(limit, unpack_str_over)
std::string s("123"); std::string s("123");
msgpack::pack(ss, s); msgpack::pack(ss, s);
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(0, 0, 2, 0, 0)); msgpack::unpack_limit(0, 0, 2, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
} }
@ -137,8 +137,8 @@ TEST(limit, unpack_bin_no_over)
v.push_back('3'); v.push_back('3');
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(0, 0, 0, 3, 0)); msgpack::unpack_limit(0, 0, 0, 3, 0));
EXPECT_TRUE(true); EXPECT_TRUE(true);
} }
@ -159,8 +159,8 @@ TEST(limit, unpack_bin_over)
v.push_back('3'); v.push_back('3');
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(0, 0, 0, 2, 0)); msgpack::unpack_limit(0, 0, 0, 2, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
} }
@ -180,8 +180,8 @@ TEST(limit, unpack_ext_no_over)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(0, 0, 0, 0, 3+1)); msgpack::unpack_limit(0, 0, 0, 0, 3+1));
EXPECT_TRUE(true); EXPECT_TRUE(true);
} }
@ -201,8 +201,8 @@ TEST(limit, unpack_ext_over)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
try { try {
msgpack::unpacked unp; msgpack::object_handle oh =
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(0, 0, 0, 0, 2+1)); msgpack::unpack_limit(0, 0, 0, 0, 2+1));
EXPECT_TRUE(false); EXPECT_TRUE(false);
} }
@ -226,7 +226,7 @@ TEST(limit, unpack_ext_over_32_bit)
static_cast<char>(0x01u), static_cast<char>(0x01u),
}; };
try { try {
msgpack::unpacked unp; msgpack::object_handle unp;
msgpack::unpack(unp, buf, sizeof(buf), nullptr, nullptr, msgpack::unpack(unp, buf, sizeof(buf), nullptr, nullptr,
msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff)); msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -252,7 +252,7 @@ TEST(limit, unpack_ext_no_over_64_bit)
static_cast<char>(0x01u), static_cast<char>(0x01u),
}; };
try { try {
msgpack::unpacked unp; msgpack::object_handle unp;
msgpack::unpack(unp, buf, sizeof(buf), nullptr, nullptr, msgpack::unpack(unp, buf, sizeof(buf), nullptr, nullptr,
msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff)); msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -278,7 +278,7 @@ TEST(limit, unpack_depth_no_over)
outer.push_back(inner); outer.push_back(inner);
msgpack::pack(ss, outer); msgpack::pack(ss, outer);
try { try {
msgpack::unpacked unp; msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(1, 0, 0, 0, 0, 2)); msgpack::unpack_limit(1, 0, 0, 0, 0, 2));
EXPECT_TRUE(true); EXPECT_TRUE(true);
@ -300,7 +300,7 @@ TEST(limit, unpack_depth_over)
outer.push_back(inner); outer.push_back(inner);
msgpack::pack(ss, outer); msgpack::pack(ss, outer);
try { try {
msgpack::unpacked unp; msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(1, 0, 0, 0, 0, 1)); msgpack::unpack_limit(1, 0, 0, 0, 0, 1));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -326,7 +326,7 @@ TEST(limit, unpack_array_over_cpp11_no_off_no_ref)
v.push_back(3); v.push_back(3);
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
msgpack::unpacked unp = msgpack::object_handle unp =
msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -349,7 +349,7 @@ TEST(limit, unpack_array_over_cpp11_no_off_ref)
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
bool ref; bool ref;
msgpack::unpacked unp = msgpack::object_handle unp =
msgpack::unpack(ss.str().c_str(), ss.str().size(), ref, nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), ref, nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -372,7 +372,7 @@ TEST(limit, unpack_array_over_cpp11_off_no_ref)
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked unp = msgpack::object_handle unp =
msgpack::unpack(ss.str().c_str(), ss.str().size(), off, nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), off, nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -396,7 +396,7 @@ TEST(limit, unpack_array_over_cpp11_off_ref)
try { try {
bool ref; bool ref;
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked unp = msgpack::object_handle unp =
msgpack::unpack(ss.str().c_str(), ss.str().size(), off, ref, nullptr, nullptr, msgpack::unpack(ss.str().c_str(), ss.str().size(), off, ref, nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -420,7 +420,7 @@ TEST(limit, unpack_array_over_no_off_no_ref)
v.push_back(3); v.push_back(3);
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
msgpack::unpacked unp; msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -443,7 +443,7 @@ TEST(limit, unpack_array_over_no_off_ref)
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
bool ref; bool ref;
msgpack::unpacked unp; msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), ref, nullptr, nullptr, msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), ref, nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -466,7 +466,7 @@ TEST(limit, unpack_array_over_off_no_ref)
msgpack::pack(ss, v); msgpack::pack(ss, v);
try { try {
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked unp; msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, nullptr, nullptr, msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -490,7 +490,7 @@ TEST(limit, unpack_array_over_off_ref)
try { try {
bool ref; bool ref;
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked unp; msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, ref, nullptr, nullptr, msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, ref, nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -515,7 +515,7 @@ TEST(limit, unpack_array_over_off_ref_pointer)
try { try {
bool ref; bool ref;
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked unp; msgpack::object_handle unp;
msgpack::unpack(&unp, ss.str().c_str(), ss.str().size(), &off, &ref, nullptr, nullptr, msgpack::unpack(&unp, ss.str().c_str(), ss.str().size(), &off, &ref, nullptr, nullptr,
msgpack::unpack_limit(2, 0, 0, 0, 0)); msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -542,7 +542,7 @@ TEST(limit, unpacker_array_over)
u.reserve_buffer(ss.str().size()); u.reserve_buffer(ss.str().size());
memcpy(u.buffer(), ss.str().c_str(), ss.str().size()); memcpy(u.buffer(), ss.str().c_str(), ss.str().size());
u.buffer_consumed(ss.str().size()); u.buffer_consumed(ss.str().size());
msgpack::unpacked unp; msgpack::object_handle unp;
u.next(unp); u.next(unp);
EXPECT_TRUE(false); EXPECT_TRUE(false);
} }

190
test/msgpack_basic.cpp
View File

@ -41,11 +41,11 @@ const double kEPS = 1e-10;
msgpack::sbuffer sbuf; \ msgpack::sbuffer sbuf; \
test_type val1 = v[i]; \ test_type val1 = v[i]; \
msgpack::pack(sbuf, val1); \ msgpack::pack(sbuf, val1); \
msgpack::unpacked ret; \ msgpack::object_handle oh = \
msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ msgpack::unpack(sbuf.data(), sbuf.size()); \
EXPECT_EQ(val1, ret.get().as<test_type>()); \ EXPECT_EQ(val1, oh.get().as<test_type>()); \
} \ } \
} while(0) } while(0)
TEST(MSGPACK, simple_buffer_char) TEST(MSGPACK, simple_buffer_char)
{ {
@ -172,9 +172,9 @@ TEST(MSGPACK, simple_buffer_float)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
float val1 = v[i]; float val1 = v[i];
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
float val2 = ret.get().as<float>(); float val2 = oh.get().as<float>();
if (std::isnan(val1)) if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2)); EXPECT_TRUE(std::isnan(val2));
@ -214,9 +214,9 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
integer_type val1 = v[i]; integer_type val1 = v[i];
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
float_type val2 = ret.get().as<float_type>(); float_type val2 = oh.get().as<float_type>();
EXPECT_TRUE(fabs(val2 - val1) <= kEPS); EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
} }
} }
@ -265,9 +265,9 @@ TEST(MSGPACK, simple_buffer_double)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
double val1 = v[i]; double val1 = v[i];
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
double val2 = ret.get().as<double>(); double val2 = oh.get().as<double>();
if (std::isnan(val1)) if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2)); EXPECT_TRUE(std::isnan(val2));
@ -283,9 +283,9 @@ TEST(MSGPACK, simple_buffer_nil)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf); msgpack::packer<msgpack::sbuffer> packer(sbuf);
packer.pack_nil(); packer.pack_nil();
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::NIL); EXPECT_EQ(oh.get().type, msgpack::type::NIL);
} }
TEST(MSGPACK, simple_buffer_true) TEST(MSGPACK, simple_buffer_true)
@ -293,9 +293,9 @@ TEST(MSGPACK, simple_buffer_true)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
bool val1 = true; bool val1 = true;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
bool val2 = ret.get().as<bool>(); bool val2 = oh.get().as<bool>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -304,9 +304,9 @@ TEST(MSGPACK, simple_buffer_false)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
bool val1 = false; bool val1 = false;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
bool val2 = ret.get().as<bool>(); bool val2 = oh.get().as<bool>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -318,11 +318,11 @@ TEST(MSGPACK, simple_buffer_fixext1)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(1ul, ret.get().via.ext.size); EXPECT_EQ(1ul, oh.get().via.ext.size);
EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_EQ(2, ret.get().via.ext.data()[0]); EXPECT_EQ(2, oh.get().via.ext.data()[0]);
} }
TEST(MSGPACK, simple_buffer_fixext2) TEST(MSGPACK, simple_buffer_fixext2)
@ -333,12 +333,12 @@ TEST(MSGPACK, simple_buffer_fixext2)
packer.pack_ext(sizeof(buf), 0); packer.pack_ext(sizeof(buf), 0);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(2ul, ret.get().via.ext.size); EXPECT_EQ(2ul, oh.get().via.ext.size);
EXPECT_EQ(0, ret.get().via.ext.type()); EXPECT_EQ(0, oh.get().via.ext.type());
EXPECT_TRUE( EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
} }
TEST(MSGPACK, simple_buffer_fixext4) TEST(MSGPACK, simple_buffer_fixext4)
@ -349,12 +349,12 @@ TEST(MSGPACK, simple_buffer_fixext4)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(4ul, ret.get().via.ext.size); EXPECT_EQ(4ul, oh.get().via.ext.size);
EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE( EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
} }
TEST(MSGPACK, simple_buffer_fixext8) TEST(MSGPACK, simple_buffer_fixext8)
@ -365,12 +365,12 @@ TEST(MSGPACK, simple_buffer_fixext8)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(8ul, ret.get().via.ext.size); EXPECT_EQ(8ul, oh.get().via.ext.size);
EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE( EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
} }
TEST(MSGPACK, simple_buffer_fixext16) TEST(MSGPACK, simple_buffer_fixext16)
@ -381,12 +381,12 @@ TEST(MSGPACK, simple_buffer_fixext16)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(16ul, ret.get().via.ext.size); EXPECT_EQ(16ul, oh.get().via.ext.size);
EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE( EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
} }
TEST(MSGPACK, simple_buffer_fixext_1byte_0) TEST(MSGPACK, simple_buffer_fixext_1byte_0)
@ -396,10 +396,10 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_0)
msgpack::packer<msgpack::sbuffer> packer(sbuf); msgpack::packer<msgpack::sbuffer> packer(sbuf);
packer.pack_ext(size, 77); packer.pack_ext(size, 77);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size); EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_EQ(77, oh.get().via.ext.type());
} }
TEST(MSGPACK, simple_buffer_fixext_1byte_255) TEST(MSGPACK, simple_buffer_fixext_1byte_255)
@ -412,12 +412,12 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_255)
packer.pack_ext(sizeof(buf), 77); packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size); EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE( EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
} }
TEST(MSGPACK, simple_buffer_fixext_2byte_256) TEST(MSGPACK, simple_buffer_fixext_2byte_256)
@ -430,12 +430,12 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_256)
packer.pack_ext(sizeof(buf), 77); packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size); EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE( EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
} }
TEST(MSGPACK, simple_buffer_fixext_2byte_65535) TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
@ -448,12 +448,12 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
packer.pack_ext(sizeof(buf), 77); packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size); EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE( EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
} }
TEST(MSGPACK, simple_buffer_fixext_4byte_65536) TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
@ -466,12 +466,12 @@ TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
packer.pack_ext(sizeof(buf), 77); packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size); EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE( EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
} }
TEST(MSGPACK, simple_buffer_ext_convert) TEST(MSGPACK, simple_buffer_ext_convert)
@ -484,10 +484,10 @@ TEST(MSGPACK, simple_buffer_ext_convert)
packer.pack_ext(sizeof(buf), 77); packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext e; msgpack::type::ext e;
ret.get().convert(e); oh.get().convert(e);
EXPECT_EQ(size, e.size()); EXPECT_EQ(size, e.size());
EXPECT_EQ(77, e.type()); EXPECT_EQ(77, e.type());
EXPECT_TRUE( EXPECT_TRUE(
@ -503,10 +503,10 @@ TEST(MSGPACK, simple_buffer_ext_pack_convert)
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i); for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext val2; msgpack::type::ext val2;
ret.get().convert(val2); oh.get().convert(val2);
EXPECT_EQ(size, val2.size()); EXPECT_EQ(size, val2.size());
EXPECT_EQ(77, val2.type()); EXPECT_EQ(77, val2.type());
EXPECT_TRUE( EXPECT_TRUE(
@ -523,10 +523,10 @@ TEST(MSGPACK, simple_buffer_ext_ref_convert)
packer.pack_ext(sizeof(buf), 77); packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext_ref er; msgpack::type::ext_ref er;
ret.get().convert(er); oh.get().convert(er);
EXPECT_EQ(size, er.size()); EXPECT_EQ(size, er.size());
EXPECT_EQ(77, er.type()); EXPECT_EQ(77, er.type());
EXPECT_TRUE( EXPECT_TRUE(
@ -543,10 +543,10 @@ TEST(MSGPACK, simple_buffer_ext_ref_pack_convert)
for (std::size_t i = 0; i != data_size; ++i) buf[i + 1] = static_cast<char>(i); for (std::size_t i = 0; i != data_size; ++i) buf[i + 1] = static_cast<char>(i);
msgpack::pack(sbuf, msgpack::type::ext_ref(buf, buf_size)); msgpack::pack(sbuf, msgpack::type::ext_ref(buf, buf_size));
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext_ref val2; msgpack::type::ext_ref val2;
ret.get().convert(val2); oh.get().convert(val2);
EXPECT_EQ(data_size, val2.size()); EXPECT_EQ(data_size, val2.size());
EXPECT_EQ(77, val2.type()); EXPECT_EQ(77, val2.type());
EXPECT_TRUE( EXPECT_TRUE(
@ -561,10 +561,10 @@ TEST(MSGPACK_STL, simple_buffer_string)
val1 += 'a' + rand() % 26; val1 += 'a' + rand() % 26;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::STR); EXPECT_EQ(oh.get().type, msgpack::type::STR);
string val2 = ret.get().as<string>(); string val2 = oh.get().as<string>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -578,10 +578,10 @@ TEST(MSGPACK_STL, simple_buffer_cstring)
val1 += 'a' + rand() % 26; val1 += 'a' + rand() % 26;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1.c_str()); msgpack::pack(sbuf, val1.c_str());
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::STR); EXPECT_EQ(oh.get().type, msgpack::type::STR);
string val2 = ret.get().as<string>(); string val2 = oh.get().as<string>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -598,10 +598,10 @@ TEST(MSGPACK_STL, simple_buffer_non_const_cstring)
std::memcpy(s, val1.c_str(), val1.size() + 1); std::memcpy(s, val1.c_str(), val1.size() + 1);
msgpack::pack(sbuf, s); msgpack::pack(sbuf, s);
delete [] s; delete [] s;
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::STR); EXPECT_EQ(oh.get().type, msgpack::type::STR);
string val2 = ret.get().as<string>(); string val2 = oh.get().as<string>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }

282
test/msgpack_container.cpp
View File

@ -45,10 +45,10 @@ TEST(MSGPACK_STL, simple_buffer_vector)
val1.push_back(rand()); val1.push_back(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -60,10 +60,10 @@ TEST(MSGPACK_STL, simple_buffer_vector_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -77,10 +77,10 @@ TEST(MSGPACK_STL, simple_buffer_vector_char)
val1.push_back(rand()); val1.push_back(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -92,10 +92,10 @@ TEST(MSGPACK_STL, simple_buffer_vector_char_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -109,10 +109,10 @@ TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char)
val1.push_back(rand()); val1.push_back(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -124,10 +124,10 @@ TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -142,10 +142,10 @@ TEST(MSGPACK_STL, simple_buffer_vector_uint8_t)
val1.push_back(rand()); val1.push_back(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -158,10 +158,10 @@ TEST(MSGPACK_STL, simple_buffer_vector_uint8_t_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -174,10 +174,10 @@ TEST(MSGPACK_STL, simple_buffer_vector_bool)
val1.push_back(i % 2 ? false : true); val1.push_back(i % 2 ? false : true);
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -188,10 +188,10 @@ TEST(MSGPACK_STL, simple_buffer_vector_bool_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -207,9 +207,9 @@ TEST(MSGPACK_STL, simple_buffer_assoc_vector)
val1.push_back(std::make_pair(5, 6)); val1.push_back(std::make_pair(5, 6));
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -221,9 +221,9 @@ TEST(MSGPACK_STL, simple_buffer_assoc_vector_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -237,9 +237,9 @@ TEST(MSGPACK_STL, simple_buffer_map)
val1[rand()] = rand(); val1[rand()] = rand();
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -251,9 +251,9 @@ TEST(MSGPACK_STL, simple_buffer_map_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -267,9 +267,9 @@ TEST(MSGPACK_STL, simple_buffer_deque)
val1.push_back(rand()); val1.push_back(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -281,9 +281,9 @@ TEST(MSGPACK_STL, simple_buffer_deque_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -297,9 +297,9 @@ TEST(MSGPACK_STL, simple_buffer_list)
val1.push_back(rand()); val1.push_back(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -311,9 +311,9 @@ TEST(MSGPACK_STL, simple_buffer_list_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = ret.get().as<type>(); type const& val2 = oh.get().as<type>();
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()));
} }
@ -327,9 +327,9 @@ TEST(MSGPACK_STL, simple_buffer_set)
val1.insert(rand()); val1.insert(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
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()));
} }
@ -341,9 +341,9 @@ TEST(MSGPACK_STL, simple_buffer_set_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
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,9 +354,9 @@ TEST(MSGPACK_STL, simple_buffer_pair)
pair<int, int> val1 = make_pair(rand(), rand()); pair<int, int> val1 = make_pair(rand(), rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
pair<int, int> val2 = ret.get().as<pair<int, int> >(); pair<int, int> val2 = oh.get().as<pair<int, int> >();
EXPECT_EQ(val1.first, val2.first); EXPECT_EQ(val1.first, val2.first);
EXPECT_EQ(val1.second, val2.second); EXPECT_EQ(val1.second, val2.second);
} }
@ -374,9 +374,9 @@ TEST(MSGPACK_STL, simple_buffer_multimap)
} }
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
vector<pair<int, int> > v1, v2; vector<pair<int, int> > v1, v2;
type::const_iterator it; type::const_iterator it;
@ -398,9 +398,9 @@ TEST(MSGPACK_STL, simple_buffer_multimap_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }
@ -413,9 +413,9 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
val1.insert(rand()); val1.insert(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
vector<int> v1, v2; vector<int> v1, v2;
type::const_iterator it; type::const_iterator it;
@ -437,9 +437,9 @@ TEST(MSGPACK_STL, simple_buffer_multiset_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }
@ -448,11 +448,11 @@ TEST(MSGPACK_TUPLE, simple_tuple)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, double> val1(true, "kzk", 12.3); msgpack::type::tuple<bool, std::string, double> val1(true, "kzk", 12.3);
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::tuple<bool, std::string, double> val2 msgpack::type::tuple<bool, std::string, double> val2
= ret.get().as<msgpack::type::tuple<bool, std::string, double> >(); = oh.get().as<msgpack::type::tuple<bool, std::string, double> >();
EXPECT_EQ(ret.get().via.array.size, 3u); EXPECT_EQ(oh.get().via.array.size, 3u);
EXPECT_EQ(val1.get<0>(), val2.get<0>()); EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>()); EXPECT_EQ(val1.get<1>(), val2.get<1>());
EXPECT_EQ(val1.get<2>(), val2.get<2>()); EXPECT_EQ(val1.get<2>(), val2.get<2>());
@ -463,10 +463,10 @@ TEST(MSGPACK_TUPLE, simple_tuple_empty)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::type::tuple<> val1; msgpack::type::tuple<> val1;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
ret.get().as<msgpack::type::tuple<> >(); oh.get().as<msgpack::type::tuple<> >();
EXPECT_EQ(ret.get().via.array.size, 0u); EXPECT_EQ(oh.get().via.array.size, 0u);
} }
@ -498,9 +498,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
val1[rand()] = rand(); val1[rand()] = rand();
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
type::const_iterator it; type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it) { for (it = val1.begin(); it != val1.end(); ++it) {
@ -516,9 +516,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }
@ -534,9 +534,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
} }
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
vector<pair<int, int> > v1, v2; vector<pair<int, int> > v1, v2;
type::const_iterator it; type::const_iterator it;
@ -558,9 +558,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }
@ -578,9 +578,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
val1.insert(rand()); val1.insert(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
type::const_iterator it; type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it) for (it = val1.begin(); it != val1.end(); ++it)
@ -594,9 +594,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }
@ -609,9 +609,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
val1.insert(rand()); val1.insert(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
vector<int> v1, v2; vector<int> v1, v2;
type::const_iterator it; type::const_iterator it;
@ -633,9 +633,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }
@ -667,9 +667,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map)
val1[rand()] = rand(); val1[rand()] = rand();
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
type::const_iterator it; type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it) { for (it = val1.begin(); it != val1.end(); ++it) {
@ -685,9 +685,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }
@ -703,9 +703,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
} }
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
vector<pair<int, int> > v1, v2; vector<pair<int, int> > v1, v2;
type::const_iterator it; type::const_iterator it;
@ -727,9 +727,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }
@ -748,9 +748,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set)
val1.insert(rand()); val1.insert(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
type::const_iterator it; type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it) for (it = val1.begin(); it != val1.end(); ++it)
@ -764,9 +764,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }
@ -779,9 +779,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
val1.insert(rand()); val1.insert(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
vector<int> v1, v2; vector<int> v1, v2;
type::const_iterator it; type::const_iterator it;
@ -803,9 +803,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1.size(), val2.size());
} }

246
test/msgpack_cpp11.cpp
View File

@ -42,9 +42,9 @@ TEST(MSGPACK_CPP11, simple_tuple)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
std::tuple<bool, std::string, double> val1(true, "kzk", 12.3); std::tuple<bool, std::string, double> val1(true, "kzk", 12.3);
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::tuple<bool, std::string, double> val2 = ret.get().as<std::tuple<bool, std::string, double> >(); std::tuple<bool, std::string, double> val2 = oh.get().as<std::tuple<bool, std::string, double> >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -53,9 +53,9 @@ TEST(MSGPACK_CPP11, simple_tuple_empty)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
std::tuple<> val1; std::tuple<> val1;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::tuple<> val2 = ret.get().as<std::tuple<> >(); std::tuple<> val2 = oh.get().as<std::tuple<> >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -67,10 +67,10 @@ TEST(MSGPACK_CPP11, simple_array)
val1[i] = rand(); val1[i] = rand();
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
array<int, kElements> val2 = ret.get().as<array<int, kElements> >(); array<int, kElements> val2 = oh.get().as<array<int, kElements> >();
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()));
} }
@ -81,10 +81,10 @@ TEST(MSGPACK_CPP11, simple_array_empty)
array<int, 0> val1; array<int, 0> val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
array<int, 0> val2 = ret.get().as<array<int, 0> >(); array<int, 0> val2 = oh.get().as<array<int, 0> >();
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()));
} }
@ -97,10 +97,10 @@ TEST(MSGPACK_CPP11, simple_buffer_array_char)
val1[i] = rand(); val1[i] = rand();
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
array<char, kElements> val2 = ret.get().as<array<char, kElements> >(); array<char, kElements> val2 = oh.get().as<array<char, kElements> >();
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()));
} }
@ -111,10 +111,10 @@ TEST(MSGPACK_CPP11, simple_buffer_array_char_empty)
array<char, 0> val1; array<char, 0> val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
array<char, 0> val2 = ret.get().as<array<char, 0> >(); array<char, 0> val2 = oh.get().as<array<char, 0> >();
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()));
} }
@ -128,10 +128,10 @@ TEST(MSGPACK_CPP11, simple_buffer_array_unsigned_char)
val1[i] = rand(); val1[i] = rand();
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
array<unsigned char, kElements> val2 = ret.get().as<array<unsigned char, kElements> >(); array<unsigned char, kElements> val2 = oh.get().as<array<unsigned char, kElements> >();
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()));
} }
@ -143,10 +143,10 @@ TEST(MSGPACK_CPP11, simple_buffer_array_unsigned_char_empty)
array<unsigned char, 0> val1; array<unsigned char, 0> val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(ret.get().type, msgpack::type::BIN); EXPECT_EQ(oh.get().type, msgpack::type::BIN);
array<unsigned char, 0> val2 = ret.get().as<array<unsigned char, 0> >(); array<unsigned char, 0> val2 = oh.get().as<array<unsigned char, 0> >();
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()));
} }
@ -191,9 +191,9 @@ TEST(MSGPACK_STL, simple_buffer_forward_list)
val1.push_front(rand()); val1.push_front(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type >(); type val2 = oh.get().as<type >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
} }
@ -204,9 +204,9 @@ TEST(MSGPACK_STL, simple_buffer_forward_list_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type >(); type val2 = oh.get().as<type >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -219,9 +219,9 @@ TEST(MSGPACK_STL, simple_buffer_unordered_map)
val1[rand()] = rand(); val1[rand()] = rand();
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type >(); type val2 = oh.get().as<type >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
} }
@ -232,9 +232,9 @@ TEST(MSGPACK_STL, simple_buffer_unordered_map_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type >(); type val2 = oh.get().as<type >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -250,9 +250,9 @@ TEST(MSGPACK_STL, simple_buffer_unordered_multimap)
} }
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type >(); type val2 = oh.get().as<type >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -264,9 +264,9 @@ TEST(MSGPACK_STL, simple_buffer_unordered_multimap_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type >(); type val2 = oh.get().as<type >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -280,9 +280,9 @@ TEST(MSGPACK_STL, simple_buffer_unordered_set)
val1.insert(rand()); val1.insert(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
} }
@ -293,9 +293,9 @@ TEST(MSGPACK_STL, simple_buffer_unordered_set_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type>(); type val2 = oh.get().as<type>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -308,9 +308,9 @@ TEST(MSGPACK_STL, simple_buffer_unordered_multiset)
val1.insert(rand()); val1.insert(rand());
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type >(); type val2 = oh.get().as<type >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
} }
@ -321,9 +321,9 @@ TEST(MSGPACK_STL, simple_buffer_unordered_multiset_empty)
type val1; type val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = ret.get().as<type >(); type val2 = oh.get().as<type >();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -332,9 +332,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member)
TestEnumClassMemberClass val1; TestEnumClassMemberClass val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
TestEnumClassMemberClass val2 = ret.get().as<TestEnumClassMemberClass>(); TestEnumClassMemberClass val2 = oh.get().as<TestEnumClassMemberClass>();
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);
@ -387,10 +387,10 @@ TEST(MSGPACK_NO_DEF_CON, simple_buffer)
no_def_con val1(42); no_def_con val1(42);
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
no_def_con val2 = ret.get().as<no_def_con>(); no_def_con val2 = oh.get().as<no_def_con>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -434,9 +434,9 @@ TEST(MSGPACK_NO_DEF_CON_COMPOSITE, simple_buffer)
no_def_con_composite val1(42); no_def_con_composite val1(42);
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
no_def_con_composite val2 = ret.get().as<no_def_con_composite>(); no_def_con_composite val2 = oh.get().as<no_def_con_composite>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -466,9 +466,9 @@ TEST(MSGPACK_NO_DEF_CON_INHERIT, simple_buffer)
no_def_con_inherit val1(42); no_def_con_inherit val1(42);
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
no_def_con_inherit val2 = ret.get().as<no_def_con_inherit>(); no_def_con_inherit val2 = oh.get().as<no_def_con_inherit>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -477,9 +477,9 @@ TEST(MSGPACK_NO_DEF_CON_VECTOR, simple_buffer)
std::vector<no_def_con> val1 { 1, 2, 3 }; std::vector<no_def_con> val1 { 1, 2, 3 };
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::vector<no_def_con> val2 = ret.get().as<std::vector<no_def_con>>(); std::vector<no_def_con> val2 = oh.get().as<std::vector<no_def_con>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -488,9 +488,9 @@ TEST(MSGPACK_NO_DEF_CON_LIST, simple_buffer)
std::list<no_def_con> val1 { 1, 2, 3 }; std::list<no_def_con> val1 { 1, 2, 3 };
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::list<no_def_con> val2 = ret.get().as<std::list<no_def_con>>(); std::list<no_def_con> val2 = oh.get().as<std::list<no_def_con>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -499,9 +499,9 @@ TEST(MSGPACK_NO_DEF_CON_SET, simple_buffer)
std::set<no_def_con> val1 { 1, 2, 3 }; std::set<no_def_con> val1 { 1, 2, 3 };
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::set<no_def_con> val2 = ret.get().as<std::set<no_def_con>>(); std::set<no_def_con> val2 = oh.get().as<std::set<no_def_con>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -510,9 +510,9 @@ TEST(MSGPACK_NO_DEF_CON_MULTISET, simple_buffer)
std::multiset<no_def_con> val1 { 1, 2, 3 }; std::multiset<no_def_con> val1 { 1, 2, 3 };
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::multiset<no_def_con> val2 = ret.get().as<std::multiset<no_def_con>>(); std::multiset<no_def_con> val2 = oh.get().as<std::multiset<no_def_con>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -521,10 +521,10 @@ TEST(MSGPACK_NO_DEF_CON_ASSOC_VECTOR, simple_buffer)
msgpack::type::assoc_vector<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}}; msgpack::type::assoc_vector<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}};
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::assoc_vector<no_def_con, no_def_con_composite> val2 msgpack::type::assoc_vector<no_def_con, no_def_con_composite> val2
= ret.get().as<msgpack::type::assoc_vector<no_def_con, no_def_con_composite>>(); = oh.get().as<msgpack::type::assoc_vector<no_def_con, no_def_con_composite>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -533,10 +533,10 @@ TEST(MSGPACK_NO_DEF_CON_MAP, simple_buffer)
std::map<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}}; std::map<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}};
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::map<no_def_con, no_def_con_composite> val2 std::map<no_def_con, no_def_con_composite> val2
= ret.get().as<std::map<no_def_con, no_def_con_composite>>(); = oh.get().as<std::map<no_def_con, no_def_con_composite>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -545,10 +545,10 @@ TEST(MSGPACK_NO_DEF_CON_MULTIMAP, simple_buffer)
std::multimap<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}}; std::multimap<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}};
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::multimap<no_def_con, no_def_con_composite> val2 std::multimap<no_def_con, no_def_con_composite> val2
= ret.get().as<std::multimap<no_def_con, no_def_con_composite>>(); = oh.get().as<std::multimap<no_def_con, no_def_con_composite>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -557,9 +557,9 @@ TEST(MSGPACK_NO_DEF_CON_DEQUE, simple_buffer)
std::deque<no_def_con> val1 { 1, 2, 3 }; std::deque<no_def_con> val1 { 1, 2, 3 };
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::deque<no_def_con> val2 = ret.get().as<std::deque<no_def_con>>(); std::deque<no_def_con> val2 = oh.get().as<std::deque<no_def_con>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -568,10 +568,10 @@ TEST(MSGPACK_NO_DEF_CON_PAIR, simple_buffer)
std::pair<no_def_con, no_def_con_composite> val1 {1, 2}; std::pair<no_def_con, no_def_con_composite> val1 {1, 2};
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::pair<no_def_con, no_def_con_composite> val2 std::pair<no_def_con, no_def_con_composite> val2
= ret.get().as<std::pair<no_def_con, no_def_con_composite>>(); = oh.get().as<std::pair<no_def_con, no_def_con_composite>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -587,10 +587,10 @@ TEST(MSGPACK_NO_DEF_CON_TUPLE, simple_buffer)
std::tuple<no_def_con, no_def_con, no_def_con_composite> val1 {1, 2, 3}; std::tuple<no_def_con, no_def_con, no_def_con_composite> val1 {1, 2, 3};
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::tuple<no_def_con, no_def_con, no_def_con_composite> val2 std::tuple<no_def_con, no_def_con, no_def_con_composite> val2
= ret.get().as<std::tuple<no_def_con, no_def_con, no_def_con_composite>>(); = oh.get().as<std::tuple<no_def_con, no_def_con, no_def_con_composite>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -599,10 +599,10 @@ TEST(MSGPACK_NO_DEF_CON_MSGPACK_TUPLE, simple_buffer)
msgpack::type::tuple<no_def_con, no_def_con, no_def_con_composite> val1 {1, 2, 3}; msgpack::type::tuple<no_def_con, no_def_con, no_def_con_composite> val1 {1, 2, 3};
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::tuple<no_def_con, no_def_con, no_def_con_composite> val2 msgpack::type::tuple<no_def_con, no_def_con, no_def_con_composite> val2
= ret.get().as<msgpack::type::tuple<no_def_con, no_def_con, no_def_con_composite>>(); = oh.get().as<msgpack::type::tuple<no_def_con, no_def_con, no_def_con_composite>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -613,9 +613,9 @@ TEST(MSGPACK_NO_DEF_FORWARD_LIST, simple_buffer)
std::forward_list<no_def_con> val1 { 1, 2, 3 }; std::forward_list<no_def_con> val1 { 1, 2, 3 };
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::forward_list<no_def_con> val2 = ret.get().as<std::forward_list<no_def_con>>(); std::forward_list<no_def_con> val2 = oh.get().as<std::forward_list<no_def_con>>();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }
@ -624,9 +624,9 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_SET, simple_buffer)
std::unordered_set<no_def_con> val1 { 1, 2, 3 }; std::unordered_set<no_def_con> val1 { 1, 2, 3 };
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::unordered_set<no_def_con> val2 = ret.get().as<std::unordered_set<no_def_con>>(); std::unordered_set<no_def_con> val2 = oh.get().as<std::unordered_set<no_def_con>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -635,9 +635,9 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_MULTISET, simple_buffer)
std::unordered_multiset<no_def_con> val1 { 1, 2, 3 }; std::unordered_multiset<no_def_con> val1 { 1, 2, 3 };
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::unordered_multiset<no_def_con> val2 = ret.get().as<std::unordered_multiset<no_def_con>>(); std::unordered_multiset<no_def_con> val2 = oh.get().as<std::unordered_multiset<no_def_con>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -646,10 +646,10 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_MAP, simple_buffer)
std::unordered_map<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}}; std::unordered_map<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}};
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::unordered_map<no_def_con, no_def_con_composite> val2 std::unordered_map<no_def_con, no_def_con_composite> val2
= ret.get().as<std::unordered_map<no_def_con, no_def_con_composite>>(); = oh.get().as<std::unordered_map<no_def_con, no_def_con_composite>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -658,10 +658,10 @@ TEST(MSGPACK_NO_DEF_CON_UNORDERED_MULTIMAP, simple_buffer)
std::unordered_multimap<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}}; std::unordered_multimap<no_def_con, no_def_con_composite> val1 { {1, 2}, {3, 4}, {5, 6}};
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::unordered_multimap<no_def_con, no_def_con_composite> val2 std::unordered_multimap<no_def_con, no_def_con_composite> val2
= ret.get().as<std::unordered_multimap<no_def_con, no_def_con_composite>>(); = oh.get().as<std::unordered_multimap<no_def_con, no_def_con_composite>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }
@ -670,9 +670,9 @@ TEST(MSGPACK_NO_DEF_CON_ARRAY, simple_buffer)
std::array<no_def_con, 3> val1 { { 1, 2, 3 } }; std::array<no_def_con, 3> val1 { { 1, 2, 3 } };
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
std::array<no_def_con, 3> val2 = ret.get().as<std::array<no_def_con, 3>>(); std::array<no_def_con, 3> val2 = oh.get().as<std::array<no_def_con, 3>>();
EXPECT_EQ(val1, val2); EXPECT_EQ(val1, val2);
} }

6
test/msgpack_stream.cpp
View File

@ -40,10 +40,10 @@ const unsigned int kLoop = 1000;
pac.reserve_buffer(sz); \ pac.reserve_buffer(sz); \
memcpy(pac.buffer(), p, sz); \ memcpy(pac.buffer(), p, sz); \
pac.buffer_consumed(sz); \ pac.buffer_consumed(sz); \
msgpack::unpacked result; \ msgpack::object_handle oh; \
while (pac.next(result)) { \ while (pac.next(oh)) { \
if (it == vec.end()) goto out; \ if (it == vec.end()) goto out; \
msgpack::object obj = result.get(); \ msgpack::object obj = oh.get(); \
vec_type::value_type val; \ vec_type::value_type val; \
obj.convert(val); \ obj.convert(val); \
EXPECT_EQ(*it, val); \ EXPECT_EQ(*it, val); \

6
test/msgpack_vref.cpp
View File

@ -29,9 +29,9 @@ using namespace std;
const struct iovec* end = cur + vbuf.vector_size(); \ const struct iovec* end = cur + vbuf.vector_size(); \
for(; cur != end; ++cur) \ for(; cur != end; ++cur) \
sbuf.write((const char*)cur->iov_base, cur->iov_len); \ sbuf.write((const char*)cur->iov_base, cur->iov_len); \
msgpack::unpacked ret; \ msgpack::object_handle oh; \
msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ msgpack::unpack(oh, sbuf.data(), sbuf.size()); \
test_type val2 = ret.get().as<test_type>(); \ test_type val2 = oh.get().as<test_type>(); \
EXPECT_EQ(val1, val2); \ EXPECT_EQ(val1, val2); \
} \ } \
} while(0); } while(0);

12
test/object.cpp
View File

@ -68,11 +68,11 @@ TEST(object, convert)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, m1); msgpack::pack(sbuf, m1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
myclass m2; myclass m2;
ret.get().convert(m2); oh.get().convert(m2);
EXPECT_EQ(m1, m2); EXPECT_EQ(m1, m2);
} }
@ -85,10 +85,10 @@ TEST(object, as)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, m1); msgpack::pack(sbuf, m1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(m1, ret.get().as<myclass>()); EXPECT_EQ(m1, oh.get().as<myclass>());
} }
TEST(object, cross_zone_copy) TEST(object, cross_zone_copy)

100
test/pack_unpack.cpp
View File

@ -55,8 +55,8 @@ TEST(unpack, int_ret_no_offset_no_ref)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size()); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
} }
TEST(unpack, int_ret_offset_no_ref) TEST(unpack, int_ret_offset_no_ref)
@ -66,8 +66,8 @@ TEST(unpack, int_ret_offset_no_ref)
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), off); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size()); EXPECT_EQ(off, sbuf.size());
} }
@ -77,8 +77,8 @@ TEST(unpack, int_ret_no_offset_ref)
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
bool referenced; bool referenced;
msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(false, referenced); EXPECT_EQ(false, referenced);
} }
@ -89,8 +89,8 @@ TEST(unpack, int_ret_offset_ref)
std::size_t off = 0; std::size_t off = 0;
bool referenced; bool referenced;
msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), off, referenced); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off, referenced);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(false, referenced); EXPECT_EQ(false, referenced);
EXPECT_EQ(off, sbuf.size()); EXPECT_EQ(off, sbuf.size());
} }
@ -100,22 +100,22 @@ TEST(unpack, int_no_offset_no_ref)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg; msgpack::object_handle oh;
msgpack::unpack(msg, sbuf.data(), sbuf.size()); msgpack::unpack(oh, sbuf.data(), sbuf.size());
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
} }
TEST(unpack, int_offset_no_ref) TEST(unpack, int_offset_no_ref)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg; msgpack::object_handle oh;
std::size_t off = 0; std::size_t off = 0;
msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size()); EXPECT_EQ(off, sbuf.size());
} }
@ -123,11 +123,11 @@ TEST(unpack, int_no_offset_ref)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg; msgpack::object_handle oh;
bool referenced; bool referenced;
msgpack::unpack(msg, sbuf.data(), sbuf.size(), referenced); msgpack::unpack(oh, sbuf.data(), sbuf.size(), referenced);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(false, referenced); EXPECT_EQ(false, referenced);
} }
@ -135,12 +135,12 @@ TEST(unpack, int_offset_ref)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg; msgpack::object_handle oh;
std::size_t off = 0; std::size_t off = 0;
bool referenced; bool referenced;
msgpack::unpack(msg, sbuf.data(), sbuf.size(), off, referenced); msgpack::unpack(oh, sbuf.data(), sbuf.size(), off, referenced);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(false, referenced); EXPECT_EQ(false, referenced);
EXPECT_EQ(off, sbuf.size()); EXPECT_EQ(off, sbuf.size());
} }
@ -150,13 +150,13 @@ TEST(unpack, int_pointer_off_no_ref)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg; msgpack::object_handle oh;
std::size_t off = 0; std::size_t off = 0;
// obsolete // obsolete
msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off); msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size()); EXPECT_EQ(off, sbuf.size());
} }
@ -164,13 +164,13 @@ TEST(unpack, int_pointer_off_no_ref_explicit)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg; msgpack::object_handle oh;
std::size_t off = 0; std::size_t off = 0;
// obsolete // obsolete
msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off, nullptr); msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, nullptr);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size()); EXPECT_EQ(off, sbuf.size());
} }
@ -178,12 +178,12 @@ TEST(unpack, int_pointer_no_off_ref)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg; msgpack::object_handle oh;
bool referenced; bool referenced;
// obsolete // obsolete
msgpack::unpack(&msg, sbuf.data(), sbuf.size(), nullptr, &referenced); msgpack::unpack(&oh, sbuf.data(), sbuf.size(), nullptr, &referenced);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(false, referenced); EXPECT_EQ(false, referenced);
} }
@ -191,13 +191,13 @@ TEST(unpack, int_pointer_off_ref)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg; msgpack::object_handle oh;
bool referenced; bool referenced;
std::size_t off = 0; std::size_t off = 0;
// obsolete // obsolete
msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off, &referenced); msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, &referenced);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size()); EXPECT_EQ(off, sbuf.size());
EXPECT_EQ(false, referenced); EXPECT_EQ(false, referenced);
} }
@ -207,11 +207,11 @@ TEST(unpack, int_default_null_pointer)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg; msgpack::object_handle oh;
// obsolete // obsolete
msgpack::unpack(&msg, sbuf.data(), sbuf.size()); msgpack::unpack(&oh, sbuf.data(), sbuf.size());
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
} }
TEST(unpack, int_zone_no_offset_no_ref) TEST(unpack, int_zone_no_offset_no_ref)
@ -273,16 +273,16 @@ TEST(unpack, sequence)
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked msg; msgpack::object_handle oh;
msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(2, msg.get().as<int>()); EXPECT_EQ(2, oh.get().as<int>());
msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(3, msg.get().as<int>()); EXPECT_EQ(3, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size()); EXPECT_EQ(off, sbuf.size());
} }
@ -325,9 +325,9 @@ TEST(unpack, insufficient_bytes_ref)
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked msg; msgpack::object_handle oh;
try { try {
msgpack::unpack(msg, sbuf.data(), 1, off); msgpack::unpack(oh, sbuf.data(), 1, off);
EXPECT_TRUE(false); EXPECT_TRUE(false);
} }
catch (msgpack::insufficient_bytes const&) { catch (msgpack::insufficient_bytes const&) {
@ -343,7 +343,6 @@ TEST(unpack, insufficient_bytes_object_handle)
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked msg;
try { try {
msgpack::object_handle oh(msgpack::unpack(sbuf.data(), 1, off)); msgpack::object_handle oh(msgpack::unpack(sbuf.data(), 1, off));
EXPECT_TRUE(false); EXPECT_TRUE(false);
@ -361,7 +360,6 @@ TEST(unpack, insufficient_bytes_zone)
std::size_t off = 0; std::size_t off = 0;
msgpack::unpacked msg;
try { try {
msgpack::zone z; msgpack::zone z;
msgpack::unpack(z, sbuf.data(), 1, off); msgpack::unpack(z, sbuf.data(), 1, off);
@ -381,9 +379,9 @@ TEST(unpack, parse_error)
sbuf.write(&c, 1); sbuf.write(&c, 1);
bool thrown = false; bool thrown = false;
msgpack::unpacked msg; msgpack::object_handle oh;
try { try {
msgpack::unpack(msg, sbuf.data(), sbuf.size()); msgpack::unpack(oh, sbuf.data(), sbuf.size());
EXPECT_TRUE(false); EXPECT_TRUE(false);
} }
catch (msgpack::parse_error const&) { catch (msgpack::parse_error const&) {
@ -434,8 +432,8 @@ TEST(unpack, extra_bytes)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size() + 1); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size() + 1);
EXPECT_EQ(1, msg.get().as<int>()); EXPECT_EQ(1, oh.get().as<int>());
} }
TEST(unpack, zone_extra_bytes) TEST(unpack, zone_extra_bytes)
@ -457,7 +455,7 @@ TEST(unpack, int_off_larger_than_length)
bool thrown = false; bool thrown = false;
try { try {
msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), off); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off);
} }
catch (msgpack::insufficient_bytes const&) { catch (msgpack::insufficient_bytes const&) {
thrown = true; thrown = true;

72
test/raw.cpp
View File

@ -23,9 +23,9 @@ TEST(MSGPACK_RAW_REF, pack_unpack)
EXPECT_EQ(packed_str[3], 'B'); EXPECT_EQ(packed_str[3], 'B');
EXPECT_EQ(packed_str[4], 'C'); EXPECT_EQ(packed_str[4], 'C');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::raw_ref rr2 = upd.get().as<msgpack::type::raw_ref>(); msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -40,9 +40,9 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_l)
EXPECT_EQ(packed_str[0], static_cast<char>(0xc4u)); EXPECT_EQ(packed_str[0], static_cast<char>(0xc4u));
EXPECT_EQ(packed_str[1], static_cast<char>(0x00u)); EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::raw_ref rr2 = upd.get().as<msgpack::type::raw_ref>(); msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -58,9 +58,9 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_h)
EXPECT_EQ(packed_str[1], static_cast<char>(0xffu)); EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[2], 'A'); EXPECT_EQ(packed_str[2], 'A');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::raw_ref rr2 = upd.get().as<msgpack::type::raw_ref>(); msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -77,9 +77,9 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_l)
EXPECT_EQ(packed_str[2], static_cast<char>(0x00)); EXPECT_EQ(packed_str[2], static_cast<char>(0x00));
EXPECT_EQ(packed_str[3], 'A'); EXPECT_EQ(packed_str[3], 'A');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::raw_ref rr2 = upd.get().as<msgpack::type::raw_ref>(); msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -96,9 +96,9 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_h)
EXPECT_EQ(packed_str[2], static_cast<char>(0xffu)); EXPECT_EQ(packed_str[2], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[3], 'A'); EXPECT_EQ(packed_str[3], 'A');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::raw_ref rr2 = upd.get().as<msgpack::type::raw_ref>(); msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -117,9 +117,9 @@ TEST(MSGPACK_RAW_REF, pack_unpack_32_l)
EXPECT_EQ(packed_str[4], static_cast<char>(0x00)); EXPECT_EQ(packed_str[4], static_cast<char>(0x00));
EXPECT_EQ(packed_str[5], 'A'); EXPECT_EQ(packed_str[5], 'A');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::raw_ref rr2 = upd.get().as<msgpack::type::raw_ref>(); msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -136,9 +136,9 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack)
EXPECT_EQ(packed_str[2], 'B'); EXPECT_EQ(packed_str[2], 'B');
EXPECT_EQ(packed_str[3], 'C'); EXPECT_EQ(packed_str[3], 'C');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::v4raw_ref rr2 = upd.get().as<msgpack::type::v4raw_ref>(); msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -152,9 +152,9 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_l)
std::string packed_str = ss.str(); std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xa0u)); EXPECT_EQ(packed_str[0], static_cast<char>(0xa0u));
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::v4raw_ref rr2 = upd.get().as<msgpack::type::v4raw_ref>(); msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -169,9 +169,9 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_h)
EXPECT_EQ(packed_str[0], static_cast<char>(0xbfu)); EXPECT_EQ(packed_str[0], static_cast<char>(0xbfu));
EXPECT_EQ(packed_str[1], 'A'); EXPECT_EQ(packed_str[1], 'A');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::v4raw_ref rr2 = upd.get().as<msgpack::type::v4raw_ref>(); msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -188,9 +188,9 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_l)
EXPECT_EQ(packed_str[2], static_cast<char>(0x20u)); EXPECT_EQ(packed_str[2], static_cast<char>(0x20u));
EXPECT_EQ(packed_str[3], 'A'); EXPECT_EQ(packed_str[3], 'A');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::v4raw_ref rr2 = upd.get().as<msgpack::type::v4raw_ref>(); msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -207,9 +207,9 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_h)
EXPECT_EQ(packed_str[2], static_cast<char>(0xffu)); EXPECT_EQ(packed_str[2], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[3], 'A'); EXPECT_EQ(packed_str[3], 'A');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::v4raw_ref rr2 = upd.get().as<msgpack::type::v4raw_ref>(); msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }
@ -228,8 +228,8 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_32_l)
EXPECT_EQ(packed_str[4], static_cast<char>(0x00)); EXPECT_EQ(packed_str[4], static_cast<char>(0x00));
EXPECT_EQ(packed_str[5], 'A'); EXPECT_EQ(packed_str[5], 'A');
msgpack::unpacked upd; msgpack::object_handle oh =
msgpack::unpack(upd, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
msgpack::type::v4raw_ref rr2 = upd.get().as<msgpack::type::v4raw_ref>(); msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2); EXPECT_TRUE(rr1 == rr2);
} }

109
test/reference.cpp
View File

@ -5,10 +5,10 @@ TEST(reference, unpack_int)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked ret;
bool referenced; bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -16,10 +16,10 @@ TEST(reference, unpack_string)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg")); msgpack::pack(sbuf, std::string("abcdefg"));
msgpack::unpacked ret;
bool referenced; bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -31,9 +31,9 @@ TEST(reference, unpack_bin)
packer.pack_bin(sizeof(c)); packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c)); packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
bool referenced; bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -45,9 +45,9 @@ TEST(reference, unpack_ext)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
bool referenced; bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -66,10 +66,10 @@ TEST(reference, unpack_int_ref)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked ret;
bool referenced; bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -77,11 +77,10 @@ TEST(reference, unpack_string_ref)
{ {
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg")); msgpack::pack(sbuf, std::string("abcdefg"));
msgpack::unpacked ret;
bool referenced; bool referenced;
msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference); msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
} }
@ -93,9 +92,9 @@ TEST(reference, unpack_bin_ref)
packer.pack_bin(sizeof(c)); packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c)); packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
bool referenced; bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
} }
@ -107,9 +106,10 @@ TEST(reference, unpack_ext_ref)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
bool referenced; bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
} }
@ -139,10 +139,11 @@ TEST(reference, unpack_int_sized_ref)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacked ret;
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called, &sbuf);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called, &sbuf);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(nullptr, s_p); EXPECT_EQ(nullptr, s_p);
} }
@ -152,12 +153,12 @@ TEST(reference, unpack_string_sized_ref_4)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("1234")); msgpack::pack(sbuf, std::string("1234"));
msgpack::unpacked ret;
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
// the last argument sbuf is any pointer as a user data. // the last argument sbuf is any pointer as a user data.
// That is stored to s_p in sized_reference // That is stored to s_p in sized_reference
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
// compare the passed argument with stored s_p. // compare the passed argument with stored s_p.
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
@ -168,10 +169,11 @@ TEST(reference, unpack_string_sized_ref_5)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("12345")); msgpack::pack(sbuf, std::string("12345"));
msgpack::unpacked ret;
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }
@ -185,10 +187,11 @@ TEST(reference, unpack_bin_sized_ref_5)
packer.pack_bin(sizeof(c)); packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c)); packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }
@ -201,10 +204,10 @@ TEST(reference, unpack_bin_sized_ref_6)
packer.pack_bin(sizeof(c)); packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c)); packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }
@ -218,10 +221,10 @@ TEST(reference, unpack_ext_sized_ref_6)
packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }
@ -235,10 +238,10 @@ TEST(reference, unpack_ext_sized_ref_7)
packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }
@ -252,12 +255,12 @@ TEST(reference, unpacker_int)
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacker unp; msgpack::unpacker unp;
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -268,12 +271,12 @@ TEST(reference, unpacker_string)
msgpack::pack(sbuf, std::string("a")); msgpack::pack(sbuf, std::string("a"));
msgpack::unpacker unp; msgpack::unpacker unp;
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
} }
@ -287,12 +290,12 @@ TEST(reference, unpacker_bin)
packer.pack_bin_body(c, sizeof(c)); packer.pack_bin_body(c, sizeof(c));
msgpack::unpacker unp; msgpack::unpacker unp;
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
} }
@ -307,12 +310,12 @@ TEST(reference, unpacker_ext)
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacker unp; msgpack::unpacker unp;
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
} }
@ -325,13 +328,13 @@ TEST(reference, unpacker_int_sized_ref)
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
msgpack::unpacker unp(never_called, &sbuf); msgpack::unpacker unp(never_called, &sbuf);
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
s_p = nullptr; s_p = nullptr;
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(nullptr, s_p); EXPECT_EQ(nullptr, s_p);
@ -343,13 +346,13 @@ TEST(reference, unpacker_string_sized_ref_4)
msgpack::pack(sbuf, std::string("1234")); msgpack::pack(sbuf, std::string("1234"));
msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
s_p = nullptr; s_p = nullptr;
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
@ -361,13 +364,13 @@ TEST(reference, unpacker_string_sized_ref_5)
msgpack::pack(sbuf, std::string("12345")); msgpack::pack(sbuf, std::string("12345"));
msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
s_p = nullptr; s_p = nullptr;
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
@ -383,13 +386,13 @@ TEST(reference, unpacker_bin_sized_ref_5)
packer.pack_bin_body(c, sizeof(c)); packer.pack_bin_body(c, sizeof(c));
msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
s_p = nullptr; s_p = nullptr;
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
@ -404,13 +407,13 @@ TEST(reference, unpacker_bin_sized_ref_6)
packer.pack_bin_body(c, sizeof(c)); packer.pack_bin_body(c, sizeof(c));
msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
s_p = nullptr; s_p = nullptr;
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
@ -426,13 +429,13 @@ TEST(reference, unpacker_ext_sized_ref_6)
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
s_p = nullptr; s_p = nullptr;
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
@ -448,13 +451,13 @@ TEST(reference, unpacker_ext_sized_ref_7)
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret; msgpack::object_handle oh;
bool referenced; bool referenced;
unp.reserve_buffer(sbuf.size()); unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size()); unp.buffer_consumed(sbuf.size());
s_p = nullptr; s_p = nullptr;
bool b = unp.next(ret, referenced); bool b = unp.next(oh, referenced);
EXPECT_TRUE(b); EXPECT_TRUE(b);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);

30
test/reference_cpp11.cpp
View File

@ -9,7 +9,7 @@ TEST(reference, unpack_int)
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
bool referenced; bool referenced;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -19,7 +19,7 @@ TEST(reference, unpack_string)
msgpack::pack(sbuf, std::string("abcdefg")); msgpack::pack(sbuf, std::string("abcdefg"));
bool referenced; bool referenced;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -32,7 +32,7 @@ TEST(reference, unpack_bin)
packer.pack_bin_body(c, sizeof(c)); packer.pack_bin_body(c, sizeof(c));
bool referenced; bool referenced;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -45,7 +45,7 @@ TEST(reference, unpack_ext)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
bool referenced; bool referenced;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -66,7 +66,7 @@ TEST(reference, unpack_int_ref)
msgpack::pack(sbuf, 1); msgpack::pack(sbuf, 1);
bool referenced; bool referenced;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
} }
@ -76,7 +76,7 @@ TEST(reference, unpack_string_ref)
msgpack::pack(sbuf, std::string("abcdefg")); msgpack::pack(sbuf, std::string("abcdefg"));
bool referenced; bool referenced;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
} }
@ -89,7 +89,7 @@ TEST(reference, unpack_bin_ref)
packer.pack_bin_body(c, sizeof(c)); packer.pack_bin_body(c, sizeof(c));
bool referenced; bool referenced;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
} }
@ -102,7 +102,7 @@ TEST(reference, unpack_ext_ref)
packer.pack_ext(sizeof(buf), 1); packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf)); packer.pack_ext_body(buf, sizeof(buf));
bool referenced; bool referenced;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
} }
@ -134,7 +134,7 @@ TEST(reference, unpack_int_sized_ref)
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called, &sbuf); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called, &sbuf);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(nullptr, s_p); EXPECT_EQ(nullptr, s_p);
} }
@ -148,7 +148,7 @@ TEST(reference, unpack_string_sized_ref_4)
s_p = nullptr; s_p = nullptr;
// the last argument sbuf is any pointer as a user data. // the last argument sbuf is any pointer as a user data.
// That is stored to s_p in sized_reference // That is stored to s_p in sized_reference
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
// compare the passed argument with stored s_p. // compare the passed argument with stored s_p.
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
@ -161,7 +161,7 @@ TEST(reference, unpack_string_sized_ref_5)
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }
@ -177,7 +177,7 @@ TEST(reference, unpack_bin_sized_ref_5)
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }
@ -192,7 +192,7 @@ TEST(reference, unpack_bin_sized_ref_6)
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }
@ -208,7 +208,7 @@ TEST(reference, unpack_ext_sized_ref_6)
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced); EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }
@ -224,7 +224,7 @@ TEST(reference, unpack_ext_sized_ref_7)
bool referenced; bool referenced;
s_p = nullptr; s_p = nullptr;
msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced); EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p); EXPECT_EQ(&sbuf, s_p);
} }

18
test/shared_ptr_cpp11.cpp
View File

@ -14,9 +14,9 @@ TEST(SHARED_PTR, pack_convert_nil)
std::stringstream ss; std::stringstream ss;
std::shared_ptr<int> val1; std::shared_ptr<int> val1;
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
std::shared_ptr<int> val2 = ret.get().as<std::shared_ptr<int>>(); std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }
@ -25,9 +25,9 @@ TEST(SHARED_PTR, pack_convert_int)
std::stringstream ss; std::stringstream ss;
std::shared_ptr<int> val1(new int(1)); std::shared_ptr<int> val1(new int(1));
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
std::shared_ptr<int> val2 = ret.get().as<std::shared_ptr<int>>(); std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
EXPECT_TRUE(*val1 == *val2); EXPECT_TRUE(*val1 == *val2);
} }
@ -113,9 +113,9 @@ TEST(SHARED_PTR, pack_convert_nil_no_def_con)
std::stringstream ss; std::stringstream ss;
std::shared_ptr<no_def_con> val1(new no_def_con(1)); std::shared_ptr<no_def_con> val1(new no_def_con(1));
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
std::shared_ptr<no_def_con> val2 = ret.get().as<std::shared_ptr<no_def_con>>(); std::shared_ptr<no_def_con> val2 = oh.get().as<std::shared_ptr<no_def_con>>();
EXPECT_TRUE(*val1 == *val2); EXPECT_TRUE(*val1 == *val2);
} }

24
test/streaming.cpp
View File

@ -15,7 +15,7 @@ TEST(streaming, basic)
const char* const eof = input + buffer.size(); const char* const eof = input + buffer.size();
msgpack::unpacker pac; msgpack::unpacker pac;
msgpack::unpacked result; msgpack::object_handle oh;
int count = 0; int count = 0;
while(count < 3) { while(count < 3) {
@ -29,8 +29,8 @@ TEST(streaming, basic)
pac.buffer_consumed(len); pac.buffer_consumed(len);
while(pac.next(result)) { while(pac.next(oh)) {
msgpack::object obj = result.get(); msgpack::object obj = oh.get();
switch(count++) { switch(count++) {
case 0: case 0:
EXPECT_EQ(1, obj.as<int>()); EXPECT_EQ(1, obj.as<int>());
@ -61,7 +61,7 @@ TEST(streaming, basic_pointer)
const char* const eof = input + buffer.size(); const char* const eof = input + buffer.size();
msgpack::unpacker pac; msgpack::unpacker pac;
msgpack::unpacked result; msgpack::object_handle oh;
int count = 0; int count = 0;
while(count < 3) { while(count < 3) {
@ -75,8 +75,8 @@ TEST(streaming, basic_pointer)
pac.buffer_consumed(len); pac.buffer_consumed(len);
while(pac.next(&result)) { while(pac.next(&oh)) {
msgpack::object obj = result.get(); msgpack::object obj = oh.get();
switch(count++) { switch(count++) {
case 0: case 0:
EXPECT_EQ(1, obj.as<int>()); EXPECT_EQ(1, obj.as<int>());
@ -109,7 +109,7 @@ TEST(streaming, move)
const char* const eof = input + buffer.size(); const char* const eof = input + buffer.size();
msgpack::unpacker pac; msgpack::unpacker pac;
msgpack::unpacked result; msgpack::object_handle oh;
int count = 0; int count = 0;
while(count < 3) { while(count < 3) {
@ -124,8 +124,8 @@ TEST(streaming, move)
pac_in.buffer_consumed(len); pac_in.buffer_consumed(len);
while(pac_in.next(result)) { while(pac_in.next(oh)) {
msgpack::object obj = result.get(); msgpack::object obj = oh.get();
switch(count++) { switch(count++) {
case 0: case 0:
EXPECT_EQ(1, obj.as<int>()); EXPECT_EQ(1, obj.as<int>());
@ -164,9 +164,9 @@ public:
pac.buffer_consumed(len); pac.buffer_consumed(len);
msgpack::unpacked result; msgpack::object_handle oh;
while(pac.next(result)) { while(pac.next(oh)) {
on_message(result.get(), msgpack::move(result.zone())); on_message(oh.get(), msgpack::move(oh.zone()));
} }
if(pac.message_size() > 10*1024*1024) { if(pac.message_size() > 10*1024*1024) {

18
test/unique_ptr_cpp11.cpp
View File

@ -14,9 +14,9 @@ TEST(UNIQUE_PTR, pack_convert_nil)
std::stringstream ss; std::stringstream ss;
std::unique_ptr<int> val1; std::unique_ptr<int> val1;
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
std::unique_ptr<int> val2 = ret.get().as<std::unique_ptr<int>>(); std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
EXPECT_TRUE(val1 == val2); EXPECT_TRUE(val1 == val2);
} }
@ -25,9 +25,9 @@ TEST(UNIQUE_PTR, pack_convert_int)
std::stringstream ss; std::stringstream ss;
std::unique_ptr<int> val1(new int(1)); std::unique_ptr<int> val1(new int(1));
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
std::unique_ptr<int> val2 = ret.get().as<std::unique_ptr<int>>(); std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
EXPECT_TRUE(*val1 == *val2); EXPECT_TRUE(*val1 == *val2);
} }
@ -113,9 +113,9 @@ TEST(UNIQUE_PTR, pack_convert_nil_no_def_con)
std::stringstream ss; std::stringstream ss;
std::unique_ptr<no_def_con> val1(new no_def_con(1)); std::unique_ptr<no_def_con> val1(new no_def_con(1));
msgpack::pack(ss, val1); msgpack::pack(ss, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::unpack(ss.str().data(), ss.str().size());
std::unique_ptr<no_def_con> val2 = ret.get().as<std::unique_ptr<no_def_con>>(); std::unique_ptr<no_def_con> val2 = oh.get().as<std::unique_ptr<no_def_con>>();
EXPECT_TRUE(*val1 == *val2); EXPECT_TRUE(*val1 == *val2);
} }

78
test/user_class.cpp
View File

@ -54,9 +54,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
TestClass val1; TestClass val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
TestClass val2 = ret.get().as<TestClass>(); TestClass val2 = oh.get().as<TestClass>();
EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s); EXPECT_EQ(val1.s, val2.s);
} }
@ -81,9 +81,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
TestClass val1; TestClass val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
TestClass2 val2 = ret.get().as<TestClass2>(); TestClass2 val2 = oh.get().as<TestClass2>();
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());
@ -96,9 +96,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
TestClass2 val1; TestClass2 val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
TestClass val2 = ret.get().as<TestClass>(); TestClass val2 = oh.get().as<TestClass>();
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());
@ -110,9 +110,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
TestEnumMemberClass val1; TestEnumMemberClass val1;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
TestEnumMemberClass val2 = ret.get().as<TestEnumMemberClass>(); TestEnumMemberClass val2 = oh.get().as<TestEnumMemberClass>();
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);
@ -166,9 +166,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
TestUnionMemberClass val1(1.0); TestUnionMemberClass val1(1.0);
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
TestUnionMemberClass val2 = ret.get().as<TestUnionMemberClass>(); TestUnionMemberClass val2 = oh.get().as<TestUnionMemberClass>();
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);
} }
@ -177,9 +177,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
TestUnionMemberClass val1(1); TestUnionMemberClass val1(1);
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1); msgpack::pack(sbuf, val1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
TestUnionMemberClass val2 = ret.get().as<TestUnionMemberClass>(); TestUnionMemberClass val2 = oh.get().as<TestUnionMemberClass>();
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);
@ -220,9 +220,9 @@ TEST(MSGPACK_INHERIT, define_non_virtual)
b.d_mid2::t = 5; b.d_mid2::t = 5;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b); msgpack::pack(sbuf, b);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
d_bottom br = ret.get().as<d_bottom>(); d_bottom br = oh.get().as<d_bottom>();
EXPECT_EQ(b.b, br.b); EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1); EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2); EXPECT_EQ(b.m2, br.m2);
@ -259,9 +259,9 @@ TEST(MSGPACK_INHERIT, define_virtual)
b.t = 4; b.t = 4;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b); msgpack::pack(sbuf, b);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
v_d_bottom br = ret.get().as<v_d_bottom>(); v_d_bottom br = oh.get().as<v_d_bottom>();
EXPECT_EQ(b.b, br.b); EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1); EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2); EXPECT_EQ(b.m2, br.m2);
@ -300,9 +300,9 @@ TEST(MSGPACK_INHERIT, define_array_non_virtual)
b.da_mid2::t = 5; b.da_mid2::t = 5;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b); msgpack::pack(sbuf, b);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
da_bottom br = ret.get().as<da_bottom>(); da_bottom br = oh.get().as<da_bottom>();
EXPECT_EQ(b.b, br.b); EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1); EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2); EXPECT_EQ(b.m2, br.m2);
@ -339,9 +339,9 @@ TEST(MSGPACK_INHERIT, define_array_virtual)
b.t = 4; b.t = 4;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b); msgpack::pack(sbuf, b);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
v_da_bottom br = ret.get().as<v_da_bottom>(); v_da_bottom br = oh.get().as<v_da_bottom>();
EXPECT_EQ(b.b, br.b); EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1); EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2); EXPECT_EQ(b.m2, br.m2);
@ -380,9 +380,9 @@ TEST(MSGPACK_INHERIT, define_map_non_virtual)
b.dm_mid2::t = 5; b.dm_mid2::t = 5;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b); msgpack::pack(sbuf, b);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
dm_bottom br = ret.get().as<dm_bottom>(); dm_bottom br = oh.get().as<dm_bottom>();
EXPECT_EQ(b.b, br.b); EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1); EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2); EXPECT_EQ(b.m2, br.m2);
@ -419,9 +419,9 @@ TEST(MSGPACK_INHERIT, define_map_virtual)
b.t = 4; b.t = 4;
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b); msgpack::pack(sbuf, b);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
v_dm_bottom br = ret.get().as<v_dm_bottom>(); v_dm_bottom br = oh.get().as<v_dm_bottom>();
EXPECT_EQ(b.b, br.b); EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1); EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2); EXPECT_EQ(b.m2, br.m2);
@ -451,9 +451,9 @@ TEST(MSGPACK_MIGRATION, order_number_changed)
msgpack::sbuffer sbuf; msgpack::sbuffer sbuf;
msgpack::pack(sbuf, v1); msgpack::pack(sbuf, v1);
msgpack::unpacked ret; msgpack::object_handle oh =
msgpack::unpack(ret, sbuf.data(), sbuf.size()); msgpack::unpack(sbuf.data(), sbuf.size());
s_v2 v2 = ret.get().as<s_v2>(); s_v2 v2 = oh.get().as<s_v2>();
EXPECT_EQ(v2.c, 'A'); EXPECT_EQ(v2.c, 'A');
EXPECT_EQ(v2.s, "foo"); // from v1 EXPECT_EQ(v2.s, "foo"); // from v1