Viewing: raw.githubusercontent.com

[ Web Proxy ]
Viewing: https://raw.githubusercontent.com/msgpack/msgpack-c/cpp_master/test/msgpack_container.cpp
#include 
#include 

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include "test_allocator.hpp"

#define BOOST_TEST_MODULE MSGPACK_STL
#include 

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif


using namespace std;

const unsigned int kLoop = 1000;
const unsigned int kElements = 100;

// strong typedefs
namespace test {

template 
struct equal_to : std::equal_to {
};

template 
struct less : std::less {
};

} // namespace test

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('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();
        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('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();
        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();
        BOOST_CHECK(val1 == val2);
        wstring val3;
        oh.get().convert(val3);
        BOOST_CHECK(val1 == val3);
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector)
{
    typedef vector type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.push_back(rand());
        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);
        type const& val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector_empty)
{
    typedef vector type;
    type val1;
    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);
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector_char)
{
    typedef vector type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.push_back(static_cast(rand()));
        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::BIN);
        type const& val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector_char_empty)
{
    typedef vector type;
    type val1;
    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::BIN);
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector_unsigned_char)
{
    typedef vector type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.push_back(static_cast(rand()));
        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::BIN);
        type const& val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector_unsigned_char_empty)
{
    typedef vector type;
    type val1;
    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::BIN);
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector_uint8_t)
{
    if (!msgpack::is_same::value) return;
    typedef vector type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.push_back(static_cast(rand()));
        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::BIN);
        type const& val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector_uint8_t_empty)
{
    if (!msgpack::is_same::value) return;
    typedef vector type;
    type val1;
    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::BIN);
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector_bool)
{
    typedef vector type;
    type val1;
    for (unsigned int i = 0; i < kElements; i++)
        val1.push_back(i % 2 ? false : true);
    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);
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_vector_bool_empty)
{
    typedef vector type;
    type val1;
    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);
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}


BOOST_AUTO_TEST_CASE(simple_buffer_assoc_vector)
{
    typedef msgpack::type::assoc_vectortype;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        val1.push_back(std::make_pair(1, 2));
        val1.push_back(std::make_pair(3, 4));
        val1.push_back(std::make_pair(5, 6));
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type const& val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_assoc_vector_empty)
{
    typedef msgpack::type::assoc_vectortype;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_map)
{
    typedef map type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1[rand()] = rand();
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type const& val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_map_empty)
{
    typedef map type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_deque)
{
    typedef deque type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.push_back(rand());
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type const& val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_deque_empty)
{
    typedef deque type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_list)
{
    typedef list type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.push_back(rand());
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type const& val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_list_empty)
{
    typedef list type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type const& val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_set)
{
    typedef set type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.insert(rand());
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_set_empty)
{
    typedef set type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
    BOOST_CHECK(equal(val1.begin(), val1.end(), val2.begin()));
}

BOOST_AUTO_TEST_CASE(simple_buffer_pair)
{
    for (unsigned int k = 0; k < kLoop; k++) {
        pair val1 = make_pair(rand(), rand());
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        pair val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.first, val2.first);
        BOOST_CHECK_EQUAL(val1.second, val2.second);
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_complex_float)
{
    complex val1 = complex(1.23F, 4.56F);
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    complex val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1, val2);
    complex val3;
    oh.get().convert(val3);
    BOOST_CHECK_EQUAL(val1, val3);

}

BOOST_AUTO_TEST_CASE(simple_buffer_complex_double)
{
    complex val1 = complex(1.23, 4.56);
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    complex val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1, val2);
    complex val3;
    oh.get().convert(val3);
    BOOST_CHECK_EQUAL(val1, val3);

}

