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

remove C++ part files

Browse Source 
remove the following files or folders:
erb
example/boost
example/cpp03
example/cpp11
example/x3
example/CMakeLists.txt
fuzz
include/msgpack/adaptor
include/msgpack/predef.h
include/msgpack/predef
include/msgpack/preprocessor
include/msgpack/v1
include/msgpack/v2
include/msgpack/v3
include/msgpack/*.hpp
include/msgpack.hpp
.gitmodules
external
make_file_list.sh
msgpack_vc8.sln
msgpack_vc8.vcproj
preprocess
QUICKSTART-CPP.md
test/*.cpp exclude test/*_c.cpp
.github/depends/boost.sh
ci/build_regression.sh
This commit is contained in:
yuangongji
2020-06-05 16:09:17 +08:00
parent 6e7deb8091
commit ee546036a1
820 changed files with 0 additions and 113794 deletions
Download Patch File Download Diff File Expand all files Collapse all files

327
test/array_ref.cpp
View File

@@ -1,327 +0,0 @@
#include <msgpack.hpp>
#include <string>
#include <sstream>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char)
{
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::array_ref<std::vector<char> > ar1 = msgpack::type::make_array_ref(v);
std::stringstream ss;
msgpack::pack(ss, ar1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::vector<char> v2;
msgpack::type::array_ref<std::vector<char> > ar2(v2);
oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char_const)
{
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
std::vector<char> const& cv = v;
msgpack::type::array_ref<std::vector<char> const> ar1 = msgpack::type::make_array_ref(cv);
std::stringstream ss;
msgpack::pack(ss, ar1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::vector<char> v2;
msgpack::type::array_ref<std::vector<char> > ar2(v2);
oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char)
{
std::vector<unsigned char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::array_ref<std::vector<unsigned char> > ar1 = msgpack::type::make_array_ref(v);
std::stringstream ss;
msgpack::pack(ss, ar1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::vector<unsigned char> v2;
msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char_const)
{
std::vector<unsigned char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
std::vector<unsigned char> const& cv = v;
msgpack::type::array_ref<std::vector<unsigned char> const> ar1 = msgpack::type::make_array_ref(cv);
std::stringstream ss;
msgpack::pack(ss, ar1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::vector<unsigned char> v2;
msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_char)
{
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::array_ref<std::vector<char> > ar1 = msgpack::type::make_array_ref(v);
msgpack::zone z;
msgpack::object obj(ar1, z);
EXPECT_EQ(obj.type, msgpack::type::ARRAY);
std::vector<char> v2;
msgpack::type::array_ref<std::vector<char> > ar2(v2);
obj.convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_char_const)
{
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
std::vector<char> const& cv = v;
msgpack::type::array_ref<std::vector<char> const> ar1 = msgpack::type::make_array_ref(cv);
msgpack::zone z;
msgpack::object obj(ar1, z);
EXPECT_EQ(obj.type, msgpack::type::ARRAY);
std::vector<char> v2;
msgpack::type::array_ref<std::vector<char> > ar2(v2);
obj.convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_unsigned_char)
{
std::vector<unsigned char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::array_ref<std::vector<unsigned char> > ar1 = msgpack::type::make_array_ref(v);
msgpack::zone z;
msgpack::object obj(ar1, z);
EXPECT_EQ(obj.type, msgpack::type::ARRAY);
std::vector<unsigned char> v2;
msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
obj.convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_unsigned_char_const)
{
std::vector<unsigned char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
std::vector<unsigned char> const& cv = v;
msgpack::type::array_ref<std::vector<unsigned char> const> ar1 = msgpack::type::make_array_ref(cv);
msgpack::zone z;
msgpack::object obj(ar1, z);
EXPECT_EQ(obj.type, msgpack::type::ARRAY);
std::vector<unsigned char> v2;
msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
obj.convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
#if !defined(MSGPACK_USE_CPP03)
TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char)
{
std::array<char, 3> v { { 'a', 'b', 'c' } };
msgpack::type::array_ref<std::array<char, 3> > ar1 = msgpack::type::make_array_ref(v);
std::stringstream ss;
msgpack::pack(ss, ar1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::array<char, 3> v2;
msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char_const)
{
std::array<char, 3> v { { 'a', 'b', 'c' } };
std::array<char, 3> const& cv = v;
msgpack::type::array_ref<std::array<char, 3> const> ar1 = msgpack::type::make_array_ref(cv);
std::stringstream ss;
msgpack::pack(ss, ar1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::array<char, 3> v2;
msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char)
{
std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
msgpack::type::array_ref<std::array<unsigned char, 3> > ar1 = msgpack::type::make_array_ref(v);
std::stringstream ss;
msgpack::pack(ss, ar1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::array<unsigned char, 3> v2;
msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char_const)
{
std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
std::array<unsigned char, 3> const& cv = v;
msgpack::type::array_ref<std::array<unsigned char, 3> const> ar1 = msgpack::type::make_array_ref(cv);
std::stringstream ss;
msgpack::pack(ss, ar1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::array<unsigned char, 3> v2;
msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
oh.get().convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, object_with_zone_array_char)
{
std::array<char, 3> v { { 'a', 'b', 'c' } };
msgpack::type::array_ref<std::array<char, 3> > ar1 = msgpack::type::make_array_ref(v);
msgpack::zone z;
msgpack::object obj(ar1, z);
EXPECT_EQ(obj.type, msgpack::type::ARRAY);
std::array<char, 3> v2;
msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
obj.convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, object_with_zone_array_char_const)
{
std::array<char, 3> v { { 'a', 'b', 'c' } };
std::array<char, 3> const& cv = v;
msgpack::type::array_ref<std::array<char, 3> const> ar1 = msgpack::type::make_array_ref(cv);
msgpack::zone z;
msgpack::object obj(ar1, z);
EXPECT_EQ(obj.type, msgpack::type::ARRAY);
std::array<char, 3> v2;
msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
obj.convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, object_with_zone_array_unsigned_char)
{
std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
msgpack::type::array_ref<std::array<unsigned char, 3> > ar1 = msgpack::type::make_array_ref(v);
msgpack::zone z;
msgpack::object obj(ar1, z);
EXPECT_EQ(obj.type, msgpack::type::ARRAY);
std::array<unsigned char, 3> v2;
msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
obj.convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
TEST(MSGPACK_ARRAY_REF, object_with_zone_array_unsigned_char_const)
{
std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
std::array<unsigned char, 3> const& cv = v;
msgpack::type::array_ref<std::array<unsigned char, 3> const> ar1 = msgpack::type::make_array_ref(cv);
msgpack::zone z;
msgpack::object obj(ar1, z);
EXPECT_EQ(obj.type, msgpack::type::ARRAY);
std::array<unsigned char, 3> v2;
msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
obj.convert(ar2);
EXPECT_TRUE(ar1 == ar2);
}
#endif // !defined(MSGPACK_USE_CPP03)

260
test/boost_fusion.cpp
View File

@@ -1,260 +0,0 @@
#include <msgpack.hpp>
#include <sstream>
#include <iterator>
#include <cmath>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if defined(MSGPACK_USE_BOOST)
#include <boost/fusion/adapted/struct/define_struct.hpp>
#include <boost/fusion/adapted/struct/adapt_struct.hpp>
const double kEPS = 1e-10;
BOOST_FUSION_DEFINE_STRUCT(
BOOST_PP_EMPTY(),
mystruct,
(int, f1)
(double, f2)
)
TEST(MSGPACK_BOOST, fusion_pack_unpack_convert)
{
std::stringstream ss;
mystruct val1;
val1.f1 = 42;
val1.f2 = 123.45;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
mystruct val2 = oh.get().as<mystruct>();
EXPECT_TRUE(val1.f1 == val2.f1);
EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
}
TEST(MSGPACK_BOOST, object_with_zone_convert)
{
mystruct val1;
val1.f1 = 42;
val1.f2 = 123.45;
msgpack::zone z;
msgpack::object obj(val1, z);
mystruct val2 = obj.as<mystruct>();
EXPECT_TRUE(val1.f1 == val2.f1);
EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
}
#if !defined(MSGPACK_USE_CPP03)
struct no_def_con1 {
no_def_con1() = delete;
no_def_con1(int i):i(i) {}
int i;
MSGPACK_DEFINE(i);
};
inline bool operator==(no_def_con1 const& lhs, no_def_con1 const& rhs) {
return lhs.i == rhs.i;
}
inline bool operator!=(no_def_con1 const& lhs, no_def_con1 const& rhs) {
return !(lhs == rhs);
}
struct no_def_con2 {
no_def_con2() = delete;
no_def_con2(int i):i(i) {}
int i;
MSGPACK_DEFINE(i);
};
inline bool operator==(no_def_con2 const& lhs, no_def_con2 const& rhs) {
return lhs.i == rhs.i;
}
inline bool operator!=(no_def_con2 const& lhs, no_def_con2 const& rhs) {
return !(lhs == rhs);
}
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor {
template <>
struct as<no_def_con1> {
no_def_con1 operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error();
return no_def_con1(o.via.array.ptr[0].as<int>());
}
};
template <>
struct as<no_def_con2> {
no_def_con2 operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error();
return no_def_con2(o.via.array.ptr[0].as<int>());
}
};
} // adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // msgpack
struct mystruct_no_def_con {
mystruct_no_def_con() = delete;
// Constructor that have parameters corresponding to BOOST_FUSION_ADAPT_STRUCT is mandatory.
// See *1, *2, and *3
mystruct_no_def_con(
no_def_con1 i,
no_def_con2 j,
no_def_con1 k):
f1(std::move(i)),
f2(std::move(j)),
f3(std::move(k)) {}
no_def_con1 f1;
no_def_con2 f2;
no_def_con1 f3;
};
inline bool operator==(mystruct_no_def_con const& lhs, mystruct_no_def_con const& rhs) {
return lhs.f1 == rhs.f1 && lhs.f2 == rhs.f2 && lhs.f3 == rhs.f3;
}
inline bool operator!=(mystruct_no_def_con const& lhs, mystruct_no_def_con const& rhs) {
return !(lhs == rhs);
}
BOOST_FUSION_ADAPT_STRUCT(
mystruct_no_def_con,
f1, // *1
f2, // *2
f3 // *3
)
// MSVC2015's std::tuple requires default constructor during 'as' process.
// It doesn't support Expression SFINAE yet, then 'as' is fallbacked to 'convert'.
// After MSVC would support Expression SFINAE, remove this guard.
#if !defined(_MSC_VER)
TEST(MSGPACK_BOOST, pack_convert_no_def_con)
{
std::stringstream ss;
mystruct_no_def_con val1(no_def_con1(1), no_def_con2(2), no_def_con1(3));
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
mystruct_no_def_con val2 = oh.get().as<mystruct_no_def_con>();
EXPECT_TRUE(val1 == val2);
}
#endif // !defined(_MSC_VER)
struct mystruct_no_def_con_def_con {
mystruct_no_def_con_def_con() = delete;
// Constructor that have parameters corresponding to BOOST_FUSION_ADAPT_STRUCT is mandatory.
// See *1, *2, and *3
mystruct_no_def_con_def_con(
no_def_con1 i,
no_def_con2 j,
int k):
f1(std::move(i)),
f2(std::move(j)),
f3(std::move(k)) {}
no_def_con1 f1;
no_def_con2 f2;
int f3;
};
inline bool operator==(mystruct_no_def_con_def_con const& lhs, mystruct_no_def_con_def_con const& rhs) {
return lhs.f1 == rhs.f1 && lhs.f2 == rhs.f2 && lhs.f3 == rhs.f3;
}
inline bool operator!=(mystruct_no_def_con_def_con const& lhs, mystruct_no_def_con_def_con const& rhs) {
return !(lhs == rhs);
}
BOOST_FUSION_ADAPT_STRUCT(
mystruct_no_def_con_def_con,
f1, // *1
f2, // *2
f3 // *3
)
// MSVC2015's std::tuple requires default constructor during 'as' process.
// It doesn't support Expression SFINAE yet, then 'as' is fallbacked to 'convert'.
// After MSVC would support Expression SFINAE, remove this guard.
#if !defined(_MSC_VER)
TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con)
{
std::stringstream ss;
mystruct_no_def_con_def_con val1(no_def_con1(1), no_def_con2(2), 3);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
mystruct_no_def_con_def_con val2 = oh.get().as<mystruct_no_def_con_def_con>();
EXPECT_TRUE(val1 == val2);
}
#endif // !defined(_MSC_VER)
#endif // !defined(MSGPACK_USE_CPP03
#include <boost/fusion/include/std_pair.hpp>
TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair)
{
std::stringstream ss;
std::pair<bool, int> val1(false, 42);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::pair<bool, int> val2 = oh.get().as<std::pair<bool, int> >();
EXPECT_TRUE(val1.first == val2.first);
EXPECT_TRUE(val1.second == val2.second);
}
#if !defined(MSGPACK_USE_CPP03)
#include <boost/fusion/include/std_tuple.hpp>
TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple)
{
std::stringstream ss;
std::tuple<bool, int> val1(false, 42);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::tuple<bool, int> val2 = oh.get().as<std::tuple<bool, int> >();
EXPECT_TRUE(val1 == val2);
}
#endif // !defined(MSGPACK_USE_CPP03)
#endif // defined(MSGPACK_USE_BOOST)

191
test/boost_optional.cpp
View File

@@ -1,191 +0,0 @@
#include <msgpack.hpp>
#include <sstream>
#include <iterator>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if defined(MSGPACK_USE_BOOST)
TEST(MSGPACK_BOOST, pack_convert_nil)
{
std::stringstream ss;
boost::optional<int> val1;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, pack_convert_int)
{
std::stringstream ss;
boost::optional<int> val1 = 1;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, pack_convert_vector)
{
typedef boost::optional<std::vector<int> > ovi_t;
std::stringstream ss;
ovi_t val1;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
val1 = v;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
ovi_t val2 = oh.get().as<ovi_t>();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, pack_convert_vector_optional)
{
typedef std::vector<boost::optional<int> > voi_t;
std::stringstream ss;
voi_t val1;
val1.resize(3);
val1[0] = 1;
val1[2] = 3;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
voi_t val2 = oh.get().as<voi_t>();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_nil)
{
boost::optional<int> val1;
msgpack::object obj(val1);
boost::optional<int> val2 = obj.as<boost::optional<int> >();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_int)
{
boost::optional<int> val1 = 1;
msgpack::object obj(val1);
boost::optional<int> val2 = obj.as<boost::optional<int> >();
EXPECT_TRUE(val1 == val2);
}
// Compile error as expected
/*
TEST(MSGPACK_BOOST, object_vector)
{
typedef boost::optional<std::vector<int> > ovi_t;
ovi_t val1;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
val1 = v;
msgpack::object obj(val1);
ovi_t val2 = obj.as<ovi_t>();
EXPECT_TRUE(val1 == val2);
}
*/
TEST(MSGPACK_BOOST, object_with_zone_nil)
{
msgpack::zone z;
boost::optional<int> val1;
msgpack::object obj(val1, z);
boost::optional<int> val2 = obj.as<boost::optional<int> >();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_int)
{
msgpack::zone z;
boost::optional<int> val1 = 1;
msgpack::object obj(val1, z);
boost::optional<int> val2 = obj.as<boost::optional<int> >();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_vector_optional)
{
typedef std::vector<boost::optional<int> > voi_t;
msgpack::zone z;
voi_t val1;
val1.resize(3);
val1[0] = 1;
val1[2] = 3;
msgpack::object obj(val1, z);
voi_t val2 = obj.as<voi_t>();
EXPECT_TRUE(val1 == val2);
}
#if !defined(MSGPACK_USE_CPP03)
struct no_def_con {
no_def_con() = delete;
no_def_con(int i):i(i) {}
int i;
MSGPACK_DEFINE(i);
};
inline bool operator==(no_def_con const& lhs, no_def_con const& rhs) {
return lhs.i == rhs.i;
}
inline bool operator!=(no_def_con const& lhs, no_def_con const& rhs) {
return !(lhs == rhs);
}
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor {
template <>
struct as<no_def_con> {
no_def_con operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error();
return no_def_con(o.via.array.ptr[0].as<int>());
}
};
} // adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // msgpack
TEST(MSGPACK_BOOST, pack_convert_no_def_con)
{
std::stringstream ss;
boost::optional<no_def_con> val1 = no_def_con(1);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
boost::optional<no_def_con> val2 = oh.get().as<boost::optional<no_def_con>>();
EXPECT_TRUE(val1 == val2);
}
#endif // !defined(MSGPACK_USE_CPP03
#endif // defined(MSGPACK_USE_BOOST)

58
test/boost_string_ref.cpp
View File

@@ -1,58 +0,0 @@
#include <msgpack.hpp>
#include <sstream>
#include <iterator>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if defined(MSGPACK_USE_BOOST)
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
TEST(MSGPACK_BOOST, pack_convert_string_ref)
{
std::stringstream ss;
std::string s = "ABC";
boost::string_ref val1(s);
msgpack::pack(ss, val1);
msgpack::object_handle oh;
std::string const& str = ss.str();
msgpack::unpack(oh, str.data(), str.size());
boost::string_ref val2 = oh.get().as<boost::string_ref>();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_strinf_ref)
{
std::string s = "ABC";
boost::string_ref val1(s);
msgpack::object obj(val1);
boost::string_ref val2 = obj.as<boost::string_ref>();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_string_ref)
{
msgpack::zone z;
std::string s = "ABC";
boost::string_ref val1(s);
msgpack::object obj(val1, z);
boost::string_ref val2 = obj.as<boost::string_ref>();
EXPECT_TRUE(val1 == val2);
}
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
#endif // defined(MSGPACK_USE_BOOST)

58
test/boost_string_view.cpp
View File

@@ -1,58 +0,0 @@
#include <msgpack.hpp>
#include <sstream>
#include <iterator>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if defined(MSGPACK_USE_BOOST)
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 61
TEST(MSGPACK_BOOST, pack_convert_string_view)
{
std::stringstream ss;
std::string s = "ABC";
boost::string_view val1(s);
msgpack::pack(ss, val1);
msgpack::object_handle oh;
std::string const& str = ss.str();
msgpack::unpack(oh, str.data(), str.size());
boost::string_view val2 = oh.get().as<boost::string_view>();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_strinf_view)
{
std::string s = "ABC";
boost::string_view val1(s);
msgpack::object obj(val1);
boost::string_view val2 = obj.as<boost::string_view>();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_string_view)
{
msgpack::zone z;
std::string s = "ABC";
boost::string_view val1(s);
msgpack::object obj(val1, z);
boost::string_view val2 = obj.as<boost::string_view>();
EXPECT_TRUE(val1 == val2);
}
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 61
#endif // defined(MSGPACK_USE_BOOST)

836
test/boost_variant.cpp
View File

