libmsgpack/msgpack-c/test/msgpack_basic.cpp

#include "msgpack.hpp"

#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <deque>
#include <set>
#include <list>
#include <limits>

#include <gtest/gtest.h>

#if defined(_MSC_VER)
#define msgpack_rand() ((double)rand() / RAND_MAX)
#else  // _MSC_VER
#define msgpack_rand() drand48()
#endif // _MSC_VER

#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(rand());                                            \
    for (unsigned int i = 0; i < v.size() ; i++) {                    \
      msgpack::sbuffer sbuf;                                          \
      test_type val1 = v[i];                                          \
      msgpack::pack(sbuf, val1);                                      \
      msgpack::unpacked ret;                                          \
      msgpack::unpack(ret, sbuf.data(), sbuf.size());                 \
      EXPECT_EQ(val1, ret.get().as<test_type>());                     \
    }                                                                 \
} while(0)

TEST(MSGPACK, simple_buffer_char)
{
  GEN_TEST(char);
}

TEST(MSGPACK, simple_buffer_signed_char)
{
  GEN_TEST(signed char);
}

TEST(MSGPACK, simple_buffer_unsigned_char)
{
  GEN_TEST(unsigned char);
}


TEST(MSGPACK, simple_buffer_short)
{
  GEN_TEST(short);
}

TEST(MSGPACK, simple_buffer_int)
{
  GEN_TEST(int);
}

TEST(MSGPACK, simple_buffer_long)
{
  GEN_TEST(long);
}

TEST(MSGPACK, simple_buffer_long_long)
{
  GEN_TEST(long long);
}

TEST(MSGPACK, simple_buffer_unsigned_short)
{
  GEN_TEST(unsigned short);
}

TEST(MSGPACK, simple_buffer_unsigned_int)
{
  GEN_TEST(unsigned int);
}

TEST(MSGPACK, simple_buffer_unsigned_long)
{
  GEN_TEST(unsigned long);
}

TEST(MSGPACK, simple_buffer_unsigned_long_long)
{
  GEN_TEST(unsigned long long);
}

TEST(MSGPACK, simple_buffer_uint8)
{
  GEN_TEST(uint8_t);
}

TEST(MSGPACK, simple_buffer_uint16)
{
  GEN_TEST(uint16_t);
}

TEST(MSGPACK, simple_buffer_uint32)
{
  GEN_TEST(uint32_t);
}

TEST(MSGPACK, simple_buffer_uint64)
{
  GEN_TEST(uint64_t);
}

TEST(MSGPACK, simple_buffer_int8)
{
  GEN_TEST(int8_t);
}

TEST(MSGPACK, simple_buffer_int16)
{
  GEN_TEST(int16_t);
}

TEST(MSGPACK, simple_buffer_int32)
{
  GEN_TEST(int32_t);
}

TEST(MSGPACK, simple_buffer_int64)
{
  GEN_TEST(int64_t);
}

TEST(MSGPACK, 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::unpacked ret;
    msgpack::unpack(ret, sbuf.data(), sbuf.size());
    float val2 = ret.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);
  }
}

namespace {
template<typename F, typename I>
struct TypePair {
  typedef F float_type;
  typedef I integer_type;
};
} // namespace

template <typename T>
class IntegerToFloatingPointTest : public testing::Test {
};
TYPED_TEST_CASE_P(IntegerToFloatingPointTest);

TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
{
  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(-1);
  else v.push_back(2);
  for (unsigned int i = 0; i < kLoop; i++) {
    v.push_back(rand() % 0x7FFFFF);
  }
  for (unsigned int i = 0; i < v.size() ; i++) {
    msgpack::sbuffer sbuf;
    integer_type val1 = v[i];
    msgpack::pack(sbuf, val1);
    msgpack::unpacked ret;
    msgpack::unpack(ret, sbuf.data(), sbuf.size());
    float_type val2 = ret.get().as<float_type>();
    EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
  }
}

REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest,
                           simple_buffer);

typedef testing::Types<TypePair<float, signed long long>,
                       TypePair<float, unsigned long long>,
                       TypePair<double, signed long long>,
                       TypePair<double, unsigned long long> > IntegerToFloatingPointTestTypes;
INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance,
                              IntegerToFloatingPointTest,
                              IntegerToFloatingPointTestTypes);

TEST(MSGPACK, 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::unpacked ret;
    msgpack::unpack(ret, sbuf.data(), sbuf.size());
    double val2 = ret.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, simple_buffer_nil)
{
  msgpack::sbuffer sbuf;
  msgpack::packer<msgpack::sbuffer> packer(sbuf);
  packer.pack_nil();
  msgpack::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(ret.get().type, msgpack::type::NIL);
}

