From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:45:59 +0200 Subject: Adding upstream version 16.2.11+ds. Signed-off-by: Daniel Baumann --- src/boost/libs/serialization/test/test_variant.cpp | 299 +++++++++++++++++++++ 1 file changed, 299 insertions(+) create mode 100644 src/boost/libs/serialization/test/test_variant.cpp (limited to 'src/boost/libs/serialization/test/test_variant.cpp') diff --git a/src/boost/libs/serialization/test/test_variant.cpp b/src/boost/libs/serialization/test/test_variant.cpp new file mode 100644 index 000000000..dcf91d13c --- /dev/null +++ b/src/boost/libs/serialization/test/test_variant.cpp @@ -0,0 +1,299 @@ +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// test_variant.cpp +// test of non-intrusive serialization of variant types +// +// copyright (c) 2005 +// troy d. straszheim +// http://www.resophonic.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) +// +// See http://www.boost.org for updates, documentation, and revision history. +// +// thanks to Robert Ramey and Peter Dimov. +// + +#include // NULL +#include // remove +#include +#include +#include // float_distance +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::remove; +} +#endif + +#include +#include +#include +#include + +#if defined(_MSC_VER) && (_MSC_VER <= 1020) +# pragma warning (disable : 4786) // too long name, harmless warning +#endif + +#include "test_tools.hpp" + +#include + +#include +#include + +#include "A.hpp" +#include "A.ipp" + +class are_equal + : public boost::static_visitor +{ +public: + // note extra rigamorole for compilers which don't support + // partial function template ordering - specfically msvc 6.x + struct same { + template + static bool invoke(const T & t, const U & u){ + return t == u; + } + }; + + struct not_same { + template + static bool invoke(const T &, const U &){ + return false; + } + }; + + template + bool operator()( const T & t, const U & u) const + { + typedef typename boost::mpl::eval_if, + boost::mpl::identity, + boost::mpl::identity + >::type type; + return type::invoke(t, u); + } + + bool operator()( const float & lhs, const float & rhs ) const + { + return std::abs( boost::math::float_distance(lhs, rhs)) < 2; + } + bool operator()( const double & lhs, const double & rhs ) const + { + return std::abs( boost::math::float_distance(lhs, rhs)) < 2; + } +}; + +template +void test_type(const T& gets_written){ + const char * testfile = boost::archive::tmpnam(NULL); + BOOST_REQUIRE(testfile != NULL); + { + test_ostream os(testfile, TEST_STREAM_FLAGS); + test_oarchive oa(os, TEST_ARCHIVE_FLAGS); + oa << boost::serialization::make_nvp("written", gets_written); + } + + T got_read; + { + test_istream is(testfile, TEST_STREAM_FLAGS); + test_iarchive ia(is, TEST_ARCHIVE_FLAGS); + ia >> boost::serialization::make_nvp("written", got_read); + } + BOOST_CHECK(boost::apply_visitor(are_equal(), gets_written, got_read)); + + std::remove(testfile); +} + +// this verifies that if you try to read in a variant from a file +// whose "which" is illegal for the one in memory (that is, you're +// reading in to a different variant than you wrote out to) the load() +// operation will throw. One could concievably add checking for +// sequence length as well, but this would add size to the archive for +// dubious benefit. +// +void do_bad_read() +{ + // Compiling this test invokes and ICE on msvc 6 + // So, we'll just to skip it for this compiler + #if defined(_MSC_VER) && (_MSC_VER <= 1020) + boost::variant big_variant; + big_variant = std::string("adrenochrome"); + + const char * testfile = boost::archive::tmpnam(NULL); + BOOST_REQUIRE(testfile != NULL); + { + test_ostream os(testfile, TEST_STREAM_FLAGS); + test_oarchive oa(os, TEST_ARCHIVE_FLAGS); + oa << BOOST_SERIALIZATION_NVP(big_variant); + } + boost::variant little_variant; + { + test_istream is(testfile, TEST_STREAM_FLAGS); + test_iarchive ia(is, TEST_ARCHIVE_FLAGS); + bool exception_invoked = false; + BOOST_TRY { + ia >> BOOST_SERIALIZATION_NVP(little_variant); + } BOOST_CATCH (boost::archive::archive_exception const& e) { + BOOST_CHECK(boost::archive::archive_exception::unsupported_version == e.code); + exception_invoked = true; + } + BOOST_CATCH_END + BOOST_CHECK(exception_invoked); + } + #endif +} + +struct H { + int i; +}; + +namespace boost { +namespace serialization { + +template +void serialize(Archive &ar, H & h, const unsigned int /*file_version*/){ + ar & boost::serialization::make_nvp("h", h.i); +} + +} // namespace serialization +} // namespace boost + +inline bool operator==(H const & lhs, H const & rhs) { + return lhs.i == rhs.i; +} + +inline bool operator!=(H const & lhs, H const & rhs) { + return !(lhs == rhs); +} + +inline bool operator<(H const & lhs, H const & rhs) { + return lhs.i < rhs.i; +} + +inline std::size_t hash_value(H const & val) { + return val.i; +} + +void test_pointer(){ + const char * testfile = boost::archive::tmpnam(NULL); + BOOST_REQUIRE(testfile != NULL); + typedef boost::variant variant_t; + H const h = {5}; + variant_t v(h); + { + test_ostream os(testfile, TEST_STREAM_FLAGS); + test_oarchive oa(os, TEST_ARCHIVE_FLAGS); + oa << boost::serialization::make_nvp("written", v); + const H * h_ptr = & boost::strict_get(v); + oa << boost::serialization::make_nvp("written", h_ptr); + } + variant_t v2; + { + test_istream is(testfile, TEST_STREAM_FLAGS); + test_iarchive ia(is, TEST_ARCHIVE_FLAGS); + ia >> boost::serialization::make_nvp("written", v2); + H * h2_ptr; + ia >> boost::serialization::make_nvp("written", h2_ptr); + BOOST_CHECK_EQUAL(h, boost::strict_get(v2)); + BOOST_CHECK_EQUAL(h2_ptr, & boost::strict_get(v2)); + } + BOOST_CHECK_EQUAL(v, v2); +} + +#include +#include + +// test a pointer to an object contained into a variant that is an +// element of a set +void test_variant_set() +{ + const char * testfile = boost::archive::tmpnam(NULL); + BOOST_REQUIRE(testfile != NULL); + typedef boost::variant variant_t; + typedef std::set uset_t; + uset_t set; + { + test_ostream os(testfile, TEST_STREAM_FLAGS); + test_oarchive oa(os, TEST_ARCHIVE_FLAGS); + H const h = {5}; + variant_t v(h); + set.insert(v); + oa << boost::serialization::make_nvp("written", set); + H const * const h_ptr = boost::strict_get(&(*set.begin())); + oa << boost::serialization::make_nvp("written", h_ptr); + } + uset_t set2; + { + test_istream is(testfile, TEST_STREAM_FLAGS); + test_iarchive ia(is, TEST_ARCHIVE_FLAGS); + ia >> boost::serialization::make_nvp("written", set2); + H * h_ptr; + ia >> boost::serialization::make_nvp("written", h_ptr); + const H * h_ptr2 = & boost::strict_get(*set2.begin()); + BOOST_CHECK_EQUAL(h_ptr, h_ptr2); + } + BOOST_CHECK_EQUAL(set, set2); +} + +// test a pointer to an object contained into a variant that is an +// element of a map +void test_variant_map() +{ + const char * testfile = boost::archive::tmpnam(NULL); + BOOST_REQUIRE(testfile != NULL); + typedef boost::variant variant_t; + typedef std::map map_t; + map_t map; + { + test_ostream os(testfile, TEST_STREAM_FLAGS); + test_oarchive oa(os, TEST_ARCHIVE_FLAGS); + H const h = {5}; + variant_t v(h); + map[0] = v; + BOOST_ASSERT(1 == map.size()); + oa << boost::serialization::make_nvp("written", map); + H const * const h_ptr = boost::strict_get(&map[0]); + BOOST_CHECK_EQUAL(h_ptr, boost::strict_get(&map[0])); + oa << boost::serialization::make_nvp("written", h_ptr); + } + map_t map2; + { + test_istream is(testfile, TEST_STREAM_FLAGS); + test_iarchive ia(is, TEST_ARCHIVE_FLAGS); + ia >> boost::serialization::make_nvp("written", map2); + BOOST_ASSERT(1 == map2.size()); + H * h_ptr; + ia >> boost::serialization::make_nvp("written", h_ptr); + H const * const h_ptr2 = boost::strict_get(&map2[0]); + BOOST_CHECK_EQUAL(h_ptr, h_ptr2); + } + BOOST_CHECK_EQUAL(map, map2); +} + +int test_main( int /* argc */, char* /* argv */[] ) +{ + { + boost::variant v; + v = false; + test_type(v); + v = 1; + test_type(v); + v = (float) 2.3; + test_type(v); + v = (double) 6.4; + test_type(v); + v = std::string("we can't stop here, this is Bat Country"); + test_type(v); + v = A(); + test_type(v); + } + test_pointer(); + test_variant_set(); + test_variant_map(); + do_bad_read(); + return EXIT_SUCCESS; +} + +// EOF -- cgit v1.2.3