@@ -1,836 +0,0 @@
#include <cmath>
#include <msgpack.hpp>
#include <sstream>
#include <iterator>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if defined(MSGPACK_USE_BOOST)
const double kEPS = 1e-10;
// nil
TEST(MSGPACK_BOOST, pack_convert_variant_nil)
{
std::stringstream ss;
msgpack::type::variant val1 = msgpack::type::nil_t();
EXPECT_TRUE(val1.is_nil());
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_nil());
EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
}
TEST(MSGPACK_BOOST, object_variant_nil)
{
msgpack::type::variant val1 = msgpack::type::nil_t();
EXPECT_TRUE(val1.is_nil());
msgpack::object obj(val1);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_nil());
EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
}
TEST(MSGPACK_BOOST, object_with_zone_variant_nil)
{
msgpack::zone z;
msgpack::type::variant val1 = msgpack::type::nil_t();
EXPECT_TRUE(val1.is_nil());
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_nil());
EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
}
// nil (default constructor)
TEST(MSGPACK_BOOST, pack_convert_variant_nil_default)
{
std::stringstream ss;
msgpack::type::variant val1;
EXPECT_TRUE(val1.is_nil());
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_nil());
EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
}
TEST(MSGPACK_BOOST, object_variant_nil_default)
{
msgpack::type::variant val1;
EXPECT_TRUE(val1.is_nil());
msgpack::object obj(val1);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_nil());
EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
}
TEST(MSGPACK_BOOST, object_with_zone_variant_nil_default)
{
msgpack::zone z;
msgpack::type::variant val1;
EXPECT_TRUE(val1.is_nil());
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_nil());
EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
}
// bool
TEST(MSGPACK_BOOST, pack_convert_variant_bool)
{
std::stringstream ss;
msgpack::type::variant val1 = true;
EXPECT_TRUE(val1.is_bool());
EXPECT_TRUE(val1.as_bool());
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_bool());
EXPECT_TRUE(val2.as_bool());
EXPECT_NO_THROW(boost::get<bool>(val2));
EXPECT_TRUE(val1 == val2);
// Tests for totally ordered
EXPECT_FALSE(val1 != val2);
EXPECT_FALSE(val1 < val2);
EXPECT_FALSE(val1 > val2);
EXPECT_TRUE(val1 <= val2);
EXPECT_TRUE(val1 >= val2);
}
TEST(MSGPACK_BOOST, object_variant_bool)
{
msgpack::type::variant val1 = true;
EXPECT_TRUE(val1.is_bool());
EXPECT_TRUE(val1.as_bool());
msgpack::object obj(val1);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_bool());
EXPECT_TRUE(val2.as_bool());
EXPECT_NO_THROW(boost::get<bool>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_bool)
{
msgpack::zone z;
msgpack::type::variant val1 = true;
EXPECT_TRUE(val1.is_bool());
EXPECT_TRUE(val1.as_bool());
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_bool());
EXPECT_TRUE(val2.as_bool());
EXPECT_NO_THROW(boost::get<bool>(val2));
EXPECT_TRUE(val1 == val2);
}
// positive integer
TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer)
{
std::stringstream ss;
msgpack::type::variant val1 = 123;
EXPECT_TRUE(val1.is_uint64_t());
EXPECT_EQ(val1.as_uint64_t(), 123U);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_uint64_t());
EXPECT_EQ(val2.as_uint64_t(), 123U);
EXPECT_NO_THROW(boost::get<uint64_t>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_variant_positive_integer)
{
msgpack::type::variant val1 = 123;
EXPECT_TRUE(val1.is_uint64_t());
EXPECT_EQ(val1.as_uint64_t(), 123U);
msgpack::object obj(val1);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_uint64_t());
EXPECT_EQ(val2.as_uint64_t(), 123U);
EXPECT_NO_THROW(boost::get<uint64_t>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_positive_integer)
{
msgpack::zone z;
msgpack::type::variant val1 = 123;
EXPECT_TRUE(val1.is_uint64_t());
EXPECT_EQ(val1.as_uint64_t(), 123U);
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_uint64_t());
EXPECT_EQ(val2.as_uint64_t(), 123U);
EXPECT_NO_THROW(boost::get<uint64_t>(val2));
EXPECT_TRUE(val1 == val2);
}
// negative integer
TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer)
{
std::stringstream ss;
msgpack::type::variant val1 = -123;
EXPECT_TRUE(val1.is_int64_t());
EXPECT_EQ(val1.as_int64_t(), -123);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_int64_t());
EXPECT_EQ(val2.as_int64_t(), -123);
EXPECT_NO_THROW(boost::get<int64_t>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_variant_negative_integer)
{
msgpack::type::variant val1 = -123;
EXPECT_TRUE(val1.is_int64_t());
EXPECT_EQ(val1.as_int64_t(), -123);
msgpack::object obj(val1);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_int64_t());
EXPECT_EQ(val2.as_int64_t(), -123);
EXPECT_NO_THROW(boost::get<int64_t>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_negative_integer)
{
msgpack::zone z;
msgpack::type::variant val1 = -123;
EXPECT_TRUE(val1.is_int64_t());
EXPECT_EQ(val1.as_int64_t(), -123);
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_int64_t());
EXPECT_EQ(val2.as_int64_t(), -123);
EXPECT_NO_THROW(boost::get<int64_t>(val2));
EXPECT_TRUE(val1 == val2);
}
// float
TEST(MSGPACK_BOOST, pack_convert_variant_float)
{
std::stringstream ss;
msgpack::type::variant val1 = 12.34;
EXPECT_TRUE(val1.is_double());
EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_double());
EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
EXPECT_NO_THROW(boost::get<double>(val2));
EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS);
}
TEST(MSGPACK_BOOST, object_variant_float)
{
msgpack::type::variant val1 = 12.34;
EXPECT_TRUE(val1.is_double());
EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS);
msgpack::object obj(val1);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_double());
EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
EXPECT_NO_THROW(boost::get<double>(val2));
EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_float)
{
msgpack::zone z;
msgpack::type::variant val1 = 12.34;
EXPECT_TRUE(val1.is_double());
EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS);
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_double());
EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
EXPECT_NO_THROW(boost::get<double>(val2));
EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS);
}
// str
TEST(MSGPACK_BOOST, pack_convert_variant_str)
{
std::stringstream ss;
msgpack::type::variant val1 = "ABC";
EXPECT_TRUE(val1.is_string());
EXPECT_EQ(val1.as_string(), "ABC");
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_string());
EXPECT_EQ(val2.as_string(), "ABC");
EXPECT_NO_THROW(boost::get<std::string>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_str)
{
msgpack::zone z;
msgpack::type::variant val1 = "ABC";
EXPECT_TRUE(val1.is_string());
EXPECT_EQ(val1.as_string(), "ABC");
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_string());
EXPECT_EQ(val2.as_string(), "ABC");
EXPECT_NO_THROW(boost::get<std::string>(val2));
EXPECT_TRUE(val1 == val2);
}
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
TEST(MSGPACK_BOOST, object_with_zone_variant_str_ref)
{
// You can use boost::string_ref with msgpack::type::variant.
msgpack::zone z;
std::string s = "ABC";
boost::string_ref sr(s);
msgpack::type::variant val1(sr);
EXPECT_TRUE(val1.is_boost_string_ref());
EXPECT_EQ(val1.as_boost_string_ref(), "ABC");
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
// Converted as std::string.
EXPECT_TRUE(val2.is_string());
EXPECT_EQ(val2.as_string(), "ABC");
EXPECT_NO_THROW(boost::get<std::string>(val2));
// boost::string_ref and std::string are different.
EXPECT_FALSE(val1 == val2);
}
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
// bin
TEST(MSGPACK_BOOST, pack_convert_variant_bin)
{
std::stringstream ss;
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::variant val1 = v;
EXPECT_TRUE(val1.is_vector_char());
EXPECT_EQ(val1.as_vector_char(), v);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_vector_char());
EXPECT_EQ(val2.as_vector_char(), v);
EXPECT_NO_THROW(boost::get<std::vector<char> >(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_bin)
{
msgpack::zone z;
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::variant val1 = v;
EXPECT_TRUE(val1.is_vector_char());
EXPECT_EQ(val1.as_vector_char(), v);
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_vector_char());
EXPECT_EQ(val2.as_vector_char(), v);
EXPECT_NO_THROW(boost::get<std::vector<char> >(val2));
EXPECT_TRUE(val1 == val2);
}
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
TEST(MSGPACK_BOOST, object_with_zone_variant_raw_ref)
{
// You can use boost::string_ref with msgpack::type::variant.
msgpack::zone z;
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::raw_ref rr(&v.front(), static_cast<uint32_t>(v.size()));
msgpack::type::variant val1 = rr;
EXPECT_TRUE(val1.is_raw_ref());
EXPECT_EQ(val1.as_raw_ref(), msgpack::type::raw_ref(&v.front(), static_cast<uint32_t>(v.size())));
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
// Converted as std::vector<char>.
EXPECT_TRUE(val2.is_vector_char());
EXPECT_EQ(val2.as_vector_char(), v);
EXPECT_NO_THROW(boost::get<std::vector<char> >(val2));
// msgpack::type::raw_ref and std::vector<char> are different.
EXPECT_FALSE(val1 == val2);
}
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
// ext
TEST(MSGPACK_BOOST, pack_convert_variant_ext)
{
std::stringstream ss;
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::ext e(42, v.data(), static_cast<uint32_t>(v.size()));
msgpack::type::variant val1(e);
EXPECT_TRUE(val1.is_ext());
EXPECT_EQ(val1.as_ext(), e);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_ext());
EXPECT_EQ(val2.as_ext(), e);
EXPECT_NO_THROW(boost::get<msgpack::type::ext>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_ext)
{
msgpack::zone z;
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::ext e(42, v.data(), static_cast<uint32_t>(v.size()));
msgpack::type::variant val1(e);
EXPECT_TRUE(val1.is_ext());
EXPECT_EQ(val1.as_ext(), e);
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_ext());
EXPECT_EQ(val2.as_ext(), e);
EXPECT_NO_THROW(boost::get<msgpack::type::ext>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_ext_ref)
{
// You can use msgpack::type::ext_ref with msgpack::type::variant.
msgpack::zone z;
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::ext_ref e(v.data(), static_cast<uint32_t>(v.size()));
msgpack::type::variant val1(e);
EXPECT_TRUE(val1.is_ext_ref());
EXPECT_EQ(val1.as_ext_ref(), e);
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
// Converted as msgpack::type::ext.
EXPECT_TRUE(val2.is_ext());
EXPECT_EQ(val2.as_ext(), e);
EXPECT_NO_THROW(boost::get<msgpack::type::ext>(val2));
// msgpack::type::ext_ref and msgpack::type::ext are different.
EXPECT_FALSE(val1 == val2);
}
// array
TEST(MSGPACK_BOOST, pack_convert_variant_array)
{
std::stringstream ss;
std::vector<msgpack::type::variant> v;
v.push_back(msgpack::type::variant(1));
v.push_back(msgpack::type::variant(-1));
v.push_back(msgpack::type::variant("ABC"));
msgpack::type::variant val1 = v;
EXPECT_TRUE(val1.is_vector());
EXPECT_EQ(val1.as_vector(), v);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_vector());
EXPECT_EQ(val2.as_vector(), v);
EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant> >(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_array)
{
msgpack::zone z;
std::vector<msgpack::type::variant> v;
v.push_back(msgpack::type::variant(1));
v.push_back(msgpack::type::variant(-1));
v.push_back(msgpack::type::variant("ABC"));
msgpack::type::variant val1 = v;
EXPECT_TRUE(val1.is_vector());
EXPECT_EQ(val1.as_vector(), v);
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_vector());
EXPECT_EQ(val2.as_vector(), v);
EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant> >(val2));
EXPECT_TRUE(val1 == val2);
}
// multimap
TEST(MSGPACK_BOOST, pack_convert_variant_map)
{
std::stringstream ss;
typedef std::multimap<msgpack::type::variant, msgpack::type::variant> multimap_t;
multimap_t v;
v.insert(multimap_t::value_type(msgpack::type::variant(1), msgpack::type::variant(-1)));
v.insert(multimap_t::value_type(msgpack::type::variant("ABC"), msgpack::type::variant("DEF")));
msgpack::type::variant val1 = v;
EXPECT_TRUE(val1.is_multimap());
EXPECT_EQ(val1.as_multimap(), v);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_multimap());
EXPECT_EQ(val2.as_multimap(), v);
EXPECT_NO_THROW(boost::get<multimap_t>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_map)
{
msgpack::zone z;
typedef std::multimap<msgpack::type::variant, msgpack::type::variant> multimap_t;
multimap_t v;
v.insert(multimap_t::value_type(msgpack::type::variant(1), msgpack::type::variant(-1)));
v.insert(multimap_t::value_type(msgpack::type::variant("ABC"), msgpack::type::variant("DEF")));
msgpack::type::variant val1 = v;
EXPECT_TRUE(val1.is_multimap());
EXPECT_EQ(val1.as_multimap(), v);
msgpack::object obj(val1, z);
msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
EXPECT_TRUE(val2.is_multimap());
EXPECT_EQ(val2.as_multimap(), v);
EXPECT_NO_THROW(boost::get<multimap_t>(val2));
EXPECT_TRUE(val1 == val2);
}
// variant_ref
// str
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
TEST(MSGPACK_BOOST, pack_convert_variant_ref_str)
{
std::stringstream ss;
std::string s("ABC");
boost::string_ref sr(s);
msgpack::type::variant_ref val1 = sr;
EXPECT_TRUE(val1.is_boost_string_ref());
EXPECT_EQ(val1.as_boost_string_ref(), sr);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_boost_string_ref());
EXPECT_EQ(val2.as_boost_string_ref(), sr);
EXPECT_NO_THROW(boost::get<boost::string_ref>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_ref_str)
{
msgpack::zone z;
std::string s("ABC");
boost::string_ref sr(s);
msgpack::type::variant_ref val1 = sr;
EXPECT_TRUE(val1.is_boost_string_ref());
EXPECT_EQ(val1.as_boost_string_ref(), sr);
msgpack::object obj(val1, z);
msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_boost_string_ref());
EXPECT_EQ(val2.as_boost_string_ref(), sr);
EXPECT_NO_THROW(boost::get<boost::string_ref>(val2));
EXPECT_TRUE(val1 == val2);
}
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
// bin
TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin)
{
std::stringstream ss;
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::raw_ref rr(v.data(), static_cast<uint32_t>(v.size()));
msgpack::type::variant_ref val1 = rr;
EXPECT_TRUE(val1.is_raw_ref());
EXPECT_EQ(val1.as_raw_ref(), rr);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_raw_ref());
EXPECT_EQ(val2.as_raw_ref(), rr);
EXPECT_NO_THROW(boost::get<msgpack::type::raw_ref>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_ref_bin)
{
msgpack::zone z;
std::vector<char> v;
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::raw_ref rr(v.data(), static_cast<uint32_t>(v.size()));
msgpack::type::variant_ref val1 = rr;
EXPECT_TRUE(val1.is_raw_ref());
EXPECT_EQ(val1.as_raw_ref(), rr);
msgpack::object obj(val1, z);
msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_raw_ref());
EXPECT_EQ(val2.as_raw_ref(), rr);
EXPECT_NO_THROW(boost::get<msgpack::type::raw_ref>(val2));
EXPECT_TRUE(val1 == val2);
}
// ext
TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext)
{
std::stringstream ss;
std::vector<char> v;
v.push_back(static_cast<char>(42));
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::ext_ref er(v.data(), static_cast<uint32_t>(v.size()));
msgpack::type::variant_ref val1(er);
EXPECT_TRUE(val1.is_ext_ref());
EXPECT_EQ(val1.as_ext_ref(), er);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_NO_THROW(boost::get<msgpack::type::ext_ref>(val2));
EXPECT_TRUE(val2.is_ext_ref());
EXPECT_EQ(val2.as_ext_ref(), er);
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_ref_ext)
{
msgpack::zone z;
std::vector<char> v;
v.push_back(static_cast<char>(42));
v.push_back('a');
v.push_back('b');
v.push_back('c');
msgpack::type::ext_ref er(v.data(), static_cast<uint32_t>(v.size()));
msgpack::type::variant_ref val1(er);
EXPECT_TRUE(val1.is_ext_ref());
EXPECT_EQ(val1.as_ext_ref(), er);
msgpack::object obj(val1, z);
msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_ext_ref());
EXPECT_EQ(val2.as_ext_ref(), er);
EXPECT_NO_THROW(boost::get<msgpack::type::ext_ref>(val2));
EXPECT_TRUE(val1 == val2);
}
// array
TEST(MSGPACK_BOOST, pack_convert_variant_ref_array)
{
std::stringstream ss;
std::vector<msgpack::type::variant_ref> v;
v.push_back(msgpack::type::variant_ref(1));
v.push_back(msgpack::type::variant_ref(-1));
std::string s("ABC");
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
v.push_back(msgpack::type::variant_ref(boost::string_ref(s)));
#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
v.push_back(msgpack::type::variant_ref(s));
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
msgpack::type::variant_ref val1 = v;
EXPECT_TRUE(val1.is_vector());
EXPECT_EQ(val1.as_vector(), v);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_vector());
EXPECT_EQ(val2.as_vector(), v);
EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant_ref> >(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_ref_array)
{
msgpack::zone z;
std::vector<msgpack::type::variant_ref> v;
v.push_back(msgpack::type::variant_ref(1));
v.push_back(msgpack::type::variant_ref(-1));
std::string s("ABC");
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
v.push_back(msgpack::type::variant_ref(boost::string_ref(s)));
#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
v.push_back(msgpack::type::variant_ref(s));
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
msgpack::type::variant_ref val1 = v;
EXPECT_TRUE(val1.is_vector());
EXPECT_EQ(val1.as_vector(), v);
msgpack::object obj(val1, z);
msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_vector());
EXPECT_EQ(val2.as_vector(), v);
EXPECT_NO_THROW(boost::get<std::vector<msgpack::type::variant_ref> >(val2));
EXPECT_TRUE(val1 == val2);
}
// multimap
TEST(MSGPACK_BOOST, pack_convert_variant_ref_map)
{
std::stringstream ss;
typedef std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref> multimap_t;
multimap_t v;
v.insert(multimap_t::value_type(msgpack::type::variant_ref(1), msgpack::type::variant_ref(-1)));
std::string s1("ABC");
std::string s2("DEF");
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
v.insert(multimap_t::value_type(msgpack::type::variant_ref(boost::string_ref(s1)), msgpack::type::variant_ref(boost::string_ref(s2))));
#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
v.insert(multimap_t::value_type(msgpack::type::variant_ref(s1), msgpack::type::variant_ref(s2)));
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
msgpack::type::variant_ref val1 = v;
EXPECT_TRUE(val1.is_multimap());
EXPECT_EQ(val1.as_multimap(), v);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_multimap());
EXPECT_EQ(val2.as_multimap(), v);
EXPECT_NO_THROW(boost::get<multimap_t>(val2));
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_BOOST, object_with_zone_variant_ref_map)
{
msgpack::zone z;
typedef std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref> multimap_t;
multimap_t v;
v.insert(multimap_t::value_type(msgpack::type::variant_ref(1), msgpack::type::variant_ref(-1)));
std::string s1("ABC");
std::string s2("DEF");
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
v.insert(multimap_t::value_type(msgpack::type::variant_ref(boost::string_ref(s1)), msgpack::type::variant_ref(boost::string_ref(s2))));
#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
v.insert(multimap_t::value_type(msgpack::type::variant_ref(s1), msgpack::type::variant_ref(s2)));
#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
msgpack::type::variant_ref val1 = v;
EXPECT_TRUE(val1.is_multimap());
EXPECT_EQ(val1.as_multimap(), v);
msgpack::object obj(val1, z);
msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
EXPECT_TRUE(val2.is_multimap());
EXPECT_EQ(val2.as_multimap(), v);
EXPECT_NO_THROW(boost::get<multimap_t>(val2));
EXPECT_TRUE(val1 == val2);
}
#endif // defined(MSGPACK_USE_BOOST)

111
test/buffer.cpp
View File

@@ -1,111 +0,0 @@
#include <msgpack.hpp>
#include <msgpack/fbuffer.hpp>
#include <msgpack/zbuffer.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__)
#include <string.h>
TEST(buffer, sbuffer)
{
msgpack::sbuffer sbuf;
sbuf.write("a", 1);
sbuf.write("a", 1);
sbuf.write("a", 1);
EXPECT_EQ(3ul, sbuf.size());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
sbuf.clear();
sbuf.write("a", 1);
sbuf.write("a", 1);
sbuf.write("a", 1);
EXPECT_EQ(3ul, sbuf.size());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
}
TEST(buffer, vrefbuffer)
{
msgpack::vrefbuffer vbuf;
vbuf.write("a", 1);
vbuf.write("a", 1);
vbuf.write("a", 1);
const struct iovec* vec = vbuf.vector();
size_t veclen = vbuf.vector_size();
msgpack::sbuffer sbuf;
for(size_t i=0; i < veclen; ++i) {
sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len);
}
EXPECT_EQ(3ul, sbuf.size());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
vbuf.clear();
vbuf.write("a", 1);
vbuf.write("a", 1);
vbuf.write("a", 1);
vec = vbuf.vector();
veclen = vbuf.vector_size();
sbuf.clear();
for(size_t i=0; i < veclen; ++i) {
sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len);
}
EXPECT_EQ(3ul, sbuf.size());
EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
}
TEST(buffer, zbuffer)
{
msgpack::zbuffer zbuf;
zbuf.write("a", 1);
zbuf.write("a", 1);
zbuf.write("a", 1);
zbuf.write("", 0);
zbuf.flush();
}
TEST(buffer, fbuffer)
{
#if defined(_MSC_VER)
FILE* file;
tmpfile_s(&file);
#else // defined(_MSC_VER)
FILE* file = tmpfile();
#endif // defined(_MSC_VER)
EXPECT_TRUE( file != NULL );
msgpack::fbuffer fbuf(file);
EXPECT_EQ(file, fbuf.file());
fbuf.write("a", 1);
fbuf.write("a", 1);
fbuf.write("a", 1);
fflush(file);
rewind(file);
for (size_t i=0; i < 3; ++i) {
int ch = fgetc(file);
EXPECT_TRUE(ch != EOF);
EXPECT_EQ('a', static_cast<char>(ch));
}
EXPECT_EQ(EOF, fgetc(file));
fclose(file);
}

283
test/carray.cpp
View File

