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

Added map-based class pack/convert support.

Browse Source
This commit is contained in:
Takatoshi Kondo
2015-07-03 11:44:07 +09:00
parent e0a2c2a4bf
commit 777e5f13f3
14 changed files with 3858 additions and 483 deletions
Download Patch File Download Diff File Expand all files Collapse all files

251
test/msgpack_container.cpp
View File

@@ -16,33 +16,10 @@
#endif
class TestEnumMemberClass
{
public:
TestEnumMemberClass()
: t1(STATE_A), t2(STATE_B), t3(STATE_C) {}
enum TestEnumType {
STATE_INVALID = 0,
STATE_A = 1,
STATE_B = 2,
STATE_C = 3
};
TestEnumType t1;
TestEnumType t2;
TestEnumType t3;
MSGPACK_DEFINE(t1, t2, t3);
};
MSGPACK_ADD_ENUM(TestEnumMemberClass::TestEnumType);
using namespace std;
const unsigned int kLoop = 1000;
const unsigned int kElements = 100;
const double kEPS = 1e-10;
TEST(MSGPACK_STL, simple_buffer_vector)
{
@@ -457,231 +434,3 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
}
}
#endif
// User-Defined Structures
class TestClass
{
public:
TestClass() : i(0), s("kzk") {}
int i;
string s;
MSGPACK_DEFINE(i, s);
};
TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
{
for (unsigned int k = 0; k < kLoop; k++) {
TestClass val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
TestClass val2 = ret.get().as<TestClass>();
EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s);
}
}
class TestClass2
{
public:
TestClass2() : i(0), s("kzk") {
for (unsigned int i = 0; i < kElements; i++)
v.push_back(rand());
}
int i;
string s;
vector<int> v;
MSGPACK_DEFINE(i, s, v);
};
TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
{
for (unsigned int k = 0; k < kLoop; k++) {
TestClass val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
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());
}
}
TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
{
for (unsigned int k = 0; k < kLoop; k++) {
TestClass2 val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
TestClass val2 = ret.get().as<TestClass>();
EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(val2.s.empty());
}
}
TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
{
TestEnumMemberClass val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
TestEnumMemberClass val2 = ret.get().as<TestEnumMemberClass>();
EXPECT_EQ(val1.t1, val2.t1);
EXPECT_EQ(val1.t2, val2.t2);
EXPECT_EQ(val1.t3, val2.t3);
}
class TestUnionMemberClass
{
public:
TestUnionMemberClass() {}
TestUnionMemberClass(double f) {
is_double = true;
value.f = f;
}
TestUnionMemberClass(int i) {
is_double = false;
value.i = i;
}
union {
double f;
int i;
} value;
bool is_double;
template <typename Packer>
void msgpack_pack(Packer& pk) const
{
if (is_double)
pk.pack(msgpack::type::tuple<bool, double>(true, value.f));
else
pk.pack(msgpack::type::tuple<bool, int>(false, value.i));
}
void msgpack_unpack(msgpack::object o)
{
msgpack::type::tuple<bool, msgpack::object> tuple;
o.convert(&tuple);
is_double = tuple.get<0>();
if (is_double)
tuple.get<1>().convert(&value.f);
else
tuple.get<1>().convert(&value.i);
}
};
TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
{
{
// double
TestUnionMemberClass val1(1.0);
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
TestUnionMemberClass val2 = ret.get().as<TestUnionMemberClass>();
EXPECT_EQ(val1.is_double, val2.is_double);
EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
}
{
// int
TestUnionMemberClass val1(1);
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
TestUnionMemberClass val2 = ret.get().as<TestUnionMemberClass>();
EXPECT_EQ(val1.is_double, val2.is_double);
EXPECT_EQ(val1.value.i, 1);
EXPECT_EQ(val1.value.i, val2.value.i);
}
}
struct top {
int t;
MSGPACK_DEFINE(t);
};
struct mid1 : top {
int m1;
MSGPACK_DEFINE(MSGPACK_BASE(top), m1);
};
struct mid2 : top {
int m2;
MSGPACK_DEFINE(m2, MSGPACK_BASE(top));
};
struct bottom : mid1, mid2 {
int b;
MSGPACK_DEFINE(MSGPACK_BASE(mid1), MSGPACK_BASE(mid2), b);
};
TEST(MSGPACK_INHERIT, simple_buffer_non_virtual)
{
bottom b;
b.b = 1;
b.m1 = 2;
b.m2 = 3;
b.mid1::t = 4;
b.mid2::t = 5;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
bottom br = ret.get().as<bottom>();
EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.mid1::t, br.mid1::t);
EXPECT_EQ(b.mid2::t, br.mid2::t);
}
struct v_top {
int t;
MSGPACK_DEFINE(t);
};
struct v_mid1 : virtual v_top {
int m1;
MSGPACK_DEFINE(m1);
};
struct v_mid2 : virtual v_top {
int m2;
MSGPACK_DEFINE(m2);
};
struct v_bottom : v_mid1, v_mid2 {
int b;
MSGPACK_DEFINE(MSGPACK_BASE(v_mid1), MSGPACK_BASE(v_mid2), MSGPACK_BASE(v_top), b);
};
TEST(MSGPACK_INHERIT, simple_buffer_virtual)
{
v_bottom b;
b.b = 1;
b.m1 = 2;
b.m2 = 3;
b.t = 4;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b);
msgpack::unpacked ret;
msgpack::unpack(ret, sbuf.data(), sbuf.size());
v_bottom br = ret.get().as<v_bottom>();
EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.t, br.t);
}