generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-10-14 15:05:37 +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

178
test/msgpack_cpp17.cpp
View File

@@ -1,32 +1,24 @@
#include <msgpack.hpp>
#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_CPP17
#include <boost/test/unit_test.hpp>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
// To avoid link error
TEST(MSGPACK_CPP17, dummy)
// For C++ standards lower than C++17
BOOST_AUTO_TEST_CASE(dummy)
{
}
#if !defined(MSGPACK_USE_CPP03) && __cplusplus >= 201703
#if MSGPACK_CPP_VERSION >= 201703
// C++17
#if MSGPACK_HAS_INCLUDE(<optional>)
TEST(MSGPACK_CPP17, optional_pack_convert_nil)
BOOST_AUTO_TEST_CASE(optional_pack_convert_nil)
{
std::stringstream ss;
std::optional<int> val1;
@@ -35,10 +27,10 @@ TEST(MSGPACK_CPP17, optional_pack_convert_nil)
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::optional<int> val2 = oh.get().as<std::optional<int> >();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_pack_convert_int)
BOOST_AUTO_TEST_CASE(optional_pack_convert_int)
{
std::stringstream ss;
std::optional<int> val1 = 1;
@@ -47,10 +39,10 @@ TEST(MSGPACK_CPP17, optional_pack_convert_int)
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::optional<int> val2 = oh.get().as<std::optional<int> >();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_pack_convert_vector)
BOOST_AUTO_TEST_CASE(optional_pack_convert_vector)
{
typedef std::optional<std::vector<int> > ovi_t;
std::stringstream ss;
@@ -65,10 +57,10 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector)
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
ovi_t val2 = oh.get().as<ovi_t>();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
BOOST_AUTO_TEST_CASE(optional_pack_convert_vector_optional)
{
typedef std::vector<std::optional<int> > voi_t;
std::stringstream ss;
@@ -81,28 +73,28 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
voi_t val2 = oh.get().as<voi_t>();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_object_nil)
BOOST_AUTO_TEST_CASE(optional_object_nil)
{
std::optional<int> val1;
msgpack::object obj(val1);
std::optional<int> val2 = obj.as<std::optional<int> >();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_object_int)
BOOST_AUTO_TEST_CASE(optional_object_int)
{
std::optional<int> val1 = 1;
msgpack::object obj(val1);
std::optional<int> val2 = obj.as<std::optional<int> >();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
// Compile error as expected
/*
TEST(MSGPACK_CPP17, optional_object_vector)
BOOST_AUTO_TEST_CASE(optional_object_vector)
{
typedef std::optional<std::vector<int> > ovi_t;
ovi_t val1;
@@ -113,29 +105,29 @@ TEST(MSGPACK_CPP17, optional_object_int)
val1 = v;
msgpack::object obj(val1);
ovi_t val2 = obj.as<ovi_t>();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
*/
TEST(MSGPACK_CPP17, optional_object_with_zone_nil)
BOOST_AUTO_TEST_CASE(optional_object_with_zone_nil)
{
msgpack::zone z;
std::optional<int> val1;
msgpack::object obj(val1, z);
std::optional<int> val2 = obj.as<std::optional<int> >();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_object_with_zone_int)
BOOST_AUTO_TEST_CASE(optional_object_with_zone_int)
{
msgpack::zone z;
std::optional<int> val1 = 1;
msgpack::object obj(val1, z);
std::optional<int> val2 = obj.as<std::optional<int> >();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_object_with_zone_vector_optional)
BOOST_AUTO_TEST_CASE(optional_object_with_zone_vector_optional)
{
typedef std::vector<std::optional<int> > voi_t;
msgpack::zone z;
@@ -145,7 +137,7 @@ TEST(MSGPACK_CPP17, optional_object_with_zone_vector_optional)
val1[2] = 3;
msgpack::object obj(val1, z);
voi_t val2 = obj.as<voi_t>();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
struct no_def_con {
@@ -180,7 +172,7 @@ struct as<no_def_con> {
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // msgpack
TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con)
BOOST_AUTO_TEST_CASE(optional_pack_convert_no_def_con)
{
std::stringstream ss;
std::optional<no_def_con> val1 = no_def_con(1);
@@ -189,14 +181,14 @@ TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con)
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::optional<no_def_con> val2 = oh.get().as<std::optional<no_def_con>>();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
#endif // MSGPACK_HAS_INCLUDE(<optional>)
#if MSGPACK_HAS_INCLUDE(<string_view>)
TEST(MSGPACK_CPP17, string_view_pack_convert)
BOOST_AUTO_TEST_CASE(string_view_pack_convert)
{
std::stringstream ss;
std::string s = "ABC";
@@ -208,31 +200,31 @@ TEST(MSGPACK_CPP17, string_view_pack_convert)
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
std::string_view val2 = oh.get().as<std::string_view>();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, string_view_object)
BOOST_AUTO_TEST_CASE(string_view_object)
{
std::string s = "ABC";
std::string_view val1(s);
msgpack::object obj(val1);
std::string_view val2 = obj.as<std::string_view>();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, string_view_object_with_zone)
BOOST_AUTO_TEST_CASE(string_view_object_with_zone)
{
msgpack::zone z;
std::string s = "ABC";
std::string_view val1(s);
msgpack::object obj(val1, z);
std::string_view val2 = obj.as<std::string_view>();
EXPECT_TRUE(val1 == val2);
BOOST_CHECK(val1 == val2);
}
#endif // MSGPACK_HAS_INCLUDE(<string_view>)
TEST(MSGPACK_CPP17, byte_pack_convert)
BOOST_AUTO_TEST_CASE(byte_pack_convert)
{
std::stringstream ss;
std::byte val1{0xff};
@@ -243,27 +235,27 @@ TEST(MSGPACK_CPP17, byte_pack_convert)
std::string const& str = ss.str();
msgpack::unpack(oh, str.data(), str.size());
std::byte val2 = oh.get().as<std::byte>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, byte_object)
BOOST_AUTO_TEST_CASE(byte_object)
{
std::byte val1{0x00};
msgpack::object obj(val1);
std::byte val2 = obj.as<std::byte>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, byte_object_with_zone)
BOOST_AUTO_TEST_CASE(byte_object_with_zone)
{
msgpack::zone z;
std::byte val1{80};
msgpack::object obj(val1, z);
std::byte val2 = obj.as<std::byte>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, vector_byte_pack_convert)
BOOST_AUTO_TEST_CASE(vector_byte_pack_convert)
{
std::stringstream ss;
std::vector<std::byte> val1{
@@ -274,18 +266,18 @@ TEST(MSGPACK_CPP17, vector_byte_pack_convert)
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
EXPECT_EQ(str.size(), sizeof(packed));
BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
EXPECT_EQ(str[i], packed[i]);
BOOST_CHECK_EQUAL(str[i], packed[i]);
}
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
std::vector<std::byte> val2 = oh.get().as<std::vector<std::byte>>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, vector_byte_object)
BOOST_AUTO_TEST_CASE(vector_byte_object)
{
std::vector<std::byte> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
@@ -295,10 +287,10 @@ TEST(MSGPACK_CPP17, vector_byte_object)
msgpack::object obj(val1);
std::vector<std::byte> val2 = obj.as<std::vector<std::byte>>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, vector_byte_object_with_zone)
BOOST_AUTO_TEST_CASE(vector_byte_object_with_zone)
{
msgpack::zone z;
std::vector<std::byte> val1{
@@ -307,10 +299,10 @@ TEST(MSGPACK_CPP17, vector_byte_object_with_zone)
msgpack::object obj(val1, z);
std::vector<std::byte> val2 = obj.as<std::vector<std::byte>>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
}
TEST(MSGPACK_CPP17, array_byte_pack_convert)
BOOST_AUTO_TEST_CASE(array_byte_pack_convert)
{
std::stringstream ss;
std::array<std::byte, 5> val1{
@@ -321,27 +313,27 @@ TEST(MSGPACK_CPP17, array_byte_pack_convert)
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
EXPECT_EQ(str.size(), sizeof(packed));
BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
EXPECT_EQ(str[i], packed[i]);
BOOST_CHECK_EQUAL(str[i], packed[i]);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
auto val2 = oh.get().as<std::array<std::byte, 5>>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
EXPECT_THROW((oh.get().as<std::array<std::byte, 0>>()), msgpack::type_error);
EXPECT_THROW((oh.get().as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 0>>()), msgpack::type_error);
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
}
TEST(MSGPACK_CPP17, array_byte_object)
BOOST_AUTO_TEST_CASE(array_byte_object)
{
std::array<std::byte, 5> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
@@ -351,14 +343,14 @@ TEST(MSGPACK_CPP17, array_byte_object)
msgpack::object obj(val1);
auto val2 = obj.as<std::array<std::byte, 5>>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
EXPECT_THROW((obj.as<std::array<std::byte, 0>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 0>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
TEST(MSGPACK_CPP17, array_byte_object_with_zone)
BOOST_AUTO_TEST_CASE(array_byte_object_with_zone)
{
msgpack::zone z;
std::array<std::byte, 5> val1{
@@ -367,14 +359,14 @@ TEST(MSGPACK_CPP17, array_byte_object_with_zone)
msgpack::object obj(val1, z);
auto val2 = obj.as<std::array<std::byte, 5>>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
EXPECT_THROW((obj.as<std::array<std::byte, 0>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 0>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
TEST(MSGPACK_CPP17, array_byte_empty_pack_convert)
BOOST_AUTO_TEST_CASE(array_byte_empty_pack_convert)
{
std::stringstream ss;
std::array<std::byte, 0> val1{};
@@ -383,26 +375,26 @@ TEST(MSGPACK_CPP17, array_byte_empty_pack_convert)
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x00) };
EXPECT_EQ(str.size(), sizeof(packed));
BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
EXPECT_EQ(str[i], packed[i]);
BOOST_CHECK_EQUAL(str[i], packed[i]);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
auto val2 = oh.get().as<std::array<std::byte, 0>>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
}
{
msgpack::object_handle oh;
msgpack::unpack(oh, str.data(), str.size());
EXPECT_THROW((oh.get().as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((oh.get().as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
}
TEST(MSGPACK_CPP17, array_byte_empty_object)
BOOST_AUTO_TEST_CASE(array_byte_empty_object)
{
std::array<std::byte, 0> val1{};
@@ -410,26 +402,26 @@ TEST(MSGPACK_CPP17, array_byte_empty_object)
msgpack::object obj(val1);
auto val2 = obj.as<std::array<std::byte, 0>>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
EXPECT_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
TEST(MSGPACK_CPP17, array_byte_empty_object_with_zone)
BOOST_AUTO_TEST_CASE(array_byte_empty_object_with_zone)
{
msgpack::zone z;
std::array<std::byte, 0> val1{};
msgpack::object obj(val1, z);
auto val2 = obj.as<std::array<std::byte, 0>>();
EXPECT_EQ(val1, val2);
BOOST_CHECK(val1 == val2);
EXPECT_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
EXPECT_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 1>>()), msgpack::type_error);
BOOST_CHECK_THROW((obj.as<std::array<std::byte, 8192>>()), msgpack::type_error);
}
TEST(MSGPACK_CPP17, carray_byte_pack_convert)
BOOST_AUTO_TEST_CASE(carray_byte_pack_convert)
{
std::stringstream ss;
std::byte val1[] = {
@@ -440,9 +432,9 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
std::string const& str = ss.str();
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
EXPECT_EQ(str.size(), sizeof(packed));
BOOST_CHECK_EQUAL(str.size(), sizeof(packed));
for (size_t i = 0; i != sizeof(packed); ++i) {
EXPECT_EQ(str[i], packed[i]);
BOOST_CHECK_EQUAL(str[i], packed[i]);
}
msgpack::object_handle oh;
@@ -450,11 +442,11 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
std::byte val2[sizeof(val1)];
oh.get().convert(val2);
for (size_t i = 0; i != sizeof(val1); ++i) {
EXPECT_EQ(val1[i], val2[i]);
BOOST_CHECK(val1[i] == val2[i]);
}
}
TEST(MSGPACK_CPP17, carray_byte_object_with_zone)
BOOST_AUTO_TEST_CASE(carray_byte_object_with_zone)
{
msgpack::zone z;
std::byte val1[] = {
@@ -465,8 +457,8 @@ TEST(MSGPACK_CPP17, carray_byte_object_with_zone)
std::byte val2[sizeof(val1)];
obj.convert(val2);
for (size_t i = 0; i != sizeof(val1); ++i) {
EXPECT_EQ(val1[i], val2[i]);
BOOST_CHECK(val1[i] == val2[i]);
}
}
#endif // !defined(MSGPACK_USE_CPP03) && __cplusplus >= 201703
#endif // MSGPACK_CPP_VERSION >= 201703