@@ -1,283 +0,0 @@
#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__)
#include <sstream>
TEST(carray, pack_unpack_int)
{
std::stringstream ss;
int v1[] = { 0, 1 };
msgpack::pack(ss, v1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
int v2[2];
oh.get().convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, obj_with_zone_int)
{
int v1[] = { 0, 1 };
msgpack::zone z;
msgpack::object o(v1, z);
EXPECT_EQ(o.type, msgpack::type::ARRAY);
int v2[2];
o.convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, pack_unpack_const_int)
{
std::stringstream ss;
const int v1[] = { 0, 1 };
msgpack::pack(ss, v1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
int v2[2];
oh.get().convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, obj_with_zone_const_int)
{
const int v1[] = { 0, 1 };
msgpack::zone z;
msgpack::object o(v1, z);
EXPECT_EQ(o.type, msgpack::type::ARRAY);
int v2[2];
o.convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, pack_unpack_string)
{
std::stringstream ss;
std::string v1[] = { "ABC", "DEFG" };
msgpack::pack(ss, v1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
std::string v2[2];
oh.get().convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, obj_with_zone_string)
{
std::string v1[] = { "ABC", "DEFG" };
msgpack::zone z;
msgpack::object o(v1, z);
EXPECT_EQ(o.type, msgpack::type::ARRAY);
std::string v2[2];
o.convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, pack_unpack_char)
{
std::stringstream ss;
char v1[] = { 0, 1 };
msgpack::pack(ss, msgpack::type::make_array_ref(v1));
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
char v2[2];
msgpack::type::array_ref<char[2]> ar = msgpack::type::make_array_ref(v2);
oh.get().convert(ar);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, pack_unpack_char_as_str)
{
std::stringstream ss;
char v1[2] = { 1, '\0' };
msgpack::pack(ss, v1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::STR);
EXPECT_EQ(oh.get().via.str.size, static_cast<size_t>(1));
char v2[2] = { 2, 3 };
oh.get().convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, obj_with_zone_char)
{
char v1[] = { 0, 1 };
msgpack::zone z;
msgpack::object o(msgpack::type::make_array_ref(v1), z);
EXPECT_EQ(o.type, msgpack::type::ARRAY);
char v2[2];
msgpack::type::array_ref<char[2]> ar = msgpack::type::make_array_ref(v2);
o.convert(ar);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, obj_with_zone_char_as_str)
{
char v1[] = { 1, '\0' };
msgpack::zone z;
msgpack::object o(v1, z);
EXPECT_EQ(o.type, msgpack::type::STR);
EXPECT_EQ(o.via.str.size, static_cast<size_t>(1));
char v2[2];
o.convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, pack_unpack_unsigned_char)
{
std::stringstream ss;
unsigned char v1[] = { 0, 1 };
msgpack::pack(ss, msgpack::type::make_array_ref(v1));
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
unsigned char v2[2];
msgpack::type::array_ref<unsigned char[2]> ar = msgpack::type::make_array_ref(v2);
oh.get().convert(ar);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, pack_unpack_unsigned_char_as_bin)
{
std::stringstream ss;
unsigned char v1[] = { 0, 1 };
msgpack::pack(ss, v1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::BIN);
EXPECT_EQ(oh.get().via.bin.size, static_cast<size_t>(2));
unsigned char v2[2];
oh.get().convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, obj_with_zone_unsigned_char)
{
unsigned char v1[] = { 0, 1 };
msgpack::zone z;
msgpack::object o(msgpack::type::make_array_ref(v1), z);
EXPECT_EQ(o.type, msgpack::type::ARRAY);
unsigned char v2[2];
msgpack::type::array_ref<unsigned char[2]> ar = msgpack::type::make_array_ref(v2);
o.convert(ar);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, obj_with_zone_unsigned_char_as_bin)
{
unsigned char v1[] = { 0, 1 };
msgpack::zone z;
msgpack::object o(v1, z);
EXPECT_EQ(o.type, msgpack::type::BIN);
EXPECT_EQ(o.via.bin.size, static_cast<size_t>(2));
unsigned char v2[2];
o.convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, pack_unpack_signed_char)
{
std::stringstream ss;
signed char v1[] = { 0, 1 };
msgpack::pack(ss, v1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
signed char v2[2];
oh.get().convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
TEST(carray, obj_with_zone_signed_char)
{
signed char v1[] = { 0, 1 };
msgpack::zone z;
msgpack::object o(v1, z);
EXPECT_EQ(o.type, msgpack::type::ARRAY);
signed char v2[2];
o.convert(v2);
EXPECT_EQ(v1[0], v2[0]);
EXPECT_EQ(v1[1], v2[1]);
}
#if MSGPACK_DEFAULT_API_VERSION == 1
TEST(carray, object_as_str)
{
char v1[] = { 1, '\0' };
msgpack::zone z;
msgpack::object o(v1);
EXPECT_EQ(o.type, msgpack::type::STR);
}
TEST(carray, object_as_str_const)
{
const char v1[] = { 1, '\0' };
msgpack::zone z;
msgpack::object o(v1);
EXPECT_EQ(o.type, msgpack::type::STR);
}
#endif // MSGPACK_DEFAULT_API_VERSION == 1

54
test/cases.cpp
View File

@@ -1,54 +0,0 @@
#include <msgpack.hpp>
#include <fstream>
#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__)
static void feed_file(msgpack::unpacker& pac, const char* path)
{
std::ifstream fin(path);
while(true) {
pac.reserve_buffer(32*1024);
fin.read(pac.buffer(), static_cast<std::streamsize>(pac.buffer_capacity()));
if(fin.bad()) {
throw std::runtime_error("read failed");
}
pac.buffer_consumed(static_cast<size_t>(fin.gcount()));
if(fin.fail()) {
break;
}
}
}
TEST(cases, format)
{
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
msgpack::unpacker pac;
msgpack::unpacker pac_compact;
feed_file(pac, "cases.mpac");
feed_file(pac_compact, "cases_compact.mpac");
msgpack::object_handle oh;
while(pac.next(oh)) {
msgpack::object_handle oh_compact;
EXPECT_TRUE( pac_compact.next(oh_compact) );
EXPECT_EQ(oh_compact.get(), oh.get());
}
EXPECT_FALSE( pac_compact.next(oh) );
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
}

BIN
test/cases.mpac
View File

Binary file not shown.

BIN
test/cases_compact.mpac
View File

Binary file not shown.

134
test/convert.cpp
View File

@@ -1,134 +0,0 @@
#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__)
class enum_member {
public:
enum_member() : flag(A) { }
enum flags_t {
A = 0,
B = 1
};
flags_t flag;
MSGPACK_DEFINE(flag);
};
MSGPACK_ADD_ENUM(enum_member::flags_t);
class compatibility {
public:
compatibility() : str1("default"), str2("default") { }
std::string str1;
std::string str2;
MSGPACK_DEFINE(str1, str2);
};
TEST(convert, compatibility_less)
{
std::vector<std::string> src(1);
src[0] = "kumofs";
msgpack::zone z;
msgpack::object obj(src, z);
compatibility c;
EXPECT_NO_THROW( obj.convert(c) );
EXPECT_EQ("kumofs", c.str1);
EXPECT_EQ("default", c.str2);
}
TEST(convert, compatibility_more)
{
std::vector<std::string> src(3);
src[0] = "kumofs";
src[1] = "mpio";
src[2] = "cloudy";
msgpack::zone z;
msgpack::object obj(src, z);
compatibility to;
EXPECT_NO_THROW( obj.convert(to) );
EXPECT_EQ("kumofs", to.str1);
EXPECT_EQ("mpio", to.str2);
}
TEST(convert, enum_member)
{
enum_member src;
src.flag = enum_member::B;
msgpack::zone z;
msgpack::object obj(src, z);
enum_member to;
EXPECT_NO_THROW( obj.convert(to) );
EXPECT_EQ(enum_member::B, to.flag);
}
TEST(convert, return_value_ref)
{
msgpack::zone z;
msgpack::object obj(1, z);
int i;
int const& j = obj.convert(i);
EXPECT_EQ(&i, &j);
EXPECT_EQ(i, j);
}
#if MSGPACK_DEFAULT_API_VERSION == 1 && !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
TEST(convert, return_value_ptr)
{
msgpack::zone z;
msgpack::object obj(1, z);
int i;
// obsolete
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
EXPECT_EQ(obj.convert(&i), &i);
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
EXPECT_EQ(1, i);
}
#endif // MSGPACK_DEFAULT_API_VERSION == 1 && !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
TEST(convert, if_not_nil_nil)
{
msgpack::object obj;
int i;
EXPECT_FALSE(obj.convert_if_not_nil(i));
}
TEST(convert, if_not_nil_not_nil)
{
msgpack::zone z;
msgpack::object obj(1, z);
int i;
EXPECT_TRUE(obj.convert_if_not_nil(i));
EXPECT_EQ(i, 1);
}

64
test/fixint.cpp
View File

@@ -1,64 +0,0 @@
#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__)
template <typename T>
void check_size(size_t size) {
T v(0);
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, v);
EXPECT_EQ(size, sbuf.size());
}
TEST(fixint, size)
{
check_size<msgpack::type::fix_int8>(2);
check_size<msgpack::type::fix_int16>(3);
check_size<msgpack::type::fix_int32>(5);
check_size<msgpack::type::fix_int64>(9);
check_size<msgpack::type::fix_uint8>(2);
check_size<msgpack::type::fix_uint16>(3);
check_size<msgpack::type::fix_uint32>(5);
check_size<msgpack::type::fix_uint64>(9);
}
template <typename T>
void check_convert() {
T v1(typename T::value_type(-11));
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, v1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
T v2;
oh.get().convert(v2);
EXPECT_EQ(v1.get(), v2.get());
EXPECT_EQ(oh.get(), msgpack::object(T(v1.get())));
}
TEST(fixint, convert)
{
check_convert<msgpack::type::fix_int8>();
check_convert<msgpack::type::fix_int16>();
check_convert<msgpack::type::fix_int32>();
check_convert<msgpack::type::fix_int64>();
check_convert<msgpack::type::fix_uint8>();
check_convert<msgpack::type::fix_uint16>();
check_convert<msgpack::type::fix_uint32>();
check_convert<msgpack::type::fix_uint64>();
}

17
test/fuzz_unpack_pack_fuzzer_cpp11.cpp
View File

@@ -1,17 +0,0 @@
#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__)
#include "../fuzz/unpack_pack_fuzzer.cpp"
TEST(FUZZ_UNPACK_PACK_FUZZER, works)
{
EXPECT_EQ(0, LLVMFuzzerTestOneInput(0, 0));
}

3
test/inc_adaptor_define.cpp
View File

@@ -1,3 +0,0 @@
#include <msgpack/adaptor/define.hpp>
int main() {}

81
test/iterator_cpp11.cpp
View File

@@ -1,81 +0,0 @@
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
using namespace std;
#if !defined(MSGPACK_USE_CPP03)
#include <iterator>
// C++11
constexpr unsigned int VECTOR_SIZE = 100;
constexpr unsigned int MAP_SIZE = 100;
TEST(iterator, vector)
{
using vec_type = vector<unsigned int>;
vec_type vec;
vec.reserve(VECTOR_SIZE);
for (unsigned int i = 0; i < VECTOR_SIZE; i++) {
vec.push_back(static_cast<unsigned int>(rand()));
}
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, vec);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
auto const& msgarr = oh.get().via.array;
auto dist = std::distance(begin(msgarr), end(msgarr));
auto vecSize = vec.size();
EXPECT_EQ(static_cast<size_t>(dist), vecSize);
vec_type::const_iterator correct = std::begin(vec);
for (auto const& obj : msgarr) {
auto u64 = *correct;
EXPECT_EQ(obj.as<unsigned int>(), u64);
++correct;
}
}
TEST(iterator, map)
{
using map_type = map<unsigned int, unsigned int>;
map_type map;
for (unsigned int i = 0; i < MAP_SIZE; i++) {
map[static_cast<unsigned int>(rand())] = static_cast<unsigned int>(rand());
}
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, map);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
auto const& msgmap = oh.get().via.map;
auto dist = std::distance(begin(msgmap), end(msgmap));
auto mapSize = map.size();
EXPECT_EQ(static_cast<size_t>(dist), mapSize);
for (auto const& kv : msgmap) {
auto key = kv.key.as<unsigned int>();
auto val = kv.val.as<unsigned int>();
auto correct = map[key];
EXPECT_EQ(val, correct);
}
}
#endif // !defined(MSGPACK_USE_CPP03

56
test/json.cpp
View File

@@ -1,56 +0,0 @@
#include <msgpack.hpp>
#include <fstream>
#include <sstream>
#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__)
TEST(json, basic_elements)
{
typedef std::map<std::string, int> map_s_i;
map_s_i msi;
msi.insert(map_s_i::value_type("Hello", 789));
msi.insert(map_s_i::value_type("World", -789));
msgpack::type::tuple<int, int, double, double, bool, bool, std::string, map_s_i>
t1(12, -34, 1.23, -4.56, true, false, "ABC", msi);
msgpack::zone z;
msgpack::object o(t1, z);
std::stringstream ss;
ss << o;
EXPECT_EQ(ss.str(), "[12,-34,1.23,-4.56,true,false,\"ABC\",{\"Hello\":789,\"World\":-789}]");
}
TEST(json, escape)
{
std::string s = "\"\\/\b\f\n\r\tabc";
msgpack::zone z;
msgpack::object o(s, z);
std::stringstream ss;
ss << o;
EXPECT_EQ(ss.str(), "\"\\\"\\\\\\/\\b\\f\\n\\r\\tabc\"");
}
TEST(json, escape_cc)
{
std::string s;
for (int i = 0; i < 0x20; ++i)
s.push_back(static_cast<char>(i));
s.push_back(0x7f);
s.push_back(0x20);
msgpack::zone z;
msgpack::object o(s, z);
std::stringstream ss;
ss << o;
EXPECT_EQ(ss.str(), "\"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f\\u007f \"");
}

595
test/limit.cpp
View File

@@ -1,595 +0,0 @@
#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__)
#include <sstream>
TEST(limit, unpack_array_no_over)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(3, 0, 0, 0, 0));
EXPECT_TRUE(true);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(false);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_array_over)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_map_no_over)
{
std::stringstream ss;
std::map<int, int> m;
m[1] = 1;
m[2] = 2;
m[3] = 3;
msgpack::pack(ss, m);
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 3, 0, 0, 0));
EXPECT_TRUE(true);
}
catch(msgpack::map_size_overflow const&) {
EXPECT_TRUE(false);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_map_over)
{
std::stringstream ss;
std::map<int, int> m;
m[1] = 1;
m[2] = 2;
m[3] = 3;
msgpack::pack(ss, m);
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 2, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::map_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_str_no_over)
{
std::stringstream ss;
std::string s("123");
msgpack::pack(ss, s);
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 0, 3, 0, 0));
EXPECT_TRUE(true);
}
catch(msgpack::str_size_overflow const&) {
EXPECT_TRUE(false);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_str_over)
{
std::stringstream ss;
std::string s("123");
msgpack::pack(ss, s);
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 0, 2, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::str_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_bin_no_over)
{
std::stringstream ss;
std::vector<char> v;
v.push_back('1');
v.push_back('2');
v.push_back('3');
msgpack::pack(ss, v);
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 0, 0, 3, 0));
EXPECT_TRUE(true);
}
catch(msgpack::bin_size_overflow const&) {
EXPECT_TRUE(false);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_bin_over)
{
std::stringstream ss;
std::vector<char> v;
v.push_back('1');
v.push_back('2');
v.push_back('3');
msgpack::pack(ss, v);
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 0, 0, 2, 0));
EXPECT_TRUE(false);
}
catch(msgpack::bin_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_ext_no_over)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char const buf [] = { 1, 2, 3 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 0, 0, 0, 3+1));
EXPECT_TRUE(true);
}
catch(msgpack::ext_size_overflow const&) {
EXPECT_TRUE(false);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_ext_over)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char const buf [] = { 1, 2, 3 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
try {
msgpack::object_handle oh =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 0, 0, 0, 2+1));
EXPECT_TRUE(false);
}
catch(msgpack::ext_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_ext_over_32_bit)
{
if (sizeof(std::size_t) == 4) {
char const buf [] = {
static_cast<char>(0xc9u),
static_cast<char>(0xffu),
static_cast<char>(0xffu),
static_cast<char>(0xffu),
static_cast<char>(0xffu),
static_cast<char>(0x01u),
};
try {
msgpack::object_handle unp;
msgpack::unpack(unp, buf, sizeof(buf), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff));
EXPECT_TRUE(false);
}
catch(msgpack::ext_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
}
TEST(limit, unpack_ext_no_over_64_bit)
{
if (sizeof(std::size_t) == 8) {
char const buf [] = {
static_cast<char>(0xc9u),
static_cast<char>(0xffu),
static_cast<char>(0xffu),
static_cast<char>(0xffu),
static_cast<char>(0xffu),
static_cast<char>(0x01u),
};
try {
msgpack::object_handle unp;
msgpack::unpack(unp, buf, sizeof(buf), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff));
EXPECT_TRUE(false);
}
catch(msgpack::ext_size_overflow const&) {
EXPECT_TRUE(false);
}
catch(msgpack::insufficient_bytes const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
}
TEST(limit, unpack_depth_no_over)
{
std::stringstream ss;
std::vector<int> inner;
inner.push_back(1);
std::vector<std::vector<int> > outer;
outer.push_back(inner);
msgpack::pack(ss, outer);
try {
msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(1, 0, 0, 0, 0, 2));
EXPECT_TRUE(true);
}
catch(msgpack::depth_size_overflow const&) {
EXPECT_TRUE(false);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_depth_over)
{
std::stringstream ss;
std::vector<int> inner;
inner.push_back(1);
std::vector<std::vector<int> > outer;
outer.push_back(inner);
msgpack::pack(ss, outer);
try {
msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(1, 0, 0, 0, 0, 1));
EXPECT_TRUE(false);
}
catch(msgpack::depth_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
#if !defined(MSGPACK_USE_CPP03)
TEST(limit, unpack_array_over_cpp11_no_off_no_ref)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
msgpack::object_handle unp =
msgpack::unpack(ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_array_over_cpp11_no_off_ref)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
bool ref;
msgpack::object_handle unp =
msgpack::unpack(ss.str().c_str(), ss.str().size(), ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_array_over_cpp11_off_no_ref)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
std::size_t off = 0;
msgpack::object_handle unp =
msgpack::unpack(ss.str().c_str(), ss.str().size(), off, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_array_over_cpp11_off_ref)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
bool ref;
std::size_t off = 0;
msgpack::object_handle unp =
msgpack::unpack(ss.str().c_str(), ss.str().size(), off, ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
#endif // !defined(MSGPACK_USE_CPP03)
TEST(limit, unpack_array_over_no_off_no_ref)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_array_over_no_off_ref)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
bool ref;
msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_array_over_off_no_ref)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
std::size_t off = 0;
msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpack_array_over_off_ref)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
bool ref;
std::size_t off = 0;
msgpack::object_handle unp;
msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
// obsolete
#if MSGPACK_DEFAULT_API_VERSION == 1
TEST(limit, unpack_array_over_off_ref_pointer)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
bool ref;
std::size_t off = 0;
msgpack::object_handle unp;
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
msgpack::unpack(&unp, ss.str().c_str(), ss.str().size(), &off, &ref, MSGPACK_NULLPTR, MSGPACK_NULLPTR,
msgpack::unpack_limit(2, 0, 0, 0, 0));
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
#endif // MSGPACK_DEFAULT_API_VERSION == 1
TEST(limit, unpacker_array_over)
{
std::stringstream ss;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::pack(ss, v);
try {
msgpack::unpacker u(MSGPACK_NULLPTR, MSGPACK_NULLPTR, MSGPACK_UNPACKER_INIT_BUFFER_SIZE,
msgpack::unpack_limit(2, 0, 0, 0, 0));
u.reserve_buffer(ss.str().size());
memcpy(u.buffer(), ss.str().c_str(), ss.str().size());
u.buffer_consumed(ss.str().size());
msgpack::object_handle unp;
u.next(unp);
EXPECT_TRUE(false);
}
catch(msgpack::array_size_overflow const&) {
EXPECT_TRUE(true);
}
catch(...) {
EXPECT_TRUE(false);
}
}
TEST(limit, unpacker_reserve)
{
msgpack::unpacker u(MSGPACK_NULLPTR, MSGPACK_NULLPTR, MSGPACK_UNPACKER_INIT_BUFFER_SIZE,
msgpack::unpack_limit());
std::size_t original_capacity = u.buffer_capacity();
u.reserve_buffer(original_capacity + 1u);
EXPECT_EQ((original_capacity + COUNTER_SIZE) * 2 - COUNTER_SIZE, u.buffer_capacity());
}
TEST(limit, unpacker_reserve_more_than_twice)
{
msgpack::unpacker u(MSGPACK_NULLPTR, MSGPACK_NULLPTR, MSGPACK_UNPACKER_INIT_BUFFER_SIZE,
msgpack::unpack_limit());
std::size_t original_capacity = u.buffer_capacity();
u.reserve_buffer(original_capacity * 3);
EXPECT_EQ((original_capacity + COUNTER_SIZE) * 4 - COUNTER_SIZE, u.buffer_capacity());
}

742
test/msgpack_basic.cpp
View File

@@ -1,742 +0,0 @@
#include "msgpack.hpp"
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <deque>
#include <set>
#include <list>
#include <limits>
#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__)
#if defined(_MSC_VER) || defined(__MINGW32__)
#define msgpack_rand() ((double)rand() / RAND_MAX)
#else // _MSC_VER || __MINGW32__
#define msgpack_rand() drand48()
#endif // _MSC_VER || __MINGW32__
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
using namespace std;
const unsigned int kLoop = 10000;
const unsigned int kElements = 100;
const double kEPS = 1e-10;
#define GEN_TEST(test_type) \
do { \
vector<test_type> v; \
v.push_back(0); \
v.push_back(1); \
v.push_back(2); \
v.push_back(numeric_limits<test_type>::min()); \
v.push_back(numeric_limits<test_type>::max()); \
for (unsigned int i = 0; i < kLoop; i++) \
v.push_back(static_cast<test_type>(rand())); \
for (unsigned int i = 0; i < v.size() ; i++) { \
msgpack::sbuffer sbuf; \
test_type val1 = v[i]; \
msgpack::pack(sbuf, val1); \
msgpack::object_handle oh = \
msgpack::unpack(sbuf.data(), sbuf.size()); \
EXPECT_EQ(val1, oh.get().as<test_type>()); \
} \
} while(0)
TEST(MSGPACK, simple_buffer_char)
{
GEN_TEST(char);
}
TEST(MSGPACK, simple_buffer_signed_char)
{
GEN_TEST(signed char);
}
TEST(MSGPACK, simple_buffer_unsigned_char)
{
GEN_TEST(unsigned char);
}
TEST(MSGPACK, simple_buffer_short)
{
GEN_TEST(short);
}
TEST(MSGPACK, simple_buffer_int)
{
GEN_TEST(int);
}
TEST(MSGPACK, simple_buffer_long)
{
GEN_TEST(long);
}
TEST(MSGPACK, simple_buffer_long_long)
{
GEN_TEST(long long);
}
TEST(MSGPACK, simple_buffer_unsigned_short)
{
GEN_TEST(unsigned short);
}
TEST(MSGPACK, simple_buffer_unsigned_int)
{
GEN_TEST(unsigned int);
}
TEST(MSGPACK, simple_buffer_unsigned_long)
{
GEN_TEST(unsigned long);
}
TEST(MSGPACK, simple_buffer_unsigned_long_long)
{
GEN_TEST(unsigned long long);
}
TEST(MSGPACK, simple_buffer_uint8)
{
GEN_TEST(uint8_t);
}
TEST(MSGPACK, simple_buffer_uint16)
{
GEN_TEST(uint16_t);
}
TEST(MSGPACK, simple_buffer_uint32)
{
GEN_TEST(uint32_t);
}
TEST(MSGPACK, simple_buffer_uint64)
{
GEN_TEST(uint64_t);
}
TEST(MSGPACK, simple_buffer_int8)
{
GEN_TEST(int8_t);
}
TEST(MSGPACK, simple_buffer_int16)
{
GEN_TEST(int16_t);
}
TEST(MSGPACK, simple_buffer_int32)
{
GEN_TEST(int32_t);
}
TEST(MSGPACK, simple_buffer_int64)
{
GEN_TEST(int64_t);
}
#if !defined(_MSC_VER) || _MSC_VER >=1800
TEST(MSGPACK, simple_buffer_float)
{
vector<float> v;
v.push_back(0.0);
v.push_back(-0.0);
v.push_back(1.0);
v.push_back(-1.0);
v.push_back(numeric_limits<float>::min());
v.push_back(numeric_limits<float>::max());
v.push_back(nanf("tag"));
if (numeric_limits<float>::has_infinity) {
v.push_back(numeric_limits<float>::infinity());
v.push_back(-numeric_limits<float>::infinity());
}
if (numeric_limits<float>::has_quiet_NaN) {
v.push_back(numeric_limits<float>::quiet_NaN());
}
if (numeric_limits<float>::has_signaling_NaN) {
v.push_back(numeric_limits<float>::signaling_NaN());
}
for (unsigned int i = 0; i < kLoop; i++) {
v.push_back(static_cast<float>(msgpack_rand()));
v.push_back(static_cast<float>(-msgpack_rand()));
}
for (unsigned int i = 0; i < v.size() ; i++) {
msgpack::sbuffer sbuf;
float val1 = v[i];
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
float val2 = oh.get().as<float>();
if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2));
else if (std::isinf(val1))
EXPECT_TRUE(std::isinf(val2));
else
EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
}
}
#endif // !defined(_MSC_VER) || _MSC_VER >=1800
namespace {
template<typename F, typename I>
struct TypePair {
typedef F float_type;
typedef I integer_type;
};
} // namespace
template <typename T>
class IntegerToFloatingPointTest : public testing::Test {
};
TYPED_TEST_CASE_P(IntegerToFloatingPointTest);
TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
{
typedef typename TypeParam::float_type float_type;
typedef typename TypeParam::integer_type integer_type;
vector<integer_type> v;
v.push_back(0);
v.push_back(1);
if (numeric_limits<integer_type>::is_signed) v.push_back(static_cast<integer_type>(-1));
else v.push_back(2);
for (unsigned int i = 0; i < kLoop; i++) {
v.push_back(rand() % 0x7FFFFF);
}
for (unsigned int i = 0; i < v.size() ; i++) {
msgpack::sbuffer sbuf;
integer_type val1 = v[i];
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
float_type val2 = oh.get().as<float_type>();
EXPECT_TRUE(fabs(val2 - static_cast<float_type>(val1)) <= kEPS);
}
}
REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest,
simple_buffer);
typedef testing::Types<TypePair<float, signed long long>,
TypePair<float, unsigned long long>,
TypePair<double, signed long long>,
TypePair<double, unsigned long long> > IntegerToFloatingPointTestTypes;
INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance,
IntegerToFloatingPointTest,
IntegerToFloatingPointTestTypes);
#if !defined(_MSC_VER) || _MSC_VER >=1800
TEST(MSGPACK, simple_buffer_double)
{
vector<double> v;
v.push_back(0.0);
v.push_back(-0.0);
v.push_back(1.0);
v.push_back(-1.0);
v.push_back(numeric_limits<double>::min());
v.push_back(numeric_limits<double>::max());
v.push_back(nanf("tag"));
if (numeric_limits<double>::has_infinity) {
v.push_back(numeric_limits<double>::infinity());
v.push_back(-numeric_limits<double>::infinity());
}
if (numeric_limits<double>::has_quiet_NaN) {
v.push_back(numeric_limits<double>::quiet_NaN());
}
if (numeric_limits<double>::has_signaling_NaN) {
v.push_back(numeric_limits<double>::signaling_NaN());
}
for (unsigned int i = 0; i < kLoop; i++) {
v.push_back(msgpack_rand());
v.push_back(-msgpack_rand());
}
for (unsigned int i = 0; i < kLoop; i++) {
v.push_back(msgpack_rand());
v.push_back(-msgpack_rand());
}
for (unsigned int i = 0; i < v.size() ; i++) {
msgpack::sbuffer sbuf;
double val1 = v[i];
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
double val2 = oh.get().as<double>();
if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2));
else if (std::isinf(val1))
EXPECT_TRUE(std::isinf(val2));
else
EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
}
}
#endif // !defined(_MSC_VER) || _MSC_VER >=1800
TEST(MSGPACK, simple_buffer_nil)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
packer.pack_nil();
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::NIL);
}
TEST(MSGPACK, simple_buffer_true)
{
msgpack::sbuffer sbuf;
bool val1 = true;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
bool val2 = oh.get().as<bool>();
EXPECT_EQ(val1, val2);
}
TEST(MSGPACK, simple_buffer_false)
{
msgpack::sbuffer sbuf;
bool val1 = false;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
bool val2 = oh.get().as<bool>();
EXPECT_EQ(val1, val2);
}
TEST(MSGPACK, simple_buffer_fixext1)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(1ul, oh.get().via.ext.size);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_EQ(2, oh.get().via.ext.data()[0]);
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
EXPECT_EQ(1ul, oh2.get().via.ext.size);
EXPECT_EQ(1, oh2.get().via.ext.type());
EXPECT_EQ(2, oh2.get().via.ext.data()[0]);
EXPECT_EQ(oh.get(), oh2.get());
}
TEST(MSGPACK, simple_buffer_fixext2)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2, 3 };
packer.pack_ext(sizeof(buf), 0);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(2ul, oh.get().via.ext.size);
EXPECT_EQ(0, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
EXPECT_EQ(2ul, oh2.get().via.ext.size);
EXPECT_EQ(0, oh2.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
EXPECT_EQ(oh.get(), oh2.get());
}
TEST(MSGPACK, simple_buffer_fixext4)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2, 3, 4, 5 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(4ul, oh.get().via.ext.size);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
EXPECT_EQ(4ul, oh2.get().via.ext.size);
EXPECT_EQ(1, oh2.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
EXPECT_EQ(oh.get(), oh2.get());
}
TEST(MSGPACK, simple_buffer_fixext8)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(8ul, oh.get().via.ext.size);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
EXPECT_EQ(8ul, oh2.get().via.ext.size);
EXPECT_EQ(1, oh2.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
EXPECT_EQ(oh.get(), oh2.get());
}
TEST(MSGPACK, simple_buffer_fixext16)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(16ul, oh.get().via.ext.size);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
EXPECT_EQ(16ul, oh2.get().via.ext.size);
EXPECT_EQ(1, oh2.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
EXPECT_EQ(oh.get(), oh2.get());
}
TEST(MSGPACK, simple_buffer_fixext_1byte_0)
{
std::size_t const size = 0;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
packer.pack_ext(size, 77);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
}
TEST(MSGPACK, simple_buffer_fixext_1byte_255)
{
std::size_t const size = 255;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
EXPECT_EQ(size, oh2.get().via.ext.size);
EXPECT_EQ(77, oh2.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
EXPECT_EQ(oh.get(), oh2.get());
}
TEST(MSGPACK, simple_buffer_fixext_2byte_256)
{
std::size_t const size = 256;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
EXPECT_EQ(size, oh2.get().via.ext.size);
EXPECT_EQ(77, oh2.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
EXPECT_EQ(oh.get(), oh2.get());
}
TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
{
std::size_t const size = 65535;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
EXPECT_EQ(size, oh2.get().via.ext.size);
EXPECT_EQ(77, oh2.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
EXPECT_EQ(oh.get(), oh2.get());
}
TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
{
std::size_t const size = 65536;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
msgpack::sbuffer sbuf2;
msgpack::pack(sbuf2, oh.get());
msgpack::object_handle oh2 =
msgpack::unpack(sbuf2.data(), sbuf2.size());
EXPECT_EQ(size, oh2.get().via.ext.size);
EXPECT_EQ(77, oh2.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh2.get().via.ext.data()));
EXPECT_EQ(oh.get(), oh2.get());
}
TEST(MSGPACK, simple_buffer_ext_convert)
{
std::size_t const size = 65536;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext e;
oh.get().convert(e);
EXPECT_EQ(size, e.size());
EXPECT_EQ(77, e.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), e.data()));
}
TEST(MSGPACK, simple_buffer_ext_pack_convert)
{
std::size_t const size = 65536;
msgpack::sbuffer sbuf;
msgpack::type::ext val1(77, size);
char* buf = val1.data();
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext val2;
oh.get().convert(val2);
EXPECT_EQ(size, val2.size());
EXPECT_EQ(77, val2.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), val2.data()));
}
TEST(MSGPACK, simple_buffer_ext_ref_convert)
{
std::size_t const size = 65536;
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext_ref er;
oh.get().convert(er);
EXPECT_EQ(size, er.size());
EXPECT_EQ(77, er.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), er.data()));
}
TEST(MSGPACK, simple_buffer_ext_ref_pack_convert)
{
std::size_t const buf_size = 65536;
std::size_t const data_size = buf_size - 1;
msgpack::sbuffer sbuf;
char buf[buf_size];
buf[0] = static_cast<char>(77);
for (std::size_t i = 0; i != data_size; ++i) buf[i + 1] = static_cast<char>(i);
msgpack::pack(sbuf, msgpack::type::ext_ref(buf, buf_size));
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::type::ext_ref val2;
oh.get().convert(val2);
EXPECT_EQ(data_size, val2.size());
EXPECT_EQ(77, val2.type());
EXPECT_TRUE(
std::equal(&buf[1], &buf[buf_size], val2.data()));
}
TEST(MSGPACK_STL, simple_buffer_string)
{
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);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(oh.get().type, msgpack::type::STR);
string val2 = oh.get().as<string>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(val1, val2);
}
}
TEST(MSGPACK_STL, 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());
EXPECT_EQ(oh.get().type, msgpack::type::STR);
string val2 = oh.get().as<string>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(val1, val2);
}
}
TEST(MSGPACK_STL, 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());
EXPECT_EQ(oh.get().type, msgpack::type::STR);
string val2 = oh.get().as<string>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(val1, val2);
}
}
TEST(MSGPACK_STL, 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());
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
wstring val2 = oh.get().as<wstring>();
EXPECT_EQ(val1, val2);
wstring val3;
oh.get().convert(val3);
EXPECT_EQ(val1, val3);
}
}

