diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 07db7f99..4755f2d0 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -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}) diff --git a/test/Makefile.am b/test/Makefile.am index 68858e76..c336e3a6 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -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 diff --git a/test/buffer.cpp b/test/buffer.cpp new file mode 100644 index 00000000..512b0bc4 --- /dev/null +++ b/test/buffer.cpp @@ -0,0 +1,119 @@ +#include +#include +#include +#include +#include +#include + +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(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); +} diff --git a/test/cases.cpp b/test/cases.cpp new file mode 100644 index 00000000..45aace0b --- /dev/null +++ b/test/cases.cpp @@ -0,0 +1,38 @@ +#include +#include +#include + +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) ); +} + diff --git a/test/convert.cpp b/test/convert.cpp new file mode 100644 index 00000000..dcda77c6 --- /dev/null +++ b/test/convert.cpp @@ -0,0 +1,76 @@ +#include +#include + +class compatibility { +public: + compatibility() : str1("default"), str2("default") { } + + std::string str1; + std::string str2; + + MSGPACK_DEFINE(str1, str2); +}; + +TEST(convert, compatibility_less) +{ + std::vector 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 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); +} + diff --git a/test/fixint.cpp b/test/fixint.cpp new file mode 100644 index 00000000..cf109ae5 --- /dev/null +++ b/test/fixint.cpp @@ -0,0 +1,55 @@ +#include +#include + +template +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(2); + check_size(3); + check_size(5); + check_size(9); + + check_size(2); + check_size(3); + check_size(5); + check_size(9); +} + + +template +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(); + check_convert(); + check_convert(); + check_convert(); + + check_convert(); + check_convert(); + check_convert(); + check_convert(); +} + diff --git a/test/fixint_c.cpp b/test/fixint_c.cpp new file mode 100644 index 00000000..d9dc5180 --- /dev/null +++ b/test/fixint_c.cpp @@ -0,0 +1,32 @@ +#include +#include + +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); +} + diff --git a/test/msgpack_tuple.cpp b/test/msgpack_tuple.cpp new file mode 100644 index 00000000..9779d06a --- /dev/null +++ b/test/msgpack_tuple.cpp @@ -0,0 +1,103 @@ +#include +#include + + +TEST(msgpack_tuple, member_get) +{ + msgpack::type::tuple 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 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 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 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 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 t1 = msgpack::type::make_tuple(42); + msgpack::type::tuple t2 = msgpack::type::make_tuple(true, "ABC"); + msgpack::type::tuple 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 t1 = msgpack::type::make_tuple(42, true, "ABC"); + msgpack::type::tuple 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 diff --git a/test/object.cpp b/test/object.cpp new file mode 100644 index 00000000..88490fb5 --- /dev/null +++ b/test/object.cpp @@ -0,0 +1,125 @@ +#include +#include + +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("<()); +} + + +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(), msgpack::type_error); + EXPECT_THROW(obj.as >(), msgpack::type_error); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(1u, obj.as()); + EXPECT_EQ(1u, obj.as()); +} + + +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); +} diff --git a/test/pack_unpack.cpp b/test/pack_unpack.cpp new file mode 100644 index 00000000..b95bccde --- /dev/null +++ b/test/pack_unpack.cpp @@ -0,0 +1,132 @@ +#include +#include +#include + +TEST(pack, num) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); +} + + +TEST(pack, vector) +{ + msgpack::sbuffer sbuf; + std::vector 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()); +} + +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()); + 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()); + 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()); +} + +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()); +} + +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()); + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(2, msg.get().as()); + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(3, msg.get().as()); + + EXPECT_EQ(off, sbuf.size()); +} diff --git a/test/pack_unpack_c.cpp b/test/pack_unpack_c.cpp new file mode 100644 index 00000000..60e0e00e --- /dev/null +++ b/test/pack_unpack_c.cpp @@ -0,0 +1,70 @@ +#include +#include +#include + +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); +} + diff --git a/test/reference.cpp b/test/reference.cpp new file mode 100644 index 00000000..09ecbca5 --- /dev/null +++ b/test/reference.cpp @@ -0,0 +1,434 @@ +#include +#include + +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 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 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 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 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 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 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 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 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 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 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 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 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 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 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); +} diff --git a/test/streaming.cpp b/test/streaming.cpp new file mode 100644 index 00000000..2daa98a1 --- /dev/null +++ b/test/streaming.cpp @@ -0,0 +1,316 @@ +#include +#include +#include + +TEST(streaming, basic) +{ + msgpack::sbuffer buffer; + + msgpack::packer 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()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + } +} + +TEST(streaming, basic_pointer) +{ + msgpack::sbuffer buffer; + + msgpack::packer 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()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + } +} + +#if !defined(MSGPACK_USE_CPP03) + +TEST(streaming, move) +{ + msgpack::sbuffer buffer; + + msgpack::packer 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()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + 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 z) + { + EXPECT_EQ(expect, obj.as()); + } + + int expect; + +private: + std::istream& input; + msgpack::unpacker pac; +}; + +TEST(streaming, event) +{ + std::stringstream stream; + msgpack::packer 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 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 z(pac.release_zone()); + msgpack::object obj = pac.data(); + pac.reset(); + + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + 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 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 z) + { + EXPECT_EQ(expect, obj.as()); + } + + int expect; + +private: + std::istream& input; + msgpack::unpacker pac; +}; + +TEST(streaming, event_compat) +{ + std::stringstream stream; + msgpack::packer 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(); +} diff --git a/test/streaming_c.cpp b/test/streaming_c.cpp new file mode 100644 index 00000000..159eef76 --- /dev/null +++ b/test/streaming_c.cpp @@ -0,0 +1,114 @@ +#include +#include +#include + +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); +} + diff --git a/test/version.cpp b/test/version.cpp new file mode 100644 index 00000000..d2809b21 --- /dev/null +++ b/test/version.cpp @@ -0,0 +1,13 @@ +#include +#include + +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()); +} + diff --git a/test/zone.cpp b/test/zone.cpp new file mode 100644 index 00000000..b2dc543e --- /dev/null +++ b/test/zone.cpp @@ -0,0 +1,78 @@ +#include +#include + +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(); + EXPECT_EQ(m->num, 0); + EXPECT_EQ(m->str, "default"); +} + + +TEST(zone, allocate_constructor) +{ + msgpack::zone z; + myclass* m = z.allocate(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 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); +} +