RPCS3/cereal
1
0
Fork 0
mirror of https://github.com/RPCS3/cereal.git synced 2025-02-25 18:24:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Unit tests for std::tuple, fixed tuple serialization

Browse Source 
Boost check for tuple serialization check could be made better, pair probably the same as well.  boost doesn't like
pairs or tuples in BOOST_CHECK_EQUAL
This commit is contained in:
Shane Grant 2013-06-15 22:54:03 -07:00
parent d4f7c4b1e1
commit adcc2532db
2 changed files with 77 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
binary_archive/tuple.hpp
View File

@ -10,17 +10,25 @@ namespace cereal
namespace tuple_detail namespace tuple_detail
{ {
// unwinds a tuple to save it // unwinds a tuple to save it
template <size_t Height, class Archive, class ... Types> inline template <size_t Height>
void serialize( Archive & ar, std::tuple<Types...> & tuple ) struct serialize
{ {
ar & std::get<Height - 1>( tuple ); template <class Archive, class ... Types> inline
serialize<Height - 1>( ar, tuple ); static void apply( Archive & ar, std::tuple<Types...> & tuple )
} {
ar & std::get<Height - 1>( tuple );
serialize<Height - 1>::template apply( ar, tuple );
}
};
// Zero height specialization - nothing to do here // Zero height specialization - nothing to do here
template <class Archive, class ... Types> inline template <>
void serialize<0, Types...>( Archive & ar, std::tuple<Types...> & tuple ) struct serialize<0>
{ } {
template <class Archive, class ... Types> inline
static void apply( Archive & ar, std::tuple<Types...> & tuple )
{ }
};
} }
//! Serializing for std::tuple to binary //! Serializing for std::tuple to binary
@ -28,7 +36,7 @@ namespace cereal
CEREAL_ARCHIVE_RESTRICT_SERIALIZE(BinaryInputArchive, BinaryOutputArchive) CEREAL_ARCHIVE_RESTRICT_SERIALIZE(BinaryInputArchive, BinaryOutputArchive)
serialize( Archive & ar, std::tuple<Types...> & tuple ) serialize( Archive & ar, std::tuple<Types...> & tuple )
{ {
tuple_size::serialize<std::tuple_size<std::tuple<Types...>>>( ar, tuple ); tuple_detail::serialize<std::tuple_size<std::tuple<Types...>>::value>::template apply( ar, tuple );
} }
} // namespace cereal } // namespace cereal

60
unittests.cpp
View File

@ -13,6 +13,7 @@
#include <cereal/binary_archive/unordered_map.hpp> #include <cereal/binary_archive/unordered_map.hpp>
#include <cereal/binary_archive/unordered_set.hpp> #include <cereal/binary_archive/unordered_set.hpp>
#include <cereal/binary_archive/utility.hpp> #include <cereal/binary_archive/utility.hpp>
#include <cereal/binary_archive/tuple.hpp>
#include <limits> #include <limits>
#include <random> #include <random>
@ -1607,3 +1608,62 @@ BOOST_AUTO_TEST_CASE( binary_pair )
} }
} }
// ######################################################################
BOOST_AUTO_TEST_CASE( binary_tuple )
{
std::random_device rd;
std::mt19937 gen(rd());
auto rng = [&](){ return random_value<int>(gen); };
for(int i=0; i<100; ++i)
{
std::ostringstream os;
cereal::BinaryOutputArchive oar(os);
auto o_podtuple = std::make_tuple( rng(), rng(), rng(), rng() );
auto o_isertuple = std::make_tuple( StructInternalSerialize( rng(), rng() ),
StructInternalSerialize( rng(), rng() ),
StructInternalSerialize( rng(), rng() ),
StructInternalSerialize( rng(), rng() ) );
auto o_ispltuple = std::make_tuple( StructInternalSplit( rng(), rng() ),
StructInternalSplit( rng(), rng() ),
StructInternalSplit( rng(), rng() ),
StructInternalSplit( rng(), rng() ) );
auto o_esertuple = std::make_tuple( StructExternalSerialize( rng(), rng() ),
StructExternalSerialize( rng(), rng() ),
StructExternalSerialize( rng(), rng() ),
StructExternalSerialize( rng(), rng() ) );
auto o_espltuple = std::make_tuple( StructExternalSerialize( rng(), rng() ),
StructExternalSerialize( rng(), rng() ),
StructExternalSerialize( rng(), rng() ),
StructExternalSerialize( rng(), rng() ) );
oar & o_podtuple;
oar & o_isertuple;
oar & o_ispltuple;
oar & o_esertuple;
oar & o_espltuple;
std::istringstream is(os.str());
cereal::BinaryInputArchive iar(is);
decltype( o_podtuple ) i_podtuple;
decltype( o_isertuple ) i_isertuple;
decltype( o_ispltuple ) i_ispltuple;
decltype( o_esertuple ) i_esertuple;
decltype( o_espltuple ) i_espltuple;
iar & i_podtuple;
iar & i_isertuple;
iar & i_ispltuple;
iar & i_esertuple;
iar & i_espltuple;
BOOST_CHECK_EQUAL( i_podtuple == o_podtuple, true );
BOOST_CHECK_EQUAL( i_isertuple == o_isertuple, true );
BOOST_CHECK_EQUAL( i_ispltuple == o_ispltuple, true );
BOOST_CHECK_EQUAL( i_esertuple == o_esertuple, true );
BOOST_CHECK_EQUAL( i_espltuple == o_espltuple, true );
}
}