891
test/msgpack_container.cpp
View File

@@ -1,891 +0,0 @@
#include <iostream>
#include <msgpack.hpp>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <deque>
#include <set>
#include <list>
#include <limits>
#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__)
#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 <class Key>
struct equal_to : std::equal_to<Key> {
};
template <class Key>
struct less : std::less<Key> {
};
} // namespace test
TEST(MSGPACK_STL, simple_buffer_vector)
{
typedef vector<int, test::allocator<int> > 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());
EXPECT_EQ(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()));
}
}
TEST(MSGPACK_STL, simple_buffer_vector_empty)
{
typedef vector<int, test::allocator<int> > type;
type val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(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()));
}
TEST(MSGPACK_STL, simple_buffer_vector_char)
{
typedef vector<char, test::allocator<char> > type;
for (unsigned int k = 0; k < kLoop; k++) {
type val1;
for (unsigned int i = 0; i < kElements; i++)
val1.push_back(static_cast<char>(rand()));
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(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()));
}
}
TEST(MSGPACK_STL, simple_buffer_vector_char_empty)
{
typedef vector<char, test::allocator<char> > type;
type val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(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()));
}
TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char)
{
typedef vector<unsigned char, test::allocator<unsigned char> > type;
for (unsigned int k = 0; k < kLoop; k++) {
type val1;
for (unsigned int i = 0; i < kElements; i++)
val1.push_back(static_cast<unsigned char>(rand()));
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(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()));
}
}
TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char_empty)
{
typedef vector<unsigned char, test::allocator<unsigned char> > type;
type val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(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()));
}
TEST(MSGPACK_STL, simple_buffer_vector_uint8_t)
{
if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
typedef vector<uint8_t, test::allocator<uint8_t> > type;
for (unsigned int k = 0; k < kLoop; k++) {
type val1;
for (unsigned int i = 0; i < kElements; i++)
val1.push_back(static_cast<uint8_t>(rand()));
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(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()));
}
}
TEST(MSGPACK_STL, 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;
type val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(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()));
}
TEST(MSGPACK_STL, simple_buffer_vector_bool)
{
typedef vector<bool, test::allocator<bool> > 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());
EXPECT_EQ(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()));
}
TEST(MSGPACK_STL, simple_buffer_vector_bool_empty)
{
typedef vector<bool, test::allocator<bool> > type;
type val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(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()));
}
TEST(MSGPACK_STL, 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++) {
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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_assoc_vector_empty)
{
typedef msgpack::type::assoc_vector<int, int, test::less<int>, test::allocator<std::pair<int, int> > >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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, 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++) {
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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_map_empty)
{
typedef map<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_deque)
{
typedef deque<int, test::allocator<int> > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_deque_empty)
{
typedef deque<int, test::allocator<int> > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_list)
{
typedef list<int, test::allocator<int> > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_list_empty)
{
typedef list<int, test::allocator<int> > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_set)
{
typedef set<int, test::less<int>, test::allocator<int> > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
}
TEST(MSGPACK_STL, simple_buffer_set_empty)
{
typedef set<int, test::less<int>, test::allocator<int> > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
}
TEST(MSGPACK_STL, simple_buffer_pair)
{
for (unsigned int k = 0; k < kLoop; k++) {
pair<int, int> val1 = make_pair(rand(), rand());
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
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);
}
}
TEST(MSGPACK_STL, 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++) {
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<type>();
vector<pair<int, int> > 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));
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
}
}
TEST(MSGPACK_STL, simple_buffer_multimap_empty)
{
typedef multimap<int, int, test::less<int>, test::allocator<std::pair<const int, int> > > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
}
TEST(MSGPACK_STL, simple_buffer_multiset)
{
typedef multiset<int, test::less<int>, test::allocator<int> > 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<type>();
vector<int> 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);
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
}
}
TEST(MSGPACK_STL, simple_buffer_multiset_empty)
{
typedef multiset<int, test::less<int>, test::allocator<int> > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
}
TEST(MSGPACK_TUPLE, simple_tuple)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, double> val1(true, "kzk", 12.3);
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
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>());
}
TEST(MSGPACK_TUPLE, 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<msgpack::type::tuple<> >();
EXPECT_EQ(oh.get().via.array.size, 0u);
}
TEST(MSGPACK_TUPLE, simple_tuple_grater_than_as)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
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>());
}
TEST(MSGPACK_TUPLE, simple_tuple_grater_than_convert)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
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>());
}
TEST(MSGPACK_TUPLE, simple_tuple_less_than_as)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
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>());
}
TEST(MSGPACK_TUPLE, simple_tuple_less_than_convert)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
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>());
}
TEST(MSGPACK_TUPLE, simple_tuple_nest)
{
msgpack::sbuffer sbuf;
msgpack::type::tuple<msgpack::type::tuple<> > val1;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
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);
}
// TR1
#if defined(MSGPACK_HAS_STD_TR1_UNORDERED_MAP) || defined(MSGPACK_HAS_STD_TR1_UNORDERED_SET)
#include <tr1/functional>
namespace test {
template <class Key>
struct tr1_hash : std::tr1::hash<Key> {
};
} // 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 <tr1/unordered_map>
#include "msgpack/adaptor/tr1/unordered_map.hpp"
TEST(MSGPACK_TR1, 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++) {
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<type>();
EXPECT_EQ(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);
}
}
}
TEST(MSGPACK_TR1, 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;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
}
TEST(MSGPACK_TR1, 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++) {
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<type>();
vector<pair<int, int> > 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));
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
}
}
TEST(MSGPACK_TR1, 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;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
}
#endif
#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)
{
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++) {
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<type>();
EXPECT_EQ(val1.size(), val2.size());
type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it)
EXPECT_TRUE(val2.find(*it) != val2.end());
}
}
TEST(MSGPACK_TR1, 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;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
}
TEST(MSGPACK_TR1, 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++) {
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<type>();
vector<int> 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);
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
}
}
TEST(MSGPACK_TR1, 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;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
}
#endif
#if defined (MSGPACK_HAS_STD_UNORDERED_MAP) || defined (MSGPACK_HAS_STD_UNORDERED_SET)
#include <functional>
namespace test {
template <class Key>
struct hash : std::hash<Key> {
};
} // namespace test
#endif // defined (MSGPACK_HAS_STD_UNORDERED_MAP) || defined (MSGPACK_HAS_STD_UNORDERED_SET)
#ifdef MSGPACK_HAS_STD_UNORDERED_MAP
#include <unordered_map>
#include "msgpack/adaptor/tr1/unordered_map.hpp"
TEST(MSGPACK_TR1, 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++) {
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<type>();
EXPECT_EQ(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);
}
}
}
TEST(MSGPACK_TR1, 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;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
}
TEST(MSGPACK_TR1, 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++) {
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<type>();
vector<pair<int, int> > 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));
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
}
}
TEST(MSGPACK_TR1, 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;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
type val2 = oh.get().as<type>();
EXPECT_EQ(val1.size(), val2.size());
}
#endif
#ifdef MSGPACK_HAS_STD_UNORDERED_SET
#include <unordered_set>
#include "msgpack/adaptor/tr1/unordered_set.hpp"
TEST(MSGPACK_TR1, 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++) {
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<type>();
EXPECT_EQ(val1.size(), val2.size());
type::const_iterator it;
for (it = val1.begin(); it != val1.end(); ++it)
EXPECT_TRUE(val2.find(*it) != val2.end());
}
}
TEST(MSGPACK_TR1, simple_buffer_unordered_set_empty)
{
typedef unordered_set<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
}
TEST(MSGPACK_TR1, 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++) {
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<type>();
vector<int> 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);
EXPECT_EQ(val1.size(), val2.size());
EXPECT_EQ(v1.size(), v2.size());
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
EXPECT_TRUE(v1 == v2);
}
}
TEST(MSGPACK_TR1, simple_buffer_unordered_multiset_empty)
{
typedef unordered_multiset<int, test::hash<int>, test::equal_to<int>, test::allocator<int> > 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<type>();
EXPECT_EQ(val1.size(), val2.size());
}
#endif

1217
test/msgpack_cpp11.cpp
View File

File diff suppressed because it is too large Load Diff

353
test/msgpack_cpp17.cpp
View File

@@ -1,353 +0,0 @@
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
// To avoid link error
TEST(MSGPACK_CPP17, dummy)
{
}
#if !defined(MSGPACK_USE_CPP03) && __cplusplus >= 201703
// C++17
#if MSGPACK_HAS_INCLUDE(<optional>)
TEST(MSGPACK_CPP17, optional_pack_convert_nil)
{
std::stringstream ss;
std::optional<int> val1;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::optional<int> val2 = oh.get().as<std::optional<int> >();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_pack_convert_int)
{
std::stringstream ss;
std::optional<int> val1 = 1;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::optional<int> val2 = oh.get().as<std::optional<int> >();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_pack_convert_vector)
{
typedef std::optional<std::vector<int> > ovi_t;
std::stringstream ss;
ovi_t val1;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
val1 = v;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
ovi_t val2 = oh.get().as<ovi_t>();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
{
typedef std::vector<std::optional<int> > voi_t;
std::stringstream ss;
voi_t val1;
val1.resize(3);
val1[0] = 1;
val1[2] = 3;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
voi_t val2 = oh.get().as<voi_t>();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_CPP17, optional_object_nil)
{
std::optional<int> val1;
msgpack::object obj(val1);
std::optional<int> val2 = obj.as<std::optional<int> >();
EXPECT_TRUE(val1 == val2);
}
TEST(MSGPACK_CPP17, 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);
}
// Compile error as expected
/*
TEST(MSGPACK_CPP17, optional_object_vector)
{
typedef std::optional<std::vector<int> > ovi_t;
ovi_t val1;
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
val1 = v;
msgpack::object obj(val1);
ovi_t val2 = obj.as<ovi_t>();
EXPECT_TRUE(val1 == val2);
}
*/
TEST(MSGPACK_CPP17, 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);
}
TEST(MSGPACK_CPP17, 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);
}
TEST(MSGPACK_CPP17, optional_object_with_zone_vector_optional)
{
typedef std::vector<std::optional<int> > voi_t;
msgpack::zone z;
voi_t val1;
val1.resize(3);
val1[0] = 1;
val1[2] = 3;
msgpack::object obj(val1, z);
voi_t val2 = obj.as<voi_t>();
EXPECT_TRUE(val1 == val2);
}
struct no_def_con {
no_def_con() = delete;
no_def_con(int i):i(i) {}
int i;
MSGPACK_DEFINE(i);
};
inline bool operator==(no_def_con const& lhs, no_def_con const& rhs) {
return lhs.i == rhs.i;
}
inline bool operator!=(no_def_con const& lhs, no_def_con const& rhs) {
return !(lhs == rhs);
}
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor {
template <>
struct as<no_def_con> {
no_def_con operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error();
return no_def_con(o.via.array.ptr[0].as<int>());
}
};
} // adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // msgpack
TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con)
{
std::stringstream ss;
std::optional<no_def_con> val1 = no_def_con(1);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
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);
}
#endif // MSGPACK_HAS_INCLUDE(<optional>)
#if MSGPACK_HAS_INCLUDE(<string_view>)
TEST(MSGPACK_CPP17, string_view_pack_convert)
{
std::stringstream ss;
std::string s = "ABC";
std::string_view val1(s);
msgpack::pack(ss, val1);
std::string const& str = ss.str();
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);
}
TEST(MSGPACK_CPP17, 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);
}
TEST(MSGPACK_CPP17, 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);
}
#endif // MSGPACK_HAS_INCLUDE(<string_view>)
TEST(MSGPACK_CPP17, byte_pack_convert)
{
std::stringstream ss;
std::byte val1{0xff};
msgpack::pack(ss, val1);
msgpack::object_handle oh;
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);
}
TEST(MSGPACK_CPP17, byte_object)
{
std::byte val1{0x00};
msgpack::object obj(val1);
std::byte val2 = obj.as<std::byte>();
EXPECT_EQ(val1, val2);
}
TEST(MSGPACK_CPP17, 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);
}
TEST(MSGPACK_CPP17, vector_byte_pack_convert)
{
std::stringstream ss;
std::vector<std::byte> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
msgpack::pack(ss, val1);
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
for (size_t i = 0; i != sizeof(packed); ++i) {
std::string const& str = ss.str();
EXPECT_EQ(str[i], packed[i]);
}
msgpack::object_handle oh;
std::string const& str = ss.str();
msgpack::unpack(oh, str.data(), str.size());
std::vector<std::byte> val2 = oh.get().as<std::vector<std::byte>>();
EXPECT_EQ(val1, val2);
}
TEST(MSGPACK_CPP17, vector_byte_object)
{
std::vector<std::byte> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
// Caller need to manage val1's lifetime. The Data is not copied.
msgpack::object obj(val1);
std::vector<std::byte> val2 = obj.as<std::vector<std::byte>>();
EXPECT_EQ(val1, val2);
}
TEST(MSGPACK_CPP17, vector_byte_object_with_zone)
{
msgpack::zone z;
std::vector<std::byte> val1{
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
msgpack::object obj(val1, z);
std::vector<std::byte> val2 = obj.as<std::vector<std::byte>>();
EXPECT_EQ(val1, val2);
}
TEST(MSGPACK_CPP17, carray_byte_pack_convert)
{
std::stringstream ss;
std::byte val1[] = {
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
msgpack::pack(ss, val1);
char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
for (size_t i = 0; i != sizeof(packed); ++i) {
std::string const& str = ss.str();
EXPECT_EQ(str[i], packed[i]);
}
msgpack::object_handle oh;
std::string const& str = ss.str();
msgpack::unpack(oh, str.data(), str.size());
std::byte val2[sizeof(val1)];
oh.get().convert(val2);
for (size_t i = 0; i != sizeof(val1); ++i) {
EXPECT_EQ(val1[i], val2[i]);
}
}
TEST(MSGPACK_CPP17, carray_byte_object_with_zone)
{
msgpack::zone z;
std::byte val1[] = {
std::byte{0x01}, std::byte{0x02}, std::byte{0x7f}, std::byte{0x80}, std::byte{0xff}
};
msgpack::object obj(val1, z);
std::byte val2[sizeof(val1)];
obj.convert(val2);
for (size_t i = 0; i != sizeof(val1); ++i) {
EXPECT_EQ(val1[i], val2[i]);
}
}
#endif // !defined(MSGPACK_USE_CPP03) && __cplusplus >= 201703

160
test/msgpack_stream.cpp
View File

@@ -1,160 +0,0 @@
#include "msgpack.hpp"
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <deque>
#include <set>
#include <list>
#include <limits>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
using namespace std;
const unsigned int kLoop = 1000;
#define GEN_TEST_STREAM(test_type) \
for (unsigned int k = 0; k < kLoop; k++) { \
msgpack::sbuffer sbuf; \
msgpack::packer<msgpack::sbuffer> pk(sbuf); \
typedef std::vector<test_type> vec_type; \
vec_type vec; \
for(unsigned int i = 0; i < static_cast<unsigned int>(rand()) % kLoop; ++i) { \
vec_type::value_type r = static_cast<test_type>(rand()); \
vec.push_back(r); \
pk.pack(r); \
} \
msgpack::unpacker pac; \
vec_type::const_iterator it = vec.begin(); \
const char *p = sbuf.data(); \
const char * const pend = p + sbuf.size(); \
while (p < pend) { \
const size_t sz = std::min<size_t>(static_cast<std::size_t>(pend - p), static_cast<std::size_t>(rand() % 128)); \
pac.reserve_buffer(sz); \
memcpy(pac.buffer(), p, sz); \
pac.buffer_consumed(sz); \
msgpack::object_handle oh; \
while (pac.next(oh)) { \
if (it == vec.end()) goto out; \
msgpack::object obj = oh.get(); \
vec_type::value_type val; \
obj.convert(val); \
EXPECT_EQ(*it, val); \
++it; \
} \
p += sz; \
} \
out: \
; \
}
TEST(MSGPACK, stream_char)
{
GEN_TEST_STREAM(char);
}
TEST(MSGPACK, stream_signed_char)
{
GEN_TEST_STREAM(signed char);
}
TEST(MSGPACK, stream_unsigned_char)
{
GEN_TEST_STREAM(unsigned char);
}
TEST(MSGPACK, stream_short)
{
GEN_TEST_STREAM(short);
}
TEST(MSGPACK, stream_int)
{
GEN_TEST_STREAM(int);
}
TEST(MSGPACK, stream_long)
{
GEN_TEST_STREAM(long);
}
TEST(MSGPACK, stream_long_long)
{
GEN_TEST_STREAM(long long);
}
TEST(MSGPACK, stream_unsigned_short)
{
GEN_TEST_STREAM(unsigned short);
}
TEST(MSGPACK, stream_unsigned_int)
{
GEN_TEST_STREAM(unsigned int);
}
TEST(MSGPACK, stream_unsigned_long)
{
GEN_TEST_STREAM(unsigned long);
}
TEST(MSGPACK, stream_unsigned_long_long)
{
GEN_TEST_STREAM(unsigned long long);
}
TEST(MSGPACK, stream_uint8)
{
GEN_TEST_STREAM(uint8_t);
}
TEST(MSGPACK, stream_uint16)
{
GEN_TEST_STREAM(uint16_t);
}
TEST(MSGPACK, stream_uint32)
{
GEN_TEST_STREAM(uint32_t);
}
TEST(MSGPACK, stream_uint64)
{
GEN_TEST_STREAM(uint64_t);
}
TEST(MSGPACK, stream_int8)
{
GEN_TEST_STREAM(int8_t);
}
TEST(MSGPACK, stream_int16)
{
GEN_TEST_STREAM(int16_t);
}
TEST(MSGPACK, stream_int32)
{
GEN_TEST_STREAM(int32_t);
}
TEST(MSGPACK, stream_int64)
{
GEN_TEST_STREAM(int64_t);
}

112
test/msgpack_tuple.cpp
View File

@@ -1,112 +0,0 @@
#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__)
TEST(msgpack_tuple, member_get)
{
msgpack::type::tuple<int, bool, std::string> t1(42, true, "ABC");
EXPECT_EQ(42, t1.get<0>());
EXPECT_EQ(true, t1.get<1>());
EXPECT_EQ("ABC", t1.get<2>());
t1.get<0>() = 40;
t1.get<1>() = false;
t1.get<2>() = "DEFG";
EXPECT_EQ(40, t1.get<0>());
EXPECT_FALSE(t1.get<1>());
EXPECT_EQ("DEFG", t1.get<2>());
}
TEST(msgpack_tuple, non_member_get)
{
msgpack::type::tuple<int, bool, std::string> t1(42, true, "ABC");
EXPECT_EQ(42, msgpack::type::get<0>(t1));
EXPECT_EQ(true, msgpack::type::get<1>(t1));
EXPECT_EQ("ABC", msgpack::type::get<2>(t1));
msgpack::type::get<0>(t1) = 40;
msgpack::type::get<1>(t1) = false;
msgpack::type::get<2>(t1) = "DEFG";
EXPECT_EQ(40, msgpack::type::get<0>(t1));
EXPECT_FALSE(msgpack::type::get<1>(t1));
EXPECT_EQ("DEFG", msgpack::type::get<2>(t1));
}
#if __cplusplus >= 201103L
TEST(msgpack_tuple, std_non_member_get)
{
msgpack::type::tuple<int, bool, std::string> t1(42, true, "ABC");
EXPECT_EQ(42, std::get<0>(t1));
EXPECT_EQ(true, std::get<1>(t1));
EXPECT_EQ("ABC", std::get<2>(t1));
std::get<0>(t1) = 40;
std::get<1>(t1) = false;
std::get<2>(t1) = "DEFG";
EXPECT_EQ(40, std::get<0>(t1));
EXPECT_FALSE(std::get<1>(t1));
EXPECT_EQ("DEFG", std::get<2>(t1));
}
TEST(msgpack_tuple, make_tuple)
{
msgpack::type::tuple<int, bool, std::string> t1 = msgpack::type::make_tuple(42, true, "ABC");
EXPECT_EQ(42, t1.get<0>());
EXPECT_EQ(true, t1.get<1>());
EXPECT_EQ("ABC", t1.get<2>());
t1.get<0>() = 40;
t1.get<1>() = false;
t1.get<2>() = "DEFG";
EXPECT_EQ(40, t1.get<0>());
EXPECT_FALSE(t1.get<1>());
EXPECT_EQ("DEFG", t1.get<2>());
}
TEST(msgpack_tuple, std_make_tuple)
{
msgpack::type::tuple<int, bool, std::string> t1 = std::make_tuple(42, true, "ABC");
EXPECT_EQ(42, t1.get<0>());
EXPECT_EQ(true, t1.get<1>());
EXPECT_EQ("ABC", t1.get<2>());
}
TEST(msgpack_tuple, tie)
{
int i(43);
bool b(false);
std::string s("DEFG");
msgpack::type::tie(i, b, s) = msgpack::type::make_tuple(42, true, "ABC");
EXPECT_EQ(42, i);
EXPECT_EQ(true, b);
EXPECT_EQ("ABC", s);
}
TEST(msgpack_tuple, tuple_cat)
{
msgpack::type::tuple<int> t1 = msgpack::type::make_tuple(42);
msgpack::type::tuple<bool, std::string> t2 = msgpack::type::make_tuple(true, "ABC");
msgpack::type::tuple<int, bool, std::string> t3 = msgpack::type::tuple_cat(t1, std::move(t2));
EXPECT_EQ(42, t3.get<0>());
EXPECT_EQ(true, t3.get<1>());
EXPECT_EQ("ABC", t3.get<2>());
}
TEST(msgpack_tuple, swap)
{
msgpack::type::tuple<int, bool, std::string> t1 = msgpack::type::make_tuple(42, true, "ABC");
msgpack::type::tuple<int, bool, std::string> t2 = msgpack::type::make_tuple(40, false, "DEFG");
msgpack::type::swap(t1, t2);
EXPECT_EQ(42, t2.get<0>());
EXPECT_EQ(true, t2.get<1>());
EXPECT_EQ("ABC", t2.get<2>());
EXPECT_EQ(40, t1.get<0>());
EXPECT_FALSE(t1.get<1>());
EXPECT_EQ("DEFG", t1.get<2>());
}
#endif

286
test/msgpack_vref.cpp
View File

@@ -1,286 +0,0 @@
#include "msgpack.hpp"
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <deque>
#include <set>
#include <list>
#include <limits>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
using namespace std;
#define GEN_TEST_VREF(test_type, vbuf) \
do { \
vector<test_type> v; \
v.push_back(0); \
for (unsigned int i = 0; i < v.size(); i++) { \
test_type val1 = v[i]; \
msgpack::pack(vbuf, val1); \
msgpack::sbuffer sbuf; \
const struct iovec* cur = vbuf.vector(); \
const struct iovec* end = cur + vbuf.vector_size(); \
for(; cur != end; ++cur) \
sbuf.write((const char*)cur->iov_base, cur->iov_len); \
msgpack::object_handle oh; \
msgpack::unpack(oh, sbuf.data(), sbuf.size()); \
test_type val2 = oh.get().as<test_type>(); \
EXPECT_EQ(val1, val2); \
} \
} while(0);
TEST(MSGPACK, vrefbuffer_char)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(char, vbuf);
}
TEST(MSGPACK, vrefbuffer_signed_char)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(signed char, vbuf);
}
TEST(MSGPACK, vrefbuffer_unsigned_char)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(unsigned char, vbuf);
}
TEST(MSGPACK, vrefbuffer_short)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(short, vbuf);
}
TEST(MSGPACK, vrefbuffer_int)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(int, vbuf);
}
TEST(MSGPACK, vrefbuffer_long)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(long, vbuf);
}
TEST(MSGPACK, vrefbuffer_long_long)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(long long, vbuf);
}
TEST(MSGPACK, vrefbuffer_unsigned_short)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(unsigned short, vbuf);
}
TEST(MSGPACK, vrefbuffer_unsigned_int)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(unsigned int, vbuf);
}
TEST(MSGPACK, vrefbuffer_unsigned_long)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(unsigned long, vbuf);
}
TEST(MSGPACK, vrefbuffer_unsigned_long_long)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(unsigned long long, vbuf);
}
TEST(MSGPACK, vrefbuffer_uint8)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(uint8_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_uint16)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(uint16_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_uint32)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(uint32_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_uint64)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(uint64_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_int8)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(int8_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_int16)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(int16_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_int32)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(int32_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_int64)
{
msgpack::vrefbuffer vbuf;
GEN_TEST_VREF(int64_t, vbuf);
}
// small ref_size and chunk_size
TEST(MSGPACK, vrefbuffer_small_char)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(char, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_signed_char)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(signed char, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_unsigned_char)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(unsigned char, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_short)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(short, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_int)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(int, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_long)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(long, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_long_long)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(long long, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_unsigned_short)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(unsigned short, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_unsigned_int)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(unsigned int, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_unsigned_long)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(unsigned long, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_unsigned_long_long)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(unsigned long long, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_uint8)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(uint8_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_uint16)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(uint16_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_uint32)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(uint32_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_uint64)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(uint64_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_int8)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(int8_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_int16)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(int16_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_int32)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(int32_t, vbuf);
}
TEST(MSGPACK, vrefbuffer_small_int64)
{
msgpack::vrefbuffer vbuf(0, 0);
GEN_TEST_VREF(int64_t, vbuf);
}
TEST(MSGPACK, vref_buffer_overflow)
{
size_t ref_size = 0;
size_t chunk_size = std::numeric_limits<size_t>::max();
char *buf = (char *)malloc(0x1000);
ASSERT_THROW(msgpack::vrefbuffer vbuf(ref_size, chunk_size), std::bad_alloc);
msgpack::vrefbuffer vbuf2(0, 0x1000);
ASSERT_THROW(vbuf2.append_copy(buf, chunk_size), std::bad_alloc);
free(buf);
}

