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

396
test/msgpack_container.cpp
View File

@@ -12,16 +12,8 @@
#include "test_allocator.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_STL
#include <boost/test/unit_test.hpp>
#ifdef HAVE_CONFIG_H
#include "config.h"
@@ -46,7 +38,63 @@ struct less : std::less<Key> {
} // namespace test
TEST(MSGPACK_STL, simple_buffer_vector)
BOOST_AUTO_TEST_CASE(simple_buffer_cstring)
{
for (unsigned int k = 0; k < kLoop; k++) {
string val1;
for (unsigned int i = 0; i < kElements; i++)
val1 += static_cast<char>('a' + rand() % 26);
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1.c_str());
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR);
string val2 = oh.get().as<string>();
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1, val2);
}
}
BOOST_AUTO_TEST_CASE(simple_buffer_non_const_cstring)
{
for (unsigned int k = 0; k < kLoop; k++) {
string val1;
for (unsigned int i = 0; i < kElements; i++)
val1 += static_cast<char>('a' + rand() % 26);
msgpack::sbuffer sbuf;
char* s = new char[val1.size() + 1];
std::memcpy(s, val1.c_str(), val1.size() + 1);
msgpack::pack(sbuf, s);
delete [] s;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::STR);
string val2 = oh.get().as<string>();
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1, val2);
}
}
BOOST_AUTO_TEST_CASE(simple_buffer_wstring)
{
for (unsigned int k = 0; k < kLoop; k++) {
wstring val1;
for (unsigned int i = 0; i < kElements; i++)
val1 += L'a' + rand() % 26;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
wstring val2 = oh.get().as<wstring>();
BOOST_CHECK(val1 == val2);
wstring val3;
oh.get().convert(val3);
BOOST_CHECK(val1 == val3);
}
}
BOOST_AUTO_TEST_CASE(simple_buffer_vector)
{
typedef vector<int, test::allocator<int> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -57,14 +105,14 @@ TEST(MSGPACK_STL, simple_buffer_vector)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_vector_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_vector_empty)
{
typedef vector<int, test::allocator<int> > type;
type val1;
@@ -72,13 +120,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_empty)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_vector_char)
BOOST_AUTO_TEST_CASE(simple_buffer_vector_char)
{
typedef vector<char, test::allocator<char> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -89,14 +137,14 @@ TEST(MSGPACK_STL, simple_buffer_vector_char)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::BIN);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_vector_char_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_vector_char_empty)
{
typedef vector<char, test::allocator<char> > type;
type val1;
@@ -104,13 +152,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_char_empty)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::BIN);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char)
BOOST_AUTO_TEST_CASE(simple_buffer_vector_unsigned_char)
{
typedef vector<unsigned char, test::allocator<unsigned char> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -121,14 +169,14 @@ TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::BIN);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_vector_unsigned_char_empty)
{
typedef vector<unsigned char, test::allocator<unsigned char> > type;
type val1;
@@ -136,13 +184,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char_empty)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::BIN);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_vector_uint8_t)
BOOST_AUTO_TEST_CASE(simple_buffer_vector_uint8_t)
{
if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
typedef vector<uint8_t, test::allocator<uint8_t> > type;
@@ -154,14 +202,14 @@ TEST(MSGPACK_STL, simple_buffer_vector_uint8_t)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::BIN);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_vector_uint8_t_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_vector_uint8_t_empty)
{
if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
typedef vector<uint8_t, test::allocator<uint8_t> > type;
@@ -170,13 +218,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_uint8_t_empty)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::BIN);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::BIN);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_vector_bool)
BOOST_AUTO_TEST_CASE(simple_buffer_vector_bool)
{
typedef vector<bool, test::allocator<bool> > type;
type val1;
@@ -186,13 +234,13 @@ TEST(MSGPACK_STL, simple_buffer_vector_bool)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_vector_bool_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_vector_bool_empty)
{
typedef vector<bool, test::allocator<bool> > type;
type val1;
@@ -200,14 +248,14 @@ TEST(MSGPACK_STL, simple_buffer_vector_bool_empty)
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
BOOST_CHECK_EQUAL(oh.get().type, msgpack::type::ARRAY);
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_assoc_vector)
BOOST_AUTO_TEST_CASE(simple_buffer_assoc_vector)
{
typedef msgpack::type::assoc_vector<int, int, test::less<int>, test::allocator<std::pair<int, int> > >type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -220,12 +268,12 @@ TEST(MSGPACK_STL, simple_buffer_assoc_vector)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_assoc_vector_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_assoc_vector_empty)
{
typedef msgpack::type::assoc_vector<int, int, test::less<int>, test::allocator<std::pair<int, int> > >type;
type val1;
@@ -234,11 +282,11 @@ TEST(MSGPACK_STL, simple_buffer_assoc_vector_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_map)
BOOST_AUTO_TEST_CASE(simple_buffer_map)
{
typedef map<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -250,12 +298,12 @@ TEST(MSGPACK_STL, simple_buffer_map)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_map_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_map_empty)
{
typedef map<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > type;
type val1;
@@ -264,11 +312,11 @@ TEST(MSGPACK_STL, simple_buffer_map_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_deque)
BOOST_AUTO_TEST_CASE(simple_buffer_deque)
{
typedef deque<int, test::allocator<int> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -280,12 +328,12 @@ TEST(MSGPACK_STL, simple_buffer_deque)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_deque_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_deque_empty)
{
typedef deque<int, test::allocator<int> > type;
type val1;
@@ -294,11 +342,11 @@ TEST(MSGPACK_STL, simple_buffer_deque_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_list)
BOOST_AUTO_TEST_CASE(simple_buffer_list)
{
typedef list<int, test::allocator<int> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -310,12 +358,12 @@ TEST(MSGPACK_STL, simple_buffer_list)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_list_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_list_empty)
{
typedef list<int, test::allocator<int> > type;
type val1;
@@ -324,11 +372,11 @@ TEST(MSGPACK_STL, simple_buffer_list_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type const& val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_set)
BOOST_AUTO_TEST_CASE(simple_buffer_set)
{
typedef set<int, test::less<int>, test::allocator<int> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -340,12 +388,12 @@ TEST(MSGPACK_STL, simple_buffer_set)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_set_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_set_empty)
{
typedef set<int, test::less<int>, test::allocator<int> > type;
type val1;
@@ -354,11 +402,11 @@ TEST(MSGPACK_STL, simple_buffer_set_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_pair)
BOOST_AUTO_TEST_CASE(simple_buffer_pair)
{
for (unsigned int k = 0; k < kLoop; k++) {
pair<int, int> val1 = make_pair(rand(), rand());
@@ -367,12 +415,12 @@ TEST(MSGPACK_STL, simple_buffer_pair)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
pair<int, int> val2 = oh.get().as<pair<int, int> >();
EXPECT_EQ(val1.first, val2.first);
EXPECT_EQ(val1.second, val2.second);
BOOST_CHECK_EQUAL(val1.first, val2.first);
BOOST_CHECK_EQUAL(val1.second, val2.second);
}
}
TEST(MSGPACK_STL, simple_buffer_complex_float)
BOOST_AUTO_TEST_CASE(simple_buffer_complex_float)
{
complex<float> val1 = complex<float>(1.23F, 4.56F);
msgpack::sbuffer sbuf;
@@ -380,14 +428,14 @@ TEST(MSGPACK_STL, simple_buffer_complex_float)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
complex<float> val2 = oh.get().as<complex<float> >();
EXPECT_EQ(val1, val2);
BOOST_CHECK_EQUAL(val1, val2);
complex<float> val3;
oh.get().convert(val3);
EXPECT_EQ(val1, val3);
BOOST_CHECK_EQUAL(val1, val3);
}
TEST(MSGPACK_STL, simple_buffer_complex_double)
BOOST_AUTO_TEST_CASE(simple_buffer_complex_double)
{
complex<double> val1 = complex<double>(1.23, 4.56);
msgpack::sbuffer sbuf;
@@ -395,14 +443,14 @@ TEST(MSGPACK_STL, simple_buffer_complex_double)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
complex<double> val2 = oh.get().as<complex<double> >();
EXPECT_EQ(val1, val2);
BOOST_CHECK_EQUAL(val1, val2);
complex<double> val3;
oh.get().convert(val3);
EXPECT_EQ(val1, val3);
BOOST_CHECK_EQUAL(val1, val3);
}
TEST(MSGPACK_STL, simple_buffer_multimap)
BOOST_AUTO_TEST_CASE(simple_buffer_multimap)
{
typedef multimap<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -424,15 +472,15 @@ TEST(MSGPACK_STL, simple_buffer_multimap)
v1.push_back(make_pair(it->first, it->second));
for (it = val2.begin(); it != val2.end(); ++it)
v2.push_back(make_pair(it->first, it->second));
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
BOOST_CHECK(v1 == v2);
}
}
TEST(MSGPACK_STL, simple_buffer_multimap_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_multimap_empty)
{
typedef multimap<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > type;
type val1;
@@ -441,10 +489,10 @@ TEST(MSGPACK_STL, simple_buffer_multimap_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
TEST(MSGPACK_STL, simple_buffer_multiset)
BOOST_AUTO_TEST_CASE(simple_buffer_multiset)
{
typedef multiset<int, test::less<int>, test::allocator<int> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -463,15 +511,15 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
v1.push_back(*it);
for (it = val2.begin(); it != val2.end(); ++it)
v2.push_back(*it);
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
BOOST_CHECK(v1 == v2);
}
}
TEST(MSGPACK_STL, simple_buffer_multiset_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_multiset_empty)
{
typedef multiset<int, test::less<int>, test::allocator<int> > type;
type val1;
@@ -480,10 +528,10 @@ TEST(MSGPACK_STL, simple_buffer_multiset_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
TEST(MSGPACK_TUPLE, simple_tuple)
BOOST_AUTO_TEST_CASE(simple_tuple)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, double> val1(true, "kzk", 12.3);
@@ -492,13 +540,13 @@ TEST(MSGPACK_TUPLE, simple_tuple)
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::tuple<bool, std::string, double> val2
= oh.get().as<msgpack::type::tuple<bool, std::string, double> >();
EXPECT_EQ(oh.get().via.array.size, 3u);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
EXPECT_EQ(val1.get<2>(), val2.get<2>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
BOOST_CHECK_EQUAL(val1.get<2>(), val2.get<2>());
}
TEST(MSGPACK_TUPLE, simple_tuple_empty)
BOOST_AUTO_TEST_CASE(simple_tuple_empty)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<> val1;
@@ -506,10 +554,10 @@ TEST(MSGPACK_TUPLE, simple_tuple_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
oh.get().as<msgpack::type::tuple<> >();
EXPECT_EQ(oh.get().via.array.size, 0u);
BOOST_CHECK_EQUAL(oh.get().via.array.size, 0u);
}
TEST(MSGPACK_TUPLE, simple_tuple_grater_than_as)
BOOST_AUTO_TEST_CASE(simple_tuple_grater_than_as)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
@@ -518,13 +566,13 @@ TEST(MSGPACK_TUPLE, simple_tuple_grater_than_as)
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::tuple<bool, std::string, int, int> val2
= oh.get().as<msgpack::type::tuple<bool, std::string, int, int> >();
EXPECT_EQ(oh.get().via.array.size, 3u);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
EXPECT_EQ(val1.get<2>(), val2.get<2>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
BOOST_CHECK_EQUAL(val1.get<2>(), val2.get<2>());
}
TEST(MSGPACK_TUPLE, simple_tuple_grater_than_convert)
BOOST_AUTO_TEST_CASE(simple_tuple_grater_than_convert)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
@@ -533,13 +581,13 @@ TEST(MSGPACK_TUPLE, simple_tuple_grater_than_convert)
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::tuple<bool, std::string, int, int> val2;
oh.get().convert(val2);
EXPECT_EQ(oh.get().via.array.size, 3u);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
EXPECT_EQ(val1.get<2>(), val2.get<2>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
BOOST_CHECK_EQUAL(val1.get<2>(), val2.get<2>());
}
TEST(MSGPACK_TUPLE, simple_tuple_less_than_as)
BOOST_AUTO_TEST_CASE(simple_tuple_less_than_as)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
@@ -548,12 +596,12 @@ TEST(MSGPACK_TUPLE, simple_tuple_less_than_as)
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::tuple<bool, std::string> val2
= oh.get().as<msgpack::type::tuple<bool, std::string> >();
EXPECT_EQ(oh.get().via.array.size, 3u);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
}
TEST(MSGPACK_TUPLE, simple_tuple_less_than_convert)
BOOST_AUTO_TEST_CASE(simple_tuple_less_than_convert)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
@@ -562,12 +610,12 @@ TEST(MSGPACK_TUPLE, simple_tuple_less_than_convert)
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::tuple<bool, std::string> val2;
oh.get().convert(val2);
EXPECT_EQ(oh.get().via.array.size, 3u);
EXPECT_EQ(val1.get<0>(), val2.get<0>());
EXPECT_EQ(val1.get<1>(), val2.get<1>());
BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
BOOST_CHECK_EQUAL(val1.get<0>(), val2.get<0>());
BOOST_CHECK_EQUAL(val1.get<1>(), val2.get<1>());
}
TEST(MSGPACK_TUPLE, simple_tuple_nest)
BOOST_AUTO_TEST_CASE(simple_tuple_nest)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<msgpack::type::tuple<> > val1;
@@ -576,7 +624,7 @@ TEST(MSGPACK_TUPLE, simple_tuple_nest)
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::tuple<msgpack::type::tuple<> > val2;
oh.get().convert(val2);
EXPECT_EQ(oh.get().via.array.size, 1u);
BOOST_CHECK_EQUAL(oh.get().via.array.size, 1u);
}
// TR1
@@ -598,7 +646,7 @@ struct tr1_hash : std::tr1::hash<Key> {
#ifdef MSGPACK_HAS_STD_TR1_UNORDERED_MAP
#include <tr1/unordered_map>
#include "msgpack/adaptor/tr1/unordered_map.hpp"
TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_map)
{
typedef tr1::unordered_map<int, int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -610,16 +658,16 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it) {
EXPECT_TRUE(val2.find(it->first) != val2.end());
EXPECT_EQ(it->second, val2.find(it->first)->second);
BOOST_CHECK(val2.find(it->first) != val2.end());
BOOST_CHECK_EQUAL(it->second, val2.find(it->first)->second);
}
}
}
TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_map_empty)
{
typedef tr1::unordered_map<int, int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
type val1;
@@ -628,10 +676,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multimap)
{
typedef tr1::unordered_multimap<int, int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -653,15 +701,15 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
v1.push_back(make_pair(it->first, it->second));
for (it = val2.begin(); it != val2.end(); ++it)
v2.push_back(make_pair(it->first, it->second));
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
BOOST_CHECK(v1 == v2);
}
}
TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multimap_empty)
{
typedef tr1::unordered_multimap<int, int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
type val1;
@@ -670,7 +718,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
#endif
@@ -678,7 +726,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap_empty)
#ifdef MSGPACK_HAS_STD_TR1_UNORDERED_SET
#include <tr1/unordered_set>
#include "msgpack/adaptor/tr1/unordered_set.hpp"
TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_set)
{
typedef tr1::unordered_set<int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<int> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -690,14 +738,14 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it)
EXPECT_TRUE(val2.find(*it) != val2.end());
BOOST_CHECK(val2.find(*it) != val2.end());
}
}
TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_set_empty)
{
typedef tr1::unordered_set<int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<int> > type;
type val1;
@@ -706,10 +754,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multiset)
{
typedef tr1::unordered_multiset<int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<int> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -728,15 +776,15 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
v1.push_back(*it);
for (it = val2.begin(); it != val2.end(); ++it)
v2.push_back(*it);
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
BOOST_CHECK(v1 == v2);
}
}
TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multiset_empty)
{
typedef tr1::unordered_multiset<int, test::tr1_hash<int>, test::equal_to<int>, test::allocator<int> > type;
type val1;
@@ -745,7 +793,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
#endif
@@ -767,7 +815,7 @@ struct hash : std::hash<Key> {
#ifdef MSGPACK_HAS_STD_UNORDERED_MAP
#include <unordered_map>
#include "msgpack/adaptor/tr1/unordered_map.hpp"
TEST(MSGPACK_TR1, simple_buffer_unordered_map)
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_map)
{
typedef unordered_map<int, int, test::hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -779,16 +827,16 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it) {
EXPECT_TRUE(val2.find(it->first) != val2.end());
EXPECT_EQ(it->second, val2.find(it->first)->second);
BOOST_CHECK(val2.find(it->first) != val2.end());
BOOST_CHECK_EQUAL(it->second, val2.find(it->first)->second);
}
}
}
TEST(MSGPACK_TR1, simple_buffer_unordered_map_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_map_empty)
{
typedef unordered_map<int, int, test::hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
type val1;
@@ -797,10 +845,10 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multimap)
{
typedef unordered_multimap<int, int, test::hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -822,15 +870,15 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
v1.push_back(make_pair(it->first, it->second));
for (it = val2.begin(); it != val2.end(); ++it)
v2.push_back(make_pair(it->first, it->second));
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
BOOST_CHECK(v1 == v2);
}
}
TEST(MSGPACK_TR1, simple_buffer_unordered_multimap_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multimap_empty)
{
typedef unordered_multimap<int, int, test::hash<int>, test::equal_to<int>, test::allocator<std::pair<const int, int> > > type;
type val1;
@@ -839,7 +887,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
#endif
@@ -848,7 +896,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap_empty)
#include <unordered_set>
#include "msgpack/adaptor/tr1/unordered_set.hpp"
TEST(MSGPACK_TR1, simple_buffer_unordered_set)
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_set)
{
typedef unordered_set<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -860,14 +908,14 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it)
EXPECT_TRUE(val2.find(*it) != val2.end());
BOOST_CHECK(val2.find(*it) != val2.end());
}
}
TEST(MSGPACK_TR1, simple_buffer_unordered_set_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_set_empty)
{
typedef unordered_set<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > type;
type val1;
@@ -876,10 +924,10 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multiset)
{
typedef unordered_multiset<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > type;
for (unsigned int k = 0; k < kLoop; k++) {
@@ -898,15 +946,15 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
v1.push_back(*it);
for (it = val2.begin(); it != val2.end(); ++it)
v2.push_back(*it);
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
BOOST_CHECK_EQUAL(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
BOOST_CHECK(v1 == v2);
}
}
TEST(MSGPACK_TR1, simple_buffer_unordered_multiset_empty)
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multiset_empty)
{
typedef unordered_multiset<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > type;
type val1;
@@ -915,7 +963,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset_empty)
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
BOOST_CHECK_EQUAL(val1.size(), val2.size());
}
#endif