libmsgpack/msgpack-c/test/object_with_zone.cpp

#include <msgpack.hpp>
#include <gtest/gtest.h>
#include <cmath>

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

enum enum_test {
    elem
};

MSGPACK_ADD_ENUM(enum_test);

struct outer_enum {
    enum enum_test {
        elem
    };
};

MSGPACK_ADD_ENUM(outer_enum::enum_test);

#if !defined(MSGPACK_USE_CPP03)

enum class enum_class_test {
    elem
};

MSGPACK_ADD_ENUM(enum_class_test);

struct outer_enum_class {
    enum class enum_class_test {
        elem
    };
};

MSGPACK_ADD_ENUM(outer_enum_class::enum_class_test);

#endif // !defined(MSGPACK_USE_CPP03)



using namespace std;

const unsigned int kLoop = 1000;
const unsigned int kElements = 100;
const double kEPS = 1e-10;

// bool
TEST(object_with_zone, bool)
{
    bool v = true;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<bool>(), v);
    v = false;
    EXPECT_TRUE(obj.as<bool>());
}

// char
TEST(object_with_zone, char)
{
    char v = 1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<char>(), v);
    v = 2;
    EXPECT_EQ(obj.as<char>(), 1);
}

// signed integer family
TEST(object_with_zone, signed_char)
{
    signed char v = -1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<signed char>(), v);
    v = -2;
    EXPECT_EQ(obj.as<signed char>(), -1);
}

TEST(object_with_zone, signed_short)
{
    signed short v = -1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<signed short>(), v);
    v = -2;
    EXPECT_EQ(obj.as<signed short>(), -1);
}

TEST(object_with_zone, signed_int)
{
    signed int v = -1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<signed int>(), v);
    v = -2;
    EXPECT_EQ(obj.as<signed int>(), -1);
}

TEST(object_with_zone, signed_long)
{
    signed long v = -1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<signed long>(), v);
    v = -2;
    EXPECT_EQ(obj.as<signed long>(), -1);
}

TEST(object_with_zone, signed_long_long)
{
    signed long long v = -1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<signed long long>(), v);
    v = -2;
    EXPECT_EQ(obj.as<signed long long>(), -1);
}

// unsigned integer family
TEST(object_with_zone, unsigned_char)
{
    unsigned char v = 1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<unsigned char>(), v);
    v = 2;
    EXPECT_EQ(obj.as<unsigned char>(), 1);
}

TEST(object_with_zone, unsigned_short)
{
    unsigned short v = 1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<unsigned short>(), v);
    v = 2;
    EXPECT_EQ(obj.as<unsigned short>(), 1);
}

TEST(object_with_zone, unsigned_int)
{
    unsigned int v = 1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<unsigned int>(), v);
    v = 2;
    EXPECT_EQ(obj.as<unsigned int>(), 1u);
}

TEST(object_with_zone, unsigned_long)
{
    unsigned long v = 1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<unsigned long>(), v);
    v = 2;
    EXPECT_EQ(obj.as<unsigned long>(), 1u);
}

TEST(object_with_zone, unsigned_long_long)
{
    unsigned long long v = 1;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<unsigned long long>(), v);
    v = 2;
    EXPECT_EQ(obj.as<unsigned long long>(), 1u);
}

// float
TEST(object_with_zone, float)
{
    float v = 1.23f;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(fabs(obj.as<float>() - v) <= kEPS);
    v = 4.56f;
    EXPECT_TRUE(fabs(obj.as<float>() - static_cast<float>(1.23)) <= kEPS);
}

// double
TEST(object_with_zone, double)
{
    double v = 1.23;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(fabs(obj.as<double>() - v) <= kEPS);
    v = 4.56;
    EXPECT_TRUE(fabs(obj.as<double>() - 1.23) <= kEPS);
}

// vector

TEST(object_with_zone, vector)
{
    for (unsigned int k = 0; k < kLoop; k++) {
        vector<int> v1;
        v1.push_back(1);
        for (unsigned int i = 1; i < kElements; i++)
            v1.push_back(i);
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<vector<int> >() == v1);
        v1.front() = 42;
        EXPECT_EQ(obj.as<vector<int> >().front(), 1);
    }
}

