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.
2025-10-17 03:03:24 +02:00 · 2014-08-07 23:26:09 +09:00
parent 17e696fc0d
commit 0a99b9f933
5 changed files with 520 additions and 48 deletions
--- 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<zone> 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);

--- 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 ()
--- 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
--- 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<test_type>());                     \
+      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<float_type>();
    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<double>();
+    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<bool>();
  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<bool>();
  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<string>();
    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<int> val2 = ret.get().as<vector<int> >();
    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<int, int> val2 = ret.get().as<map<int, int> >();
    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<int> val2 = ret.get().as<deque<int> >();
    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<int> val2 = ret.get().as<list<int> >();
    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<int> val2 = ret.get().as<set<int> >();
    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<int, int> val2 = ret.get().as<pair<int, int> >();
    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<int>::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<int>::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<bool, std::string, double> val2 = ret.get().as<std::tuple<bool, std::string, double> >();
  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<TestClass>();
    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<TestUnionMemberClass>();
    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<test_type>();                       \
      EXPECT_EQ(val1, val2);                                            \
+      EXPECT_FALSE(ret.referenced());                                   \
    }                                                                   \
  } while(0);

--- a/test/reference.cc
+++ b/test/reference.cc
@@ -0,0 +1,434 @@
+#include <msgpack.hpp>
+#include <gtest/gtest.h>
+
+TEST(reference, unpack_int)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+    msgpack::unpacked ret;
+
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    EXPECT_FALSE(ret.referenced());
+}
+
+TEST(reference, unpack_string)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, std::string("abcdefg"));
+    msgpack::unpacked ret;
+
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    EXPECT_FALSE(ret.referenced());
+}
+
+TEST(reference, unpack_bin)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char c[] = { 1, 2, 3, 4, 5, 6 };
+    packer.pack_bin(sizeof(c));
+    packer.pack_bin_body(c, sizeof(c));
+
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    EXPECT_FALSE(ret.referenced());
+}
+
+TEST(reference, unpack_ext)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char const buf [] = { 2 };
+
+    packer.pack_ext(sizeof(buf), 1);
+    packer.pack_ext_body(buf, sizeof(buf));
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size());
+    EXPECT_FALSE(ret.referenced());
+}
+
+bool never_called(msgpack::type::object_type, std::size_t, void*)
+{
+    EXPECT_TRUE(false);
+    return false;
+}
+
+bool always_reference(msgpack::type::object_type, std::size_t, void*)
+{
+    return true;
+}
+
+TEST(reference, unpack_int_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+    msgpack::unpacked ret;
+
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called);
+    EXPECT_FALSE(ret.referenced());
+}
+
+TEST(reference, unpack_string_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, std::string("abcdefg"));
+    msgpack::unpacked ret;
+
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
+    EXPECT_TRUE(ret.referenced());
+}
+
+TEST(reference, unpack_bin_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char c[] = { 1, 2, 3, 4, 5, 6 };
+    packer.pack_bin(sizeof(c));
+    packer.pack_bin_body(c, sizeof(c));
+
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
+    EXPECT_TRUE(ret.referenced());
+}
+
+TEST(reference, unpack_ext_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char const buf [] = { 2 };
+
+    packer.pack_ext(sizeof(buf), 1);
+    packer.pack_ext_body(buf, sizeof(buf));
+    msgpack::unpacked ret;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
+    EXPECT_TRUE(ret.referenced());
+}
+
+static void* s_p;
+
+bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p)
+{
+    s_p = p;
+    switch (t) {
+    case msgpack::type::STR:
+        if (s >= 5) return true;
+        break;
+    case msgpack::type::BIN:
+        if (s >= 6) return true;
+        break;
+    case msgpack::type::EXT:
+        if (s >= 7) return true;
+        break;
+    default:
+        EXPECT_TRUE(false);
+    }
+    return false;
+}
+
+TEST(reference, unpack_int_sized_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+
+    msgpack::unpacked ret;
+    s_p = nullptr;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called, &sbuf);
+    EXPECT_FALSE(ret.referenced());
+    EXPECT_EQ(nullptr, s_p);
+}
+
+TEST(reference, unpack_string_sized_ref_4)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, std::string("1234"));
+
+    msgpack::unpacked ret;
+    s_p = nullptr;
+    // the last argument sbuf is any pointer as a user data.
+    // That is stored to s_p in sized_reference
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
+    EXPECT_FALSE(ret.referenced());
+    // compare the passed argument with stored s_p.
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+TEST(reference, unpack_string_sized_ref_5)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, std::string("12345"));
+
+    msgpack::unpacked ret;
+    s_p = nullptr;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
+    EXPECT_TRUE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+
+TEST(reference, unpack_bin_sized_ref_5)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char c[] = { 1, 2, 3, 4, 5 };
+    packer.pack_bin(sizeof(c));
+    packer.pack_bin_body(c, sizeof(c));
+
+    msgpack::unpacked ret;
+    s_p = nullptr;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
+    EXPECT_FALSE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+TEST(reference, unpack_bin_sized_ref_6)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char c[] = { 1, 2, 3, 4, 5, 6 };
+    packer.pack_bin(sizeof(c));
+    packer.pack_bin_body(c, sizeof(c));
+
+    msgpack::unpacked ret;
+    s_p = nullptr;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
+    EXPECT_TRUE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+TEST(reference, unpack_ext_sized_ref_6)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char const buf [] = { 1, 2, 3, 4, 5 };
+
+    packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6
+    packer.pack_ext_body(buf, sizeof(buf));
+
+    msgpack::unpacked ret;
+    s_p = nullptr;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
+    EXPECT_FALSE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+TEST(reference, unpack_ext_sized_ref_7)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char const buf [] = { 1, 2, 3, 4, 5, 6 };
+
+    packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7
+    packer.pack_ext_body(buf, sizeof(buf));
+
+    msgpack::unpacked ret;
+    s_p = nullptr;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
+    EXPECT_TRUE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+// default reference function
+// STR, BIN, and EXT are always referenced, otherwise copied (converted).
+
+TEST(reference, unpacker_int)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+
+    msgpack::unpacker unp;
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_FALSE(ret.referenced());
+}
+
+TEST(reference, unpacker_string)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, std::string("a"));
+
+    msgpack::unpacker unp;
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_TRUE(ret.referenced());
+}
+
+TEST(reference, unpacker_bin)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char c[] = { 1 };
+    packer.pack_bin(sizeof(c));
+    packer.pack_bin_body(c, sizeof(c));
+
+    msgpack::unpacker unp;
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_TRUE(ret.referenced());
+}
+
+TEST(reference, unpacker_ext)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char const buf [] = { 2 };
+
+    packer.pack_ext(sizeof(buf), 1);
+    packer.pack_ext_body(buf, sizeof(buf));
+
+    msgpack::unpacker unp;
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_TRUE(ret.referenced());
+}
+
+// pass user custom reference function
+
+TEST(reference, unpacker_int_sized_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+
+    msgpack::unpacker unp(never_called, &sbuf);
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    s_p = nullptr;
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_FALSE(ret.referenced());
+    EXPECT_EQ(nullptr, s_p);
+}
+
+TEST(reference, unpacker_string_sized_ref_4)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, std::string("1234"));
+
+    msgpack::unpacker unp(sized_reference, &sbuf);
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    s_p = nullptr;
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_FALSE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+TEST(reference, unpacker_string_sized_ref_5)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, std::string("12345"));
+
+    msgpack::unpacker unp(sized_reference, &sbuf);
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    s_p = nullptr;
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_TRUE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+
+TEST(reference, unpacker_bin_sized_ref_5)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char c[] = { 1, 2, 3, 4, 5 };
+    packer.pack_bin(sizeof(c));
+    packer.pack_bin_body(c, sizeof(c));
+
+    msgpack::unpacker unp(sized_reference, &sbuf);
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    s_p = nullptr;
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_FALSE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+TEST(reference, unpacker_bin_sized_ref_6)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char c[] = { 1, 2, 3, 4, 5, 6 };
+    packer.pack_bin(sizeof(c));
+    packer.pack_bin_body(c, sizeof(c));
+
+    msgpack::unpacker unp(sized_reference, &sbuf);
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    s_p = nullptr;
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_TRUE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+TEST(reference, unpacker_ext_sized_ref_6)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char const buf [] = { 1, 2, 3, 4, 5 };
+
+    packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6
+    packer.pack_ext_body(buf, sizeof(buf));
+
+    msgpack::unpacker unp(sized_reference, &sbuf);
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    s_p = nullptr;
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_FALSE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}
+
+TEST(reference, unpacker_ext_sized_ref_7)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::packer<msgpack::sbuffer> packer(sbuf);
+    char const buf [] = { 1, 2, 3, 4, 5, 6 };
+
+    packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7
+    packer.pack_ext_body(buf, sizeof(buf));
+
+    msgpack::unpacker unp(sized_reference, &sbuf);
+    msgpack::unpacked ret;
+    unp.reserve_buffer(sbuf.size());
+    std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
+    unp.buffer_consumed(sbuf.size());
+    s_p = nullptr;
+    bool b = unp.next(ret);
+    EXPECT_TRUE(b);
+    EXPECT_TRUE(ret.referenced());
+    EXPECT_EQ(&sbuf, s_p);
+}