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

Replaced zone* member variable in object with zone&.

Browse Source 
Added msgpack::object::with_zone tests.
Added tuples operator<<'s parameter to const.
Fixed array object::with_zone pointer and size unset problem.
Fixed forward_list object::with_zone pointer and size unset problem.
This commit is contained in:
Takatoshi Kondo 2014-08-11 13:23:27 +09:00
parent 8920c49597
commit f969f6f39c
38 changed files with 818 additions and 1839 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
erb/cpp03_define.hpp.erb
View File

@ -29,7 +29,7 @@
msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
}\
template <typename MSGPACK_OBJECT> \
void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \
void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
{ \
msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
}
@ -82,7 +82,7 @@ struct define<> {
{
if(o.type != type::ARRAY) { throw type_error(); }
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = nullptr;
@ -115,10 +115,10 @@ struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*<%=i+1%>));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*<%=i+1%>));
o->via.array.size = <%=i+1%>;
<%0.upto(i) {|j|%>
o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%>

2
erb/cpp03_msgpack_tuple.hpp.erb
View File

@ -184,7 +184,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*<%=i+1%>));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*<%=i+1%>));
o.via.array.size = <%=i+1%>;
<%0.upto(i) {|j|%>
o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%>

4
include/msgpack/adaptor/cpp11/array.hpp
View File

@ -57,7 +57,9 @@ inline void operator<< (object::with_zone& o, const std::array<T, N>& v) {
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
object* p = static_cast<object*>(o.zone->allocate_align(sizeof(object)*v.size()));
object* p = static_cast<object*>(o.zone.allocate_align(sizeof(object)*v.size()));
o.via.array.size = v.size();
o.via.array.ptr = p;
for (auto const& e : v) *p++ = object(e, o.zone);
}
}

2
include/msgpack/adaptor/cpp11/array_char.hpp
View File

@ -63,7 +63,7 @@ template <std::size_t N>
inline void operator<< (object::with_zone& o, const std::array<char, N>& v)
{
o.type = type::BIN;
char* ptr = static_cast<char*>(o.zone->allocate_align(v.size()));
char* ptr = static_cast<char*>(o.zone.allocate_align(v.size()));
o.via.bin.ptr = ptr;
o.via.bin.size = static_cast<uint32_t>(v.size());
std::memcpy(ptr, v.data(), v.size());

5
include/msgpack/adaptor/cpp11/forward_list.hpp
View File

@ -55,8 +55,11 @@ inline void operator<< (object::with_zone& o, const std::forward_list<T>& v)
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
std::size_t size = std::distance(v.begin(), v.end());
o.via.array.size = size;
object* p = static_cast<object*>(
o.zone->allocate_align(sizeof(object)*std::distance(v.begin(), v.end())));
o.zone.allocate_align(sizeof(object)*size));
o.via.array.ptr = p;
for(auto const& e : v) *p++ = object(e, o.zone);
}
}

4
include/msgpack/adaptor/cpp11/tuple.hpp
View File

@ -108,9 +108,9 @@ struct StdTupleToObjectWithZone<Tuple, 1> {
template <typename... Args>
inline void operator<< (
object::with_zone& o,
std::tuple<Args...>& v) {
std::tuple<Args...> const& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*sizeof...(Args)));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*sizeof...(Args)));
o.via.array.size = sizeof...(Args);
StdTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
}

2
include/msgpack/adaptor/deque.hpp
View File

@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::deque<T>& v)
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
object* p = static_cast<object*>(o.zone->allocate_align(sizeof(object)*v.size()));
object* p = static_cast<object*>(o.zone.allocate_align(sizeof(object)*v.size()));
object* const pend = p + v.size();
o.via.array.ptr = p;
o.via.array.size = v.size();

132
include/msgpack/adaptor/detail/cpp03_define.hpp
View File

@ -29,7 +29,7 @@
msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
}\
template <typename MSGPACK_OBJECT> \
void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \
void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
{ \
msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
}
@ -82,7 +82,7 @@ struct define<> {
{
if(o.type != type::ARRAY) { throw type_error(); }
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = nullptr;
@ -115,10 +115,10 @@ struct define<A0> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*1));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*1));
o->via.array.size = 1;
o->via.array.ptr[0] = object(a0, z);
@ -154,10 +154,10 @@ struct define<A0, A1> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*2));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*2));
o->via.array.size = 2;
o->via.array.ptr[0] = object(a0, z);
@ -197,10 +197,10 @@ struct define<A0, A1, A2> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*3));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*3));
o->via.array.size = 3;
o->via.array.ptr[0] = object(a0, z);
@ -244,10 +244,10 @@ struct define<A0, A1, A2, A3> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*4));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*4));
o->via.array.size = 4;
o->via.array.ptr[0] = object(a0, z);
@ -295,10 +295,10 @@ struct define<A0, A1, A2, A3, A4> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*5));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*5));
o->via.array.size = 5;
o->via.array.ptr[0] = object(a0, z);
@ -350,10 +350,10 @@ struct define<A0, A1, A2, A3, A4, A5> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*6));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*6));
o->via.array.size = 6;
o->via.array.ptr[0] = object(a0, z);
@ -409,10 +409,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*7));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*7));
o->via.array.size = 7;
o->via.array.ptr[0] = object(a0, z);
@ -472,10 +472,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*8));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*8));
o->via.array.size = 8;
o->via.array.ptr[0] = object(a0, z);
@ -539,10 +539,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*9));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*9));
o->via.array.size = 9;
o->via.array.ptr[0] = object(a0, z);
@ -610,10 +610,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*10));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*10));
o->via.array.size = 10;
o->via.array.ptr[0] = object(a0, z);
@ -685,10 +685,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*11));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*11));
o->via.array.size = 11;
o->via.array.ptr[0] = object(a0, z);
@ -764,10 +764,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*12));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*12));
o->via.array.size = 12;
o->via.array.ptr[0] = object(a0, z);
@ -847,10 +847,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*13));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*13));
o->via.array.size = 13;
o->via.array.ptr[0] = object(a0, z);
@ -934,10 +934,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*14));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*14));
o->via.array.size = 14;
o->via.array.ptr[0] = object(a0, z);
@ -1025,10 +1025,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*15));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*15));
o->via.array.size = 15;
o->via.array.ptr[0] = object(a0, z);
@ -1120,10 +1120,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*16));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*16));
o->via.array.size = 16;
o->via.array.ptr[0] = object(a0, z);
@ -1219,10 +1219,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*17));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*17));
o->via.array.size = 17;
o->via.array.ptr[0] = object(a0, z);
@ -1322,10 +1322,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*18));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*18));
o->via.array.size = 18;
o->via.array.ptr[0] = object(a0, z);
@ -1429,10 +1429,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*19));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*19));
o->via.array.size = 19;
o->via.array.ptr[0] = object(a0, z);
@ -1540,10 +1540,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*20));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*20));
o->via.array.size = 20;
o->via.array.ptr[0] = object(a0, z);
@ -1655,10 +1655,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*21));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*21));
o->via.array.size = 21;
o->via.array.ptr[0] = object(a0, z);
@ -1774,10 +1774,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*22));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*22));
o->via.array.size = 22;
o->via.array.ptr[0] = object(a0, z);
@ -1897,10 +1897,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*23));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*23));
o->via.array.size = 23;
o->via.array.ptr[0] = object(a0, z);
@ -2024,10 +2024,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*24));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*24));
o->via.array.size = 24;
o->via.array.ptr[0] = object(a0, z);
@ -2155,10 +2155,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*25));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*25));
o->via.array.size = 25;
o->via.array.ptr[0] = object(a0, z);
@ -2290,10 +2290,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*26));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*26));
o->via.array.size = 26;
o->via.array.ptr[0] = object(a0, z);
@ -2429,10 +2429,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*27));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*27));
o->via.array.size = 27;
o->via.array.ptr[0] = object(a0, z);
@ -2572,10 +2572,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*28));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*28));
o->via.array.size = 28;
o->via.array.ptr[0] = object(a0, z);
@ -2719,10 +2719,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*29));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*29));
o->via.array.size = 29;
o->via.array.ptr[0] = object(a0, z);
@ -2870,10 +2870,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*30));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*30));
o->via.array.size = 30;
o->via.array.ptr[0] = object(a0, z);
@ -3025,10 +3025,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*31));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*31));
o->via.array.size = 31;
o->via.array.ptr[0] = object(a0, z);
@ -3184,10 +3184,10 @@ struct define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A
}
}
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*32));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*32));
o->via.array.size = 32;
o->via.array.ptr[0] = object(a0, z);

64
include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp
View File