// vector_char
TEST(object_with_zone, vector_char)
{
    for (unsigned int k = 0; k < kLoop; k++) {
        vector<char> v1;
        v1.push_back(1);
        for (unsigned int i = 1; i < kElements; i++)
            v1.push_back(static_cast<char>(i));
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<vector<char> >() == v1);
        v1.front() = 42;
        EXPECT_EQ(obj.as<vector<char> >().front(), 1);
    }
}

TEST(object_without_zone, vector_char)
{
    for (unsigned int k = 0; k < kLoop; k++) {
        vector<char> v1;
        v1.push_back(1);
        for (unsigned int i = 1; i < kElements; i++)
            v1.push_back(static_cast<char>(i));
        msgpack::object obj(v1);
        EXPECT_TRUE(obj.as<vector<char> >() == v1);
        v1.front() = 42;
        // obj refer to v1
        EXPECT_EQ(obj.as<vector<char> >().front(), 42);
    }
}

// vector_unsgined_char
TEST(object_with_zone, vector_unsigned_char)
{
    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
    for (unsigned int k = 0; k < kLoop; k++) {
        vector<unsigned char> v1;
        v1.push_back(1);
        for (unsigned int i = 1; i < kElements; i++)
            v1.push_back(static_cast<unsigned char>(i));
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<vector<unsigned char> >() == v1);
        v1.front() = 42;
        EXPECT_EQ(obj.as<vector<unsigned char> >().front(), 1);
    }
}

TEST(object_without_zone, vector_unsigned_char)
{
    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
    for (unsigned int k = 0; k < kLoop; k++) {
        vector<unsigned char> v1;
        v1.push_back(1);
        for (unsigned int i = 1; i < kElements; i++)
            v1.push_back(static_cast<unsigned char>(i));
        msgpack::object obj(v1);
        EXPECT_TRUE(obj.as<vector<unsigned char> >() == v1);
        v1.front() = 42;
        // obj refer to v1
        EXPECT_EQ(obj.as<vector<unsigned char> >().front(), 42);
    }
}

// list
TEST(object_with_zone, list)
{
    for (unsigned int k = 0; k < kLoop; k++) {
        list<int> v1;
        v1.push_back(1);
        for (unsigned int i = 1; i < kElements; i++)
            v1.push_back(i);
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<list<int> >() == v1);
        v1.front() = 42;
        EXPECT_EQ(obj.as<list<int> >().front(), 1);
    }
}

// deque
TEST(object_with_zone, deque)
{
    for (unsigned int k = 0; k < kLoop; k++) {
        deque<int> v1;
        v1.push_back(1);
        for (unsigned int i = 1; i < kElements; i++)
            v1.push_back(i);
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<deque<int> >() == v1);
        v1.front() = 42;
        EXPECT_EQ(obj.as<deque<int> >().front(), 1);
    }
}

// string
TEST(object_with_zone, string)
{
    string v = "abc";
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<string>(), v);
    v[0] = 'd';
    EXPECT_EQ(obj.as<string>()[0], 'a');
}

TEST(object_without_zone, string)
{
    string v = "abc";
    msgpack::zone z;
    msgpack::object obj(v);
    EXPECT_EQ(obj.as<string>(), v);
    v[0] = 'd';
    EXPECT_EQ(obj.as<string>()[0], 'd');
}

// char*
TEST(object_with_zone, char_ptr)
{
    char v[] = "abc";
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.as<string>(), std::string(v));
    v[0] = 'd';
    EXPECT_EQ(obj.as<string>()[0], 'a');
}

TEST(object_without_zone, char_ptr)
{
    char v[] = "abc";
    msgpack::zone z;
    msgpack::object obj(v);
    EXPECT_EQ(obj.as<string>(), std::string(v));
    v[0] = 'd';
    EXPECT_EQ(obj.as<string>()[0], 'd');
}


// raw_ref
TEST(object_with_zone, raw_ref)
{
    string s = "abc";
    msgpack::type::raw_ref v(s.data(), static_cast<uint32_t>(s.size()));
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(obj.as<msgpack::type::raw_ref>() == v);
    s[0] = 'd';
    // even if with_zone, not copied due to raw_ref
    // Basically, the combination raw_ref and object::wit_zone
    // is meaningless.
    EXPECT_TRUE(obj.as<msgpack::type::raw_ref>() == v);
}

TEST(object_without_zone, raw_ref)
{
    string s = "abc";
    msgpack::type::raw_ref v(s.data(), static_cast<uint32_t>(s.size()));
    msgpack::zone z;
    msgpack::object obj(v);
    EXPECT_TRUE(obj.as<msgpack::type::raw_ref>() == v);
    s[0] = 'd';
    EXPECT_TRUE(obj.as<msgpack::type::raw_ref>() == v);
}