844
test/msgpack_x3_parse.cpp
View File

@@ -1,844 +0,0 @@
#include "msgpack.hpp"
#include <sstream>
#include <limits>
#include <cmath>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
// To avoid link error
TEST(MSGPACK_X3_PARSE, dummy)
{
}
#if defined(MSGPACK_USE_X3_PARSE) && MSGPACK_DEFAULT_API_VERSION >= 2
using namespace std;
const double kEPS = 1e-10;
TEST(MSGPACK_X3_PARSE, nil_t)
{
msgpack::type::nil_t v;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_TRUE(oh.get().is_nil());
}
TEST(MSGPACK_X3_PARSE, bool_false)
{
bool v = false;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<bool>());
}
TEST(MSGPACK_X3_PARSE, bool_true)
{
bool v = true;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<bool>());
}
TEST(MSGPACK_X3_PARSE, positive_fixint_1)
{
uint8_t v = 0;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint8_t>());
}
TEST(MSGPACK_X3_PARSE, positive_fixint_2)
{
uint8_t v = 127;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint8_t>());
}
TEST(MSGPACK_X3_PARSE, negative_fixint_1)
{
int8_t v = -1;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int8_t>());
}
TEST(MSGPACK_X3_PARSE, negative_fixint_2)
{
int8_t v = -32;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int8_t>());
}
TEST(MSGPACK_X3_PARSE, uint8_1)
{
uint8_t v = 128U;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint8_t>());
}
TEST(MSGPACK_X3_PARSE, uint8_2)
{
uint8_t v = 0xffU;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint8_t>());
}
TEST(MSGPACK_X3_PARSE, uint16_1)
{
uint16_t v = 0x100U;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint16_t>());
}
TEST(MSGPACK_X3_PARSE, uint16_2)
{
uint16_t v = 0xffffU;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint16_t>());
}
TEST(MSGPACK_X3_PARSE, uint32_1)
{
uint32_t v = 0x10000UL;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint32_t>());
}
TEST(MSGPACK_X3_PARSE, uint32_2)
{
uint32_t v = 0xffffffffUL;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint32_t>());
}
TEST(MSGPACK_X3_PARSE, uint64_1)
{
uint64_t v = 0x100000000ULL;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint64_t>());
}
TEST(MSGPACK_X3_PARSE, uint64_2)
{
uint64_t v = 0xffffffffffffffffULL;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<uint64_t>());
}
TEST(MSGPACK_X3_PARSE, int8_1)
{
int8_t v = static_cast<int8_t>(0b11011111);
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int8_t>());
}
TEST(MSGPACK_X3_PARSE, int8_2)
{
int8_t v = static_cast<int8_t>(0b10000000);
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int8_t>());
}
TEST(MSGPACK_X3_PARSE, int16_1)
{
int16_t v = static_cast<int16_t>(0xff00);
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int16_t>());
}
TEST(MSGPACK_X3_PARSE, int16_2)
{
int16_t v = static_cast<int16_t>(0x8000);
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int16_t>());
}
TEST(MSGPACK_X3_PARSE, int32_1)
{
int32_t v = static_cast<int32_t>(0xff000000L);
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int32_t>());
}
TEST(MSGPACK_X3_PARSE, int32_2)
{
int32_t v = static_cast<int32_t>(0x80000000L);
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int32_t>());
}
TEST(MSGPACK_X3_PARSE, int64_1)
{
int64_t v = static_cast<int64_t>(0xff00000000000000LL);
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int64_t>());
}
TEST(MSGPACK_X3_PARSE, int64_2)
{
int64_t v = static_cast<int64_t>(0x8000000000000000LL);
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<int64_t>());
}
TEST(MSGPACK_X3_PARSE, array_1)
{
std::vector<int> v;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<int> >());
}
TEST(MSGPACK_X3_PARSE, array_2)
{
std::vector<int> v;
std::stringstream ss;
for (int i = 0; i != 0xffU; ++i) v.push_back(i);
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<int> >());
}
TEST(MSGPACK_X3_PARSE, array_3)
{
std::vector<int> v;
std::stringstream ss;
for (int i = 0; i != 0xffU+1U; ++i) v.push_back(i);
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<int> >());
}
TEST(MSGPACK_X3_PARSE, array_4)
{
std::vector<int> v;
std::stringstream ss;
for (int i = 0; i != 0xffffU; ++i) v.push_back(i);
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<int> >());
}
TEST(MSGPACK_X3_PARSE, array_5)
{
std::vector<uint32_t> v;
std::stringstream ss;
for (uint32_t i = 0; i != 0xffffU+1U; ++i) v.push_back(i);
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<uint32_t> >());
}
TEST(MSGPACK_X3_PARSE, map_1)
{
std::map<int, int> v;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
}
TEST(MSGPACK_X3_PARSE, map_2)
{
std::map<int, int> v;
std::stringstream ss;
for (int i = 0; i != 0xffU; ++i) v.emplace(i, i);
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
}
TEST(MSGPACK_X3_PARSE, map_3)
{
std::map<int, int> v;
std::stringstream ss;
for (int i = 0; i != 0xffU+1U; ++i) v.emplace(i, i);
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
}
TEST(MSGPACK_X3_PARSE, map_4)
{
std::map<int, int> v;
std::stringstream ss;
for (int i = 0; i != 0xffffU; ++i) v.emplace(i, i);
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, (oh.get().as<std::map<int, int> >()));
}
TEST(MSGPACK_X3_PARSE, map_5)
{
std::map<uint32_t, uint32_t> v;
std::stringstream ss;
for (uint32_t i = 0; i != 0xffffU+1U; ++i) v.emplace(i, i);
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, (oh.get().as<std::map<uint32_t, uint32_t> >()));
}
TEST(MSGPACK_X3_PARSE, float_1)
{
std::vector<float> v;
v.push_back(0.0);
v.push_back(-0.0);
v.push_back(1.0);
v.push_back(-1.0);
v.push_back(numeric_limits<float>::min());
v.push_back(numeric_limits<float>::max());
v.push_back(nanf("tag"));
if (numeric_limits<float>::has_infinity) {
v.push_back(numeric_limits<float>::infinity());
v.push_back(-numeric_limits<float>::infinity());
}
if (numeric_limits<float>::has_quiet_NaN) {
v.push_back(numeric_limits<float>::quiet_NaN());
}
if (numeric_limits<float>::has_signaling_NaN) {
v.push_back(numeric_limits<float>::signaling_NaN());
}
for (unsigned int i = 0; i < v.size() ; i++) {
std::stringstream ss;
float val1 = v[i];
msgpack::pack(ss, val1);
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
float val2 = oh.get().as<float>();
if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2));
else if (std::isinf(val1))
EXPECT_TRUE(std::isinf(val2));
else
EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
}
}
TEST(MSGPACK_X3_PARSE, double_1)
{
std::vector<double> v;
v.push_back(0.0);
v.push_back(-0.0);
v.push_back(1.0);
v.push_back(-1.0);
v.push_back(numeric_limits<double>::min());
v.push_back(numeric_limits<double>::max());
v.push_back(nanf("tag"));
if (numeric_limits<double>::has_infinity) {
v.push_back(numeric_limits<double>::infinity());
v.push_back(-numeric_limits<double>::infinity());
}
if (numeric_limits<double>::has_quiet_NaN) {
v.push_back(numeric_limits<double>::quiet_NaN());
}
if (numeric_limits<double>::has_signaling_NaN) {
v.push_back(numeric_limits<double>::signaling_NaN());
}
for (unsigned int i = 0; i < v.size() ; i++) {
std::stringstream ss;
double val1 = v[i];
msgpack::pack(ss, val1);
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
double val2 = oh.get().as<double>();
if (std::isnan(val1))
EXPECT_TRUE(std::isnan(val2));
else if (std::isinf(val1))
EXPECT_TRUE(std::isinf(val2));
else
EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
}
}
TEST(MSGPACK_X3_PARSE, string_1)
{
std::string v;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_2)
{
std::string v;
for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(static_cast<char>('0'+(i%10)));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_3)
{
std::string v;
for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(static_cast<char>('0'+(i%10)));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_4)
{
std::string v;
for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(static_cast<char>('0'+(i%10)));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_5)
{
std::string v;
for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(static_cast<char>('0'+(i%10)));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, string_6)
{
std::string v;
for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(static_cast<char>('0'+(i%10)));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, bin_1)
{
std::vector<char> v;
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_2)
{
std::vector<char> v;
for (uint64_t i = 0; i != 0x1fU; ++i) v.push_back(static_cast<char>(i%0xff));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_3)
{
std::vector<char> v;
for (uint64_t i = 0; i != 0xffU; ++i) v.push_back(static_cast<char>(i%0xff));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_4)
{
std::vector<char> v;
for (uint64_t i = 0; i != 0xffU+1U; ++i) v.push_back(static_cast<char>(i%0xff));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_5)
{
std::vector<char> v;
for (uint64_t i = 0; i != 0xffffU; ++i) v.push_back(static_cast<char>(i%0xff));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, bin_6)
{
std::vector<char> v;
for (uint64_t i = 0; i != 0xffffUL + 1UL; ++i) v.push_back(static_cast<char>(i%0xff));
std::stringstream ss;
msgpack::pack(ss, v);
auto oh = msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(v, oh.get().as<std::vector<char>>());
}
TEST(MSGPACK_X3_PARSE, fixext1)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(1ul, oh.get().via.ext.size);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_EQ(2, oh.get().via.ext.data()[0]);
}
TEST(MSGPACK_X3_PARSE, fixext2)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char const buf [] = { 2, 3 };
packer.pack_ext(sizeof(buf), 0);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(2ul, oh.get().via.ext.size);
EXPECT_EQ(0, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
}
TEST(MSGPACK_X3_PARSE, fixext4)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char const buf [] = { 2, 3, 4, 5 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(4ul, oh.get().via.ext.size);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
}
TEST(MSGPACK_X3_PARSE, fixext8)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(8ul, oh.get().via.ext.size);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
}
TEST(MSGPACK_X3_PARSE, fixext16)
{
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(16ul, oh.get().via.ext.size);
EXPECT_EQ(1, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
}
TEST(MSGPACK_X3_PARSE, ext_0)
{
std::size_t const size = 0;
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
packer.pack_ext(size, 77);
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
}
TEST(MSGPACK_X3_PARSE, ext_255)
{
std::size_t const size = 255;
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
}
TEST(MSGPACK_X3_PARSE, ext_256)
{
std::size_t const size = 256;
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
}
TEST(MSGPACK_X3_PARSE, ext_65535)
{
std::size_t const size = 65535;
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
}
TEST(MSGPACK_X3_PARSE, ext_65536)
{
std::size_t const size = 65536;
std::stringstream ss;
msgpack::packer<std::stringstream> packer(ss);
char buf[size];
for (std::size_t i = 0; i != size; ++i) buf[i] = static_cast<char>(i);
packer.pack_ext(sizeof(buf), 77);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end());
EXPECT_EQ(size, oh.get().via.ext.size);
EXPECT_EQ(77, oh.get().via.ext.type());
EXPECT_TRUE(
std::equal(buf, buf + sizeof(buf), oh.get().via.ext.data()));
}
TEST(MSGPACK_X3_PARSE, unpack_referenced_1)
{
std::string v = "ABC";
std::stringstream ss;
msgpack::pack(ss, v);
bool r;
msgpack::object_handle oh =
msgpack::unpack(ss.str().begin(), ss.str().end(), r);
EXPECT_FALSE(r);
EXPECT_EQ(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, unpack_referenced_2)
{
std::string v = "ABC";
std::stringstream ss;
msgpack::pack(ss, v);
// copy is required because ss.str() returns temporary object.
std::string str = ss.str();
bool r;
msgpack::object_handle oh =
msgpack::unpack(
str.begin(),
str.end(),
r,
[](msgpack::type::object_type, std::size_t, void*) {
return true;
}
);
EXPECT_TRUE(r);
EXPECT_EQ(v, oh.get().as<std::string>());
}
TEST(MSGPACK_X3_PARSE, unpack_zone_1)
{
std::string v = "ABC";
std::stringstream ss;
msgpack::pack(ss, v);
msgpack::zone z;
msgpack::object obj =
msgpack::unpack(z, ss.str().begin(), ss.str().end());
EXPECT_EQ(v, obj.as<std::string>());
}
TEST(MSGPACK_X3_PARSE, unpack_zone_2)
{
std::string v = "ABC";
std::stringstream ss;
msgpack::pack(ss, v);
msgpack::zone z;
bool r;
msgpack::object obj =
msgpack::unpack(z, ss.str().begin(), ss.str().end(), r);
EXPECT_EQ(v, obj.as<std::string>());
EXPECT_FALSE(r);
EXPECT_EQ(v, obj.as<std::string>());
}
TEST(MSGPACK_X3_PARSE, unpack_zone_3)
{
std::string v = "ABC";
std::stringstream ss;
msgpack::pack(ss, v);
// copy is required because ss.str() returns temporary object.
std::string str = ss.str();
msgpack::zone z;
bool r;
msgpack::object obj =
msgpack::unpack(
z,
str.begin(),
str.end(),
r,
[](msgpack::type::object_type, std::size_t, void*) {
return true;
}
);
EXPECT_TRUE(r);
EXPECT_EQ(v, obj.as<std::string>());
}
#endif // defined(MSGPACK_USE_X3_PARSE) && MSGPACK_DEFAULT_API_VERSION >= 2

1
test/multi_file1.cpp
View File

@@ -1 +0,0 @@
#include <msgpack.hpp>

3
test/multi_file2.cpp
View File

@@ -1,3 +0,0 @@
#include <msgpack.hpp>
int main() {}

491
test/object.cpp
View File

@@ -1,491 +0,0 @@
#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__)
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)
struct myclass {
myclass() : num(0), str("default") { }
myclass(int num, const std::string& str) :
num(num), str(str) { }
~myclass() { }
int num;
std::string str;
std::vector<double> vec;
std::map<std::string, std::vector<char> > map;
MSGPACK_DEFINE(num, str, vec, map);
bool operator==(const myclass& o) const
{
return num == o.num && str == o.str && vec == o.vec && map == o.map;
}
};
std::ostream& operator<<(std::ostream& o, const myclass& m)
{
return o << "myclass("<<m.num<<",\""<<m.str<<"\")";
}
TEST(object, convert)
{
myclass m1(1, "custom");
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, m1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
myclass m2;
oh.get().convert(m2);
EXPECT_EQ(m1, m2);
}
TEST(object, as)
{
myclass m1(1, "custom");
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, m1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(m1, oh.get().as<myclass>());
}
TEST(object, cross_zone_copy)
{
myclass m1(1, "custom");
m1.vec.push_back(1.0);
m1.vec.push_back(0.1);
std::vector<char> vc;
vc.push_back('t');
vc.push_back('w');
vc.push_back('o');
m1.map["one"] = vc;
msgpack::zone z1;
msgpack::object::with_zone obj1(z1);
{
msgpack::zone z2;
msgpack::object::with_zone obj2(z2);
obj2 << m1;
obj1 << obj2;
EXPECT_EQ(obj1.via.array.ptr[2].via.array.ptr[0].via.f64, 1.0);
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
EXPECT_EQ(obj1.via.array.ptr[2].via.array.ptr[0].via.dec, 1.0);
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr[0], 'o');
EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr[0], 't');
EXPECT_NE(
obj1.via.array.ptr[2].via.array.ptr,
obj2.via.array.ptr[2].via.array.ptr);
EXPECT_NE(
obj1.via.array.ptr[3].via.map.ptr,
obj2.via.array.ptr[3].via.map.ptr);
EXPECT_NE(
obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr,
obj2.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr);
EXPECT_NE(
obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr,
obj2.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr);
}
EXPECT_EQ(m1, obj1.as<myclass>());
}
TEST(object, cross_zone_copy_construct)
{
myclass m1(1, "custom");
m1.vec.push_back(1.0);
m1.vec.push_back(0.1);
std::vector<char> vc;
vc.push_back('t');
vc.push_back('w');
vc.push_back('o');
m1.map["one"] = vc;
msgpack::zone z1;
msgpack::zone z2;
msgpack::object::with_zone obj2(z2);
obj2 << m1;
msgpack::object obj1(obj2, z1);
EXPECT_EQ(obj1.via.array.ptr[2].via.array.ptr[0].via.f64, 1.0);
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
EXPECT_EQ(obj1.via.array.ptr[2].via.array.ptr[0].via.dec, 1.0);
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr[0], 'o');
EXPECT_EQ(obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr[0], 't');
EXPECT_NE(
obj1.via.array.ptr[2].via.array.ptr,
obj2.via.array.ptr[2].via.array.ptr);
EXPECT_NE(
obj1.via.array.ptr[3].via.map.ptr,
obj2.via.array.ptr[3].via.map.ptr);
EXPECT_NE(
obj1.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr,
obj2.via.array.ptr[3].via.map.ptr[0].key.via.str.ptr);
EXPECT_NE(
obj1.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr,
obj2.via.array.ptr[3].via.map.ptr[0].val.via.bin.ptr);
EXPECT_EQ(m1, obj1.as<myclass>());
}
TEST(object, cross_zone_copy_ext)
{
msgpack::zone z1;
msgpack::zone z2;
msgpack::object::with_zone obj1(z1);
obj1.type = msgpack::type::EXT;
char* ptr = static_cast<char*>(obj1.zone.allocate_align(2, MSGPACK_ZONE_ALIGNOF(char)));
ptr[0] = 1;
ptr[1] = 2;
obj1.via.ext.ptr = ptr;
obj1.via.ext.size = 1;
msgpack::object::with_zone obj2(z2);
obj2 << obj1;
EXPECT_EQ(obj2.via.ext.size, 1u);
EXPECT_EQ(obj2.via.ext.ptr[0], 1);
EXPECT_EQ(obj2.via.ext.ptr[1], 2);
EXPECT_NE(
obj1.via.ext.ptr,
obj2.via.ext.ptr);
}
TEST(object, cross_zone_copy_construct_ext)
{
msgpack::zone z1;
msgpack::zone z2;
msgpack::object::with_zone obj1(z1);
obj1.type = msgpack::type::EXT;
char* ptr = static_cast<char*>(obj1.zone.allocate_align(2, MSGPACK_ZONE_ALIGNOF(char)));
ptr[0] = 1;
ptr[1] = 2;
obj1.via.ext.ptr = ptr;
obj1.via.ext.size = 1;
msgpack::object obj2(obj1, z2);
EXPECT_EQ(obj2.via.ext.size, 1u);
EXPECT_EQ(obj2.via.ext.ptr[0], 1);
EXPECT_EQ(obj2.via.ext.ptr[1], 2);
EXPECT_NE(
obj1.via.ext.ptr,
obj2.via.ext.ptr);
}
TEST(object, print)
{
msgpack::object obj;
std::cout << obj << std::endl;
}
TEST(object, is_nil)
{
msgpack::object obj;
EXPECT_TRUE(obj.is_nil());
}
TEST(object, type_error)
{
msgpack::object obj(1);
EXPECT_THROW(obj.as<std::string>(), msgpack::type_error);
EXPECT_THROW(obj.as<std::vector<int> >(), msgpack::type_error);
EXPECT_EQ(1, obj.as<int>());
EXPECT_EQ(1, obj.as<short>());
EXPECT_EQ(1u, obj.as<unsigned int>());
EXPECT_EQ(1u, obj.as<unsigned long>());
}
TEST(object, equal_primitive)
{
msgpack::object obj_nil;
EXPECT_EQ(obj_nil, msgpack::object());
msgpack::object obj_int(1);
EXPECT_EQ(obj_int, msgpack::object(1));
EXPECT_EQ(obj_int, 1);
msgpack::object obj_float(1.2);
EXPECT_EQ(obj_float, msgpack::object(1.2));
EXPECT_EQ(obj_float, 1.2);
msgpack::object obj_bool(true);
EXPECT_EQ(obj_bool, msgpack::object(true));
EXPECT_EQ(obj_bool, true);
}
TEST(object, construct_primitive)
{
msgpack::object obj_nil;
EXPECT_EQ(msgpack::type::NIL, obj_nil.type);
msgpack::object obj_uint(1);
EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type);
EXPECT_EQ(1u, obj_uint.via.u64);
msgpack::object obj_int(-1);
EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type);
EXPECT_EQ(-1, obj_int.via.i64);
msgpack::object obj_float(1.2F);
EXPECT_EQ(msgpack::type::FLOAT32, obj_float.type);
EXPECT_EQ(1.2F, obj_float.via.f64);
msgpack::object obj_double(1.2);
EXPECT_EQ(msgpack::type::FLOAT64, obj_double.type);
EXPECT_EQ(msgpack::type::FLOAT, obj_double.type);
EXPECT_EQ(1.2, obj_double.via.f64);
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type);
EXPECT_EQ(1.2, obj_double.via.dec);
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
msgpack::object obj_bool(true);
EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type);
EXPECT_EQ(true, obj_bool.via.boolean);
}
TEST(object, construct_enum)
{
msgpack::object obj(elem);
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, construct_enum_newstyle)
{
msgpack::object obj(enum_test::elem);
EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
EXPECT_EQ(elem, obj.via.u64);
}
#endif // !defined(MSGPACK_USE_CPP03)
TEST(object, construct_enum_outer)
{
msgpack::object obj(outer_enum::elem);
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, construct_enum_outer_newstyle)
{
msgpack::object obj(outer_enum::enum_test::elem);
EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
EXPECT_EQ(elem, obj.via.u64);
}
TEST(object, construct_class_enum)
{
msgpack::object obj(enum_class_test::elem);
EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
EXPECT_EQ(elem, obj.via.u64);
}
TEST(object, construct_class_enum_outer)
{
msgpack::object obj(outer_enum_class::enum_class_test::elem);
EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj.type);
EXPECT_EQ(elem, obj.via.u64);
}
#endif // !defined(MSGPACK_USE_CPP03)
TEST(object, clone_int)
{
int v = 0;
msgpack::object obj(v);
std::size_t sz1 = msgpack::aligned_zone_size(obj);
msgpack::object_handle h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
}
TEST(object, clone_str)
{
msgpack::object_handle oh;
std::string v = "123456789";
{
msgpack::zone z;
msgpack::object obj(v, z);
std::size_t sz1 = msgpack::aligned_zone_size(obj);
msgpack::object_handle h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
oh = msgpack::move(h);
}
EXPECT_EQ(v, oh.get().as<std::string>());
}
TEST(object, clone_bin)
{
msgpack::object_handle oh;
std::vector<char> v;
{
msgpack::zone z;
v.push_back('A');
v.push_back('B');
v.push_back('C');
msgpack::object obj(v, z);
std::size_t sz1 = msgpack::aligned_zone_size(obj);
msgpack::object_handle h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
oh = msgpack::move(h);
}
std::vector<char> v2 = oh.get().as<std::vector<char> >();
EXPECT_EQ(v.size(), v2.size());
EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
}
TEST(object, clone_array)
{
msgpack::object_handle oh;
std::vector<int> v;
{
msgpack::zone z;
v.push_back(1);
v.push_back(2);
v.push_back(3);
msgpack::object obj(v, z);
std::size_t sz1 = msgpack::aligned_zone_size(obj);
msgpack::object_handle h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
oh = msgpack::move(h);
}
std::vector<int> v2 = oh.get().as<std::vector<int> >();
EXPECT_EQ(v.size(), v2.size());
EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
}
TEST(object, clone_map)
{
msgpack::object_handle oh;
std::map<int, std::string> v;
{
msgpack::zone z;
v.insert(std::map<int, std::string>::value_type(1, "ABC"));
v.insert(std::map<int, std::string>::value_type(2, "DEF"));
v.insert(std::map<int, std::string>::value_type(3, "GHI"));
msgpack::object obj(v, z);
std::size_t sz1 = msgpack::aligned_zone_size(obj);
msgpack::object_handle h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
h = msgpack::clone(obj);
EXPECT_EQ(h.get(), obj);
EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
oh = msgpack::move(h);
}
std::map<int, std::string> v2 = oh.get().as<std::map<int, std::string> >();
EXPECT_EQ(v.size(), v2.size());
EXPECT_TRUE(equal(v.begin(), v.end(), v2.begin()));
}
TEST(object, pack_float)
{
msgpack::object obj(1.2F);
std::stringstream ss1;
msgpack::pack(ss1, obj);
std::stringstream ss2;
msgpack::pack(ss2, 1.2F);
EXPECT_EQ(static_cast<size_t>(5), ss1.str().size());
EXPECT_EQ(ss1.str(), ss2.str());
}
TEST(object, pack_double)
{
msgpack::object obj(1.2);
std::stringstream ss1;
msgpack::pack(ss1, obj);
std::stringstream ss2;
msgpack::pack(ss2, 1.2);
EXPECT_EQ(static_cast<size_t>(9), ss1.str().size());
EXPECT_EQ(ss1.str(), ss2.str());
}
TEST(object, handle_operators)
{
int i = 1;
msgpack::object obj(i);
msgpack::object_handle oh = msgpack::clone(obj);
EXPECT_EQ(oh.get(), *oh);
EXPECT_EQ(oh->as<int>(), oh.get().as<int>());
}