@ -12274,7 +12274,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*1));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*1));
o.via.array.size = 1;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12285,7 +12285,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*2));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*2));
o.via.array.size = 2;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12297,7 +12297,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*3));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*3));
o.via.array.size = 3;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12310,7 +12310,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*4));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*4));
o.via.array.size = 4;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12324,7 +12324,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*5));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*5));
o.via.array.size = 5;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12339,7 +12339,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*6));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*6));
o.via.array.size = 6;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12355,7 +12355,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*7));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*7));
o.via.array.size = 7;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12372,7 +12372,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*8));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*8));
o.via.array.size = 8;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12390,7 +12390,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*9));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*9));
o.via.array.size = 9;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12409,7 +12409,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*10));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*10));
o.via.array.size = 10;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12429,7 +12429,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*11));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*11));
o.via.array.size = 11;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12450,7 +12450,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*12));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*12));
o.via.array.size = 12;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12472,7 +12472,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*13));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*13));
o.via.array.size = 13;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12495,7 +12495,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*14));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*14));
o.via.array.size = 14;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12519,7 +12519,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*15));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*15));
o.via.array.size = 15;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12544,7 +12544,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*16));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*16));
o.via.array.size = 16;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12570,7 +12570,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*17));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*17));
o.via.array.size = 17;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12597,7 +12597,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*18));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*18));
o.via.array.size = 18;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12625,7 +12625,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*19));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*19));
o.via.array.size = 19;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12654,7 +12654,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*20));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*20));
o.via.array.size = 20;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12684,7 +12684,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*21));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*21));
o.via.array.size = 21;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12715,7 +12715,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*22));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*22));
o.via.array.size = 22;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12747,7 +12747,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*23));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*23));
o.via.array.size = 23;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12780,7 +12780,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*24));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*24));
o.via.array.size = 24;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12814,7 +12814,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*25));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*25));
o.via.array.size = 25;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12849,7 +12849,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*26));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*26));
o.via.array.size = 26;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12885,7 +12885,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*27));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*27));
o.via.array.size = 27;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12922,7 +12922,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*28));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*28));
o.via.array.size = 28;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12960,7 +12960,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*29));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*29));
o.via.array.size = 29;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -12999,7 +12999,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*30));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*30));
o.via.array.size = 30;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -13039,7 +13039,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*31));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*31));
o.via.array.size = 31;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);
@ -13080,7 +13080,7 @@ inline void operator<< (
object::with_zone& o,
const type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*32));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*32));
o.via.array.size = 32;
o.via.array.ptr[0] = object(v.template get<0>(), o.zone);

12
include/msgpack/adaptor/detail/cpp11_define.hpp
View File

@ -31,7 +31,7 @@
msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
}\
template <typename MSGPACK_OBJECT> \
void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \
void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
{ \
msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
}
@ -79,7 +79,7 @@ struct define_imp {
if(size <= N-1) { return; }
o.via.array.ptr[N-1].convert(std::get<N-1>(t));
}
static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
define_imp<Tuple, N-1>::object(o, z, t);
o->via.array.ptr[N-1] = msgpack::object(std::get<N-1>(t), z);
}
@ -96,7 +96,7 @@ struct define_imp<Tuple, 1> {
if(size <= 0) { return; }
o.via.array.ptr[0].convert(std::get<0>(t));
}
static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z);
}
};
@ -120,10 +120,10 @@ struct define {
define_imp<tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = static_cast<object*>(z->allocate_align(sizeof(object)*sizeof...(Args)));
o->via.array.ptr = static_cast<object*>(z.allocate_align(sizeof(object)*sizeof...(Args)));
o->via.array.size = sizeof...(Args);
define_imp<tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
@ -145,7 +145,7 @@ struct define<> {
{
if(o.type != type::ARRAY) { throw type_error(); }
}
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
void msgpack_object(msgpack::object* o, msgpack::zone& z) const
{
o->type = type::ARRAY;
o->via.array.ptr = NULL;

4
include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp
View File

@ -172,9 +172,9 @@ struct MsgpackTupleToObjectWithZone<Tuple, 1> {
template <typename... Args>
inline void operator<< (
object::with_zone& o,
type::tuple<Args...>& v) {
type::tuple<Args...> const& v) {
o.type = type::ARRAY;
o.via.array.ptr = static_cast<object*>(o.zone->allocate_align(sizeof(object)*sizeof...(Args)));
o.via.array.ptr = static_cast<object*>(o.zone.allocate_align(sizeof(object)*sizeof...(Args)));
o.via.array.size = sizeof...(Args);
MsgpackTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
}

2
include/msgpack/adaptor/list.hpp
View File

@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::list<T>& v)
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
object* p = static_cast<object*>(o.zone->allocate_align(sizeof(object)*v.size()));
object* p = static_cast<object*>(o.zone.allocate_align(sizeof(object)*v.size()));
object* const pend = p + v.size();
o.via.array.ptr = p;
o.via.array.size = v.size();

6
include/msgpack/adaptor/map.hpp
View File

@ -78,7 +78,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector<K,V>& v)
o.via.map.ptr = nullptr;
o.via.map.size = 0;
} else {
object_kv* p = static_cast<object_kv*>(o.zone->allocate_align(sizeof(object_kv)*v.size()));
object_kv* p = static_cast<object_kv*>(o.zone.allocate_align(sizeof(object_kv)*v.size()));
object_kv* const pend = p + v.size();
o.via.map.ptr = p;
o.via.map.size = v.size();
@ -134,7 +134,7 @@ inline void operator<< (object::with_zone& o, const std::map<K,V>& v)
o.via.map.ptr = nullptr;
o.via.map.size = 0;
} else {
object_kv* p = static_cast<object_kv*>(o.zone->allocate_align(sizeof(object_kv)*v.size()));
object_kv* p = static_cast<object_kv*>(o.zone.allocate_align(sizeof(object_kv)*v.size()));
object_kv* const pend = p + v.size();
o.via.map.ptr = p;
o.via.map.size = v.size();
@ -184,7 +184,7 @@ inline void operator<< (object::with_zone& o, const std::multimap<K,V>& v)
o.via.map.ptr = nullptr;
o.via.map.size = 0;
} else {
object_kv* p = static_cast<object_kv*>(o.zone->allocate_align(sizeof(object_kv)*v.size()));
object_kv* p = static_cast<object_kv*>(o.zone.allocate_align(sizeof(object_kv)*v.size()));
object_kv* const pend = p + v.size();
o.via.map.ptr = p;
o.via.map.size = v.size();

2
include/msgpack/adaptor/pair.hpp
View File

@ -47,7 +47,7 @@ template <typename T1, typename T2>
inline void operator<< (object::with_zone& o, const std::pair<T1, T2>& v)
{
o.type = type::ARRAY;
object* p = static_cast<object*>(o.zone->allocate_align(sizeof(object)*2));
object* p = static_cast<object*>(o.zone.allocate_align(sizeof(object)*2));
o.via.array.ptr = p;
o.via.array.size = 2;
p[0] = object(v.first, o.zone);

4
include/msgpack/adaptor/set.hpp
View File

@ -56,7 +56,7 @@ inline void operator<< (object::with_zone& o, const std::set<T>& v)
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
object* p = static_cast<object*>(o.zone->allocate_align(sizeof(object)*v.size()));
object* p = static_cast<object*>(o.zone.allocate_align(sizeof(object)*v.size()));
object* const pend = p + v.size();
o.via.array.ptr = p;
o.via.array.size = v.size();
@ -102,7 +102,7 @@ inline void operator<< (object::with_zone& o, const std::multiset<T>& v)
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
object* p = static_cast<object*>(o.zone->allocate_align(sizeof(object)*v.size()));
object* p = static_cast<object*>(o.zone.allocate_align(sizeof(object)*v.size()));
object* const pend = p + v.size();
o.via.array.ptr = p;
o.via.array.size = v.size();

2
include/msgpack/adaptor/string.hpp
View File

@ -51,7 +51,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v)
inline void operator<< (object::with_zone& o, const std::string& v)
{
o.type = type::STR;
char* ptr = static_cast<char*>(o.zone->allocate_align(v.size()));
char* ptr = static_cast<char*>(o.zone.allocate_align(v.size()));
o.via.str.ptr = ptr;
o.via.str.size = static_cast<uint32_t>(v.size());
memcpy(ptr, v.data(), v.size());

4
include/msgpack/adaptor/tr1/unordered_map.hpp
View File

@ -77,7 +77,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
o.via.map.ptr = nullptr;
o.via.map.size = 0;
} else {
object_kv* p = static_cast<object_kv*>(o.zone->allocate_align(sizeof(object_kv)*v.size()));
object_kv* p = static_cast<object_kv*>(o.zone.allocate_align(sizeof(object_kv)*v.size()));
object_kv* const pend = p + v.size();
o.via.map.ptr = p;
o.via.map.size = v.size();
@ -127,7 +127,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
o.via.map.ptr = nullptr;
o.via.map.size = 0;
} else {
object_kv* p = static_cast<object_kv*>(o.zone->allocate_align(sizeof(object_kv)*v.size()));
object_kv* p = static_cast<object_kv*>(o.zone.allocate_align(sizeof(object_kv)*v.size()));
object_kv* const pend = p + v.size();
o.via.map.ptr = p;
o.via.map.size = v.size();

4
include/msgpack/adaptor/tr1/unordered_set.hpp
View File

@ -74,7 +74,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
object* p = static_cast<object*>(o.zone->allocate_align(sizeof(object)*v.size()));
object* p = static_cast<object*>(o.zone.allocate_align(sizeof(object)*v.size()));
object* const pend = p + v.size();
o.via.array.ptr = p;
o.via.array.size = v.size();
@ -120,7 +120,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
object* p = static_cast<object*>(o.zone->allocate_align(sizeof(object)*v.size()));
object* p = static_cast<object*>(o.zone.allocate_align(sizeof(object)*v.size()));
object* const pend = p + v.size();
o.via.array.ptr = p;
o.via.array.size = v.size();

2
include/msgpack/adaptor/vector.hpp
View File

@ -61,7 +61,7 @@ inline void operator<< (object::with_zone& o, const std::vector<T>& v)
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
object* p = static_cast<object*>(o.zone->allocate_align(sizeof(object)*v.size()));
object* p = static_cast<object*>(o.zone.allocate_align(sizeof(object)*v.size()));
object* const pend = p + v.size();
o.via.array.ptr = p;
o.via.array.size = v.size();

2
include/msgpack/adaptor/vector_char.hpp
View File

@ -60,7 +60,7 @@ inline void operator<< (object& o, const std::vector<char>& v)
inline void operator<< (object::with_zone& o, const std::vector<char>& v)
{
o.type = type::BIN;
char* ptr = static_cast<char*>(o.zone->allocate_align(v.size()));
char* ptr = static_cast<char*>(o.zone.allocate_align(v.size()));
o.via.bin.ptr = ptr;
o.via.bin.size = static_cast<uint32_t>(v.size());
std::memcpy(ptr, v.data(), v.size());

19
include/msgpack/object.hpp
View File

@ -112,6 +112,10 @@ struct object {
template <typename T>
explicit object(const T& v);
template <typename T>
object(const T& v, zone& z);
// obsolete
template <typename T>
object(const T& v, zone* z);
@ -135,8 +139,8 @@ struct object_kv {
};
struct object::with_zone : object {
with_zone(msgpack::zone* zone) : zone(zone) { }
msgpack::zone* zone;
with_zone(msgpack::zone& zone) : zone(zone) { }
msgpack::zone& zone;
private:
with_zone();
};
@ -367,7 +371,7 @@ inline object& object::operator=(const T& v)
}
template <typename T>
object::object(const T& v, zone* z)
object::object(const T& v, zone& z)
{
with_zone oz(z);
oz << v;
@ -375,6 +379,15 @@ object::object(const T& v, zone* z)
via = oz.via;
}
template <typename T>
object::object(const T& v, zone* z)
{
with_zone oz(*z);
oz << v;
type = oz.type;
via = oz.via;
}
inline object::object(msgpack_object o)
{

1
test/CMakeLists.txt
View File

@ -14,6 +14,7 @@ SET (check_PROGRAMS
streaming.cpp
streaming_c.cpp
object.cpp
object_with_zone.cpp
version.cpp
convert.cpp
buffer.cpp

3
test/Makefile.am
View File

@ -9,6 +9,7 @@ check_PROGRAMS = \
streaming \
streaming_c \
object \
object_with_zone \
convert \
buffer \
cases \
@ -35,6 +36,8 @@ streaming_c_SOURCES = streaming_c.cpp
object_SOURCES = object.cpp
object_with_zone_SOURCES = object_with_zone.cpp
convert_SOURCES = convert.cpp
buffer_SOURCES = buffer.cpp

119
test/buffer.cc
View File

@ -1,119 +0,0 @@
#include <msgpack.hpp>
#include <msgpack/fbuffer.hpp>
#include <msgpack/fbuffer.h>
#include <msgpack/zbuffer.hpp>
#include <gtest/gtest.h>
#include <string.h>
TEST(buffer, sbuffer)
{
msgpack::sbuffer sbuf;
sbuf.write("a", 1);
sbuf.write("a", 1);
sbuf.write("a", 1);
EXPECT_EQ(3, sbuf.size());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
sbuf.clear();
sbuf.write("a", 1);
sbuf.write("a", 1);
sbuf.write("a", 1);
EXPECT_EQ(3, sbuf.size());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
}
TEST(buffer, vrefbuffer)
{
msgpack::vrefbuffer vbuf;
vbuf.write("a", 1);
vbuf.write("a", 1);
vbuf.write("a", 1);
const struct iovec* vec = vbuf.vector();
size_t veclen = vbuf.vector_size();
msgpack::sbuffer sbuf;
for(size_t i=0; i < veclen; ++i) {
sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len);
}
EXPECT_EQ(3, sbuf.size());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
vbuf.clear();
vbuf.write("a", 1);
vbuf.write("a", 1);
vbuf.write("a", 1);
vec = vbuf.vector();
veclen = vbuf.vector_size();
sbuf.clear();
for(size_t i=0; i < veclen; ++i) {
sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len);
}
EXPECT_EQ(3, sbuf.size());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
}
TEST(buffer, zbuffer)
{
msgpack::zbuffer zbuf;
zbuf.write("a", 1);
zbuf.write("a", 1);
zbuf.write("a", 1);
zbuf.flush();
}
TEST(buffer, fbuffer)
{
FILE* file = tmpfile();
EXPECT_TRUE( file != NULL );
msgpack::fbuffer fbuf(file);
EXPECT_EQ(file, fbuf.file());
fbuf.write("a", 1);
fbuf.write("a", 1);
fbuf.write("a", 1);
fflush(file);
rewind(file);
for (size_t i=0; i < 3; ++i) {
int ch = fgetc(file);
EXPECT_TRUE(ch != EOF);
EXPECT_EQ('a', static_cast<char>(ch));
}
EXPECT_EQ(EOF, fgetc(file));
fclose(file);
}
TEST(buffer, fbuffer_c)
{
FILE* file = tmpfile();
void* fbuf = (void*)file;
EXPECT_TRUE( file != NULL );
EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1));
EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1));
EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1));
fflush(file);
rewind(file);
for (size_t i=0; i < 3; ++i) {
int ch = fgetc(file);
EXPECT_TRUE(ch != EOF);
EXPECT_EQ('a', (char) ch);
}
EXPECT_EQ(EOF, fgetc(file));
fclose(file);
}

