generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-11-03 19:40:38 +01:00
Code Issues Projects Releases Wiki Activity

Removed referenced member from msgpack::unpacked.

Browse Source 
Added a referenced parameter to msgpack::unpack() and msgpack::unpacker::next().

msgpack::unpacked is a kind of handler that holds msgpack::object and msgpack::zone, so the size of msgpack::unpacked should be small. There is no reason to have referenced in msgpack::unpacked. msgpack user can get the same information using msgpack::unpack() and msgpack::unpacker::next().
This commit is contained in:
Takatoshi Kondo
2014-08-11 15:50:51 +09:00
parent f969f6f39c
commit 4d6e9d6c05
4 changed files with 125 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
test/msgpack_test.cpp
View File

@@ -38,7 +38,6 @@ const double kEPS = 1e-10;
msgpack::unpacked ret; \
msgpack::unpack(ret, sbuf.data(), sbuf.size()); \
EXPECT_EQ(val1, ret.get().as<test_type>()); \
EXPECT_FALSE(ret.referenced()); \
} \
} while(0)
@@ -206,7 +205,6 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
msgpack::unpack(ret, sbuf.data(), sbuf.size());
float_type val2 = ret.get().as<float_type>();
EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
EXPECT_FALSE(ret.referenced());
}
}
@@ -244,7 +242,6 @@ TEST(MSGPACK, simple_buffer_double)
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
double val2 = ret.get().as<double>();
EXPECT_FALSE(ret.referenced());
if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2));
@@ -264,7 +261,6 @@ TEST(MSGPACK, simple_buffer_true)
msgpack::unpack(ret, sbuf.data(), sbuf.size());
bool val2 = ret.get().as<bool>();
EXPECT_EQ(val1, val2);
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_false)
@@ -276,7 +272,6 @@ TEST(MSGPACK, simple_buffer_false)
msgpack::unpack(ret, sbuf.data(), sbuf.size());
bool val2 = ret.get().as<bool>();
EXPECT_EQ(val1, val2);
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext1)
@@ -292,7 +287,6 @@ TEST(MSGPACK, simple_buffer_fixext1)
EXPECT_EQ(1, ret.get().via.ext.size);
EXPECT_EQ(1, ret.get().via.ext.type());
EXPECT_EQ(2, ret.get().via.ext.data()[0]);
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext2)
@@ -309,7 +303,6 @@ TEST(MSGPACK, simple_buffer_fixext2)
EXPECT_EQ(0, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext4)
@@ -326,7 +319,6 @@ TEST(MSGPACK, simple_buffer_fixext4)
EXPECT_EQ(1, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext8)
@@ -343,7 +335,6 @@ TEST(MSGPACK, simple_buffer_fixext8)
EXPECT_EQ(1, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext16)
@@ -360,7 +351,6 @@ TEST(MSGPACK, simple_buffer_fixext16)
EXPECT_EQ(1, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext_1byte_0)
@@ -374,7 +364,6 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_0)
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type());
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext_1byte_255)
@@ -393,7 +382,6 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_255)
EXPECT_EQ(77, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext_2byte_256)
@@ -412,7 +400,6 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_256)
EXPECT_EQ(77, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
@@ -431,7 +418,6 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
EXPECT_EQ(77, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
@@ -450,7 +436,6 @@ TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
EXPECT_EQ(77, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
EXPECT_FALSE(ret.referenced());
}
//-----------------------------------------------------------------------------
@@ -471,7 +456,6 @@ TEST(MSGPACK_STL, simple_buffer_string)
string val2 = ret.get().as<string>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(val1, val2);
EXPECT_FALSE(ret.referenced());
}
}
@@ -489,7 +473,6 @@ TEST(MSGPACK_STL, simple_buffer_vector)
vector<int> val2 = ret.get().as<vector<int> >();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
EXPECT_FALSE(ret.referenced());
}
}
@@ -523,7 +506,6 @@ TEST(MSGPACK_STL, simple_buffer_map)
map<int, int> val2 = ret.get().as<map<int, int> >();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
EXPECT_FALSE(ret.referenced());
}
}
@@ -540,7 +522,6 @@ TEST(MSGPACK_STL, simple_buffer_deque)
deque<int> val2 = ret.get().as<deque<int> >();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
EXPECT_FALSE(ret.referenced());
}
}
@@ -557,7 +538,6 @@ TEST(MSGPACK_STL, simple_buffer_list)
list<int> val2 = ret.get().as<list<int> >();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
EXPECT_FALSE(ret.referenced());
}
}
@@ -574,7 +554,6 @@ TEST(MSGPACK_STL, simple_buffer_set)
set<int> val2 = ret.get().as<set<int> >();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
EXPECT_FALSE(ret.referenced());
}
}
@@ -589,7 +568,6 @@ TEST(MSGPACK_STL, simple_buffer_pair)
pair<int, int> val2 = ret.get().as<pair<int, int> >();
EXPECT_EQ(val1.first, val2.first);
EXPECT_EQ(val1.second, val2.second);
EXPECT_FALSE(ret.referenced());
}
}
@@ -619,7 +597,6 @@ TEST(MSGPACK_STL, simple_buffer_multimap)
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
EXPECT_FALSE(ret.referenced());
}
}
@@ -646,7 +623,6 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
EXPECT_FALSE(ret.referenced());
}
}
@@ -672,7 +648,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
EXPECT_TRUE(val2.find(it->first) != val2.end());
EXPECT_EQ(it->second, val2.find(it->first)->second);
}
EXPECT_FALSE(ret.referenced());
}
}
@@ -702,7 +677,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
EXPECT_FALSE(ret.referenced());
}
}
#endif
@@ -725,7 +699,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
tr1::unordered_set<int>::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it)
EXPECT_TRUE(val2.find(*it) != val2.end());
EXPECT_FALSE(ret.referenced());
}
}
@@ -752,7 +725,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
EXPECT_FALSE(ret.referenced());
}
}
#endif
@@ -777,7 +749,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map)
EXPECT_TRUE(val2.find(it->first) != val2.end());
EXPECT_EQ(it->second, val2.find(it->first)->second);
}
EXPECT_FALSE(ret.referenced());
}
}
@@ -807,7 +778,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
EXPECT_FALSE(ret.referenced());
}
}
#endif
@@ -830,7 +800,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set)
unordered_set<int>::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it)
EXPECT_TRUE(val2.find(*it) != val2.end());
EXPECT_FALSE(ret.referenced());
}
}
@@ -857,7 +826,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
EXPECT_FALSE(ret.referenced());
}
}
#endif
@@ -885,7 +853,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
TestClass val2 = ret.get().as<TestClass>();
EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(ret.referenced());
}
}
@@ -914,7 +881,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(val2.s.empty());
EXPECT_FALSE(ret.referenced());
}
}
@@ -965,7 +931,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
EXPECT_EQ(val1.t1, val2.t1);
EXPECT_EQ(val1.t2, val2.t2);
EXPECT_EQ(val1.t3, val2.t3);
EXPECT_FALSE(ret.referenced());
}
class TestUnionMemberClass
@@ -1021,7 +986,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
TestUnionMemberClass val2 = ret.get().as<TestUnionMemberClass>();
EXPECT_EQ(val1.is_double, val2.is_double);
EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
EXPECT_FALSE(ret.referenced());
}
{
// int
@@ -1034,7 +998,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
EXPECT_EQ(val1.is_double, val2.is_double);
EXPECT_EQ(val1.value.i, 1);
EXPECT_EQ(val1.value.i, val2.value.i);
EXPECT_FALSE(ret.referenced());
}
}
@@ -1056,7 +1019,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
msgpack::unpack(ret, sbuf.data(), sbuf.size()); \
test_type val2 = ret.get().as<test_type>(); \
EXPECT_EQ(val1, val2); \
EXPECT_FALSE(ret.referenced()); \
} \
} while(0);