1090
test/object_with_zone.cpp
View File

File diff suppressed because it is too large Load Diff

610
test/pack_unpack.cpp
View File

@@ -1,610 +0,0 @@
#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__)
#include <sstream>
TEST(pack, num)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
}
TEST(pack, vector)
{
msgpack::sbuffer sbuf;
std::vector<int> vec;
vec.push_back(1);
vec.push_back(2);
vec.push_back(3);
msgpack::pack(sbuf, vec);
}
TEST(pack, to_ostream)
{
std::ostringstream stream;
msgpack::pack(stream, 1);
}
struct myclass {
myclass() : num(0), str("default") { }
myclass(int num, const std::string& str) :
num(num), str(str) { }
~myclass() { }
int num;
std::string str;
MSGPACK_DEFINE(num, str);
};
TEST(pack, myclass)
{
msgpack::sbuffer sbuf;
myclass m(1, "msgpack");
msgpack::pack(sbuf, m);
}
TEST(unpack, int_ret_no_offset_no_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(1, oh.get().as<int>());
}
TEST(unpack, int_ret_offset_no_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
std::size_t off = 0;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off);
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, int_ret_no_offset_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_FALSE(referenced);
}
TEST(unpack, int_ret_offset_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
std::size_t off = 0;
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off, referenced);
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_FALSE(referenced);
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, int_no_offset_no_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh;
msgpack::unpack(oh, sbuf.data(), sbuf.size());
EXPECT_EQ(1, oh.get().as<int>());
}
TEST(unpack, int_offset_no_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh;
std::size_t off = 0;
msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, int_no_offset_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh;
bool referenced;
msgpack::unpack(oh, sbuf.data(), sbuf.size(), referenced);
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_FALSE(referenced);
}
TEST(unpack, int_offset_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh;
std::size_t off = 0;
bool referenced;
msgpack::unpack(oh, sbuf.data(), sbuf.size(), off, referenced);
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_FALSE(referenced);
EXPECT_EQ(off, sbuf.size());
}
#if MSGPACK_DEFAULT_API_VERSION == 1
TEST(unpack, int_pointer_off_no_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh;
std::size_t off = 0;
// obsolete
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off);
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, int_pointer_off_no_ref_explicit)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh;
std::size_t off = 0;
// obsolete
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, MSGPACK_NULLPTR);
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, int_pointer_no_off_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh;
bool referenced;
// obsolete
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
msgpack::unpack(&oh, sbuf.data(), sbuf.size(), MSGPACK_NULLPTR, &referenced);
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_FALSE(referenced);
}
TEST(unpack, int_pointer_off_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh;
bool referenced;
std::size_t off = 0;
// obsolete
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
msgpack::unpack(&oh, sbuf.data(), sbuf.size(), &off, &referenced);
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
EXPECT_EQ(1, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size());
EXPECT_FALSE(referenced);
}
TEST(unpack, int_default_null_pointer)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh;
// obsolete
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
msgpack::unpack(&oh, sbuf.data(), sbuf.size());
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
EXPECT_EQ(1, oh.get().as<int>());
}
#endif // MSGPACK_DEFAULT_API_VERSION == 1
TEST(unpack, int_zone_no_offset_no_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::zone z;
msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size());
EXPECT_EQ(1, obj.as<int>());
}
TEST(unpack, int_zone_offset_no_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
std::size_t off = 0;
msgpack::zone z;
msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(1, obj.as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, int_zone_no_offset_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
bool referenced;
msgpack::zone z;
msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), referenced);
EXPECT_EQ(1, obj.as<int>());
EXPECT_FALSE(referenced);
}
TEST(unpack, int_zone_offset_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
std::size_t off = 0;
bool referenced;
msgpack::zone z;
msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), off, referenced);
EXPECT_EQ(1, obj.as<int>());
EXPECT_FALSE(referenced);
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, sequence)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::pack(sbuf, 2);
msgpack::pack(sbuf, 3);
std::size_t off = 0;
msgpack::object_handle oh;
msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(1, oh.get().as<int>());
msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(2, oh.get().as<int>());
msgpack::unpack(oh, sbuf.data(), sbuf.size(), off);
EXPECT_EQ(3, oh.get().as<int>());
EXPECT_EQ(off, sbuf.size());
}
TEST(unpack, convert_to_object_handle)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacked msg;
msgpack::unpack(msg, sbuf.data(), sbuf.size());
msgpack::object_handle oh(msgpack::move(msg));
EXPECT_EQ(1, oh.get().as<int>());
}
TEST(unpack, convert_to_object_handle_direct)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh(msgpack::unpack(sbuf.data(), sbuf.size()));
EXPECT_EQ(1, oh.get().as<int>());
}
TEST(unpack, convert_to_object_handle_direct_implicit)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_EQ(1, oh.get().as<int>());
}
TEST(unpack, insufficient_bytes_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 255); // uint8 (2bytes)
std::size_t off = 0;
msgpack::object_handle oh;
try {
msgpack::unpack(oh, sbuf.data(), 1, off);
EXPECT_TRUE(false);
}
catch (msgpack::insufficient_bytes const&) {
EXPECT_TRUE(true);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(off, 0u);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(1u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
}
TEST(unpack, insufficient_bytes_object_handle)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 255); // uint8 (2bytes)
std::size_t off = 0;
try {
msgpack::object_handle oh(msgpack::unpack(sbuf.data(), 1, off));
EXPECT_TRUE(false);
}
catch (msgpack::insufficient_bytes const&) {
EXPECT_TRUE(true);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(off, 0u);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(1u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
}
TEST(unpack, insufficient_bytes_zone)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 255); // uint8 (2bytes)
std::size_t off = 0;
try {
msgpack::zone z;
msgpack::unpack(z, sbuf.data(), 1, off);
EXPECT_TRUE(false);
}
catch (msgpack::insufficient_bytes const&) {
EXPECT_TRUE(true);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(off, 0u);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(1u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
}
TEST(unpack, parse_error)
{
msgpack::sbuffer sbuf;
char c = '\xc1';
sbuf.write(&c, 1);
bool thrown = false;
msgpack::object_handle oh;
try {
msgpack::unpack(oh, sbuf.data(), sbuf.size());
EXPECT_TRUE(false);
}
catch (msgpack::parse_error const&) {
thrown = true;
}
EXPECT_TRUE(thrown);
}
TEST(unpack, returned_parse_error)
{
msgpack::sbuffer sbuf;
char c = '\xc1';
sbuf.write(&c, 1);
bool thrown = false;
try {
msgpack::unpack(sbuf.data(), sbuf.size());
EXPECT_TRUE(false);
}
catch (msgpack::parse_error const&) {
thrown = true;
}
EXPECT_TRUE(thrown);
}
TEST(unpack, zone_parse_error)
{
msgpack::sbuffer sbuf;
char c = '\xc1';
sbuf.write(&c, 1);
bool thrown = false;
msgpack::zone z;
try {
msgpack::unpack(z, sbuf.data(), sbuf.size());
EXPECT_TRUE(false);
}
catch (msgpack::parse_error const&) {
thrown = true;
}
EXPECT_TRUE(thrown);
}
TEST(unpack, extra_bytes)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size() + 1);
EXPECT_EQ(1, oh.get().as<int>());
}
TEST(unpack, zone_extra_bytes)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::zone z;
msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size() + 1);
EXPECT_EQ(1, obj.as<int>());
}
TEST(unpack, int_off_larger_than_length)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
std::size_t off = 2;
bool thrown = false;
try {
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), off);
}
catch (msgpack::insufficient_bytes const&) {
thrown = true;
}
EXPECT_TRUE(thrown);
EXPECT_EQ(off, 2u);
}
TEST(unpack, empty_array_fix)
{
std::string buf;
buf.push_back(static_cast<char>(0x90u));
std::size_t off = 0;
msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
EXPECT_EQ(oh.get().via.array.size, 0u);
EXPECT_EQ(off, 1u);
}
TEST(unpack, empty_array_16)
{
std::string buf;
buf.push_back(static_cast<char>(0xdcu));
buf.push_back(static_cast<char>(0x00));
buf.push_back(static_cast<char>(0x00));
std::size_t off = 0;
msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
EXPECT_EQ(oh.get().via.array.size, 0u);
EXPECT_EQ(off, 3u);
}
TEST(unpack, empty_array_32)
{
std::string buf;
buf.push_back(static_cast<char>(0xddu));
buf.push_back(static_cast<char>(0x00));
buf.push_back(static_cast<char>(0x00));
buf.push_back(static_cast<char>(0x00));
buf.push_back(static_cast<char>(0x00));
std::size_t off = 0;
msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
EXPECT_EQ(oh.get().via.array.size, 0u);
EXPECT_EQ(off, 5u);
}
TEST(unpack, empty_map_fix)
{
std::string buf;
buf.push_back(static_cast<char>(0x80u));
std::size_t off = 0;
msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
EXPECT_EQ(oh.get().type, msgpack::type::MAP);
EXPECT_EQ(oh.get().via.map.size, 0u);
EXPECT_EQ(off, 1u);
}
TEST(unpack, empty_map_16)
{
std::string buf;
buf.push_back(static_cast<char>(0xdeu));
buf.push_back(static_cast<char>(0x00));
buf.push_back(static_cast<char>(0x00));
std::size_t off = 0;
msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
EXPECT_EQ(oh.get().type, msgpack::type::MAP);
EXPECT_EQ(oh.get().via.map.size, 0u);
EXPECT_EQ(off, 3u);
}
TEST(unpack, empty_map_32)
{
std::string buf;
buf.push_back(static_cast<char>(0xdfu));
buf.push_back(static_cast<char>(0x00));
buf.push_back(static_cast<char>(0x00));
buf.push_back(static_cast<char>(0x00));
buf.push_back(static_cast<char>(0x00));
std::size_t off = 0;
msgpack::object_handle oh = msgpack::unpack(buf.data(), buf.size(), off);
EXPECT_EQ(oh.get().type, msgpack::type::MAP);
EXPECT_EQ(oh.get().via.map.size, 0u);
EXPECT_EQ(off, 5u);
}

244
test/raw.cpp
View File

@@ -1,244 +0,0 @@
#include <msgpack.hpp>
#include <string>
#include <sstream>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
TEST(MSGPACK_RAW_REF, pack_unpack)
{
std::string s = "ABC";
msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xc4u));
EXPECT_EQ(packed_str[1], static_cast<char>(0x03u));
EXPECT_EQ(packed_str[2], 'A');
EXPECT_EQ(packed_str[3], 'B');
EXPECT_EQ(packed_str[4], 'C');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_RAW_REF, pack_unpack_8_l)
{
std::string s;
msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xc4u));
EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_RAW_REF, pack_unpack_8_h)
{
std::string s(0xff, 'A');
msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xc4u));
EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[2], 'A');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_RAW_REF, pack_unpack_16_l)
{
std::string s(0xff+1, 'A');
msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xc5u));
EXPECT_EQ(packed_str[1], static_cast<char>(0x01));
EXPECT_EQ(packed_str[2], static_cast<char>(0x00));
EXPECT_EQ(packed_str[3], 'A');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_RAW_REF, pack_unpack_16_h)
{
std::string s(0xffff, 'A');
msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xc5u));
EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[2], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[3], 'A');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_RAW_REF, pack_unpack_32_l)
{
std::string s(0xffff+1, 'A');
msgpack::type::raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xc6u));
EXPECT_EQ(packed_str[1], static_cast<char>(0x00));
EXPECT_EQ(packed_str[2], static_cast<char>(0x01));
EXPECT_EQ(packed_str[3], static_cast<char>(0x00));
EXPECT_EQ(packed_str[4], static_cast<char>(0x00));
EXPECT_EQ(packed_str[5], 'A');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_V4RAW_REF, pack_unpack)
{
std::string s = "ABC";
msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xa3u));
EXPECT_EQ(packed_str[1], 'A');
EXPECT_EQ(packed_str[2], 'B');
EXPECT_EQ(packed_str[3], 'C');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_l)
{
std::string s;
msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xa0u));
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_h)
{
std::string s(0x1f, 'A');
msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xbfu));
EXPECT_EQ(packed_str[1], 'A');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_V4RAW_REF, pack_unpack_16_l)
{
std::string s(0x1f+1, 'A');
msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xdau));
EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
EXPECT_EQ(packed_str[2], static_cast<char>(0x20u));
EXPECT_EQ(packed_str[3], 'A');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_V4RAW_REF, pack_unpack_16_h)
{
std::string s(0xffff, 'A');
msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xdau));
EXPECT_EQ(packed_str[1], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[2], static_cast<char>(0xffu));
EXPECT_EQ(packed_str[3], 'A');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}
TEST(MSGPACK_V4RAW_REF, pack_unpack_32_l)
{
std::string s(0xffff+1, 'A');
msgpack::type::v4raw_ref rr1(s.data(), static_cast<uint32_t>(s.size()));
std::stringstream ss;
msgpack::pack(ss, rr1);
std::string packed_str = ss.str();
EXPECT_EQ(packed_str[0], static_cast<char>(0xdbu));
EXPECT_EQ(packed_str[1], static_cast<char>(0x00));
EXPECT_EQ(packed_str[2], static_cast<char>(0x01));
EXPECT_EQ(packed_str[3], static_cast<char>(0x00));
EXPECT_EQ(packed_str[4], static_cast<char>(0x00));
EXPECT_EQ(packed_str[5], 'A');
msgpack::object_handle oh =
msgpack::unpack(packed_str.data(), packed_str.size());
msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
EXPECT_TRUE(rr1 == rr2);
}

474
test/reference.cpp
View File

@@ -1,474 +0,0 @@
#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__)
TEST(reference, unpack_int)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
bool referenced = false;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_string)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg"));
bool referenced = false;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_bin)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
bool referenced = false;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_ext)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
bool referenced = false;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
bool never_called(msgpack::type::object_type, std::size_t, void*)
{
EXPECT_TRUE(false);
return false;
}
bool always_reference(msgpack::type::object_type, std::size_t, void*)
{
return true;
}
TEST(reference, unpack_int_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
bool referenced = false;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_string_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg"));
bool referenced = false;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced);
}
TEST(reference, unpack_bin_ref)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
bool referenced = false;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced);
}
TEST(reference, unpack_ext_ref)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
bool referenced = false;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced);
}
static void* s_p;
bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p)
{
s_p = p;
switch (t) {
case msgpack::type::STR:
if (s >= 5) return true;
break;
case msgpack::type::BIN:
if (s >= 6) return true;
break;
case msgpack::type::EXT:
if (s >= 7) return true;
break;
default:
EXPECT_TRUE(false);
}
return false;
}
TEST(reference, unpack_int_sized_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
bool referenced = false;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called, &sbuf);
EXPECT_FALSE(referenced);
EXPECT_EQ(MSGPACK_NULLPTR, s_p);
}
TEST(reference, unpack_string_sized_ref_4)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("1234"));
bool referenced = false;
s_p = MSGPACK_NULLPTR;
// the last argument sbuf is any pointer as a user data.
// That is stored to s_p in sized_reference
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced);
// compare the passed argument with stored s_p.
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_string_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("12345"));
bool referenced = false;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_bin_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
bool referenced = false;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_bin_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
bool referenced = false;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_ext_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5 };
packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6
packer.pack_ext_body(buf, sizeof(buf));
bool referenced = false;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_ext_sized_ref_7)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5, 6 };
packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7
packer.pack_ext_body(buf, sizeof(buf));
bool referenced = false;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
// default reference function
// STR, BIN, and EXT are always referenced, otherwise copied (converted).
TEST(reference, unpacker_int)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacker unp;
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(referenced);
}
TEST(reference, unpacker_string)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("a"));
msgpack::unpacker unp;
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(referenced);
}
TEST(reference, unpacker_bin)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacker unp;
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(referenced);
}
TEST(reference, unpacker_ext)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacker unp;
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(referenced);
}
// pass user custom reference function
TEST(reference, unpacker_int_sized_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
msgpack::unpacker unp(never_called, &sbuf);
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = MSGPACK_NULLPTR;
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(referenced);
EXPECT_EQ(MSGPACK_NULLPTR, s_p);
}
TEST(reference, unpacker_string_sized_ref_4)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("1234"));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = MSGPACK_NULLPTR;
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_string_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("12345"));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = MSGPACK_NULLPTR;
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_bin_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = MSGPACK_NULLPTR;
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_bin_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = MSGPACK_NULLPTR;
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_ext_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5 };
packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = MSGPACK_NULLPTR;
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpacker_ext_sized_ref_7)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5, 6 };
packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7
packer.pack_ext_body(buf, sizeof(buf));
msgpack::unpacker unp(sized_reference, &sbuf);
msgpack::object_handle oh;
bool referenced = false;
unp.reserve_buffer(sbuf.size());
std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
unp.buffer_consumed(sbuf.size());
s_p = MSGPACK_NULLPTR;
bool b = unp.next(oh, referenced);
EXPECT_TRUE(b);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}

242
test/reference_cpp11.cpp
View File

@@ -1,242 +0,0 @@
#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__)
#if !defined(MSGPACK_USE_CPP03)
TEST(reference, unpack_int)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_string)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg"));
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_bin)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_ext)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced);
EXPECT_FALSE(referenced);
}
bool never_called(msgpack::type::object_type, std::size_t, void*)
{
EXPECT_TRUE(false);
return false;
}
bool always_reference(msgpack::type::object_type, std::size_t, void*)
{
return true;
}
TEST(reference, unpack_int_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called);
EXPECT_FALSE(referenced);
}
TEST(reference, unpack_string_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("abcdefg"));
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced);
}
TEST(reference, unpack_bin_ref)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced);
}
TEST(reference, unpack_ext_ref)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 2 };
packer.pack_ext(sizeof(buf), 1);
packer.pack_ext_body(buf, sizeof(buf));
bool referenced;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference);
EXPECT_TRUE(referenced);
}
static void* s_p;
bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p)
{
s_p = p;
switch (t) {
case msgpack::type::STR:
if (s >= 5) return true;
break;
case msgpack::type::BIN:
if (s >= 6) return true;
break;
case msgpack::type::EXT:
if (s >= 7) return true;
break;
default:
EXPECT_TRUE(false);
}
return false;
}
TEST(reference, unpack_int_sized_ref)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, 1);
bool referenced;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called, &sbuf);
EXPECT_FALSE(referenced);
EXPECT_EQ(MSGPACK_NULLPTR, s_p);
}
TEST(reference, unpack_string_sized_ref_4)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("1234"));
bool referenced;
s_p = MSGPACK_NULLPTR;
// the last argument sbuf is any pointer as a user data.
// That is stored to s_p in sized_reference
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced);
// compare the passed argument with stored s_p.
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_string_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, std::string("12345"));
bool referenced;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_bin_sized_ref_5)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
bool referenced;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_bin_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char c[] = { 1, 2, 3, 4, 5, 6 };
packer.pack_bin(sizeof(c));
packer.pack_bin_body(c, sizeof(c));
bool referenced;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_ext_sized_ref_6)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5 };
packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6
packer.pack_ext_body(buf, sizeof(buf));
bool referenced;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_FALSE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
TEST(reference, unpack_ext_sized_ref_7)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> packer(sbuf);
char const buf [] = { 1, 2, 3, 4, 5, 6 };
packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7
packer.pack_ext_body(buf, sizeof(buf));
bool referenced;
s_p = MSGPACK_NULLPTR;
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
EXPECT_TRUE(referenced);
EXPECT_EQ(&sbuf, s_p);
}
#endif // !defined(MSGPACK_USE_CPP03)

108
test/reference_wrapper_cpp11.cpp
View File

