From 6a8412d6de63479577ae3dda899adebc68c77c11 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 9 Sep 2014 14:15:21 +0900 Subject: [PATCH] Separated msgpack_test.cpp. Renamed test files. Decreased test's loop counter to avoid travis-ci no output timeout. The number of loops is not so meaningful. --- test/CMakeLists.txt | 9 +- test/Makefile.am | 21 +- test/msgpack_basic.cpp | 474 ++++++ test/{msgpackc_test.cpp => msgpack_c.cpp} | 0 test/msgpack_container.cpp | 564 +++++++ ...gpack_test_cpp11.cpp => msgpack_cpp11.cpp} | 0 test/msgpack_stream.cpp | 153 ++ test/msgpack_test.cpp | 1401 ----------------- test/msgpack_vref.cpp | 270 ++++ test/object_with_zone.cpp | 2 +- 10 files changed, 1483 insertions(+), 1411 deletions(-) create mode 100644 test/msgpack_basic.cpp rename test/{msgpackc_test.cpp => msgpack_c.cpp} (100%) create mode 100644 test/msgpack_container.cpp rename test/{msgpack_test_cpp11.cpp => msgpack_cpp11.cpp} (100%) create mode 100644 test/msgpack_stream.cpp delete mode 100644 test/msgpack_test.cpp create mode 100644 test/msgpack_vref.cpp diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index eed53ec6..3c971a29 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -22,14 +22,17 @@ LIST (APPEND check_PROGRAMS fixint.cpp fixint_c.cpp msgpack_tuple.cpp - msgpack_test.cpp - msgpackc_test.cpp + msgpack_basic.cpp + msgpack_container.cpp + msgpack_stream.cpp + msgpack_vref.cpp + msgpack_c.cpp reference.cpp ) IF (MSGPACK_CXX11) LIST (APPEND check_PROGRAMS - msgpack_test_cpp11.cpp + msgpack_cpp11.cpp ) ENDIF () diff --git a/test/Makefile.am b/test/Makefile.am index 64b296fd..35859b3a 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -17,9 +17,12 @@ check_PROGRAMS = \ fixint_c \ version \ msgpack_tuple \ - msgpackc_test \ - msgpack_test \ - msgpack_test_cpp11 \ + msgpack_c \ + msgpack_basic \ + msgpack_container \ + msgpack_stream \ + msgpack_vref \ + msgpack_cpp11 \ reference TESTS = $(check_PROGRAMS) @@ -53,11 +56,17 @@ version_SOURCES = version.cpp msgpack_tuple_SOURCES = msgpack_tuple.cpp -msgpackc_test_SOURCES = msgpackc_test.cpp +msgpack_c_SOURCES = msgpack_c.cpp -msgpack_test_SOURCES = msgpack_test.cpp +msgpack_basic_SOURCES = msgpack_basic.cpp -msgpack_test_cpp11_SOURCES = msgpack_test_cpp11.cpp +msgpack_container_SOURCES = msgpack_container.cpp + +msgpack_stream_SOURCES = msgpack_stream.cpp + +msgpack_vref_SOURCES = msgpack_vref.cpp + +msgpack_cpp11_SOURCES = msgpack_cpp11.cpp reference_SOURCES = reference.cpp diff --git a/test/msgpack_basic.cpp b/test/msgpack_basic.cpp new file mode 100644 index 00000000..bd0a8745 --- /dev/null +++ b/test/msgpack_basic.cpp @@ -0,0 +1,474 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 10000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +#define GEN_TEST(test_type) \ + do { \ + vector v; \ + v.push_back(0); \ + v.push_back(1); \ + v.push_back(2); \ + v.push_back(numeric_limits::min()); \ + v.push_back(numeric_limits::max()); \ + for (unsigned int i = 0; i < kLoop; i++) \ + v.push_back(rand()); \ + for (unsigned int i = 0; i < v.size() ; i++) { \ + msgpack::sbuffer sbuf; \ + test_type val1 = v[i]; \ + msgpack::pack(sbuf, val1); \ + msgpack::unpacked ret; \ + msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ + EXPECT_EQ(val1, ret.get().as()); \ + } \ +} while(0) + +TEST(MSGPACK, simple_buffer_char) +{ + GEN_TEST(char); +} + +TEST(MSGPACK, simple_buffer_signed_char) +{ + GEN_TEST(signed char); +} + +TEST(MSGPACK, simple_buffer_unsigned_char) +{ + GEN_TEST(unsigned char); +} + + +TEST(MSGPACK, simple_buffer_short) +{ + GEN_TEST(short); +} + +TEST(MSGPACK, simple_buffer_int) +{ + GEN_TEST(int); +} + +TEST(MSGPACK, simple_buffer_long) +{ + GEN_TEST(long); +} + +TEST(MSGPACK, simple_buffer_long_long) +{ + GEN_TEST(long long); +} + +TEST(MSGPACK, simple_buffer_unsigned_short) +{ + GEN_TEST(unsigned short); +} + +TEST(MSGPACK, simple_buffer_unsigned_int) +{ + GEN_TEST(unsigned int); +} + +TEST(MSGPACK, simple_buffer_unsigned_long) +{ + GEN_TEST(unsigned long); +} + +TEST(MSGPACK, simple_buffer_unsigned_long_long) +{ + GEN_TEST(unsigned long long); +} + +TEST(MSGPACK, simple_buffer_uint8) +{ + GEN_TEST(uint8_t); +} + +TEST(MSGPACK, simple_buffer_uint16) +{ + GEN_TEST(uint16_t); +} + +TEST(MSGPACK, simple_buffer_uint32) +{ + GEN_TEST(uint32_t); +} + +TEST(MSGPACK, simple_buffer_uint64) +{ + GEN_TEST(uint64_t); +} + +TEST(MSGPACK, simple_buffer_int8) +{ + GEN_TEST(int8_t); +} + +TEST(MSGPACK, simple_buffer_int16) +{ + GEN_TEST(int16_t); +} + +TEST(MSGPACK, simple_buffer_int32) +{ + GEN_TEST(int32_t); +} + +TEST(MSGPACK, simple_buffer_int64) +{ + GEN_TEST(int64_t); +} + +TEST(MSGPACK, simple_buffer_float) +{ + vector v; + v.push_back(0.0); + v.push_back(-0.0); + v.push_back(1.0); + v.push_back(-1.0); + v.push_back(numeric_limits::min()); + v.push_back(numeric_limits::max()); + v.push_back(nanf("tag")); + v.push_back(1.0/0.0); // inf + v.push_back(-(1.0/0.0)); // -inf + for (unsigned int i = 0; i < kLoop; i++) { + v.push_back(drand48()); + v.push_back(-drand48()); + } + for (unsigned int i = 0; i < v.size() ; i++) { + msgpack::sbuffer sbuf; + float val1 = v[i]; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + float val2 = ret.get().as(); + + if (std::isnan(val1)) + EXPECT_TRUE(std::isnan(val2)); + else if (std::isinf(val1)) + EXPECT_TRUE(std::isinf(val2)); + else + EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + } +} + +namespace { +template +struct TypePair { + typedef F float_type; + typedef I integer_type; +}; +} // namespace + +template +class IntegerToFloatingPointTest : public testing::Test { +}; +TYPED_TEST_CASE_P(IntegerToFloatingPointTest); + +TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) +{ + typedef typename TypeParam::float_type float_type; + typedef typename TypeParam::integer_type integer_type; + vector v; + v.push_back(0); + v.push_back(1); + if (numeric_limits::is_signed) v.push_back(-1); + else v.push_back(2); + v.push_back(numeric_limits::min()); + v.push_back(numeric_limits::max()); + for (unsigned int i = 0; i < kLoop; i++) { + v.push_back(rand()); + } + for (unsigned int i = 0; i < v.size() ; i++) { + msgpack::sbuffer sbuf; + integer_type val1 = v[i]; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + float_type val2 = ret.get().as(); + EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + } +} + +REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest, + simple_buffer); + +typedef testing::Types, + TypePair, + TypePair, + TypePair > IntegerToFloatingPointTestTypes; +INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance, + IntegerToFloatingPointTest, + IntegerToFloatingPointTestTypes); + +TEST(MSGPACK, simple_buffer_double) +{ + vector v; + v.push_back(0.0); + v.push_back(-0.0); + v.push_back(1.0); + v.push_back(-1.0); + v.push_back(numeric_limits::min()); + v.push_back(numeric_limits::max()); + v.push_back(nanf("tag")); + v.push_back(1.0/0.0); // inf + v.push_back(-(1.0/0.0)); // -inf + for (unsigned int i = 0; i < kLoop; i++) { + v.push_back(drand48()); + v.push_back(-drand48()); + } + for (unsigned int i = 0; i < v.size() ; i++) { + msgpack::sbuffer sbuf; + double val1 = v[i]; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + double val2 = ret.get().as(); + + if (std::isnan(val1)) + EXPECT_TRUE(std::isnan(val2)); + else if (std::isinf(val1)) + EXPECT_TRUE(std::isinf(val2)); + else + EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + } +} + +TEST(MSGPACK, simple_buffer_true) +{ + msgpack::sbuffer sbuf; + bool val1 = true; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + bool val2 = ret.get().as(); + EXPECT_EQ(val1, val2); +} + +TEST(MSGPACK, simple_buffer_false) +{ + msgpack::sbuffer sbuf; + bool val1 = false; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + bool val2 = ret.get().as(); + EXPECT_EQ(val1, val2); +} + +TEST(MSGPACK, simple_buffer_fixext1) +{ + 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_EQ(1, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_EQ(2, ret.get().via.ext.data()[0]); +} + +TEST(MSGPACK, simple_buffer_fixext2) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3 }; + + packer.pack_ext(sizeof(buf), 0); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(2, ret.get().via.ext.size); + EXPECT_EQ(0, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext4) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(4, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext8) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(8, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext16) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(16, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_1byte_0) +{ + std::size_t const size = 0; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + + packer.pack_ext(size, 77); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); +} + +TEST(MSGPACK, simple_buffer_fixext_1byte_255) +{ + std::size_t const size = 255; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_2byte_256) +{ + std::size_t const size = 256; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_2byte_65535) +{ + std::size_t const size = 65535; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_4byte_65536) +{ + std::size_t const size = 65536; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK_STL, simple_buffer_string) +{ + for (unsigned int k = 0; k < kLoop; k++) { + string val1; + for (unsigned int i = 0; i < kElements; i++) + val1 += 'a' + rand() % 26; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::STR); + string val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(val1, val2); + } +} + +TEST(MSGPACK_STL, simple_buffer_cstring) +{ + for (unsigned int k = 0; k < kLoop; k++) { + string val1; + for (unsigned int i = 0; i < kElements; i++) + val1 += 'a' + rand() % 26; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1.c_str()); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::STR); + string val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(val1, val2); + } +} + diff --git a/test/msgpackc_test.cpp b/test/msgpack_c.cpp similarity index 100% rename from test/msgpackc_test.cpp rename to test/msgpack_c.cpp diff --git a/test/msgpack_container.cpp b/test/msgpack_container.cpp new file mode 100644 index 00000000..5b8accf0 --- /dev/null +++ b/test/msgpack_container.cpp @@ -0,0 +1,564 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 1000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +TEST(MSGPACK_STL, simple_buffer_vector) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); + vector val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_vector_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::BIN); + vector val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_map) +{ + for (unsigned int k = 0; k < kLoop; k++) { + map val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + map val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_deque) +{ + for (unsigned int k = 0; k < kLoop; k++) { + deque val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + deque val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_list) +{ + for (unsigned int k = 0; k < kLoop; k++) { + list val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + list val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + set val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + set val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_pair) +{ + for (unsigned int k = 0; k < kLoop; k++) { + pair val1 = make_pair(rand(), rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + pair val2 = ret.get().as >(); + EXPECT_EQ(val1.first, val2.first); + EXPECT_EQ(val1.second, val2.second); + } +} + +TEST(MSGPACK_STL, simple_buffer_multimap) +{ + for (unsigned int k = 0; k < kLoop; k++) { + multimap val1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + val1.insert(make_pair(i1, rand())); + val1.insert(make_pair(i1, rand())); + } + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + multimap val2 = ret.get().as >(); + + vector > v1, v2; + multimap::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(make_pair(it->first, it->second)); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} + +TEST(MSGPACK_STL, simple_buffer_multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + multiset val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + multiset val2 = ret.get().as >(); + + vector v1, v2; + multiset::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(*it); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(*it); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} + +// TR1 + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_map val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_map val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + tr1::unordered_map::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) { + EXPECT_TRUE(val2.find(it->first) != val2.end()); + EXPECT_EQ(it->second, val2.find(it->first)->second); + } + } +} + +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_multimap val1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + val1.insert(make_pair(i1, rand())); + val1.insert(make_pair(i1, rand())); + } + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_multimap val2 = ret.get().as >(); + + vector > v1, v2; + tr1::unordered_multimap::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(make_pair(it->first, it->second)); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_set val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_set val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + tr1::unordered_set::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + EXPECT_TRUE(val2.find(*it) != val2.end()); + } +} + +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_multiset val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_multiset val2 = ret.get().as >(); + + vector v1, v2; + tr1::unordered_multiset::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(*it); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(*it); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(MSGPACK_TR1, simple_buffer_unordered_map) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_map val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_map val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + unordered_map::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) { + EXPECT_TRUE(val2.find(it->first) != val2.end()); + EXPECT_EQ(it->second, val2.find(it->first)->second); + } + } +} + +TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_multimap val1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + val1.insert(make_pair(i1, rand())); + val1.insert(make_pair(i1, rand())); + } + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_multimap val2 = ret.get().as >(); + + vector > v1, v2; + unordered_multimap::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(make_pair(it->first, it->second)); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(MSGPACK_TR1, simple_buffer_unordered_set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_set val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_set val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + unordered_set::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + EXPECT_TRUE(val2.find(*it) != val2.end()); + } +} + +TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_multiset val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_multiset val2 = ret.get().as >(); + + vector v1, v2; + unordered_multiset::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(*it); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(*it); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#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(); + 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 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(); + 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(); + EXPECT_EQ(val1.i, val2.i); + EXPECT_EQ(val1.s, val2.s); + EXPECT_FALSE(val2.s.empty()); + } +} + +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); + +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(); + 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 + void msgpack_pack(Packer& pk) const + { + if (is_double) + pk.pack(msgpack::type::tuple(true, value.f)); + else + pk.pack(msgpack::type::tuple(false, value.i)); + } + + void msgpack_unpack(msgpack::object o) + { + msgpack::type::tuple 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(); + 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(); + EXPECT_EQ(val1.is_double, val2.is_double); + EXPECT_EQ(val1.value.i, 1); + EXPECT_EQ(val1.value.i, val2.value.i); + } +} diff --git a/test/msgpack_test_cpp11.cpp b/test/msgpack_cpp11.cpp similarity index 100% rename from test/msgpack_test_cpp11.cpp rename to test/msgpack_cpp11.cpp diff --git a/test/msgpack_stream.cpp b/test/msgpack_stream.cpp new file mode 100644 index 00000000..2f4be819 --- /dev/null +++ b/test/msgpack_stream.cpp @@ -0,0 +1,153 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 1000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + + +#define GEN_TEST_STREAM(test_type) \ + for (unsigned int k = 0; k < kLoop; k++) { \ + msgpack::sbuffer sbuf; \ + msgpack::packer pk(sbuf); \ + typedef std::vector vec_type; \ + vec_type vec; \ + for(unsigned int i = 0; i < rand() % kLoop; ++i) { \ + vec_type::value_type r = rand(); \ + vec.push_back(r); \ + pk.pack(r); \ + } \ + msgpack::unpacker pac; \ + vec_type::const_iterator it = vec.begin(); \ + const char *p = sbuf.data(); \ + const char * const pend = p + sbuf.size(); \ + while (p < pend) { \ + const size_t sz = std::min(pend - p, rand() % 128); \ + pac.reserve_buffer(sz); \ + memcpy(pac.buffer(), p, sz); \ + pac.buffer_consumed(sz); \ + msgpack::unpacked result; \ + while (pac.next(result)) { \ + if (it == vec.end()) goto out; \ + msgpack::object obj = result.get(); \ + vec_type::value_type val; \ + obj.convert(&val); \ + EXPECT_EQ(*it, val); \ + ++it; \ + } \ + p += sz; \ + } \ + out: \ + ; \ + } + +TEST(MSGPACK, stream_char) +{ + GEN_TEST_STREAM(char); +} + +TEST(MSGPACK, stream_signed_char) +{ + GEN_TEST_STREAM(signed char); +} + +TEST(MSGPACK, stream_unsigned_char) +{ + GEN_TEST_STREAM(unsigned char); +} + +TEST(MSGPACK, stream_short) +{ + GEN_TEST_STREAM(short); +} + +TEST(MSGPACK, stream_int) +{ + GEN_TEST_STREAM(int); +} + +TEST(MSGPACK, stream_long) +{ + GEN_TEST_STREAM(long); +} + +TEST(MSGPACK, stream_long_long) +{ + GEN_TEST_STREAM(long long); +} + +TEST(MSGPACK, stream_unsigned_short) +{ + GEN_TEST_STREAM(unsigned short); +} + +TEST(MSGPACK, stream_unsigned_int) +{ + GEN_TEST_STREAM(unsigned int); +} + +TEST(MSGPACK, stream_unsigned_long) +{ + GEN_TEST_STREAM(unsigned long); +} + +TEST(MSGPACK, stream_unsigned_long_long) +{ + GEN_TEST_STREAM(unsigned long long); +} + +TEST(MSGPACK, stream_uint8) +{ + GEN_TEST_STREAM(uint8_t); +} + +TEST(MSGPACK, stream_uint16) +{ + GEN_TEST_STREAM(uint16_t); +} + +TEST(MSGPACK, stream_uint32) +{ + GEN_TEST_STREAM(uint32_t); +} + +TEST(MSGPACK, stream_uint64) +{ + GEN_TEST_STREAM(uint64_t); +} + +TEST(MSGPACK, stream_int8) +{ + GEN_TEST_STREAM(int8_t); +} + +TEST(MSGPACK, stream_int16) +{ + GEN_TEST_STREAM(int16_t); +} + +TEST(MSGPACK, stream_int32) +{ + GEN_TEST_STREAM(int32_t); +} + +TEST(MSGPACK, stream_int64) +{ + GEN_TEST_STREAM(int64_t); +} diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp deleted file mode 100644 index dcbb883f..00000000 --- a/test/msgpack_test.cpp +++ /dev/null @@ -1,1401 +0,0 @@ -#include "msgpack.hpp" - -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -using namespace std; - -const unsigned int kLoop = 10000; -const unsigned int kElements = 100; -const double kEPS = 1e-10; - -#define GEN_TEST(test_type) \ - do { \ - vector v; \ - v.push_back(0); \ - v.push_back(1); \ - v.push_back(2); \ - v.push_back(numeric_limits::min()); \ - v.push_back(numeric_limits::max()); \ - for (unsigned int i = 0; i < kLoop; i++) \ - v.push_back(rand()); \ - for (unsigned int i = 0; i < v.size() ; i++) { \ - msgpack::sbuffer sbuf; \ - test_type val1 = v[i]; \ - msgpack::pack(sbuf, val1); \ - msgpack::unpacked ret; \ - msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ - EXPECT_EQ(val1, ret.get().as()); \ - } \ -} while(0) - -TEST(MSGPACK, simple_buffer_char) -{ - GEN_TEST(char); -} - -TEST(MSGPACK, simple_buffer_signed_char) -{ - GEN_TEST(signed char); -} - -TEST(MSGPACK, simple_buffer_unsigned_char) -{ - GEN_TEST(unsigned char); -} - - -TEST(MSGPACK, simple_buffer_short) -{ - GEN_TEST(short); -} - -TEST(MSGPACK, simple_buffer_int) -{ - GEN_TEST(int); -} - -TEST(MSGPACK, simple_buffer_long) -{ - GEN_TEST(long); -} - -TEST(MSGPACK, simple_buffer_long_long) -{ - GEN_TEST(long long); -} - -TEST(MSGPACK, simple_buffer_unsigned_short) -{ - GEN_TEST(unsigned short); -} - -TEST(MSGPACK, simple_buffer_unsigned_int) -{ - GEN_TEST(unsigned int); -} - -TEST(MSGPACK, simple_buffer_unsigned_long) -{ - GEN_TEST(unsigned long); -} - -TEST(MSGPACK, simple_buffer_unsigned_long_long) -{ - GEN_TEST(unsigned long long); -} - -TEST(MSGPACK, simple_buffer_uint8) -{ - GEN_TEST(uint8_t); -} - -TEST(MSGPACK, simple_buffer_uint16) -{ - GEN_TEST(uint16_t); -} - -TEST(MSGPACK, simple_buffer_uint32) -{ - GEN_TEST(uint32_t); -} - -TEST(MSGPACK, simple_buffer_uint64) -{ - GEN_TEST(uint64_t); -} - -TEST(MSGPACK, simple_buffer_int8) -{ - GEN_TEST(int8_t); -} - -TEST(MSGPACK, simple_buffer_int16) -{ - GEN_TEST(int16_t); -} - -TEST(MSGPACK, simple_buffer_int32) -{ - GEN_TEST(int32_t); -} - -TEST(MSGPACK, simple_buffer_int64) -{ - GEN_TEST(int64_t); -} - -TEST(MSGPACK, simple_buffer_float) -{ - vector v; - v.push_back(0.0); - v.push_back(-0.0); - v.push_back(1.0); - v.push_back(-1.0); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - v.push_back(nanf("tag")); - v.push_back(1.0/0.0); // inf - v.push_back(-(1.0/0.0)); // -inf - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(drand48()); - v.push_back(-drand48()); - } - for (unsigned int i = 0; i < v.size() ; i++) { - msgpack::sbuffer sbuf; - float val1 = v[i]; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - float val2 = ret.get().as(); - - if (std::isnan(val1)) - EXPECT_TRUE(std::isnan(val2)); - else if (std::isinf(val1)) - EXPECT_TRUE(std::isinf(val2)); - else - EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - } -} - -namespace { -template -struct TypePair { - typedef F float_type; - typedef I integer_type; -}; -} // namespace - -template -class IntegerToFloatingPointTest : public testing::Test { -}; -TYPED_TEST_CASE_P(IntegerToFloatingPointTest); - -TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) -{ - typedef typename TypeParam::float_type float_type; - typedef typename TypeParam::integer_type integer_type; - vector v; - v.push_back(0); - v.push_back(1); - if (numeric_limits::is_signed) v.push_back(-1); - else v.push_back(2); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(rand()); - } - for (unsigned int i = 0; i < v.size() ; i++) { - msgpack::sbuffer sbuf; - integer_type val1 = v[i]; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - float_type val2 = ret.get().as(); - EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - } -} - -REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest, - simple_buffer); - -typedef testing::Types, - TypePair, - TypePair, - TypePair > IntegerToFloatingPointTestTypes; -INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance, - IntegerToFloatingPointTest, - IntegerToFloatingPointTestTypes); - -TEST(MSGPACK, simple_buffer_double) -{ - vector v; - v.push_back(0.0); - v.push_back(-0.0); - v.push_back(1.0); - v.push_back(-1.0); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - v.push_back(nanf("tag")); - v.push_back(1.0/0.0); // inf - v.push_back(-(1.0/0.0)); // -inf - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(drand48()); - v.push_back(-drand48()); - } - for (unsigned int i = 0; i < v.size() ; i++) { - msgpack::sbuffer sbuf; - double val1 = v[i]; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - double val2 = ret.get().as(); - - if (std::isnan(val1)) - EXPECT_TRUE(std::isnan(val2)); - else if (std::isinf(val1)) - EXPECT_TRUE(std::isinf(val2)); - else - EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - } -} - -TEST(MSGPACK, simple_buffer_true) -{ - msgpack::sbuffer sbuf; - bool val1 = true; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - bool val2 = ret.get().as(); - EXPECT_EQ(val1, val2); -} - -TEST(MSGPACK, simple_buffer_false) -{ - msgpack::sbuffer sbuf; - bool val1 = false; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - bool val2 = ret.get().as(); - EXPECT_EQ(val1, val2); -} - -TEST(MSGPACK, simple_buffer_fixext1) -{ - 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_EQ(1, ret.get().via.ext.size); - EXPECT_EQ(1, ret.get().via.ext.type()); - EXPECT_EQ(2, ret.get().via.ext.data()[0]); -} - -TEST(MSGPACK, simple_buffer_fixext2) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2, 3 }; - - packer.pack_ext(sizeof(buf), 0); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(2, ret.get().via.ext.size); - EXPECT_EQ(0, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext4) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2, 3, 4, 5 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(4, ret.get().via.ext.size); - EXPECT_EQ(1, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext8) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(8, ret.get().via.ext.size); - EXPECT_EQ(1, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext16) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(16, ret.get().via.ext.size); - EXPECT_EQ(1, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext_1byte_0) -{ - std::size_t const size = 0; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - - packer.pack_ext(size, 77); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); -} - -TEST(MSGPACK, simple_buffer_fixext_1byte_255) -{ - std::size_t const size = 255; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char buf[size]; - for (int i = 0; i != size; ++i) buf[i] = static_cast(i); - packer.pack_ext(sizeof(buf), 77); - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext_2byte_256) -{ - std::size_t const size = 256; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char buf[size]; - for (int i = 0; i != size; ++i) buf[i] = static_cast(i); - packer.pack_ext(sizeof(buf), 77); - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext_2byte_65535) -{ - std::size_t const size = 65535; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char buf[size]; - for (int i = 0; i != size; ++i) buf[i] = static_cast(i); - packer.pack_ext(sizeof(buf), 77); - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext_4byte_65536) -{ - std::size_t const size = 65536; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char buf[size]; - for (int i = 0; i != size; ++i) buf[i] = static_cast(i); - packer.pack_ext(sizeof(buf), 77); - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -//----------------------------------------------------------------------------- - -// STL - -TEST(MSGPACK_STL, simple_buffer_string) -{ - for (unsigned int k = 0; k < kLoop; k++) { - string val1; - for (unsigned int i = 0; i < kElements; i++) - val1 += 'a' + rand() % 26; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::STR); - string val2 = ret.get().as(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(val1, val2); - } -} - -TEST(MSGPACK_STL, simple_buffer_cstring) -{ - for (unsigned int k = 0; k < kLoop; k++) { - string val1; - for (unsigned int i = 0; i < kElements; i++) - val1 += 'a' + rand() % 26; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1.c_str()); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::STR); - string val2 = ret.get().as(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(val1, val2); - } -} - -TEST(MSGPACK_STL, simple_buffer_vector) -{ - for (unsigned int k = 0; k < kLoop; k++) { - vector val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); - vector val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_vector_char) -{ - for (unsigned int k = 0; k < kLoop; k++) { - vector val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::BIN); - vector val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_map) -{ - for (unsigned int k = 0; k < kLoop; k++) { - map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - map val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_deque) -{ - for (unsigned int k = 0; k < kLoop; k++) { - deque val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - deque val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_list) -{ - for (unsigned int k = 0; k < kLoop; k++) { - list val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - list val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_set) -{ - for (unsigned int k = 0; k < kLoop; k++) { - set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - set val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_pair) -{ - for (unsigned int k = 0; k < kLoop; k++) { - pair val1 = make_pair(rand(), rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - pair val2 = ret.get().as >(); - EXPECT_EQ(val1.first, val2.first); - EXPECT_EQ(val1.second, val2.second); - } -} - -TEST(MSGPACK_STL, simple_buffer_multimap) -{ - for (unsigned int k = 0; k < kLoop; k++) { - multimap val1; - for (unsigned int i = 0; i < kElements; i++) { - int i1 = rand(); - val1.insert(make_pair(i1, rand())); - val1.insert(make_pair(i1, rand())); - } - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - multimap val2 = ret.get().as >(); - - vector > v1, v2; - multimap::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(make_pair(it->first, it->second)); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} - -TEST(MSGPACK_STL, simple_buffer_multiset) -{ - for (unsigned int k = 0; k < kLoop; k++) { - multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - multiset val2 = ret.get().as >(); - - vector v1, v2; - multiset::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(*it); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(*it); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} - -// TR1 - -#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP -#include -#include "msgpack/adaptor/tr1/unordered_map.hpp" -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_map val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - tr1::unordered_map::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) { - EXPECT_TRUE(val2.find(it->first) != val2.end()); - EXPECT_EQ(it->second, val2.find(it->first)->second); - } - } -} - -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_multimap val1; - for (unsigned int i = 0; i < kElements; i++) { - int i1 = rand(); - val1.insert(make_pair(i1, rand())); - val1.insert(make_pair(i1, rand())); - } - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_multimap val2 = ret.get().as >(); - - vector > v1, v2; - tr1::unordered_multimap::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(make_pair(it->first, it->second)); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET -#include -#include "msgpack/adaptor/tr1/unordered_set.hpp" -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_set val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - tr1::unordered_set::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - EXPECT_TRUE(val2.find(*it) != val2.end()); - } -} - -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_multiset val2 = ret.get().as >(); - - vector v1, v2; - tr1::unordered_multiset::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(*it); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(*it); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP -#include -#include "msgpack/adaptor/tr1/unordered_map.hpp" -TEST(MSGPACK_TR1, simple_buffer_unordered_map) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_map val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - unordered_map::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) { - EXPECT_TRUE(val2.find(it->first) != val2.end()); - EXPECT_EQ(it->second, val2.find(it->first)->second); - } - } -} - -TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_multimap val1; - for (unsigned int i = 0; i < kElements; i++) { - int i1 = rand(); - val1.insert(make_pair(i1, rand())); - val1.insert(make_pair(i1, rand())); - } - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_multimap val2 = ret.get().as >(); - - vector > v1, v2; - unordered_multimap::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(make_pair(it->first, it->second)); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -#ifdef MSGPACK_HAS_STD_UNOURDERED_SET -#include -#include "msgpack/adaptor/tr1/unordered_set.hpp" -TEST(MSGPACK_TR1, simple_buffer_unordered_set) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_set val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - unordered_set::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - EXPECT_TRUE(val2.find(*it) != val2.end()); - } -} - -TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_multiset val2 = ret.get().as >(); - - vector v1, v2; - unordered_multiset::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(*it); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(*it); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#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(); - 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 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(); - 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(); - EXPECT_EQ(val1.i, val2.i); - EXPECT_EQ(val1.s, val2.s); - EXPECT_FALSE(val2.s.empty()); - } -} - -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); - -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(); - 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 - void msgpack_pack(Packer& pk) const - { - if (is_double) - pk.pack(msgpack::type::tuple(true, value.f)); - else - pk.pack(msgpack::type::tuple(false, value.i)); - } - - void msgpack_unpack(msgpack::object o) - { - msgpack::type::tuple 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(); - 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(); - EXPECT_EQ(val1.is_double, val2.is_double); - EXPECT_EQ(val1.value.i, 1); - EXPECT_EQ(val1.value.i, val2.value.i); - } -} - -//----------------------------------------------------------------------------- - -#define GEN_TEST_VREF(test_type, vbuf) \ - do { \ - vector v; \ - v.push_back(0); \ - for (unsigned int i = 0; i < v.size(); i++) { \ - test_type val1 = v[i]; \ - msgpack::pack(vbuf, val1); \ - msgpack::sbuffer sbuf; \ - const struct iovec* cur = vbuf.vector(); \ - const struct iovec* end = cur + vbuf.vector_size(); \ - for(; cur != end; ++cur) \ - sbuf.write((const char*)cur->iov_base, cur->iov_len); \ - msgpack::unpacked ret; \ - msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ - test_type val2 = ret.get().as(); \ - EXPECT_EQ(val1, val2); \ - } \ - } while(0); - -TEST(MSGPACK, vrefbuffer_char) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_signed_char) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(signed char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_char) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_short) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(short, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int, vbuf); -} - -TEST(MSGPACK, vrefbuffer_long) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_long_long) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(long long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_short) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned short, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_int) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned int, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_long) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_long_long) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned long long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_uint8) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(uint8_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_uint16) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(uint16_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_uint32) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(uint32_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_uint64) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(uint64_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int8) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int8_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int16) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int16_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int32) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int32_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int64) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int64_t, vbuf); -} - -// small ref_size and chunk_size -TEST(MSGPACK, vrefbuffer_small_char) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_signed_char) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(signed char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_char) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_short) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(short, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_long) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_long_long) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(long long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_short) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned short, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_int) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned int, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_long) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_long_long) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned long long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_uint8) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(uint8_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_uint16) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(uint16_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_uint32) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(uint32_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_uint64) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(uint64_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int8) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int8_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int16) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int16_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int32) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int32_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int64) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int64_t, vbuf); -} - -//----------------------------------------------------------------------------- - -#define GEN_TEST_STREAM(test_type) \ - for (unsigned int k = 0; k < kLoop; k++) { \ - msgpack::sbuffer sbuf; \ - msgpack::packer pk(sbuf); \ - typedef std::vector vec_type; \ - vec_type vec; \ - for(unsigned int i = 0; i < rand() % kLoop; ++i) { \ - vec_type::value_type r = rand(); \ - vec.push_back(r); \ - pk.pack(r); \ - } \ - msgpack::unpacker pac; \ - vec_type::const_iterator it = vec.begin(); \ - const char *p = sbuf.data(); \ - const char * const pend = p + sbuf.size(); \ - while (p < pend) { \ - const size_t sz = std::min(pend - p, rand() % 128); \ - pac.reserve_buffer(sz); \ - memcpy(pac.buffer(), p, sz); \ - pac.buffer_consumed(sz); \ - msgpack::unpacked result; \ - while (pac.next(result)) { \ - if (it == vec.end()) goto out; \ - msgpack::object obj = result.get(); \ - vec_type::value_type val; \ - obj.convert(&val); \ - EXPECT_EQ(*it, val); \ - ++it; \ - } \ - p += sz; \ - } \ - out: \ - ; \ - } - -TEST(MSGPACK, stream_char) -{ - GEN_TEST_STREAM(char); -} - -TEST(MSGPACK, stream_signed_char) -{ - GEN_TEST_STREAM(signed char); -} - -TEST(MSGPACK, stream_unsigned_char) -{ - GEN_TEST_STREAM(unsigned char); -} - -TEST(MSGPACK, stream_short) -{ - GEN_TEST_STREAM(short); -} - -TEST(MSGPACK, stream_int) -{ - GEN_TEST_STREAM(int); -} - -TEST(MSGPACK, stream_long) -{ - GEN_TEST_STREAM(long); -} - -TEST(MSGPACK, stream_long_long) -{ - GEN_TEST_STREAM(long long); -} - -TEST(MSGPACK, stream_unsigned_short) -{ - GEN_TEST_STREAM(unsigned short); -} - -TEST(MSGPACK, stream_unsigned_int) -{ - GEN_TEST_STREAM(unsigned int); -} - -TEST(MSGPACK, stream_unsigned_long) -{ - GEN_TEST_STREAM(unsigned long); -} - -TEST(MSGPACK, stream_unsigned_long_long) -{ - GEN_TEST_STREAM(unsigned long long); -} - -TEST(MSGPACK, stream_uint8) -{ - GEN_TEST_STREAM(uint8_t); -} - -TEST(MSGPACK, stream_uint16) -{ - GEN_TEST_STREAM(uint16_t); -} - -TEST(MSGPACK, stream_uint32) -{ - GEN_TEST_STREAM(uint32_t); -} - -TEST(MSGPACK, stream_uint64) -{ - GEN_TEST_STREAM(uint64_t); -} - -TEST(MSGPACK, stream_int8) -{ - GEN_TEST_STREAM(int8_t); -} - -TEST(MSGPACK, stream_int16) -{ - GEN_TEST_STREAM(int16_t); -} - -TEST(MSGPACK, stream_int32) -{ - GEN_TEST_STREAM(int32_t); -} - -TEST(MSGPACK, stream_int64) -{ - GEN_TEST_STREAM(int64_t); -} diff --git a/test/msgpack_vref.cpp b/test/msgpack_vref.cpp new file mode 100644 index 00000000..a66179b1 --- /dev/null +++ b/test/msgpack_vref.cpp @@ -0,0 +1,270 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 10000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +#define GEN_TEST_VREF(test_type, vbuf) \ + do { \ + vector v; \ + v.push_back(0); \ + for (unsigned int i = 0; i < v.size(); i++) { \ + test_type val1 = v[i]; \ + msgpack::pack(vbuf, val1); \ + msgpack::sbuffer sbuf; \ + const struct iovec* cur = vbuf.vector(); \ + const struct iovec* end = cur + vbuf.vector_size(); \ + for(; cur != end; ++cur) \ + sbuf.write((const char*)cur->iov_base, cur->iov_len); \ + msgpack::unpacked ret; \ + msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ + test_type val2 = ret.get().as(); \ + EXPECT_EQ(val1, val2); \ + } \ + } while(0); + +TEST(MSGPACK, vrefbuffer_char) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_signed_char) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(signed char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_char) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_short) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_long_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_short) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_int) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_long_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint8) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint16) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint32) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint64) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint64_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int8) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int16) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int32) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int64) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int64_t, vbuf); +} + +// small ref_size and chunk_size +TEST(MSGPACK, vrefbuffer_small_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_signed_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(signed char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_short) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_long_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_short) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_int) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_long_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint8) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint16) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint32) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint64) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint64_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int8) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int16) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int32) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int64) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int64_t, vbuf); +} diff --git a/test/object_with_zone.cpp b/test/object_with_zone.cpp index cb49b8b3..38182f0c 100644 --- a/test/object_with_zone.cpp +++ b/test/object_with_zone.cpp @@ -8,7 +8,7 @@ using namespace std; -const unsigned int kLoop = 10000; +const unsigned int kLoop = 1000; const unsigned int kElements = 100; const double kEPS = 1e-10;