4
test/msgpack_test_cpp11.cpp
View File

@@ -25,7 +25,6 @@ TEST(MSGPACK_CPP11, simple_tuple)
msgpack::unpack(ret, sbuf.data(), sbuf.size());
std::tuple<bool, std::string, double> val2 = ret.get().as<std::tuple<bool, std::string, double> >();
EXPECT_EQ(val1, val2);
EXPECT_FALSE(ret.referenced());
}
TEST(MSGPACK_CPP11, simple_array)
@@ -42,7 +41,6 @@ TEST(MSGPACK_CPP11, simple_array)
array<int, kElements> val2 = ret.get().as<array<int, kElements> >();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
EXPECT_FALSE(ret.referenced());
}
}
@@ -75,7 +73,6 @@ TEST(MSGPACK_STL, simple_buffer_forward_list)
msgpack::unpack(ret, sbuf.data(), sbuf.size());
forward_list<int> val2 = ret.get().as<forward_list<int> >();
EXPECT_EQ(val1, val2);
EXPECT_FALSE(ret.referenced());
}
}
@@ -112,7 +109,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member)
EXPECT_EQ(val1.t1, val2.t1);
EXPECT_EQ(val1.t2, val2.t2);
EXPECT_EQ(val1.t3, val2.t3);
EXPECT_FALSE(ret.referenced());
}
#endif // !defined(MSGPACK_USE_CPP03)

131
test/reference.cpp
View File

