generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-04-19 15:47:15 +02:00
Code Issues Projects Releases Wiki Activity
msgpack/test/msgpack_basic.cpp
Stephan Lachnit 3788b5ba63
Revert "Merge pull request #1018 from GeorgFritze/cpp_master" 
This reverts commit d13d933eea138215791c209456f38b8055d70cba, reversing
changes made to 05f654fd64de96fdb91d043a70de86a8f6149e9a.
2024-10-24 16:35:11 +02:00

669 lines
20 KiB
C++
Raw Permalink Blame History

#include "msgpack.hpp"
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <deque>
#include <set>
#include <list>
#include <limits>
#define BOOST_TEST_MODULE MSGPACK
#include <boost/test/unit_test.hpp>
#include <boost/mpl/list.hpp>
#if defined(_MSC_VER) || defined(__MINGW32__)
#define msgpack_rand() ((double)rand() / RAND_MAX)
#else // _MSC_VER || __MINGW32__
#define msgpack_rand() drand48()
#endif // _MSC_VER || __MINGW32__
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
using namespace std;
const unsigned int kLoop = 10000;
const unsigned int kElements = 100;
const double kEPS = 1e-10;
#define GEN_TEST(test_type) \
do { \
vector<test_type> v; \
v.push_back(0); \
v.push_back(1); \
v.push_back(2); \
v.push_back(numeric_limits<test_type>::min()); \
v.push_back(numeric_limits<test_type>::max()); \
for (unsigned int i = 0; i < kLoop; i++) \
v.push_back(static_cast<test_type>(rand())); \
for (unsigned int i = 0; i < v.size() ; i++) { \
msgpack::sbuffer sbuf; \
test_type val1 = v[i]; \
msgpack::pack(sbuf, val1); \
msgpack::object_handle oh = \
msgpack::unpack(sbuf.data(), sbuf.size()); \
BOOST_CHECK_EQUAL(val1, oh.get().as<test_type>()); \
} \
} while(0)
BOOST_AUTO_TEST_CASE(simple_buffer_char)
{
GEN_TEST(char);
}
BOOST_AUTO_TEST_CASE(simple_buffer_signed_char)
{
GEN_TEST(signed char);
}
BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_char)
{
GEN_TEST(unsigned char);
}
BOOST_AUTO_TEST_CASE(simple_buffer_short)
{
GEN_TEST(short);
}
BOOST_AUTO_TEST_CASE(simple_buffer_int)
{
GEN_TEST(int);
}
BOOST_AUTO_TEST_CASE(simple_buffer_long)
{
GEN_TEST(long);
}
BOOST_AUTO_TEST_CASE(simple_buffer_long_long)
{
GEN_TEST(long long);
}
BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_short)
{
GEN_TEST(unsigned short);
}
BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_int)
{
GEN_TEST(unsigned int);
}
BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_long)
{
GEN_TEST(unsigned long);
}
BOOST_AUTO_TEST_CASE(simple_buffer_unsigned_long_long)
{
GEN_TEST(unsigned long long);
}
BOOST_AUTO_TEST_CASE(simple_buffer_uint8)
{
GEN_TEST(uint8_t);
}
BOOST_AUTO_TEST_CASE(simple_buffer_uint16)
{
GEN_TEST(uint16_t);
}
BOOST_AUTO_TEST_CASE(simple_buffer_uint32)
{
GEN_TEST(uint32_t);
}
BOOST_AUTO_TEST_CASE(simple_buffer_uint64)
{
GEN_TEST(uint64_t);
}
BOOST_AUTO_TEST_CASE(simple_buffer_int8)
{
GEN_TEST(int8_t);
}
BOOST_AUTO_TEST_CASE(simple_buffer_int16)
{
GEN_TEST(int16_t);
}
BOOST_AUTO_TEST_CASE(simple_buffer_int32)
{
GEN_TEST(int32_t);
}
BOOST_AUTO_TEST_CASE(simple_buffer_int64)
{
GEN_TEST(int64_t);
}
#if !defined(_MSC_VER) || _MSC_VER >=1800
BOOST_AUTO_TEST_CASE(simple_buffer_float)
{
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 < kLoop; i++) {
v.push_back(static_cast<float>(msgpack_rand()));
v.push_back(static_cast<float>(-msgpack_rand()));
}
for (unsigned int i = 0; i < v.size() ; i++) {
msgpack::sbuffer sbuf;
float val1 = v[i];
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
float val2 = oh.get().as<float>();
if (std::isnan(val1))
BOOST_CHECK(std::isnan(val2));
else if (std::isinf(val1))
BOOST_CHECK(std::isinf(val2));
else
BOOST_CHECK(fabs(val2 - val1) <= kEPS);
}
}
#endif // !defined(_MSC_VER) || _MSC_VER >=1800
namespace {
template<typename F, typename I>
struct TypePair {
typedef F float_type;
typedef I integer_type;
};
} // namespace
typedef boost::mpl::list<TypePair<float, signed long long>,
TypePair<float, unsigned long long>,
TypePair<double, signed long long>,
TypePair<double, unsigned long long> > IntegerToFloatingPointTestTypes;
BOOST_AUTO_TEST_CASE_TEMPLATE(simple_buffer, TypeParam, IntegerToFloatingPointTestTypes)
{
typedef typename TypeParam::float_type float_type;
typedef typename TypeParam::integer_type integer_type;
vector<integer_type> v;
v.push_back(0);
v.push_back(1);
if (numeric_limits<integer_type>::is_signed) v.push_back(static_cast<integer_type>(-1));
else v.push_back(2);
for (unsigned int i = 0; i < kLoop; i++) {
v.push_back(static_cast<integer_type>(rand() % 0x7FFFFF));
}
for (unsigned int i = 0; i < v.size() ; i++) {
msgpack::sbuffer sbuf;
integer_type val1 = v[i];
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
float_type val2 = oh.get().as<float_type>();
BOOST_CHECK(fabs(val2 - static_cast<float_type>(val1)) <= kEPS);
}
}
#if !defined(_MSC_VER) || _MSC_VER >=1800
BOOST_AUTO_TEST_CASE(simple_buffer_double)
{
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 < kLoop; i++) {
v.push_back(msgpack_rand());
v.push_back(-msgpack_rand());
}
for (unsigned int i = 0; i < kLoop; i++) {
v.push_back(msgpack_rand());
v.push_back(-msgpack_rand());
}
for (unsigned int i = 0; i < v.size() ; i++) {
msgpack::sbuffer sbuf;
double val1 = v[i];
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
double val2 = oh.get().as<double>();
if (std::isnan(val1))
BOOST_CHECK(std::isnan(val2));
else if (std::isinf(val1))
BOOST_CHECK(std::isinf(val2));
else
BOOST_CHECK(fabs(val2 - val1) <= kEPS);
}
}
#endif // !defined(_MSC_VER) || _MSC_VER >=1800
BOOST_AUTO_TEST_CASE(simple_buffer_nil)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
packer.pack_nil();
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::NIL);
}
BOOST_AUTO_TEST_CASE(simple_buffer_true)
{
msgpack::sbuffer sbuf;
bool val1 = true;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
bool val2 = oh.get().as<bool>();
BOOST_CHECK_EQUAL(val1, val2);
}
BOOST_AUTO_TEST_CASE(simple_buffer_false)
{
msgpack::sbuffer sbuf;
bool val1 = false;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
bool val2 = oh.get().as<bool>();
BOOST_CHECK_EQUAL(val1, val2);
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext1)
{
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::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(1ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
BOOST_CHECK_EQUAL(2, oh.get().via.ext.data()[0]);
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
BOOST_CHECK_EQUAL(1ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
BOOST_CHECK_EQUAL(2, oh2.get().via.ext.data()[0]);
BOOST_CHECK_EQUAL(oh.get(), oh2.get());
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext2)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2, 3 };
packer.pack_ext(sizeof(buf), 0);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(2ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(0, oh.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
BOOST_CHECK_EQUAL(2ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(0, oh2.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
BOOST_CHECK_EQUAL(oh.get(), oh2.get());
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext4)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
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(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(4ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
BOOST_CHECK_EQUAL(4ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
BOOST_CHECK_EQUAL(oh.get(), oh2.get());
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext8)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
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(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(8ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
BOOST_CHECK_EQUAL(8ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
BOOST_CHECK_EQUAL(oh.get(), oh2.get());
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext16)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
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(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(16ul, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
BOOST_CHECK_EQUAL(16ul, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(1, oh2.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
BOOST_CHECK_EQUAL(oh.get(), oh2.get());
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext_1byte_0)
{
std::size_t const size = 0;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
packer.pack_ext(size, 77);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext_1byte_255)
{
std::size_t const size = 255;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
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(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
BOOST_CHECK_EQUAL(oh.get(), oh2.get());
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext_2byte_256)
{
std::size_t const size = 256;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
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(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
BOOST_CHECK_EQUAL(oh.get(), oh2.get());
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext_2byte_65535)
{
std::size_t const size = 65535;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
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(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
BOOST_CHECK_EQUAL(oh.get(), oh2.get());
}
BOOST_AUTO_TEST_CASE(simple_buffer_fixext_4byte_65536)
{
std::size_t const size = 65536;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
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(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
BOOST_CHECK_EQUAL(size, oh2.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh2.get().via.ext.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
BOOST_CHECK_EQUAL(oh.get(), oh2.get());
}
BOOST_AUTO_TEST_CASE(simple_buffer_ext_convert)
{
std::size_t const size = 65536;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
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(sbuf.data(), sbuf.size());
msgpack::type::ext e;
oh.get().convert(e);
BOOST_CHECK_EQUAL(size, e.size());
BOOST_CHECK_EQUAL(77, e.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), e.data()));
}
BOOST_AUTO_TEST_CASE(simple_buffer_ext_pack_convert)
{
std::size_t const size = 65536;
msgpack::sbuffer sbuf;
msgpack::type::ext val1(77, size);
char* buf = val1.data();
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext val2;
oh.get().convert(val2);
BOOST_CHECK_EQUAL(size, val2.size());
BOOST_CHECK_EQUAL(77, val2.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), val2.data()));
}
BOOST_AUTO_TEST_CASE(simple_buffer_ext_ref_convert)
{
std::size_t const size = 65536;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
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(sbuf.data(), sbuf.size());
msgpack::type::ext_ref er;
oh.get().convert(er);
BOOST_CHECK_EQUAL(size, er.size());
BOOST_CHECK_EQUAL(77, er.type());
BOOST_CHECK(
std::equal(buf, buf + sizeof(buf), er.data()));
}
BOOST_AUTO_TEST_CASE(simple_buffer_ext_ref_pack_convert)
{
std::size_t const buf_size = 65536;
std::size_t const data_size = buf_size - 1;
msgpack::sbuffer sbuf;
char buf[buf_size];
buf[0] = static_cast<char>(77);
for (std::size_t i = 0; i != data_size; ++i) buf[i + 1] = static_cast<char>(i);
msgpack::pack(sbuf, msgpack::type::ext_ref(buf, buf_size));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext_ref val2;
oh.get().convert(val2);
BOOST_CHECK_EQUAL(data_size, val2.size());
BOOST_CHECK_EQUAL(77, val2.type());
BOOST_CHECK(
std::equal(&buf[1], &buf[buf_size], val2.data()));
}
BOOST_AUTO_TEST_CASE(simple_buffer_string)
{
for (unsigned int k = 0; k < kLoop; k++) {
string val1;
for (unsigned int i = 0; i < kElements; i++)
val1 += static_cast<char>('a' + rand() % 26);
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR);
string val2 = oh.get().as<string>();
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1, val2);
}
}
Reference in New Issue View Git Blame Copy Permalink