mirror of
https://github.com/USCiLab/cereal.git
synced 2025-08-09 08:55:29 +02:00
Switching to CMake and splitting unittests
This commit is contained in:
Randolph Voorhies
Shane Grant
parent
94cb6d3ba8
commit
ba2ca7c94d
2
.gitignore
vendored
2
.gitignore
vendored
@ -27,7 +27,6 @@
|
||||
out.txt
|
||||
ptr.txt
|
||||
test.txt
|
||||
unittests
|
||||
boost_serialize
|
||||
arr.txt
|
||||
performance
|
||||
@ -45,3 +44,4 @@ file.json
|
||||
out.xml
|
||||
cereal_version.out
|
||||
xml_ordering.out
|
||||
build
|
||||
|
||||
22
CMakeLists.txt
Normal file
22
CMakeLists.txt
Normal file
@ -0,0 +1,22 @@
|
||||
cmake_minimum_required (VERSION 2.6.2)
|
||||
project (cereal)
|
||||
|
||||
set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Werror -g -Wextra -Wshadow -pedantic ${CMAKE_CXX_FLAGS}")
|
||||
|
||||
include_directories(./include)
|
||||
|
||||
add_executable(sandbox sandbox.cpp)
|
||||
add_executable(sandbox_json sandbox_json.cpp)
|
||||
add_executable(sandbox_rtti sandbox_rtti.cpp)
|
||||
add_executable(sandbox_vs sandbox_vs.cpp)
|
||||
add_executable(portability_test portability_test.cpp)
|
||||
|
||||
find_package(Boost COMPONENTS serialization unit_test_framework)
|
||||
if(Boost_FOUND)
|
||||
add_executable(performance performance.cpp)
|
||||
target_link_libraries(performance ${Boost_LIBRARIES})
|
||||
|
||||
enable_testing()
|
||||
add_subdirectory(unittests)
|
||||
|
||||
endif(Boost_FOUND)
|
||||
7
Makefile
7
Makefile
@ -16,9 +16,10 @@ sandbox_rtti: sandbox_rtti.cpp
|
||||
sandbox_vs: sandbox_vs.cpp
|
||||
${CXX} sandbox_vs.cpp -o sandbox_vs ${CPPFLAGS}
|
||||
|
||||
unittests: unittests.cpp
|
||||
${CXX} unittests.cpp -o unittests -lboost_unit_test_framework ${CPPFLAGS}
|
||||
./unittests --show_progress
|
||||
unittests: unittests/*.cpp
|
||||
#${CXX} unittests/pod.cpp -o unittests_bin/pod -lboost_unit_test_framework ${CPPFLAGS}
|
||||
#${CXX} unittests.cpp -o unittests -lboost_unit_test_framework ${CPPFLAGS}
|
||||
#./unittests --show_progress
|
||||
|
||||
performance: performance.cpp
|
||||
${CXX} performance.cpp -o performance -lboost_serialization ${CPPFLAGS} -O3
|
||||
|
||||
@ -203,6 +203,7 @@ namespace cereal
|
||||
// When loading we don't need to do this specialization since we catch the types with
|
||||
// templates according to their size
|
||||
|
||||
private:
|
||||
//! 32 bit long saving to current node
|
||||
template <class T> inline
|
||||
typename std::enable_if<sizeof(T) == sizeof(std::uint32_t), void>::type
|
||||
@ -213,9 +214,19 @@ namespace cereal
|
||||
typename std::enable_if<sizeof(T) != sizeof(std::uint32_t), void>::type
|
||||
saveLong(T lu){ saveValue( static_cast<std::uint64_t>( lu ) ); }
|
||||
|
||||
public:
|
||||
//! MSVC only long overload to current node
|
||||
void saveValue( unsigned long lu ){ saveLong( lu ); };
|
||||
#endif
|
||||
#else // _MSC_VER
|
||||
//! Saves a long on a 32 bit system
|
||||
template <class T> inline
|
||||
typename std::enable_if<std::is_same<T, long>::value && sizeof(T) == 4, void>::type
|
||||
saveValue(T t){ saveValue( static_cast<std::int32_t>( t ) ); }
|
||||
//! Saves an unsigned long on a 32 bit system
|
||||
template <class T> inline
|
||||
typename std::enable_if<std::is_same<T, unsigned long>::value && sizeof(T) == 4, void>::type
|
||||
saveValue(T t){ saveValue( static_cast<std::uint32_t>( t ) ); }
|
||||
#endif // _MSC_VER
|
||||
|
||||
//! Save exotic arithmetic types as binary to current node
|
||||
template<class T> inline
|
||||
|
||||
3678
unittests.cpp
3678
unittests.cpp
File diff suppressed because it is too large
Load Diff
13
unittests/CMakeLists.txt
Normal file
13
unittests/CMakeLists.txt
Normal file
@ -0,0 +1,13 @@
|
||||
file(GLOB TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
|
||||
|
||||
foreach(TEST_SOURCE ${TESTS})
|
||||
|
||||
string(REPLACE ".cpp" "" TEST_TARGET "${TEST_SOURCE}")
|
||||
set(TEST_TARGET "test_${TEST_TARGET}")
|
||||
|
||||
add_executable(${TEST_TARGET} ${TEST_SOURCE})
|
||||
set_target_properties(${TEST_TARGET} PROPERTIES COMPILE_DEFINITIONS "BOOST_TEST_DYN_LINK;BOOST_TEST_MODULE=${TEST_TARGET}")
|
||||
target_link_libraries(${TEST_TARGET} ${Boost_LIBRARIES})
|
||||
add_test("${TEST_TARGET}" "${TEST_TARGET}")
|
||||
|
||||
endforeach()
|
||||
86
unittests/array.cpp
Normal file
86
unittests/array.cpp
Normal file
@ -0,0 +1,86 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_array()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::array<int, 100> o_podarray;
|
||||
for(auto & elem : o_podarray)
|
||||
elem = random_value<int>(gen);
|
||||
|
||||
std::array<StructInternalSerialize, 100> o_iserarray;
|
||||
for(auto & elem : o_iserarray)
|
||||
elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::array<StructInternalSplit, 100> o_isplarray;
|
||||
for(auto & elem : o_isplarray)
|
||||
elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::array<StructExternalSerialize, 100> o_eserarray;
|
||||
for(auto & elem : o_eserarray)
|
||||
elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::array<StructExternalSplit, 100> o_esplarray;
|
||||
for(auto & elem : o_esplarray)
|
||||
elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podarray);
|
||||
oar(o_iserarray);
|
||||
oar(o_isplarray);
|
||||
oar(o_eserarray);
|
||||
oar(o_esplarray);
|
||||
}
|
||||
|
||||
std::array<int, 100> i_podarray;
|
||||
std::array<StructInternalSerialize, 100> i_iserarray;
|
||||
std::array<StructInternalSplit, 100> i_isplarray;
|
||||
std::array<StructExternalSerialize, 100> i_eserarray;
|
||||
std::array<StructExternalSplit, 100> i_esplarray;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podarray);
|
||||
iar(i_iserarray);
|
||||
iar(i_isplarray);
|
||||
iar(i_eserarray);
|
||||
iar(i_esplarray);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_podarray.begin(), i_podarray.end(), o_podarray.begin(), o_podarray.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_iserarray.begin(), i_iserarray.end(), o_iserarray.begin(), o_iserarray.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_isplarray.begin(), i_isplarray.end(), o_isplarray.begin(), o_isplarray.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_eserarray.begin(), i_eserarray.end(), o_eserarray.begin(), o_eserarray.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_esplarray.begin(), i_esplarray.end(), o_esplarray.begin(), o_esplarray.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_array )
|
||||
{
|
||||
test_array<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_array )
|
||||
{
|
||||
test_array<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_array )
|
||||
{
|
||||
test_array<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_array )
|
||||
{
|
||||
test_array<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
100
unittests/basic_string.cpp
Normal file
100
unittests/basic_string.cpp
Normal file
@ -0,0 +1,100 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_string_basic()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(size_t i=0; i<100; ++i)
|
||||
{
|
||||
std::basic_string<char> o_string = random_basic_string<char>(gen);
|
||||
std::basic_string<char> o_string2 = "";
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
oar(o_string);
|
||||
oar(o_string2);
|
||||
}
|
||||
|
||||
std::basic_string<char> i_string;
|
||||
std::basic_string<char> i_string2;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_string);
|
||||
iar(i_string2);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(i_string, o_string);
|
||||
BOOST_CHECK_EQUAL(i_string2, o_string2);
|
||||
}
|
||||
}
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_string_all()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(size_t i=0; i<100; ++i)
|
||||
{
|
||||
std::basic_string<char> o_string = random_basic_string<char>(gen);
|
||||
std::basic_string<wchar_t> o_wstring = random_basic_string<wchar_t>(gen);
|
||||
std::basic_string<char16_t> o_u16string = random_basic_string<char16_t>(gen);
|
||||
std::basic_string<char32_t> o_u32string = random_basic_string<char32_t>(gen);
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
oar(o_string);
|
||||
oar(o_wstring);
|
||||
oar(o_u16string);
|
||||
oar(o_u32string);
|
||||
}
|
||||
|
||||
std::basic_string<char> i_string;
|
||||
std::basic_string<wchar_t> i_wstring;
|
||||
std::basic_string<char16_t> i_u16string;
|
||||
std::basic_string<char32_t> i_u32string;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_string);
|
||||
iar(i_wstring);
|
||||
iar(i_u16string);
|
||||
iar(i_u32string);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(i_string, o_string);
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_wstring.begin(), i_wstring.end(), o_wstring.begin(), o_wstring.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_u16string.begin(), i_u16string.end(), o_u16string.begin(), o_u16string.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_u32string.begin(), i_u32string.end(), o_u32string.begin(), o_u32string.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_string )
|
||||
{
|
||||
test_string_all<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_string )
|
||||
{
|
||||
test_string_all<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_string_basic )
|
||||
{
|
||||
test_string_basic<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_string_basic )
|
||||
{
|
||||
test_string_basic<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
67
unittests/bitset.cpp
Normal file
67
unittests/bitset.cpp
Normal file
@ -0,0 +1,67 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_bitset()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
auto rng32 = [&](){ return random_binary_string<32>( gen ); };
|
||||
auto rng65 = [&](){ return random_binary_string<65>( gen ); };
|
||||
auto rng256 = [&](){ return random_binary_string<256>( gen ); };
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::bitset<32> o_bit32( rng32() );
|
||||
std::bitset<65> o_bit65( rng65() );
|
||||
std::bitset<256> o_bit256( rng256() );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_bit32);
|
||||
oar(o_bit65);
|
||||
oar(o_bit256);
|
||||
}
|
||||
|
||||
std::bitset<32> i_bit32;
|
||||
std::bitset<65> i_bit65;
|
||||
std::bitset<256> i_bit256;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_bit32);
|
||||
iar(i_bit65);
|
||||
iar(i_bit256);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL( o_bit32, i_bit32 );
|
||||
BOOST_CHECK_EQUAL( o_bit65, i_bit65 );
|
||||
BOOST_CHECK_EQUAL( o_bit256, i_bit256 );
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_bitset )
|
||||
{
|
||||
test_bitset<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_bitset )
|
||||
{
|
||||
test_bitset<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_bitset )
|
||||
{
|
||||
test_bitset<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_bitset )
|
||||
{
|
||||
test_bitset<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
|
||||
96
unittests/chrono.cpp
Normal file
96
unittests/chrono.cpp
Normal file
@ -0,0 +1,96 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_chrono()
|
||||
{
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
auto o_timePoint1 = std::chrono::system_clock::now();
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
auto o_timePoint2 = std::chrono::steady_clock::now();
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
auto o_timePoint3 = std::chrono::high_resolution_clock::now();
|
||||
|
||||
auto o_duration1 = std::chrono::system_clock::now() - o_timePoint1;
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
auto o_duration2 = std::chrono::steady_clock::now() - o_timePoint2;
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
auto o_duration3 = std::chrono::high_resolution_clock::now() - o_timePoint3;
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_timePoint1);
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
oar(o_timePoint2);
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
oar(o_timePoint3);
|
||||
oar(o_duration1);
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
oar(o_duration2);
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
oar(o_duration3);
|
||||
}
|
||||
|
||||
decltype(o_timePoint1) i_timePoint1;
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
decltype(o_timePoint2) i_timePoint2;
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
decltype(o_timePoint3) i_timePoint3;
|
||||
decltype(o_duration1) i_duration1;
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
decltype(o_duration2) i_duration2;
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
decltype(o_duration3) i_duration3;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_timePoint1);
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
iar(i_timePoint2);
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
iar(i_timePoint3);
|
||||
iar(i_duration1);
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
iar(i_duration2);
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
iar(i_duration3);
|
||||
}
|
||||
|
||||
BOOST_CHECK( o_timePoint1 == i_timePoint1 );
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
BOOST_CHECK( o_timePoint2 == i_timePoint2 );
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
BOOST_CHECK( o_timePoint3 == i_timePoint3 );
|
||||
BOOST_CHECK( o_duration1 == i_duration1 );
|
||||
#ifndef CEREAL_OLDER_GCC
|
||||
BOOST_CHECK( o_duration2 == i_duration2 );
|
||||
#endif // CEREAL_OLDER_GCC
|
||||
BOOST_CHECK( o_duration3 == i_duration3 );
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_chrono )
|
||||
{
|
||||
test_chrono<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_chrono )
|
||||
{
|
||||
test_chrono<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_chrono )
|
||||
{
|
||||
test_chrono<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_chrono )
|
||||
{
|
||||
test_chrono<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
|
||||
208
unittests/common.hpp
Normal file
208
unittests/common.hpp
Normal file
@ -0,0 +1,208 @@
|
||||
/*
|
||||
Copyright (c) 2013, Randolph Voorhies, Shane Grant
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of cereal nor the
|
||||
names of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES AND SHANE GRANT BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include <cereal/types/memory.hpp>
|
||||
#include <cereal/types/array.hpp>
|
||||
#include <cereal/types/vector.hpp>
|
||||
#include <cereal/types/deque.hpp>
|
||||
#include <cereal/types/forward_list.hpp>
|
||||
#include <cereal/types/list.hpp>
|
||||
#include <cereal/types/string.hpp>
|
||||
#include <cereal/types/map.hpp>
|
||||
#include <cereal/types/queue.hpp>
|
||||
#include <cereal/types/set.hpp>
|
||||
#include <cereal/types/stack.hpp>
|
||||
#include <cereal/types/unordered_map.hpp>
|
||||
#include <cereal/types/unordered_set.hpp>
|
||||
#include <cereal/types/utility.hpp>
|
||||
#include <cereal/types/tuple.hpp>
|
||||
#include <cereal/types/bitset.hpp>
|
||||
#include <cereal/types/complex.hpp>
|
||||
#include <cereal/types/chrono.hpp>
|
||||
#include <cereal/types/polymorphic.hpp>
|
||||
|
||||
#include <cereal/archives/binary.hpp>
|
||||
#include <cereal/archives/portable_binary.hpp>
|
||||
#include <cereal/archives/xml.hpp>
|
||||
#include <cereal/archives/json.hpp>
|
||||
#include <limits>
|
||||
#include <random>
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
template<class F, class S>
|
||||
::std::ostream & operator<<(::std::ostream & os, ::std::pair<F, S> const & p)
|
||||
{
|
||||
os << "([" << p.first << "], [" << p.second << "])";
|
||||
return os;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
namespace cereal
|
||||
{
|
||||
template <class Archive, class T>
|
||||
void serialize( Archive &, std::less<T> & )
|
||||
{ }
|
||||
}
|
||||
|
||||
template<class T>
|
||||
typename std::enable_if<std::is_floating_point<T>::value, T>::type
|
||||
random_value(std::mt19937 & gen)
|
||||
{ return std::uniform_real_distribution<T>(-10000.0, 10000.0)(gen); }
|
||||
|
||||
template<class T>
|
||||
typename std::enable_if<std::is_integral<T>::value && sizeof(T) != sizeof(char), T>::type
|
||||
random_value(std::mt19937 & gen)
|
||||
{ return std::uniform_int_distribution<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max())(gen); }
|
||||
|
||||
template<class T>
|
||||
typename std::enable_if<std::is_integral<T>::value && sizeof(T) == sizeof(char), T>::type
|
||||
random_value(std::mt19937 & gen)
|
||||
{ return static_cast<T>( std::uniform_int_distribution<int64_t>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max())(gen) ); }
|
||||
|
||||
template<class T>
|
||||
typename std::enable_if<std::is_same<T, std::string>::value, std::string>::type
|
||||
random_value(std::mt19937 & gen)
|
||||
{
|
||||
std::string s(std::uniform_int_distribution<int>(3, 30)(gen), ' ');
|
||||
for(char & c : s)
|
||||
c = static_cast<char>( std::uniform_int_distribution<int>( 'A', 'Z' )(gen) );
|
||||
return s;
|
||||
}
|
||||
|
||||
template<class C>
|
||||
std::basic_string<C> random_basic_string(std::mt19937 & gen)
|
||||
{
|
||||
std::basic_string<C> s(std::uniform_int_distribution<int>(3, 30)(gen), ' ');
|
||||
for(C & c : s)
|
||||
c = static_cast<C>( std::uniform_int_distribution<int>( 'A', 'Z' )(gen) );
|
||||
return s;
|
||||
}
|
||||
|
||||
template <size_t N>
|
||||
std::string random_binary_string(std::mt19937 & gen)
|
||||
{
|
||||
std::string s(N, ' ');
|
||||
for(auto & c : s )
|
||||
c = static_cast<char>( std::uniform_int_distribution<int>( '0', '1' )(gen) );
|
||||
return s;
|
||||
}
|
||||
|
||||
struct StructBase
|
||||
{
|
||||
StructBase() {}
|
||||
StructBase( int xx, int yy ) : x( xx ), y( yy ) {}
|
||||
int x, y;
|
||||
bool operator==(StructBase const & other) const
|
||||
{ return x == other.x && y == other.y; }
|
||||
bool operator!=(StructBase const & other) const
|
||||
{ return x != other.x || y != other.y; }
|
||||
bool operator<(StructBase const & other) const
|
||||
{
|
||||
if (x < other.x) return true;
|
||||
else if(other.x < x) return false;
|
||||
else return (y < other.y);
|
||||
}
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, StructBase const & s)
|
||||
{
|
||||
os << "[x: " << s.x << " y: " << s.y << "]";
|
||||
return os;
|
||||
}
|
||||
|
||||
struct StructInternalSerialize : StructBase
|
||||
{
|
||||
StructInternalSerialize() : StructBase{0,0} {}
|
||||
StructInternalSerialize(int x_, int y_) : StructBase{x_,y_} {}
|
||||
template<class Archive>
|
||||
void serialize(Archive & ar)
|
||||
{
|
||||
ar(x, y);
|
||||
}
|
||||
};
|
||||
|
||||
struct StructInternalSplit : StructBase
|
||||
{
|
||||
StructInternalSplit() : StructBase{0,0} {}
|
||||
StructInternalSplit(int x_, int y_) : StructBase{x_,y_} {}
|
||||
template<class Archive>
|
||||
void save(Archive & ar) const
|
||||
{
|
||||
ar(x, y);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void load(Archive & ar)
|
||||
{
|
||||
ar(x, y);
|
||||
}
|
||||
};
|
||||
|
||||
struct StructExternalSerialize : StructBase
|
||||
{
|
||||
StructExternalSerialize() : StructBase{0,0} {}
|
||||
StructExternalSerialize(int x_, int y_) : StructBase{x_,y_} {}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
void serialize(Archive & ar, StructExternalSerialize & s)
|
||||
{
|
||||
ar(s.x, s.y);
|
||||
}
|
||||
|
||||
struct StructExternalSplit : StructBase
|
||||
{
|
||||
StructExternalSplit() : StructBase{0,0} {}
|
||||
StructExternalSplit(int x_, int y_) : StructBase{x_,y_} {}
|
||||
};
|
||||
|
||||
template<class Archive>
|
||||
void save(Archive & ar, StructExternalSplit const & s)
|
||||
{
|
||||
ar(s.x, s.y);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void load(Archive & ar, StructExternalSplit & s)
|
||||
{
|
||||
ar(s.x, s.y);
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
struct StructHash {
|
||||
public:
|
||||
size_t operator()(const T & s) const
|
||||
{
|
||||
size_t h1 = std::hash<int>()(s.x);
|
||||
size_t h2 = std::hash<int>()(s.y);
|
||||
return h1 ^ ( h2 << 1 );
|
||||
}
|
||||
};
|
||||
69
unittests/complex.cpp
Normal file
69
unittests/complex.cpp
Normal file
@ -0,0 +1,69 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_complex()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
auto rngF = [&](){ return random_value<float>(gen); };
|
||||
auto rngD = [&](){ return random_value<double>(gen); };
|
||||
auto rngLD = [&](){ return random_value<long double>(gen); };
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::complex<float> o_float( rngF(), rngF() );
|
||||
std::complex<double> o_double( rngD(), rngD() );
|
||||
std::complex<long double> o_ldouble( rngLD(), rngLD() );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_float);
|
||||
oar(o_double);
|
||||
oar(o_ldouble);
|
||||
}
|
||||
|
||||
std::complex<float> i_float;
|
||||
std::complex<double> i_double;
|
||||
std::complex<long double> i_ldouble;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_float);
|
||||
iar(i_double);
|
||||
iar(i_ldouble);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL( o_float, i_float );
|
||||
BOOST_CHECK_CLOSE( o_double.real(), i_double.real(), 1e-5);
|
||||
BOOST_CHECK_CLOSE( o_double.imag(), i_double.imag(), 1e-5);
|
||||
BOOST_CHECK_CLOSE( o_ldouble.real(), i_ldouble.real(), 1e-5);
|
||||
BOOST_CHECK_CLOSE( o_ldouble.imag(), i_ldouble.imag(), 1e-5);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_complex )
|
||||
{
|
||||
test_complex<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_complex )
|
||||
{
|
||||
test_complex<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_complex )
|
||||
{
|
||||
test_complex<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_complex )
|
||||
{
|
||||
test_complex<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
|
||||
91
unittests/deque.cpp
Normal file
91
unittests/deque.cpp
Normal file
@ -0,0 +1,91 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_deque()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::deque<int> o_poddeque(100);
|
||||
for(auto & elem : o_poddeque)
|
||||
elem = random_value<int>(gen);
|
||||
|
||||
std::deque<StructInternalSerialize> o_iserdeque(100);
|
||||
for(auto & elem : o_iserdeque)
|
||||
elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::deque<StructInternalSplit> o_ispldeque(100);
|
||||
for(auto & elem : o_ispldeque)
|
||||
elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::deque<StructExternalSerialize> o_eserdeque(100);
|
||||
for(auto & elem : o_eserdeque)
|
||||
elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::deque<StructExternalSplit> o_espldeque(100);
|
||||
for(auto & elem : o_espldeque)
|
||||
elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_poddeque);
|
||||
oar(o_iserdeque);
|
||||
oar(o_ispldeque);
|
||||
oar(o_eserdeque);
|
||||
oar(o_espldeque);
|
||||
}
|
||||
|
||||
std::deque<int> i_poddeque;
|
||||
std::deque<StructInternalSerialize> i_iserdeque;
|
||||
std::deque<StructInternalSplit> i_ispldeque;
|
||||
std::deque<StructExternalSerialize> i_eserdeque;
|
||||
std::deque<StructExternalSplit> i_espldeque;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_poddeque);
|
||||
iar(i_iserdeque);
|
||||
iar(i_ispldeque);
|
||||
iar(i_eserdeque);
|
||||
iar(i_espldeque);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(i_poddeque.size(), o_poddeque.size());
|
||||
BOOST_CHECK_EQUAL(i_iserdeque.size(), o_iserdeque.size());
|
||||
BOOST_CHECK_EQUAL(i_ispldeque.size(), o_ispldeque.size());
|
||||
BOOST_CHECK_EQUAL(i_eserdeque.size(), o_eserdeque.size());
|
||||
BOOST_CHECK_EQUAL(i_espldeque.size(), o_espldeque.size());
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_poddeque.begin(), i_poddeque.end(), o_poddeque.begin(), o_poddeque.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_iserdeque.begin(), i_iserdeque.end(), o_iserdeque.begin(), o_iserdeque.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_ispldeque.begin(), i_ispldeque.end(), o_ispldeque.begin(), o_ispldeque.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_eserdeque.begin(), i_eserdeque.end(), o_eserdeque.begin(), o_eserdeque.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_espldeque.begin(), i_espldeque.end(), o_espldeque.begin(), o_espldeque.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_dequeue )
|
||||
{
|
||||
test_deque<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_dequeue )
|
||||
{
|
||||
test_deque<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_dequeue )
|
||||
{
|
||||
test_deque<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_dequeue )
|
||||
{
|
||||
test_deque<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
85
unittests/forward_list.cpp
Normal file
85
unittests/forward_list.cpp
Normal file
@ -0,0 +1,85 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_forward_list()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::forward_list<int> o_podforward_list(100);
|
||||
for(auto & elem : o_podforward_list)
|
||||
elem = random_value<int>(gen);
|
||||
|
||||
std::forward_list<StructInternalSerialize> o_iserforward_list(100);
|
||||
for(auto & elem : o_iserforward_list)
|
||||
elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::forward_list<StructInternalSplit> o_isplforward_list(100);
|
||||
for(auto & elem : o_isplforward_list)
|
||||
elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::forward_list<StructExternalSerialize> o_eserforward_list(100);
|
||||
for(auto & elem : o_eserforward_list)
|
||||
elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::forward_list<StructExternalSplit> o_esplforward_list(100);
|
||||
for(auto & elem : o_esplforward_list)
|
||||
elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podforward_list);
|
||||
oar(o_iserforward_list);
|
||||
oar(o_isplforward_list);
|
||||
oar(o_eserforward_list);
|
||||
oar(o_esplforward_list);
|
||||
}
|
||||
|
||||
std::forward_list<int> i_podforward_list;
|
||||
std::forward_list<StructInternalSerialize> i_iserforward_list;
|
||||
std::forward_list<StructInternalSplit> i_isplforward_list;
|
||||
std::forward_list<StructExternalSerialize> i_eserforward_list;
|
||||
std::forward_list<StructExternalSplit> i_esplforward_list;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podforward_list);
|
||||
iar(i_iserforward_list);
|
||||
iar(i_isplforward_list);
|
||||
iar(i_eserforward_list);
|
||||
iar(i_esplforward_list);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_podforward_list.begin(), i_podforward_list.end(), o_podforward_list.begin(), o_podforward_list.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_iserforward_list.begin(), i_iserforward_list.end(), o_iserforward_list.begin(), o_iserforward_list.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_isplforward_list.begin(), i_isplforward_list.end(), o_isplforward_list.begin(), o_isplforward_list.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_eserforward_list.begin(), i_eserforward_list.end(), o_eserforward_list.begin(), o_eserforward_list.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_esplforward_list.begin(), i_esplforward_list.end(), o_esplforward_list.begin(), o_esplforward_list.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_forward_list )
|
||||
{
|
||||
test_forward_list<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_forward_list )
|
||||
{
|
||||
test_forward_list<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_forward_list )
|
||||
{
|
||||
test_forward_list<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_forward_list )
|
||||
{
|
||||
test_forward_list<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
86
unittests/list.cpp
Normal file
86
unittests/list.cpp
Normal file
@ -0,0 +1,86 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_list()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::list<int> o_podlist(100);
|
||||
for(auto & elem : o_podlist)
|
||||
elem = random_value<int>(gen);
|
||||
|
||||
std::list<StructInternalSerialize> o_iserlist(100);
|
||||
for(auto & elem : o_iserlist)
|
||||
elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::list<StructInternalSplit> o_ispllist(100);
|
||||
for(auto & elem : o_ispllist)
|
||||
elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::list<StructExternalSerialize> o_eserlist(100);
|
||||
for(auto & elem : o_eserlist)
|
||||
elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::list<StructExternalSplit> o_espllist(100);
|
||||
for(auto & elem : o_espllist)
|
||||
elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podlist);
|
||||
oar(o_iserlist);
|
||||
oar(o_ispllist);
|
||||
oar(o_eserlist);
|
||||
oar(o_espllist);
|
||||
}
|
||||
|
||||
std::list<int> i_podlist;
|
||||
std::list<StructInternalSerialize> i_iserlist;
|
||||
std::list<StructInternalSplit> i_ispllist;
|
||||
std::list<StructExternalSerialize> i_eserlist;
|
||||
std::list<StructExternalSplit> i_espllist;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podlist);
|
||||
iar(i_iserlist);
|
||||
iar(i_ispllist);
|
||||
iar(i_eserlist);
|
||||
iar(i_espllist);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_podlist.begin(), i_podlist.end(), o_podlist.begin(), o_podlist.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_iserlist.begin(), i_iserlist.end(), o_iserlist.begin(), o_iserlist.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_ispllist.begin(), i_ispllist.end(), o_ispllist.begin(), o_ispllist.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_eserlist.begin(), i_eserlist.end(), o_eserlist.begin(), o_eserlist.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_espllist.begin(), i_espllist.end(), o_espllist.begin(), o_espllist.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_list )
|
||||
{
|
||||
test_list<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_list )
|
||||
{
|
||||
test_list<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_list )
|
||||
{
|
||||
test_list<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_list )
|
||||
{
|
||||
test_list<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
168
unittests/load_construct.cpp
Normal file
168
unittests/load_construct.cpp
Normal file
@ -0,0 +1,168 @@
|
||||
#include "common.hpp"
|
||||
|
||||
struct OneLA
|
||||
{
|
||||
OneLA( int xx ) : x( xx ) {}
|
||||
|
||||
int x;
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{ ar( x ); }
|
||||
|
||||
template <class Archive>
|
||||
static void load_and_construct( Archive & ar, cereal::construct<OneLA> & construct )
|
||||
{
|
||||
int xx;
|
||||
ar( xx );
|
||||
construct( xx );
|
||||
}
|
||||
|
||||
bool operator==( OneLA const & other ) const
|
||||
{ return x == other.x; }
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, OneLA const & s)
|
||||
{
|
||||
os << "[" << s.x << "]";
|
||||
return os;
|
||||
}
|
||||
|
||||
struct TwoLA
|
||||
{
|
||||
TwoLA( int xx ) : x( xx ) {}
|
||||
|
||||
int x;
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{ ar( x ); }
|
||||
|
||||
bool operator==( TwoLA const & other ) const
|
||||
{ return x == other.x; }
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, TwoLA const & s)
|
||||
{
|
||||
os << "[" << s.x << "]";
|
||||
return os;
|
||||
}
|
||||
|
||||
namespace cereal
|
||||
{
|
||||
template <>
|
||||
struct LoadAndConstruct<TwoLA>
|
||||
{
|
||||
template <class Archive>
|
||||
static void load_and_construct( Archive & ar, cereal::construct<TwoLA> & construct )
|
||||
{
|
||||
int xx;
|
||||
ar( xx );
|
||||
construct( xx );
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
struct ThreeLA : std::enable_shared_from_this<ThreeLA>
|
||||
{
|
||||
ThreeLA( int xx ) : x( xx ) {}
|
||||
|
||||
int x;
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{ ar( x ); }
|
||||
|
||||
bool operator==( ThreeLA const & other ) const
|
||||
{ return x == other.x; }
|
||||
|
||||
template <class Archive>
|
||||
static void load_and_construct( Archive & ar, cereal::construct<ThreeLA> & construct )
|
||||
{
|
||||
int xx;
|
||||
ar( xx );
|
||||
construct( xx );
|
||||
}
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, ThreeLA const & s)
|
||||
{
|
||||
os << "[" << s.x << "]";
|
||||
return os;
|
||||
}
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_memory_load_construct()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
auto o_shared1 = std::make_shared<OneLA>( random_value<int>(gen) );
|
||||
auto o_shared2 = std::make_shared<TwoLA>( random_value<int>(gen) );
|
||||
std::unique_ptr<OneLA> o_unique1( new OneLA( random_value<int>(gen) ) );
|
||||
std::unique_ptr<TwoLA> o_unique2( new TwoLA( random_value<int>(gen) ) );
|
||||
auto o_shared3 = std::make_shared<ThreeLA>( random_value<int>(gen) );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar( o_shared1 );
|
||||
oar( o_shared2 );
|
||||
oar( o_unique1 );
|
||||
oar( o_unique2 );
|
||||
oar( o_shared3 );
|
||||
}
|
||||
|
||||
o_shared3->shared_from_this(); // tests github issue #68
|
||||
|
||||
decltype(o_shared1) i_shared1;
|
||||
decltype(o_shared2) i_shared2;
|
||||
decltype(o_unique1) i_unique1;
|
||||
decltype(o_unique2) i_unique2;
|
||||
decltype(o_shared3) i_shared3;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar( i_shared1 );
|
||||
iar( i_shared2 );
|
||||
iar( i_unique1 );
|
||||
iar( i_unique2 );
|
||||
iar( i_shared3 );
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL( *o_shared1, *i_shared1 );
|
||||
BOOST_CHECK_EQUAL( *o_shared2, *i_shared2 );
|
||||
BOOST_CHECK_EQUAL( *o_unique1, *i_unique1 );
|
||||
BOOST_CHECK_EQUAL( *o_unique2, *i_unique2 );
|
||||
BOOST_CHECK_EQUAL( *o_shared3, *i_shared3 );
|
||||
|
||||
auto i_shared3_2 = i_shared3->shared_from_this();
|
||||
BOOST_CHECK_EQUAL( *o_shared3, *i_shared3_2 );
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_memory_load_construct )
|
||||
{
|
||||
test_memory_load_construct<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_memory_load_construct )
|
||||
{
|
||||
test_memory_load_construct<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_memory_load_construct )
|
||||
{
|
||||
test_memory_load_construct<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_memory_load_construct )
|
||||
{
|
||||
test_memory_load_construct<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
179
unittests/map.cpp
Normal file
179
unittests/map.cpp
Normal file
@ -0,0 +1,179 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_map()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::map<size_t, std::vector<StructInternalSerialize>> o_vectormap;
|
||||
for(int j=0; j<10; ++j)
|
||||
{
|
||||
size_t id = random_value<size_t>(gen);
|
||||
for(int k=0; k<100; ++k)
|
||||
o_vectormap[id].emplace_back(random_value<int>(gen), random_value<int>(gen));
|
||||
}
|
||||
|
||||
std::map<std::string, int> o_podmap;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_podmap.insert({random_value<std::string>(gen), random_value<int>(gen)});
|
||||
|
||||
std::map<int, StructInternalSerialize> o_isermap;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_isermap.insert({random_value<int>(gen), { random_value<int>(gen), random_value<int>(gen) }});
|
||||
|
||||
std::map<int, StructInternalSplit> o_isplmap;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_isplmap.insert({random_value<int>(gen), { random_value<int>(gen), random_value<int>(gen) }});
|
||||
|
||||
std::map<uint32_t, StructExternalSerialize> o_esermap;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_esermap.insert({random_value<uint32_t>(gen), { random_value<int>(gen), random_value<int>(gen) }});
|
||||
|
||||
std::map<int8_t, StructExternalSplit> o_esplmap;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_esplmap.insert({random_value<char>(gen), { random_value<int>(gen), random_value<int>(gen) }});
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_vectormap);
|
||||
oar(o_podmap);
|
||||
oar(o_isermap);
|
||||
oar(o_isplmap);
|
||||
oar(o_esermap);
|
||||
oar(o_esplmap);
|
||||
}
|
||||
|
||||
std::map<size_t, std::vector<StructInternalSerialize>> i_vectormap;
|
||||
std::map<std::string, int> i_podmap;
|
||||
std::map<int, StructInternalSerialize> i_isermap;
|
||||
std::map<int, StructInternalSplit> i_isplmap;
|
||||
std::map<uint32_t, StructExternalSerialize> i_esermap;
|
||||
std::map<int8_t, StructExternalSplit> i_esplmap;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_vectormap);
|
||||
iar(i_podmap);
|
||||
iar(i_isermap);
|
||||
iar(i_isplmap);
|
||||
iar(i_esermap);
|
||||
iar(i_esplmap);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(i_vectormap.size(), o_vectormap.size());
|
||||
auto o_v_it = o_vectormap.begin();
|
||||
auto i_v_it = i_vectormap.begin();
|
||||
for(;o_v_it != o_vectormap.end(); ++o_v_it, ++i_v_it)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(i_v_it->second.size(), o_v_it->second.size());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_v_it->second.begin(), i_v_it->second.end(), o_v_it->second.begin(), o_v_it->second.end());
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_podmap.begin(), i_podmap.end(), o_podmap.begin(), o_podmap.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_isermap.begin(), i_isermap.end(), o_isermap.begin(), o_isermap.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_isplmap.begin(), i_isplmap.end(), o_isplmap.begin(), o_isplmap.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_esermap.begin(), i_esermap.end(), o_esermap.begin(), o_esermap.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_esplmap.begin(), i_esplmap.end(), o_esplmap.begin(), o_esplmap.end());
|
||||
}
|
||||
}
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_map_memory()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::map<int, std::unique_ptr<int>> o_uniqueptrMap;
|
||||
std::map<int, std::shared_ptr<int>> o_sharedptrMap;
|
||||
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
#ifdef CEREAL_OLDER_GCC
|
||||
o_uniqueptrMap.insert( std::make_pair(random_value<int>(gen), std::unique_ptr<int>( new int( random_value<int>(gen) ) )) );
|
||||
o_sharedptrMap.insert( std::make_pair(random_value<int>(gen), std::make_shared<int>( random_value<int>(gen) )) );
|
||||
#else // NOT CEREAL_OLDER_GCC
|
||||
o_uniqueptrMap.emplace( random_value<int>(gen), std::unique_ptr<int>( new int( random_value<int>(gen) ) ) );
|
||||
o_sharedptrMap.emplace( random_value<int>(gen), std::make_shared<int>( random_value<int>(gen) ) );
|
||||
#endif // NOT CEREAL_OLDER_GCC
|
||||
}
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar( o_uniqueptrMap );
|
||||
oar( o_sharedptrMap );
|
||||
}
|
||||
|
||||
decltype( o_uniqueptrMap ) i_uniqueptrMap;
|
||||
decltype( o_sharedptrMap ) i_sharedptrMap;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar( i_uniqueptrMap );
|
||||
iar( i_sharedptrMap );
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(o_sharedptrMap.size(), i_sharedptrMap.size());
|
||||
BOOST_CHECK_EQUAL(o_uniqueptrMap.size(), i_uniqueptrMap.size());
|
||||
|
||||
auto o_v_it = o_uniqueptrMap.begin();
|
||||
auto i_v_it = i_uniqueptrMap.begin();
|
||||
for(;o_v_it != o_uniqueptrMap.end(); ++o_v_it, ++i_v_it)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(i_v_it->first, o_v_it->first);
|
||||
BOOST_CHECK_EQUAL(*i_v_it->second, *o_v_it->second);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_map )
|
||||
{
|
||||
test_map<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_map )
|
||||
{
|
||||
test_map<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_map )
|
||||
{
|
||||
test_map<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_map )
|
||||
{
|
||||
test_map<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_map_memory )
|
||||
{
|
||||
test_map_memory<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_map_memory )
|
||||
{
|
||||
test_map_memory<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_map_memory )
|
||||
{
|
||||
test_map_memory<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_map_memory )
|
||||
{
|
||||
test_map_memory<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
74
unittests/memory.cpp
Normal file
74
unittests/memory.cpp
Normal file
@ -0,0 +1,74 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_memory()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::shared_ptr<int> o_xptr1 = std::make_shared<int>(random_value<int>(gen));
|
||||
std::shared_ptr<int> o_xptr2 = o_xptr1;
|
||||
std::shared_ptr<int> o_yptr1 = std::make_shared<int>(random_value<int>(gen));
|
||||
std::shared_ptr<int> o_yptr2 = o_yptr1;
|
||||
std::shared_ptr<int> o_nullptr1;
|
||||
std::shared_ptr<int> o_nullptr2;
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar( o_xptr1, o_xptr2 );
|
||||
oar( o_yptr1, o_yptr2 );
|
||||
oar( o_nullptr1, o_nullptr2 );
|
||||
}
|
||||
|
||||
std::shared_ptr<int> i_xptr1;
|
||||
std::shared_ptr<int> i_xptr2;
|
||||
std::shared_ptr<int> i_yptr1;
|
||||
std::shared_ptr<int> i_yptr2;
|
||||
std::shared_ptr<int> i_nullptr1;
|
||||
std::shared_ptr<int> i_nullptr2;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar( i_xptr1, i_xptr2);
|
||||
iar( i_yptr1, i_yptr2);
|
||||
iar( i_nullptr1, i_nullptr2 );
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(o_xptr1.get(), o_xptr2.get());
|
||||
BOOST_CHECK_EQUAL(i_xptr1.get(), i_xptr2.get());
|
||||
BOOST_CHECK_EQUAL(*i_xptr1, *i_xptr2);
|
||||
|
||||
BOOST_CHECK_EQUAL(o_yptr1.get(), o_yptr2.get());
|
||||
BOOST_CHECK_EQUAL(i_yptr1.get(), i_yptr2.get());
|
||||
BOOST_CHECK_EQUAL(*i_yptr1, *i_yptr2);
|
||||
BOOST_CHECK(!i_nullptr1);
|
||||
BOOST_CHECK(!i_nullptr2);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_memory )
|
||||
{
|
||||
test_memory<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_memory )
|
||||
{
|
||||
test_memory<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_memory )
|
||||
{
|
||||
test_memory<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_memory )
|
||||
{
|
||||
test_memory<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
134
unittests/memory_cycles.cpp
Normal file
134
unittests/memory_cycles.cpp
Normal file
@ -0,0 +1,134 @@
|
||||
#include "common.hpp"
|
||||
|
||||
struct MemoryCycle
|
||||
{
|
||||
MemoryCycle() = default;
|
||||
|
||||
MemoryCycle( int v ) :
|
||||
value( v )
|
||||
{ }
|
||||
|
||||
int value;
|
||||
std::weak_ptr<MemoryCycle> ptr;
|
||||
|
||||
bool operator==( MemoryCycle const & other ) const
|
||||
{
|
||||
return value == other.value && ptr.lock() == other.ptr.lock();
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
ar( value, ptr );
|
||||
}
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, MemoryCycle const & s)
|
||||
{
|
||||
os << "[value: " << s.value << " ptr: " << s.ptr.lock() << "]";
|
||||
return os;
|
||||
}
|
||||
|
||||
class MemoryCycleLoadAndConstruct
|
||||
{
|
||||
public:
|
||||
MemoryCycleLoadAndConstruct( int v ) :
|
||||
value( v )
|
||||
{ }
|
||||
|
||||
MemoryCycleLoadAndConstruct( int v,
|
||||
std::weak_ptr<MemoryCycleLoadAndConstruct> p ) :
|
||||
value( v ),
|
||||
ptr( p )
|
||||
{ }
|
||||
|
||||
bool operator==( MemoryCycleLoadAndConstruct const & other ) const
|
||||
{
|
||||
return value == other.value && ptr.lock() == other.ptr.lock();
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
ar( value, ptr );
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
static void load_and_construct( Archive & ar, cereal::construct<MemoryCycleLoadAndConstruct> & construct )
|
||||
{
|
||||
int value;
|
||||
std::weak_ptr<MemoryCycleLoadAndConstruct> ptr;
|
||||
|
||||
ar( value, ptr );
|
||||
construct( value, ptr );
|
||||
}
|
||||
|
||||
int value;
|
||||
std::weak_ptr<MemoryCycleLoadAndConstruct> ptr;
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, MemoryCycleLoadAndConstruct const & s)
|
||||
{
|
||||
os << "[value: " << s.value << " ptr: " << s.ptr.lock() << "]";
|
||||
return os;
|
||||
}
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_memory_cycles()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
auto o_ptr1 = std::make_shared<MemoryCycle>( random_value<int>(gen) );
|
||||
o_ptr1->ptr = o_ptr1;
|
||||
auto o_ptr2 = std::make_shared<MemoryCycleLoadAndConstruct>( random_value<int>(gen) );
|
||||
o_ptr2->ptr = o_ptr2;
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar( o_ptr1 );
|
||||
oar( o_ptr2 );
|
||||
}
|
||||
|
||||
decltype(o_ptr1) i_ptr1;
|
||||
decltype(o_ptr2) i_ptr2;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar( i_ptr1 );
|
||||
iar( i_ptr2 );
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL( o_ptr1->value, i_ptr1->value );
|
||||
BOOST_CHECK_EQUAL( i_ptr1.get(), i_ptr1->ptr.lock().get() );
|
||||
BOOST_CHECK_EQUAL( o_ptr2->value, i_ptr2->value );
|
||||
BOOST_CHECK_EQUAL( i_ptr2.get(), i_ptr2->ptr.lock().get() );
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_memory_cycles )
|
||||
{
|
||||
test_memory_cycles<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_memory_cycles )
|
||||
{
|
||||
test_memory_cycles<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_memory_cycles )
|
||||
{
|
||||
test_memory_cycles<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_memory_cycles )
|
||||
{
|
||||
test_memory_cycles<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
120
unittests/multimap.cpp
Normal file
120
unittests/multimap.cpp
Normal file
@ -0,0 +1,120 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_multimap()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::multimap<std::string, int> o_podmultimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<std::string>(gen);
|
||||
o_podmultimap.insert({key, random_value<int>(gen)});
|
||||
o_podmultimap.insert({key, random_value<int>(gen)});
|
||||
}
|
||||
|
||||
std::multimap<uint8_t, StructInternalSerialize> o_isermultimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<uint8_t>(gen);
|
||||
o_isermultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
o_isermultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
}
|
||||
|
||||
std::multimap<int16_t, StructInternalSplit> o_isplmultimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<int16_t>(gen);
|
||||
o_isplmultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
o_isplmultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
}
|
||||
|
||||
std::multimap<uint32_t, StructExternalSerialize> o_esermultimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<uint32_t>(gen);
|
||||
o_esermultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
o_esermultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
}
|
||||
|
||||
std::multimap<int8_t, StructExternalSplit> o_esplmultimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<char>(gen);
|
||||
o_esplmultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
o_esplmultimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
}
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podmultimap);
|
||||
oar(o_isermultimap);
|
||||
oar(o_isplmultimap);
|
||||
oar(o_esermultimap);
|
||||
oar(o_esplmultimap);
|
||||
}
|
||||
|
||||
std::multimap<std::string, int> i_podmultimap;
|
||||
std::multimap<uint8_t, StructInternalSerialize> i_isermultimap;
|
||||
std::multimap<int16_t, StructInternalSplit> i_isplmultimap;
|
||||
std::multimap<uint32_t, StructExternalSerialize> i_esermultimap;
|
||||
std::multimap<int8_t, StructExternalSplit> i_esplmultimap;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podmultimap);
|
||||
iar(i_isermultimap);
|
||||
iar(i_isplmultimap);
|
||||
iar(i_esermultimap);
|
||||
iar(i_esplmultimap);
|
||||
}
|
||||
|
||||
#define MULTIMAP_CHECK(InMap, OutMap) \
|
||||
for( auto & pair : OutMap ) \
|
||||
{ \
|
||||
auto const count = InMap.count( pair.first ); \
|
||||
BOOST_CHECK_EQUAL( count, OutMap.count( pair.first ) ); \
|
||||
auto find = InMap.find( pair.first ); \
|
||||
bool found = false; \
|
||||
for( size_t i = 0; i < count; ++i, ++find ) \
|
||||
found |= find->second == pair.second; \
|
||||
BOOST_CHECK( found ); \
|
||||
}
|
||||
|
||||
MULTIMAP_CHECK( i_podmultimap, o_podmultimap );
|
||||
MULTIMAP_CHECK( i_isermultimap, o_isermultimap );
|
||||
MULTIMAP_CHECK( i_isplmultimap, o_isplmultimap );
|
||||
MULTIMAP_CHECK( i_esermultimap, o_esermultimap );
|
||||
MULTIMAP_CHECK( i_esplmultimap, o_esplmultimap );
|
||||
|
||||
#undef MULTIMAP_CHECK
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_multimap )
|
||||
{
|
||||
test_multimap<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_multimap )
|
||||
{
|
||||
test_multimap<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_multimap )
|
||||
{
|
||||
test_multimap<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_multimap )
|
||||
{
|
||||
test_multimap<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
126
unittests/multiset.cpp
Normal file
126
unittests/multiset.cpp
Normal file
@ -0,0 +1,126 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_multiset()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::multiset<int> o_podmultiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
int value = random_value<int>(gen);
|
||||
o_podmultiset.insert(value);
|
||||
o_podmultiset.insert(value);
|
||||
}
|
||||
|
||||
std::multiset<StructInternalSerialize> o_isermultiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
StructInternalSerialize value = { random_value<int>(gen), random_value<int>(gen) };
|
||||
o_isermultiset.insert(value);
|
||||
o_isermultiset.insert(value);
|
||||
}
|
||||
|
||||
std::multiset<StructInternalSplit> o_isplmultiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
StructInternalSplit value = { random_value<int>(gen), random_value<int>(gen) };
|
||||
o_isplmultiset.insert(value);
|
||||
o_isplmultiset.insert(value);
|
||||
}
|
||||
|
||||
std::multiset<StructExternalSerialize> o_esermultiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
StructExternalSerialize value = { random_value<int>(gen), random_value<int>(gen) };
|
||||
o_esermultiset.insert(value);
|
||||
o_esermultiset.insert(value);
|
||||
}
|
||||
|
||||
std::multiset<StructExternalSplit> o_esplmultiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
StructExternalSplit value = { random_value<int>(gen), random_value<int>(gen) };
|
||||
o_esplmultiset.insert(value);
|
||||
o_esplmultiset.insert(value);
|
||||
}
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podmultiset);
|
||||
oar(o_isermultiset);
|
||||
oar(o_isplmultiset);
|
||||
oar(o_esermultiset);
|
||||
oar(o_esplmultiset);
|
||||
}
|
||||
|
||||
std::multiset<int> i_podmultiset;
|
||||
std::multiset<StructInternalSerialize> i_isermultiset;
|
||||
std::multiset<StructInternalSplit> i_isplmultiset;
|
||||
std::multiset<StructExternalSerialize> i_esermultiset;
|
||||
std::multiset<StructExternalSplit> i_esplmultiset;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podmultiset);
|
||||
iar(i_isermultiset);
|
||||
iar(i_isplmultiset);
|
||||
iar(i_esermultiset);
|
||||
iar(i_esplmultiset);
|
||||
}
|
||||
|
||||
for(auto const & p : i_podmultiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_podmultiset.count(p), i_podmultiset.count(p));
|
||||
}
|
||||
|
||||
for(auto const & p : i_isermultiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_isermultiset.count(p), i_isermultiset.count(p));
|
||||
}
|
||||
|
||||
for(auto const & p : i_isplmultiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_isplmultiset.count(p), i_isplmultiset.count(p));
|
||||
}
|
||||
|
||||
for(auto const & p : i_esermultiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_esermultiset.count(p), i_esermultiset.count(p));
|
||||
}
|
||||
|
||||
for(auto const & p : i_esplmultiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_esplmultiset.count(p), i_esplmultiset.count(p));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_multiset )
|
||||
{
|
||||
test_multiset<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_multiset )
|
||||
{
|
||||
test_multiset<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_multiset )
|
||||
{
|
||||
test_multiset<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_multiset )
|
||||
{
|
||||
test_multiset<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
|
||||
82
unittests/pair.cpp
Normal file
82
unittests/pair.cpp
Normal file
@ -0,0 +1,82 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_pair()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
auto rng = [&](){ return random_value<int>(gen); };
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::pair<int, int> o_podpair = {rng(), rng()};
|
||||
std::pair<StructInternalSerialize, StructInternalSerialize> o_iserpair = {{rng(), rng()}, {rng(), rng()}};
|
||||
std::pair<StructInternalSplit, StructInternalSplit> o_isplpair = {{rng(), rng()}, {rng(), rng()}};
|
||||
std::pair<StructExternalSerialize, StructExternalSerialize> o_eserpair = {{rng(), rng()}, {rng(), rng()}};
|
||||
std::pair<StructExternalSplit, StructExternalSplit> o_esplpair = {{rng(), rng()}, {rng(), rng()}};
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podpair);
|
||||
oar(o_iserpair);
|
||||
oar(o_isplpair);
|
||||
oar(o_eserpair);
|
||||
oar(o_esplpair);
|
||||
}
|
||||
|
||||
std::pair<int, int> i_podpair;
|
||||
std::pair<StructInternalSerialize, StructInternalSerialize> i_iserpair;
|
||||
std::pair<StructInternalSplit, StructInternalSplit> i_isplpair;
|
||||
std::pair<StructExternalSerialize, StructExternalSerialize> i_eserpair;
|
||||
std::pair<StructExternalSplit, StructExternalSplit> i_esplpair;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podpair);
|
||||
iar(i_iserpair);
|
||||
iar(i_isplpair);
|
||||
iar(i_eserpair);
|
||||
iar(i_esplpair);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL( i_podpair.first, o_podpair.first );
|
||||
BOOST_CHECK_EQUAL( i_podpair.second, o_podpair.second );
|
||||
|
||||
BOOST_CHECK_EQUAL( i_iserpair.first, o_iserpair.first );
|
||||
BOOST_CHECK_EQUAL( i_iserpair.second, o_iserpair.second );
|
||||
|
||||
BOOST_CHECK_EQUAL( i_isplpair.first, o_isplpair.first );
|
||||
BOOST_CHECK_EQUAL( i_isplpair.second, o_isplpair.second );
|
||||
|
||||
BOOST_CHECK_EQUAL( i_eserpair.first, o_eserpair.first );
|
||||
BOOST_CHECK_EQUAL( i_eserpair.second, o_eserpair.second );
|
||||
|
||||
BOOST_CHECK_EQUAL( i_esplpair.first, o_esplpair.first );
|
||||
BOOST_CHECK_EQUAL( i_esplpair.second, o_esplpair.second );
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_pair )
|
||||
{
|
||||
test_pair<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_pair )
|
||||
{
|
||||
test_pair<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_pair )
|
||||
{
|
||||
test_pair<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
BOOST_AUTO_TEST_CASE( json_pair )
|
||||
{
|
||||
test_pair<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
127
unittests/pod.cpp
Normal file
127
unittests/pod.cpp
Normal file
@ -0,0 +1,127 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_pod()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(size_t i=0; i<100; ++i)
|
||||
{
|
||||
bool const o_bool = random_value<uint8_t>(gen) % 2 ? true : false;
|
||||
uint8_t const o_uint8 = random_value<uint8_t>(gen);
|
||||
int8_t const o_int8 = random_value<int8_t>(gen);
|
||||
uint16_t const o_uint16 = random_value<uint16_t>(gen);
|
||||
int16_t const o_int16 = random_value<int16_t>(gen);
|
||||
uint32_t const o_uint32 = random_value<uint32_t>(gen);
|
||||
int32_t const o_int32 = random_value<int32_t>(gen);
|
||||
uint64_t const o_uint64 = random_value<uint64_t>(gen);
|
||||
int64_t const o_int64 = random_value<int64_t>(gen);
|
||||
float const o_float = random_value<float>(gen);
|
||||
double const o_double = random_value<double>(gen);
|
||||
|
||||
long double const o_long_double = random_value<long double>(gen);
|
||||
long const o_long = random_value<long>(gen);
|
||||
unsigned long const o_ulong = random_value<unsigned long>(gen);
|
||||
long long const o_long_long = random_value<long long>(gen);
|
||||
unsigned long long const o_ulong_long = random_value<unsigned long long>(gen);
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
oar(o_bool);
|
||||
oar(o_uint8);
|
||||
oar(o_int8);
|
||||
oar(o_uint16);
|
||||
oar(o_int16);
|
||||
oar(o_uint32);
|
||||
oar(o_int32);
|
||||
oar(o_uint64);
|
||||
oar(o_int64);
|
||||
oar(o_float);
|
||||
oar(o_double);
|
||||
oar(o_long_double);
|
||||
oar(o_long);
|
||||
oar(o_ulong);
|
||||
oar(o_long_long);
|
||||
oar(o_ulong_long);
|
||||
}
|
||||
|
||||
bool i_bool = false;
|
||||
uint8_t i_uint8 = 0;
|
||||
int8_t i_int8 = 0;
|
||||
uint16_t i_uint16 = 0;
|
||||
int16_t i_int16 = 0;
|
||||
uint32_t i_uint32 = 0;
|
||||
int32_t i_int32 = 0;
|
||||
uint64_t i_uint64 = 0;
|
||||
int64_t i_int64 = 0;
|
||||
float i_float = 0;
|
||||
double i_double = 0;
|
||||
|
||||
long double i_long_double = 0;
|
||||
long i_long = 0;
|
||||
unsigned long i_ulong = 0;
|
||||
long long i_long_long = 0;
|
||||
unsigned long long i_ulong_long = 0;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
iar(i_bool);
|
||||
iar(i_uint8);
|
||||
iar(i_int8);
|
||||
iar(i_uint16);
|
||||
iar(i_int16);
|
||||
iar(i_uint32);
|
||||
iar(i_int32);
|
||||
iar(i_uint64);
|
||||
iar(i_int64);
|
||||
iar(i_float);
|
||||
iar(i_double);
|
||||
iar(i_long_double);
|
||||
iar(i_long);
|
||||
iar(i_ulong);
|
||||
iar(i_long_long);
|
||||
iar(i_ulong_long);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(i_bool , o_bool);
|
||||
BOOST_CHECK_EQUAL(i_uint8 , o_uint8);
|
||||
BOOST_CHECK_EQUAL(i_int8 , o_int8);
|
||||
BOOST_CHECK_EQUAL(i_uint16 , o_uint16);
|
||||
BOOST_CHECK_EQUAL(i_int16 , o_int16);
|
||||
BOOST_CHECK_EQUAL(i_uint32 , o_uint32);
|
||||
BOOST_CHECK_EQUAL(i_int32 , o_int32);
|
||||
BOOST_CHECK_EQUAL(i_uint64 , o_uint64);
|
||||
BOOST_CHECK_EQUAL(i_int64 , o_int64);
|
||||
BOOST_CHECK_CLOSE(i_float , o_float, (float)1e-5);
|
||||
BOOST_CHECK_CLOSE(i_double , o_double, 1e-5);
|
||||
|
||||
BOOST_CHECK_CLOSE(i_long_double, o_long_double, 1e-5);
|
||||
BOOST_CHECK_EQUAL(i_long, o_long);
|
||||
BOOST_CHECK_EQUAL(i_ulong, o_ulong);
|
||||
BOOST_CHECK_EQUAL(i_long_long, o_long_long);
|
||||
BOOST_CHECK_EQUAL(i_ulong_long, o_ulong_long);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_pod )
|
||||
{
|
||||
test_pod<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_pod )
|
||||
{
|
||||
test_pod<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_pod )
|
||||
{
|
||||
test_pod<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_pod )
|
||||
{
|
||||
test_pod<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
169
unittests/polymorphic.cpp
Normal file
169
unittests/polymorphic.cpp
Normal file
@ -0,0 +1,169 @@
|
||||
#include "common.hpp"
|
||||
|
||||
struct PolyBase
|
||||
{
|
||||
PolyBase() {}
|
||||
PolyBase( int xx, float yy ) : x(xx), y(yy) {}
|
||||
int x;
|
||||
float y;
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
ar( x, y );
|
||||
}
|
||||
|
||||
virtual void foo() = 0;
|
||||
|
||||
bool operator==( PolyBase const & other ) const
|
||||
{
|
||||
return x == other.x && std::abs(y - other.y) < 1e-5;
|
||||
}
|
||||
};
|
||||
|
||||
struct PolyDerived : PolyBase
|
||||
{
|
||||
PolyDerived() {}
|
||||
PolyDerived( int xx, float yy, bool aa, double bb ) :
|
||||
PolyBase( xx, yy ), a(aa), b(bb) {}
|
||||
|
||||
bool a;
|
||||
double b;
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
ar( cereal::base_class<PolyBase>( this ),
|
||||
a, b );
|
||||
}
|
||||
|
||||
bool operator==( PolyDerived const & other ) const
|
||||
{
|
||||
return PolyBase::operator==( other ) && a == other.a && std::abs(b - other.b) < 1e-5;
|
||||
}
|
||||
|
||||
void foo() {}
|
||||
};
|
||||
|
||||
struct PolyLA : std::enable_shared_from_this<PolyLA>
|
||||
{
|
||||
virtual void foo() = 0;
|
||||
};
|
||||
|
||||
struct PolyDerivedLA : public PolyLA
|
||||
{
|
||||
PolyDerivedLA( int xx ) : x( xx ) { }
|
||||
|
||||
int x;
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
ar( x );
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
static void load_and_construct( Archive & ar, cereal::construct<PolyDerivedLA> & construct )
|
||||
{
|
||||
int xx;
|
||||
ar( xx );
|
||||
construct( xx );
|
||||
}
|
||||
|
||||
void foo() {}
|
||||
|
||||
bool operator==( PolyDerivedLA const & other ) const
|
||||
{
|
||||
return x == other.x;
|
||||
}
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, PolyDerivedLA const & s)
|
||||
{
|
||||
os << "[x: " << s.x << "]";
|
||||
return os;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, PolyDerived const & s)
|
||||
{
|
||||
os << "[x: " << s.x << " y: " << s.y << " a: " << s.a << " b: " << s.b << "]";
|
||||
return os;
|
||||
}
|
||||
|
||||
CEREAL_REGISTER_TYPE(PolyDerived)
|
||||
CEREAL_REGISTER_TYPE(PolyDerivedLA)
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_polymorphic()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
auto rngB = [&](){ return random_value<int>( gen ) % 2 == 0; };
|
||||
auto rngI = [&](){ return random_value<int>( gen ); };
|
||||
auto rngF = [&](){ return random_value<float>( gen ); };
|
||||
auto rngD = [&](){ return random_value<double>( gen ); };
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::shared_ptr<PolyBase> o_shared = std::make_shared<PolyDerived>( rngI(), rngF(), rngB(), rngD() );
|
||||
std::weak_ptr<PolyBase> o_weak = o_shared;
|
||||
std::unique_ptr<PolyBase> o_unique( new PolyDerived( rngI(), rngF(), rngB(), rngD() ) );
|
||||
std::shared_ptr<PolyLA> o_sharedLA = std::make_shared<PolyDerivedLA>( rngI() );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar( o_shared, o_weak, o_unique );
|
||||
oar( o_sharedLA );
|
||||
}
|
||||
|
||||
decltype(o_shared) i_shared;
|
||||
decltype(o_weak) i_weak;
|
||||
decltype(o_unique) i_unique;
|
||||
decltype(o_sharedLA) i_sharedLA;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar( i_shared, i_weak, i_unique );
|
||||
iar( i_sharedLA );
|
||||
}
|
||||
|
||||
auto i_locked = i_weak.lock();
|
||||
auto o_locked = o_weak.lock();
|
||||
|
||||
auto i_sharedLA2 = i_sharedLA->shared_from_this();
|
||||
|
||||
BOOST_CHECK_EQUAL(i_shared.get(), i_locked.get());
|
||||
BOOST_CHECK_EQUAL(*((PolyDerived*)i_shared.get()), *((PolyDerived*)o_shared.get()));
|
||||
BOOST_CHECK_EQUAL(*((PolyDerived*)i_shared.get()), *((PolyDerived*)i_locked.get()));
|
||||
BOOST_CHECK_EQUAL(*((PolyDerived*)i_locked.get()), *((PolyDerived*)o_locked.get()));
|
||||
BOOST_CHECK_EQUAL(*((PolyDerived*)i_unique.get()), *((PolyDerived*)o_unique.get()));
|
||||
BOOST_CHECK_EQUAL(*((PolyDerivedLA*)i_sharedLA.get()), *((PolyDerivedLA*)o_sharedLA.get()));
|
||||
BOOST_CHECK_EQUAL(*((PolyDerivedLA*)i_sharedLA2.get()), *((PolyDerivedLA*)o_sharedLA.get()));
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_polymorphic )
|
||||
{
|
||||
test_polymorphic<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_polymorphic )
|
||||
{
|
||||
test_polymorphic<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_polymorphic )
|
||||
{
|
||||
test_polymorphic<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_polymorphic )
|
||||
{
|
||||
test_polymorphic<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
128
unittests/portable_binary_archive.cpp
Normal file
128
unittests/portable_binary_archive.cpp
Normal file
@ -0,0 +1,128 @@
|
||||
#include "common.hpp"
|
||||
|
||||
namespace mynamespace { struct MyCustomClass {}; }
|
||||
|
||||
#ifdef _MSC_VER
|
||||
BOOST_AUTO_TEST_CASE( util )
|
||||
{
|
||||
BOOST_CHECK_EQUAL( cereal::util::demangledName<mynamespace::MyCustomClass>(), "struct mynamespace::MyCustomClass" );
|
||||
}
|
||||
#else
|
||||
BOOST_AUTO_TEST_CASE( util )
|
||||
{
|
||||
BOOST_CHECK_EQUAL( cereal::util::demangledName<mynamespace::MyCustomClass>(), "mynamespace::MyCustomClass" );
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
inline void swapBytes( T & t )
|
||||
{
|
||||
cereal::portable_binary_detail::swap_bytes<sizeof(T)>( reinterpret_cast<std::uint8_t*>(&t) );
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_archive )
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(size_t i=0; i<100; ++i)
|
||||
{
|
||||
bool o_bool = random_value<uint8_t>(gen) % 2 ? true : false;
|
||||
uint8_t o_uint8 = random_value<uint8_t>(gen);
|
||||
int8_t o_int8 = random_value<int8_t>(gen);
|
||||
uint16_t o_uint16 = random_value<uint16_t>(gen);
|
||||
int16_t o_int16 = random_value<int16_t>(gen);
|
||||
uint32_t o_uint32 = random_value<uint32_t>(gen);
|
||||
int32_t o_int32 = random_value<int32_t>(gen);
|
||||
uint64_t o_uint64 = random_value<uint64_t>(gen);
|
||||
int64_t o_int64 = random_value<int64_t>(gen);
|
||||
float o_float = random_value<float>(gen);
|
||||
double o_double = random_value<double>(gen);
|
||||
|
||||
// swap the bytes on all of the data
|
||||
swapBytes(o_bool);
|
||||
swapBytes(o_uint8);
|
||||
swapBytes(o_int8);
|
||||
swapBytes(o_uint16);
|
||||
swapBytes(o_int16);
|
||||
swapBytes(o_uint32);
|
||||
swapBytes(o_int32);
|
||||
swapBytes(o_uint64);
|
||||
swapBytes(o_int64);
|
||||
swapBytes(o_float);
|
||||
swapBytes(o_double);
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
cereal::BinaryOutputArchive oar(os);
|
||||
// manually insert incorrect endian encoding
|
||||
oar(!cereal::portable_binary_detail::is_little_endian());
|
||||
|
||||
oar(o_bool);
|
||||
oar(o_uint8);
|
||||
oar(o_int8);
|
||||
oar(o_uint16);
|
||||
oar(o_int16);
|
||||
oar(o_uint32);
|
||||
oar(o_int32);
|
||||
oar(o_uint64);
|
||||
oar(o_int64);
|
||||
oar(o_float);
|
||||
oar(o_double);
|
||||
}
|
||||
|
||||
// swap back to original values
|
||||
swapBytes(o_bool);
|
||||
swapBytes(o_uint8);
|
||||
swapBytes(o_int8);
|
||||
swapBytes(o_uint16);
|
||||
swapBytes(o_int16);
|
||||
swapBytes(o_uint32);
|
||||
swapBytes(o_int32);
|
||||
swapBytes(o_uint64);
|
||||
swapBytes(o_int64);
|
||||
swapBytes(o_float);
|
||||
swapBytes(o_double);
|
||||
|
||||
bool i_bool = false;
|
||||
uint8_t i_uint8 = 0;
|
||||
int8_t i_int8 = 0;
|
||||
uint16_t i_uint16 = 0;
|
||||
int16_t i_int16 = 0;
|
||||
uint32_t i_uint32 = 0;
|
||||
int32_t i_int32 = 0;
|
||||
uint64_t i_uint64 = 0;
|
||||
int64_t i_int64 = 0;
|
||||
float i_float = 0;
|
||||
double i_double = 0;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
cereal::PortableBinaryInputArchive iar(is);
|
||||
iar(i_bool);
|
||||
iar(i_uint8);
|
||||
iar(i_int8);
|
||||
iar(i_uint16);
|
||||
iar(i_int16);
|
||||
iar(i_uint32);
|
||||
iar(i_int32);
|
||||
iar(i_uint64);
|
||||
iar(i_int64);
|
||||
iar(i_float);
|
||||
iar(i_double);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(i_bool , o_bool);
|
||||
BOOST_CHECK_EQUAL(i_uint8 , o_uint8);
|
||||
BOOST_CHECK_EQUAL(i_int8 , o_int8);
|
||||
BOOST_CHECK_EQUAL(i_uint16 , o_uint16);
|
||||
BOOST_CHECK_EQUAL(i_int16 , o_int16);
|
||||
BOOST_CHECK_EQUAL(i_uint32 , o_uint32);
|
||||
BOOST_CHECK_EQUAL(i_int32 , o_int32);
|
||||
BOOST_CHECK_EQUAL(i_uint64 , o_uint64);
|
||||
BOOST_CHECK_EQUAL(i_int64 , o_int64);
|
||||
BOOST_CHECK_CLOSE(i_float , o_float, (float)1e-5);
|
||||
BOOST_CHECK_CLOSE(i_double , o_double, 1e-5);
|
||||
}
|
||||
}
|
||||
|
||||
98
unittests/priority_queue.cpp
Normal file
98
unittests/priority_queue.cpp
Normal file
@ -0,0 +1,98 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_priority_queue()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::priority_queue<int> o_podpriority_queue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_podpriority_queue.push(random_value<int>(gen));
|
||||
|
||||
std::priority_queue<StructInternalSerialize> o_iserpriority_queue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_iserpriority_queue.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::priority_queue<StructInternalSplit> o_isplpriority_queue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_isplpriority_queue.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::priority_queue<StructExternalSerialize> o_eserpriority_queue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_eserpriority_queue.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::priority_queue<StructExternalSplit> o_esplpriority_queue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_esplpriority_queue.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podpriority_queue);
|
||||
oar(o_iserpriority_queue);
|
||||
oar(o_isplpriority_queue);
|
||||
oar(o_eserpriority_queue);
|
||||
oar(o_esplpriority_queue);
|
||||
}
|
||||
|
||||
std::priority_queue<int> i_podpriority_queue;
|
||||
std::priority_queue<StructInternalSerialize> i_iserpriority_queue;
|
||||
std::priority_queue<StructInternalSplit> i_isplpriority_queue;
|
||||
std::priority_queue<StructExternalSerialize> i_eserpriority_queue;
|
||||
std::priority_queue<StructExternalSplit> i_esplpriority_queue;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podpriority_queue);
|
||||
iar(i_iserpriority_queue);
|
||||
iar(i_isplpriority_queue);
|
||||
iar(i_eserpriority_queue);
|
||||
iar(i_esplpriority_queue);
|
||||
}
|
||||
|
||||
auto & i_podpriority_queue_c = cereal::queue_detail::container(i_podpriority_queue);
|
||||
auto & i_iserpriority_queue_c = cereal::queue_detail::container(i_iserpriority_queue);
|
||||
auto & i_isplpriority_queue_c = cereal::queue_detail::container(i_isplpriority_queue);
|
||||
auto & i_eserpriority_queue_c = cereal::queue_detail::container(i_eserpriority_queue);
|
||||
auto & i_esplpriority_queue_c = cereal::queue_detail::container(i_esplpriority_queue);
|
||||
|
||||
auto & o_podpriority_queue_c = cereal::queue_detail::container(o_podpriority_queue);
|
||||
auto & o_iserpriority_queue_c = cereal::queue_detail::container(o_iserpriority_queue);
|
||||
auto & o_isplpriority_queue_c = cereal::queue_detail::container(o_isplpriority_queue);
|
||||
auto & o_eserpriority_queue_c = cereal::queue_detail::container(o_eserpriority_queue);
|
||||
auto & o_esplpriority_queue_c = cereal::queue_detail::container(o_esplpriority_queue);
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_podpriority_queue_c.begin(), i_podpriority_queue_c.end(), o_podpriority_queue_c.begin(), o_podpriority_queue_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_iserpriority_queue_c.begin(), i_iserpriority_queue_c.end(), o_iserpriority_queue_c.begin(), o_iserpriority_queue_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_isplpriority_queue_c.begin(), i_isplpriority_queue_c.end(), o_isplpriority_queue_c.begin(), o_isplpriority_queue_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_eserpriority_queue_c.begin(), i_eserpriority_queue_c.end(), o_eserpriority_queue_c.begin(), o_eserpriority_queue_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_esplpriority_queue_c.begin(), i_esplpriority_queue_c.end(), o_esplpriority_queue_c.begin(), o_esplpriority_queue_c.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_priority_queue )
|
||||
{
|
||||
test_priority_queue<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_priority_queue )
|
||||
{
|
||||
test_priority_queue<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_priority_queue )
|
||||
{
|
||||
test_priority_queue<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_priority_queue )
|
||||
{
|
||||
test_priority_queue<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
98
unittests/queue.cpp
Normal file
98
unittests/queue.cpp
Normal file
@ -0,0 +1,98 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_queue()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::queue<int> o_podqueue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_podqueue.push(random_value<int>(gen));
|
||||
|
||||
std::queue<StructInternalSerialize> o_iserqueue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_iserqueue.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::queue<StructInternalSplit> o_isplqueue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_isplqueue.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::queue<StructExternalSerialize> o_eserqueue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_eserqueue.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::queue<StructExternalSplit> o_esplqueue;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_esplqueue.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podqueue);
|
||||
oar(o_iserqueue);
|
||||
oar(o_isplqueue);
|
||||
oar(o_eserqueue);
|
||||
oar(o_esplqueue);
|
||||
}
|
||||
|
||||
std::queue<int> i_podqueue;
|
||||
std::queue<StructInternalSerialize> i_iserqueue;
|
||||
std::queue<StructInternalSplit> i_isplqueue;
|
||||
std::queue<StructExternalSerialize> i_eserqueue;
|
||||
std::queue<StructExternalSplit> i_esplqueue;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podqueue);
|
||||
iar(i_iserqueue);
|
||||
iar(i_isplqueue);
|
||||
iar(i_eserqueue);
|
||||
iar(i_esplqueue);
|
||||
}
|
||||
|
||||
auto & i_podqueue_c = cereal::queue_detail::container(i_podqueue);
|
||||
auto & i_iserqueue_c = cereal::queue_detail::container(i_iserqueue);
|
||||
auto & i_isplqueue_c = cereal::queue_detail::container(i_isplqueue);
|
||||
auto & i_eserqueue_c = cereal::queue_detail::container(i_eserqueue);
|
||||
auto & i_esplqueue_c = cereal::queue_detail::container(i_esplqueue);
|
||||
|
||||
auto & o_podqueue_c = cereal::queue_detail::container(o_podqueue);
|
||||
auto & o_iserqueue_c = cereal::queue_detail::container(o_iserqueue);
|
||||
auto & o_isplqueue_c = cereal::queue_detail::container(o_isplqueue);
|
||||
auto & o_eserqueue_c = cereal::queue_detail::container(o_eserqueue);
|
||||
auto & o_esplqueue_c = cereal::queue_detail::container(o_esplqueue);
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_podqueue_c.begin(), i_podqueue_c.end(), o_podqueue_c.begin(), o_podqueue_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_iserqueue_c.begin(), i_iserqueue_c.end(), o_iserqueue_c.begin(), o_iserqueue_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_isplqueue_c.begin(), i_isplqueue_c.end(), o_isplqueue_c.begin(), o_isplqueue_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_eserqueue_c.begin(), i_eserqueue_c.end(), o_eserqueue_c.begin(), o_eserqueue_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_esplqueue_c.begin(), i_esplqueue_c.end(), o_esplqueue_c.begin(), o_esplqueue_c.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_queue )
|
||||
{
|
||||
test_queue<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_queue )
|
||||
{
|
||||
test_queue<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_queue )
|
||||
{
|
||||
test_queue<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_queue )
|
||||
{
|
||||
test_queue<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
86
unittests/set.cpp
Normal file
86
unittests/set.cpp
Normal file
@ -0,0 +1,86 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_set()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::set<int> o_podset;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_podset.insert(random_value<int>(gen));
|
||||
|
||||
std::set<StructInternalSerialize> o_iserset;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_iserset.insert({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::set<StructInternalSplit> o_isplset;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_isplset.insert({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::set<StructExternalSerialize> o_eserset;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_eserset.insert({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::set<StructExternalSplit> o_esplset;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_esplset.insert({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podset);
|
||||
oar(o_iserset);
|
||||
oar(o_isplset);
|
||||
oar(o_eserset);
|
||||
oar(o_esplset);
|
||||
}
|
||||
|
||||
std::set<int> i_podset;
|
||||
std::set<StructInternalSerialize> i_iserset;
|
||||
std::set<StructInternalSplit> i_isplset;
|
||||
std::set<StructExternalSerialize> i_eserset;
|
||||
std::set<StructExternalSplit> i_esplset;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podset);
|
||||
iar(i_iserset);
|
||||
iar(i_isplset);
|
||||
iar(i_eserset);
|
||||
iar(i_esplset);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_podset.begin(), i_podset.end(), o_podset.begin(), o_podset.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_iserset.begin(), i_iserset.end(), o_iserset.begin(), o_iserset.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_isplset.begin(), i_isplset.end(), o_isplset.begin(), o_isplset.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_eserset.begin(), i_eserset.end(), o_eserset.begin(), o_eserset.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_esplset.begin(), i_esplset.end(), o_esplset.begin(), o_esplset.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_set )
|
||||
{
|
||||
test_set<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_set )
|
||||
{
|
||||
test_set<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_set )
|
||||
{
|
||||
test_set<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_set )
|
||||
{
|
||||
test_set<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
98
unittests/stack.cpp
Normal file
98
unittests/stack.cpp
Normal file
@ -0,0 +1,98 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_stack()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::stack<int> o_podstack;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_podstack.push(random_value<int>(gen));
|
||||
|
||||
std::stack<StructInternalSerialize> o_iserstack;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_iserstack.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::stack<StructInternalSplit> o_isplstack;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_isplstack.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::stack<StructExternalSerialize> o_eserstack;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_eserstack.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::stack<StructExternalSplit> o_esplstack;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_esplstack.push({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podstack);
|
||||
oar(o_iserstack);
|
||||
oar(o_isplstack);
|
||||
oar(o_eserstack);
|
||||
oar(o_esplstack);
|
||||
}
|
||||
|
||||
std::stack<int> i_podstack;
|
||||
std::stack<StructInternalSerialize> i_iserstack;
|
||||
std::stack<StructInternalSplit> i_isplstack;
|
||||
std::stack<StructExternalSerialize> i_eserstack;
|
||||
std::stack<StructExternalSplit> i_esplstack;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podstack);
|
||||
iar(i_iserstack);
|
||||
iar(i_isplstack);
|
||||
iar(i_eserstack);
|
||||
iar(i_esplstack);
|
||||
}
|
||||
|
||||
auto & i_podstack_c = cereal::stack_detail::container(i_podstack);
|
||||
auto & i_iserstack_c = cereal::stack_detail::container(i_iserstack);
|
||||
auto & i_isplstack_c = cereal::stack_detail::container(i_isplstack);
|
||||
auto & i_eserstack_c = cereal::stack_detail::container(i_eserstack);
|
||||
auto & i_esplstack_c = cereal::stack_detail::container(i_esplstack);
|
||||
|
||||
auto & o_podstack_c = cereal::stack_detail::container(o_podstack);
|
||||
auto & o_iserstack_c = cereal::stack_detail::container(o_iserstack);
|
||||
auto & o_isplstack_c = cereal::stack_detail::container(o_isplstack);
|
||||
auto & o_eserstack_c = cereal::stack_detail::container(o_eserstack);
|
||||
auto & o_esplstack_c = cereal::stack_detail::container(o_esplstack);
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_podstack_c.begin(), i_podstack_c.end(), o_podstack_c.begin(), o_podstack_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_iserstack_c.begin(), i_iserstack_c.end(), o_iserstack_c.begin(), o_iserstack_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_isplstack_c.begin(), i_isplstack_c.end(), o_isplstack_c.begin(), o_isplstack_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_eserstack_c.begin(), i_eserstack_c.end(), o_eserstack_c.begin(), o_eserstack_c.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_esplstack_c.begin(), i_esplstack_c.end(), o_esplstack_c.begin(), o_esplstack_c.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_stack )
|
||||
{
|
||||
test_stack<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_stack )
|
||||
{
|
||||
test_stack<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_stack )
|
||||
{
|
||||
test_stack<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_stack )
|
||||
{
|
||||
test_stack<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
58
unittests/structs.cpp
Normal file
58
unittests/structs.cpp
Normal file
@ -0,0 +1,58 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_structs()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
StructInternalSerialize o_iser = { random_value<int>(gen), random_value<int>(gen) };
|
||||
StructInternalSplit o_ispl = { random_value<int>(gen), random_value<int>(gen) };
|
||||
StructExternalSerialize o_eser = { random_value<int>(gen), random_value<int>(gen) };
|
||||
StructExternalSplit o_espl = { random_value<int>(gen), random_value<int>(gen) };
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
oar( o_iser, o_ispl, o_eser, o_espl);
|
||||
}
|
||||
|
||||
StructInternalSerialize i_iser;
|
||||
StructInternalSplit i_ispl;
|
||||
StructExternalSerialize i_eser;
|
||||
StructExternalSplit i_espl;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
iar( i_iser, i_ispl, i_eser, i_espl);
|
||||
}
|
||||
|
||||
BOOST_CHECK(i_iser == o_iser);
|
||||
BOOST_CHECK(i_ispl == o_ispl);
|
||||
BOOST_CHECK(i_eser == o_eser);
|
||||
BOOST_CHECK(i_espl == o_espl);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_structs )
|
||||
{
|
||||
test_structs<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_structs )
|
||||
{
|
||||
test_structs<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_structs )
|
||||
{
|
||||
test_structs<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_structs )
|
||||
{
|
||||
test_structs<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
133
unittests/structs_specialized.cpp
Normal file
133
unittests/structs_specialized.cpp
Normal file
@ -0,0 +1,133 @@
|
||||
#include "common.hpp"
|
||||
|
||||
class SpecializedMSerialize
|
||||
{
|
||||
public:
|
||||
int x;
|
||||
|
||||
private:
|
||||
friend class cereal::access;
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
ar( x );
|
||||
}
|
||||
};
|
||||
|
||||
class SpecializedMSplit
|
||||
{
|
||||
public:
|
||||
int x;
|
||||
|
||||
private:
|
||||
friend class cereal::access;
|
||||
template <class Archive>
|
||||
void save( Archive & ar ) const
|
||||
{
|
||||
ar( x );
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void load( Archive & ar )
|
||||
{
|
||||
ar( x );
|
||||
}
|
||||
};
|
||||
|
||||
class SpecializedNMSerialize
|
||||
{
|
||||
public:
|
||||
int x;
|
||||
};
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar, SpecializedNMSerialize & s )
|
||||
{
|
||||
ar( s.x );
|
||||
}
|
||||
|
||||
class SpecializedNMSplit
|
||||
{
|
||||
public:
|
||||
int x;
|
||||
};
|
||||
|
||||
template <class Archive>
|
||||
void load( Archive & ar, SpecializedNMSplit & s )
|
||||
{
|
||||
ar( s.x );
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void save( Archive & ar, SpecializedNMSplit const & s )
|
||||
{
|
||||
ar( s.x );
|
||||
}
|
||||
|
||||
namespace cereal
|
||||
{
|
||||
template <class Archive> struct specialize<Archive, SpecializedMSerialize, cereal::specialization::member_serialize> {};
|
||||
template <class Archive> struct specialize<Archive, SpecializedMSplit, cereal::specialization::member_load_save> {};
|
||||
template <class Archive> struct specialize<Archive, SpecializedNMSerialize, cereal::specialization::non_member_serialize> {};
|
||||
template <class Archive> struct specialize<Archive, SpecializedNMSplit, cereal::specialization::non_member_load_save> {};
|
||||
}
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_structs_specialized()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
SpecializedMSerialize o_iser = { random_value<int>(gen) };
|
||||
SpecializedMSplit o_ispl = { random_value<int>(gen) };
|
||||
SpecializedNMSerialize o_eser = { random_value<int>(gen) };
|
||||
SpecializedNMSplit o_espl = { random_value<int>(gen) };
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar( o_iser, o_ispl, o_eser, o_espl);
|
||||
}
|
||||
|
||||
decltype(o_iser) i_iser;
|
||||
decltype(o_ispl) i_ispl;
|
||||
decltype(o_eser) i_eser;
|
||||
decltype(o_espl) i_espl;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar( i_iser, i_ispl, i_eser, i_espl);
|
||||
}
|
||||
|
||||
BOOST_CHECK(i_iser.x == o_iser.x);
|
||||
BOOST_CHECK(i_ispl.x == o_ispl.x);
|
||||
BOOST_CHECK(i_eser.x == o_eser.x);
|
||||
BOOST_CHECK(i_espl.x == o_espl.x);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_structs_specialized )
|
||||
{
|
||||
test_structs_specialized<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_structs_specialized )
|
||||
{
|
||||
test_structs_specialized<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_structs_specialized )
|
||||
{
|
||||
test_structs_specialized<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_structs_specialized )
|
||||
{
|
||||
test_structs_specialized<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
86
unittests/tuple.cpp
Normal file
86
unittests/tuple.cpp
Normal file
@ -0,0 +1,86 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_tuple()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
auto rng = [&](){ return random_value<int>(gen); };
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
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() ) );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podtuple);
|
||||
oar(o_isertuple);
|
||||
oar(o_ispltuple);
|
||||
oar(o_esertuple);
|
||||
oar(o_espltuple);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
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 );
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_tuple )
|
||||
{
|
||||
test_tuple<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_tuple )
|
||||
{
|
||||
test_tuple<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_tuple )
|
||||
{
|
||||
test_tuple<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_tuple )
|
||||
{
|
||||
test_tuple<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
126
unittests/unordered_loads.cpp
Normal file
126
unittests/unordered_loads.cpp
Normal file
@ -0,0 +1,126 @@
|
||||
#include "common.hpp"
|
||||
|
||||
struct unordered_naming
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
int z;
|
||||
|
||||
template <class Archive>
|
||||
void save( Archive & ar ) const
|
||||
{
|
||||
ar( CEREAL_NVP(x),
|
||||
CEREAL_NVP(z),
|
||||
CEREAL_NVP(y) );
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void load( Archive & ar )
|
||||
{
|
||||
ar( x,
|
||||
CEREAL_NVP(y),
|
||||
CEREAL_NVP(z) );
|
||||
}
|
||||
|
||||
bool operator==( unordered_naming const & other ) const
|
||||
{
|
||||
return x == other.x && y == other.y && z == other.z;
|
||||
}
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, unordered_naming const & s)
|
||||
{
|
||||
os << "[x: " << s.x << " y: " << s.y << " z: " << s.z << "]";
|
||||
return os;
|
||||
}
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_unordered_loads()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
auto rngB = [&](){ return random_value<int>( gen ) % 2 == 0; };
|
||||
auto rngI = [&](){ return random_value<int>( gen ); };
|
||||
auto rngF = [&](){ return random_value<float>( gen ); };
|
||||
auto rngD = [&](){ return random_value<double>( gen ); };
|
||||
auto rngS = [&](){ return random_basic_string<char>( gen ); };
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
auto const name1 = rngS();
|
||||
auto const name2 = rngS();
|
||||
auto const name3 = rngS();
|
||||
auto const name4 = rngS();
|
||||
auto const name5 = rngS();
|
||||
auto const name6 = rngS();
|
||||
auto const name7 = rngS();
|
||||
|
||||
int o_int1 = rngI();
|
||||
double o_double2 = rngD();
|
||||
std::vector<bool> o_vecbool3 = { rngB(), rngB(), rngB(), rngB(), rngB() };
|
||||
int o_int4 = rngI();
|
||||
int o_int5 = rngI();
|
||||
int o_int6 = rngI();
|
||||
std::pair<float, unordered_naming> o_un7;
|
||||
o_un7.first = rngF();
|
||||
o_un7.second.x = rngI();
|
||||
o_un7.second.y = rngI();
|
||||
o_un7.second.z = rngI();
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar( cereal::make_nvp( name1, o_int1 ),
|
||||
cereal::make_nvp( name2, o_double2 ),
|
||||
cereal::make_nvp( name3, o_vecbool3 ),
|
||||
cereal::make_nvp( name4, o_int4 ),
|
||||
cereal::make_nvp( name5, o_int5 ),
|
||||
cereal::make_nvp( name6, o_int6 ),
|
||||
cereal::make_nvp( name7, o_un7 ) );
|
||||
}
|
||||
|
||||
decltype(o_int1) i_int1;
|
||||
decltype(o_double2) i_double2;
|
||||
decltype(o_vecbool3) i_vecbool3;
|
||||
decltype(o_int4) i_int4;
|
||||
decltype(o_int5) i_int5;
|
||||
decltype(o_int6) i_int6;
|
||||
decltype(o_un7) i_un7;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar( cereal::make_nvp( name7, i_un7 ),
|
||||
cereal::make_nvp( name2, i_double2 ),
|
||||
cereal::make_nvp( name4, i_int4 ),
|
||||
cereal::make_nvp( name3, i_vecbool3 ),
|
||||
cereal::make_nvp( name1, i_int1 ),
|
||||
cereal::make_nvp( name5, i_int5 ),
|
||||
i_int6 );
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(o_int1, i_int1);
|
||||
BOOST_CHECK_CLOSE(o_double2 , o_double2, 1e-5);
|
||||
BOOST_CHECK_EQUAL(o_vecbool3.size(), i_vecbool3.size());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_vecbool3.begin(), i_vecbool3.end(), o_vecbool3.begin(), o_vecbool3.end());
|
||||
BOOST_CHECK_EQUAL(o_int4, i_int4);
|
||||
BOOST_CHECK_EQUAL(o_int5, i_int5);
|
||||
BOOST_CHECK_EQUAL(o_int6, i_int6);
|
||||
BOOST_CHECK_EQUAL(o_un7.first, i_un7.first);
|
||||
BOOST_CHECK_EQUAL(o_un7.second, i_un7.second);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_unordered_loads )
|
||||
{
|
||||
test_unordered_loads<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_unordered_loads )
|
||||
{
|
||||
test_unordered_loads<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
115
unittests/unordered_map.cpp
Normal file
115
unittests/unordered_map.cpp
Normal file
@ -0,0 +1,115 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_unordered_map()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::unordered_map<std::string, int> o_podunordered_map;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_podunordered_map.insert({random_value<std::string>(gen), random_value<int>(gen)});
|
||||
|
||||
std::unordered_map<uint16_t, StructInternalSerialize> o_iserunordered_map;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_iserunordered_map.insert({random_value<uint16_t>(gen), { random_value<int>(gen), random_value<int>(gen) }});
|
||||
|
||||
std::unordered_map<uint16_t, StructInternalSplit> o_isplunordered_map;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_isplunordered_map.insert({random_value<uint16_t>(gen), { random_value<int>(gen), random_value<int>(gen) }});
|
||||
|
||||
std::unordered_map<uint32_t, StructExternalSerialize> o_eserunordered_map;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_eserunordered_map.insert({random_value<uint32_t>(gen), { random_value<int>(gen), random_value<int>(gen) }});
|
||||
|
||||
std::unordered_map<int8_t, StructExternalSplit> o_esplunordered_map;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_esplunordered_map.insert({random_value<char>(gen), { random_value<int>(gen), random_value<int>(gen) }});
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podunordered_map);
|
||||
oar(o_iserunordered_map);
|
||||
oar(o_isplunordered_map);
|
||||
oar(o_eserunordered_map);
|
||||
oar(o_esplunordered_map);
|
||||
}
|
||||
|
||||
std::unordered_map<std::string, int> i_podunordered_map;
|
||||
std::unordered_map<uint16_t, StructInternalSerialize> i_iserunordered_map;
|
||||
std::unordered_map<uint16_t, StructInternalSplit> i_isplunordered_map;
|
||||
std::unordered_map<uint32_t, StructExternalSerialize> i_eserunordered_map;
|
||||
std::unordered_map<int8_t, StructExternalSplit> i_esplunordered_map;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podunordered_map);
|
||||
iar(i_iserunordered_map);
|
||||
iar(i_isplunordered_map);
|
||||
iar(i_eserunordered_map);
|
||||
iar(i_esplunordered_map);
|
||||
}
|
||||
|
||||
for(auto const & p : i_podunordered_map)
|
||||
{
|
||||
auto v = o_podunordered_map.find(p.first);
|
||||
BOOST_CHECK(v != o_podunordered_map.end());
|
||||
BOOST_CHECK_EQUAL(p.second, v->second);
|
||||
}
|
||||
|
||||
for(auto const & p : i_iserunordered_map)
|
||||
{
|
||||
auto v = o_iserunordered_map.find(p.first);
|
||||
BOOST_CHECK(v != o_iserunordered_map.end());
|
||||
BOOST_CHECK_EQUAL(p.second, v->second);
|
||||
}
|
||||
|
||||
for(auto const & p : i_isplunordered_map)
|
||||
{
|
||||
auto v = o_isplunordered_map.find(p.first);
|
||||
BOOST_CHECK(v != o_isplunordered_map.end());
|
||||
BOOST_CHECK_EQUAL(p.second, v->second);
|
||||
}
|
||||
|
||||
for(auto const & p : i_eserunordered_map)
|
||||
{
|
||||
auto v = o_eserunordered_map.find(p.first);
|
||||
BOOST_CHECK(v != o_eserunordered_map.end());
|
||||
BOOST_CHECK_EQUAL(p.second, v->second);
|
||||
}
|
||||
|
||||
for(auto const & p : i_esplunordered_map)
|
||||
{
|
||||
auto v = o_esplunordered_map.find(p.first);
|
||||
BOOST_CHECK(v != o_esplunordered_map.end());
|
||||
BOOST_CHECK_EQUAL(p.second, v->second);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_unordered_map )
|
||||
{
|
||||
test_unordered_map<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_unordered_map )
|
||||
{
|
||||
test_unordered_map<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_unordered_map )
|
||||
{
|
||||
test_unordered_map<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_unordered_map )
|
||||
{
|
||||
test_unordered_map<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
145
unittests/unordered_multimap.cpp
Normal file
145
unittests/unordered_multimap.cpp
Normal file
@ -0,0 +1,145 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_unordered_multimap()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::unordered_multimap<std::string, int> o_podunordered_multimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<std::string>(gen);
|
||||
o_podunordered_multimap.insert({key, random_value<int>(gen)});
|
||||
o_podunordered_multimap.insert({key, random_value<int>(gen)});
|
||||
}
|
||||
|
||||
std::unordered_multimap<int, StructInternalSerialize> o_iserunordered_multimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<int>(gen);
|
||||
o_iserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
o_iserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
}
|
||||
|
||||
std::unordered_multimap<int, StructInternalSplit> o_isplunordered_multimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<int>(gen);
|
||||
o_isplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
o_isplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
}
|
||||
|
||||
std::unordered_multimap<uint32_t, StructExternalSerialize> o_eserunordered_multimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<uint32_t>(gen);
|
||||
o_eserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
o_eserunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
}
|
||||
|
||||
std::unordered_multimap<int8_t, StructExternalSplit> o_esplunordered_multimap;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
auto key = random_value<char>(gen);
|
||||
o_esplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
o_esplunordered_multimap.insert({key, { random_value<int>(gen), random_value<int>(gen) }});
|
||||
}
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podunordered_multimap);
|
||||
oar(o_iserunordered_multimap);
|
||||
oar(o_isplunordered_multimap);
|
||||
oar(o_eserunordered_multimap);
|
||||
oar(o_esplunordered_multimap);
|
||||
}
|
||||
|
||||
std::unordered_multimap<std::string, int> i_podunordered_multimap;
|
||||
std::unordered_multimap<int, StructInternalSerialize> i_iserunordered_multimap;
|
||||
std::unordered_multimap<int, StructInternalSplit> i_isplunordered_multimap;
|
||||
std::unordered_multimap<uint32_t, StructExternalSerialize> i_eserunordered_multimap;
|
||||
std::unordered_multimap<int8_t, StructExternalSplit> i_esplunordered_multimap;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podunordered_multimap);
|
||||
iar(i_iserunordered_multimap);
|
||||
iar(i_isplunordered_multimap);
|
||||
iar(i_eserunordered_multimap);
|
||||
iar(i_esplunordered_multimap);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(i_podunordered_multimap.size(), o_podunordered_multimap.size());
|
||||
BOOST_CHECK_EQUAL(i_iserunordered_multimap.size(), o_iserunordered_multimap.size());
|
||||
BOOST_CHECK_EQUAL(i_isplunordered_multimap.size(), o_isplunordered_multimap.size());
|
||||
BOOST_CHECK_EQUAL(i_eserunordered_multimap.size(), o_eserunordered_multimap.size());
|
||||
BOOST_CHECK_EQUAL(i_esplunordered_multimap.size(), o_esplunordered_multimap.size());
|
||||
|
||||
for(auto const & p : i_podunordered_multimap)
|
||||
{
|
||||
size_t const bucket = o_podunordered_multimap.bucket(p.first);
|
||||
auto bucket_begin = o_podunordered_multimap.begin(bucket);
|
||||
auto bucket_end = o_podunordered_multimap.end(bucket);
|
||||
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
|
||||
}
|
||||
|
||||
for(auto const & p : i_iserunordered_multimap)
|
||||
{
|
||||
size_t const bucket = o_iserunordered_multimap.bucket(p.first);
|
||||
auto bucket_begin = o_iserunordered_multimap.begin(bucket);
|
||||
auto bucket_end = o_iserunordered_multimap.end(bucket);
|
||||
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
|
||||
}
|
||||
|
||||
for(auto const & p : i_isplunordered_multimap)
|
||||
{
|
||||
size_t const bucket = o_isplunordered_multimap.bucket(p.first);
|
||||
auto bucket_begin = o_isplunordered_multimap.begin(bucket);
|
||||
auto bucket_end = o_isplunordered_multimap.end(bucket);
|
||||
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
|
||||
}
|
||||
|
||||
for(auto const & p : i_eserunordered_multimap)
|
||||
{
|
||||
size_t const bucket = o_eserunordered_multimap.bucket(p.first);
|
||||
auto bucket_begin = o_eserunordered_multimap.begin(bucket);
|
||||
auto bucket_end = o_eserunordered_multimap.end(bucket);
|
||||
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
|
||||
}
|
||||
|
||||
for(auto const & p : i_esplunordered_multimap)
|
||||
{
|
||||
size_t const bucket = o_esplunordered_multimap.bucket(p.first);
|
||||
auto bucket_begin = o_esplunordered_multimap.begin(bucket);
|
||||
auto bucket_end = o_esplunordered_multimap.end(bucket);
|
||||
BOOST_CHECK(std::find(bucket_begin, bucket_end, p) != bucket_end);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_unordered_multimap )
|
||||
{
|
||||
test_unordered_multimap<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_unordered_multimap )
|
||||
{
|
||||
test_unordered_multimap<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_unordered_multimap )
|
||||
{
|
||||
test_unordered_multimap<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_unordered_multimap )
|
||||
{
|
||||
test_unordered_multimap<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
125
unittests/unordered_multiset.cpp
Normal file
125
unittests/unordered_multiset.cpp
Normal file
@ -0,0 +1,125 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_unordered_multiset()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::unordered_multiset<int> o_podunordered_multiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
int value = random_value<int>(gen);
|
||||
o_podunordered_multiset.insert(value);
|
||||
o_podunordered_multiset.insert(value);
|
||||
}
|
||||
|
||||
std::unordered_multiset<StructInternalSerialize, StructHash<StructInternalSerialize>> o_iserunordered_multiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
StructInternalSerialize value = { random_value<int>(gen), random_value<int>(gen) };
|
||||
o_iserunordered_multiset.insert(value);
|
||||
o_iserunordered_multiset.insert(value);
|
||||
}
|
||||
|
||||
std::unordered_multiset<StructInternalSplit, StructHash<StructInternalSplit>> o_isplunordered_multiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
StructInternalSplit value = { random_value<int>(gen), random_value<int>(gen) };
|
||||
o_isplunordered_multiset.insert(value);
|
||||
o_isplunordered_multiset.insert(value);
|
||||
}
|
||||
|
||||
std::unordered_multiset<StructExternalSerialize, StructHash<StructExternalSerialize>> o_eserunordered_multiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
StructExternalSerialize value = { random_value<int>(gen), random_value<int>(gen) };
|
||||
o_eserunordered_multiset.insert(value);
|
||||
o_eserunordered_multiset.insert(value);
|
||||
}
|
||||
|
||||
std::unordered_multiset<StructExternalSplit, StructHash<StructExternalSplit>> o_esplunordered_multiset;
|
||||
for(int j=0; j<100; ++j)
|
||||
{
|
||||
StructExternalSplit value = { random_value<int>(gen), random_value<int>(gen) };
|
||||
o_esplunordered_multiset.insert(value);
|
||||
o_esplunordered_multiset.insert(value);
|
||||
}
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podunordered_multiset);
|
||||
oar(o_iserunordered_multiset);
|
||||
oar(o_isplunordered_multiset);
|
||||
oar(o_eserunordered_multiset);
|
||||
oar(o_esplunordered_multiset);
|
||||
}
|
||||
|
||||
std::unordered_multiset<int> i_podunordered_multiset;
|
||||
std::unordered_multiset<StructInternalSerialize, StructHash<StructInternalSerialize>> i_iserunordered_multiset;
|
||||
std::unordered_multiset<StructInternalSplit, StructHash<StructInternalSplit>> i_isplunordered_multiset;
|
||||
std::unordered_multiset<StructExternalSerialize, StructHash<StructExternalSerialize>> i_eserunordered_multiset;
|
||||
std::unordered_multiset<StructExternalSplit, StructHash<StructExternalSplit>> i_esplunordered_multiset;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podunordered_multiset);
|
||||
iar(i_iserunordered_multiset);
|
||||
iar(i_isplunordered_multiset);
|
||||
iar(i_eserunordered_multiset);
|
||||
iar(i_esplunordered_multiset);
|
||||
}
|
||||
|
||||
for(auto const & p : i_podunordered_multiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_podunordered_multiset.count(p), i_podunordered_multiset.count(p));
|
||||
}
|
||||
|
||||
for(auto const & p : i_iserunordered_multiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_iserunordered_multiset.count(p), i_iserunordered_multiset.count(p));
|
||||
}
|
||||
|
||||
for(auto const & p : i_isplunordered_multiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_isplunordered_multiset.count(p), i_isplunordered_multiset.count(p));
|
||||
}
|
||||
|
||||
for(auto const & p : i_eserunordered_multiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_eserunordered_multiset.count(p), i_eserunordered_multiset.count(p));
|
||||
}
|
||||
|
||||
for(auto const & p : i_esplunordered_multiset)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_esplunordered_multiset.count(p), i_esplunordered_multiset.count(p));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_unordered_multiset )
|
||||
{
|
||||
test_unordered_multiset<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_unordered_multiset )
|
||||
{
|
||||
test_unordered_multiset<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_unordered_multiset )
|
||||
{
|
||||
test_unordered_multiset<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_unordered_multiset )
|
||||
{
|
||||
test_unordered_multiset<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
106
unittests/unordered_set.cpp
Normal file
106
unittests/unordered_set.cpp
Normal file
@ -0,0 +1,106 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_unordered_set()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::unordered_set<int> o_podunordered_set;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_podunordered_set.insert(random_value<int>(gen));
|
||||
|
||||
std::unordered_set<StructInternalSerialize, StructHash<StructInternalSerialize>> o_iserunordered_set;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_iserunordered_set.insert({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::unordered_set<StructInternalSplit, StructHash<StructInternalSplit>> o_isplunordered_set;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_isplunordered_set.insert({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::unordered_set<StructExternalSerialize, StructHash<StructExternalSerialize>> o_eserunordered_set;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_eserunordered_set.insert({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::unordered_set<StructExternalSplit, StructHash<StructExternalSplit>> o_esplunordered_set;
|
||||
for(int j=0; j<100; ++j)
|
||||
o_esplunordered_set.insert({ random_value<int>(gen), random_value<int>(gen) });
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podunordered_set);
|
||||
oar(o_iserunordered_set);
|
||||
oar(o_isplunordered_set);
|
||||
oar(o_eserunordered_set);
|
||||
oar(o_esplunordered_set);
|
||||
}
|
||||
|
||||
std::unordered_set<int> i_podunordered_set;
|
||||
std::unordered_set<StructInternalSerialize, StructHash<StructInternalSerialize>> i_iserunordered_set;
|
||||
std::unordered_set<StructInternalSplit, StructHash<StructInternalSplit>> i_isplunordered_set;
|
||||
std::unordered_set<StructExternalSerialize, StructHash<StructExternalSerialize>> i_eserunordered_set;
|
||||
std::unordered_set<StructExternalSplit, StructHash<StructExternalSplit>> i_esplunordered_set;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podunordered_set);
|
||||
iar(i_iserunordered_set);
|
||||
iar(i_isplunordered_set);
|
||||
iar(i_eserunordered_set);
|
||||
iar(i_esplunordered_set);
|
||||
}
|
||||
|
||||
for(auto const & p : i_podunordered_set)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_podunordered_set.count(p), 1);
|
||||
}
|
||||
|
||||
for(auto const & p : i_iserunordered_set)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_iserunordered_set.count(p), 1);
|
||||
}
|
||||
|
||||
for(auto const & p : i_isplunordered_set)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_isplunordered_set.count(p), 1);
|
||||
}
|
||||
|
||||
for(auto const & p : i_eserunordered_set)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_eserunordered_set.count(p), 1);
|
||||
}
|
||||
|
||||
for(auto const & p : i_esplunordered_set)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(o_esplunordered_set.count(p), 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_unordered_set )
|
||||
{
|
||||
test_unordered_set<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_unordered_set )
|
||||
{
|
||||
test_unordered_set<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_unordered_set )
|
||||
{
|
||||
test_unordered_set<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_unordered_set )
|
||||
{
|
||||
test_unordered_set<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
|
||||
102
unittests/vector.cpp
Normal file
102
unittests/vector.cpp
Normal file
@ -0,0 +1,102 @@
|
||||
#include "common.hpp"
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_vector()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(int ii=0; ii<100; ++ii)
|
||||
{
|
||||
std::vector<int> o_podvector(100);
|
||||
for(auto & elem : o_podvector)
|
||||
elem = random_value<int>(gen);
|
||||
|
||||
std::vector<bool> o_boolvector; o_boolvector.reserve(100);
|
||||
for( size_t i = 0; i < 100; ++i )
|
||||
o_boolvector[i] = (random_value<int>(gen) % 2) == 0;
|
||||
|
||||
std::vector<StructInternalSerialize> o_iservector(100);
|
||||
for(auto & elem : o_iservector)
|
||||
elem = StructInternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::vector<StructInternalSplit> o_isplvector(100);
|
||||
for(auto & elem : o_isplvector)
|
||||
elem = StructInternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::vector<StructExternalSerialize> o_eservector(100);
|
||||
for(auto & elem : o_eservector)
|
||||
elem = StructExternalSerialize( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::vector<StructExternalSplit> o_esplvector(100);
|
||||
for(auto & elem : o_esplvector)
|
||||
elem = StructExternalSplit( random_value<int>(gen), random_value<int>(gen) );
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
|
||||
oar(o_podvector);
|
||||
oar(o_boolvector);
|
||||
oar(o_iservector);
|
||||
oar(o_isplvector);
|
||||
oar(o_eservector);
|
||||
oar(o_esplvector);
|
||||
}
|
||||
|
||||
std::vector<int> i_podvector;
|
||||
std::vector<bool> i_boolvector;
|
||||
std::vector<StructInternalSerialize> i_iservector;
|
||||
std::vector<StructInternalSplit> i_isplvector;
|
||||
std::vector<StructExternalSerialize> i_eservector;
|
||||
std::vector<StructExternalSplit> i_esplvector;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
|
||||
iar(i_podvector);
|
||||
iar(i_boolvector);
|
||||
iar(i_iservector);
|
||||
iar(i_isplvector);
|
||||
iar(i_eservector);
|
||||
iar(i_esplvector);
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(i_podvector.size(), o_podvector.size());
|
||||
BOOST_CHECK_EQUAL(i_boolvector.size(), o_boolvector.size());
|
||||
BOOST_CHECK_EQUAL(i_iservector.size(), o_iservector.size());
|
||||
BOOST_CHECK_EQUAL(i_isplvector.size(), o_isplvector.size());
|
||||
BOOST_CHECK_EQUAL(i_eservector.size(), o_eservector.size());
|
||||
BOOST_CHECK_EQUAL(i_esplvector.size(), o_esplvector.size());
|
||||
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_podvector.begin(), i_podvector.end(), o_podvector.begin(), o_podvector.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_boolvector.begin(), i_boolvector.end(), o_boolvector.begin(), o_boolvector.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_iservector.begin(), i_iservector.end(), o_iservector.begin(), o_iservector.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_isplvector.begin(), i_isplvector.end(), o_isplvector.begin(), o_isplvector.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_eservector.begin(), i_eservector.end(), o_eservector.begin(), o_eservector.end());
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(i_esplvector.begin(), i_esplvector.end(), o_esplvector.begin(), o_esplvector.end());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_vector )
|
||||
{
|
||||
test_vector<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_vector )
|
||||
{
|
||||
test_vector<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_vector )
|
||||
{
|
||||
test_vector<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_vector )
|
||||
{
|
||||
test_vector<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
|
||||
164
unittests/versioning.cpp
Normal file
164
unittests/versioning.cpp
Normal file
@ -0,0 +1,164 @@
|
||||
#include "common.hpp"
|
||||
|
||||
class VersionStructMS
|
||||
{
|
||||
public:
|
||||
bool x;
|
||||
std::uint32_t v;
|
||||
|
||||
private:
|
||||
friend class cereal::access;
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar, std::uint32_t const version )
|
||||
{
|
||||
ar( x );
|
||||
v = version;
|
||||
}
|
||||
};
|
||||
|
||||
struct VersionStructMSP
|
||||
{
|
||||
uint8_t x;
|
||||
std::uint32_t v;
|
||||
template <class Archive>
|
||||
void save( Archive & ar, std::uint32_t const /*version*/ ) const
|
||||
{
|
||||
ar( x );
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void load( Archive & ar, std::uint32_t const version )
|
||||
{
|
||||
ar( x );
|
||||
v = version;
|
||||
}
|
||||
};
|
||||
|
||||
struct VersionStructNMS
|
||||
{
|
||||
std::int32_t x;
|
||||
std::uint32_t v;
|
||||
};
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar, VersionStructNMS & vnms, const std::uint32_t version )
|
||||
{
|
||||
ar( vnms.x );
|
||||
vnms.v = version;
|
||||
}
|
||||
|
||||
struct VersionStructNMSP
|
||||
{
|
||||
double x;
|
||||
std::uint32_t v;
|
||||
};
|
||||
|
||||
template <class Archive>
|
||||
void save( Archive & ar, VersionStructNMSP const & vnms, const std::uint32_t /*version*/ )
|
||||
{
|
||||
ar( vnms.x );
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void load( Archive & ar, VersionStructNMSP & vnms, const std::uint32_t version )
|
||||
{
|
||||
ar( vnms.x );
|
||||
vnms.v = version;
|
||||
}
|
||||
|
||||
CEREAL_CLASS_VERSION( VersionStructMSP, 33 )
|
||||
CEREAL_CLASS_VERSION( VersionStructNMS, 66 )
|
||||
CEREAL_CLASS_VERSION( VersionStructNMSP, 99 )
|
||||
|
||||
template <class IArchive, class OArchive>
|
||||
void test_versioning()
|
||||
{
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
|
||||
for(size_t i=0; i<100; ++i)
|
||||
{
|
||||
VersionStructMS o_MS = {random_value<uint8_t>(gen) % 2 ? true : false, 1};
|
||||
VersionStructMSP o_MSP = {random_value<uint8_t>(gen), 1};
|
||||
VersionStructNMS o_NMS = {random_value<int32_t>(gen), 1};
|
||||
VersionStructNMSP o_NMSP = {random_value<double>(gen), 1};
|
||||
VersionStructMS o_MS2 = {random_value<uint8_t>(gen) % 2 ? true : false, 1};
|
||||
VersionStructMSP o_MSP2 = {random_value<uint8_t>(gen), 1};
|
||||
VersionStructNMS o_NMS2 = {random_value<int32_t>(gen), 1};
|
||||
VersionStructNMSP o_NMSP2 = {random_value<double>(gen), 1};
|
||||
|
||||
std::ostringstream os;
|
||||
{
|
||||
OArchive oar(os);
|
||||
oar( o_MS );
|
||||
oar( o_MSP );
|
||||
oar( o_NMS );
|
||||
oar( o_NMSP );
|
||||
oar( o_MS2 );
|
||||
oar( o_MSP2 );
|
||||
oar( o_NMS2 );
|
||||
oar( o_NMSP2 );
|
||||
}
|
||||
|
||||
decltype(o_MS) i_MS;
|
||||
decltype(o_MSP) i_MSP;
|
||||
decltype(o_NMS) i_NMS;
|
||||
decltype(o_NMSP) i_NMSP;
|
||||
decltype(o_MS2) i_MS2;
|
||||
decltype(o_MSP2) i_MSP2;
|
||||
decltype(o_NMS2) i_NMS2;
|
||||
decltype(o_NMSP2) i_NMSP2;
|
||||
|
||||
std::istringstream is(os.str());
|
||||
{
|
||||
IArchive iar(is);
|
||||
iar( i_MS );
|
||||
iar( i_MSP );
|
||||
iar( i_NMS );
|
||||
iar( i_NMSP );
|
||||
iar( i_MS2 );
|
||||
iar( i_MSP2 );
|
||||
iar( i_NMS2 );
|
||||
iar( i_NMSP2 );
|
||||
}
|
||||
|
||||
BOOST_CHECK_EQUAL(o_MS.x, i_MS.x);
|
||||
BOOST_CHECK_EQUAL(i_MS.v, 0);
|
||||
BOOST_CHECK_EQUAL(o_MSP.x, i_MSP.x);
|
||||
BOOST_CHECK_EQUAL(i_MSP.v, 33);
|
||||
BOOST_CHECK_EQUAL(o_NMS.x, i_NMS.x);
|
||||
BOOST_CHECK_EQUAL(i_NMS.v, 66);
|
||||
BOOST_CHECK_CLOSE(o_NMSP.x, i_NMSP.x, 1e-5);
|
||||
BOOST_CHECK_EQUAL(i_NMSP.v, 99);
|
||||
|
||||
BOOST_CHECK_EQUAL(o_MS2.x, i_MS2.x);
|
||||
BOOST_CHECK_EQUAL(i_MS2.v, 0);
|
||||
BOOST_CHECK_EQUAL(o_MSP2.x, i_MSP2.x);
|
||||
BOOST_CHECK_EQUAL(i_MSP2.v, 33);
|
||||
BOOST_CHECK_EQUAL(o_NMS2.x, i_NMS2.x);
|
||||
BOOST_CHECK_EQUAL(i_NMS2.v, 66);
|
||||
BOOST_CHECK_CLOSE(o_NMSP2.x, i_NMSP2.x, 1e-5);
|
||||
BOOST_CHECK_EQUAL(i_NMSP2.v, 99);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( binary_versioning )
|
||||
{
|
||||
test_versioning<cereal::BinaryInputArchive, cereal::BinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( portable_binary_versioning )
|
||||
{
|
||||
test_versioning<cereal::PortableBinaryInputArchive, cereal::PortableBinaryOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( xml_versioning )
|
||||
{
|
||||
test_versioning<cereal::XMLInputArchive, cereal::XMLOutputArchive>();
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( json_versioning )
|
||||
{
|
||||
test_versioning<cereal::JSONInputArchive, cereal::JSONOutputArchive>();
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user