38
test/cases.cc
View File

@ -1,38 +0,0 @@
#include <msgpack.hpp>
#include <fstream>
#include <gtest/gtest.h>
static void feed_file(msgpack::unpacker& pac, const char* path)
{
std::ifstream fin(path);
while(true) {
pac.reserve_buffer(32*1024);
fin.read(pac.buffer(), pac.buffer_capacity());
if(fin.bad()) {
throw std::runtime_error("read failed");
}
pac.buffer_consumed(fin.gcount());
if(fin.fail()) {
break;
}
}
}
TEST(cases, format)
{
msgpack::unpacker pac;
msgpack::unpacker pac_compact;
feed_file(pac, "cases.mpac");
feed_file(pac_compact, "cases_compact.mpac");
msgpack::unpacked result;
while(pac.next(&result)) {
msgpack::unpacked result_compact;
EXPECT_TRUE( pac_compact.next(&result_compact) );
EXPECT_EQ(result_compact.get(), result.get());
}
EXPECT_FALSE( pac_compact.next(&result) );
}

76
test/convert.cc
View File

@ -1,76 +0,0 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
class compatibility {
public:
compatibility() : str1("default"), str2("default") { }
std::string str1;
std::string str2;
MSGPACK_DEFINE(str1, str2);
};
TEST(convert, compatibility_less)
{
std::vector<std::string> src(1);
src[0] = "kumofs";
msgpack::zone z;
msgpack::object obj(src, &z);
compatibility c;
EXPECT_NO_THROW( obj.convert(&c) );
EXPECT_EQ("kumofs", c.str1);
EXPECT_EQ("default", c.str2);
}
TEST(convert, compatibility_more)
{
std::vector<std::string> src(3);
src[0] = "kumofs";
src[1] = "mpio";
src[2] = "cloudy";
msgpack::zone z;
msgpack::object obj(src, &z);
compatibility to;
EXPECT_NO_THROW( obj.convert(&to) );
EXPECT_EQ("kumofs", to.str1);
EXPECT_EQ("mpio", to.str2);
}
class enum_member {
public:
enum_member() : flag(A) { }
enum flags_t {
A = 0,
B = 1
};
flags_t flag;
MSGPACK_DEFINE(flag);
};
MSGPACK_ADD_ENUM(enum_member::flags_t);
TEST(convert, enum_member)
{
enum_member src;
src.flag = enum_member::B;
msgpack::zone z;
msgpack::object obj(src, &z);
enum_member to;
EXPECT_NO_THROW( obj.convert(&to) );
EXPECT_EQ(enum_member::B, to.flag);
}

