diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
commit | 19fcec84d8d7d21e796c7624e521b60d28ee21ed (patch) | |
tree | 42d26aa27d1e3f7c0b8bd3fd14e7d7082f5008dc /src/boost/libs/serialization/test/test_variant.cpp | |
parent | Initial commit. (diff) | |
download | ceph-6d07fdb6bb33b1af39833b850bb6cf8af79fe293.tar.xz ceph-6d07fdb6bb33b1af39833b850bb6cf8af79fe293.zip |
Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/boost/libs/serialization/test/test_variant.cpp')
-rw-r--r-- | src/boost/libs/serialization/test/test_variant.cpp | 299 |
1 files changed, 299 insertions, 0 deletions
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 <troy@resophonic.com> +// 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 <cstddef> // NULL +#include <cstdio> // remove +#include <fstream> +#include <boost/config.hpp> +#include <boost/math/special_functions/next.hpp> // float_distance +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::remove; +} +#endif + +#include <boost/type_traits/is_same.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/serialization/throw_exception.hpp> + +#if defined(_MSC_VER) && (_MSC_VER <= 1020) +# pragma warning (disable : 4786) // too long name, harmless warning +#endif + +#include "test_tools.hpp" + +#include <boost/archive/archive_exception.hpp> + +#include <boost/serialization/nvp.hpp> +#include <boost/serialization/variant.hpp> + +#include "A.hpp" +#include "A.ipp" + +class are_equal + : public boost::static_visitor<bool> +{ +public: + // note extra rigamorole for compilers which don't support + // partial function template ordering - specfically msvc 6.x + struct same { + template<class T, class U> + static bool invoke(const T & t, const U & u){ + return t == u; + } + }; + + struct not_same { + template<class T, class U> + static bool invoke(const T &, const U &){ + return false; + } + }; + + template <class T, class U> + bool operator()( const T & t, const U & u) const + { + typedef typename boost::mpl::eval_if<boost::is_same<T, U>, + boost::mpl::identity<same>, + boost::mpl::identity<not_same> + >::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 <class T> +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<bool, float, int, std::string> 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<bool, float, int> 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<class Archive> +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<H, int> 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<H const &>(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<H const>(v2)); + BOOST_CHECK_EQUAL(h2_ptr, & boost::strict_get<H const &>(v2)); + } + BOOST_CHECK_EQUAL(v, v2); +} + +#include <boost/serialization/map.hpp> +#include <boost/serialization/set.hpp> + +// 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<H, int> variant_t; + typedef std::set<variant_t> 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<H const>(&(*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<H const>(*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<H, int> variant_t; + typedef std::map<int, variant_t> 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<H const>(&map[0]); + BOOST_CHECK_EQUAL(h_ptr, boost::strict_get<H const>(&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<H const>(&map2[0]); + BOOST_CHECK_EQUAL(h_ptr, h_ptr2); + } + BOOST_CHECK_EQUAL(map, map2); +} + +int test_main( int /* argc */, char* /* argv */[] ) +{ + { + boost::variant<bool, int, float, double, A, std::string> 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 |