// pair
TEST(object_with_zone, pair)
{
    typedef pair<int, string> test_t;
    test_t v(1, "abc");
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(obj.as<test_t>() == v);
    v.first = 42;
    EXPECT_EQ(obj.as<test_t>().first, 1);
}

// set
TEST(object_with_zone, set)
{
    for (unsigned int k = 0; k < kLoop; k++) {
        set<int> v1;
        for (unsigned int i = 0; i < kElements; i++)
            v1.insert(i);
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<set<int> >() == v1);
    }
}

// multiset
TEST(object_with_zone, multiset)
{
    for (unsigned int k = 0; k < kLoop; k++) {
        multiset<int> v1;
        for (unsigned int i = 0; i < kElements; i++)
            v1.insert(i % (kElements / 2));
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<multiset<int> >() == v1);
    }
}

// map
TEST(object_with_zone, map)
{
    typedef map<int, int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++)
            v1.insert(std::make_pair(i, i*2));
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<test_t >() == v1);
    }
}

// multimap
TEST(object_with_zone, multimap)
{
    typedef multimap<int, int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++)
            v1.insert(std::make_pair(i % (kElements / 2), i*2));
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<test_t >() == v1);
    }
}

// msgpack_tuple
TEST(object_with_zone, msgpack_tuple)
{
    typedef msgpack::type::tuple<int, string, bool> test_t;
    test_t v(1, "abc", true);
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(msgpack::type::get<0>(obj.as<test_t>()), 1);
    EXPECT_EQ(msgpack::type::get<1>(obj.as<test_t>()), "abc");
    EXPECT_EQ(msgpack::type::get<2>(obj.as<test_t>()), true);
    msgpack::type::get<0>(v) = 42;
    EXPECT_EQ(msgpack::type::get<0>(obj.as<test_t>()), 1);
}

TEST(object_with_zone, msgpack_tuple_empty)
{
    typedef msgpack::type::tuple<> test_t;
    test_t v;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_EQ(obj.via.array.size, 0u);
}

// TR1

#ifdef MSGPACK_HAS_STD_TR1_UNORDERED_MAP
#include <tr1/unordered_map>
#include "msgpack/adaptor/tr1/unordered_map.hpp"
TEST(object_with_zone, tr1_unordered_map)
{
    typedef tr1::unordered_map<int, int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++)
            v1[rand()] = rand();
        msgpack::zone z;
        msgpack::object obj(v1, z);
        test_t v2 = obj.as<test_t>();
        EXPECT_EQ(v1.size(), v2.size());
        test_t::const_iterator it;
        for (it = v1.begin(); it != v1.end(); ++it) {
            EXPECT_TRUE(v2.find(it->first) != v2.end());
            EXPECT_EQ(it->second, v2.find(it->first)->second);
        }
    }
}


TEST(object_with_zone, tr1_unordered_multimap)
{
    typedef tr1::unordered_multimap<int, int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++) {
            int i1 = rand();
            v1.insert(make_pair(i1, rand()));
            v1.insert(make_pair(i1, rand()));
        }
        msgpack::zone z;
        msgpack::object obj(v1, z);
        test_t v2 = obj.as<test_t>();
        vector<pair<int, int> > vec1, vec2;
        tr1::unordered_multimap<int, int>::const_iterator it;
        for (it = v1.begin(); it != v1.end(); ++it)
            vec1.push_back(make_pair(it->first, it->second));
        for (it = v2.begin(); it != v2.end(); ++it)
            vec2.push_back(make_pair(it->first, it->second));
        EXPECT_EQ(v1.size(), v2.size());
        EXPECT_EQ(vec1.size(), vec2.size());
        sort(vec1.begin(), vec1.end());
        sort(vec2.begin(), vec2.end());
        EXPECT_TRUE(vec1 == vec2);
    }
}
#endif

#ifdef MSGPACK_HAS_STD_TR1_UNORDERED_SET
#include <tr1/unordered_set>
#include "msgpack/adaptor/tr1/unordered_set.hpp"
TEST(object_with_zone, tr1_unordered_set)
{
    typedef tr1::unordered_set<int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++)
            v1.insert(rand());
        msgpack::zone z;
        msgpack::object obj(v1, z);
        test_t v2 = obj.as<test_t>();
        EXPECT_EQ(v1.size(), v2.size());
        tr1::unordered_set<int>::const_iterator it;
        for (it = v1.begin(); it != v1.end(); ++it)
            EXPECT_TRUE(v2.find(*it) != v2.end());
    }
}