55
test/fixint.cc
View File

@ -1,55 +0,0 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
template <typename T>
void check_size(size_t size) {
T v(0);
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, v);
EXPECT_EQ(size, sbuf.size());
}
TEST(fixint, size)
{
check_size<msgpack::type::fix_int8>(2);
check_size<msgpack::type::fix_int16>(3);
check_size<msgpack::type::fix_int32>(5);
check_size<msgpack::type::fix_int64>(9);
check_size<msgpack::type::fix_uint8>(2);
check_size<msgpack::type::fix_uint16>(3);
check_size<msgpack::type::fix_uint32>(5);
check_size<msgpack::type::fix_uint64>(9);
}
template <typename T>
void check_convert() {
T v1(-11);
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, v1);
msgpack::unpacked msg;
msgpack::unpack(&msg, sbuf.data(), sbuf.size());
T v2;
msg.get().convert(&v2);
EXPECT_EQ(v1.get(), v2.get());
EXPECT_EQ(msg.get(), msgpack::object(T(v1.get())));
}
TEST(fixint, convert)
{
check_convert<msgpack::type::fix_int8>();
check_convert<msgpack::type::fix_int16>();
check_convert<msgpack::type::fix_int32>();
check_convert<msgpack::type::fix_int64>();
check_convert<msgpack::type::fix_uint8>();
check_convert<msgpack::type::fix_uint16>();
check_convert<msgpack::type::fix_uint32>();
check_convert<msgpack::type::fix_uint64>();
}

32
test/fixint_c.cc
View File

@ -1,32 +0,0 @@
#include <msgpack.h>
#include <gtest/gtest.h>
TEST(fixint, size)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
size_t sum = 0;
EXPECT_EQ(0, msgpack_pack_fix_int8(pk, 0));
EXPECT_EQ(sum+=2, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_int16(pk, 0));
EXPECT_EQ(sum+=3, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_int32(pk, 0));
EXPECT_EQ(sum+=5, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_int64(pk, 0));
EXPECT_EQ(sum+=9, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_uint8(pk, 0));
EXPECT_EQ(sum+=2, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_uint16(pk, 0));
EXPECT_EQ(sum+=3, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_uint32(pk, 0));
EXPECT_EQ(sum+=5, sbuf->size);
EXPECT_EQ(0, msgpack_pack_fix_uint64(pk, 0));
EXPECT_EQ(sum+=9, sbuf->size);
msgpack_sbuffer_free(sbuf);
msgpack_packer_free(pk);
}

103
test/msgpack_tuple.cc
View File

@ -1,103 +0,0 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
TEST(msgpack_tuple, member_get)
{
msgpack::type::tuple<int, bool, std::string> t1(42, true, "ABC");
EXPECT_EQ(42, t1.get<0>());
EXPECT_EQ(true, t1.get<1>());
EXPECT_EQ("ABC", t1.get<2>());
t1.get<0>() = 40;
t1.get<1>() = false;
t1.get<2>() = "DEFG";
EXPECT_EQ(40, t1.get<0>());
EXPECT_EQ(false, t1.get<1>());
EXPECT_EQ("DEFG", t1.get<2>());
}
TEST(msgpack_tuple, non_member_get)
{
msgpack::type::tuple<int, bool, std::string> t1(42, true, "ABC");
EXPECT_EQ(42, msgpack::type::get<0>(t1));
EXPECT_EQ(true, msgpack::type::get<1>(t1));
EXPECT_EQ("ABC", msgpack::type::get<2>(t1));
msgpack::type::get<0>(t1) = 40;
msgpack::type::get<1>(t1) = false;
msgpack::type::get<2>(t1) = "DEFG";
EXPECT_EQ(40, msgpack::type::get<0>(t1));
EXPECT_EQ(false, msgpack::type::get<1>(t1));
EXPECT_EQ("DEFG", msgpack::type::get<2>(t1));
}
#if __cplusplus >= 201103
TEST(msgpack_tuple, std_non_member_get)
{
msgpack::type::tuple<int, bool, std::string> t1(42, true, "ABC");
EXPECT_EQ(42, std::get<0>(t1));
EXPECT_EQ(true, std::get<1>(t1));
EXPECT_EQ("ABC", std::get<2>(t1));
std::get<0>(t1) = 40;
std::get<1>(t1) = false;
std::get<2>(t1) = "DEFG";
EXPECT_EQ(40, std::get<0>(t1));
EXPECT_EQ(false, std::get<1>(t1));
EXPECT_EQ("DEFG", std::get<2>(t1));
}
TEST(msgpack_tuple, make_tuple)
{
msgpack::type::tuple<int, bool, std::string> t1 = msgpack::type::make_tuple(42, true, "ABC");
EXPECT_EQ(42, t1.get<0>());
EXPECT_EQ(true, t1.get<1>());
EXPECT_EQ("ABC", t1.get<2>());
t1.get<0>() = 40;
t1.get<1>() = false;
t1.get<2>() = "DEFG";
EXPECT_EQ(40, t1.get<0>());
EXPECT_EQ(false, t1.get<1>());
EXPECT_EQ("DEFG", t1.get<2>());
}
TEST(msgpack_tuple, std_make_tuple)
{
msgpack::type::tuple<int, bool, std::string> t1 = std::make_tuple(42, true, "ABC");
EXPECT_EQ(42, t1.get<0>());
EXPECT_EQ(true, t1.get<1>());
EXPECT_EQ("ABC", t1.get<2>());
}
TEST(msgpack_tuple, tie)
{
int i(43);
bool b(false);
std::string s("DEFG");
msgpack::type::tie(i, b, s) = msgpack::type::make_tuple(42, true, "ABC");
EXPECT_EQ(42, i);
EXPECT_EQ(true, b);
EXPECT_EQ("ABC", s);
}
TEST(msgpack_tuple, tuple_cat)
{
msgpack::type::tuple<int> t1 = msgpack::type::make_tuple(42);
msgpack::type::tuple<bool, std::string> t2 = msgpack::type::make_tuple(true, "ABC");
msgpack::type::tuple<int, bool, std::string> t3 = msgpack::type::tuple_cat(t1, std::move(t2));
EXPECT_EQ(42, t3.get<0>());
EXPECT_EQ(true, t3.get<1>());
EXPECT_EQ("ABC", t3.get<2>());
}
TEST(msgpack_tuple, swap)
{
msgpack::type::tuple<int, bool, std::string> t1 = msgpack::type::make_tuple(42, true, "ABC");
msgpack::type::tuple<int, bool, std::string> t2 = msgpack::type::make_tuple(40, false, "DEFG");
msgpack::type::swap(t1, t2);
EXPECT_EQ(42, t2.get<0>());
EXPECT_EQ(true, t2.get<1>());
EXPECT_EQ("ABC", t2.get<2>());
EXPECT_EQ(40, t1.get<0>());
EXPECT_EQ(false, t1.get<1>());
EXPECT_EQ("DEFG", t1.get<2>());
}
#endif

125
test/object.cc
View File

@ -1,125 +0,0 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
struct myclass {
myclass() : num(0), str("default") { }
myclass(int num, const std::string& str) :
num(0), str("default") { }
~myclass() { }
int num;
std::string str;
MSGPACK_DEFINE(num, str);
bool operator==(const myclass& o) const
{
return num == o.num && str == o.str;
}
};
std::ostream& operator<<(std::ostream& o, const myclass& m)
{
return o << "myclass("<<m.num<<",\""<<m.str<<"\")";
}
TEST(object, convert)
{
myclass m1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, m1);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
myclass m2;
ret.get().convert(&m2);
EXPECT_EQ(m1, m2);
}
TEST(object, as)
{
myclass m1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, m1);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(m1, ret.get().as<myclass>());
}
TEST(object, print)
{
msgpack::object obj;
std::cout << obj << std::endl;
}
TEST(object, is_nil)
{
msgpack::object obj;
EXPECT_TRUE(obj.is_nil());
}
TEST(object, type_error)
{
msgpack::object obj(1);
EXPECT_THROW(obj.as<std::string>(), msgpack::type_error);
EXPECT_THROW(obj.as<std::vector<int> >(), msgpack::type_error);
EXPECT_EQ(1, obj.as<int>());
EXPECT_EQ(1, obj.as<short>());
EXPECT_EQ(1u, obj.as<unsigned int>());
EXPECT_EQ(1u, obj.as<unsigned long>());
}
TEST(object, equal_primitive)
{
msgpack::object obj_nil;
EXPECT_EQ(obj_nil, msgpack::object());
msgpack::object obj_int(1);
EXPECT_EQ(obj_int, msgpack::object(1));
EXPECT_EQ(obj_int, 1);
msgpack::object obj_double(1.2);
EXPECT_EQ(obj_double, msgpack::object(1.2));
EXPECT_EQ(obj_double, 1.2);
msgpack::object obj_bool(true);
EXPECT_EQ(obj_bool, msgpack::object(true));
EXPECT_EQ(obj_bool, true);
}
TEST(object, construct_primitive)
{
msgpack::object obj_nil;
EXPECT_EQ(msgpack::type::NIL, obj_nil.type);
msgpack::object obj_uint(1);
EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type);
EXPECT_EQ(1u, obj_uint.via.u64);
msgpack::object obj_int(-1);
EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type);
EXPECT_EQ(-1, obj_int.via.i64);
msgpack::object obj_double(1.2);
EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type);
EXPECT_EQ(1.2, obj_double.via.dec);
msgpack::object obj_bool(true);
EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type);
EXPECT_EQ(true, obj_bool.via.boolean);
}