@@ -1,108 +0,0 @@
#include <msgpack.hpp>
#include <sstream>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if !defined(MSGPACK_USE_CPP03)
TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert)
{
int i1 = 42;
std::reference_wrapper<int> val1(i1);
std::stringstream ss;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
int i2 = 0;
std::reference_wrapper<int> val2(i2);
oh.get().convert(val2);
EXPECT_EQ(i1, i2);
}
TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert_const)
{
const int i1 = 42;
std::reference_wrapper<const int> val1(i1);
std::stringstream ss;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
int i2 = 0;
std::reference_wrapper<int> val2(i2);
oh.get().convert(val2);
EXPECT_EQ(i1, i2);
}
TEST(MSGPACK_REFERENCE_WRAPPER, pack_vector)
{
int i1 = 42;
std::vector<std::reference_wrapper<int>> val1{i1};
std::stringstream ss;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
std::vector<int> val2 = oh.get().as<std::vector<int>>();
EXPECT_EQ(val2.size(), static_cast<size_t>(1));
EXPECT_EQ(val1[0], val2[0]);
}
TEST(MSGPACK_REFERENCE_WRAPPER, object)
{
int i1 = 42;
std::reference_wrapper<int> val1(i1);
msgpack::object o(val1);
int i2 = 0;
std::reference_wrapper<int> val2(i2);
o.convert(val2);
EXPECT_EQ(i1, i2);
}
TEST(MSGPACK_REFERENCE_WRAPPER, object_const)
{
const int i1 = 42;
std::reference_wrapper<const int> val1(i1);
msgpack::object o(val1);
int i2 = 0;
std::reference_wrapper<int> val2(i2);
o.convert(val2);
EXPECT_EQ(i1, i2);
}
TEST(MSGPACK_REFERENCE_WRAPPER, object_with_zone)
{
std::string s1 = "ABC";
std::reference_wrapper<std::string> val1(s1);
msgpack::zone z;
msgpack::object o(val1, z);
std::string s2 = "DE";
std::reference_wrapper<std::string> val2(s2);
o.convert(val2);
EXPECT_EQ(s1, s2);
}
TEST(MSGPACK_REFERENCE_WRAPPER, object_with_zone_const)
{
const std::string s1 = "ABC";
std::reference_wrapper<const std::string> val1(s1);
msgpack::zone z;
msgpack::object o(val1, z);
std::string s2 = "DE";
std::reference_wrapper<std::string> val2(s2);
o.convert(val2);
EXPECT_EQ(s1, s2);
}
#endif // !defined(MSGPACK_USE_CPP03)

136
test/shared_ptr_cpp11.cpp
View File

@@ -1,136 +0,0 @@
#include <msgpack.hpp>
#include <sstream>
#include <iterator>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if !defined(MSGPACK_USE_CPP03)
TEST(SHARED_PTR, pack_convert_nil)
{
std::stringstream ss;
std::shared_ptr<int> val1;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
EXPECT_TRUE(val1 == val2);
}
TEST(SHARED_PTR, pack_convert_int)
{
std::stringstream ss;
std::shared_ptr<int> val1(new int(1));
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
TEST(SHARED_PTR, object_nil)
{
std::shared_ptr<int> val1;
msgpack::object obj(val1);
std::shared_ptr<int> val2 = obj.as<std::shared_ptr<int>>();
EXPECT_TRUE(val1 == val2);
}
TEST(SHARED_PTR, object_int)
{
std::shared_ptr<int> val1(new int(1));
msgpack::object obj(val1);
std::shared_ptr<int> val2 = obj.as<std::shared_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
// Compile error as expected
// object::with_zone is required not object
/*
TEST(SHARED_PTR, object_vector)
{
typedef std::shared_ptr<std::vector<int>> ovi_t;
ovi_t val1(new std::vector<int>());
msgpack::object obj(val1);
ovi_t val2 = obj.as<ovi_t>();
EXPECT_TRUE(val1 == val2);
}
*/
TEST(SHARED_PTR, object_with_zone_nil)
{
msgpack::zone z;
std::shared_ptr<int> val1;
msgpack::object obj(val1, z);
std::shared_ptr<int> val2 = obj.as<std::shared_ptr<int>>();
EXPECT_TRUE(val1 == val2);
}
TEST(SHARED_PTR, object_with_zone_int)
{
msgpack::zone z;
std::shared_ptr<int> val1(new int(1));
msgpack::object obj(val1, z);
std::shared_ptr<int> val2 = obj.as<std::shared_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
struct no_def_con {
no_def_con() = delete;
no_def_con(int i):i(i) {}
int i;
MSGPACK_DEFINE(i);
};
inline bool operator==(no_def_con const& lhs, no_def_con const& rhs) {
return lhs.i == rhs.i;
}
inline bool operator!=(no_def_con const& lhs, no_def_con const& rhs) {
return !(lhs == rhs);
}
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor {
template <>
struct as<no_def_con> {
no_def_con operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error();
return no_def_con(o.via.array.ptr[0].as<int>());
}
};
} // adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // msgpack
TEST(SHARED_PTR, pack_convert_nil_no_def_con)
{
std::stringstream ss;
std::shared_ptr<no_def_con> val1(new no_def_con(1));
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::shared_ptr<no_def_con> val2 = oh.get().as<std::shared_ptr<no_def_con>>();
EXPECT_TRUE(*val1 == *val2);
}
#endif // !defined(MSGPACK_USE_CPP03)

234
test/size_equal_only.cpp
View File

@@ -1,234 +0,0 @@
#include <sstream>
#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__)
TEST(size_equal_only, array)
{
std::stringstream ss;
int buf[3] = { 1, 2, 3 };
msgpack::type::size_equal_only<int[3]> seo(buf);
msgpack::pack(ss, seo);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
int ret_buf1[3];
oh.get().convert(ret_buf1);
EXPECT_EQ(buf[0], ret_buf1[0]);
EXPECT_EQ(buf[1], ret_buf1[1]);
EXPECT_EQ(buf[2], ret_buf1[2]);
int ret_buf2[4];
oh.get().convert(ret_buf2);
EXPECT_EQ(buf[0], ret_buf2[0]);
EXPECT_EQ(buf[1], ret_buf2[1]);
EXPECT_EQ(buf[2], ret_buf2[2]);
int ret_buf3[3];
msgpack::type::size_equal_only<int[3]> ret_seo3(ret_buf3);
oh.get().convert(ret_seo3);
EXPECT_EQ(buf[0], ret_buf3[0]);
EXPECT_EQ(buf[1], ret_buf3[1]);
EXPECT_EQ(buf[2], ret_buf3[2]);
int ret_buf4[4];
msgpack::type::size_equal_only<int[4]> ret_seo4(ret_buf4);
try {
oh.get().convert(ret_seo4);
EXPECT_TRUE(false);
}
catch (msgpack::type_error const&) {
EXPECT_TRUE(true);
}
}
TEST(size_equal_only, vector)
{
std::stringstream ss;
std::vector<int> buf;
buf.push_back(1);
buf.push_back(2);
buf.push_back(3);
msgpack::type::size_equal_only<std::vector<int> > seo(buf);
msgpack::pack(ss, seo);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
std::vector<int> ret_buf1;
oh.get().convert(ret_buf1);
EXPECT_EQ(buf, ret_buf1);
std::vector<int> ret_buf2;
ret_buf2.resize(3);
msgpack::type::size_equal_only<std::vector<int> > ret_seo2(ret_buf2);
oh.get().convert(ret_seo2);
EXPECT_EQ(buf, ret_buf2);
std::vector<int> ret_buf3;
ret_buf2.resize(4);
msgpack::type::size_equal_only<std::vector<int> > ret_seo3(ret_buf3);
try {
oh.get().convert(ret_seo3);
EXPECT_TRUE(false);
}
catch (msgpack::type_error const&) {
EXPECT_TRUE(true);
}
}
TEST(size_equal_only, msgpack_tuple)
{
std::stringstream ss;
msgpack::type::tuple<int, bool, std::string> buf(1, false, "ABC");
msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string> > seo(buf);
msgpack::pack(ss, seo);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
msgpack::type::tuple<int, bool, std::string> ret_buf1;
oh.get().convert(ret_buf1);
EXPECT_EQ(buf.get<0>(), ret_buf1.get<0>());
EXPECT_EQ(buf.get<1>(), ret_buf1.get<1>());
EXPECT_EQ(buf.get<2>(), ret_buf1.get<2>());
msgpack::type::tuple<int, bool, std::string> ret_buf2;
msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string> > ret_seo2(ret_buf2);
oh.get().convert(ret_seo2);
EXPECT_EQ(buf.get<0>(), ret_buf2.get<0>());
EXPECT_EQ(buf.get<1>(), ret_buf2.get<1>());
EXPECT_EQ(buf.get<2>(), ret_buf2.get<2>());
msgpack::type::tuple<int, bool, std::string, int> ret_buf3;
oh.get().convert(ret_buf3);
EXPECT_EQ(buf.get<0>(), ret_buf3.get<0>());
EXPECT_EQ(buf.get<1>(), ret_buf3.get<1>());
EXPECT_EQ(buf.get<2>(), ret_buf3.get<2>());
msgpack::type::tuple<int, bool, std::string, int> ret_buf4;
msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string, int> > ret_seo4(ret_buf4);
try {
oh.get().convert(ret_seo4);
EXPECT_TRUE(false);
}
catch (msgpack::type_error const&) {
EXPECT_TRUE(true);
}
msgpack::type::tuple<int, bool, std::string> ret_buf5;
oh.get().convert(ret_buf5);
EXPECT_EQ(buf.get<0>(), ret_buf5.get<0>());
EXPECT_EQ(buf.get<1>(), ret_buf5.get<1>());
msgpack::type::tuple<int, bool, std::string, int> ret_buf6;
msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string, int> > ret_seo6(ret_buf6);
try {
oh.get().convert(ret_seo6);
EXPECT_TRUE(false);
}
catch (msgpack::type_error const&) {
EXPECT_TRUE(true);
}
}
#if !defined(MSGPACK_USE_CPP03)
TEST(size_equal_only, tuple)
{
std::stringstream ss;
std::tuple<int, bool, std::string> buf(1, false, "ABC");
auto seo = msgpack::type::make_size_equal_only(buf);
msgpack::pack(ss, seo);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
std::tuple<int, bool, std::string> ret_buf1;
oh.get().convert(ret_buf1);
EXPECT_EQ(buf, ret_buf1);
std::tuple<int, bool, std::string> ret_buf2;
auto ret_seo2 = msgpack::type::make_size_equal_only(ret_buf2);
oh.get().convert(ret_seo2);
EXPECT_EQ(buf, ret_buf2);
std::tuple<int, bool, std::string, int> ret_buf3;
oh.get().convert(ret_buf3);
EXPECT_EQ(std::get<0>(buf), std::get<0>(ret_buf3));
EXPECT_EQ(std::get<1>(buf), std::get<1>(ret_buf3));
EXPECT_EQ(std::get<2>(buf), std::get<2>(ret_buf3));
std::tuple<int, bool, std::string, int> ret_buf4;
auto ret_seo4 = msgpack::type::make_size_equal_only(ret_buf4);
try {
oh.get().convert(ret_seo4);
EXPECT_TRUE(false);
}
catch (msgpack::type_error const&) {
EXPECT_TRUE(true);
}
std::tuple<int, bool, std::string> ret_buf5;
oh.get().convert(ret_buf5);
EXPECT_EQ(std::get<0>(buf), std::get<0>(ret_buf5));
EXPECT_EQ(std::get<1>(buf), std::get<1>(ret_buf5));
std::tuple<int, bool, std::string, int> ret_buf6;
auto ret_seo6 = msgpack::type::make_size_equal_only(ret_buf6);
try {
oh.get().convert(ret_seo6);
EXPECT_TRUE(false);
}
catch (msgpack::type_error const&) {
EXPECT_TRUE(true);
}
}
struct foo1 {
foo1(int i, bool b):t(i, b), seo(t) {}
std::tuple<int, bool> t;
msgpack::type::size_equal_only<std::tuple<int, bool> > seo;
MSGPACK_DEFINE(seo);
};
struct foo2 {
foo2(int i, bool b, std::string const& s):t(i, b, s), seo(t) {}
std::tuple<int, bool, std::string> t;
msgpack::type::size_equal_only<std::tuple<int, bool, std::string> > seo;
MSGPACK_DEFINE(seo);
};
TEST(size_equal_only, custom_class)
{
std::stringstream ss;
foo1 f1(42, true);
msgpack::pack(ss, f1);
std::string const& str = ss.str();
msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
foo2 f2(123, false, "ABC");
try {
oh.get().convert(f2);
EXPECT_TRUE(false);
}
catch (msgpack::type_error const&) {
EXPECT_TRUE(true);
}
}
#endif // !defined(MSGPACK_USE_CPP03)

343
test/streaming.cpp
View File

@@ -1,343 +0,0 @@
#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__)
#include <sstream>
TEST(streaming, basic)
{
msgpack::sbuffer buffer;
msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack(1);
pk.pack(2);
pk.pack(3);
const char* input = buffer.data();
const char* const eof = input + buffer.size();
msgpack::unpacker pac;
msgpack::object_handle oh;
int count = 0;
while(count < 3) {
pac.reserve_buffer(32*1024);
// read buffer into pac.buffer() upto
// pac.buffer_capacity() bytes.
size_t len = 1;
memcpy(pac.buffer(), input, len);
input += len;
pac.buffer_consumed(len);
while(pac.next(oh)) {
msgpack::object obj = oh.get();
switch(count++) {
case 0:
EXPECT_EQ(1, obj.as<int>());
break;
case 1:
EXPECT_EQ(2, obj.as<int>());
break;
case 2:
EXPECT_EQ(3, obj.as<int>());
return;
}
}
EXPECT_TRUE(input < eof);
}
}
// obsolete
#if MSGPACK_DEFAULT_API_VERSION == 1
TEST(streaming, basic_pointer)
{
msgpack::sbuffer buffer;
msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack(1);
pk.pack(2);
pk.pack(3);
const char* input = buffer.data();
const char* const eof = input + buffer.size();
msgpack::unpacker pac;
msgpack::object_handle oh;
int count = 0;
while(count < 3) {
pac.reserve_buffer(32*1024);
// read buffer into pac.buffer() upto
// pac.buffer_capacity() bytes.
size_t len = 1;
memcpy(pac.buffer(), input, len);
input += len;
pac.buffer_consumed(len);
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
while(pac.next(&oh)) {
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
msgpack::object obj = oh.get();
switch(count++) {
case 0:
EXPECT_EQ(1, obj.as<int>());
break;
case 1:
EXPECT_EQ(2, obj.as<int>());
break;
case 2:
EXPECT_EQ(3, obj.as<int>());
return;
}
}
EXPECT_TRUE(input < eof);
}
}
#endif // MSGPACK_DEFAULT_API_VERSION == 1
#if !defined(MSGPACK_USE_CPP03)
TEST(streaming, move)
{
msgpack::sbuffer buffer;
msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack(1);
pk.pack(2);
pk.pack(3);
const char* input = buffer.data();
const char* const eof = input + buffer.size();
msgpack::unpacker pac;
msgpack::object_handle oh;
int count = 0;
while(count < 3) {
msgpack::unpacker pac_in(std::move(pac));
pac_in.reserve_buffer(32*1024);
// read buffer into pac_in.buffer() upto
// pac_in.buffer_capac_inity() bytes.
size_t len = 1;
memcpy(pac_in.buffer(), input, len);
input += len;
pac_in.buffer_consumed(len);
while(pac_in.next(oh)) {
msgpack::object obj = oh.get();
switch(count++) {
case 0:
EXPECT_EQ(1, obj.as<int>());
break;
case 1:
EXPECT_EQ(2, obj.as<int>());
break;
case 2:
EXPECT_EQ(3, obj.as<int>());
return;
}
}
EXPECT_TRUE(input < eof);
pac = std::move(pac_in);
}
}
#endif // !defined(MSGPACK_USE_CPP03)
class event_handler {
public:
event_handler(std::istream& input) : input(input) { }
~event_handler() { }
void on_read()
{
while(true) {
pac.reserve_buffer(32*1024);
size_t len = static_cast<size_t>(input.readsome(pac.buffer(), static_cast<std::streamsize>(pac.buffer_capacity())));
if(len == 0) {
return;
}
pac.buffer_consumed(len);
msgpack::object_handle oh;
while(pac.next(oh)) {
on_message(oh.get(), msgpack::move(oh.zone()));
}
if(pac.message_size() > 10*1024*1024) {
throw std::runtime_error("message is too large");
}
}
}
void on_message(msgpack::object obj, msgpack::unique_ptr<msgpack::zone>)
{
EXPECT_EQ(expect, obj.as<int>());
}
int expect;
private:
std::istream& input;
msgpack::unpacker pac;
};
TEST(streaming, event)
{
std::stringstream stream;
msgpack::packer<std::ostream> pk(&stream);
event_handler handler(stream);
pk.pack(1);
handler.expect = 1;
handler.on_read();
pk.pack(2);
handler.expect = 2;
handler.on_read();
pk.pack(3);
handler.expect = 3;
handler.on_read();
}
// obsolete
#if MSGPACK_DEFAULT_API_VERSION == 1
// backward compatibility
TEST(streaming, basic_compat)
{
std::ostringstream stream;
msgpack::packer<std::ostream> pk(&stream);
pk.pack(1);
pk.pack(2);
pk.pack(3);
std::istringstream input(stream.str());
msgpack::unpacker pac;
int count = 0;
while(count < 3) {
pac.reserve_buffer(32*1024);
size_t len = static_cast<size_t>(input.readsome(pac.buffer(), static_cast<std::streamsize>(pac.buffer_capacity())));
pac.buffer_consumed(len);
while(pac.execute()) {
msgpack::unique_ptr<msgpack::zone> z(pac.release_zone());
msgpack::object obj = pac.data();
pac.reset();
switch(count++) {
case 0:
EXPECT_EQ(1, obj.as<int>());
break;
case 1:
EXPECT_EQ(2, obj.as<int>());
break;
case 2:
EXPECT_EQ(3, obj.as<int>());
return;
}
}
}
}
// backward compatibility
class event_handler_compat {
public:
event_handler_compat(std::istream& input) : input(input) { }
~event_handler_compat() { }
void on_read()
{
while(true) {
pac.reserve_buffer(32*1024);
size_t len = static_cast<size_t>(input.readsome(pac.buffer(), static_cast<std::streamsize>(pac.buffer_capacity())));
if(len == 0) {
return;
}
pac.buffer_consumed(len);
while(pac.execute()) {
msgpack::unique_ptr<msgpack::zone> z(pac.release_zone());
msgpack::object obj = pac.data();
pac.reset();
on_message(obj, msgpack::move(z));
}
if(pac.message_size() > 10*1024*1024) {
throw std::runtime_error("message is too large");
}
}
}
void on_message(msgpack::object obj, msgpack::unique_ptr<msgpack::zone>)
{
EXPECT_EQ(expect, obj.as<int>());
}
int expect;
private:
std::istream& input;
msgpack::unpacker pac;
};
TEST(streaming, event_compat)
{
std::stringstream stream;
msgpack::packer<std::ostream> pk(&stream);
event_handler_compat handler(stream);
pk.pack(1);
handler.expect = 1;
handler.on_read();
pk.pack(2);
handler.expect = 2;
handler.on_read();
pk.pack(3);
handler.expect = 3;
handler.on_read();
}
#endif // !defined(MSGPACK_USE_CPP03)

79
test/test_allocator.hpp
View File

@@ -1,79 +0,0 @@
//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2015 KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef TEST_ALLOCATOR_HPP
#define TEST_ALLOCATOR_HPP
#include <memory>
namespace test {
template <typename T>
struct allocator {
typedef typename std::allocator<T>::value_type value_type;
typedef typename std::allocator<T>::pointer pointer;
typedef typename std::allocator<T>::reference reference;
typedef typename std::allocator<T>::const_pointer const_pointer;
typedef typename std::allocator<T>::const_reference const_reference;
typedef typename std::allocator<T>::size_type size_type;
typedef typename std::allocator<T>::difference_type difference_type;
template <class U> struct rebind { typedef allocator<U> other; };
#if defined(MSGPACK_USE_CPP03)
allocator() throw() {}
allocator (const allocator& alloc) throw()
:alloc_(alloc.alloc_) {}
template <class U>
allocator (const allocator<U>& alloc) throw()
:alloc_(alloc.alloc_) {}
void construct ( pointer p, const_reference val ) {
return alloc_.construct(p, val);
}
size_type max_size() const throw() { return alloc_.max_size(); }
#else // defined(MSGPACK_USE_CPP03)
allocator() noexcept {}
allocator (const allocator& alloc) noexcept
:alloc_(alloc.alloc_) {}
template <class U>
allocator (const allocator<U>& alloc) noexcept
:alloc_(alloc.alloc_) {}
template <class U, class... Args>
void construct (U* p, Args&&... args) {
return alloc_.construct(p, std::forward<Args>(args)...);
}
size_type max_size() const noexcept { return alloc_.max_size(); }
#endif // defined(MSGPACK_USE_CPP03)
pointer allocate (size_type n) {
return alloc_.allocate(n);
}
void deallocate (pointer p, size_type n) {
return alloc_.deallocate(p, n);
}
void destroy (pointer p) {
alloc_.destroy(p);
}
std::allocator<T> alloc_;
};
template <typename T>
inline bool operator==(allocator<T> const& lhs, allocator<T> const& rhs) {
return lhs.alloc_ == rhs.alloc_;
}
template <typename T>
inline bool operator!=(allocator<T> const& lhs, allocator<T> const& rhs) {
return lhs.alloc_ != rhs.alloc_;
}
} // namespace test
#endif // TEST_ALLOCATOR_HPP

136
test/unique_ptr_cpp11.cpp
View File

@@ -1,136 +0,0 @@
#include <msgpack.hpp>
#include <sstream>
#include <iterator>
#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__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if !defined(MSGPACK_USE_CPP03)
TEST(UNIQUE_PTR, pack_convert_nil)
{
std::stringstream ss;
std::unique_ptr<int> val1;
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
EXPECT_TRUE(val1 == val2);
}
TEST(UNIQUE_PTR, pack_convert_int)
{
std::stringstream ss;
std::unique_ptr<int> val1(new int(1));
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
TEST(UNIQUE_PTR, object_nil)
{
std::unique_ptr<int> val1;
msgpack::object obj(val1);
std::unique_ptr<int> val2 = obj.as<std::unique_ptr<int>>();
EXPECT_TRUE(val1 == val2);
}
TEST(UNIQUE_PTR, object_int)
{
std::unique_ptr<int> val1(new int(1));
msgpack::object obj(val1);
std::unique_ptr<int> val2 = obj.as<std::unique_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
// Compile error as expected
// object::with_zone is required not object
/*
TEST(UNIQUE_PTR, object_vector)
{
typedef std::unique_ptr<std::vector<int>> ovi_t;
ovi_t val1(new std::vector<int>());
msgpack::object obj(val1);
ovi_t val2 = obj.as<ovi_t>();
EXPECT_TRUE(val1 == val2);
}
*/
TEST(UNIQUE_PTR, object_with_zone_nil)
{
msgpack::zone z;
std::unique_ptr<int> val1;
msgpack::object obj(val1, z);
std::unique_ptr<int> val2 = obj.as<std::unique_ptr<int>>();
EXPECT_TRUE(val1 == val2);
}
TEST(UNIQUE_PTR, object_with_zone_int)
{
msgpack::zone z;
std::unique_ptr<int> val1(new int(1));
msgpack::object obj(val1, z);
std::unique_ptr<int> val2 = obj.as<std::unique_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
struct no_def_con {
no_def_con() = delete;
no_def_con(int i):i(i) {}
int i;
MSGPACK_DEFINE(i);
};
inline bool operator==(no_def_con const& lhs, no_def_con const& rhs) {
return lhs.i == rhs.i;
}
inline bool operator!=(no_def_con const& lhs, no_def_con const& rhs) {
return !(lhs == rhs);
}
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor {
template <>
struct as<no_def_con> {
no_def_con operator()(msgpack::object const& o) const {
if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
if (o.via.array.size != 1) throw msgpack::type_error();
return no_def_con(o.via.array.ptr[0].as<int>());
}
};
} // adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // msgpack
TEST(UNIQUE_PTR, pack_convert_nil_no_def_con)
{
std::stringstream ss;
std::unique_ptr<no_def_con> val1(new no_def_con(1));
msgpack::pack(ss, val1);
std::string const& str = ss.str();
msgpack::object_handle oh =
msgpack::unpack(str.data(), str.size());
std::unique_ptr<no_def_con> val2 = oh.get().as<std::unique_ptr<no_def_con>>();
EXPECT_TRUE(*val1 == *val2);
}
#endif // !defined(MSGPACK_USE_CPP03)

637
test/user_class.cpp
View File

@@ -1,637 +0,0 @@
#include <msgpack.hpp>
#include <string>
#include <cmath>
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif //defined(__GNUC__)
#include <gtest/gtest.h>
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif //defined(__GNUC__)
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
using namespace std;
const unsigned int kLoop = 1000;
const unsigned int kElements = 100;
const double kEPS = 1e-10;
// User-Defined Structures
class TestEnumMemberClass
{
public:
TestEnumMemberClass()
: t1(STATE_A), t2(STATE_B), t3(STATE_C) {}
enum TestEnumType {
STATE_INVALID = 0,
STATE_A = 1,
STATE_B = 2,
STATE_C = 3
};
TestEnumType t1;
TestEnumType t2;
TestEnumType t3;
MSGPACK_DEFINE(t1, t2, t3);
};
MSGPACK_ADD_ENUM(TestEnumMemberClass::TestEnumType);
class TestClass
{
public:
TestClass() : i(0), s("kzk") {}
int i;
string s;
MSGPACK_DEFINE(i, s);
};
TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
{
for (unsigned int k = 0; k < kLoop; k++) {
TestClass val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
TestClass val2 = oh.get().as<TestClass>();
EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s);
}
}
class TestClass2
{
public:
TestClass2() : i(0), s("kzk") {
for (unsigned int i = 0; i < kElements; i++)
v.push_back(rand());
}
int i;
string s;
vector<int> v;
MSGPACK_DEFINE(i, s, v);
};
TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
{
for (unsigned int k = 0; k < kLoop; k++) {
TestClass val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
TestClass2 val2 = oh.get().as<TestClass2>();
EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(val2.s.empty());
}
}
TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
{
for (unsigned int k = 0; k < kLoop; k++) {
TestClass2 val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
TestClass val2 = oh.get().as<TestClass>();
EXPECT_EQ(val1.i, val2.i);
EXPECT_EQ(val1.s, val2.s);
EXPECT_FALSE(val2.s.empty());
}
}
TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
{
TestEnumMemberClass val1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
TestEnumMemberClass val2 = oh.get().as<TestEnumMemberClass>();
EXPECT_EQ(val1.t1, val2.t1);
EXPECT_EQ(val1.t2, val2.t2);
EXPECT_EQ(val1.t3, val2.t3);
}
class TestUnionMemberClass
{
public:
TestUnionMemberClass() {}
TestUnionMemberClass(double f) {
is_double = true;
value.f = f;
}
TestUnionMemberClass(int i) {
is_double = false;
value.i = i;
}
union {
double f;
int i;
} value;
bool is_double;
template <typename Packer>
void msgpack_pack(Packer& pk) const
{
if (is_double)
pk.pack(msgpack::type::tuple<bool, double>(true, value.f));
else
pk.pack(msgpack::type::tuple<bool, int>(false, value.i));
}
void msgpack_unpack(msgpack::object o)
{
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
msgpack::type::tuple<bool, msgpack::object> tuple(false, msgpack::object());
o.convert(tuple);
is_double = tuple.get<0>();
if (is_double)
tuple.get<1>().convert(value.f);
else
tuple.get<1>().convert(value.i);
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
}
};
TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
{
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
{
// double
TestUnionMemberClass val1(1.0);
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
TestUnionMemberClass val2 = oh.get().as<TestUnionMemberClass>();
EXPECT_EQ(val1.is_double, val2.is_double);
EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
}
{
// int
TestUnionMemberClass val1(1);
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, val1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
TestUnionMemberClass val2 = oh.get().as<TestUnionMemberClass>();
EXPECT_EQ(val1.is_double, val2.is_double);
EXPECT_EQ(val1.value.i, 1);
EXPECT_EQ(val1.value.i, val2.value.i);
}
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
}
// inheritance
// define
struct d_top {
int t;
MSGPACK_DEFINE(t);
};
struct d_mid1 : d_top {
int m1;
MSGPACK_DEFINE(MSGPACK_BASE(d_top), m1);
};
struct d_mid2 : d_top {
int m2;
MSGPACK_DEFINE(m2, MSGPACK_BASE(d_top));
};
struct d_bottom : d_mid1, d_mid2 {
int b;
MSGPACK_DEFINE(MSGPACK_BASE(d_mid1), MSGPACK_BASE(d_mid2), b);
};
TEST(MSGPACK_INHERIT, define_non_virtual)
{
d_bottom b;
b.b = 1;
b.m1 = 2;
b.m2 = 3;
b.d_mid1::t = 4;
b.d_mid2::t = 5;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
d_bottom br = oh.get().as<d_bottom>();
EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.d_mid1::t, br.d_mid1::t);
EXPECT_EQ(b.d_mid2::t, br.d_mid2::t);
}
struct v_d_top {
int t;
MSGPACK_DEFINE(t);
};
struct v_d_mid1 : virtual v_d_top {
int m1;
MSGPACK_DEFINE(m1);
};
struct v_d_mid2 : virtual v_d_top {
int m2;
MSGPACK_DEFINE(m2);
};
struct v_d_bottom : v_d_mid1, v_d_mid2 {
int b;
MSGPACK_DEFINE(MSGPACK_BASE(v_d_mid1), MSGPACK_BASE(v_d_mid2), MSGPACK_BASE(v_d_top), b);
};
TEST(MSGPACK_INHERIT, define_virtual)
{
v_d_bottom b;
b.b = 1;
b.m1 = 2;
b.m2 = 3;
b.t = 4;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
v_d_bottom br = oh.get().as<v_d_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);
}
// define_array
struct da_top {
int t;
MSGPACK_DEFINE_ARRAY(t);
};
struct da_mid1 : da_top {
int m1;
MSGPACK_DEFINE_ARRAY(MSGPACK_BASE_ARRAY(da_top), m1);
};
struct da_mid2 : da_top {
int m2;
MSGPACK_DEFINE_ARRAY(m2, MSGPACK_BASE_ARRAY(da_top));
};
struct da_bottom : da_mid1, da_mid2 {
int b;
MSGPACK_DEFINE_ARRAY(MSGPACK_BASE_ARRAY(da_mid1), MSGPACK_BASE_ARRAY(da_mid2), b);
};
TEST(MSGPACK_INHERIT, define_array_non_virtual)
{
da_bottom b;
b.b = 1;
b.m1 = 2;
b.m2 = 3;
b.da_mid1::t = 4;
b.da_mid2::t = 5;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
da_bottom br = oh.get().as<da_bottom>();
EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.da_mid1::t, br.da_mid1::t);
EXPECT_EQ(b.da_mid2::t, br.da_mid2::t);
}
struct v_da_top {
int t;
MSGPACK_DEFINE_ARRAY(t);
};
struct v_da_mid1 : virtual v_da_top {
int m1;
MSGPACK_DEFINE_ARRAY(m1);
};
struct v_da_mid2 : virtual v_da_top {
int m2;
MSGPACK_DEFINE_ARRAY(m2);
};
struct v_da_bottom : v_da_mid1, v_da_mid2 {
int b;
MSGPACK_DEFINE_ARRAY(MSGPACK_BASE_ARRAY(v_da_mid1), MSGPACK_BASE_ARRAY(v_da_mid2), MSGPACK_BASE_ARRAY(v_da_top), b);
};
TEST(MSGPACK_INHERIT, define_array_virtual)
{
v_da_bottom b;
b.b = 1;
b.m1 = 2;
b.m2 = 3;
b.t = 4;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
v_da_bottom br = oh.get().as<v_da_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);
}
// define_map
struct dm_top {
int t;
MSGPACK_DEFINE_MAP(t);
};
struct dm_mid1 : dm_top {
int m1;
MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(dm_top), m1);
};
struct dm_mid2 : dm_top {
int m2;
MSGPACK_DEFINE_MAP(m2, MSGPACK_BASE_MAP(dm_top));
};
struct dm_bottom : dm_mid1, dm_mid2 {
int b;
MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(dm_mid1), MSGPACK_BASE_MAP(dm_mid2), b);
};
TEST(MSGPACK_INHERIT, define_map_non_virtual)
{
dm_bottom b;
b.b = 1;
b.m1 = 2;
b.m2 = 3;
b.dm_mid1::t = 4;
b.dm_mid2::t = 5;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
dm_bottom br = oh.get().as<dm_bottom>();
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) && !defined(__clang__)
EXPECT_EQ(b.b, br.b);
EXPECT_EQ(b.m1, br.m1);
EXPECT_EQ(b.m2, br.m2);
EXPECT_EQ(b.dm_mid1::t, br.dm_mid1::t);
EXPECT_EQ(b.dm_mid2::t, br.dm_mid2::t);
}
struct v_dm_top {
int t;
MSGPACK_DEFINE_MAP(t);
};
struct v_dm_mid1 : virtual v_dm_top {
int m1;
MSGPACK_DEFINE_MAP(m1);
};
struct v_dm_mid2 : virtual v_dm_top {
int m2;
MSGPACK_DEFINE_MAP(m2);
};
struct v_dm_bottom : v_dm_mid1, v_dm_mid2 {
int b;
MSGPACK_DEFINE_MAP(MSGPACK_BASE_MAP(v_dm_mid1), MSGPACK_BASE_MAP(v_dm_mid2), MSGPACK_BASE_MAP(v_dm_top), b);
};
TEST(MSGPACK_INHERIT, define_map_virtual)
{
v_dm_bottom b;
b.b = 1;
b.m1 = 2;
b.m2 = 3;
b.t = 4;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, b);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
v_dm_bottom br = oh.get().as<v_dm_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);
}
// map migration
struct s_v1 {
int i;
std::string s;
s_v1():i(42), s("foo") {}
MSGPACK_DEFINE_MAP(i, s);
};
struct s_v2 {
char c; // new member variable
std::string s;
int i;
s_v2():c('A'), s("bar"), i(77) {}
MSGPACK_DEFINE_MAP(c, s, i); // variable added, order changed
};
TEST(MSGPACK_MIGRATION, order_number_changed)
{
s_v1 v1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, v1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
s_v2 v2 = oh.get().as<s_v2>();
EXPECT_EQ(v2.c, 'A');
EXPECT_EQ(v2.s, "foo"); // from v1
EXPECT_EQ(v2.i, 42); // from v1
}
// non intrusive with operator <<
class test_non_intrusive {
public:
const std::string& name() const { return m_name; }
void set_name(const std::string& name) { m_name = name; }
private:
std::string m_name;
};
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
namespace adaptor {
template<>
struct convert<test_non_intrusive>
{
msgpack::object const& operator()(
msgpack::object const& o,
test_non_intrusive& t) const {
t.set_name(o.as<std::string>());
return o;
}
};
template<>
struct pack<test_non_intrusive>
{
template <typename Stream>
msgpack::packer<Stream>& operator()(
msgpack::packer<Stream>& p,
test_non_intrusive const& t) const {
p.pack(t.name());
return p;
}
};
template <>
struct object_with_zone<test_non_intrusive>
{
void operator()(
msgpack::object::with_zone& o,
const test_non_intrusive& t) const {
o << t.name();
}
};
} // namespace adaptor
} // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
} // namespace msgpack
TEST(MSGPACK_USER_DEFINED, test_non_intrusive)
{
test_non_intrusive t1;
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, t1);
msgpack::object_handle oh =
msgpack::unpack(sbuf.data(), sbuf.size());
test_non_intrusive t2 = oh.get().as<test_non_intrusive>();
EXPECT_EQ(t1.name(), t2.name());
}
struct nvp_base {
int a;
int b;
MSGPACK_DEFINE_MAP(MSGPACK_NVP("aaa", a), b);
};
struct nvp_derived : nvp_base {
int c;
std::string d;
MSGPACK_DEFINE_MAP(MSGPACK_NVP("ccc", c), MSGPACK_NVP("base", MSGPACK_BASE(nvp_base)), MSGPACK_NVP("ddd", d));
};
TEST(MSGPACK_NVP, combination)
{
msgpack::sbuffer sbuf;
nvp_derived d1;
d1.a = 1;
d1.b = 2;
d1.c = 3;
d1.d = "ABC";
msgpack::pack(sbuf, d1);
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
msgpack::object obj = oh.get();
EXPECT_EQ(obj.via.map.size, static_cast<size_t>(3));
EXPECT_EQ(std::string(obj.via.map.ptr[0].key.via.str.ptr, obj.via.map.ptr[0].key.via.str.size), "ccc");
EXPECT_EQ(obj.via.map.ptr[0].val.via.i64, 3);
EXPECT_EQ(std::string(obj.via.map.ptr[1].key.via.str.ptr, obj.via.map.ptr[1].key.via.str.size), "base");
EXPECT_EQ(obj.via.map.ptr[1].val.via.map.size, static_cast<size_t>(2));
EXPECT_EQ(
std::string(
obj.via.map.ptr[1].val.via.map.ptr[0].key.via.str.ptr,
obj.via.map.ptr[1].val.via.map.ptr[0].key.via.str.size),
"aaa"
);
EXPECT_EQ(obj.via.map.ptr[1].val.via.map.ptr[0].val.via.i64, 1);
EXPECT_EQ(
std::string(
obj.via.map.ptr[1].val.via.map.ptr[1].key.via.str.ptr,
obj.via.map.ptr[1].val.via.map.ptr[1].key.via.str.size),
"b"
);
EXPECT_EQ(obj.via.map.ptr[1].val.via.map.ptr[1].val.via.i64, 2);
EXPECT_EQ(std::string(obj.via.map.ptr[2].key.via.str.ptr, obj.via.map.ptr[2].key.via.str.size), "ddd");
EXPECT_EQ(std::string(obj.via.map.ptr[2].val.via.str.ptr, obj.via.map.ptr[2].val.via.str.size), "ABC");
nvp_derived d2 = obj.as<nvp_derived>();
EXPECT_EQ(d2.a, 1);
EXPECT_EQ(d2.b, 2);
EXPECT_EQ(d2.c, 3);
EXPECT_EQ(d2.d, "ABC");
}
struct invalid_key {
int val;
MSGPACK_DEFINE_MAP(val);
};
TEST(MSGPACK_USER_DEFINED, test_invalid_key_type)
{
msgpack::sbuffer sbuf;
msgpack::packer<msgpack::sbuffer> pk(sbuf);
pk.pack_map(1);
pk.pack_int(42);
pk.pack_int(43);
msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
try {
oh.get().as<invalid_key>();
EXPECT_TRUE(false);
}
catch (msgpack::type_error const&) {
EXPECT_TRUE(true);
}
catch (...) {
EXPECT_TRUE(false);
}
}

