generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-10-16 18:56:54 +02:00
Code Issues Projects Releases Wiki Activity

Added EXT support.

Browse Source 
Removed obsolete unpack functions.
Updated examples that no longer use obsolete functions.
Added reference checking function to unpacked. ( unpacked::referenced() )
Added std:: namespace.
Added reference or copy choice function and default behavior:
  When you use unpacker, default behavior is:
    STR, BIN, EXT types are always held by reference.
  When you don't use unpacker, default behavior is:
    STR, BIN, EXT types are always held by copy.
    The memory is allocated from zone.
  You can customize the behavior passing your custom judging function to unpack() or unpacker's constructor.
This commit is contained in:
Takatoshi Kondo
2014-08-06 16:18:37 +09:00
parent ce21ab0ebf
commit 1f5d6b9cac
12 changed files with 519 additions and 400 deletions
Download Patch File Download Diff File Expand all files Collapse all files

177
test/msgpack_test.cpp
View File

@@ -274,6 +274,170 @@ TEST(MSGPACK, simple_buffer_false)
EXPECT_EQ(val1, val2);
}
TEST(MSGPACK, simple_buffer_fixext1)
{
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_EQ(1, ret.get().via.ext.size);
EXPECT_EQ(1, ret.get().via.ext.type());
EXPECT_EQ(2, ret.get().via.ext.data()[0]);
}
TEST(MSGPACK, simple_buffer_fixext2)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2, 3 };
packer.pack_ext(sizeof(buf), 0);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(2, ret.get().via.ext.size);
EXPECT_EQ(0, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}
TEST(MSGPACK, simple_buffer_fixext4)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2, 3, 4, 5 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(4, ret.get().via.ext.size);
EXPECT_EQ(1, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}
TEST(MSGPACK, simple_buffer_fixext8)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(8, ret.get().via.ext.size);
EXPECT_EQ(1, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}
TEST(MSGPACK, simple_buffer_fixext16)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(16, ret.get().via.ext.size);
EXPECT_EQ(1, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}
TEST(MSGPACK, simple_buffer_fixext_1byte_0)
{
std::size_t const size = 0;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
packer.pack_ext(size, 77);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type());
}
TEST(MSGPACK, simple_buffer_fixext_1byte_255)
{
std::size_t const size = 255;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (int i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}
TEST(MSGPACK, simple_buffer_fixext_2byte_256)
{
std::size_t const size = 256;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (int i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}
TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
{
std::size_t const size = 65535;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (int i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}
TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
{
std::size_t const size = 65536;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (int i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
EXPECT_EQ(size, ret.get().via.ext.size);
EXPECT_EQ(77, ret.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}
//-----------------------------------------------------------------------------
// STL
@@ -707,16 +871,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
TestClass val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::zone z;
msgpack::object obj;
msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
TestClass2 val2;
val2.i = -1;
val2.s = "";
val2.v = vector<int>();
obj.convert(&val2);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
TestClass2 val2 = ret.get().as<TestClass2>();
EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(val2.s.empty());

185
test/pack_unpack.cc
View File

@@ -49,88 +49,6 @@ TEST(pack, myclass)
msgpack::pack(sbuf, m);
}
TEST(unpack, myclass_no_offset)
{
msgpack::sbuffer sbuf;
myclass m1(1, "phraser");
msgpack::pack(sbuf, m1);
msgpack::zone z;
msgpack::object obj;
// obsolete
msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
myclass m2 = obj.as<myclass>();
EXPECT_EQ(m1.num, m2.num);
EXPECT_EQ(m1.str, m2.str);
}
TEST(unpack, myclass_offset)
{
msgpack::sbuffer sbuf;
myclass m1(1, "phraser");
msgpack::pack(sbuf, m1);
msgpack::zone z;
msgpack::object obj;
std::size_t off = 0;
// obsolete
msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
myclass m2 = obj.as<myclass>();
EXPECT_EQ(m1.num, m2.num);
EXPECT_EQ(m1.str, m2.str);
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, myclass_offset_pointer)
{
msgpack::sbuffer sbuf;
myclass m1(1, "phraser");
msgpack::pack(sbuf, m1);
msgpack::zone z;
msgpack::object obj;
std::size_t off = 0;
// obsolete
msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), &off, &z, &obj);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
myclass m2 = obj.as<myclass>();
EXPECT_EQ(m1.num, m2.num);
EXPECT_EQ(m1.str, m2.str);
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, myclass_offset_null_pointer)
{
msgpack::sbuffer sbuf;
myclass m1(1, "phraser");
msgpack::pack(sbuf, m1);
msgpack::zone z;
msgpack::object obj;
// obsolete
msgpack::unpack_return ret =
msgpack::unpack(sbuf.data(), sbuf.size(), nullptr, &z, &obj);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
myclass m2 = obj.as<myclass>();
EXPECT_EQ(m1.num, m2.num);
EXPECT_EQ(m1.str, m2.str);
}
TEST(unpack, int_no_offset)
{
msgpack::sbuffer sbuf;
@@ -212,106 +130,3 @@ TEST(unpack, sequence)
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack_return, int_no_offset)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::zone z;
msgpack::object obj;
msgpack::unpack_return ret;
// obsolete
ret = msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
EXPECT_EQ(1, obj.as<int>());
}
TEST(unpack_return, int_offset)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
std::size_t off = 0;
msgpack::zone z;
msgpack::object obj;
msgpack::unpack_return ret;
// obsolete
ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
EXPECT_EQ(1, obj.as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack_return, int_pointer)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
std::size_t off = 0;
msgpack::zone z;
msgpack::object obj;
msgpack::unpack_return ret;
// obsolete
ret = msgpack::unpack(sbuf.data(), sbuf.size(), &off, &z, &obj);
EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
EXPECT_EQ(1, obj.as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack_return, int_null_pointer)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::zone z;
msgpack::object obj;
msgpack::unpack_return ret;
// obsolete
ret = msgpack::unpack(sbuf.data(), sbuf.size(), nullptr, &z, &obj);
EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
EXPECT_EQ(1, obj.as<int>());
}
TEST(unpack, sequence_compat)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::pack(sbuf, 2);
msgpack::pack(sbuf, 3);
std::size_t off = 0;
msgpack::zone z;
msgpack::object obj;
msgpack::unpack_return ret;
// obsolete
ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
EXPECT_EQ(1, obj.as<int>());
// obsolete
ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
EXPECT_EQ(2, obj.as<int>());
// obsolete
ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
EXPECT_TRUE(ret >= 0);
EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
EXPECT_EQ(3, obj.as<int>());
}