662
test/object_with_zone.cpp Normal file
View File

@ -0,0 +1,662 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
#include <cmath>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
using namespace std;
const unsigned int kLoop = 10000;
const unsigned int kElements = 100;
const double kEPS = 1e-10;
// bool
TEST(object_with_zone, bool)
{
bool v = true;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<bool>(), v);
v = false;
EXPECT_TRUE(obj.as<bool>());
}
// char
TEST(object_with_zone, char)
{
char v = 1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<char>(), v);
v = 2;
EXPECT_EQ(obj.as<char>(), 1);
}
// signed integer family
TEST(object_with_zone, signed_char)
{
signed char v = -1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<signed char>(), v);
v = -2;
EXPECT_EQ(obj.as<signed char>(), -1);
}
TEST(object_with_zone, signed_short)
{
signed short v = -1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<signed short>(), v);
v = -2;
EXPECT_EQ(obj.as<signed short>(), -1);
}
TEST(object_with_zone, signed_int)
{
signed int v = -1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<signed int>(), v);
v = -2;
EXPECT_EQ(obj.as<signed int>(), -1);
}
TEST(object_with_zone, signed_long)
{
signed long v = -1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<signed long>(), v);
v = -2;
EXPECT_EQ(obj.as<signed long>(), -1);
}
TEST(object_with_zone, signed_long_long)
{
signed long long v = -1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<signed long long>(), v);
v = -2;
EXPECT_EQ(obj.as<signed long long>(), -1);
}
// unsigned integer family
TEST(object_with_zone, unsigned_char)
{
unsigned char v = 1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<unsigned char>(), v);
v = 2;
EXPECT_EQ(obj.as<unsigned char>(), 1);
}
TEST(object_with_zone, unsigned_short)
{
unsigned short v = 1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<unsigned short>(), v);
v = 2;
EXPECT_EQ(obj.as<unsigned short>(), 1);
}
TEST(object_with_zone, unsigned_int)
{
unsigned int v = 1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<unsigned int>(), v);
v = 2;
EXPECT_EQ(obj.as<unsigned int>(), 1);
}
TEST(object_with_zone, unsigned_long)
{
unsigned long v = 1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<unsigned long>(), v);
v = 2;
EXPECT_EQ(obj.as<unsigned long>(), 1);
}
TEST(object_with_zone, unsigned_long_long)
{
unsigned long long v = 1;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<unsigned long long>(), v);
v = 2;
EXPECT_EQ(obj.as<unsigned long long>(), 1);
}
// float
TEST(object_with_zone, float)
{
float v = 1.23;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_TRUE(fabs(obj.as<float>() - v) <= kEPS);
v = 4.56;
EXPECT_TRUE(fabs(obj.as<float>() - static_cast<float>(1.23)) <= kEPS);
}
// double
TEST(object_with_zone, double)
{
double v = 1.23;
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_TRUE(fabs(obj.as<double>() - v) <= kEPS);
v = 4.56;
EXPECT_TRUE(fabs(obj.as<double>() - 1.23) <= kEPS);
}
// vector
TEST(object_with_zone, vector)
{
for (unsigned int k = 0; k < kLoop; k++) {
vector<int> v1;
v1.push_back(1);
for (unsigned int i = 1; i < kElements; i++)
v1.push_back(i);
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<vector<int> >(), v1);
v1.front() = 42;
EXPECT_EQ(obj.as<vector<int> >().front(), 1);
}
}
// vector_char
TEST(object_with_zone, vector_char)
{
for (unsigned int k = 0; k < kLoop; k++) {
vector<char> v1;
v1.push_back(1);
for (unsigned int i = 1; i < kElements; i++)
v1.push_back(static_cast<char>(i));
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<vector<char> >(), v1);
v1.front() = 42;
EXPECT_EQ(obj.as<vector<char> >().front(), 1);
}
}
TEST(object_without_zone, vector_char)
{
for (unsigned int k = 0; k < kLoop; k++) {
vector<char> v1;
v1.push_back(1);
for (unsigned int i = 1; i < kElements; i++)
v1.push_back(static_cast<char>(i));
msgpack::object obj(v1);
EXPECT_EQ(obj.as<vector<char> >(), v1);
v1.front() = 42;
// obj refer to v1
EXPECT_EQ(obj.as<vector<char> >().front(), 42);
}
}
// list
TEST(object_with_zone, list)
{
for (unsigned int k = 0; k < kLoop; k++) {
list<int> v1;
v1.push_back(1);
for (unsigned int i = 1; i < kElements; i++)
v1.push_back(i);
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<list<int> >(), v1);
v1.front() = 42;
EXPECT_EQ(obj.as<list<int> >().front(), 1);
}
}
// deque
TEST(object_with_zone, deque)
{
for (unsigned int k = 0; k < kLoop; k++) {
deque<int> v1;
v1.push_back(1);
for (unsigned int i = 1; i < kElements; i++)
v1.push_back(i);
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<deque<int> >(), v1);
v1.front() = 42;
EXPECT_EQ(obj.as<deque<int> >().front(), 1);
}
}
// string
TEST(object_with_zone, string)
{
string v = "abc";
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<string>(), v);
v[0] = 'd';
EXPECT_EQ(obj.as<string>()[0], 'a');
}
TEST(object_without_zone, string)
{
string v = "abc";
msgpack::zone z;
msgpack::object obj(v);
EXPECT_EQ(obj.as<string>(), v);
v[0] = 'd';
EXPECT_EQ(obj.as<string>()[0], 'd');
}
// raw_ref
TEST(object_with_zone, raw_ref)
{
string s = "abc";
msgpack::type::raw_ref v(s.data(), s.size());
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<msgpack::type::raw_ref>(), v);
s[0] = 'd';
// even if with_zone, not copied due to raw_ref
// Basically, the combination raw_ref and object::wit_zone
// is meaningless.
EXPECT_EQ(obj.as<msgpack::type::raw_ref>(), v);
}
TEST(object_without_zone, raw_ref)
{
string s = "abc";
msgpack::type::raw_ref v(s.data(), s.size());
msgpack::zone z;
msgpack::object obj(v);
EXPECT_EQ(obj.as<msgpack::type::raw_ref>(), v);
s[0] = 'd';
EXPECT_EQ(obj.as<msgpack::type::raw_ref>(), v);
}
// pair
TEST(object_with_zone, pair)
{
typedef pair<int, string> test_t;
test_t v(1, "abc");
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<test_t>(), v);
v.first = 42;
EXPECT_EQ(obj.as<test_t>().first, 1);
}
// set
TEST(object_with_zone, set)
{
for (unsigned int k = 0; k < kLoop; k++) {
set<int> v1;
for (unsigned int i = 0; i < kElements; i++)
v1.insert(i);
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<set<int> >(), v1);
}
}
// multiset
TEST(object_with_zone, multiset)
{
for (unsigned int k = 0; k < kLoop; k++) {
multiset<int> v1;
for (unsigned int i = 0; i < kElements; i++)
v1.insert(i % (kElements / 2));
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<multiset<int> >(), v1);
}
}
// map
TEST(object_with_zone, map)
{
typedef map<int, int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++)
v1.insert(std::make_pair(i, i*2));
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<test_t >(), v1);
}
}
// multimap
TEST(object_with_zone, multimap)
{
typedef multimap<int, int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++)
v1.insert(std::make_pair(i % (kElements / 2), i*2));
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<test_t >(), v1);
}
}
// msgpack_tuple
TEST(object_with_zone, msgpack_tuple)
{
typedef msgpack::type::tuple<int, string, bool> test_t;
test_t v(1, "abc", true);
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(msgpack::type::get<0>(obj.as<test_t>()), 1);
EXPECT_EQ(msgpack::type::get<1>(obj.as<test_t>()), "abc");
EXPECT_EQ(msgpack::type::get<2>(obj.as<test_t>()), true);
msgpack::type::get<0>(v) = 42;
EXPECT_EQ(msgpack::type::get<0>(obj.as<test_t>()), 1);
}
// TR1
#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP
#include <tr1/unordered_map>
#include "msgpack/adaptor/tr1/unordered_map.hpp"
TEST(object_with_zone, tr1_unordered_map)
{
typedef tr1::unordered_map<int, int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++)
v1[rand()] = rand();
msgpack::zone z;
msgpack::object obj(v1, z);
test_t v2 = obj.as<test_t>();
EXPECT_EQ(v1.size(), v2.size());
test_t::const_iterator it;
for (it = v1.begin(); it != v1.end(); ++it) {
EXPECT_TRUE(v2.find(it->first) != v2.end());
EXPECT_EQ(it->second, v2.find(it->first)->second);
}
}
}
TEST(object_with_zone, tr1_unordered_multimap)
{
typedef tr1::unordered_multimap<int, int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++) {
int i1 = rand();
v1.insert(make_pair(i1, rand()));
v1.insert(make_pair(i1, rand()));
}
msgpack::zone z;
msgpack::object obj(v1, z);
test_t v2 = obj.as<test_t>();
vector<pair<int, int> > vec1, vec2;
tr1::unordered_multimap<int, int>::const_iterator it;
for (it = v1.begin(); it != v1.end(); ++it)
vec1.push_back(make_pair(it->first, it->second));
for (it = v2.begin(); it != v2.end(); ++it)
vec2.push_back(make_pair(it->first, it->second));
EXPECT_EQ(v1.size(), v2.size());
EXPECT_EQ(vec1.size(), vec2.size());
sort(vec1.begin(), vec1.end());
sort(vec2.begin(), vec2.end());
EXPECT_TRUE(vec1 == vec2);
}
}
#endif
#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET
#include <tr1/unordered_set>
#include "msgpack/adaptor/tr1/unordered_set.hpp"
TEST(object_with_zone, tr1_unordered_set)
{
typedef tr1::unordered_set<int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++)
v1.insert(rand());
msgpack::zone z;
msgpack::object obj(v1, z);
test_t v2 = obj.as<test_t>();
EXPECT_EQ(v1.size(), v2.size());
tr1::unordered_set<int>::const_iterator it;
for (it = v1.begin(); it != v1.end(); ++it)
EXPECT_TRUE(v2.find(*it) != v2.end());
}
}
TEST(object_with_zone, tr1_unordered_multiset)
{
typedef tr1::unordered_set<int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++) {
int i1 = rand();
v1.insert(i1);
v1.insert(i1);
}
msgpack::zone z;
msgpack::object obj(v1, z);
test_t v2 = obj.as<test_t>();
vector<int> vec1, vec2;
tr1::unordered_multiset<int>::const_iterator it;
for (it = v1.begin(); it != v1.end(); ++it)
vec1.push_back(*it);
for (it = v2.begin(); it != v2.end(); ++it)
vec2.push_back(*it);
EXPECT_EQ(v1.size(), v2.size());
EXPECT_EQ(vec1.size(), vec2.size());
sort(vec1.begin(), vec1.end());
sort(vec2.begin(), vec2.end());
EXPECT_TRUE(vec1 == vec2);
}
}
#endif
#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP
#include <unordered_map>
#include "msgpack/adaptor/tr1/unordered_map.hpp"
TEST(object_with_zone, unordered_map)
{
typedef unordered_map<int, int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++)
v1[rand()] = rand();
msgpack::zone z;
msgpack::object obj(v1, z);
test_t v2 = obj.as<test_t>();
EXPECT_EQ(v1.size(), v2.size());
test_t::const_iterator it;
for (it = v1.begin(); it != v1.end(); ++it) {
EXPECT_TRUE(v2.find(it->first) != v2.end());
EXPECT_EQ(it->second, v2.find(it->first)->second);
}
}
}
TEST(object_with_zone, unordered_multimap)
{
typedef unordered_multimap<int, int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++) {
int i1 = rand();
v1.insert(make_pair(i1, rand()));
v1.insert(make_pair(i1, rand()));
}
msgpack::zone z;
msgpack::object obj(v1, z);
test_t v2 = obj.as<test_t>();
vector<pair<int, int> > vec1, vec2;
tr1::unordered_multimap<int, int>::const_iterator it;
for (it = v1.begin(); it != v1.end(); ++it)
vec1.push_back(make_pair(it->first, it->second));
for (it = v2.begin(); it != v2.end(); ++it)
vec2.push_back(make_pair(it->first, it->second));
EXPECT_EQ(v1.size(), v2.size());
EXPECT_EQ(vec1.size(), vec2.size());
sort(vec1.begin(), vec1.end());
sort(vec2.begin(), vec2.end());
EXPECT_TRUE(vec1 == vec2);
}
}
#endif
#ifdef MSGPACK_HAS_STD_UNOURDERED_SET
#include <unordered_set>
#include "msgpack/adaptor/tr1/unordered_set.hpp"
TEST(object_with_zone, unordered_set)
{
typedef unordered_set<int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++)
v1.insert(rand());
msgpack::zone z;
msgpack::object obj(v1, z);
test_t v2 = obj.as<test_t>();
EXPECT_EQ(v1.size(), v2.size());
tr1::unordered_set<int>::const_iterator it;
for (it = v1.begin(); it != v1.end(); ++it)
EXPECT_TRUE(v2.find(*it) != v2.end());
}
}
TEST(object_with_zone, unordered_multiset)
{
typedef unordered_set<int> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
for (unsigned int i = 0; i < kElements; i++) {
int i1 = rand();
v1.insert(i1);
v1.insert(i1);
}
msgpack::zone z;
msgpack::object obj(v1, z);
test_t v2 = obj.as<test_t>();
vector<int> vec1, vec2;
tr1::unordered_multiset<int>::const_iterator it;
for (it = v1.begin(); it != v1.end(); ++it)
vec1.push_back(*it);
for (it = v2.begin(); it != v2.end(); ++it)
vec2.push_back(*it);
EXPECT_EQ(v1.size(), v2.size());
EXPECT_EQ(vec1.size(), vec2.size());
sort(vec1.begin(), vec1.end());
sort(vec2.begin(), vec2.end());
EXPECT_TRUE(vec1 == vec2);
}
}
#endif
// User defined class
class TestClass
{
public:
TestClass() : i(0), s("kzk") {}
int i;
string s;
MSGPACK_DEFINE(i, s);
};
TEST(object_with_zone, user_defined)
{
TestClass v1;
msgpack::zone z;
msgpack::object obj(v1, z);
TestClass v2 = obj.as<TestClass>();
EXPECT_EQ(v1.i, v2.i);
EXPECT_EQ(v1.s, v2.s);
}
#if !defined(MSGPACK_USE_CPP03)
TEST(object_with_zone, array)
{
typedef array<int, kElements> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
v1[0] = 1;
for (unsigned int i = 1; i < kElements; i++)
v1[i] = rand();
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<test_t>(), v1);
v1.front() = 42;
EXPECT_EQ(obj.as<test_t>().front(), 1);
}
}
TEST(object_with_zone, array_char)
{
typedef array<char, kElements> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
v1[0] = 1;
for (unsigned int i = 1; i < kElements; i++)
v1[i] = rand();
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<test_t>(), v1);
v1.front() = 42;
EXPECT_EQ(obj.as<test_t>().front(), 1);
}
}
TEST(object_without_zone, array_char)
{
typedef array<char, kElements> test_t;
for (unsigned int k = 0; k < kLoop; k++) {
test_t v1;
v1[0] = 1;
for (unsigned int i = 1; i < kElements; i++)
v1[i] = rand();
msgpack::object obj(v1);
EXPECT_EQ(obj.as<test_t>(), v1);
v1.front() = 42;
// obj refer to v1
EXPECT_EQ(obj.as<test_t>().front(), 42);
}
}
TEST(object_with_zone, forward_list)
{
for (unsigned int k = 0; k < kLoop; k++) {
forward_list<int> v1;
for (unsigned int i = 0; i < kElements; i++)
v1.push_front(i);
msgpack::zone z;
msgpack::object obj(v1, z);
EXPECT_EQ(obj.as<forward_list<int> >(), v1);
v1.front() = 42;
EXPECT_EQ(obj.as<forward_list<int> >().front(), kElements - 1);
}
}
TEST(object_with_zone, tuple)
{
typedef tuple<int, string, bool> test_t;
test_t v(1, "abc", true);
msgpack::zone z;
msgpack::object obj(v, z);
EXPECT_EQ(obj.as<test_t>(), v);
}
#endif