24
test/version.cpp
View File

@@ -1,24 +0,0 @@
#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__)
TEST(version, print)
{
printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION);
printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR);
printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR);
printf("MSGPACK_VERSION_REVISION : %d\n", MSGPACK_VERSION_REVISION);
printf("msgpack_version() : %s\n", msgpack_version());
printf("msgpack_version_major() : %d\n", msgpack_version_major());
printf("msgpack_version_minor() : %d\n", msgpack_version_minor());
printf("msgpack_version_revision() : %d\n", msgpack_version_revision());
}

497
test/visitor.cpp
View File

@@ -1,497 +0,0 @@
#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__)
#include <sstream>
// To avoid link error
TEST(visitor, dummy)
{
}
#if MSGPACK_DEFAULT_API_VERSION >= 2
struct json_like_visitor : msgpack::null_visitor {
json_like_visitor(std::string& s):m_s(s) {}
bool visit_nil() {
m_s += "null";
return true;
}
bool visit_boolean(bool v) {
if (v) m_s += "true";
else m_s += "false";
return true;
}
bool visit_positive_integer(uint64_t v) {
std::stringstream ss;
ss << v;
m_s += ss.str();
return true;
}
bool visit_negative_integer(int64_t v) {
std::stringstream ss;
ss << v;
m_s += ss.str();
return true;
}
bool visit_str(const char* v, uint32_t size) {
// I omit escape process.
m_s += '"' + std::string(v, size) + '"';
return true;
}
bool start_array(uint32_t /*num_elements*/) {
m_s += "[";
return true;
}
bool end_array_item() {
m_s += ",";
return true;
}
bool end_array() {
m_s.erase(m_s.size() - 1, 1); // remove the last ','
m_s += "]";
return true;
}
bool start_map(uint32_t /*num_kv_pairs*/) {
m_s += "{";
return true;
}
bool end_map_key() {
m_s += ":";
return true;
}
bool end_map_value() {
m_s += ",";
return true;
}
bool end_map() {
m_s.erase(m_s.size() - 1, 1); // remove the last ','
m_s += "}";
return true;
}
void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
EXPECT_TRUE(false);
}
void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
EXPECT_TRUE(false);
}
std::string& m_s;
};
TEST(visitor, json_like)
{
std::stringstream ss;
msgpack::packer<std::stringstream> p(ss);
p.pack_map(1);
p.pack("key");
p.pack_array(3);
p.pack(42);
p.pack_nil();
p.pack(true);
std::string json_like;
json_like_visitor v(json_like);
std::size_t off = 0;
std::string const& str = ss.str();
bool ret = msgpack::parse(str.data(), str.size(), off, v);
EXPECT_TRUE(ret);
EXPECT_EQ("{\"key\":[42,null,true]}", json_like);
}
struct parse_error_check_visitor : msgpack::null_visitor {
parse_error_check_visitor(bool& called):m_called(called) {}
void parse_error(size_t parsed_offset, size_t error_offset) {
EXPECT_EQ(static_cast<size_t>(1), parsed_offset);
EXPECT_EQ(static_cast<size_t>(2), error_offset);
m_called = true;
}
bool& m_called;
};
TEST(visitor, parse_error)
{
bool called = false;
parse_error_check_visitor v(called);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, static_cast<char>(0xc1u), 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_TRUE(called);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(2u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct insuf_bytes_check_visitor : msgpack::null_visitor {
insuf_bytes_check_visitor(bool& called):m_called(called) {}
void insufficient_bytes(size_t parsed_offset, size_t error_offset) {
EXPECT_EQ(static_cast<size_t>(2), parsed_offset);
EXPECT_EQ(static_cast<size_t>(3), error_offset);
m_called = true;
}
bool& m_called;
};
TEST(visitor, insuf_bytes)
{
bool called = false;
insuf_bytes_check_visitor v(called);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x01u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_TRUE(called);
// Even if MSGPACK_DEFAULT_API_VERSION is 2, then off is updated
// in the case of insufficient bytes.
EXPECT_EQ(3u, off);
}
struct return_false_array_val_visitor : msgpack::null_visitor {
return_false_array_val_visitor(std::size_t& times):m_times(times) {}
bool visit_positive_integer(uint64_t) {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_array_val)
{
std::size_t times = 0;
return_false_array_val_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(2u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_start_array_item_visitor : msgpack::null_visitor {
return_false_start_array_item_visitor(std::size_t& times):m_times(times) {}
bool start_array_item() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_start_array_item)
{
std::size_t times = 0;
return_false_start_array_item_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(2u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_end_array_item_visitor : msgpack::null_visitor {
return_false_end_array_item_visitor(std::size_t& times):m_times(times) {}
bool end_array_item() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_end_array_item)
{
std::size_t times = 0;
return_false_end_array_item_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(2u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_start_array_visitor : msgpack::null_visitor {
bool start_array(uint32_t) {
return false;
}
};
TEST(visitor, return_false_start_array)
{
return_false_start_array_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_start_array0_visitor : msgpack::null_visitor {
bool start_array(uint32_t) {
return false;
}
};
TEST(visitor, return_false_start_array0)
{
return_false_start_array0_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x90u) };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_end_array_visitor : msgpack::null_visitor {
bool end_array() {
return false;
}
};
TEST(visitor, return_false_end_array)
{
return_false_end_array_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(3u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_end_array0_visitor : msgpack::null_visitor {
bool end_array() {
return false;
}
};
TEST(visitor, return_false_end_array0)
{
return_false_end_array0_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x90u) };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_map_val_visitor : msgpack::null_visitor {
return_false_map_val_visitor(std::size_t& times):m_times(times) {}
bool visit_positive_integer(uint64_t) {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_map_val)
{
std::size_t times = 0;
return_false_map_val_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(2u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_start_map_key_visitor : msgpack::null_visitor {
return_false_start_map_key_visitor(std::size_t& times):m_times(times) {}
bool start_map_key() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_start_map_key)
{
std::size_t times = 0;
return_false_start_map_key_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(3u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_end_map_key_visitor : msgpack::null_visitor {
return_false_end_map_key_visitor(std::size_t& times):m_times(times) {}
bool end_map_key() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_end_map_key)
{
std::size_t times = 0;
return_false_end_map_key_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(3u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_start_map_value_visitor : msgpack::null_visitor {
return_false_start_map_value_visitor(std::size_t& times):m_times(times) {}
bool start_map_value() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_start_map_value)
{
std::size_t times = 0;
return_false_start_map_value_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(4u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_end_map_value_visitor : msgpack::null_visitor {
return_false_end_map_value_visitor(std::size_t& times):m_times(times) {}
bool end_map_value() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_end_map_value)
{
std::size_t times = 0;
return_false_end_map_value_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(4u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_start_map_visitor : msgpack::null_visitor {
bool start_map(uint32_t) {
return false;
}
};
TEST(visitor, return_false_start_map)
{
return_false_start_map_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_start_map0_visitor : msgpack::null_visitor {
bool start_map(uint32_t) {
return false;
}
};
TEST(visitor, return_false_start_map0)
{
return_false_start_map0_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x80u) };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_end_map_visitor : msgpack::null_visitor {
bool end_map() {
return false;
}
};
TEST(visitor, return_false_end_map)
{
return_false_end_map_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
#if MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(0u, off);
#else // MSGPACK_DEFAULT_API_VERSION < 3
EXPECT_EQ(6u, off);
#endif // MSGPACK_DEFAULT_API_VERSION < 3
}
struct return_false_end_map0_visitor : msgpack::null_visitor {
bool end_map() {
return false;
}
};
TEST(visitor, return_false_end_map0)
{
return_false_end_map0_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x80u) };
bool ret = msgpack::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
#endif // MSGPACK_DEFAULT_API_VERSION >= 1

103
test/zone.cpp
View File

@@ -1,103 +0,0 @@
#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__)
TEST(zone, allocate_align)
{
msgpack::zone z;
char* start = (char*)z.allocate_align(1);
EXPECT_EQ(0ul, reinterpret_cast<std::size_t>(start) % sizeof(int));
for (std::size_t s = 1; s < sizeof(int); ++s) {
z.allocate_no_align(s);
char* buf_a = (char*)z.allocate_align(1);
EXPECT_EQ(0ul, reinterpret_cast<std::size_t>(buf_a) % sizeof(int));
}
}
TEST(zone, allocate_align_custom)
{
msgpack::zone z;
for (std::size_t align = 1; align < 64; ++align) {
char* start = (char*)z.allocate_align(1, align);
EXPECT_EQ(0ul, reinterpret_cast<std::size_t>(start) % align);
for (std::size_t s = 1; s < align; ++s) {
z.allocate_no_align(s);
char* buf_a = (char*)z.allocate_align(1, align);
EXPECT_EQ(0ul, reinterpret_cast<std::size_t>(buf_a) % align);
}
}
}
class myclass {
public:
myclass() : num(0), str("default") { }
myclass(int num, const std::string& str) :
num(num), str(str) { }
~myclass() { }
int num;
std::string str;
private:
myclass(const myclass&);
};
TEST(zone, allocate)
{
msgpack::zone z;
myclass* m = z.allocate<myclass>();
EXPECT_EQ(m->num, 0);
EXPECT_EQ(m->str, "default");
}
TEST(zone, allocate_constructor)
{
msgpack::zone z;
myclass* m = z.allocate<myclass>(7, "msgpack");
EXPECT_EQ(m->num, 7);
EXPECT_EQ(m->str, "msgpack");
}
static void custom_finalizer_func(void* user)
{
myclass* m = (myclass*)user;
delete m;
}
TEST(zone, push_finalizer)
{
msgpack::zone z;
myclass* m = new myclass();
z.push_finalizer(custom_finalizer_func, (void*)m);
}
TEST(zone, push_finalizer_unique_ptr)
{
msgpack::zone z;
msgpack::unique_ptr<myclass> am(new myclass());
z.push_finalizer(msgpack::move(am));
}
TEST(zone, allocate_no_align)
{
msgpack::zone z;
char* buf1 = (char*)z.allocate_no_align(4);
char* buf2 = (char*)z.allocate_no_align(4);
EXPECT_EQ(buf1+4, buf2);
}