generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-10-14 06:55:50 +02:00
Code Issues Projects Releases Wiki Activity

Modernize codebase

Browse Source 
- Enhance CMakeLists.txt files.
- Move to Boost Test from Google Test to support pre-C++11 compilers.
- Add more configurations on CI matrix builds.
- Other minor fixes
This commit is contained in:
Daniil Kovalev
2021-07-01 11:17:20 -04:00
committed by GitHub
parent 0af15e45de
commit 7b7615a6d9
80 changed files with 3451 additions and 3799 deletions
Download Patch File Download Diff File Expand all files Collapse all files

318
test/msgpack_x3_parse.cpp
View File

@@ -4,19 +4,11 @@
#include <limits>
#include <cmath>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#define BOOST_TEST_MODULE MSGPACK_X3_PARSE
#include <boost/test/unit_test.hpp>
// To avoid link error
TEST(MSGPACK_X3_PARSE, dummy)
BOOST_AUTO_TEST_CASE(dummy)
{
}
@@ -26,247 +18,247 @@ using namespace std;
const double kEPS = 1e-10;
TEST(MSGPACK_X3_PARSE, nil_t)
BOOST_AUTO_TEST_CASE(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());
BOOST_CHECK(oh.get().is_nil());
}
TEST(MSGPACK_X3_PARSE, bool_false)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<bool>());
}
TEST(MSGPACK_X3_PARSE, bool_true)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<bool>());
}
TEST(MSGPACK_X3_PARSE, positive_fixint_1)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint8_t>());
}
TEST(MSGPACK_X3_PARSE, positive_fixint_2)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint8_t>());
}
TEST(MSGPACK_X3_PARSE, negative_fixint_1)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int8_t>());
}
TEST(MSGPACK_X3_PARSE, negative_fixint_2)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int8_t>());
}
TEST(MSGPACK_X3_PARSE, uint8_1)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint8_t>());
}
TEST(MSGPACK_X3_PARSE, uint8_2)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint8_t>());
}
TEST(MSGPACK_X3_PARSE, uint16_1)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint16_t>());
}
TEST(MSGPACK_X3_PARSE, uint16_2)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint16_t>());
}
TEST(MSGPACK_X3_PARSE, uint32_1)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint32_t>());
}
TEST(MSGPACK_X3_PARSE, uint32_2)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint32_t>());
}
TEST(MSGPACK_X3_PARSE, uint64_1)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint64_t>());
}
TEST(MSGPACK_X3_PARSE, uint64_2)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<uint64_t>());
}
TEST(MSGPACK_X3_PARSE, int8_1)
BOOST_AUTO_TEST_CASE(int8_1)
{
int8_t v = static_cast<int8_t>(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int8_t>());
}
TEST(MSGPACK_X3_PARSE, int8_2)
BOOST_AUTO_TEST_CASE(int8_2)
{
int8_t v = static_cast<int8_t>(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int8_t>());
}
TEST(MSGPACK_X3_PARSE, int16_1)
BOOST_AUTO_TEST_CASE(int16_1)
{
int16_t v = static_cast<int16_t>(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int16_t>());
}
TEST(MSGPACK_X3_PARSE, int16_2)
BOOST_AUTO_TEST_CASE(int16_2)
{
int16_t v = static_cast<int16_t>(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int16_t>());
}
TEST(MSGPACK_X3_PARSE, int32_1)
BOOST_AUTO_TEST_CASE(int32_1)
{
int32_t v = static_cast<int32_t>(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int32_t>());
}
TEST(MSGPACK_X3_PARSE, int32_2)
BOOST_AUTO_TEST_CASE(int32_2)
{
int32_t v = static_cast<int32_t>(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int32_t>());
}
TEST(MSGPACK_X3_PARSE, int64_1)
BOOST_AUTO_TEST_CASE(int64_1)
{
int64_t v = static_cast<int64_t>(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int64_t>());
}
TEST(MSGPACK_X3_PARSE, int64_2)
BOOST_AUTO_TEST_CASE(int64_2)
{
int64_t v = static_cast<int64_t>(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<int64_t>());
}
TEST(MSGPACK_X3_PARSE, array_1)
BOOST_AUTO_TEST_CASE(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> >());
BOOST_CHECK(v == oh.get().as<std::vector<int> >());
}
TEST(MSGPACK_X3_PARSE, array_2)
BOOST_AUTO_TEST_CASE(array_2)
{
std::vector<int> v;
std::stringstream ss;
@@ -274,10 +266,10 @@ TEST(MSGPACK_X3_PARSE, array_2)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<int> >());
BOOST_CHECK(v == oh.get().as<std::vector<int> >());
}
TEST(MSGPACK_X3_PARSE, array_3)
BOOST_AUTO_TEST_CASE(array_3)
{
std::vector<int> v;
std::stringstream ss;
@@ -285,10 +277,10 @@ TEST(MSGPACK_X3_PARSE, array_3)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<int> >());
BOOST_CHECK(v == oh.get().as<std::vector<int> >());
}
TEST(MSGPACK_X3_PARSE, array_4)
BOOST_AUTO_TEST_CASE(array_4)
{
std::vector<int> v;
std::stringstream ss;
@@ -296,10 +288,10 @@ TEST(MSGPACK_X3_PARSE, array_4)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<int> >());
BOOST_CHECK(v == oh.get().as<std::vector<int> >());
}
TEST(MSGPACK_X3_PARSE, array_5)
BOOST_AUTO_TEST_CASE(array_5)
{
std::vector<uint32_t> v;
std::stringstream ss;
@@ -307,20 +299,20 @@ TEST(MSGPACK_X3_PARSE, array_5)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<uint32_t> >());
BOOST_CHECK(v == oh.get().as<std::vector<uint32_t> >());
}
TEST(MSGPACK_X3_PARSE, map_1)
BOOST_AUTO_TEST_CASE(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> >()));
BOOST_CHECK(v == (oh.get().as<std::map<int, int> >()));
}
TEST(MSGPACK_X3_PARSE, map_2)
BOOST_AUTO_TEST_CASE(map_2)
{
std::map<int, int> v;
std::stringstream ss;
@@ -328,10 +320,10 @@ TEST(MSGPACK_X3_PARSE, map_2)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
BOOST_CHECK(v == (oh.get().as<std::map<int, int> >()));
}
TEST(MSGPACK_X3_PARSE, map_3)
BOOST_AUTO_TEST_CASE(map_3)
{
std::map<int, int> v;
std::stringstream ss;
@@ -339,10 +331,10 @@ TEST(MSGPACK_X3_PARSE, map_3)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
BOOST_CHECK(v == (oh.get().as<std::map<int, int> >()));
}
TEST(MSGPACK_X3_PARSE, map_4)
BOOST_AUTO_TEST_CASE(map_4)
{
std::map<int, int> v;
std::stringstream ss;
@@ -350,10 +342,10 @@ TEST(MSGPACK_X3_PARSE, map_4)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
BOOST_CHECK(v == (oh.get().as<std::map<int, int> >()));
}
TEST(MSGPACK_X3_PARSE, map_5)
BOOST_AUTO_TEST_CASE(map_5)
{
std::map<uint32_t, uint32_t> v;
std::stringstream ss;
@@ -361,10 +353,10 @@ TEST(MSGPACK_X3_PARSE, map_5)
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> >()));
BOOST_CHECK(v == (oh.get().as<std::map<uint32_t, uint32_t> >()));
}
TEST(MSGPACK_X3_PARSE, float_1)
BOOST_AUTO_TEST_CASE(float_1)
{
std::vector<float> v;
v.push_back(0.0);
@@ -394,15 +386,15 @@ TEST(MSGPACK_X3_PARSE, float_1)
float val2 = oh.get().as<float>();
if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2));
BOOST_CHECK(std::isnan(val2));
else if (std::isinf(val1))
EXPECT_TRUE(std::isinf(val2));
BOOST_CHECK(std::isinf(val2));
else
EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
BOOST_CHECK(fabs(val2 - val1) <= kEPS);
}
}
TEST(MSGPACK_X3_PARSE, double_1)
BOOST_AUTO_TEST_CASE(double_1)
{
std::vector<double> v;
v.push_back(0.0);
@@ -432,25 +424,25 @@ TEST(MSGPACK_X3_PARSE, double_1)
double val2 = oh.get().as<double>();
if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2));
BOOST_CHECK(std::isnan(val2));
else if (std::isinf(val1))
EXPECT_TRUE(std::isinf(val2));
BOOST_CHECK(std::isinf(val2));
else
EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
BOOST_CHECK(fabs(val2 - val1) <= kEPS);
}
}
TEST(MSGPACK_X3_PARSE, string_1)
BOOST_AUTO_TEST_CASE(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>());
BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_2)
BOOST_AUTO_TEST_CASE(string_2)
{
std::string v;
@@ -460,10 +452,10 @@ TEST(MSGPACK_X3_PARSE, string_2)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_3)
BOOST_AUTO_TEST_CASE(string_3)
{
std::string v;
@@ -473,10 +465,10 @@ TEST(MSGPACK_X3_PARSE, string_3)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_4)
BOOST_AUTO_TEST_CASE(string_4)
{
std::string v;
@@ -486,10 +478,10 @@ TEST(MSGPACK_X3_PARSE, string_4)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_5)
BOOST_AUTO_TEST_CASE(string_5)
{
std::string v;
@@ -499,10 +491,10 @@ TEST(MSGPACK_X3_PARSE, string_5)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_6)
BOOST_AUTO_TEST_CASE(string_6)
{
std::string v;
@@ -512,20 +504,20 @@ TEST(MSGPACK_X3_PARSE, string_6)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, bin_1)
BOOST_AUTO_TEST_CASE(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>>());
BOOST_CHECK(v == oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_2)
BOOST_AUTO_TEST_CASE(bin_2)
{
std::vector<char> v;
@@ -535,10 +527,10 @@ TEST(MSGPACK_X3_PARSE, bin_2)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
BOOST_CHECK(v == oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_3)
BOOST_AUTO_TEST_CASE(bin_3)
{
std::vector<char> v;
@@ -548,10 +540,10 @@ TEST(MSGPACK_X3_PARSE, bin_3)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
BOOST_CHECK(v == oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_4)
BOOST_AUTO_TEST_CASE(bin_4)
{
std::vector<char> v;
@@ -561,10 +553,10 @@ TEST(MSGPACK_X3_PARSE, bin_4)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
BOOST_CHECK(v == oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_5)
BOOST_AUTO_TEST_CASE(bin_5)
{
std::vector<char> v;
@@ -574,10 +566,10 @@ TEST(MSGPACK_X3_PARSE, bin_5)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
BOOST_CHECK(v == oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_6)
BOOST_AUTO_TEST_CASE(bin_6)
{
std::vector<char> v;
@@ -587,10 +579,10 @@ TEST(MSGPACK_X3_PARSE, bin_6)
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
BOOST_CHECK(v == oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, fixext1)
BOOST_AUTO_TEST_CASE(fixext1)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
@@ -600,12 +592,12 @@ TEST(MSGPACK_X3_PARSE, fixext1)
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]);
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]);
}
TEST(MSGPACK_X3_PARSE, fixext2)
BOOST_AUTO_TEST_CASE(fixext2)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
@@ -615,13 +607,13 @@ TEST(MSGPACK_X3_PARSE, fixext2)
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(
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()));
}
TEST(MSGPACK_X3_PARSE, fixext4)
BOOST_AUTO_TEST_CASE(fixext4)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
@@ -631,13 +623,13 @@ TEST(MSGPACK_X3_PARSE, fixext4)
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(
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()));
}
TEST(MSGPACK_X3_PARSE, fixext8)
BOOST_AUTO_TEST_CASE(fixext8)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
@@ -647,13 +639,13 @@ TEST(MSGPACK_X3_PARSE, fixext8)
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(
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()));
}
TEST(MSGPACK_X3_PARSE, fixext16)
BOOST_AUTO_TEST_CASE(fixext16)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
@@ -663,13 +655,13 @@ TEST(MSGPACK_X3_PARSE, fixext16)
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(
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()));
}
TEST(MSGPACK_X3_PARSE, ext_0)
BOOST_AUTO_TEST_CASE(ext_0)
{
std::size_t const size = 0;
std::stringstream ss;
@@ -678,11 +670,11 @@ TEST(MSGPACK_X3_PARSE, ext_0)
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());
BOOST_CHECK_EQUAL(size, oh.get().via.ext.size);
BOOST_CHECK_EQUAL(77, oh.get().via.ext.type());
}
TEST(MSGPACK_X3_PARSE, ext_255)
BOOST_AUTO_TEST_CASE(ext_255)
{
std::size_t const size = 255;
std::stringstream ss;
@@ -694,13 +686,13 @@ TEST(MSGPACK_X3_PARSE, ext_255)
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(
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()));
}
TEST(MSGPACK_X3_PARSE, ext_256)
BOOST_AUTO_TEST_CASE(ext_256)
{
std::size_t const size = 256;
std::stringstream ss;
@@ -712,13 +704,13 @@ TEST(MSGPACK_X3_PARSE, ext_256)
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(
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()));
}
TEST(MSGPACK_X3_PARSE, ext_65535)
BOOST_AUTO_TEST_CASE(ext_65535)
{
std::size_t const size = 65535;
std::stringstream ss;
@@ -730,13 +722,13 @@ TEST(MSGPACK_X3_PARSE, ext_65535)
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(
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()));
}
TEST(MSGPACK_X3_PARSE, ext_65536)
BOOST_AUTO_TEST_CASE(ext_65536)
{
std::size_t const size = 65536;
std::stringstream ss;
@@ -748,13 +740,13 @@ TEST(MSGPACK_X3_PARSE, ext_65536)
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(
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()));
}
TEST(MSGPACK_X3_PARSE, unpack_referenced_1)
BOOST_AUTO_TEST_CASE(unpack_referenced_1)
{
std::string v = "ABC";
std::stringstream ss;
@@ -763,11 +755,11 @@ TEST(MSGPACK_X3_PARSE, unpack_referenced_1)
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>());
BOOST_CHECK(!r);
BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, unpack_referenced_2)
BOOST_AUTO_TEST_CASE(unpack_referenced_2)
{
std::string v = "ABC";
std::stringstream ss;
@@ -785,11 +777,11 @@ TEST(MSGPACK_X3_PARSE, unpack_referenced_2)
return true;
}
);
EXPECT_TRUE(r);
EXPECT_EQ(v, oh.get().as<std::string>());
BOOST_CHECK(r);
BOOST_CHECK_EQUAL(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, unpack_zone_1)
BOOST_AUTO_TEST_CASE(unpack_zone_1)
{
std::string v = "ABC";
std::stringstream ss;
@@ -798,10 +790,10 @@ TEST(MSGPACK_X3_PARSE, unpack_zone_1)
msgpack::zone z;
msgpack::object obj =
msgpack::unpack(z, ss.str().begin(), ss.str().end());
EXPECT_EQ(v, obj.as<std::string>());
BOOST_CHECK_EQUAL(v, obj.as<std::string>());
}
TEST(MSGPACK_X3_PARSE, unpack_zone_2)
BOOST_AUTO_TEST_CASE(unpack_zone_2)
{
std::string v = "ABC";
std::stringstream ss;
@@ -811,13 +803,13 @@ TEST(MSGPACK_X3_PARSE, unpack_zone_2)
bool r;
msgpack::object obj =
msgpack::unpack(z, ss.str().begin(), ss.str().end(), r);
EXPECT_EQ(v, obj.as<std::string>());
BOOST_CHECK_EQUAL(v, obj.as<std::string>());
EXPECT_FALSE(r);
EXPECT_EQ(v, obj.as<std::string>());
BOOST_CHECK(!r);
BOOST_CHECK_EQUAL(v, obj.as<std::string>());
}
TEST(MSGPACK_X3_PARSE, unpack_zone_3)
BOOST_AUTO_TEST_CASE(unpack_zone_3)
{
std::string v = "ABC";
std::stringstream ss;
@@ -837,8 +829,8 @@ TEST(MSGPACK_X3_PARSE, unpack_zone_3)
return true;
}
);
EXPECT_TRUE(r);
EXPECT_EQ(v, obj.as<std::string>());
BOOST_CHECK(r);
BOOST_CHECK_EQUAL(v, obj.as<std::string>());
}
#endif // defined(MSGPACK_USE_X3_PARSE) && MSGPACK_DEFAULT_API_VERSION >= 2