132
test/pack_unpack.cc
View File

@ -1,132 +0,0 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
#include <sstream>
TEST(pack, num)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
}
TEST(pack, vector)
{
msgpack::sbuffer sbuf;
std::vector<int> vec;
vec.push_back(1);
vec.push_back(2);
vec.push_back(3);
msgpack::pack(sbuf, vec);
}
TEST(pack, to_ostream)
{
std::ostringstream stream;
msgpack::pack(stream, 1);
}
struct myclass {
myclass() : num(0), str("default") { }
myclass(int num, const std::string& str) :
num(num), str(str) { }
~myclass() { }
int num;
std::string str;
MSGPACK_DEFINE(num, str);
};
TEST(pack, myclass)
{
msgpack::sbuffer sbuf;
myclass m(1, "msgpack");
msgpack::pack(sbuf, m);
}
TEST(unpack, int_no_offset)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked msg;
msgpack::unpack(msg, sbuf.data(), sbuf.size());
EXPECT_EQ(1, msg.get().as<int>());
}
TEST(unpack, int_offset)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked msg;
std::size_t off = 0;
msgpack::unpack(msg, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(1, msg.get().as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, int_pointer)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked msg;
std::size_t off = 0;
// obsolete
msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off);
EXPECT_EQ(1, msg.get().as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, int_null_pointer)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked msg;
// obsolete
msgpack::unpack(&msg, sbuf.data(), sbuf.size(), nullptr);
EXPECT_EQ(1, msg.get().as<int>());
}
TEST(unpack, int_default_null_pointer)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked msg;
// obsolete
msgpack::unpack(&msg, sbuf.data(), sbuf.size());
EXPECT_EQ(1, msg.get().as<int>());
}
TEST(unpack, sequence)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::pack(sbuf, 2);
msgpack::pack(sbuf, 3);
std::size_t off = 0;
msgpack::unpacked msg;
msgpack::unpack(msg, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(1, msg.get().as<int>());
msgpack::unpack(msg, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(2, msg.get().as<int>());
msgpack::unpack(msg, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(3, msg.get().as<int>());
EXPECT_EQ(off, sbuf.size());
}

70
test/pack_unpack_c.cc
View File

@ -1,70 +0,0 @@
#include <msgpack.h>
#include <gtest/gtest.h>
#include <stdio.h>
TEST(pack, num)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
EXPECT_EQ(0, msgpack_pack_int(pk, 1));
msgpack_sbuffer_free(sbuf);
msgpack_packer_free(pk);
}
TEST(pack, array)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
EXPECT_EQ(0, msgpack_pack_array(pk, 3));
EXPECT_EQ(0, msgpack_pack_int(pk, 1));
EXPECT_EQ(0, msgpack_pack_int(pk, 2));
EXPECT_EQ(0, msgpack_pack_int(pk, 3));
msgpack_sbuffer_free(sbuf);
msgpack_packer_free(pk);
}
TEST(unpack, sequence)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
EXPECT_EQ(0, msgpack_pack_int(pk, 1));
EXPECT_EQ(0, msgpack_pack_int(pk, 2));
EXPECT_EQ(0, msgpack_pack_int(pk, 3));
msgpack_packer_free(pk);
bool success;
size_t offset = 0;
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_TRUE(success);
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type);
EXPECT_EQ(1, msg.data.via.u64);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_TRUE(success);
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type);
EXPECT_EQ(2, msg.data.via.u64);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_TRUE(success);
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type);
EXPECT_EQ(3, msg.data.via.u64);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_FALSE(success);
msgpack_sbuffer_free(sbuf);
msgpack_unpacked_destroy(&msg);
}