BOOST_AUTO_TEST_CASE(simple_buffer_multimap)
{
    typedef multimap type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++) {
            int i1 = rand();
            val1.insert(make_pair(i1, rand()));
            val1.insert(make_pair(i1, rand()));
        }
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();

        vector v1, v2;
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it)
            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));
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK_EQUAL(v1.size(), v2.size());
        sort(v1.begin(), v1.end());
        sort(v2.begin(), v2.end());
        BOOST_CHECK(v1 == v2);
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_multimap_empty)
{
    typedef multimap type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

BOOST_AUTO_TEST_CASE(simple_buffer_multiset)
{
    typedef multiset type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.insert(rand());
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();

        vector v1, v2;
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it)
            v1.push_back(*it);
        for (it = val2.begin(); it != val2.end(); ++it)
            v2.push_back(*it);
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK_EQUAL(v1.size(), v2.size());
        sort(v1.begin(), v1.end());
        sort(v2.begin(), v2.end());
        BOOST_CHECK(v1 == v2);
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_multiset_empty)
{
    typedef multiset type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

BOOST_AUTO_TEST_CASE(simple_tuple)
{
    msgpack::sbuffer sbuf;
    msgpack::type::tuple val1(true, "kzk", 12.3);
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    msgpack::type::tuple val2
        = oh.get().as();
    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
}

BOOST_AUTO_TEST_CASE(simple_tuple_empty)
{
    msgpack::sbuffer sbuf;
    msgpack::type::tuple val1;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    oh.get().as();
    BOOST_CHECK_EQUAL(oh.get().via.array.size, 0u);
}

BOOST_AUTO_TEST_CASE(simple_tuple_grater_than_as)
{
    msgpack::sbuffer sbuf;
    msgpack::type::tuple val1(true, "kzk", 42);
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    msgpack::type::tuple val2
        = oh.get().as();
    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
}

BOOST_AUTO_TEST_CASE(simple_tuple_grater_than_convert)
{
    msgpack::sbuffer sbuf;
    msgpack::type::tuple val1(true, "kzk", 42);
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    msgpack::type::tuple val2;
    oh.get().convert(val2);
    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
}

BOOST_AUTO_TEST_CASE(simple_tuple_less_than_as)
{
    msgpack::sbuffer sbuf;
    msgpack::type::tuple val1(true, "kzk", 42);
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    msgpack::type::tuple val2
        = oh.get().as();
    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
}

BOOST_AUTO_TEST_CASE(simple_tuple_less_than_convert)
{
    msgpack::sbuffer sbuf;
    msgpack::type::tuple val1(true, "kzk", 42);
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    msgpack::type::tuple val2;
    oh.get().convert(val2);
    BOOST_CHECK_EQUAL(oh.get().via.array.size, 3u);
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
    BOOST_CHECK_EQUAL(val1.get(), val2.get());
}

BOOST_AUTO_TEST_CASE(simple_tuple_nest)
{
    msgpack::sbuffer sbuf;
    msgpack::type::tuple val1;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    msgpack::type::tuple val2;
    oh.get().convert(val2);
    BOOST_CHECK_EQUAL(oh.get().via.array.size, 1u);
}

// TR1

#if defined(MSGPACK_HAS_STD_TR1_UNORDERED_MAP) || defined(MSGPACK_HAS_STD_TR1_UNORDERED_SET)

#include 

namespace test {

template 
struct tr1_hash : std::tr1::hash {
};

} // namespace test

#endif // defined(MSGPACK_HAS_STD_TR1_UNORDERED_MAP) || defined(MSGPACK_HAS_STD_TR1_UNORDERED_SET)

#ifdef MSGPACK_HAS_STD_TR1_UNORDERED_MAP
#include 
#include "msgpack/adaptor/tr1/unordered_map.hpp"
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_map)
{
    typedef tr1::unordered_map type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1[rand()] = rand();
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it) {
            BOOST_CHECK(val2.find(it->first) != val2.end());
            BOOST_CHECK_EQUAL(it->second, val2.find(it->first)->second);
        }
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_map_empty)
{
    typedef tr1::unordered_map type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multimap)
{
    typedef tr1::unordered_multimap type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++) {
            int i1 = rand();
            val1.insert(make_pair(i1, rand()));
            val1.insert(make_pair(i1, rand()));
        }
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();

        vector v1, v2;
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it)
            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));
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK_EQUAL(v1.size(), v2.size());
        sort(v1.begin(), v1.end());
        sort(v2.begin(), v2.end());
        BOOST_CHECK(v1 == v2);
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multimap_empty)
{
    typedef tr1::unordered_multimap type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

#endif

#ifdef MSGPACK_HAS_STD_TR1_UNORDERED_SET
#include 
#include "msgpack/adaptor/tr1/unordered_set.hpp"
BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_set)
{
    typedef tr1::unordered_set type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.insert(rand());
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it)
            BOOST_CHECK(val2.find(*it) != val2.end());
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_set_empty)
{
    typedef tr1::unordered_set type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multiset)
{
    typedef tr1::unordered_multiset type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.insert(rand());
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();

        vector v1, v2;
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it)
            v1.push_back(*it);
        for (it = val2.begin(); it != val2.end(); ++it)
            v2.push_back(*it);
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK_EQUAL(v1.size(), v2.size());
        sort(v1.begin(), v1.end());
        sort(v2.begin(), v2.end());
        BOOST_CHECK(v1 == v2);
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_tr1_unordered_multiset_empty)
{
    typedef tr1::unordered_multiset type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

#endif

#if defined (MSGPACK_HAS_STD_UNORDERED_MAP) || defined (MSGPACK_HAS_STD_UNORDERED_SET)

#include 

namespace test {

template 
struct hash : std::hash {
};

} // namespace test

#endif // defined (MSGPACK_HAS_STD_UNORDERED_MAP) || defined (MSGPACK_HAS_STD_UNORDERED_SET)

#ifdef MSGPACK_HAS_STD_UNORDERED_MAP
#include 
#include "msgpack/adaptor/tr1/unordered_map.hpp"
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_map)
{
    typedef unordered_map type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1[rand()] = rand();
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it) {
            BOOST_CHECK(val2.find(it->first) != val2.end());
            BOOST_CHECK_EQUAL(it->second, val2.find(it->first)->second);
        }
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_unordered_map_empty)
{
    typedef unordered_map type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multimap)
{
    typedef unordered_multimap type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++) {
            int i1 = rand();
            val1.insert(make_pair(i1, rand()));
            val1.insert(make_pair(i1, rand()));
        }
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();

        vector v1, v2;
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it)
            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));
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK_EQUAL(v1.size(), v2.size());
        sort(v1.begin(), v1.end());
        sort(v2.begin(), v2.end());
        BOOST_CHECK(v1 == v2);
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multimap_empty)
{
    typedef unordered_multimap type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

#endif

#ifdef MSGPACK_HAS_STD_UNORDERED_SET

#include 
#include "msgpack/adaptor/tr1/unordered_set.hpp"
BOOST_AUTO_TEST_CASE(simple_buffer_unordered_set)
{
    typedef unordered_set type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.insert(rand());
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it)
            BOOST_CHECK(val2.find(*it) != val2.end());
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_unordered_set_empty)
{
    typedef unordered_set type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multiset)
{
    typedef unordered_multiset type;
    for (unsigned int k = 0; k < kLoop; k++) {
        type val1;
        for (unsigned int i = 0; i < kElements; i++)
            val1.insert(rand());
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, val1);
        msgpack::object_handle oh =
            msgpack::unpack(sbuf.data(), sbuf.size());
        type val2 = oh.get().as();

        vector v1, v2;
        type::const_iterator it;
        for (it = val1.begin(); it != val1.end(); ++it)
            v1.push_back(*it);
        for (it = val2.begin(); it != val2.end(); ++it)
            v2.push_back(*it);
        BOOST_CHECK_EQUAL(val1.size(), val2.size());
        BOOST_CHECK_EQUAL(v1.size(), v2.size());
        sort(v1.begin(), v1.end());
        sort(v2.begin(), v2.end());
        BOOST_CHECK(v1 == v2);
    }
}

BOOST_AUTO_TEST_CASE(simple_buffer_unordered_multiset_empty)
{
    typedef unordered_multiset type;
    type val1;
    msgpack::sbuffer sbuf;
    msgpack::pack(sbuf, val1);
    msgpack::object_handle oh =
        msgpack::unpack(sbuf.data(), sbuf.size());
    type val2 = oh.get().as();
    BOOST_CHECK_EQUAL(val1.size(), val2.size());
}

#endif
Web Proxy Viewer | New URL | Original Page