mirror of
https://github.com/msgpack/msgpack-c.git
synced 2025-05-02 07:31:38 +02:00
Unified test files extension as cpp.
This commit is contained in:
Takatoshi Kondo
parent
e18102d16f
commit
8920c49597
@ -8,23 +8,23 @@ INCLUDE_DIRECTORIES (
|
||||
)
|
||||
|
||||
SET (check_PROGRAMS
|
||||
zone.cc
|
||||
pack_unpack.cc
|
||||
pack_unpack_c.cc
|
||||
streaming.cc
|
||||
streaming_c.cc
|
||||
object.cc
|
||||
version.cc
|
||||
convert.cc
|
||||
buffer.cc
|
||||
cases.cc
|
||||
fixint.cc
|
||||
fixint_c.cc
|
||||
msgpack_tuple.cc
|
||||
zone.cpp
|
||||
pack_unpack.cpp
|
||||
pack_unpack_c.cpp
|
||||
streaming.cpp
|
||||
streaming_c.cpp
|
||||
object.cpp
|
||||
version.cpp
|
||||
convert.cpp
|
||||
buffer.cpp
|
||||
cases.cpp
|
||||
fixint.cpp
|
||||
fixint_c.cpp
|
||||
msgpack_tuple.cpp
|
||||
msgpack_test.cpp
|
||||
msgpackc_test.cpp
|
||||
msgpack_test_cpp11.cpp
|
||||
reference.cc
|
||||
reference.cpp
|
||||
)
|
||||
|
||||
FOREACH (source_file ${check_PROGRAMS})
|
||||
|
||||
@ -23,32 +23,32 @@ check_PROGRAMS = \
|
||||
|
||||
TESTS = $(check_PROGRAMS)
|
||||
|
||||
zone_SOURCES = zone.cc
|
||||
zone_SOURCES = zone.cpp
|
||||
|
||||
pack_unpack_SOURCES = pack_unpack.cc
|
||||
pack_unpack_SOURCES = pack_unpack.cpp
|
||||
|
||||
pack_unpack_c_SOURCES = pack_unpack_c.cc
|
||||
pack_unpack_c_SOURCES = pack_unpack_c.cpp
|
||||
|
||||
streaming_SOURCES = streaming.cc
|
||||
streaming_SOURCES = streaming.cpp
|
||||
|
||||
streaming_c_SOURCES = streaming_c.cc
|
||||
streaming_c_SOURCES = streaming_c.cpp
|
||||
|
||||
object_SOURCES = object.cc
|
||||
object_SOURCES = object.cpp
|
||||
|
||||
convert_SOURCES = convert.cc
|
||||
convert_SOURCES = convert.cpp
|
||||
|
||||
buffer_SOURCES = buffer.cc
|
||||
buffer_SOURCES = buffer.cpp
|
||||
buffer_LDADD = -lz
|
||||
|
||||
cases_SOURCES = cases.cc
|
||||
cases_SOURCES = cases.cpp
|
||||
|
||||
fixint_SOURCES = fixint.cc
|
||||
fixint_SOURCES = fixint.cpp
|
||||
|
||||
fixint_c_SOURCES = fixint_c.cc
|
||||
fixint_c_SOURCES = fixint_c.cpp
|
||||
|
||||
version_SOURCES = version.cc
|
||||
version_SOURCES = version.cpp
|
||||
|
||||
msgpack_tuple_SOURCES = msgpack_tuple.cc
|
||||
msgpack_tuple_SOURCES = msgpack_tuple.cpp
|
||||
|
||||
msgpackc_test_SOURCES = msgpackc_test.cpp
|
||||
|
||||
@ -56,6 +56,6 @@ msgpack_test_SOURCES = msgpack_test.cpp
|
||||
|
||||
msgpack_test_cpp11_SOURCES = msgpack_test_cpp11.cpp
|
||||
|
||||
reference_SOURCES = reference.cc
|
||||
reference_SOURCES = reference.cpp
|
||||
|
||||
EXTRA_DIST = cases.mpac cases_compact.mpac
|
||||
|
||||
119
test/buffer.cpp
Normal file
119
test/buffer.cpp
Normal file
@ -0,0 +1,119 @@
|
||||
#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.cpp
Normal file
38
test/cases.cpp
Normal file
@ -0,0 +1,38 @@
|
||||
#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.cpp
Normal file
76
test/convert.cpp
Normal file
@ -0,0 +1,76 @@
|
||||
#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.cpp
Normal file
55
test/fixint.cpp
Normal file
@ -0,0 +1,55 @@
|
||||
#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.cpp
Normal file
32
test/fixint_c.cpp
Normal file
@ -0,0 +1,32 @@
|
||||
#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.cpp
Normal file
103
test/msgpack_tuple.cpp
Normal file
@ -0,0 +1,103 @@
|
||||
#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.cpp
Normal file
125
test/object.cpp
Normal file
@ -0,0 +1,125 @@
|
||||
#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);
|
||||
}
|
||||
132
test/pack_unpack.cpp
Normal file
132
test/pack_unpack.cpp
Normal file
@ -0,0 +1,132 @@
|
||||
#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.cpp
Normal file
70
test/pack_unpack_c.cpp
Normal file
@ -0,0 +1,70 @@
|
||||
#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.cpp
Normal file
434
test/reference.cpp
Normal file
@ -0,0 +1,434 @@
|
||||
#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.cpp
Normal file
316
test/streaming.cpp
Normal file
@ -0,0 +1,316 @@
|
||||
#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.cpp
Normal file
114
test/streaming_c.cpp
Normal file
@ -0,0 +1,114 @@
|
||||
#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.cpp
Normal file
13
test/version.cpp
Normal file
@ -0,0 +1,13 @@
|
||||
#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.cpp
Normal file
78
test/zone.cpp
Normal file
@ -0,0 +1,78 @@
|
||||
#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);
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user