434
test/reference.cc
View File

@ -1,434 +0,0 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
TEST(reference, unpack_int)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_FALSE(ret.referenced());
}
TEST(reference, unpack_string)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg"));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_FALSE(ret.referenced());
}
TEST(reference, unpack_bin)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_FALSE(ret.referenced());
}
TEST(reference, unpack_ext)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_FALSE(ret.referenced());
}
bool never_called(msgpack::type::object_type, std::size_t, void*)
{
EXPECT_TRUE(false);
return false;
}
bool always_reference(msgpack::type::object_type, std::size_t, void*)
{
return true;
}
TEST(reference, unpack_int_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called);
EXPECT_FALSE(ret.referenced());
}
TEST(reference, unpack_string_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg"));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
EXPECT_TRUE(ret.referenced());
}
TEST(reference, unpack_bin_ref)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
EXPECT_TRUE(ret.referenced());
}
TEST(reference, unpack_ext_ref)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
EXPECT_TRUE(ret.referenced());
}
static void* s_p;
bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p)
{
s_p = p;
switch (t) {
case msgpack::type::STR:
if (s >= 5) return true;
break;
case msgpack::type::BIN:
if (s >= 6) return true;
break;
case msgpack::type::EXT:
if (s >= 7) return true;
break;
default:
EXPECT_TRUE(false);
}
return false;
}
TEST(reference, unpack_int_sized_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked ret;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called, &sbuf);
EXPECT_FALSE(ret.referenced());
EXPECT_EQ(nullptr, s_p);
}
TEST(reference, unpack_string_sized_ref_4)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("1234"));
msgpack::unpacked ret;
s_p = nullptr;
// the last argument sbuf is any pointer as a user data.
// That is stored to s_p in sized_reference
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_FALSE(ret.referenced());
// compare the passed argument with stored s_p.
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_string_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("12345"));
msgpack::unpacked ret;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_TRUE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_bin_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_FALSE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_bin_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_TRUE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_ext_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5 };
packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_FALSE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_ext_sized_ref_7)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5, 6 };
packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_TRUE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
// default reference function
// STR, BIN, and EXT are always referenced, otherwise copied (converted).
TEST(reference, unpacker_int)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacker unp;
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
}
TEST(reference, unpacker_string)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("a"));
msgpack::unpacker unp;
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
}
TEST(reference, unpacker_bin)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacker unp;
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
}
TEST(reference, unpacker_ext)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacker unp;
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
}
// pass user custom reference function
TEST(reference, unpacker_int_sized_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacker unp(never_called, &sbuf);
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = nullptr;
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
EXPECT_EQ(nullptr, s_p);
}
TEST(reference, unpacker_string_sized_ref_4)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("1234"));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = nullptr;
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_string_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("12345"));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = nullptr;
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_bin_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = nullptr;
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_bin_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = nullptr;
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_ext_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5 };
packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = nullptr;
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_ext_sized_ref_7)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5, 6 };
packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = nullptr;
bool b = unp.next(ret);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
EXPECT_EQ(&sbuf, s_p);
}

316
test/streaming.cc
View File

