From 70f950ac05a7323374d68b1456821e7855ada552 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 29 Aug 2019 20:22:10 +0900 Subject: [PATCH] Fixed #806. Removed `ss.str().data()` (the type of ss is std::stringstream). Introduced variable that is const reference of `ss.str()`. --- example/boost/msgpack_variant_mapbased.cpp | 3 +- example/cpp03/class_intrusive.cpp | 5 ++- example/cpp03/class_intrusive_map.cpp | 3 +- example/cpp03/class_non_intrusive.cpp | 5 ++- example/cpp03/map_based_versionup.cpp | 3 +- example/cpp03/reuse_zone.cpp | 5 ++- example/cpp11/container.cpp | 27 ++++++++---- test/array_ref.cpp | 24 +++++++---- test/boost_fusion.cpp | 15 ++++--- test/boost_optional.cpp | 15 ++++--- test/boost_string_ref.cpp | 3 +- test/boost_string_view.cpp | 3 +- test/boost_variant.cpp | 48 ++++++++++++++-------- test/carray.cpp | 24 +++++++---- test/msgpack_cpp11.cpp | 30 ++++++++------ test/msgpack_cpp17.cpp | 33 ++++++++++----- test/raw.cpp | 24 +++++------ test/reference_wrapper_cpp11.cpp | 9 ++-- test/shared_ptr_cpp11.cpp | 9 ++-- test/size_equal_only.cpp | 15 ++++--- test/unique_ptr_cpp11.cpp | 9 ++-- test/visitor.cpp | 3 +- 22 files changed, 203 insertions(+), 112 deletions(-) diff --git a/example/boost/msgpack_variant_mapbased.cpp b/example/boost/msgpack_variant_mapbased.cpp index e36c5dac..0faf48c5 100644 --- a/example/boost/msgpack_variant_mapbased.cpp +++ b/example/boost/msgpack_variant_mapbased.cpp @@ -83,7 +83,8 @@ int main() { u.address = "Tokyo"; msgpack::pack(ss, u); - 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()); msgpack::object const& obj = oh.get(); std::cout << "Unpacked msgpack object." << std::endl; std::cout << obj << std::endl; diff --git a/example/cpp03/class_intrusive.cpp b/example/cpp03/class_intrusive.cpp index c286055d..b37042af 100644 --- a/example/cpp03/class_intrusive.cpp +++ b/example/cpp03/class_intrusive.cpp @@ -82,10 +82,11 @@ int main() { std::stringstream ss; msgpack::pack(ss, my); - print(ss.str()); + std::string const& str = ss.str(); + print(str); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); msgpack::object obj = oh.get(); std::cout << obj << std::endl; assert(obj.as() == my); diff --git a/example/cpp03/class_intrusive_map.cpp b/example/cpp03/class_intrusive_map.cpp index 6cc04ad2..ae7dff7e 100644 --- a/example/cpp03/class_intrusive_map.cpp +++ b/example/cpp03/class_intrusive_map.cpp @@ -59,8 +59,9 @@ int main() { print(ss.str()); + std::string const& str = ss.str(); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); msgpack::object obj = oh.get(); std::cout << obj << std::endl; assert(obj.as() == my); diff --git a/example/cpp03/class_non_intrusive.cpp b/example/cpp03/class_non_intrusive.cpp index 8226f845..9ee58118 100644 --- a/example/cpp03/class_non_intrusive.cpp +++ b/example/cpp03/class_non_intrusive.cpp @@ -100,10 +100,11 @@ int main() { std::stringstream ss; msgpack::pack(ss, my); - print(ss.str()); + std::string const& str = ss.str(); + print(str); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); msgpack::object obj = oh.get(); std::cout << obj << std::endl; assert(obj.as() == my); diff --git a/example/cpp03/map_based_versionup.cpp b/example/cpp03/map_based_versionup.cpp index e64d20b7..6ec996bc 100644 --- a/example/cpp03/map_based_versionup.cpp +++ b/example/cpp03/map_based_versionup.cpp @@ -71,7 +71,8 @@ int main() { print(ss.str()); - 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()); msgpack::object obj = oh.get(); std::cout << obj << std::endl; diff --git a/example/cpp03/reuse_zone.cpp b/example/cpp03/reuse_zone.cpp index 9001e65d..0afd5134 100644 --- a/example/cpp03/reuse_zone.cpp +++ b/example/cpp03/reuse_zone.cpp @@ -31,12 +31,13 @@ int main() { std::size_t offset = 0; // msgpack array is constructed on z. - msgpack::object obj = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset); + std::string const& ps = ss.str(); + msgpack::object obj = msgpack::unpack(z, ps.data(), ps.size(), offset); std::cout << obj << std::endl; assert(obj.as >() == v); // msgpack str is constructed on z. - std::string const& str = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset).as(); + std::string const& str = msgpack::unpack(z, ps.data(), ps.size(), offset).as(); std::cout << str << std::endl; assert(str == s); } diff --git a/example/cpp11/container.cpp b/example/cpp11/container.cpp index 7b8c3e65..59806d83 100644 --- a/example/cpp11/container.cpp +++ b/example/cpp11/container.cpp @@ -37,7 +37,8 @@ void tuple() { std::stringstream ss; msgpack::pack(ss, t); - auto oh = msgpack::unpack(ss.str().data(), ss.str().size()); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size()); auto obj = oh.get(); std::cout << obj << std::endl; @@ -49,7 +50,8 @@ void unordered_map() { std::stringstream ss; msgpack::pack(ss, m); - auto oh = msgpack::unpack(ss.str().data(), ss.str().size()); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size()); msgpack::object obj = oh.get(); std::cout << obj << std::endl; @@ -61,7 +63,8 @@ void unordered_set() { std::stringstream ss; msgpack::pack(ss, s); - auto oh = msgpack::unpack(ss.str().data(), ss.str().size()); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size()); auto obj = oh.get(); std::cout << obj << std::endl; @@ -74,7 +77,8 @@ void forward_list() { std::stringstream ss; msgpack::pack(ss, f); - auto oh = msgpack::unpack(ss.str().data(), ss.str().size()); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size()); auto obj = oh.get(); std::cout << obj << std::endl; @@ -98,7 +102,8 @@ void combi() { std::size_t offset = 0; std::cout << "offset: " << offset << std::endl; { - auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size(), offset); auto obj = oh.get(); std::cout << obj << std::endl; @@ -106,7 +111,8 @@ void combi() { } std::cout << "offset: " << offset << std::endl; { - auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size(), offset); auto obj = oh.get(); std::cout << obj << std::endl; @@ -114,7 +120,8 @@ void combi() { } std::cout << "offset: " << offset << std::endl; { - auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size(), offset); auto obj = oh.get(); std::cout << obj << std::endl; @@ -122,7 +129,8 @@ void combi() { } std::cout << "offset: " << offset << std::endl; { - auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size(), offset); auto obj = oh.get(); std::cout << obj << std::endl; @@ -130,7 +138,8 @@ void combi() { } std::cout << "offset: " << offset << std::endl; { - auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset); + auto const& str = ss.str(); + auto oh = msgpack::unpack(str.data(), str.size(), offset); auto obj = oh.get(); std::cout << obj << std::endl; diff --git a/test/array_ref.cpp b/test/array_ref.cpp index cb58f2c7..b45356ac 100644 --- a/test/array_ref.cpp +++ b/test/array_ref.cpp @@ -25,8 +25,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char) std::stringstream ss; msgpack::pack(ss, ar1); + std::string const& str = ss.str(); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY); std::vector v2; msgpack::type::array_ref > ar2(v2); @@ -47,8 +48,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char_const) std::stringstream ss; msgpack::pack(ss, ar1); + std::string const& str = ss.str(); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY); std::vector v2; msgpack::type::array_ref > ar2(v2); @@ -67,8 +69,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char) std::stringstream ss; msgpack::pack(ss, ar1); + std::string const& str = ss.str(); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY); std::vector v2; msgpack::type::array_ref > ar2(v2); @@ -89,8 +92,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char_const) std::stringstream ss; msgpack::pack(ss, ar1); + std::string const& str = ss.str(); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY); std::vector v2; msgpack::type::array_ref > ar2(v2); @@ -184,8 +188,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char) std::stringstream ss; msgpack::pack(ss, ar1); + std::string const& str = ss.str(); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY); std::array v2; msgpack::type::array_ref > ar2(v2); @@ -203,8 +208,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char_const) std::stringstream ss; msgpack::pack(ss, ar1); + std::string const& str = ss.str(); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY); std::array v2; msgpack::type::array_ref > ar2(v2); @@ -220,8 +226,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char) std::stringstream ss; msgpack::pack(ss, ar1); + std::string const& str = ss.str(); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY); std::array v2; msgpack::type::array_ref > ar2(v2); @@ -239,8 +246,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char_const) std::stringstream ss; msgpack::pack(ss, ar1); + std::string const& str = ss.str(); msgpack::object_handle oh = - msgpack::unpack(ss.str().data(), ss.str().size()); + msgpack::unpack(str.data(), str.size()); EXPECT_EQ(oh.get().type, msgpack::type::ARRAY); std::array v2; msgpack::type::array_ref > ar2(v2); diff --git a/test/boost_fusion.cpp b/test/boost_fusion.cpp index c6859a4b..3b003515 100644 --- a/test/boost_fusion.cpp +++ b/test/boost_fusion.cpp @@ -35,8 +35,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert) val1.f1 = 42; val1.f2 = 123.45; 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()); mystruct val2 = oh.get().as(); EXPECT_TRUE(val1.f1 == val2.f1); EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS); @@ -156,8 +157,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con) std::stringstream ss; mystruct_no_def_con val1(no_def_con1(1), no_def_con2(2), no_def_con1(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()); mystruct_no_def_con val2 = oh.get().as(); EXPECT_TRUE(val1 == val2); } @@ -207,8 +209,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con) std::stringstream ss; mystruct_no_def_con_def_con val1(no_def_con1(1), no_def_con2(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()); mystruct_no_def_con_def_con val2 = oh.get().as(); EXPECT_TRUE(val1 == val2); } @@ -224,8 +227,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair) std::stringstream ss; std::pair val1(false, 42); 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::pair val2 = oh.get().as >(); EXPECT_TRUE(val1.first == val2.first); EXPECT_TRUE(val1.second == val2.second); @@ -240,8 +244,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple) std::stringstream ss; std::tuple val1(false, 42); 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::tuple val2 = oh.get().as >(); EXPECT_TRUE(val1 == val2); } diff --git a/test/boost_optional.cpp b/test/boost_optional.cpp index b029f8c0..9d540252 100644 --- a/test/boost_optional.cpp +++ b/test/boost_optional.cpp @@ -21,8 +21,9 @@ TEST(MSGPACK_BOOST, pack_convert_nil) std::stringstream ss; boost::optional 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()); boost::optional val2 = oh.get().as >(); EXPECT_TRUE(val1 == val2); } @@ -32,8 +33,9 @@ TEST(MSGPACK_BOOST, pack_convert_int) std::stringstream ss; boost::optional 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()); boost::optional val2 = oh.get().as >(); EXPECT_TRUE(val1 == val2); } @@ -49,8 +51,9 @@ TEST(MSGPACK_BOOST, 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(); EXPECT_TRUE(val1 == val2); } @@ -64,8 +67,9 @@ TEST(MSGPACK_BOOST, 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(); EXPECT_TRUE(val1 == val2); } @@ -171,8 +175,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con) std::stringstream ss; boost::optional 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()); boost::optional val2 = oh.get().as>(); EXPECT_TRUE(val1 == val2); } diff --git a/test/boost_string_ref.cpp b/test/boost_string_ref.cpp index 6554cd7c..b6968975 100644 --- a/test/boost_string_ref.cpp +++ b/test/boost_string_ref.cpp @@ -26,7 +26,8 @@ TEST(MSGPACK_BOOST, pack_convert_string_ref) 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()); boost::string_ref val2 = oh.get().as(); EXPECT_TRUE(val1 == val2); } diff --git a/test/boost_string_view.cpp b/test/boost_string_view.cpp index ce02ab5e..97f55f1e 100644 --- a/test/boost_string_view.cpp +++ b/test/boost_string_view.cpp @@ -25,7 +25,8 @@ TEST(MSGPACK_BOOST, pack_convert_string_view) 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()); boost::string_view val2 = oh.get().as(); EXPECT_TRUE(val1 == val2); } diff --git a/test/boost_variant.cpp b/test/boost_variant.cpp index ab9a791f..3c8d0cf3 100644 --- a/test/boost_variant.cpp +++ b/test/boost_variant.cpp @@ -27,8 +27,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil) EXPECT_TRUE(val1.is_nil()); 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_nil()); EXPECT_NO_THROW(boost::get(val2)); @@ -65,8 +66,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil_default) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_nil()); EXPECT_NO_THROW(boost::get(val2)); @@ -104,8 +106,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_bool()); EXPECT_TRUE(val2.as_bool()); @@ -157,8 +160,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_uint64_t()); EXPECT_EQ(val2.as_uint64_t(), 123U); @@ -204,8 +208,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_int64_t()); EXPECT_EQ(val2.as_int64_t(), -123); @@ -251,8 +256,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_float) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_double()); EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS); @@ -298,8 +304,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_str) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_string()); EXPECT_EQ(val2.as_string(), "ABC"); @@ -360,8 +367,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bin) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_vector_char()); EXPECT_EQ(val2.as_vector_char(), v); @@ -431,8 +439,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ext) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_ext()); EXPECT_EQ(val2.as_ext(), e); @@ -498,8 +507,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_vector()); EXPECT_EQ(val2.as_vector(), v); @@ -540,8 +550,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map) 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()); msgpack::type::variant val2 = oh.get().as(); EXPECT_TRUE(val2.is_multimap()); EXPECT_EQ(val2.as_multimap(), v); @@ -584,8 +595,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_str) 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()); msgpack::type::variant_ref val2 = oh.get().as(); EXPECT_TRUE(val2.is_boost_string_ref()); EXPECT_EQ(val2.as_boost_string_ref(), sr); @@ -629,8 +641,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin) 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()); msgpack::type::variant_ref val2 = oh.get().as(); EXPECT_TRUE(val2.is_raw_ref()); EXPECT_EQ(val2.as_raw_ref(), rr); @@ -676,8 +689,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext) 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()); msgpack::type::variant_ref val2 = oh.get().as(); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val2.is_ext_ref()); @@ -726,8 +740,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array) 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()); msgpack::type::variant_ref val2 = oh.get().as(); EXPECT_TRUE(val2.is_vector()); EXPECT_EQ(val2.as_vector(), v); @@ -779,8 +794,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map) 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()); msgpack::type::variant_ref val2 = oh.get().as(); EXPECT_TRUE(val2.is_multimap()); EXPECT_EQ(val2.as_multimap(), v); diff --git a/test/carray.cpp b/test/carray.cpp index 2def7d6f..99bb8b04 100644 --- a/test/carray.cpp +++ b/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(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(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]; diff --git a/test/msgpack_cpp11.cpp b/test/msgpack_cpp11.cpp index 34588bf3..5bf4bdcc 100644 --- a/test/msgpack_cpp11.cpp +++ b/test/msgpack_cpp11.cpp @@ -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(0xd6)); + std::string const& str = ss.str(); + EXPECT_EQ(str.data()[0], static_cast(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(); 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(0xd6)); + std::string const& str = ss.str(); + EXPECT_EQ(str.data()[0], static_cast(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(); 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(0xd7)); + std::string const& str = ss.str(); + EXPECT_EQ(str.data()[0], static_cast(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(); 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().tv_sec)>(0x3ffffffffULL), 999999999 }; msgpack::pack(ss, val1); - EXPECT_EQ(ss.str().data()[0], static_cast(0xd7)); + std::string const& str = ss.str(); + EXPECT_EQ(str.data()[0], static_cast(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(); 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().tv_sec)>(0x7ffffffffULL), 999999999 }; msgpack::pack(ss, val1); - EXPECT_EQ(ss.str().data()[0], static_cast(0xc7)); + std::string const& str = ss.str(); + EXPECT_EQ(str.data()[0], static_cast(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(); 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().tv_sec)>::max(), 999999999 }; msgpack::pack(ss, val1); - EXPECT_EQ(ss.str().data()[0], static_cast(0xc7)); + std::string const& str = ss.str(); + EXPECT_EQ(str.data()[0], static_cast(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(); EXPECT_EQ(val1.tv_sec, val2.tv_sec); EXPECT_EQ(val1.tv_nsec, val2.tv_nsec); diff --git a/test/msgpack_cpp17.cpp b/test/msgpack_cpp17.cpp index 9b596f58..93234172 100644 --- a/test/msgpack_cpp17.cpp +++ b/test/msgpack_cpp17.cpp @@ -27,8 +27,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_nil) std::stringstream ss; std::optional 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 val2 = oh.get().as >(); EXPECT_TRUE(val1 == val2); } @@ -38,8 +39,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_int) std::stringstream ss; std::optional 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 val2 = oh.get().as >(); 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(); 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(); EXPECT_TRUE(val1 == val2); } @@ -177,8 +181,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con) std::stringstream ss; std::optional 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 val2 = oh.get().as>(); 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(); 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(); 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 val2 = oh.get().as>(); 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) { diff --git a/test/raw.cpp b/test/raw.cpp index f3da1fcc..a3cfc313 100644 --- a/test/raw.cpp +++ b/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(); EXPECT_TRUE(rr1 == rr2); } @@ -46,7 +46,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_l) EXPECT_EQ(packed_str[1], static_cast(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(); 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(); 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(); 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(); 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(); 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(); EXPECT_TRUE(rr1 == rr2); } @@ -158,7 +158,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_l) EXPECT_EQ(packed_str[0], static_cast(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(); 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(); 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(); 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(); 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(); EXPECT_TRUE(rr1 == rr2); } diff --git a/test/reference_wrapper_cpp11.cpp b/test/reference_wrapper_cpp11.cpp index 7d08db31..b94ca88d 100644 --- a/test/reference_wrapper_cpp11.cpp +++ b/test/reference_wrapper_cpp11.cpp @@ -20,7 +20,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert) std::reference_wrapper 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 val2(i2); oh.get().convert(val2); @@ -33,7 +34,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert_const) std::reference_wrapper 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 val2(i2); oh.get().convert(val2); @@ -46,7 +48,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_vector) std::vector> 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 val2 = oh.get().as>(); EXPECT_EQ(val2.size(), static_cast(1)); EXPECT_EQ(val1[0], val2[0]); diff --git a/test/shared_ptr_cpp11.cpp b/test/shared_ptr_cpp11.cpp index 8f69d99f..18f34574 100644 --- a/test/shared_ptr_cpp11.cpp +++ b/test/shared_ptr_cpp11.cpp @@ -20,8 +20,9 @@ TEST(SHARED_PTR, pack_convert_nil) std::stringstream ss; std::shared_ptr 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::shared_ptr val2 = oh.get().as>(); EXPECT_TRUE(val1 == val2); } @@ -31,8 +32,9 @@ TEST(SHARED_PTR, pack_convert_int) std::stringstream ss; std::shared_ptr val1(new int(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::shared_ptr val2 = oh.get().as>(); EXPECT_TRUE(*val1 == *val2); } @@ -119,8 +121,9 @@ TEST(SHARED_PTR, pack_convert_nil_no_def_con) std::stringstream ss; std::shared_ptr val1(new 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::shared_ptr val2 = oh.get().as>(); EXPECT_TRUE(*val1 == *val2); } diff --git a/test/size_equal_only.cpp b/test/size_equal_only.cpp index d4b9da48..0fe53ef9 100644 --- a/test/size_equal_only.cpp +++ b/test/size_equal_only.cpp @@ -15,7 +15,8 @@ TEST(size_equal_only, array) msgpack::type::size_equal_only seo(buf); msgpack::pack(ss, seo); - 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 ret_buf1[3]; oh.get().convert(ret_buf1); @@ -58,7 +59,8 @@ TEST(size_equal_only, vector) msgpack::type::size_equal_only > seo(buf); msgpack::pack(ss, seo); - 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 ret_buf1; oh.get().convert(ret_buf1); @@ -91,7 +93,8 @@ TEST(size_equal_only, msgpack_tuple) msgpack::type::size_equal_only > seo(buf); msgpack::pack(ss, seo); - 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()); msgpack::type::tuple ret_buf1; oh.get().convert(ret_buf1); @@ -148,7 +151,8 @@ TEST(size_equal_only, tuple) auto seo = msgpack::type::make_size_equal_only(buf); msgpack::pack(ss, seo); - 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::tuple ret_buf1; oh.get().convert(ret_buf1); @@ -210,7 +214,8 @@ TEST(size_equal_only, custom_class) std::stringstream ss; foo1 f1(42, true); msgpack::pack(ss, f1); - 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()); foo2 f2(123, false, "ABC"); try { diff --git a/test/unique_ptr_cpp11.cpp b/test/unique_ptr_cpp11.cpp index 316e39d1..d28e94e2 100644 --- a/test/unique_ptr_cpp11.cpp +++ b/test/unique_ptr_cpp11.cpp @@ -20,8 +20,9 @@ TEST(UNIQUE_PTR, pack_convert_nil) std::stringstream ss; std::unique_ptr 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::unique_ptr val2 = oh.get().as>(); EXPECT_TRUE(val1 == val2); } @@ -31,8 +32,9 @@ TEST(UNIQUE_PTR, pack_convert_int) std::stringstream ss; std::unique_ptr val1(new int(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::unique_ptr val2 = oh.get().as>(); EXPECT_TRUE(*val1 == *val2); } @@ -119,8 +121,9 @@ TEST(UNIQUE_PTR, pack_convert_nil_no_def_con) std::stringstream ss; std::unique_ptr val1(new 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::unique_ptr val2 = oh.get().as>(); EXPECT_TRUE(*val1 == *val2); } diff --git a/test/visitor.cpp b/test/visitor.cpp index 963f3a61..c3faa69c 100644 --- a/test/visitor.cpp +++ b/test/visitor.cpp @@ -98,7 +98,8 @@ TEST(visitor, json_like) std::string json_like; json_like_visitor v(json_like); std::size_t off = 0; - bool ret = msgpack::parse(ss.str().data(), ss.str().size(), off, v); + std::string const& str = ss.str(); + bool ret = msgpack::parse(str.data(), str.size(), off, v); EXPECT_TRUE(ret); EXPECT_EQ("{\"key\":[42,null,true]}", json_like); }