From 0a99b9f933709f67414a21d3cdb58b167cff2eee Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 7 Aug 2014 23:26:09 +0900 Subject: [PATCH] Fixed the problem that reference function doesn't pass correctly. Fixed referenced flag writing timing on next(). It should place before flush. Added msgpack_tuple test for CMakeLists.txt Untabified CMakeLists.txt Added reference function test. --- include/msgpack/unpack.hpp | 4 +- test/CMakeLists.txt | 83 ++++--- test/Makefile.am | 7 +- test/msgpack_test.cpp | 40 ++++ test/reference.cc | 434 +++++++++++++++++++++++++++++++++++++ 5 files changed, 520 insertions(+), 48 deletions(-) create mode 100644 test/reference.cc diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index a35e151b..60df2f6d 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -1148,9 +1148,9 @@ inline bool unpacker::next(unpacked& result) return false; } else { + result.set_referenced(m_ctx.user().referenced()); result.zone().reset( release_zone() ); result.set(data()); - result.set_referenced(m_ctx.user().referenced()); reset(); return true; } @@ -1314,7 +1314,7 @@ inline void unpack(unpacked& result, msgpack::unique_ptr z(new zone); bool referenced = false; unpack_return ret = detail::unpack_imp( - data, len, off, *z, obj, referenced); + data, len, off, *z, obj, referenced, f, user_data); result.set_referenced(referenced); diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 252fd164..23536a3a 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -3,53 +3,50 @@ FIND_PACKAGE (ZLIB REQUIRED) FIND_PACKAGE (Threads REQUIRED) INCLUDE_DIRECTORIES ( - ${GTEST_INCLUDE_DIRS} - ${ZLIB_INCLUDE_DIRS} + ${GTEST_INCLUDE_DIRS} + ${ZLIB_INCLUDE_DIRS} ) SET (check_PROGRAMS - pack_unpack.cc - version.cc - streaming_c.cc - pack_unpack_c.cc - zone.cc - msgpack_test.cpp - buffer.cc - msgpackc_test.cpp - streaming.cc - convert.cc - fixint_c.cc + 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 + msgpack_test.cpp + msgpackc_test.cpp + reference.cc ) -IF (MSGPACK_ENABLE_CXX) - LIST (APPEND check_PROGRAMS - cases.cc - fixint.cc - object.cc - ) -ENDIF () - FOREACH (source_file ${check_PROGRAMS}) - GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) - ADD_EXECUTABLE ( - ${source_file_we} - ${source_file} - ) - TARGET_LINK_LIBRARIES (${source_file_we} - msgpack - ${GTEST_BOTH_LIBRARIES} - ${ZLIB_LIBRARIES} - ${CMAKE_THREAD_LIBS_INIT} - ) - ADD_TEST (${source_file_we} ${source_file_we}) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3") - ENDIF () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") - IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") - STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") - ELSE () - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") - ENDIF () - ENDIF () + GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) + ADD_EXECUTABLE ( + ${source_file_we} + ${source_file} + ) + TARGET_LINK_LIBRARIES (${source_file_we} + msgpack + ${GTEST_BOTH_LIBRARIES} + ${ZLIB_LIBRARIES} + ${CMAKE_THREAD_LIBS_INIT} + ) + ADD_TEST (${source_file_we} ${source_file_we}) + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3") + ENDIF () + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + ELSE () + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") + ENDIF () + ENDIF () ENDFOREACH () diff --git a/test/Makefile.am b/test/Makefile.am index b7e9d00c..dfa7d3f0 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -1,4 +1,3 @@ - AM_CPPFLAGS = -I$(top_srcdir)/include AM_C_CPPFLAGS = -I$(top_srcdir)/include AM_LDFLAGS = $(top_builddir)/src/libmsgpack.la -lgtest_main -lgtest -pthread @@ -18,7 +17,8 @@ check_PROGRAMS = \ version \ msgpack_tuple \ msgpackc_test \ - msgpack_test + msgpack_test \ + reference TESTS = $(check_PROGRAMS) @@ -53,5 +53,6 @@ msgpackc_test_SOURCES = msgpackc_test.cpp msgpack_test_SOURCES = msgpack_test.cpp -EXTRA_DIST = cases.mpac cases_compact.mpac +reference_SOURCES = reference.cc +EXTRA_DIST = cases.mpac cases_compact.mpac diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index 8dda3f39..53af6dfb 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -38,6 +38,7 @@ const double kEPS = 1e-10; msgpack::unpacked ret; \ msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ EXPECT_EQ(val1, ret.get().as()); \ + EXPECT_FALSE(ret.referenced()); \ } \ } while(0) @@ -205,6 +206,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) msgpack::unpack(ret, sbuf.data(), sbuf.size()); float_type val2 = ret.get().as(); EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + EXPECT_FALSE(ret.referenced()); } } @@ -242,6 +244,7 @@ TEST(MSGPACK, simple_buffer_double) msgpack::unpacked ret; msgpack::unpack(ret, sbuf.data(), sbuf.size()); double val2 = ret.get().as(); + EXPECT_FALSE(ret.referenced()); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); @@ -261,6 +264,7 @@ TEST(MSGPACK, simple_buffer_true) msgpack::unpack(ret, sbuf.data(), sbuf.size()); bool val2 = ret.get().as(); EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_false) @@ -272,6 +276,7 @@ TEST(MSGPACK, simple_buffer_false) msgpack::unpack(ret, sbuf.data(), sbuf.size()); bool val2 = ret.get().as(); EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext1) @@ -287,6 +292,7 @@ TEST(MSGPACK, simple_buffer_fixext1) 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]); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext2) @@ -303,6 +309,7 @@ TEST(MSGPACK, simple_buffer_fixext2) EXPECT_EQ(0, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext4) @@ -319,6 +326,7 @@ TEST(MSGPACK, simple_buffer_fixext4) EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext8) @@ -335,6 +343,7 @@ TEST(MSGPACK, simple_buffer_fixext8) EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext16) @@ -351,6 +360,7 @@ TEST(MSGPACK, simple_buffer_fixext16) EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_1byte_0) @@ -364,6 +374,7 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_0) msgpack::unpack(ret, sbuf.data(), sbuf.size()); EXPECT_EQ(size, ret.get().via.ext.size); EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_1byte_255) @@ -382,6 +393,7 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_255) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_2byte_256) @@ -400,6 +412,7 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_256) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_2byte_65535) @@ -418,6 +431,7 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_65535) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_4byte_65536) @@ -436,6 +450,7 @@ TEST(MSGPACK, simple_buffer_fixext_4byte_65536) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } //----------------------------------------------------------------------------- @@ -455,6 +470,7 @@ TEST(MSGPACK_STL, simple_buffer_string) string val2 = ret.get().as(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); } } @@ -471,6 +487,7 @@ TEST(MSGPACK_STL, simple_buffer_vector) vector val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -487,6 +504,7 @@ TEST(MSGPACK_STL, simple_buffer_map) map val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -503,6 +521,7 @@ TEST(MSGPACK_STL, simple_buffer_deque) deque val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -519,6 +538,7 @@ TEST(MSGPACK_STL, simple_buffer_list) list val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -535,6 +555,7 @@ TEST(MSGPACK_STL, simple_buffer_set) set val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -549,6 +570,7 @@ TEST(MSGPACK_STL, simple_buffer_pair) pair val2 = ret.get().as >(); EXPECT_EQ(val1.first, val2.first); EXPECT_EQ(val1.second, val2.second); + EXPECT_FALSE(ret.referenced()); } } @@ -578,6 +600,7 @@ TEST(MSGPACK_STL, simple_buffer_multimap) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } @@ -604,6 +627,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } @@ -629,6 +653,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) EXPECT_TRUE(val2.find(it->first) != val2.end()); EXPECT_EQ(it->second, val2.find(it->first)->second); } + EXPECT_FALSE(ret.referenced()); } } @@ -658,6 +683,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } #endif @@ -680,6 +706,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) tr1::unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) EXPECT_TRUE(val2.find(*it) != val2.end()); + EXPECT_FALSE(ret.referenced()); } } @@ -706,6 +733,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } #endif @@ -730,6 +758,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map) EXPECT_TRUE(val2.find(it->first) != val2.end()); EXPECT_EQ(it->second, val2.find(it->first)->second); } + EXPECT_FALSE(ret.referenced()); } } @@ -759,6 +788,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } #endif @@ -781,6 +811,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set) unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) EXPECT_TRUE(val2.find(*it) != val2.end()); + EXPECT_FALSE(ret.referenced()); } } @@ -807,6 +838,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } #endif @@ -823,6 +855,7 @@ TEST(MSGPACK_CPP11, simple_tuple) msgpack::unpack(ret, sbuf.data(), sbuf.size()); std::tuple val2 = ret.get().as >(); EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); } #endif // !defined(MSGPACK_USE_CPP03) @@ -849,6 +882,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) TestClass val2 = ret.get().as(); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); + EXPECT_FALSE(ret.referenced()); } } @@ -877,6 +911,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); EXPECT_FALSE(val2.s.empty()); + EXPECT_FALSE(ret.referenced()); } } @@ -927,6 +962,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); + EXPECT_FALSE(ret.referenced()); } #if !defined(MSGPACK_USE_CPP03) @@ -963,6 +999,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); + EXPECT_FALSE(ret.referenced()); } #endif // !defined(MSGPACK_USE_CPP03) @@ -1020,6 +1057,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) TestUnionMemberClass val2 = ret.get().as(); EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); + EXPECT_FALSE(ret.referenced()); } { // int @@ -1032,6 +1070,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_EQ(val1.value.i, 1); EXPECT_EQ(val1.value.i, val2.value.i); + EXPECT_FALSE(ret.referenced()); } } @@ -1054,6 +1093,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ test_type val2 = ret.get().as(); \ EXPECT_EQ(val1, val2); \ + EXPECT_FALSE(ret.referenced()); \ } \ } while(0); diff --git a/test/reference.cc b/test/reference.cc new file mode 100644 index 00000000..09ecbca5 --- /dev/null +++ b/test/reference.cc @@ -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); +}