TEST(MSGPACK, simple_buffer_true)
{
  msgpack::sbuffer sbuf;
  bool val1 = true;
  msgpack::pack(sbuf, val1);
  msgpack::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  bool val2 = ret.get().as<bool>();
  EXPECT_EQ(val1, val2);
}

TEST(MSGPACK, simple_buffer_false)
{
  msgpack::sbuffer sbuf;
  bool val1 = false;
  msgpack::pack(sbuf, val1);
  msgpack::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  bool val2 = ret.get().as<bool>();
  EXPECT_EQ(val1, val2);
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(1ul, ret.get().via.ext.size);
  EXPECT_EQ(1, ret.get().via.ext.type());
  EXPECT_EQ(2, ret.get().via.ext.data()[0]);
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(2ul, ret.get().via.ext.size);
  EXPECT_EQ(0, ret.get().via.ext.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(4ul, ret.get().via.ext.size);
  EXPECT_EQ(1, ret.get().via.ext.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(8ul, ret.get().via.ext.size);
  EXPECT_EQ(1, ret.get().via.ext.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(16ul, ret.get().via.ext.size);
  EXPECT_EQ(1, ret.get().via.ext.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(size, ret.get().via.ext.size);
  EXPECT_EQ(77, ret.get().via.ext.type());
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(size, ret.get().via.ext.size);
  EXPECT_EQ(77, ret.get().via.ext.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(size, ret.get().via.ext.size);
  EXPECT_EQ(77, ret.get().via.ext.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(size, ret.get().via.ext.size);
  EXPECT_EQ(77, ret.get().via.ext.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  EXPECT_EQ(size, ret.get().via.ext.size);
  EXPECT_EQ(77, ret.get().via.ext.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  msgpack::type::ext e;
  ret.get().convert(e);
  EXPECT_EQ(size, e.size());
  EXPECT_EQ(77, e.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), e.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  msgpack::type::ext val2;
  ret.get().convert(val2);
  EXPECT_EQ(size, val2.size());
  EXPECT_EQ(77, val2.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), val2.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  msgpack::type::ext_ref er;
  ret.get().convert(er);
  EXPECT_EQ(size, er.size());
  EXPECT_EQ(77, er.type());
  EXPECT_TRUE(
      std::equal(buf, buf + sizeof(buf), er.data()));
}

TEST(MSGPACK, 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::unpacked ret;
  msgpack::unpack(ret, sbuf.data(), sbuf.size());
  msgpack::type::ext_ref val2;
  ret.get().convert(val2);
  EXPECT_EQ(data_size, val2.size());
  EXPECT_EQ(77, val2.type());
  EXPECT_TRUE(
      std::equal(&buf[1], &buf[buf_size], val2.data()));
}

TEST(MSGPACK_STL, simple_buffer_string)
{
  for (unsigned int k = 0; k < kLoop; k++) {
    string val1;
    for (unsigned int i = 0; i < kElements; i++)
      val1 += 'a' + rand() % 26;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::unpacked ret;
    msgpack::unpack(ret, sbuf.data(), sbuf.size());
    EXPECT_EQ(ret.get().type, msgpack::type::STR);
    string val2 = ret.get().as<string>();
    EXPECT_EQ(val1.size(), val2.size());
    EXPECT_EQ(val1, val2);
  }
}

TEST(MSGPACK_STL, simple_buffer_cstring)
{
  for (unsigned int k = 0; k < kLoop; k++) {
    string val1;
    for (unsigned int i = 0; i < kElements; i++)
      val1 += 'a' + rand() % 26;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1.c_str());
    msgpack::unpacked ret;
    msgpack::unpack(ret, sbuf.data(), sbuf.size());
    EXPECT_EQ(ret.get().type, msgpack::type::STR);
    string val2 = ret.get().as<string>();
    EXPECT_EQ(val1.size(), val2.size());
    EXPECT_EQ(val1, val2);
  }
}

TEST(MSGPACK_STL, simple_buffer_non_const_cstring)
{
  for (unsigned int k = 0; k < kLoop; k++) {
    string val1;
    for (unsigned int i = 0; i < kElements; i++)
      val1 += 'a' + rand() % 26;
    msgpack::sbuffer sbuf;
    char* s = new char[val1.size() + 1];
    std::memcpy(s, val1.c_str(), val1.size() + 1);
    msgpack::pack(sbuf, s);
    delete [] s;
    msgpack::unpacked ret;
    msgpack::unpack(ret, sbuf.data(), sbuf.size());
    EXPECT_EQ(ret.get().type, msgpack::type::STR);
    string val2 = ret.get().as<string>();
    EXPECT_EQ(val1.size(), val2.size());
    EXPECT_EQ(val1, val2);
  }
}