@ -1,316 +0,0 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
#include <sstream>
TEST(streaming, basic)
{
msgpack::sbuffer buffer;
msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack(1);
pk.pack(2);
pk.pack(3);
const char* input = buffer.data();
const char* const eof = input + buffer.size();
msgpack::unpacker pac;
msgpack::unpacked result;
int count = 0;
while(count < 3) {
pac.reserve_buffer(32*1024);
// read buffer into pac.buffer() upto
// pac.buffer_capacity() bytes.
size_t len = 1;
memcpy(pac.buffer(), input, len);
input += len;
pac.buffer_consumed(len);
while(pac.next(result)) {
msgpack::object obj = result.get();
switch(count++) {
case 0:
EXPECT_EQ(1, obj.as<int>());
break;
case 1:
EXPECT_EQ(2, obj.as<int>());
break;
case 2:
EXPECT_EQ(3, obj.as<int>());
return;
}
}
EXPECT_TRUE(input < eof);
}
}
TEST(streaming, basic_pointer)
{
msgpack::sbuffer buffer;
msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack(1);
pk.pack(2);
pk.pack(3);
const char* input = buffer.data();
const char* const eof = input + buffer.size();
msgpack::unpacker pac;
msgpack::unpacked result;
int count = 0;
while(count < 3) {
pac.reserve_buffer(32*1024);
// read buffer into pac.buffer() upto
// pac.buffer_capacity() bytes.
size_t len = 1;
memcpy(pac.buffer(), input, len);
input += len;
pac.buffer_consumed(len);
while(pac.next(&result)) {
msgpack::object obj = result.get();
switch(count++) {
case 0:
EXPECT_EQ(1, obj.as<int>());
break;
case 1:
EXPECT_EQ(2, obj.as<int>());
break;
case 2:
EXPECT_EQ(3, obj.as<int>());
return;
}
}
EXPECT_TRUE(input < eof);
}
}
#if !defined(MSGPACK_USE_CPP03)
TEST(streaming, move)
{
msgpack::sbuffer buffer;
msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack(1);
pk.pack(2);
pk.pack(3);
const char* input = buffer.data();
const char* const eof = input + buffer.size();
msgpack::unpacker pac;
msgpack::unpacked result;
int count = 0;
while(count < 3) {
msgpack::unpacker pac_in(std::move(pac));
pac_in.reserve_buffer(32*1024);
// read buffer into pac_in.buffer() upto
// pac_in.buffer_capac_inity() bytes.
size_t len = 1;
memcpy(pac_in.buffer(), input, len);
input += len;
pac_in.buffer_consumed(len);
while(pac_in.next(result)) {
msgpack::object obj = result.get();
switch(count++) {
case 0:
EXPECT_EQ(1, obj.as<int>());
break;
case 1:
EXPECT_EQ(2, obj.as<int>());
break;
case 2:
EXPECT_EQ(3, obj.as<int>());
return;
}
}
EXPECT_TRUE(input < eof);
pac = std::move(pac_in);
}
}
#endif // !defined(MSGPACK_USE_CPP03)
class event_handler {
public:
event_handler(std::istream& input) : input(input) { }
~event_handler() { }
void on_read()
{
while(true) {
pac.reserve_buffer(32*1024);
size_t len = input.readsome(pac.buffer(), pac.buffer_capacity());
if(len == 0) {
return;
}
pac.buffer_consumed(len);
msgpack::unpacked result;
while(pac.next(result)) {
on_message(result.get(), msgpack::move(result.zone()));
}
if(pac.message_size() > 10*1024*1024) {
throw std::runtime_error("message is too large");
}
}
}
void on_message(msgpack::object obj, msgpack::unique_ptr<msgpack::zone> z)
{
EXPECT_EQ(expect, obj.as<int>());
}
int expect;
private:
std::istream& input;
msgpack::unpacker pac;
};
TEST(streaming, event)
{
std::stringstream stream;
msgpack::packer<std::ostream> pk(&stream);
event_handler handler(stream);
pk.pack(1);
handler.expect = 1;
handler.on_read();
pk.pack(2);
handler.expect = 2;
handler.on_read();
pk.pack(3);
handler.expect = 3;
handler.on_read();
}
// backward compatibility
TEST(streaming, basic_compat)
{
std::ostringstream stream;
msgpack::packer<std::ostream> pk(&stream);
pk.pack(1);
pk.pack(2);
pk.pack(3);
std::istringstream input(stream.str());
msgpack::unpacker pac;
int count = 0;
while(count < 3) {
pac.reserve_buffer(32*1024);
size_t len = input.readsome(pac.buffer(), pac.buffer_capacity());
pac.buffer_consumed(len);
while(pac.execute()) {
msgpack::unique_ptr<msgpack::zone> z(pac.release_zone());
msgpack::object obj = pac.data();
pac.reset();
switch(count++) {
case 0:
EXPECT_EQ(1, obj.as<int>());
break;
case 1:
EXPECT_EQ(2, obj.as<int>());
break;
case 2:
EXPECT_EQ(3, obj.as<int>());
return;
}
}
}
}
// backward compatibility
class event_handler_compat {
public:
event_handler_compat(std::istream& input) : input(input) { }
~event_handler_compat() { }
void on_read()
{
while(true) {
pac.reserve_buffer(32*1024);
size_t len = input.readsome(pac.buffer(), pac.buffer_capacity());
if(len == 0) {
return;
}
pac.buffer_consumed(len);
while(pac.execute()) {
msgpack::unique_ptr<msgpack::zone> z(pac.release_zone());
msgpack::object obj = pac.data();
pac.reset();
on_message(obj, msgpack::move(z));
}
if(pac.message_size() > 10*1024*1024) {
throw std::runtime_error("message is too large");
}
}
}
void on_message(msgpack::object obj, msgpack::unique_ptr<msgpack::zone> z)
{
EXPECT_EQ(expect, obj.as<int>());
}
int expect;
private:
std::istream& input;
msgpack::unpacker pac;
};
TEST(streaming, event_compat)
{
std::stringstream stream;
msgpack::packer<std::ostream> pk(&stream);
event_handler_compat handler(stream);
pk.pack(1);
handler.expect = 1;
handler.on_read();
pk.pack(2);
handler.expect = 2;
handler.on_read();
pk.pack(3);
handler.expect = 3;
handler.on_read();
}

114
test/streaming_c.cc
View File

@ -1,114 +0,0 @@
#include <msgpack.h>
#include <gtest/gtest.h>
#include <stdio.h>
TEST(streaming, basic)
{
msgpack_sbuffer* buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
// 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4}
EXPECT_EQ(0, msgpack_pack_int(pk, 1));
EXPECT_EQ(0, msgpack_pack_int(pk, 2));
EXPECT_EQ(0, msgpack_pack_int(pk, 3));
EXPECT_EQ(0, msgpack_pack_str(pk, 3));
EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3));
EXPECT_EQ(0, msgpack_pack_array(pk, 1));
EXPECT_EQ(0, msgpack_pack_str(pk, 8));
EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8));
EXPECT_EQ(0, msgpack_pack_bin(pk, 3));
EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3));
EXPECT_EQ(0, msgpack_pack_array(pk, 1));
EXPECT_EQ(0, msgpack_pack_bin(pk, 8));
EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8));
EXPECT_EQ(0, msgpack_pack_map(pk, 1));
EXPECT_EQ(0, msgpack_pack_float(pk, 0.4));
EXPECT_EQ(0, msgpack_pack_double(pk, 0.8));
int max_count = 6;
msgpack_packer_free(pk);
const char* input = buffer->data;
const char* const eof = input + buffer->size;
msgpack_unpacker pac;
msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE);
msgpack_unpacked result;
msgpack_unpacked_init(&result);
int count = 0;
while(count < max_count) {
bool unpacked = false;
msgpack_unpacker_reserve_buffer(&pac, 32*1024);
while(!unpacked) {
/* read buffer into msgpack_unapcker_buffer(&pac) upto
* msgpack_unpacker_buffer_capacity(&pac) bytes. */
memcpy(msgpack_unpacker_buffer(&pac), input, 1);
input += 1;
EXPECT_TRUE(input <= eof);
msgpack_unpacker_buffer_consumed(&pac, 1);
while(msgpack_unpacker_next(&pac, &result) == MSGPACK_UNPACK_SUCCESS) {
unpacked = 1;
msgpack_object obj = result.data;
msgpack_object e;
switch(count++) {
case 0:
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type);
EXPECT_EQ(1, obj.via.u64);
break;
case 1:
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type);
EXPECT_EQ(2, obj.via.u64);
break;
case 2:
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type);
EXPECT_EQ(3, obj.via.u64);
break;
case 3:
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size));
break;
case 4:
EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
EXPECT_EQ(1, obj.via.array.size);
e = obj.via.array.ptr[0];
EXPECT_EQ(MSGPACK_OBJECT_STR, e.type);
EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size));
break;
case 5:
EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type);
EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size));
break;
case 6:
EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
EXPECT_EQ(1, obj.via.array.size);
e = obj.via.array.ptr[0];
EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type);
EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size));
break;
case 7:
EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type);
EXPECT_EQ(1, obj.via.map.size);
e = obj.via.map.ptr[0].key;
EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type);
ASSERT_FLOAT_EQ(0.4, (float)e.via.dec);
e = obj.via.map.ptr[0].val;
EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type);
ASSERT_DOUBLE_EQ(0.8, e.via.dec);
break;
}
}
}
}
msgpack_unpacker_destroy(&pac);
msgpack_unpacked_destroy(&result);
}

13
test/version.cc
View File

@ -1,13 +0,0 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
TEST(version, print)
{
printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION);
printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR);
printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR);
printf("msgpack_version() : %s\n", msgpack_version());
printf("msgpack_version_major() : %d\n", msgpack_version_major());
printf("msgpack_version_minor() : %d\n", msgpack_version_minor());
}

78
test/zone.cc
View File

@ -1,78 +0,0 @@
#include <msgpack.hpp>
#include <gtest/gtest.h>
TEST(zone, allocate_align)
{
msgpack::zone z;
char* buf1 = (char*)z.allocate_align(4);
memcpy(buf1, "test", 4);
char* buf2 = (char*)z.allocate_align(4);
memcpy(buf2, "test", 4);
}
class myclass {
public:
myclass() : num(0), str("default") { }
myclass(int num, const std::string& str) :
num(num), str(str) { }
~myclass() { }
int num;
std::string str;
private:
myclass(const myclass&);
};
TEST(zone, allocate)
{
msgpack::zone z;
myclass* m = z.allocate<myclass>();
EXPECT_EQ(m->num, 0);
EXPECT_EQ(m->str, "default");
}
TEST(zone, allocate_constructor)
{
msgpack::zone z;
myclass* m = z.allocate<myclass>(7, "msgpack");
EXPECT_EQ(m->num, 7);
EXPECT_EQ(m->str, "msgpack");
}
static void custom_finalizer_func(void* user)
{
myclass* m = (myclass*)user;
delete m;
}
TEST(zone, push_finalizer)
{
msgpack::zone z;
myclass* m = new myclass();
z.push_finalizer(custom_finalizer_func, (void*)m);
}
TEST(zone, push_finalizer_unique_ptr)
{
msgpack::zone z;
msgpack::unique_ptr<myclass> am(new myclass());
z.push_finalizer(msgpack::move(am));
}
TEST(zone, allocate_no_align)
{
msgpack::zone z;
char* buf1 = (char*)z.allocate_no_align(4);
char* buf2 = (char*)z.allocate_no_align(4);
EXPECT_EQ(buf1+4, buf2);
}