TEST(object_with_zone, tr1_unordered_multiset)
{
    typedef tr1::unordered_set<int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++) {
            int i1 = rand();
            v1.insert(i1);
            v1.insert(i1);
        }
        msgpack::zone z;
        msgpack::object obj(v1, z);
        test_t v2 = obj.as<test_t>();
        vector<int> vec1, vec2;
        tr1::unordered_multiset<int>::const_iterator it;
        for (it = v1.begin(); it != v1.end(); ++it)
            vec1.push_back(*it);
        for (it = v2.begin(); it != v2.end(); ++it)
            vec2.push_back(*it);
        EXPECT_EQ(v1.size(), v2.size());
        EXPECT_EQ(vec1.size(), vec2.size());
        sort(vec1.begin(), vec1.end());
        sort(vec2.begin(), vec2.end());
        EXPECT_TRUE(vec1 == vec2);
    }
}
#endif

#ifdef MSGPACK_HAS_STD_UNORDERED_MAP
#include <unordered_map>
#include "msgpack/adaptor/tr1/unordered_map.hpp"
TEST(object_with_zone, unordered_map)
{
    typedef unordered_map<int, int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++)
            v1[rand()] = rand();
        msgpack::zone z;
        msgpack::object obj(v1, z);
        test_t v2 = obj.as<test_t>();
        EXPECT_EQ(v1.size(), v2.size());
        test_t::const_iterator it;
        for (it = v1.begin(); it != v1.end(); ++it) {
            EXPECT_TRUE(v2.find(it->first) != v2.end());
            EXPECT_EQ(it->second, v2.find(it->first)->second);
        }
    }
}

TEST(object_with_zone, unordered_multimap)
{
   typedef unordered_multimap<int, int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++) {
            int i1 = rand();
            v1.insert(make_pair(i1, rand()));
            v1.insert(make_pair(i1, rand()));
        }
        msgpack::zone z;
        msgpack::object obj(v1, z);
        test_t v2 = obj.as<test_t>();
        vector<pair<int, int> > vec1, vec2;
        unordered_multimap<int, int>::const_iterator it;
        for (it = v1.begin(); it != v1.end(); ++it)
            vec1.push_back(make_pair(it->first, it->second));
        for (it = v2.begin(); it != v2.end(); ++it)
            vec2.push_back(make_pair(it->first, it->second));
        EXPECT_EQ(v1.size(), v2.size());
        EXPECT_EQ(vec1.size(), vec2.size());
        sort(vec1.begin(), vec1.end());
        sort(vec2.begin(), vec2.end());
        EXPECT_TRUE(vec1 == vec2);
    }
}
#endif

#ifdef MSGPACK_HAS_STD_UNORDERED_SET
#include <unordered_set>
#include "msgpack/adaptor/tr1/unordered_set.hpp"
TEST(object_with_zone, unordered_set)
{
    typedef unordered_set<int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++)
            v1.insert(rand());
        msgpack::zone z;
        msgpack::object obj(v1, z);
        test_t v2 = obj.as<test_t>();
        EXPECT_EQ(v1.size(), v2.size());
        unordered_set<int>::const_iterator it;
        for (it = v1.begin(); it != v1.end(); ++it)
            EXPECT_TRUE(v2.find(*it) != v2.end());
    }
}

TEST(object_with_zone, unordered_multiset)
{
    typedef unordered_set<int> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        for (unsigned int i = 0; i < kElements; i++) {
            int i1 = rand();
            v1.insert(i1);
            v1.insert(i1);
        }
        msgpack::zone z;
        msgpack::object obj(v1, z);
        test_t v2 = obj.as<test_t>();
        vector<int> vec1, vec2;
        unordered_multiset<int>::const_iterator it;
        for (it = v1.begin(); it != v1.end(); ++it)
            vec1.push_back(*it);
        for (it = v2.begin(); it != v2.end(); ++it)
            vec2.push_back(*it);
        EXPECT_EQ(v1.size(), v2.size());
        EXPECT_EQ(vec1.size(), vec2.size());
        sort(vec1.begin(), vec1.end());
        sort(vec2.begin(), vec2.end());
        EXPECT_TRUE(vec1 == vec2);
    }
}
#endif

