From 483eb2f56657e8e7f419ab1a4fab8dce9ade8609 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 20:24:20 +0200 Subject: Adding upstream version 14.2.21. Signed-off-by: Daniel Baumann --- .../libs/serialization/test/test_registered.cpp | 239 +++++++++++++++++++++ 1 file changed, 239 insertions(+) create mode 100644 src/boost/libs/serialization/test/test_registered.cpp (limited to 'src/boost/libs/serialization/test/test_registered.cpp') diff --git a/src/boost/libs/serialization/test/test_registered.cpp b/src/boost/libs/serialization/test/test_registered.cpp new file mode 100644 index 00000000..5a5ccdda --- /dev/null +++ b/src/boost/libs/serialization/test/test_registered.cpp @@ -0,0 +1,239 @@ +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// test_registered.cpp + +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// Use, modification and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// should pass compilation and execution + +#include // NULL +#include // remove +#include + +#include +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::remove; +} +#endif + +#include +#include "test_tools.hpp" + +#include +#include + +class polymorphic_base +{ + friend class boost::serialization::access; + template + void serialize(Archive & /* ar */, const unsigned int /* file_version */){ + } +public: + virtual ~polymorphic_base(){}; +}; + +class polymorphic_derived1 : public polymorphic_base +{ + friend class boost::serialization::access; + template + void serialize(Archive &ar, const unsigned int /* file_version */){ + ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(polymorphic_base); + } +}; + +class polymorphic_derived2 : public polymorphic_base +{ + friend class boost::serialization::access; + template + void serialize(Archive &ar, const unsigned int /* file_version */){ + ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(polymorphic_base); + } +}; + +// save derived polymorphic class +void save_derived(const char *testfile) +{ + test_ostream os(testfile, TEST_STREAM_FLAGS); + test_oarchive oa(os, TEST_ARCHIVE_FLAGS); + + polymorphic_derived1 *rd1 = new polymorphic_derived1; + polymorphic_derived2 *rd2 = new polymorphic_derived2; + + // registration IS necessary when serializing pointers of + // polymorphic classes + oa.register_type(static_cast(NULL)); + oa.register_type(static_cast(NULL)); + oa << BOOST_SERIALIZATION_NVP(rd1); + oa << BOOST_SERIALIZATION_NVP(rd2); + + // the above opereration registers the derived classes as a side + // effect. Hence, instances can now be correctly serialized through + // a base class pointer. + polymorphic_base *rb1 = rd1; + polymorphic_base *rb2 = rd2; + oa << BOOST_SERIALIZATION_NVP(rb1); + oa << BOOST_SERIALIZATION_NVP(rb2); + + delete rd1; + delete rd2; +} + +// save derived polymorphic class +void load_derived(const char *testfile) +{ + test_istream is(testfile, TEST_STREAM_FLAGS); + test_iarchive ia(is, TEST_ARCHIVE_FLAGS); + + polymorphic_derived1 *rd1 = NULL; + polymorphic_derived2 *rd2 = NULL; + + // registration IS necessary when serializing pointers of + // polymorphic classes + ia.register_type(static_cast(NULL)); + ia.register_type(static_cast(NULL)); + + ia >> BOOST_SERIALIZATION_NVP(rd1); + + const boost::serialization::extended_type_info * p1; + p1 = & boost::serialization::type_info_implementation + ::type::get_const_instance(); + + BOOST_CHECK(NULL != p1); + + const boost::serialization::extended_type_info * p2; + p2 = boost::serialization::type_info_implementation + ::type::get_const_instance().get_derived_extended_type_info(*rd1); + + BOOST_CHECK(NULL != p2); + + BOOST_CHECK_MESSAGE(p1 == p2, "restored pointer d1 not of correct type"); + + ia >> BOOST_SERIALIZATION_NVP(rd2); + + BOOST_CHECK_MESSAGE( + & boost::serialization::type_info_implementation + ::type::get_const_instance() + == + boost::serialization::type_info_implementation + ::type::get_const_instance().get_derived_extended_type_info(*rd2), + "restored pointer d2 not of correct type" + ); + + polymorphic_base *rb1 = NULL; + polymorphic_base *rb2 = NULL; + + // the above opereration registers the derived classes as a side + // effect. Hence, instances can now be correctly serialized through + // a base class pointer. + ia >> BOOST_SERIALIZATION_NVP(rb1); + + BOOST_CHECK_MESSAGE( + rb1 == dynamic_cast(rd1), + "serialized pointers not correctly restored" + ); + + p1 = & boost::serialization::type_info_implementation + ::type::get_const_instance(); + + BOOST_CHECK(NULL != p1); + + p2 = boost::serialization::type_info_implementation + ::type::get_const_instance().get_derived_extended_type_info(*rb1); + + BOOST_CHECK(NULL != p2); + + BOOST_CHECK_MESSAGE(p1 == p2, "restored pointer b1 not of correct type"); + + ia >> BOOST_SERIALIZATION_NVP(rb2); + + BOOST_CHECK_MESSAGE( + rb2 == dynamic_cast(rd2), + "serialized pointers not correctly restored" + ); + + BOOST_CHECK_MESSAGE( + & boost::serialization::type_info_implementation + ::type::get_const_instance() + == boost::serialization::type_info_implementation + ::type::get_const_instance().get_derived_extended_type_info(*rb2), + "restored pointer b2 not of correct type" + ); + + delete rb1; + delete rb2; +} + +// save registered polymorphic class +void save_registered(const char *testfile) +{ + test_ostream os(testfile, TEST_STREAM_FLAGS); + test_oarchive oa(os, TEST_ARCHIVE_FLAGS); + + polymorphic_base *rb1 = new polymorphic_derived1; + polymorphic_base *rb2 = new polymorphic_derived2; + + // registration (forward declaration) will permit correct serialization + // through a pointer to a base class + oa.register_type(static_cast(NULL)); + oa.register_type(static_cast(NULL)); + oa << BOOST_SERIALIZATION_NVP(rb1) << BOOST_SERIALIZATION_NVP(rb2); + + delete rb1; + delete rb2; +} + +// save registered polymorphic class +void load_registered(const char *testfile) +{ + test_istream is(testfile, TEST_STREAM_FLAGS); + test_iarchive ia(is, TEST_ARCHIVE_FLAGS); + + polymorphic_base *rb1 = NULL; + polymorphic_base *rb2 = NULL; + + // registration (forward declaration) will permit correct serialization + // through a pointer to a base class + ia.register_type(static_cast(NULL)); + ia.register_type(static_cast(NULL)); + ia >> BOOST_SERIALIZATION_NVP(rb1) >> BOOST_SERIALIZATION_NVP(rb2); + + BOOST_CHECK_MESSAGE( + & boost::serialization::type_info_implementation + ::type::get_const_instance() + == boost::serialization::type_info_implementation + ::type::get_const_instance().get_derived_extended_type_info(*rb1), + "restored pointer b1 not of correct type" + ); + + BOOST_CHECK_MESSAGE( + & boost::serialization::type_info_implementation + ::type::get_const_instance() + == boost::serialization::type_info_implementation + ::type::get_const_instance().get_derived_extended_type_info(*rb2), + "restored pointer b2 not of correct type" + ); + + delete rb1; + delete rb2; +} + +int +test_main( int /* argc */, char* /* argv */[] ) +{ + const char * testfile = boost::archive::tmpnam(NULL); + + BOOST_REQUIRE(NULL != testfile); + + save_derived(testfile); + load_derived(testfile); + save_registered(testfile); + load_registered(testfile); + + std::remove(testfile); + return EXIT_SUCCESS; +} + +// EOF -- cgit v1.2.3