@@ -6,9 +6,10 @@ TEST(reference, unpack_int)
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked ret;
bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_FALSE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_string)
@@ -16,9 +17,10 @@ TEST(reference, unpack_string)
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg"));
msgpack::unpacked ret;
bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_FALSE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_bin)
@@ -30,8 +32,9 @@ TEST(reference, unpack_bin)
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_FALSE(ret.referenced());
bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_ext)
@@ -43,8 +46,9 @@ TEST(reference, unpack_ext)
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 referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
bool never_called(msgpack::type::object_type, std::size_t, void*)
@@ -63,9 +67,10 @@ TEST(reference, unpack_int_ref)
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked ret;
bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called);
EXPECT_FALSE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_string_ref)
@@ -73,9 +78,11 @@ TEST(reference, unpack_string_ref)
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg"));
msgpack::unpacked ret;
bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
EXPECT_TRUE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced);
}
TEST(reference, unpack_bin_ref)
@@ -87,8 +94,9 @@ TEST(reference, unpack_bin_ref)
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
EXPECT_TRUE(ret.referenced());
bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced);
}
TEST(reference, unpack_ext_ref)
@@ -100,8 +108,9 @@ TEST(reference, unpack_ext_ref)
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());
bool referenced;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced);
}
static void* s_p;
@@ -131,9 +140,10 @@ TEST(reference, unpack_int_sized_ref)
msgpack::pack(sbuf, 1);
msgpack::unpacked ret;
bool referenced;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called, &sbuf);
EXPECT_FALSE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called, &sbuf);
EXPECT_FALSE(referenced);
EXPECT_EQ(nullptr, s_p);
}
@@ -143,11 +153,12 @@ TEST(reference, unpack_string_sized_ref_4)
msgpack::pack(sbuf, std::string("1234"));
msgpack::unpacked ret;
bool referenced;
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());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced);
// compare the passed argument with stored s_p.
EXPECT_EQ(&sbuf, s_p);
}
@@ -158,9 +169,10 @@ TEST(reference, unpack_string_sized_ref_5)
msgpack::pack(sbuf, std::string("12345"));
msgpack::unpacked ret;
bool referenced;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_TRUE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -174,9 +186,10 @@ TEST(reference, unpack_bin_sized_ref_5)
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
bool referenced;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_FALSE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -189,9 +202,10 @@ TEST(reference, unpack_bin_sized_ref_6)
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacked ret;
bool referenced;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_TRUE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -205,9 +219,10 @@ TEST(reference, unpack_ext_sized_ref_6)
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
bool referenced;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_FALSE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -221,9 +236,10 @@ TEST(reference, unpack_ext_sized_ref_7)
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
bool referenced;
s_p = nullptr;
msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
EXPECT_TRUE(ret.referenced());
msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -237,12 +253,13 @@ TEST(reference, unpacker_int)
msgpack::unpacker unp;
msgpack::unpacked ret;
bool referenced;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
EXPECT_FALSE(referenced);
}
TEST(reference, unpacker_string)
@@ -252,12 +269,13 @@ TEST(reference, unpacker_string)
msgpack::unpacker unp;
msgpack::unpacked ret;
bool referenced;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
EXPECT_TRUE(referenced);
}
TEST(reference, unpacker_bin)
@@ -270,12 +288,13 @@ TEST(reference, unpacker_bin)
msgpack::unpacker unp;
msgpack::unpacked ret;
bool referenced;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
EXPECT_TRUE(referenced);
}
TEST(reference, unpacker_ext)
@@ -289,12 +308,13 @@ TEST(reference, unpacker_ext)
msgpack::unpacker unp;
msgpack::unpacked ret;
bool referenced;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(ret);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
EXPECT_TRUE(referenced);
}
// pass user custom reference function
@@ -306,13 +326,14 @@ TEST(reference, unpacker_int_sized_ref)
msgpack::unpacker unp(never_called, &sbuf);
msgpack::unpacked ret;
bool referenced;
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);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
EXPECT_FALSE(referenced);
EXPECT_EQ(nullptr, s_p);
}
@@ -323,13 +344,14 @@ TEST(reference, unpacker_string_sized_ref_4)
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
bool referenced;
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);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -340,13 +362,14 @@ TEST(reference, unpacker_string_sized_ref_5)
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
bool referenced;
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);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -361,13 +384,14 @@ TEST(reference, unpacker_bin_sized_ref_5)
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
bool referenced;
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);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -381,13 +405,14 @@ TEST(reference, unpacker_bin_sized_ref_6)
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
bool referenced;
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);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -402,13 +427,14 @@ TEST(reference, unpacker_ext_sized_ref_6)
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
bool referenced;
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);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(ret.referenced());
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
@@ -423,12 +449,13 @@ TEST(reference, unpacker_ext_sized_ref_7)
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::unpacked ret;
bool referenced;
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);
bool b = unp.next(ret, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(ret.referenced());
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}