// User defined class
class TestClass
{
public:
    TestClass() : i(0), s("kzk") {}
    int i;
    string s;
    MSGPACK_DEFINE(i, s);
};

TEST(object_with_zone, user_defined)
{
    TestClass v1;
    msgpack::zone z;
    msgpack::object obj(v1, z);
    TestClass v2 = obj.as<TestClass>();
    EXPECT_EQ(v1.i, v2.i);
    EXPECT_EQ(v1.s, v2.s);
}

TEST(object_with_zone, construct_enum)
{
    msgpack::zone z;
    msgpack::object obj(elem, z);
    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
    EXPECT_EQ(static_cast<uint64_t>(elem), obj.via.u64);
}

#if !defined(MSGPACK_USE_CPP03)

TEST(object_with_zone, construct_enum_newstyle)
{
    msgpack::zone z;
    msgpack::object obj(enum_test::elem, z);
    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
    EXPECT_EQ(elem, obj.via.u64);
}

#endif // !defined(MSGPACK_USE_CPP03)

TEST(object_with_zone, construct_enum_outer)
{
    msgpack::zone z;
    msgpack::object obj(outer_enum::elem, z);
    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
    EXPECT_EQ(static_cast<uint64_t>(elem), obj.via.u64);
}

// User defined inheriting classes
struct top {
    int t;
    MSGPACK_DEFINE(t);
};

struct mid1 : top {
    int m1;
    MSGPACK_DEFINE(MSGPACK_BASE(top), m1);
};

struct mid2 : top {
    int m2;
    MSGPACK_DEFINE(m2, MSGPACK_BASE(top));
};

struct bottom : mid1, mid2 {
    int b;
    MSGPACK_DEFINE(MSGPACK_BASE(mid1), MSGPACK_BASE(mid2), b);
};

TEST(object_with_zone, user_defined_non_virtual)
{
    bottom b;
    b.b = 1;
    b.m1 = 2;
    b.m2 = 3;
    b.mid1::t = 4;
    b.mid2::t = 5;

    msgpack::zone z;
    msgpack::object obj(b, z);
    bottom br = obj.as<bottom>();
    EXPECT_EQ(b.b, br.b);
    EXPECT_EQ(b.m1, br.m1);
    EXPECT_EQ(b.m2, br.m2);
    EXPECT_EQ(b.mid1::t, br.mid1::t);
    EXPECT_EQ(b.mid2::t, br.mid2::t);
}

struct v_top {
    int t;
    MSGPACK_DEFINE(t);
};

struct v_mid1 : virtual v_top {
    int m1;
    MSGPACK_DEFINE(m1);
};

struct v_mid2 : virtual v_top {
    int m2;
    MSGPACK_DEFINE(m2);
};

struct v_bottom : v_mid1, v_mid2 {
    int b;
    MSGPACK_DEFINE(MSGPACK_BASE(v_mid1), MSGPACK_BASE(v_mid2), MSGPACK_BASE(v_top), b);
};

TEST(object_with_zone, user_defined_virtual)
{
    v_bottom b;
    b.b = 1;
    b.m1 = 2;
    b.m2 = 3;
    b.t = 4;

    msgpack::zone z;
    msgpack::object obj(b, z);
    v_bottom br = obj.as<v_bottom>();
    EXPECT_EQ(b.b, br.b);
    EXPECT_EQ(b.m1, br.m1);
    EXPECT_EQ(b.m2, br.m2);
    EXPECT_EQ(b.t, br.t);
}

#if !defined(MSGPACK_USE_CPP03)

TEST(object_with_zone, construct_enum_outer_newstyle)
{
    msgpack::zone z;
    msgpack::object obj(outer_enum::enum_test::elem, z);
    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
    EXPECT_EQ(elem, obj.via.u64);
}

TEST(object_with_zone, construct_class_enum)
{
    msgpack::zone z;
    msgpack::object obj(enum_class_test::elem, z);
    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
    EXPECT_EQ(elem, obj.via.u64);
}


TEST(object_with_zone, construct_class_enum_outer)
{
    msgpack::zone z;
    msgpack::object obj(outer_enum_class::enum_class_test::elem, z);
    EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
    EXPECT_EQ(elem, obj.via.u64);
}


