#include "msgpack.hpp" #include <sstream> #include <limits> #if defined(MSGPACK_USE_X3_PARSE) #include <gtest/gtest.h> using namespace std; const double kEPS = 1e-10; TEST(MSGPACK_X3_PARSE, nil_t) { msgpack::type::nil_t v; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_TRUE(oh.get().is_nil()); } TEST(MSGPACK_X3_PARSE, bool_false) { bool v = false; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<bool>()); } TEST(MSGPACK_X3_PARSE, bool_true) { bool v = true; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<bool>()); } TEST(MSGPACK_X3_PARSE, positive_fixint_1) { uint8_t v = 0; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint8_t>()); } TEST(MSGPACK_X3_PARSE, positive_fixint_2) { uint8_t v = 127; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint8_t>()); } TEST(MSGPACK_X3_PARSE, negative_fixint_1) { int8_t v = -1; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int8_t>()); } TEST(MSGPACK_X3_PARSE, negative_fixint_2) { int8_t v = -32; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int8_t>()); } TEST(MSGPACK_X3_PARSE, uint8_1) { uint8_t v = 128U; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint8_t>()); } TEST(MSGPACK_X3_PARSE, uint8_2) { uint8_t v = 0xffU; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint8_t>()); } TEST(MSGPACK_X3_PARSE, uint16_1) { uint16_t v = 0x100U; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint16_t>()); } TEST(MSGPACK_X3_PARSE, uint16_2) { uint16_t v = 0xffffU; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint16_t>()); } TEST(MSGPACK_X3_PARSE, uint32_1) { uint32_t v = 0x10000UL; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint32_t>()); } TEST(MSGPACK_X3_PARSE, uint32_2) { uint32_t v = 0xffffffffUL; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint32_t>()); } TEST(MSGPACK_X3_PARSE, uint64_1) { uint64_t v = 0x100000000ULL; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint64_t>()); } TEST(MSGPACK_X3_PARSE, uint64_2) { uint64_t v = 0xffffffffffffffffULL; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<uint64_t>()); } TEST(MSGPACK_X3_PARSE, int8_1) { int8_t v = 0b11011111; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int8_t>()); } TEST(MSGPACK_X3_PARSE, int8_2) { int8_t v = 0b10000000; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int8_t>()); } TEST(MSGPACK_X3_PARSE, int16_1) { int16_t v = 0xff00; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int16_t>()); } TEST(MSGPACK_X3_PARSE, int16_2) { int16_t v = 0x8000; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int16_t>()); } TEST(MSGPACK_X3_PARSE, int32_1) { int32_t v = 0xff000000L; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int32_t>()); } TEST(MSGPACK_X3_PARSE, int32_2) { int32_t v = 0x80000000L; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int32_t>()); } TEST(MSGPACK_X3_PARSE, int64_1) { int64_t v = 0xff00000000000000LL; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int64_t>()); } TEST(MSGPACK_X3_PARSE, int64_2) { int64_t v = 0x8000000000000000LL; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<int64_t>()); } TEST(MSGPACK_X3_PARSE, array_1) { std::vector<int> v; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<int> >()); } TEST(MSGPACK_X3_PARSE, array_2) { std::vector<int> v; std::stringstream ss; for (int i = 0; i != 0xffU; ++i) v.push_back(i); msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<int> >()); } TEST(MSGPACK_X3_PARSE, array_3) { std::vector<int> v; std::stringstream ss; for (int i = 0; i != 0xffU+1U; ++i) v.push_back(i); msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<int> >()); } TEST(MSGPACK_X3_PARSE, array_4) { std::vector<int> v; std::stringstream ss; for (int i = 0; i != 0xffffU; ++i) v.push_back(i); msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<int> >()); } TEST(MSGPACK_X3_PARSE, array_5) { std::vector<uint32_t> v; std::stringstream ss; for (uint32_t i = 0; i != 0xffffU+1U; ++i) v.push_back(i); msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<uint32_t> >()); } TEST(MSGPACK_X3_PARSE, map_1) { std::map<int, int> v; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, (oh.get().as<std::map<int, int> >())); } TEST(MSGPACK_X3_PARSE, map_2) { std::map<int, int> v; std::stringstream ss; for (int i = 0; i != 0xffU; ++i) v.emplace(i, i); msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, (oh.get().as<std::map<int, int> >())); } TEST(MSGPACK_X3_PARSE, map_3) { std::map<int, int> v; std::stringstream ss; for (int i = 0; i != 0xffU+1U; ++i) v.emplace(i, i); msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, (oh.get().as<std::map<int, int> >())); } TEST(MSGPACK_X3_PARSE, map_4) { std::map<int, int> v; std::stringstream ss; for (int i = 0; i != 0xffffU; ++i) v.emplace(i, i); msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, (oh.get().as<std::map<int, int> >())); } TEST(MSGPACK_X3_PARSE, map_5) { std::map<uint32_t, uint32_t> v; std::stringstream ss; for (uint32_t i = 0; i != 0xffffU+1U; ++i) v.emplace(i, i); msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, (oh.get().as<std::map<uint32_t, uint32_t> >())); } TEST(MSGPACK_X3_PARSE, float_1) { std::vector<float> v; v.push_back(0.0); v.push_back(-0.0); v.push_back(1.0); v.push_back(-1.0); v.push_back(numeric_limits<float>::min()); v.push_back(numeric_limits<float>::max()); v.push_back(nanf("tag")); if (numeric_limits<float>::has_infinity) { v.push_back(numeric_limits<float>::infinity()); v.push_back(-numeric_limits<float>::infinity()); } if (numeric_limits<float>::has_quiet_NaN) { v.push_back(numeric_limits<float>::quiet_NaN()); } if (numeric_limits<float>::has_signaling_NaN) { v.push_back(numeric_limits<float>::signaling_NaN()); } for (unsigned int i = 0; i < v.size() ; i++) { std::stringstream ss; float val1 = v[i]; msgpack::pack(ss, val1); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); float val2 = oh.get().as<float>(); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); else if (std::isinf(val1)) EXPECT_TRUE(std::isinf(val2)); else EXPECT_TRUE(fabs(val2 - val1) <= kEPS); } } TEST(MSGPACK_X3_PARSE, double_1) { std::vector<double> v; v.push_back(0.0); v.push_back(-0.0); v.push_back(1.0); v.push_back(-1.0); v.push_back(numeric_limits<double>::min()); v.push_back(numeric_limits<double>::max()); v.push_back(nanf("tag")); if (numeric_limits<double>::has_infinity) { v.push_back(numeric_limits<double>::infinity()); v.push_back(-numeric_limits<double>::infinity()); } if (numeric_limits<double>::has_quiet_NaN) { v.push_back(numeric_limits<double>::quiet_NaN()); } if (numeric_limits<double>::has_signaling_NaN) { v.push_back(numeric_limits<double>::signaling_NaN()); } for (unsigned int i = 0; i < v.size() ; i++) { std::stringstream ss; double val1 = v[i]; msgpack::pack(ss, val1); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); double val2 = oh.get().as<double>(); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); else if (std::isinf(val1)) EXPECT_TRUE(std::isinf(val2)); else EXPECT_TRUE(fabs(val2 - val1) <= kEPS); } } TEST(MSGPACK_X3_PARSE, string_1) { std::string v; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::string>()); } TEST(MSGPACK_X3_PARSE, string_2) { std::string v; for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back('0'+(i%10)); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::string>()); } TEST(MSGPACK_X3_PARSE, string_3) { std::string v; for (uint64_t i = 0; i != 0xffU; ++i) v.push_back('0'+(i%10)); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::string>()); } TEST(MSGPACK_X3_PARSE, string_4) { std::string v; for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back('0'+(i%10)); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::string>()); } TEST(MSGPACK_X3_PARSE, string_5) { std::string v; for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back('0'+(i%10)); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::string>()); } TEST(MSGPACK_X3_PARSE, string_6) { std::string v; for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back('0'+(i%10)); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::string>()); } TEST(MSGPACK_X3_PARSE, bin_1) { std::vector<char> v; std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<char>>()); } TEST(MSGPACK_X3_PARSE, bin_2) { std::vector<char> v; for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(i%0xff); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<char>>()); } TEST(MSGPACK_X3_PARSE, bin_3) { std::vector<char> v; for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(i%0xff); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<char>>()); } TEST(MSGPACK_X3_PARSE, bin_4) { std::vector<char> v; for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(i%0xff); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<char>>()); } TEST(MSGPACK_X3_PARSE, bin_5) { std::vector<char> v; for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(i%0xff); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<char>>()); } TEST(MSGPACK_X3_PARSE, bin_6) { std::vector<char> v; for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(i%0xff); std::stringstream ss; msgpack::pack(ss, v); auto oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(v, oh.get().as<std::vector<char>>()); } TEST(MSGPACK_X3_PARSE, fixext1) { std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); char const buf [] = { 2 }; packer.pack_ext(sizeof(buf), 1); packer.pack_ext_body(buf, sizeof(buf)); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(1ul, oh.get().via.ext.size); EXPECT_EQ(1, oh.get().via.ext.type()); EXPECT_EQ(2, oh.get().via.ext.data()[0]); } TEST(MSGPACK_X3_PARSE, fixext2) { std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); char const buf [] = { 2, 3 }; packer.pack_ext(sizeof(buf), 0); packer.pack_ext_body(buf, sizeof(buf)); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(2ul, oh.get().via.ext.size); EXPECT_EQ(0, oh.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data())); } TEST(MSGPACK_X3_PARSE, fixext4) { std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); char const buf [] = { 2, 3, 4, 5 }; packer.pack_ext(sizeof(buf), 1); packer.pack_ext_body(buf, sizeof(buf)); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(4ul, oh.get().via.ext.size); EXPECT_EQ(1, oh.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data())); } TEST(MSGPACK_X3_PARSE, fixext8) { std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; packer.pack_ext(sizeof(buf), 1); packer.pack_ext_body(buf, sizeof(buf)); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(8ul, oh.get().via.ext.size); EXPECT_EQ(1, oh.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data())); } TEST(MSGPACK_X3_PARSE, fixext16) { std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; packer.pack_ext(sizeof(buf), 1); packer.pack_ext_body(buf, sizeof(buf)); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(16ul, oh.get().via.ext.size); EXPECT_EQ(1, oh.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data())); } TEST(MSGPACK_X3_PARSE, ext_0) { std::size_t const size = 0; std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); packer.pack_ext(size, 77); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(size, oh.get().via.ext.size); EXPECT_EQ(77, oh.get().via.ext.type()); } TEST(MSGPACK_X3_PARSE, ext_255) { std::size_t const size = 255; std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); char buf[size]; for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i); packer.pack_ext(sizeof(buf), 77); packer.pack_ext_body(buf, sizeof(buf)); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(size, oh.get().via.ext.size); EXPECT_EQ(77, oh.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data())); } TEST(MSGPACK_X3_PARSE, ext_256) { std::size_t const size = 256; std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); char buf[size]; for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i); packer.pack_ext(sizeof(buf), 77); packer.pack_ext_body(buf, sizeof(buf)); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(size, oh.get().via.ext.size); EXPECT_EQ(77, oh.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data())); } TEST(MSGPACK_X3_PARSE, ext_65535) { std::size_t const size = 65535; std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); char buf[size]; for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i); packer.pack_ext(sizeof(buf), 77); packer.pack_ext_body(buf, sizeof(buf)); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(size, oh.get().via.ext.size); EXPECT_EQ(77, oh.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data())); } TEST(MSGPACK_X3_PARSE, ext_65536) { std::size_t const size = 65536; std::stringstream ss; msgpack::packer<std::stringstream> packer(ss); char buf[size]; for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i); packer.pack_ext(sizeof(buf), 77); packer.pack_ext_body(buf, sizeof(buf)); msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end()); EXPECT_EQ(size, oh.get().via.ext.size); EXPECT_EQ(77, oh.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data())); } TEST(MSGPACK_X3_PARSE, unpack_referenced_1) { std::string v = "ABC"; std::stringstream ss; msgpack::pack(ss, v); bool r; msgpack::object_handle oh = msgpack::unpack(ss.str().begin(), ss.str().end(), r); EXPECT_FALSE(r); EXPECT_EQ(v, oh.get().as<std::string>()); } TEST(MSGPACK_X3_PARSE, unpack_referenced_2) { std::string v = "ABC"; std::stringstream ss; msgpack::pack(ss, v); // copy is required because ss.str() returns temporary object. std::string str = ss.str(); bool r; msgpack::object_handle oh = msgpack::unpack( str.begin(), str.end(), r, [](msgpack::type::object_type, std::size_t, void*) { return true; } ); EXPECT_TRUE(r); EXPECT_EQ(v, oh.get().as<std::string>()); } TEST(MSGPACK_X3_PARSE, unpack_zone_1) { std::string v = "ABC"; std::stringstream ss; msgpack::pack(ss, v); msgpack::zone z; msgpack::object obj = msgpack::unpack(z, ss.str().begin(), ss.str().end()); EXPECT_EQ(v, obj.as<std::string>()); } TEST(MSGPACK_X3_PARSE, unpack_zone_2) { std::string v = "ABC"; std::stringstream ss; msgpack::pack(ss, v); msgpack::zone z; bool r; msgpack::object obj = msgpack::unpack(z, ss.str().begin(), ss.str().end(), r); EXPECT_EQ(v, obj.as<std::string>()); EXPECT_FALSE(r); EXPECT_EQ(v, obj.as<std::string>()); } TEST(MSGPACK_X3_PARSE, unpack_zone_3) { std::string v = "ABC"; std::stringstream ss; msgpack::pack(ss, v); // copy is required because ss.str() returns temporary object. std::string str = ss.str(); msgpack::zone z; bool r; msgpack::object obj = msgpack::unpack( z, str.begin(), str.end(), r, [](msgpack::type::object_type, std::size_t, void*) { return true; } ); EXPECT_TRUE(r); EXPECT_EQ(v, obj.as<std::string>()); } #endif // defined(MSGPACK_USE_X3_PARSE)