mirror of
https://github.com/msgpack/msgpack-c.git
synced 2025-04-21 08:18:59 +02:00
a6bf728a5c
In MSGPACK_CHECKED_CALL, the return value of snprintf is incorrectly assumed to mean success if it is less than or equal to the buffer size. The call should only be considered a success if the return value is less than the buffer size. This commit adds two unit tests that illustrates the issue and fixes the issue, making the unit tests pass.
1413 lines
44 KiB
C++
1413 lines
44 KiB
C++
#include "msgpack.h"
|
|
|
|
#include <math.h>
|
|
#include <vector>
|
|
#include <limits>
|
|
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wconversion"
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#pragma GCC diagnostic pop
|
|
|
|
#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__
|
|
|
|
using namespace std;
|
|
|
|
const unsigned int kLoop = 10000;
|
|
const double kEPS = 1e-10;
|
|
|
|
#define GEN_TEST_SIGNED(test_type, func_type) \
|
|
do { \
|
|
vector<test_type> v; \
|
|
v.push_back(0); \
|
|
v.push_back(1); \
|
|
v.push_back(-1); \
|
|
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++) { \
|
|
test_type val = v[i]; \
|
|
msgpack_sbuffer sbuf; \
|
|
msgpack_sbuffer_init(&sbuf); \
|
|
msgpack_packer pk; \
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); \
|
|
msgpack_pack_##func_type(&pk, val); \
|
|
msgpack_zone z; \
|
|
msgpack_zone_init(&z, 2048); \
|
|
msgpack_object obj; \
|
|
msgpack_unpack_return ret = \
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); \
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); \
|
|
if (val < 0) { \
|
|
EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, obj.type); \
|
|
EXPECT_EQ(val, obj.via.i64); \
|
|
} else { \
|
|
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); \
|
|
EXPECT_EQ(static_cast<uint64_t>(val), obj.via.u64); \
|
|
} \
|
|
msgpack_zone_destroy(&z); \
|
|
msgpack_sbuffer_destroy(&sbuf); \
|
|
} \
|
|
} while(0)
|
|
|
|
#define GEN_TEST_UNSIGNED(test_type, func_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++) { \
|
|
test_type val = v[i]; \
|
|
msgpack_sbuffer sbuf; \
|
|
msgpack_sbuffer_init(&sbuf); \
|
|
msgpack_packer pk; \
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); \
|
|
msgpack_pack_##func_type(&pk, val); \
|
|
msgpack_zone z; \
|
|
msgpack_zone_init(&z, 2048); \
|
|
msgpack_object obj; \
|
|
msgpack_unpack_return ret = \
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); \
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); \
|
|
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); \
|
|
EXPECT_EQ(val, obj.via.u64); \
|
|
msgpack_zone_destroy(&z); \
|
|
msgpack_sbuffer_destroy(&sbuf); \
|
|
} \
|
|
} while(0)
|
|
|
|
TEST(MSGPACKC, simple_buffer_char)
|
|
{
|
|
#if defined(CHAR_MIN)
|
|
#if CHAR_MIN < 0
|
|
GEN_TEST_SIGNED(char, char);
|
|
#else
|
|
GEN_TEST_UNSIGNED(char, char);
|
|
#endif
|
|
#else
|
|
#error CHAR_MIN is not defined
|
|
#endif
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_singed_char)
|
|
{
|
|
GEN_TEST_SIGNED(signed char, signed_char);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_short)
|
|
{
|
|
GEN_TEST_SIGNED(short, short);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_int)
|
|
{
|
|
GEN_TEST_SIGNED(int, int);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_long)
|
|
{
|
|
GEN_TEST_SIGNED(long, long);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_long_long)
|
|
{
|
|
GEN_TEST_SIGNED(long long, long_long);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_unsigned_char)
|
|
{
|
|
GEN_TEST_UNSIGNED(unsigned char, unsigned_char);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_unsigned_short)
|
|
{
|
|
GEN_TEST_UNSIGNED(unsigned short, unsigned_short);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_unsigned_int)
|
|
{
|
|
GEN_TEST_UNSIGNED(unsigned int, unsigned_int);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_unsigned_long)
|
|
{
|
|
GEN_TEST_UNSIGNED(unsigned long, unsigned_long);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_unsigned_long_long)
|
|
{
|
|
GEN_TEST_UNSIGNED(unsigned long long, unsigned_long_long);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_uint8)
|
|
{
|
|
GEN_TEST_UNSIGNED(uint8_t, uint8);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_uint16)
|
|
{
|
|
GEN_TEST_UNSIGNED(uint16_t, uint16);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_uint32)
|
|
{
|
|
GEN_TEST_UNSIGNED(uint32_t, uint32);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_uint64)
|
|
{
|
|
GEN_TEST_UNSIGNED(uint64_t, uint64);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_int8)
|
|
{
|
|
GEN_TEST_SIGNED(int8_t, int8);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_int16)
|
|
{
|
|
GEN_TEST_SIGNED(int16_t, int16);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_int32)
|
|
{
|
|
GEN_TEST_SIGNED(int32_t, int32);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_int64)
|
|
{
|
|
GEN_TEST_SIGNED(int64_t, int64);
|
|
}
|
|
|
|
#if !defined(_MSC_VER) || _MSC_VER >=1800
|
|
|
|
TEST(MSGPACKC, simple_buffer_float)
|
|
{
|
|
vector<float> v;
|
|
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++) {
|
|
float val = v[i];
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_float(&pk, val);
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_FLOAT32, obj.type);
|
|
if (isnan(val)) {
|
|
EXPECT_TRUE(isnan(obj.via.f64));
|
|
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
|
|
EXPECT_TRUE(isnan(obj.via.dec));
|
|
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
|
|
}
|
|
else if (isinf(val)) {
|
|
EXPECT_TRUE(isinf(obj.via.f64));
|
|
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
|
|
EXPECT_TRUE(isinf(obj.via.dec));
|
|
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
|
|
}
|
|
else {
|
|
EXPECT_TRUE(fabs(obj.via.f64 - val) <= kEPS);
|
|
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
|
|
EXPECT_TRUE(fabs(obj.via.dec - val) <= kEPS);
|
|
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
|
|
}
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
}
|
|
|
|
TEST(MSGPACKC, 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(nan("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 < v.size() ; i++) {
|
|
double val = v[i];
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_double(&pk, val);
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_FLOAT64, obj.type);
|
|
EXPECT_EQ(MSGPACK_OBJECT_FLOAT, obj.type);
|
|
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
|
|
EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type);
|
|
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
|
|
if (isnan(val)) {
|
|
EXPECT_TRUE(isnan(obj.via.f64));
|
|
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
|
|
EXPECT_TRUE(isnan(obj.via.dec));
|
|
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
|
|
}
|
|
else if (isinf(val)) {
|
|
EXPECT_TRUE(isinf(obj.via.f64));
|
|
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
|
|
EXPECT_TRUE(isinf(obj.via.dec));
|
|
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
|
|
}
|
|
else {
|
|
EXPECT_TRUE(fabs(obj.via.f64 - val) <= kEPS);
|
|
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
|
|
EXPECT_TRUE(fabs(obj.via.dec - val) <= kEPS);
|
|
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
|
|
}
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
}
|
|
|
|
#endif // !defined(_MSC_VER) || _MSC_VER >=1800
|
|
|
|
TEST(MSGPACKC, simple_buffer_nil)
|
|
{
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_nil(&pk);
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_NIL, obj.type);
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_true)
|
|
{
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_true(&pk);
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type);
|
|
EXPECT_EQ(true, obj.via.boolean);
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_false)
|
|
{
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_false(&pk);
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, obj.type);
|
|
EXPECT_FALSE(obj.via.boolean);
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext1)
|
|
{
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
char const buf[] = { 2 };
|
|
|
|
msgpack_pack_ext(&pk, sizeof(buf), 1);
|
|
msgpack_pack_ext_body(&pk, buf, sizeof(buf));
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(1u, obj.via.ext.size);
|
|
EXPECT_EQ(1, obj.via.ext.type);
|
|
EXPECT_EQ(2, obj.via.ext.ptr[0]);
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext2)
|
|
{
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
char const buf[] = { 2, 3 };
|
|
|
|
msgpack_pack_ext(&pk, sizeof(buf), 0);
|
|
msgpack_pack_ext_body(&pk, buf, sizeof(buf));
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(2u, obj.via.ext.size);
|
|
EXPECT_EQ(0, obj.via.ext.type);
|
|
EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf)));
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext4)
|
|
{
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
char const buf[] = { 2, 3, 4, 5 };
|
|
|
|
msgpack_pack_ext(&pk, sizeof(buf), 1);
|
|
msgpack_pack_ext_body(&pk, buf, sizeof(buf));
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(4u, obj.via.ext.size);
|
|
EXPECT_EQ(1, obj.via.ext.type);
|
|
EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf)));
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext8)
|
|
{
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 };
|
|
|
|
msgpack_pack_ext(&pk, sizeof(buf), 1);
|
|
msgpack_pack_ext_body(&pk, buf, sizeof(buf));
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(8u, obj.via.ext.size);
|
|
EXPECT_EQ(1, obj.via.ext.type);
|
|
EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf)));
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext16)
|
|
{
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
|
|
|
|
msgpack_pack_ext(&pk, sizeof(buf), 1);
|
|
msgpack_pack_ext_body(&pk, buf, sizeof(buf));
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(16u, obj.via.ext.size);
|
|
EXPECT_EQ(1, obj.via.ext.type);
|
|
EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf)));
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext_1byte_0)
|
|
{
|
|
const size_t size = 0;
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
|
|
msgpack_pack_ext(&pk, size, 77);
|
|
// fprintf(stderr, "size: %u, data: \"", sbuf.size);
|
|
// for (size_t i = 0; i < sbuf.size; i++)
|
|
// fprintf(stderr, "%02x ", (uint8_t)sbuf.data[i]);
|
|
// fprintf(stderr, "\"\n");
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(size, obj.via.ext.size);
|
|
EXPECT_EQ(77, obj.via.ext.type);
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext_1byte_255)
|
|
{
|
|
const size_t size = 255;
|
|
char buf[size];
|
|
for (size_t i = 0; i != size; ++i) buf[i] = (char)i;
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
|
|
msgpack_pack_ext(&pk, size, 78);
|
|
msgpack_pack_ext_body(&pk, buf, sizeof(buf));
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(size, obj.via.ext.size);
|
|
EXPECT_EQ(78, obj.via.ext.type);
|
|
EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf)));
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext_2byte_256)
|
|
{
|
|
const size_t size = 256;
|
|
char buf[size];
|
|
for (size_t i = 0; i != size; ++i) buf[i] = (char)i;
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
|
|
msgpack_pack_ext(&pk, size, 79);
|
|
msgpack_pack_ext_body(&pk, buf, sizeof(buf));
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(size, obj.via.ext.size);
|
|
EXPECT_EQ(79, obj.via.ext.type);
|
|
EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf)));
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext_2byte_65535)
|
|
{
|
|
const size_t size = 65535;
|
|
char buf[size];
|
|
for (size_t i = 0; i != size; ++i) buf[i] = (char)i;
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
|
|
msgpack_pack_ext(&pk, size, 80);
|
|
msgpack_pack_ext_body(&pk, buf, sizeof(buf));
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(size, obj.via.ext.size);
|
|
EXPECT_EQ(80, obj.via.ext.type);
|
|
EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf)));
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_fixext_4byte_65536)
|
|
{
|
|
const size_t size = 65536;
|
|
char buf[size];
|
|
for (size_t i = 0; i != size; ++i) buf[i] = (char)i;
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
|
|
msgpack_pack_ext(&pk, size, 81);
|
|
msgpack_pack_ext_body(&pk, buf, sizeof(buf));
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(size, obj.via.ext.size);
|
|
EXPECT_EQ(81, obj.via.ext.type);
|
|
EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf)));
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_timestamp_32)
|
|
{
|
|
msgpack_timestamp ts = {
|
|
0xffffffff,
|
|
0
|
|
};
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
|
|
msgpack_pack_timestamp(&pk, &ts);
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(4u, obj.via.ext.size);
|
|
EXPECT_EQ(-1, obj.via.ext.type);
|
|
msgpack_timestamp ts2;
|
|
bool r = msgpack_object_to_timestamp(&obj, &ts2);
|
|
|
|
EXPECT_TRUE(r);
|
|
EXPECT_EQ(ts.tv_sec, ts2.tv_sec);
|
|
EXPECT_EQ(ts.tv_nsec, ts2.tv_nsec);
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_timestamp_64)
|
|
{
|
|
msgpack_timestamp ts = {
|
|
0x3ffffffffL,
|
|
999999999
|
|
};
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
|
|
msgpack_pack_timestamp(&pk, &ts);
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(8u, obj.via.ext.size);
|
|
EXPECT_EQ(-1, obj.via.ext.type);
|
|
msgpack_timestamp ts2;
|
|
bool r = msgpack_object_to_timestamp(&obj, &ts2);
|
|
|
|
EXPECT_TRUE(r);
|
|
EXPECT_EQ(ts.tv_sec, ts2.tv_sec);
|
|
EXPECT_EQ(ts.tv_nsec, ts2.tv_nsec);
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_timestamp_96)
|
|
{
|
|
msgpack_timestamp ts = {
|
|
0x7fffffffffffffffLL,
|
|
999999999
|
|
};
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
|
|
msgpack_pack_timestamp(&pk, &ts);
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret =
|
|
msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type);
|
|
EXPECT_EQ(12u, obj.via.ext.size);
|
|
EXPECT_EQ(-1, obj.via.ext.type);
|
|
msgpack_timestamp ts2;
|
|
bool r = msgpack_object_to_timestamp(&obj, &ts2);
|
|
|
|
EXPECT_TRUE(r);
|
|
EXPECT_EQ(ts.tv_sec, ts2.tv_sec);
|
|
EXPECT_EQ(ts.tv_nsec, ts2.tv_nsec);
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_array)
|
|
{
|
|
unsigned int array_size = 5;
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_array(&pk, array_size);
|
|
msgpack_pack_nil(&pk);
|
|
msgpack_pack_true(&pk);
|
|
msgpack_pack_false(&pk);
|
|
msgpack_pack_int(&pk, 10);
|
|
msgpack_pack_int(&pk, -10);
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
|
|
EXPECT_EQ(array_size, obj.via.array.size);
|
|
|
|
for (unsigned int i = 0; i < obj.via.array.size; i++) {
|
|
msgpack_object o = obj.via.array.ptr[i];
|
|
switch (i) {
|
|
case 0:
|
|
EXPECT_EQ(MSGPACK_OBJECT_NIL, o.type);
|
|
break;
|
|
case 1:
|
|
EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, o.type);
|
|
EXPECT_EQ(true, o.via.boolean);
|
|
break;
|
|
case 2:
|
|
EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, o.type);
|
|
EXPECT_FALSE(o.via.boolean);
|
|
break;
|
|
case 3:
|
|
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, o.type);
|
|
EXPECT_EQ(10u, o.via.u64);
|
|
break;
|
|
case 4:
|
|
EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, o.type);
|
|
EXPECT_EQ(-10, o.via.i64);
|
|
break;
|
|
}
|
|
}
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_map)
|
|
{
|
|
unsigned int map_size = 2;
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_map(&pk, map_size);
|
|
msgpack_pack_true(&pk);
|
|
msgpack_pack_false(&pk);
|
|
msgpack_pack_int(&pk, 10);
|
|
msgpack_pack_int(&pk, -10);
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type);
|
|
EXPECT_EQ(map_size, obj.via.map.size);
|
|
|
|
for (unsigned int i = 0; i < map_size; i++) {
|
|
msgpack_object key = obj.via.map.ptr[i].key;
|
|
msgpack_object val = obj.via.map.ptr[i].val;
|
|
switch (i) {
|
|
case 0:
|
|
EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, key.type);
|
|
EXPECT_EQ(true, key.via.boolean);
|
|
EXPECT_EQ(MSGPACK_OBJECT_BOOLEAN, val.type);
|
|
EXPECT_FALSE(val.via.boolean);
|
|
break;
|
|
case 1:
|
|
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, key.type);
|
|
EXPECT_EQ(10u, key.via.u64);
|
|
EXPECT_EQ(MSGPACK_OBJECT_NEGATIVE_INTEGER, val.type);
|
|
EXPECT_EQ(-10, val.via.i64);
|
|
break;
|
|
}
|
|
}
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_str)
|
|
{
|
|
unsigned int str_size = 7;
|
|
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_str(&pk, str_size);
|
|
msgpack_pack_str_body(&pk, "fr", 2);
|
|
msgpack_pack_str_body(&pk, "syuki", 5);
|
|
// invalid data
|
|
msgpack_pack_str_body(&pk, "", 0);
|
|
msgpack_pack_str_body(&pk, "kzk", 0);
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_str_fix_l)
|
|
{
|
|
char const* str = NULL;
|
|
unsigned int str_size = 0;
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_str(&pk, str_size);
|
|
msgpack_pack_str_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0x01u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xa0u));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_str_fix_h)
|
|
{
|
|
char str[0x1f] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_str(&pk, str_size);
|
|
msgpack_pack_str_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0x1f+1u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xbfu));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_str_8_l)
|
|
{
|
|
char str[0x1f+1] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_str(&pk, str_size);
|
|
msgpack_pack_str_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0x1f+1+2u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xd9u));
|
|
EXPECT_EQ(sbuf.data[1], static_cast<char>(0x20u));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_str_8_h)
|
|
{
|
|
char str[0xff] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_str(&pk, str_size);
|
|
msgpack_pack_str_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0xff+2u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xd9u));
|
|
EXPECT_EQ(sbuf.data[1], static_cast<char>(0xffu));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_str_16_l)
|
|
{
|
|
char str[0xff+1] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_str(&pk, str_size);
|
|
msgpack_pack_str_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0xff+1+3u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdau));
|
|
EXPECT_EQ(sbuf.data[1], static_cast<char>(0x01u));
|
|
EXPECT_EQ(sbuf.data[2], static_cast<char>(0x00u));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_str_16_h)
|
|
{
|
|
char str[0xffff] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_str(&pk, str_size);
|
|
msgpack_pack_str_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0xffff+3u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdau));
|
|
EXPECT_EQ(sbuf.data[1], static_cast<char>(0xffu));
|
|
EXPECT_EQ(sbuf.data[2], static_cast<char>(0xffu));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_str_32_l)
|
|
{
|
|
char str[0xffff+1] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_str(&pk, str_size);
|
|
msgpack_pack_str_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0xffff+1+5u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdbu));
|
|
EXPECT_EQ(sbuf.data[1], static_cast<char>(0x00u));
|
|
EXPECT_EQ(sbuf.data[2], static_cast<char>(0x01u));
|
|
EXPECT_EQ(sbuf.data[3], static_cast<char>(0x00u));
|
|
EXPECT_EQ(sbuf.data[4], static_cast<char>(0x00u));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_v4raw_fix_l)
|
|
{
|
|
char const* str = NULL;
|
|
unsigned int str_size = 0;
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_v4raw(&pk, str_size);
|
|
msgpack_pack_v4raw_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0x01u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xa0u));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_v4raw_fix_h)
|
|
{
|
|
char str[0x1f] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_v4raw(&pk, str_size);
|
|
msgpack_pack_v4raw_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0x1f+1u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xbfu));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_v4raw_16_l)
|
|
{
|
|
char str[0x1f+1] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_v4raw(&pk, str_size);
|
|
msgpack_pack_v4raw_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0x1f+1+3u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdau));
|
|
EXPECT_EQ(sbuf.data[1], static_cast<char>(0x00u));
|
|
EXPECT_EQ(sbuf.data[2], static_cast<char>(0x20u));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_v4raw_16_h)
|
|
{
|
|
char str[0xffff] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_v4raw(&pk, str_size);
|
|
msgpack_pack_v4raw_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0xffff+3u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdau));
|
|
EXPECT_EQ(sbuf.data[1], static_cast<char>(0xffu));
|
|
EXPECT_EQ(sbuf.data[2], static_cast<char>(0xffu));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
TEST(MSGPACKC, simple_buffer_v4raw_32_l)
|
|
{
|
|
char str[0xffff+1] = {'0'};
|
|
unsigned int str_size = sizeof(str);
|
|
msgpack_sbuffer sbuf;
|
|
msgpack_sbuffer_init(&sbuf);
|
|
msgpack_packer pk;
|
|
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
|
|
msgpack_pack_v4raw(&pk, str_size);
|
|
msgpack_pack_v4raw_body(&pk, str, str_size);
|
|
EXPECT_EQ(sbuf.size, 0xffff+1+5u);
|
|
EXPECT_EQ(sbuf.data[0], static_cast<char>(0xdbu));
|
|
EXPECT_EQ(sbuf.data[1], static_cast<char>(0x00u));
|
|
EXPECT_EQ(sbuf.data[2], static_cast<char>(0x01u));
|
|
EXPECT_EQ(sbuf.data[3], static_cast<char>(0x00u));
|
|
EXPECT_EQ(sbuf.data[4], static_cast<char>(0x00u));
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp(str, obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
msgpack_sbuffer_destroy(&sbuf);
|
|
}
|
|
|
|
|
|
TEST(MSGPACKC, unpack_fixstr)
|
|
{
|
|
size_t str_size = 7;
|
|
const char buf[] = {
|
|
(char)0xa7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
|
|
};
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
}
|
|
|
|
TEST(MSGPACKC, unpack_str8)
|
|
{
|
|
size_t str_size = 7;
|
|
const char buf[] = {
|
|
(char)0xd9, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
|
|
};
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
}
|
|
|
|
TEST(MSGPACKC, unpack_str16)
|
|
{
|
|
size_t str_size = 7;
|
|
const char buf[] = {
|
|
(char)0xda, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
|
|
};
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
}
|
|
|
|
TEST(MSGPACKC, unpack_str32)
|
|
{
|
|
size_t str_size = 7;
|
|
const char buf[] = {
|
|
(char)0xdb, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
|
|
};
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
|
|
EXPECT_EQ(str_size, obj.via.str.size);
|
|
EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
}
|
|
|
|
TEST(MSGPACKC, unpack_bin8)
|
|
{
|
|
size_t bin_size = 7;
|
|
const char buf[] = {
|
|
(char)0xc4, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
|
|
};
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type);
|
|
EXPECT_EQ(bin_size, obj.via.bin.size);
|
|
EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
}
|
|
|
|
TEST(MSGPACKC, unpack_bin16)
|
|
{
|
|
size_t bin_size = 7;
|
|
const char buf[] = {
|
|
(char)0xc5, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
|
|
};
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type);
|
|
EXPECT_EQ(bin_size, obj.via.bin.size);
|
|
EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
}
|
|
|
|
TEST(MSGPACKC, unpack_bin32)
|
|
{
|
|
size_t bin_size = 7;
|
|
const char buf[] = {
|
|
(char)0xc6, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
|
|
};
|
|
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type);
|
|
EXPECT_EQ(bin_size, obj.via.bin.size);
|
|
EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size));
|
|
|
|
msgpack_zone_destroy(&z);
|
|
}
|
|
|
|
TEST(MSGPACKC, unpack_array_uint64)
|
|
{
|
|
const char buf[] = {
|
|
(char)0x91, (char)0xcf, (char)0xff, (char)0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
|
|
};
|
|
msgpack_zone z;
|
|
msgpack_zone_init(&z, 2048);
|
|
msgpack_object obj;
|
|
msgpack_unpack_return ret;
|
|
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
|
|
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
|
|
EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
|
|
EXPECT_EQ(1u, obj.via.array.size);
|
|
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.via.array.ptr[0].type);
|
|
EXPECT_EQ(0xFFF0000000000001LL, obj.via.array.ptr[0].via.u64);
|
|
msgpack_zone_destroy(&z);
|
|
}
|
|
|
|
|
|
TEST(MSGPACKC, vref_buffer_overflow)
|
|
{
|
|
msgpack_vrefbuffer vbuf;
|
|
msgpack_vrefbuffer to;
|
|
size_t ref_size = 0;
|
|
size_t chunk_size = std::numeric_limits<size_t>::max();
|
|
EXPECT_FALSE(msgpack_vrefbuffer_init(&vbuf, ref_size, chunk_size));
|
|
EXPECT_EQ(-1, msgpack_vrefbuffer_migrate(&vbuf, &to));
|
|
}
|
|
|
|
TEST(MSGPACKC, object_print_buffer_overflow) {
|
|
msgpack_object obj;
|
|
obj.type = MSGPACK_OBJECT_NIL;
|
|
char buffer[4];
|
|
|
|
int ret;
|
|
ret = msgpack_object_print_buffer(buffer, 1, obj);
|
|
EXPECT_EQ(0, ret);
|
|
ret = msgpack_object_print_buffer(buffer, 2, obj);
|
|
EXPECT_EQ(0, ret);
|
|
ret = msgpack_object_print_buffer(buffer, 3, obj);
|
|
EXPECT_EQ(0, ret);
|
|
ret = msgpack_object_print_buffer(buffer, 4, obj);
|
|
EXPECT_EQ(3, ret);
|
|
EXPECT_STREQ("nil", buffer);
|
|
}
|
|
|
|
TEST(MSGPACKC, object_bin_print_buffer_overflow) {
|
|
msgpack_object obj;
|
|
obj.type = MSGPACK_OBJECT_BIN;
|
|
obj.via.bin.ptr = "test";
|
|
obj.via.bin.size = 4;
|
|
char buffer[7];
|
|
|
|
int ret;
|
|
ret = msgpack_object_print_buffer(buffer, 1, obj);
|
|
EXPECT_EQ(0, ret);
|
|
ret = msgpack_object_print_buffer(buffer, 2, obj);
|
|
EXPECT_EQ(0, ret);
|
|
ret = msgpack_object_print_buffer(buffer, 3, obj);
|
|
EXPECT_EQ(0, ret);
|
|
ret = msgpack_object_print_buffer(buffer, 4, obj);
|
|
EXPECT_EQ(0, ret);
|
|
ret = msgpack_object_print_buffer(buffer, 5, obj);
|
|
EXPECT_EQ(0, ret);
|
|
ret = msgpack_object_print_buffer(buffer, 6, obj);
|
|
EXPECT_EQ(0, ret);
|
|
ret = msgpack_object_print_buffer(buffer, 7, obj);
|
|
EXPECT_EQ(6, ret);
|
|
EXPECT_STREQ("\"test\"", buffer);
|
|
}
|