diff options
Diffstat (limited to 'src/boost/libs/fusion/test/sequence/fixture.hpp')
| -rw-r--r-- | src/boost/libs/fusion/test/sequence/fixture.hpp | 216 |
1 files changed, 216 insertions, 0 deletions
diff --git a/src/boost/libs/fusion/test/sequence/fixture.hpp b/src/boost/libs/fusion/test/sequence/fixture.hpp new file mode 100644 index 000000000..4cb05971e --- /dev/null +++ b/src/boost/libs/fusion/test/sequence/fixture.hpp @@ -0,0 +1,216 @@ +/*============================================================================= + Copyright (c) 2016 Lee Clagett + + Distributed under 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) +==============================================================================*/ + +#include <boost/fusion/sequence/comparison.hpp> +#include <boost/mpl/identity.hpp> + +namespace test_detail +{ + struct convertible + { + convertible() : value_() {} + convertible(int value) : value_(value) {} + int value_; + }; + + bool operator==(convertible const& lhs, convertible const& rhs) + { + return lhs.value_ == rhs.value_; + } + + bool operator!=(convertible const& lhs, convertible const& rhs) + { + return lhs.value_ != rhs.value_; + } + + // Testing conversion at function call allows for testing mutable lvalue, + // const lvalue, and rvalue as the source. mpl::identity prevents deduction + template <typename T> + T implicit_construct(typename boost::mpl::identity<T>::type source) + { + return source; + } + + template <typename F, typename Source, typename Expected> + bool run(Source const& source, Expected const& expected) + { + return F()(source, expected); + } + + template <typename F, typename Source> + bool run(Source const& source) + { + return run<F>(source, source); + } + + template <typename T> + struct can_rvalue_implicit_construct + { + template<typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + return expected == implicit_construct<T>(implicit_construct<Source>(source)); + } + }; + + template <typename T> + struct can_lvalue_implicit_construct + { + template <typename Source, typename Expected> + bool operator()(Source source, Expected const& expected) const + { + return expected == implicit_construct<T>(source); + } + }; + + template <typename T> + struct can_const_lvalue_implicit_construct + { + template <typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + return expected == implicit_construct<T>(source); + } + }; + + template <typename T> + struct can_implicit_construct + { + template <typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + return + run< can_rvalue_implicit_construct<T> >(source, expected) && + run< can_lvalue_implicit_construct<T> >(source, expected) && + run< can_const_lvalue_implicit_construct<T> >(source, expected); + } + }; + + template <typename T> + struct can_rvalue_construct + { + template<typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + return expected == T(implicit_construct<Source>(source)); + } + }; + + template <typename T> + struct can_lvalue_construct + { + template <typename Source, typename Expected> + bool operator()(Source source, Expected const& expected) const + { + return expected == T(source); + } + }; + + template <typename T> + struct can_const_lvalue_construct + { + template <typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + return expected == T(source); + } + }; + + template <typename T> + struct can_construct + { + template <typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + return + run< can_rvalue_construct<T> >(source, expected) && + run< can_lvalue_construct<T> >(source, expected) && + run< can_const_lvalue_construct<T> >(source, expected); + } + }; + + template <typename T> + struct can_rvalue_assign + { + template <typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + bool result = true; + { + T seq; + result &= (seq == expected || seq != expected); + + seq = implicit_construct<Source>(source); + result &= (seq == expected); + } + return result; + } + }; + + template <typename T> + struct can_lvalue_assign + { + + template <typename Source, typename Expected> + bool operator()(Source source, Expected const& expected) const + { + bool result = true; + { + T seq; + result &= (seq == expected || seq != expected); + + seq = source; + result &= (seq == expected); + } + return result; + } + }; + + template <typename T> + struct can_const_lvalue_assign + { + template <typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + bool result = true; + { + T seq; + result &= (seq == expected || seq != expected); + + seq = source; + result &= (seq == expected); + } + return result; + } + }; + + template <typename T> + struct can_assign + { + template <typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + return + run< can_rvalue_assign<T> >(source, expected) && + run< can_lvalue_assign<T> >(source, expected) && + run< can_const_lvalue_assign<T> >(source, expected); + } + }; + + template <typename T> + struct can_copy + { + template <typename Source, typename Expected> + bool operator()(Source const& source, Expected const& expected) const + { + return + run< can_construct<T> >(source, expected) && + run< can_implicit_construct<T> >(source, expected) && + run< can_assign<T> >(source, expected); + } + }; +} // test_detail |