script_core 0.2.0 → 0.2.5

data/ext/enterprise_script_service/msgpack/test/carray.cpp

@@ -15,7 +15,8 @@ TEST(carray, pack_unpack_int)
     int v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
@@ -44,7 +45,8 @@ TEST(carray, pack_unpack_const_int)
     const int v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
@@ -73,7 +75,8 @@ TEST(carray, pack_unpack_string)
     std::string v1[] = { "ABC", "DEFG" };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     std::string v2[2];
@@ -102,7 +105,8 @@ TEST(carray, pack_unpack_char)
     char v1[] = { 0, 1 };
 
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     char v2[2];
@@ -118,7 +122,8 @@ TEST(carray, pack_unpack_char_as_str)
     char v1[2] = { 1, '\0' };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::STR);
     EXPECT_EQ(oh.get().via.str.size, static_cast<size_t>(1));
 
@@ -164,7 +169,8 @@ TEST(carray, pack_unpack_unsigned_char)
     unsigned char v1[] = { 0, 1 };
 
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     unsigned char v2[2];
@@ -180,7 +186,8 @@ TEST(carray, pack_unpack_unsigned_char_as_bin)
     unsigned char v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::BIN);
     EXPECT_EQ(oh.get().via.bin.size, static_cast<size_t>(2));
 
@@ -226,7 +233,8 @@ TEST(carray, pack_unpack_signed_char)
     signed char v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     signed char v2[2];

data/ext/enterprise_script_service/msgpack/test/msgpack_c.cpp

@@ -1368,3 +1368,45 @@ TEST(MSGPACKC, vref_buffer_overflow)
     EXPECT_FALSE(msgpack_vrefbuffer_init(&vbuf, ref_size, chunk_size));
     EXPECT_EQ(-1, msgpack_vrefbuffer_migrate(&vbuf, &to));
 }
+
+TEST(MSGPACKC, object_print_buffer_overflow) {
+  msgpack_object obj;
+  obj.type = MSGPACK_OBJECT_NIL;
+  char buffer[4];
+
+  int ret;
+  ret = msgpack_object_print_buffer(buffer, 1, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 2, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 3, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 4, obj);
+  EXPECT_EQ(3, ret);
+  EXPECT_STREQ("nil", buffer);
+}
+
+TEST(MSGPACKC, object_bin_print_buffer_overflow) {
+  msgpack_object obj;
+  obj.type = MSGPACK_OBJECT_BIN;
+  obj.via.bin.ptr = "test";
+  obj.via.bin.size = 4;
+  char buffer[7];
+
+  int ret;
+  ret = msgpack_object_print_buffer(buffer, 1, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 2, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 3, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 4, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 5, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 6, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 7, obj);
+  EXPECT_EQ(6, ret);
+  EXPECT_STREQ("\"test\"", buffer);
+}

data/ext/enterprise_script_service/msgpack/test/msgpack_cpp11.cpp

@@ -183,7 +183,7 @@ TEST(MSGPACK_CPP11, simple_buffer_array_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         array<char, kElements> val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1[i] = rand();
+            val1[i] = static_cast<char>(rand());
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -214,7 +214,7 @@ TEST(MSGPACK_CPP11, simple_buffer_array_unsigned_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         array<unsigned char, kElements> val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1[i] = rand();
+            val1[i] = static_cast<unsigned char>(rand());
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -1055,10 +1055,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_zero)
     timespec val1{ 0, 0 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd6));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1080,10 +1081,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_32bit_sec)
     timespec val1{ 0xffffffffUL, 0 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd6));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1105,9 +1107,10 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_max_nano)
     timespec val1{ 0, 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7));
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1130,10 +1133,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_34bit_sec_max_nano)
     timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x3ffffffffULL), 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1157,10 +1161,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_35bit_sec_max_nano)
     timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x7ffffffffULL), 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xc7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1183,10 +1188,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_64bit_sec_max_nano)
     timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::max(), 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xc7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);

data/ext/enterprise_script_service/msgpack/test/msgpack_cpp17.cpp

@@ -27,8 +27,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_nil)
     std::stringstream ss;
     std::optional<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -38,8 +39,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_int)
     std::stringstream ss;
     std::optional<int> val1 = 1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -55,8 +57,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector)
     v.push_back(3);
     val1 = v;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     ovi_t  val2 = oh.get().as<ovi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -70,8 +73,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
     val1[0] = 1;
     val1[2] = 3;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     voi_t  val2 = oh.get().as<voi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -177,8 +181,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con)
     std::stringstream ss;
     std::optional<no_def_con> val1 = no_def_con(1);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<no_def_con> val2 = oh.get().as<std::optional<no_def_con>>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -195,8 +200,9 @@ TEST(MSGPACK_CPP17, string_view_pack_convert)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     std::string_view val2 = oh.get().as<std::string_view>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -230,7 +236,8 @@ TEST(MSGPACK_CPP17, byte_pack_convert)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::byte val2 = oh.get().as<std::byte>();
     EXPECT_EQ(val1, val2);
 }
@@ -263,11 +270,13 @@ TEST(MSGPACK_CPP17, vector_byte_pack_convert)
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(ss.str()[i], packed[i]);
+        std::string const& str = ss.str();
+        EXPECT_EQ(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::vector<std::byte> val2 = oh.get().as<std::vector<std::byte>>();
     EXPECT_EQ(val1, val2);
 }
@@ -308,11 +317,13 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(ss.str()[i], packed[i]);
+        std::string const& str = ss.str();
+        EXPECT_EQ(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::byte val2[sizeof(val1)];
     oh.get().convert(val2);
     for (size_t i = 0; i != sizeof(val1); ++i) {

data/ext/enterprise_script_service/msgpack/test/raw.cpp

@@ -29,7 +29,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack)
     EXPECT_EQ(packed_str[4], 'C');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -46,7 +46,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_l)
     EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -64,7 +64,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_h)
     EXPECT_EQ(packed_str[2], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -83,7 +83,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_l)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -102,7 +102,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_h)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -123,7 +123,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_32_l)
     EXPECT_EQ(packed_str[5], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -142,7 +142,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack)
     EXPECT_EQ(packed_str[3], 'C');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -158,7 +158,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_l)
     EXPECT_EQ(packed_str[0], static_cast<char>(0xa0u));
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -175,7 +175,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_h)
     EXPECT_EQ(packed_str[1], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -194,7 +194,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_l)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -213,7 +213,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_h)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -234,7 +234,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_32_l)
     EXPECT_EQ(packed_str[5], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }

data/ext/enterprise_script_service/msgpack/test/reference_wrapper_cpp11.cpp

@@ -20,7 +20,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert)
     std::reference_wrapper<int> val1(i1);
     std::stringstream ss;
     msgpack::pack(ss, val1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     oh.get().convert(val2);
@@ -33,7 +34,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert_const)
     std::reference_wrapper<const int> val1(i1);
     std::stringstream ss;
     msgpack::pack(ss, val1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     oh.get().convert(val2);
@@ -46,7 +48,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_vector)
     std::vector<std::reference_wrapper<int>> val1{i1};
     std::stringstream ss;
     msgpack::pack(ss, val1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     std::vector<int> val2 = oh.get().as<std::vector<int>>();
     EXPECT_EQ(val2.size(), static_cast<size_t>(1));
     EXPECT_EQ(val1[0], val2[0]);