TEST(object_with_zone, array)
{
    typedef array<int, kElements> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        v1[0] = 1;
        for (unsigned int i = 1; i < kElements; i++)
            v1[i] = rand();
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<test_t>() == v1);
        v1.front() = 42;
        EXPECT_EQ(obj.as<test_t>().front(), 1);
    }
}

TEST(object_with_zone, array_char)
{
    typedef array<char, kElements> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        v1[0] = 1;
        for (unsigned int i = 1; i < kElements; i++)
            v1[i] = rand();
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<test_t>() == v1);
        v1.front() = 42;
        EXPECT_EQ(obj.as<test_t>().front(), 1);
    }
}

TEST(object_without_zone, array_char)
{
    typedef array<char, kElements> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        v1[0] = 1;
        for (unsigned int i = 1; i < kElements; i++)
            v1[i] = rand();
        msgpack::object obj(v1);
        EXPECT_TRUE(obj.as<test_t>() == v1);
        v1.front() = 42;
        // obj refer to v1
        EXPECT_EQ(obj.as<test_t>().front(), 42);
    }
}

TEST(object_with_zone, array_unsigned_char)
{
    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
    typedef array<unsigned char, kElements> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        v1[0] = 1;
        for (unsigned int i = 1; i < kElements; i++)
            v1[i] = rand();
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<test_t>() == v1);
        v1.front() = 42;
        EXPECT_EQ(obj.as<test_t>().front(), 1);
    }
}

TEST(object_without_zone, array_unsigned_char)
{
    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
    typedef array<unsigned char, kElements> test_t;
    for (unsigned int k = 0; k < kLoop; k++) {
        test_t v1;
        v1[0] = 1;
        for (unsigned int i = 1; i < kElements; i++)
            v1[i] = rand();
        msgpack::object obj(v1);
        EXPECT_TRUE(obj.as<test_t>() == v1);
        v1.front() = 42;
        // obj refer to v1
        EXPECT_EQ(obj.as<test_t>().front(), 42);
    }
}


TEST(object_with_zone, forward_list)
{
    for (unsigned int k = 0; k < kLoop; k++) {
        forward_list<int> v1;
        for (unsigned int i = 0; i < kElements; i++)
            v1.push_front(i);
        msgpack::zone z;
        msgpack::object obj(v1, z);
        EXPECT_TRUE(obj.as<forward_list<int> >() == v1);
        v1.front() = 42;
        EXPECT_EQ(obj.as<forward_list<int> >().front(), static_cast<int>(kElements - 1));
    }
}

TEST(object_with_zone, tuple)
{
    typedef tuple<int, string, bool> test_t;
    test_t v(1, "abc", true);
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(obj.as<test_t>() == v);
}

TEST(object_with_zone, tuple_empty)
{
    typedef tuple<> test_t;
    test_t v;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(obj.as<test_t>() == v);
}

#endif // !defined(MSGPACK_USE_CPP03)

TEST(object_with_zone, ext_empty)
{
    msgpack::type::ext v;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(obj.as<msgpack::type::ext>() == v);
    EXPECT_TRUE(obj.as<msgpack::type::ext_ref>() == v);
}

TEST(object_with_zone, ext)
{
    msgpack::type::ext v(42, 10);
    for (int i = 0; i < 10; ++i) v.data()[i] = i;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(obj.as<msgpack::type::ext>() == v);
    EXPECT_TRUE(obj.as<msgpack::type::ext_ref>() == v);
}

TEST(object_with_zone, ext_from_buf)
{
    char const buf[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    msgpack::type::ext v(42, buf, sizeof(buf));
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(obj.as<msgpack::type::ext>() == v);
    EXPECT_TRUE(obj.as<msgpack::type::ext_ref>() == v);
}

TEST(object_with_zone, ext_ref_empty)
{
    msgpack::type::ext_ref v;
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(obj.as<msgpack::type::ext>() == v);
    EXPECT_TRUE(obj.as<msgpack::type::ext_ref>() == v);
}

TEST(object_with_zone, ext_ref_from_buf)
{
    char const buf[] = { 77, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    msgpack::type::ext_ref v(buf, sizeof(buf));
    msgpack::zone z;
    msgpack::object obj(v, z);
    EXPECT_TRUE(obj.as<msgpack::type::ext>() == v);
    EXPECT_TRUE(obj.as<msgpack::type::ext_ref>() == v);
}