diff options
Diffstat (limited to 'src/boost/libs/hof/test')
63 files changed, 7654 insertions, 0 deletions
diff --git a/src/boost/libs/hof/test/Jamfile.v2 b/src/boost/libs/hof/test/Jamfile.v2 new file mode 100644 index 000000000..198de5bd3 --- /dev/null +++ b/src/boost/libs/hof/test/Jamfile.v2 @@ -0,0 +1,31 @@ +#============================================================================= +# Copyright (c) 2017 Paul Fultz II +# Jamfile.v2 +# 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) +#============================================================================== +import testing ; +import ../../config/checks/config : requires ; + +project hof + : requirements [ requires cxx11_variadic_templates cxx11_constexpr ] + <include>../include/ + ; + +rule test_all +{ + local all_rules = ; + + for local fileb in [ glob *.cpp ] + { + all_rules += [ run $(fileb) + : # additional args + : # test-files + : # requirements + ] ; + } + + return $(all_rules) ; +} + +test-suite hof : [ test_all r ] : ; diff --git a/src/boost/libs/hof/test/alias.cpp b/src/boost/libs/hof/test/alias.cpp new file mode 100644 index 000000000..d6f94c2cd --- /dev/null +++ b/src/boost/libs/hof/test/alias.cpp @@ -0,0 +1,24 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + alias.cpp + 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/hof/alias.hpp> +#include "test.hpp" + +struct foo +{ + int i; + foo(int i_) : i(i_) + {} +}; + +BOOST_HOF_TEST_CASE() +{ + boost::hof::alias<int> ai = 5; + BOOST_HOF_TEST_CHECK(boost::hof::alias_value(ai) == 5); + boost::hof::alias_inherit<foo> af = foo{5}; + BOOST_HOF_TEST_CHECK(boost::hof::alias_value(af).i == 5); +} + diff --git a/src/boost/libs/hof/test/always.cpp b/src/boost/libs/hof/test/always.cpp new file mode 100644 index 000000000..8acb08a9f --- /dev/null +++ b/src/boost/libs/hof/test/always.cpp @@ -0,0 +1,65 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + always.cpp + 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/hof/always.hpp> +#include <boost/hof/function.hpp> +#include <memory> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + static const int ten = 10; + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::always(ten)(1,2,3,4,5) == 10); + BOOST_HOF_TEST_CHECK( boost::hof::always(ten)(1,2,3,4,5) == 10 ); + + int i = 10; + BOOST_HOF_TEST_CHECK( boost::hof::always(std::ref(i))(1,2,3,4,5) == 10 ); + BOOST_HOF_TEST_CHECK( &boost::hof::always(std::ref(i))(1,2,3,4,5) == &i ); + + boost::hof::always()(1, 2); + static_assert(std::is_same<decltype(boost::hof::always()(1, 2)), BOOST_HOF_ALWAYS_VOID_RETURN>::value, "Failed"); +} + +BOOST_HOF_TEST_CASE() +{ + int i = 10; + BOOST_HOF_TEST_CHECK( boost::hof::always_ref(i)(1,2,3,4,5) == 10 ); + BOOST_HOF_TEST_CHECK( &boost::hof::always_ref(i)(1,2,3,4,5) == &i ); +} + +BOOST_HOF_STATIC_FUNCTION(gten) = boost::hof::always(std::integral_constant<int, 10>{}); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(gten(1,2,3,4,5) == 10); + BOOST_HOF_TEST_CHECK(gten(1,2,3,4,5) == 10); +} + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::always(10); + STATIC_ASSERT_NOT_DEFAULT_CONSTRUCTIBLE(decltype(f)); + BOOST_HOF_TEST_CHECK(f(1,2,3,4,5) == 10); +} + +struct copy_throws +{ + copy_throws() {} + copy_throws(copy_throws const&) {} + copy_throws(copy_throws&&) noexcept {} +}; + +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::always()()), "noexcept always"); + static_assert(noexcept(boost::hof::always(1)()), "noexcept always"); + static_assert(!noexcept(boost::hof::always(copy_throws{})()), "noexcept always"); + copy_throws ct{}; + static_assert(!noexcept(boost::hof::always(ct)()), "noexcept always"); + static_assert(noexcept(boost::hof::always(std::ref(ct))()) == BOOST_HOF_IS_NOTHROW_COPY_CONSTRUCTIBLE(std::reference_wrapper<copy_throws>), "noexcept always"); + auto ctf = boost::hof::always(copy_throws{}); + static_assert(!noexcept(ctf()), "noexcept always"); +} diff --git a/src/boost/libs/hof/test/apply.cpp b/src/boost/libs/hof/test/apply.cpp new file mode 100644 index 000000000..e85eb915f --- /dev/null +++ b/src/boost/libs/hof/test/apply.cpp @@ -0,0 +1,467 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + apply.cpp + 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/hof/apply.hpp> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::apply(binary_class(), 1, 2) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::apply(binary_class(), 1, 2) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::apply(boost::hof::apply, binary_class(), 1, 2) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::apply(boost::hof::apply, binary_class(), 1, 2) == 3); +} + +struct member_sum_f +{ + int i; + constexpr member_sum_f(int x) : i(x) + {} + + constexpr int add(int x) const + { + return i+x; + } +}; + +struct member_sum_f_derived +: member_sum_f +{ + constexpr member_sum_f_derived(int x) : member_sum_f(x) + {} +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::apply(&member_sum_f::add, member_sum_f(1), 2) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::apply(&member_sum_f::add, member_sum_f_derived(1), 2) == 3); + +#ifdef __clang__ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::apply(&member_sum_f::add, member_sum_f(1), 2) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::apply(&member_sum_f::add, member_sum_f_derived(1), 2) == 3); +#endif + + static_assert(std::is_base_of<member_sum_f, member_sum_f>::value, "Base of failed"); + std::unique_ptr<member_sum_f> msp(new member_sum_f(1)); + BOOST_HOF_TEST_CHECK(boost::hof::apply(&member_sum_f::add, msp, 2) == 3); + + std::unique_ptr<member_sum_f_derived> mspd(new member_sum_f_derived(1)); + BOOST_HOF_TEST_CHECK(boost::hof::apply(&member_sum_f::add, mspd, 2) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::apply(&member_sum_f::i, member_sum_f(3)) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::apply(&member_sum_f::i, member_sum_f_derived(3)) == 3); + +#ifdef __clang__ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::apply(&member_sum_f::i, member_sum_f(3)) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::apply(&member_sum_f::i, member_sum_f_derived(3)) == 3); +#endif + + std::unique_ptr<member_sum_f> msp(new member_sum_f(3)); + BOOST_HOF_TEST_CHECK(boost::hof::apply(&member_sum_f::i, msp) == 3); + + std::unique_ptr<member_sum_f_derived> mspd(new member_sum_f_derived(3)); + BOOST_HOF_TEST_CHECK(boost::hof::apply(&member_sum_f::i, mspd) == 3); +} + + +struct mem_hash +{ + mutable unsigned int hash; + + mem_hash(): hash(0) {} + + int f0() { f1(17); return 0; } + int g0() const { g1(17); return 0; } + + int f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; } + int g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; } + + int f2(int a1, int a2) { f1(a1); f1(a2); return 0; } + int g2(int a1, int a2) const { g1(a1); g1(a2); return 0; } + + int f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; } + int g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; } + + int f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; } + int g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; } + + int f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; } + int g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; } + + int f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; } + int g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; } + + int f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; } + int g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; } + + int f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; } + int g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; } +}; + +BOOST_HOF_TEST_CASE() +{ + + mem_hash x; + + mem_hash const & rcx = x; + mem_hash const * pcx = &x; + + std::shared_ptr<mem_hash> sp(new mem_hash); + + boost::hof::apply(&mem_hash::f0, x); + boost::hof::apply(&mem_hash::f0, &x); + boost::hof::apply(&mem_hash::f0, sp); + + boost::hof::apply(&mem_hash::g0, x); + boost::hof::apply(&mem_hash::g0, rcx); + boost::hof::apply(&mem_hash::g0, &x); + boost::hof::apply(&mem_hash::g0, pcx); + boost::hof::apply(&mem_hash::g0, sp); + + boost::hof::apply(&mem_hash::f1, x, 1); + boost::hof::apply(&mem_hash::f1, &x, 1); + boost::hof::apply(&mem_hash::f1, sp, 1); + + boost::hof::apply(&mem_hash::g1, x, 1); + boost::hof::apply(&mem_hash::g1, rcx, 1); + boost::hof::apply(&mem_hash::g1, &x, 1); + boost::hof::apply(&mem_hash::g1, pcx, 1); + boost::hof::apply(&mem_hash::g1, sp, 1); + + boost::hof::apply(&mem_hash::f2, x, 1, 2); + boost::hof::apply(&mem_hash::f2, &x, 1, 2); + boost::hof::apply(&mem_hash::f2, sp, 1, 2); + + boost::hof::apply(&mem_hash::g2, x, 1, 2); + boost::hof::apply(&mem_hash::g2, rcx, 1, 2); + boost::hof::apply(&mem_hash::g2, &x, 1, 2); + boost::hof::apply(&mem_hash::g2, pcx, 1, 2); + boost::hof::apply(&mem_hash::g2, sp, 1, 2); + + boost::hof::apply(&mem_hash::f3, x, 1, 2, 3); + boost::hof::apply(&mem_hash::f3, &x, 1, 2, 3); + boost::hof::apply(&mem_hash::f3, sp, 1, 2, 3); + + boost::hof::apply(&mem_hash::g3, x, 1, 2, 3); + boost::hof::apply(&mem_hash::g3, rcx, 1, 2, 3); + boost::hof::apply(&mem_hash::g3, &x, 1, 2, 3); + boost::hof::apply(&mem_hash::g3, pcx, 1, 2, 3); + boost::hof::apply(&mem_hash::g3, sp, 1, 2, 3); + + boost::hof::apply(&mem_hash::f4, x, 1, 2, 3, 4); + boost::hof::apply(&mem_hash::f4, &x, 1, 2, 3, 4); + boost::hof::apply(&mem_hash::f4, sp, 1, 2, 3, 4); + + boost::hof::apply(&mem_hash::g4, x, 1, 2, 3, 4); + boost::hof::apply(&mem_hash::g4, rcx, 1, 2, 3, 4); + boost::hof::apply(&mem_hash::g4, &x, 1, 2, 3, 4); + boost::hof::apply(&mem_hash::g4, pcx, 1, 2, 3, 4); + boost::hof::apply(&mem_hash::g4, sp, 1, 2, 3, 4); + + boost::hof::apply(&mem_hash::f5, x, 1, 2, 3, 4, 5); + boost::hof::apply(&mem_hash::f5, &x, 1, 2, 3, 4, 5); + boost::hof::apply(&mem_hash::f5, sp, 1, 2, 3, 4, 5); + + boost::hof::apply(&mem_hash::g5, x, 1, 2, 3, 4, 5); + boost::hof::apply(&mem_hash::g5, rcx, 1, 2, 3, 4, 5); + boost::hof::apply(&mem_hash::g5, &x, 1, 2, 3, 4, 5); + boost::hof::apply(&mem_hash::g5, pcx, 1, 2, 3, 4, 5); + boost::hof::apply(&mem_hash::g5, sp, 1, 2, 3, 4, 5); + + boost::hof::apply(&mem_hash::f6, x, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&mem_hash::f6, &x, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&mem_hash::f6, sp, 1, 2, 3, 4, 5, 6); + + boost::hof::apply(&mem_hash::g6, x, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&mem_hash::g6, rcx, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&mem_hash::g6, &x, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&mem_hash::g6, pcx, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&mem_hash::g6, sp, 1, 2, 3, 4, 5, 6); + + boost::hof::apply(&mem_hash::f7, x, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&mem_hash::f7, &x, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&mem_hash::f7, sp, 1, 2, 3, 4, 5, 6, 7); + + boost::hof::apply(&mem_hash::g7, x, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&mem_hash::g7, rcx, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&mem_hash::g7, &x, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&mem_hash::g7, pcx, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&mem_hash::g7, sp, 1, 2, 3, 4, 5, 6, 7); + + boost::hof::apply(&mem_hash::f8, x, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&mem_hash::f8, &x, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&mem_hash::f8, sp, 1, 2, 3, 4, 5, 6, 7, 8); + + boost::hof::apply(&mem_hash::g8, x, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&mem_hash::g8, rcx, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&mem_hash::g8, &x, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&mem_hash::g8, pcx, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&mem_hash::g8, sp, 1, 2, 3, 4, 5, 6, 7, 8); + + BOOST_HOF_TEST_CHECK(boost::hof::apply(&mem_hash::hash, x) == 17610 && boost::hof::apply(&mem_hash::hash, sp) == 2155); +} + +struct hash_base +{ + mutable unsigned int hash; + + hash_base(): hash(0) {} + + int f0() { f1(17); return 0; } + int g0() const { g1(17); return 0; } + + int f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; } + int g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; } + + int f2(int a1, int a2) { f1(a1); f1(a2); return 0; } + int g2(int a1, int a2) const { g1(a1); g1(a2); return 0; } + + int f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; } + int g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; } + + int f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; } + int g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; } + + int f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; } + int g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; } + + int f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; } + int g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; } + + int f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; } + int g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; } + + int f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; } + int g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; } +}; + +struct derived_hash: public hash_base +{ +}; + +BOOST_HOF_TEST_CASE() +{ + + derived_hash x; + + derived_hash const & rcx = x; + derived_hash const * pcx = &x; + + std::shared_ptr<derived_hash> sp(new derived_hash); + + boost::hof::apply(&derived_hash::f0, x); + boost::hof::apply(&derived_hash::f0, &x); + boost::hof::apply(&derived_hash::f0, sp); + + boost::hof::apply(&derived_hash::g0, x); + boost::hof::apply(&derived_hash::g0, rcx); + boost::hof::apply(&derived_hash::g0, &x); + boost::hof::apply(&derived_hash::g0, pcx); + boost::hof::apply(&derived_hash::g0, sp); + + boost::hof::apply(&derived_hash::f1, x, 1); + boost::hof::apply(&derived_hash::f1, &x, 1); + boost::hof::apply(&derived_hash::f1, sp, 1); + + boost::hof::apply(&derived_hash::g1, x, 1); + boost::hof::apply(&derived_hash::g1, rcx, 1); + boost::hof::apply(&derived_hash::g1, &x, 1); + boost::hof::apply(&derived_hash::g1, pcx, 1); + boost::hof::apply(&derived_hash::g1, sp, 1); + + boost::hof::apply(&derived_hash::f2, x, 1, 2); + boost::hof::apply(&derived_hash::f2, &x, 1, 2); + boost::hof::apply(&derived_hash::f2, sp, 1, 2); + + boost::hof::apply(&derived_hash::g2, x, 1, 2); + boost::hof::apply(&derived_hash::g2, rcx, 1, 2); + boost::hof::apply(&derived_hash::g2, &x, 1, 2); + boost::hof::apply(&derived_hash::g2, pcx, 1, 2); + boost::hof::apply(&derived_hash::g2, sp, 1, 2); + + boost::hof::apply(&derived_hash::f3, x, 1, 2, 3); + boost::hof::apply(&derived_hash::f3, &x, 1, 2, 3); + boost::hof::apply(&derived_hash::f3, sp, 1, 2, 3); + + boost::hof::apply(&derived_hash::g3, x, 1, 2, 3); + boost::hof::apply(&derived_hash::g3, rcx, 1, 2, 3); + boost::hof::apply(&derived_hash::g3, &x, 1, 2, 3); + boost::hof::apply(&derived_hash::g3, pcx, 1, 2, 3); + boost::hof::apply(&derived_hash::g3, sp, 1, 2, 3); + + boost::hof::apply(&derived_hash::f4, x, 1, 2, 3, 4); + boost::hof::apply(&derived_hash::f4, &x, 1, 2, 3, 4); + boost::hof::apply(&derived_hash::f4, sp, 1, 2, 3, 4); + + boost::hof::apply(&derived_hash::g4, x, 1, 2, 3, 4); + boost::hof::apply(&derived_hash::g4, rcx, 1, 2, 3, 4); + boost::hof::apply(&derived_hash::g4, &x, 1, 2, 3, 4); + boost::hof::apply(&derived_hash::g4, pcx, 1, 2, 3, 4); + boost::hof::apply(&derived_hash::g4, sp, 1, 2, 3, 4); + + boost::hof::apply(&derived_hash::f5, x, 1, 2, 3, 4, 5); + boost::hof::apply(&derived_hash::f5, &x, 1, 2, 3, 4, 5); + boost::hof::apply(&derived_hash::f5, sp, 1, 2, 3, 4, 5); + + boost::hof::apply(&derived_hash::g5, x, 1, 2, 3, 4, 5); + boost::hof::apply(&derived_hash::g5, rcx, 1, 2, 3, 4, 5); + boost::hof::apply(&derived_hash::g5, &x, 1, 2, 3, 4, 5); + boost::hof::apply(&derived_hash::g5, pcx, 1, 2, 3, 4, 5); + boost::hof::apply(&derived_hash::g5, sp, 1, 2, 3, 4, 5); + + boost::hof::apply(&derived_hash::f6, x, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&derived_hash::f6, &x, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&derived_hash::f6, sp, 1, 2, 3, 4, 5, 6); + + boost::hof::apply(&derived_hash::g6, x, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&derived_hash::g6, rcx, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&derived_hash::g6, &x, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&derived_hash::g6, pcx, 1, 2, 3, 4, 5, 6); + boost::hof::apply(&derived_hash::g6, sp, 1, 2, 3, 4, 5, 6); + + boost::hof::apply(&derived_hash::f7, x, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&derived_hash::f7, &x, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&derived_hash::f7, sp, 1, 2, 3, 4, 5, 6, 7); + + boost::hof::apply(&derived_hash::g7, x, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&derived_hash::g7, rcx, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&derived_hash::g7, &x, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&derived_hash::g7, pcx, 1, 2, 3, 4, 5, 6, 7); + boost::hof::apply(&derived_hash::g7, sp, 1, 2, 3, 4, 5, 6, 7); + + boost::hof::apply(&derived_hash::f8, x, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&derived_hash::f8, &x, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&derived_hash::f8, sp, 1, 2, 3, 4, 5, 6, 7, 8); + + boost::hof::apply(&derived_hash::g8, x, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&derived_hash::g8, rcx, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&derived_hash::g8, &x, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&derived_hash::g8, pcx, 1, 2, 3, 4, 5, 6, 7, 8); + boost::hof::apply(&derived_hash::g8, sp, 1, 2, 3, 4, 5, 6, 7, 8); + + BOOST_HOF_TEST_CHECK(boost::hof::apply(&derived_hash::hash, x) == 17610 && boost::hof::apply(&derived_hash::hash, sp) == 2155); +} + +struct dm_t +{ + int m; +}; + +BOOST_HOF_TEST_CASE() +{ + dm_t x = { 0 }; + + boost::hof::apply( &dm_t::m, x ) = 401; + + BOOST_HOF_TEST_CHECK( x.m == 401 ); + BOOST_HOF_TEST_CHECK( boost::hof::apply( &dm_t::m, x ) == 401 ); + + boost::hof::apply( &dm_t::m, &x ) = 502; + + BOOST_HOF_TEST_CHECK( x.m == 502 ); + BOOST_HOF_TEST_CHECK( boost::hof::apply( &dm_t::m, &x ) == 502 ); + + dm_t * px = &x; + + boost::hof::apply( &dm_t::m, px ) = 603; + + BOOST_HOF_TEST_CHECK( x.m == 603 ); + BOOST_HOF_TEST_CHECK( boost::hof::apply( &dm_t::m, px ) == 603 ); + + dm_t const & cx = x; + dm_t const * pcx = &x; + + BOOST_HOF_TEST_CHECK( boost::hof::apply( &dm_t::m, cx ) == 603 ); + BOOST_HOF_TEST_CHECK( boost::hof::apply( &dm_t::m, pcx ) == 603 ); + +} + + +struct X_ref +{ + int f() + { + return 1; + } + + int g() const + { + return 2; + } +}; + +BOOST_HOF_TEST_CASE() +{ + X_ref x; + + BOOST_HOF_TEST_CHECK( boost::hof::apply( &X_ref::f, std::ref( x ) ) == 1 ); + BOOST_HOF_TEST_CHECK( boost::hof::apply( &X_ref::g, std::cref( x ) ) == 2 ); +} +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +struct copy_throws +{ + copy_throws() {} + copy_throws(copy_throws const&) {} + copy_throws(copy_throws&&) noexcept {} +}; + +struct no_throw_fo +{ + void operator()() noexcept {} + void operator()(copy_throws) noexcept {} +}; + +struct throws_fo +{ + void operator()() {} +}; + +struct member_obj +{ + int x; +}; +// Only newer versions of gcc support deducing noexcept for member function pointers +#if defined(__GNUC__) && !defined (__clang__) && ((__GNUC__ == 4 && __GNUC_MINOR__ > 8) || (__GNUC__ > 4)) +struct no_throw_member_fun +{ + void foo_nullary() noexcept {} + void foo_unary(copy_throws) noexcept {} +}; +BOOST_HOF_TEST_CASE() +{ + no_throw_member_fun obj; + copy_throws arg; + static_assert(noexcept(boost::hof::apply(&no_throw_member_fun::foo_nullary, obj)), ""); + static_assert(!noexcept(boost::hof::apply(&no_throw_member_fun::foo_unary, obj, arg)), ""); + static_assert(noexcept(boost::hof::apply(&no_throw_member_fun::foo_unary, obj, std::move(arg))), ""); +} +#endif +BOOST_HOF_TEST_CASE() +{ + no_throw_fo obj; + copy_throws arg; + static_assert(noexcept(boost::hof::apply(obj)), ""); + static_assert(!noexcept(boost::hof::apply(obj, arg)), ""); + static_assert(noexcept(boost::hof::apply(obj, std::move(arg))), ""); +} +BOOST_HOF_TEST_CASE() +{ + throws_fo obj; + static_assert(!noexcept(boost::hof::apply(obj)), ""); +} +BOOST_HOF_TEST_CASE() +{ + member_obj obj{42}; + static_assert(noexcept(boost::hof::apply(&member_obj::x, obj)), ""); +} +#endif diff --git a/src/boost/libs/hof/test/apply_eval.cpp b/src/boost/libs/hof/test/apply_eval.cpp new file mode 100644 index 000000000..c97d87c30 --- /dev/null +++ b/src/boost/libs/hof/test/apply_eval.cpp @@ -0,0 +1,63 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + apply_eval.cpp + 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/hof/apply_eval.hpp> +#include <boost/hof/always.hpp> +#include <boost/hof/placeholders.hpp> +#include "test.hpp" + +#include <memory> + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::apply_eval(binary_class(), boost::hof::always(1), boost::hof::always(2)) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::apply_eval(binary_class(), []{ return 1; }, []{ return 2;}) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + boost::hof::apply_eval(boost::hof::always(), boost::hof::always(1), boost::hof::always(2)); +} +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::apply_eval(boost::hof::always(), boost::hof::always(1), boost::hof::always(2))), "noexcept apply_eval"); +} +#endif +BOOST_HOF_TEST_CASE() +{ + int i = 3; + BOOST_HOF_TEST_CHECK(boost::hof::apply_eval(boost::hof::_ - boost::hof::_, [&]{ return i++; }, [&]{ return i++;}) == -1); + BOOST_HOF_TEST_CHECK(boost::hof::apply_eval(boost::hof::_ - boost::hof::_, [&]{ return ++i; }, [&]{ return ++i;}) == -1); +} + +struct indirect_sum_f +{ + template<class T, class U> + auto operator()(T x, U y) const + BOOST_HOF_RETURNS(*x + *y); +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK( + boost::hof::apply_eval( + indirect_sum_f(), + []{ return std::unique_ptr<int>(new int(1)); }, + []{ return std::unique_ptr<int>(new int(2)); }) + == 3); +} + +std::unique_ptr<int> moveable(int i) +{ + return std::unique_ptr<int>{new int(i)}; +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(*boost::hof::apply_eval(&moveable, boost::hof::always(1)) == 1); + BOOST_HOF_TEST_CHECK(*boost::hof::apply_eval(&moveable, boost::hof::always(3)) == 3); +} diff --git a/src/boost/libs/hof/test/arg.cpp b/src/boost/libs/hof/test/arg.cpp new file mode 100644 index 000000000..b6343a330 --- /dev/null +++ b/src/boost/libs/hof/test/arg.cpp @@ -0,0 +1,53 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + arg.cpp + 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/hof/arg.hpp> +#include <boost/hof/is_invocable.hpp> +#include <type_traits> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::arg_c<3>(1,2,3,4,5) == 3); + BOOST_HOF_TEST_CHECK( boost::hof::arg_c<3>(1,2,3,4,5) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::arg(std::integral_constant<int, 3>())(1,2,3,4,5) == 3); + BOOST_HOF_TEST_CHECK( boost::hof::arg(std::integral_constant<int, 3>())(1,2,3,4,5) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + auto at_3 = boost::hof::arg(std::integral_constant<int, 3>()); + static_assert(boost::hof::is_invocable<decltype(at_3), int, int, int>::value, "Not SFINAE-friendly"); + static_assert(!boost::hof::is_invocable<decltype(at_3), int, int>::value, "Not SFINAE-friendly"); + static_assert(!boost::hof::is_invocable<decltype(at_3), int>::value, "Not SFINAE-friendly"); +} + +struct foo {}; + +BOOST_HOF_TEST_CASE() +{ + static_assert(!boost::hof::is_invocable<decltype(boost::hof::arg), int>::value, "Not sfinae friendly"); + static_assert(!boost::hof::is_invocable<decltype(boost::hof::arg), foo>::value, "Not sfinae friendly"); +} + +struct copy_throws +{ + copy_throws() {} + copy_throws(copy_throws const&) {} + copy_throws(copy_throws&&) noexcept {} +}; +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::arg_c<3>(1,2,3,4,5)), "noexcept arg"); + static_assert(noexcept(boost::hof::arg(std::integral_constant<int, 3>())(1,2,3,4,5)), "noexcept arg"); + static_assert(!noexcept(boost::hof::arg(std::integral_constant<int, 3>())(1,2,copy_throws{},4,5)), "noexcept arg"); +} +#endif diff --git a/src/boost/libs/hof/test/capture.cpp b/src/boost/libs/hof/test/capture.cpp new file mode 100644 index 000000000..ac80447e3 --- /dev/null +++ b/src/boost/libs/hof/test/capture.cpp @@ -0,0 +1,96 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + capture.cpp + 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/hof/capture.hpp> +#include <boost/hof/identity.hpp> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::capture_basic(1, 2)(binary_class())() == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture_basic(1, 2)(binary_class())() == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::capture_basic(1)(binary_class())(2) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture_basic(1)(binary_class())(2) == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::capture_basic()(binary_class())(1, 2) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture_basic()(binary_class())(1, 2) == 3); + + static const int one = 1; + static const int two = 2; + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::capture_forward(one, two)(binary_class())() == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture_forward(one, two)(binary_class())() == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture_forward(1, 2)(binary_class())() == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::capture_forward(one)(binary_class())(two) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture_forward(1)(binary_class())(2) == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::capture_forward()(binary_class())(one, two) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture_forward()(binary_class())(one, two) == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::capture(1, 2)(binary_class())() == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture(1, 2)(binary_class())() == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::capture(1)(binary_class())(2) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture(1)(binary_class())(2) == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::capture()(binary_class())(1, 2) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture()(binary_class())(1, 2) == 3); +} + +struct add_member +{ + int i; + + add_member(int ip) : i(ip) + {} + + int add(int j) const + { + return i + j; + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::capture_basic(add_member(1), 2)(&add_member::add)() == 3); + BOOST_HOF_TEST_CHECK(boost::hof::capture_basic(add_member(1))(&add_member::add)(2) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + auto id = boost::hof::identity; + auto f = boost::hof::capture(boost::hof::identity)(boost::hof::identity); + static_assert(BOOST_HOF_IS_DEFAULT_CONSTRUCTIBLE(decltype(id)), "Id not default constructible"); + static_assert(BOOST_HOF_IS_DEFAULT_CONSTRUCTIBLE(decltype(f)), "Not default constructible"); + f(); +} +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::capture(boost::hof::identity)(boost::hof::identity)()), "noexcept capture"); + static_assert(noexcept(boost::hof::capture_basic(boost::hof::identity)(boost::hof::identity)()), "noexcept capture"); + static_assert(noexcept(boost::hof::capture_forward(boost::hof::identity)(boost::hof::identity)()), "noexcept capture"); +} +#endif +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::capture_basic(boost::hof::identity)(boost::hof::identity); + f(); +} + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::capture_forward(boost::hof::identity)(boost::hof::identity); + f(); +} + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::capture(boost::hof::identity)(add_member{1}); + static_assert(!boost::hof::is_invocable<decltype(f), int>::value, "Not sfinae friendly"); +} + diff --git a/src/boost/libs/hof/test/combine.cpp b/src/boost/libs/hof/test/combine.cpp new file mode 100644 index 000000000..6340150e9 --- /dev/null +++ b/src/boost/libs/hof/test/combine.cpp @@ -0,0 +1,71 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + combine.cpp + 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/hof/combine.hpp> +#include "test.hpp" + +#include <boost/hof/construct.hpp> +#include <boost/hof/capture.hpp> +#include <utility> +#include <tuple> + +template<class T, class U> +struct mini_pair +{ + T first; + U second; + + template<class X, class Y> + constexpr mini_pair(X&& x, Y&& y) + : first(boost::hof::forward<X>(x)), second(boost::hof::forward<Y>(y)) + {} +}; + +template<class T1, class U1, class T2, class U2> +constexpr bool operator==(const mini_pair<T1, U1>& x, const mini_pair<T2, U2>& y) +{ + return x.first == y.first && x.second == y.second; +} + +template<class T, class U> +constexpr mini_pair<T, U> make_mini_pair(T x, U y) +{ + return mini_pair<T, U>(x, y); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK( + boost::hof::combine( + boost::hof::construct<std::tuple>(), + boost::hof::capture_basic(1)(boost::hof::construct<std::pair>()), + boost::hof::capture_basic(2)(boost::hof::construct<std::pair>()) + )(2, 4) + == std::make_tuple(std::make_pair(1, 2), std::make_pair(2, 4))); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK( + boost::hof::combine( + boost::hof::construct<mini_pair>(), + boost::hof::capture_basic(1)(boost::hof::construct<mini_pair>()), + boost::hof::capture_basic(2)(boost::hof::construct<mini_pair>()) + )(2, 4) + == make_mini_pair(make_mini_pair(1, 2), make_mini_pair(2, 4))); + + BOOST_HOF_STATIC_TEST_CHECK( + boost::hof::combine( + boost::hof::construct<mini_pair>(), + boost::hof::capture_basic(1)(boost::hof::construct<mini_pair>()), + boost::hof::capture_basic(2)(boost::hof::construct<mini_pair>()) + )(2, 4) + == make_mini_pair(make_mini_pair(1, 2), make_mini_pair(2, 4))); +} + + + + diff --git a/src/boost/libs/hof/test/compose.cpp b/src/boost/libs/hof/test/compose.cpp new file mode 100644 index 000000000..f36291fda --- /dev/null +++ b/src/boost/libs/hof/test/compose.cpp @@ -0,0 +1,186 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + compose.cpp + 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/hof/compose.hpp> +#include <boost/hof/function.hpp> +#include <boost/hof/lambda.hpp> +#include <boost/hof/placeholders.hpp> +#include <memory> +#include "test.hpp" + +namespace compose_test { +struct increment +{ + template<class T> + constexpr T operator()(T x) const noexcept + { + return x + 1; + } +}; + +struct decrement +{ + template<class T> + constexpr T operator()(T x) const noexcept + { + return x - 1; + } +}; + +struct negate +{ + template<class T> + constexpr T operator()(T x) const noexcept + { + return -x; + } +}; + +struct increment_movable +{ + std::unique_ptr<int> n; + increment_movable() + : n(new int(1)) + {} + template<class T> + T operator()(T x) const + { + return x + *n; + } +}; + +struct decrement_movable +{ + std::unique_ptr<int> n; + decrement_movable() + : n(new int(1)) + {} + template<class T> + T operator()(T x) const + { + return x - *n; + } +}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::compose(increment(), decrement(), increment())(3)), "noexcept compose"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::compose(boost::hof::identity)(3) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::compose(boost::hof::identity, boost::hof::identity)(3) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::compose(boost::hof::identity, boost::hof::identity, boost::hof::identity)(3) == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::compose(boost::hof::identity)(3) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::compose(boost::hof::identity, boost::hof::identity)(3) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::compose(boost::hof::identity, boost::hof::identity, boost::hof::identity)(3) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + int r = boost::hof::compose(increment(), decrement(), increment())(3); + BOOST_HOF_TEST_CHECK(r == 4); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::compose(increment(), decrement(), increment())(3) == 4); +} + +BOOST_HOF_TEST_CASE() +{ + int r = boost::hof::compose(increment(), negate(), decrement(), decrement())(3); + BOOST_HOF_TEST_CHECK(r == 0); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::compose(increment(), negate(), decrement(), decrement())(3) == 0); +} +BOOST_HOF_TEST_CASE() +{ + constexpr auto f = boost::hof::compose(increment(), decrement()); +#ifndef _MSC_VER + static_assert(std::is_empty<decltype(f)>::value, "Compose function not empty"); +#endif + static_assert(BOOST_HOF_IS_DEFAULT_CONSTRUCTIBLE(decltype(f)), "Compose function not default constructible"); + int r = f(3); + BOOST_HOF_TEST_CHECK(r == 3); + BOOST_HOF_STATIC_TEST_CHECK(f(3) == 3); +} + +#ifndef _MSC_VER +BOOST_HOF_TEST_CASE() +{ + constexpr auto f = boost::hof::compose(increment(), negate(), decrement(), decrement()); + static_assert(std::is_empty<decltype(f)>::value, "Compose function not empty"); + static_assert(BOOST_HOF_IS_DEFAULT_CONSTRUCTIBLE(decltype(f)), "Compose function not default constructible"); + int r = f(3); + BOOST_HOF_TEST_CHECK(r == 0); + BOOST_HOF_STATIC_TEST_CHECK(f(3) == 0); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + STATIC_ASSERT_MOVE_ONLY(increment_movable); + STATIC_ASSERT_MOVE_ONLY(decrement_movable); + int r = boost::hof::compose(increment_movable(), decrement_movable(), increment_movable())(3); + BOOST_HOF_TEST_CHECK(r == 4); +} + +template<class T> +struct print; + +BOOST_HOF_TEST_CASE() +{ + const auto f = boost::hof::compose([](int i) { return i+1; }, [](int i) { return i-1; }, [](int i) { return i+1; }); +#ifndef _MSC_VER + static_assert(std::is_empty<decltype(f)>::value, "Compose function not empty"); +#endif + int r = f(3); + BOOST_HOF_TEST_CHECK(r == 4); +} + + +BOOST_HOF_STATIC_FUNCTION(f_compose_single_function) = boost::hof::compose(increment()); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(f_compose_single_function(3) == 4); + BOOST_HOF_STATIC_TEST_CHECK(f_compose_single_function(3) == 4); +} + +BOOST_HOF_STATIC_FUNCTION(f_compose_function) = boost::hof::compose(increment(), decrement(), increment()); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(f_compose_function(3) == 4); + BOOST_HOF_STATIC_TEST_CHECK(f_compose_function(3) == 4); +} + +BOOST_HOF_STATIC_FUNCTION(f_compose_function_4) = boost::hof::compose(increment(), negate(), decrement(), decrement()); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(f_compose_function_4(3) == 0); + BOOST_HOF_STATIC_TEST_CHECK(f_compose_function_4(3) == 0); +} + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(f_compose_lambda) = boost::hof::compose( + [](int i) { return i+1; }, + [](int i) { return i-1; }, + [](int i) { return i+1; } +); + +BOOST_HOF_TEST_CASE() +{ + int r = f_compose_lambda(3); + BOOST_HOF_TEST_CHECK(r == 4); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::compose(boost::hof::_1 * boost::hof::_1, boost::hof::_1 + boost::hof::_1)(3) == 36); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::compose(boost::hof::_1 * boost::hof::_1, boost::hof::_1 + boost::hof::_1)(3) == 36); +} +} diff --git a/src/boost/libs/hof/test/construct.cpp b/src/boost/libs/hof/test/construct.cpp new file mode 100644 index 000000000..953f0f6c3 --- /dev/null +++ b/src/boost/libs/hof/test/construct.cpp @@ -0,0 +1,222 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + construct.cpp + 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/hof/construct.hpp> +#include "test.hpp" + +#include <boost/hof/first_of.hpp> +#include <boost/hof/proj.hpp> +#include <boost/hof/placeholders.hpp> + +#include <tuple> +#include <type_traits> +#include <vector> + +template<class T> +struct ac +{ + T value; + constexpr ac(T i) : value(i) + {} +}; + +template<class... Ts> +struct tuple_meta +{ + typedef std::tuple<Ts...> type; +}; + +struct tuple_meta_class +{ + template<class... Ts> + struct apply + { + typedef std::tuple<Ts...> type; + }; +}; + +struct implicit_default +{ + int mem1; + std::string mem2; +}; + +struct user_default +{ + int mem1; + std::string mem2; + user_default() { } +}; + +struct user_construct +{ + int mem1; + std::string mem2; + user_construct(int) { } +}; + +template<class T> +struct template_user_construct +{ + int mem1; + std::string mem2; + template_user_construct(T) { } +}; + + +BOOST_HOF_TEST_CASE() +{ + auto v = boost::hof::construct<std::vector<int>>()(5, 5); + BOOST_HOF_TEST_CHECK(v.size() == 5); + BOOST_HOF_TEST_CHECK(v == std::vector<int>{5, 5, 5, 5, 5}); +} + +BOOST_HOF_TEST_CASE() +{ + auto v = boost::hof::construct_basic<std::vector<int>>()(5, 5); + BOOST_HOF_TEST_CHECK(v.size() == 5); + BOOST_HOF_TEST_CHECK(v == std::vector<int>{5, 5, 5, 5, 5}); +} + +BOOST_HOF_TEST_CASE() +{ + auto v = boost::hof::construct_forward<std::vector<int>>()(5, 5); + BOOST_HOF_TEST_CHECK(v.size() == 5); + BOOST_HOF_TEST_CHECK(v == std::vector<int>{5, 5, 5, 5, 5}); +} + +BOOST_HOF_TEST_CASE() +{ + auto x = boost::hof::construct<implicit_default>()(); + BOOST_HOF_TEST_CHECK(x.mem1 == 0); + BOOST_HOF_TEST_CHECK(x.mem2 == ""); +} + +BOOST_HOF_TEST_CASE() +{ + auto x = boost::hof::construct<user_default>()(); + BOOST_HOF_TEST_CHECK(x.mem1 == 0); + BOOST_HOF_TEST_CHECK(x.mem2 == ""); +} + +BOOST_HOF_TEST_CASE() +{ + auto x = boost::hof::construct<user_construct>()(3); + BOOST_HOF_TEST_CHECK(x.mem1 == 0); + BOOST_HOF_TEST_CHECK(x.mem2 == ""); +} + +BOOST_HOF_TEST_CASE() +{ + auto x = boost::hof::construct<template_user_construct>()(3); + BOOST_HOF_TEST_CHECK(x.mem1 == 0); + BOOST_HOF_TEST_CHECK(x.mem2 == ""); +} + +BOOST_HOF_TEST_CASE() +{ + auto x = boost::hof::construct_forward<template_user_construct>()(3); + BOOST_HOF_TEST_CHECK(x.mem1 == 0); + BOOST_HOF_TEST_CHECK(x.mem2 == ""); +} + +BOOST_HOF_TEST_CASE() +{ + auto x = boost::hof::construct_basic<template_user_construct>()(3); + BOOST_HOF_TEST_CHECK(x.mem1 == 0); + BOOST_HOF_TEST_CHECK(x.mem2 == ""); +} + +BOOST_HOF_TEST_CASE() +{ + auto v = boost::hof::construct<std::vector<int>>()({5, 5, 5, 5, 5}); + BOOST_HOF_TEST_CHECK(v.size() == 5); + BOOST_HOF_TEST_CHECK(v == std::vector<int>{5, 5, 5, 5, 5}); +} + +BOOST_HOF_TEST_CASE() +{ + auto t = boost::hof::construct<std::tuple>()(1, 2, 3); + static_assert(std::is_same<std::tuple<int, int, int>, decltype(t)>::value, ""); + BOOST_HOF_TEST_CHECK(t == std::make_tuple(1, 2, 3)); +// GCC 4.7 doesn't have fully constexpr tuple +#if BOOST_HOF_HAS_CONSTEXPR_TUPLE + BOOST_HOF_STATIC_TEST_CHECK(std::make_tuple(1, 2, 3) == boost::hof::construct<std::tuple>()(1, 2, 3)); +#endif +} + +BOOST_HOF_TEST_CASE() +{ + auto t = boost::hof::construct<std::pair>()(1, 2); + static_assert(std::is_same<std::pair<int, int>, decltype(t)>::value, ""); + BOOST_HOF_TEST_CHECK(t == std::make_pair(1, 2)); +// GCC 4.7 doesn't have fully constexpr pair +#if BOOST_HOF_HAS_CONSTEXPR_TUPLE + BOOST_HOF_STATIC_TEST_CHECK(std::make_pair(1, 2) == boost::hof::construct<std::pair>()(1, 2)); +#endif +} + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::first_of(boost::hof::construct<std::pair>(), boost::hof::identity); + BOOST_HOF_TEST_CHECK(f(1, 2) == std::make_pair(1, 2)); + BOOST_HOF_TEST_CHECK(f(1) == 1); +} + +BOOST_HOF_TEST_CASE() +{ + auto x = boost::hof::construct<ac>()(1); + static_assert(std::is_same<ac<int>, decltype(x)>::value, ""); + BOOST_HOF_TEST_CHECK(x.value == ac<int>(1).value); + BOOST_HOF_STATIC_TEST_CHECK(ac<int>(1).value == boost::hof::construct<ac>()(1).value); +} + +BOOST_HOF_TEST_CASE() +{ + auto x = boost::hof::construct_basic<ac>()(1); + static_assert(std::is_same<ac<int>, decltype(x)>::value, ""); + BOOST_HOF_TEST_CHECK(x.value == ac<int>(1).value); + BOOST_HOF_STATIC_TEST_CHECK(ac<int>(1).value == boost::hof::construct<ac>()(1).value); +} + +BOOST_HOF_TEST_CASE() +{ + int i = 1; + auto x = boost::hof::construct_forward<ac>()(i); + static_assert(std::is_same<ac<int&>, decltype(x)>::value, ""); + BOOST_HOF_TEST_CHECK(&x.value == &i); +} + +BOOST_HOF_TEST_CASE() +{ + int i = 1; + auto x = boost::hof::construct_basic<ac>()(i); + static_assert(std::is_same<ac<int&>, decltype(x)>::value, ""); + BOOST_HOF_TEST_CHECK(&x.value == &i); +} + +BOOST_HOF_TEST_CASE() +{ + auto t = boost::hof::construct_meta<tuple_meta>()(1, 2, 3); + static_assert(std::is_same<std::tuple<int, int, int>, decltype(t)>::value, ""); + BOOST_HOF_TEST_CHECK(t == std::make_tuple(1, 2, 3)); +// GCC 4.7 doesn't have fully constexpr tuple +#if BOOST_HOF_HAS_CONSTEXPR_TUPLE + BOOST_HOF_STATIC_TEST_CHECK(std::make_tuple(1, 2, 3) == boost::hof::construct_meta<tuple_meta>()(1, 2, 3)); +#endif +} + +BOOST_HOF_TEST_CASE() +{ + auto t = boost::hof::construct_meta<tuple_meta_class>()(1, 2, 3); + static_assert(std::is_same<std::tuple<int, int, int>, decltype(t)>::value, ""); + BOOST_HOF_TEST_CHECK(t == std::make_tuple(1, 2, 3)); +// GCC 4.7 doesn't have fully constexpr tuple +#if BOOST_HOF_HAS_CONSTEXPR_TUPLE + BOOST_HOF_STATIC_TEST_CHECK(std::make_tuple(1, 2, 3) == boost::hof::construct_meta<tuple_meta_class>()(1, 2, 3)); +#endif +} + diff --git a/src/boost/libs/hof/test/decay.cpp b/src/boost/libs/hof/test/decay.cpp new file mode 100644 index 000000000..bcf235bfd --- /dev/null +++ b/src/boost/libs/hof/test/decay.cpp @@ -0,0 +1,28 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + decay.cpp + 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/hof/decay.hpp> +#include "test.hpp" + +#define CHECK_DECAY(T) \ + STATIC_ASSERT_SAME(decltype(boost::hof::decay(std::declval<T>())), std::decay<T>::type) + +BOOST_HOF_TEST_CASE() +{ + CHECK_DECAY(int); + CHECK_DECAY(int*); + CHECK_DECAY(int&); + CHECK_DECAY(int&&); + CHECK_DECAY(const int&); + CHECK_DECAY(int[2]); + CHECK_DECAY(int(int)); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::decay(3) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::decay(3) == 3); +} diff --git a/src/boost/libs/hof/test/decorate.cpp b/src/boost/libs/hof/test/decorate.cpp new file mode 100644 index 000000000..11b1f5b66 --- /dev/null +++ b/src/boost/libs/hof/test/decorate.cpp @@ -0,0 +1,35 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + decorate.cpp + 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/hof/decorate.hpp> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::decorate(boost::hof::always(1))(boost::hof::always(1))(boost::hof::always(1))(5) == 1); +} + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +struct copy_throws +{ + copy_throws() {} + copy_throws(copy_throws const&) {} + copy_throws(copy_throws&&) noexcept {} +}; + +struct no_throw_fo +{ + void operator()() const noexcept {} + void operator()(copy_throws) const noexcept {} +}; + +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::decorate(boost::hof::always(1))(boost::hof::always(1))(boost::hof::always(1))(5)), "noexcept decorator"); + static_assert(!noexcept(boost::hof::decorate(boost::hof::always(1))(boost::hof::always(1))(boost::hof::always(1))(copy_throws{})), "noexcept decorator"); +} + +#endif diff --git a/src/boost/libs/hof/test/fail/always.cpp b/src/boost/libs/hof/test/fail/always.cpp new file mode 100644 index 000000000..76b6e5d70 --- /dev/null +++ b/src/boost/libs/hof/test/fail/always.cpp @@ -0,0 +1,14 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + always.cpp + 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/hof/always.hpp> +#include <memory> + +int main() { + auto f = boost::hof::always(std::unique_ptr<int>{new int(1)}); + auto i = f(1, 2, 3); + (void)i; +} diff --git a/src/boost/libs/hof/test/fail/apply_eval.cpp b/src/boost/libs/hof/test/fail/apply_eval.cpp new file mode 100644 index 000000000..c87d7ed9d --- /dev/null +++ b/src/boost/libs/hof/test/fail/apply_eval.cpp @@ -0,0 +1,11 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + apply_eval.cpp + 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/hof/apply_eval.hpp> + +int main() { + (void)boost::hof::apply_eval(boost::hof::always(), 1, 2); +} diff --git a/src/boost/libs/hof/test/fail/flip_lazy.cpp b/src/boost/libs/hof/test/fail/flip_lazy.cpp new file mode 100644 index 000000000..7d5e0dc36 --- /dev/null +++ b/src/boost/libs/hof/test/fail/flip_lazy.cpp @@ -0,0 +1,14 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + flip_lazy.cpp + 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/hof/lazy.hpp> +#include <boost/hof/placeholders.hpp> +#include <boost/hof/flip.hpp> + +int main() { + auto i = (boost::hof::flip(boost::hof::_1 - boost::hof::_2) * boost::hof::_1)(3, 6); + (void)i; +} diff --git a/src/boost/libs/hof/test/fail/implicit.cpp b/src/boost/libs/hof/test/fail/implicit.cpp new file mode 100644 index 000000000..df81297ac --- /dev/null +++ b/src/boost/libs/hof/test/fail/implicit.cpp @@ -0,0 +1,29 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + implicit.cpp + 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/hof/implicit.hpp> + +template<class T> +struct auto_caster +{ + template<class U> + T operator()(U x) + { + return T(x); + } +}; + + +int main() +{ + boost::hof::implicit<auto_caster> auto_cast = {}; + auto x = auto_cast(1.5); + (void)x; +// This is not possible in c++17 due to guaranteed copy elison +#if BOOST_HOF_HAS_STD_17 || (defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7) + static_assert(false, "Always fail"); +#endif +} diff --git a/src/boost/libs/hof/test/fail/rotate_lazy.cpp b/src/boost/libs/hof/test/fail/rotate_lazy.cpp new file mode 100644 index 000000000..59c4f4e95 --- /dev/null +++ b/src/boost/libs/hof/test/fail/rotate_lazy.cpp @@ -0,0 +1,14 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + rotate_lazy.cpp + 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/hof/lazy.hpp> +#include <boost/hof/placeholders.hpp> +#include <boost/hof/rotate.hpp> + +int main() { + auto i = (boost::hof::rotate(boost::hof::_1 - boost::hof::_2) * boost::hof::_1)(3, 6); + (void)i; +} diff --git a/src/boost/libs/hof/test/fail/unpack.cpp b/src/boost/libs/hof/test/fail/unpack.cpp new file mode 100644 index 000000000..f4758be0c --- /dev/null +++ b/src/boost/libs/hof/test/fail/unpack.cpp @@ -0,0 +1,27 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + unpack.cpp + 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/hof/unpack.hpp> + +struct foo +{}; + +namespace boost { namespace hof { + +template<> +struct unpack_sequence<foo> +{ + template<class F, class S> + constexpr static int apply(F&&, S&&) + { + return 0; + } +}; +} + +int main() { + boost::hof::unpack(boost::hof::always(1))(foo{}); +} diff --git a/src/boost/libs/hof/test/fail/unpack_uncallable.cpp b/src/boost/libs/hof/test/fail/unpack_uncallable.cpp new file mode 100644 index 000000000..d3c946f4e --- /dev/null +++ b/src/boost/libs/hof/test/fail/unpack_uncallable.cpp @@ -0,0 +1,24 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + unpack_uncallable.cpp + 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/hof/unpack.hpp> + +struct foo +{}; + +namespace boost { namespace hof { + +template<> +struct unpack_sequence<foo> +{ + template<class F, class S> + constexpr static auto apply(F&&, S&& s) BOOST_HOF_RETURNS(s.bar); +}; +} + +int main() { + boost::hof::unpack(boost::hof::always(1))(foo{}); +} diff --git a/src/boost/libs/hof/test/filter.cpp b/src/boost/libs/hof/test/filter.cpp new file mode 100644 index 000000000..0b0268e01 --- /dev/null +++ b/src/boost/libs/hof/test/filter.cpp @@ -0,0 +1,54 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + filter.cpp + 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/hof/if.hpp> +#include "test.hpp" + +#include <boost/hof/proj.hpp> +#include <boost/hof/lift.hpp> +#include <boost/hof/construct.hpp> +#include <boost/hof/first_of.hpp> +#include <boost/hof/unpack.hpp> + +#include <tuple> + +BOOST_HOF_LIFT_CLASS(make_tuple_f, std::make_tuple); + +struct integer_predicate +{ + constexpr integer_predicate() + {} + template<class T> + constexpr auto operator()(T x) const BOOST_HOF_RETURNS + ( + boost::hof::first_of( + boost::hof::if_(std::is_integral<T>())(boost::hof::pack_basic), + boost::hof::always(boost::hof::pack_basic()) + )(boost::hof::move(x)) + ) +}; + +struct filter_integers +{ + template<class Seq> + constexpr auto operator()(Seq s) const BOOST_HOF_RETURNS + ( + boost::hof::unpack( + boost::hof::proj(integer_predicate(), boost::hof::unpack(make_tuple_f())) + )(std::move(s)) + ) +}; + + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(filter_integers()(boost::hof::pack_basic(1, 2, 2.0, 3)) == std::make_tuple(1, 2, 3)); +#if BOOST_HOF_HAS_CONSTEXPR_TUPLE + BOOST_HOF_STATIC_TEST_CHECK(filter_integers()(boost::hof::pack_basic(1, 2, 2.0, 3)) == std::make_tuple(1, 2, 3)); +#endif +} + + diff --git a/src/boost/libs/hof/test/final_base.cpp b/src/boost/libs/hof/test/final_base.cpp new file mode 100644 index 000000000..d348e922a --- /dev/null +++ b/src/boost/libs/hof/test/final_base.cpp @@ -0,0 +1,26 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + final_base.cpp + 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/hof/flip.hpp> +#include "test.hpp" + +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7 +#define FINAL +#else +#define FINAL final +#endif + + +struct f FINAL { + int operator()(int i, void *) const { + return i; + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::flip(f())(nullptr, 2) == 2); +} diff --git a/src/boost/libs/hof/test/first_of.cpp b/src/boost/libs/hof/test/first_of.cpp new file mode 100644 index 000000000..c995e5142 --- /dev/null +++ b/src/boost/libs/hof/test/first_of.cpp @@ -0,0 +1,216 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + first_of.cpp + 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/hof/first_of.hpp> +#include <boost/hof/static.hpp> +#include <boost/hof/lambda.hpp> +#include <boost/hof/function.hpp> +#include <memory> +#include "test.hpp" + +namespace conditional_test { + +#define CONDITIONAL_FUNCTION(n) \ +struct t ## n {}; \ +struct f ## n \ +{ \ + constexpr int operator()(t ## n) const \ + { \ + return n; \ + } \ +}; + +CONDITIONAL_FUNCTION(1) +CONDITIONAL_FUNCTION(2) +CONDITIONAL_FUNCTION(3) + +#define CONDITIONAL_MOVE_FUNCTION(n) \ +struct t_move ## n {}; \ +struct f_move ## n \ +{ \ + std::unique_ptr<int> i;\ + f_move ## n(int ip) : i(new int(ip)) {}; \ + int operator()(t_move ## n) const \ + { \ + return *i; \ + } \ +}; + +CONDITIONAL_MOVE_FUNCTION(1) +CONDITIONAL_MOVE_FUNCTION(2) +CONDITIONAL_MOVE_FUNCTION(3) + +struct ff +{ + constexpr int operator()(t2) const + { + return 500; + } +}; + +static constexpr boost::hof::static_<boost::hof::first_of_adaptor<f1, f2, f3, ff> > f = {}; + +BOOST_HOF_STATIC_FUNCTION(f_constexpr) = boost::hof::first_of_adaptor<f1, f2, f3, ff>(); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(f(t1()) == 1); + BOOST_HOF_TEST_CHECK(f(t2()) == 2); + BOOST_HOF_TEST_CHECK(f(t3()) == 3); + + BOOST_HOF_STATIC_TEST_CHECK(f_constexpr(t1()) == 1); + BOOST_HOF_STATIC_TEST_CHECK(f_constexpr(t2()) == 2); + BOOST_HOF_STATIC_TEST_CHECK(f_constexpr(t3()) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::first_of(f1{}, f2{})(t1()) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::first_of(f1{}, f2{})(t2()) == 2); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(f1{}, f2{})(t1()) == 1); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(f1{}, f2{})(t2()) == 2); +} + +#if (defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7) +#else + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f1{}, f2{}))(t1()) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f1{}, f2{}))(t2()) == 2); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f1{}, f2{}))(t1()) == 1); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f1{}, f2{}))(t2()) == 2); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::first_of(f1{}, boost::hof::first_of(f2{}, f3{}))(t1()) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::first_of(f1{}, boost::hof::first_of(f2{}, f3{}))(t2()) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::first_of(f1{}, boost::hof::first_of(f2{}, f3{}))(t3()) == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(f1{}, boost::hof::first_of(f2{}, f3{}))(t1()) == 1); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(f1{}, boost::hof::first_of(f2{}, f3{}))(t2()) == 2); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(f1{}, boost::hof::first_of(f2{}, f3{}))(t3()) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f2{}, f3{}))(t1()) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f2{}, f3{}))(t2()) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f2{}, f3{}))(t3()) == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f2{}, f3{}))(t1()) == 1); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f2{}, f3{}))(t2()) == 2); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::first_of(boost::hof::first_of(f1{}, f2{}), boost::hof::first_of(f2{}, f3{}))(t3()) == 3); +} + +#endif + +BOOST_HOF_TEST_CASE() +{ + auto f_move_local = boost::hof::first_of(f_move1(1), f_move2(2), f_move3(3)); + STATIC_ASSERT_MOVE_ONLY(decltype(f_move_local)); + BOOST_HOF_TEST_CHECK(f_move_local(t_move1()) == 1); + BOOST_HOF_TEST_CHECK(f_move_local(t_move2()) == 2); + BOOST_HOF_TEST_CHECK(f_move_local(t_move3()) == 3); +} +#ifndef _MSC_VER +static constexpr auto lam = boost::hof::first_of( + BOOST_HOF_STATIC_LAMBDA(t1) + { + return 1; + }, + BOOST_HOF_STATIC_LAMBDA(t2) + { + return 2; + }, + BOOST_HOF_STATIC_LAMBDA(t3) + { + return 3; + } +); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(lam(t1()) == 1); + BOOST_HOF_TEST_CHECK(lam(t2()) == 2); + BOOST_HOF_TEST_CHECK(lam(t3()) == 3); +} +#endif + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(static_fun) = boost::hof::first_of( + [](t1) + { + return 1; + }, + [](t2) + { + return 2; + }, + [](t3) + { + return 3; + } +); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(static_fun(t1()) == 1); + BOOST_HOF_TEST_CHECK(static_fun(t2()) == 2); + BOOST_HOF_TEST_CHECK(static_fun(t3()) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::first_of(boost::hof::identity, boost::hof::identity)(3) == 3); +} + +template<class T> +struct throw_fo +{ + void operator()(T) const {} +}; + +template<class T> +struct no_throw_fo +{ + void operator()(T) const noexcept {} +}; +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + typedef boost::hof::first_of_adaptor<throw_fo<t1>, no_throw_fo<t2>> fun; + auto g = fun{}; + static_assert(noexcept(g(t2{})), "noexcept conditional"); + static_assert(!noexcept(g(t1{})), "noexcept conditional"); + + static_assert(noexcept(fun{}(t2{})), "noexcept conditional"); + static_assert(!noexcept(fun{}(t1{})), "noexcept conditional"); +} + +BOOST_HOF_TEST_CASE() +{ + typedef boost::hof::first_of_adaptor<no_throw_fo<t2>, throw_fo<t1>> fun; + auto g = fun{}; + static_assert(noexcept(g(t2{})), "noexcept conditional"); + static_assert(!noexcept(g(t1{})), "noexcept conditional"); + + static_assert(noexcept(fun{}(t2{})), "noexcept conditional"); + static_assert(!noexcept(fun{}(t1{})), "noexcept conditional"); +} + +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::first_of_adaptor<no_throw_fo<t2>, throw_fo<t1>>{}(t2{})), "noexcept conditional"); + static_assert(!noexcept(boost::hof::first_of_adaptor<no_throw_fo<t2>, throw_fo<t1>>{}(t1{})), "noexcept conditional"); + + static_assert(noexcept(boost::hof::first_of(no_throw_fo<t2>{}, throw_fo<t1>{})(t2{})), "noexcept conditional"); + static_assert(!noexcept(boost::hof::first_of(no_throw_fo<t2>{}, throw_fo<t1>{})(t1{})), "noexcept conditional"); +} +#endif +} diff --git a/src/boost/libs/hof/test/fix.cpp b/src/boost/libs/hof/test/fix.cpp new file mode 100644 index 000000000..8262d9eb0 --- /dev/null +++ b/src/boost/libs/hof/test/fix.cpp @@ -0,0 +1,100 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + fix.cpp + 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/hof/fix.hpp> +#include <boost/hof/static.hpp> +#include <boost/hof/reveal.hpp> +#include <boost/hof/result.hpp> +#include "test.hpp" + +#include <memory> + +struct factorial_t +{ + template<class Self, class T> + T operator()(Self s, T x) const noexcept + { + return x == 0 ? 1 : x * s(x-1); + } +}; + +struct factorial_constexpr_t +{ + template<class Self, class T> + constexpr T operator()(Self s, T x) const noexcept + { + return x == 0 ? 1 : x * s(x-1); + } +}; + +struct factorial_move_t +{ + std::unique_ptr<int> i; + factorial_move_t() : i(new int(1)) + {} + template<class Self, class T> + T operator()(const Self& s, T x) const + { + return x == 0 ? *i : x * s(x-1); + } +}; + +static constexpr boost::hof::fix_adaptor<factorial_t> factorial = {}; +static constexpr boost::hof::fix_adaptor<factorial_constexpr_t> factorial_constexpr = {}; +static constexpr boost::hof::static_<boost::hof::fix_adaptor<factorial_move_t> > factorial_move = {}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(factorial(5)), "noexcept fix"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + const int r = factorial(5); + BOOST_HOF_TEST_CHECK(r == 5*4*3*2*1); +} + +BOOST_HOF_TEST_CASE() +{ + const int r = boost::hof::reveal(factorial)(5); + BOOST_HOF_TEST_CHECK(r == 5*4*3*2*1); +} + +#if !BOOST_HOF_NO_EXPRESSION_SFINAE +BOOST_HOF_TEST_CASE() +{ + const int r = boost::hof::fix(boost::hof::result<int>(factorial_constexpr_t()))(5); + BOOST_HOF_TEST_CHECK(r == 5*4*3*2*1); +} + +BOOST_HOF_TEST_CASE() +{ + const int r = boost::hof::result<int>(factorial_constexpr)(5); + BOOST_HOF_TEST_CHECK(r == 5*4*3*2*1); +} +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fix(boost::hof::result<int>(factorial_constexpr_t()))(5) == 5*4*3*2*1); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::result<int>(factorial_constexpr)(5) == 5*4*3*2*1); +} +#endif +BOOST_HOF_TEST_CASE() +{ +#if BOOST_HOF_HAS_GENERIC_LAMBDA + auto factorial_ = boost::hof::fix([](auto s, auto x) -> decltype(x) { return x == 0 ? 1 : x * s(x-1); }); + int r = boost::hof::result<int>(factorial_)(5); + BOOST_HOF_TEST_CHECK(r == 5*4*3*2*1); +#endif +} + +BOOST_HOF_TEST_CASE() +{ + const int r = factorial_move(5); + BOOST_HOF_TEST_CHECK(r == 5*4*3*2*1); + BOOST_HOF_TEST_CHECK(boost::hof::fix(factorial_move_t())(5) == 5*4*3*2*1); +} diff --git a/src/boost/libs/hof/test/flip.cpp b/src/boost/libs/hof/test/flip.cpp new file mode 100644 index 000000000..599997421 --- /dev/null +++ b/src/boost/libs/hof/test/flip.cpp @@ -0,0 +1,61 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + flip.cpp + 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/hof/flip.hpp> +#include <boost/hof/placeholders.hpp> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::flip(boost::hof::_ - boost::hof::_)(2, 5)); + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::flip(boost::hof::_ - boost::hof::_)(2, 5)); +} + +BOOST_HOF_TEST_CASE() +{ + typedef std::integral_constant<int, 1> one; + typedef std::integral_constant<int, 2> two; + typedef std::integral_constant<int, 3> three; + BOOST_HOF_TEST_CHECK(1 == boost::hof::arg(one{})(1, 2, 3, 4)); + BOOST_HOF_STATIC_TEST_CHECK(1 == boost::hof::arg(one{})(1, 2, 3, 4)); + BOOST_HOF_TEST_CHECK(2 == boost::hof::flip(boost::hof::arg(one{}))(1, 2, 3, 4)); + BOOST_HOF_STATIC_TEST_CHECK(2 == boost::hof::flip(boost::hof::arg(one{}))(1, 2, 3, 4)); + + BOOST_HOF_TEST_CHECK(2 == boost::hof::arg(two{})(1, 2, 3, 4)); + BOOST_HOF_STATIC_TEST_CHECK(2 == boost::hof::arg(two{})(1, 2, 3, 4)); + BOOST_HOF_TEST_CHECK(1 == boost::hof::flip(boost::hof::arg(two{}))(1, 2, 3, 4)); + BOOST_HOF_STATIC_TEST_CHECK(1 == boost::hof::flip(boost::hof::arg(two{}))(1, 2, 3, 4)); + + BOOST_HOF_TEST_CHECK(3 == boost::hof::arg(three{})(1, 2, 3, 4)); + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::arg(three{})(1, 2, 3, 4)); + BOOST_HOF_TEST_CHECK(3 == boost::hof::flip(boost::hof::arg(three{}))(1, 2, 3, 4)); + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::flip(boost::hof::arg(three{}))(1, 2, 3, 4)); +} + +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7 +#define FINAL +#else +#define FINAL final +#endif + + +struct f FINAL { + int operator()(int i, void *) const { + return i; + } +}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(boost::hof::flip(boost::hof::_ - boost::hof::_)(2, 5), "noexcept flip"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::flip(f())(nullptr, 2) == 2); +} diff --git a/src/boost/libs/hof/test/flow.cpp b/src/boost/libs/hof/test/flow.cpp new file mode 100644 index 000000000..755374e47 --- /dev/null +++ b/src/boost/libs/hof/test/flow.cpp @@ -0,0 +1,169 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + flow.cpp + 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/hof/flow.hpp> +#include <boost/hof/function.hpp> +#include <boost/hof/lambda.hpp> +#include <boost/hof/placeholders.hpp> +#include <memory> +#include "test.hpp" + +namespace flow_test { +struct increment +{ + template<class T> + constexpr T operator()(T x) const noexcept + { + return x + 1; + } +}; + +struct decrement +{ + template<class T> + constexpr T operator()(T x) const noexcept + { + return x - 1; + } +}; + +struct negate +{ + template<class T> + constexpr T operator()(T x) const noexcept + { + return -x; + } +}; + +struct increment_movable +{ + std::unique_ptr<int> n; + increment_movable() + : n(new int(1)) + {} + template<class T> + T operator()(T x) const + { + return x + *n; + } +}; + +struct decrement_movable +{ + std::unique_ptr<int> n; + decrement_movable() + : n(new int(1)) + {} + template<class T> + T operator()(T x) const + { + return x - *n; + } +}; +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::flow(increment(), decrement(), increment())(3)), "noexcept flow"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::flow(boost::hof::identity)(3) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::flow(boost::hof::identity, boost::hof::identity)(3) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::flow(boost::hof::identity, boost::hof::identity, boost::hof::identity)(3) == 3); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::flow(boost::hof::identity)(3) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::flow(boost::hof::identity, boost::hof::identity)(3) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::flow(boost::hof::identity, boost::hof::identity, boost::hof::identity)(3) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + int r = boost::hof::flow(increment(), decrement(), increment())(3); + BOOST_HOF_TEST_CHECK(r == 4); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::flow(increment(), decrement(), increment())(3) == 4); +} + +BOOST_HOF_TEST_CASE() +{ + int r = boost::hof::flow(increment(), negate(), decrement(), decrement())(3); + BOOST_HOF_TEST_CHECK(r == -6); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::flow(increment(), negate(), decrement(), decrement())(3) == -6); +} +#ifndef _MSC_VER +BOOST_HOF_TEST_CASE() +{ + constexpr auto f = boost::hof::flow(increment(), decrement()); + static_assert(std::is_empty<decltype(f)>::value, "Compose function not empty"); + int r = f(3); + BOOST_HOF_TEST_CHECK(r == 3); + BOOST_HOF_STATIC_TEST_CHECK(f(3) == 3); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + STATIC_ASSERT_MOVE_ONLY(increment_movable); + STATIC_ASSERT_MOVE_ONLY(decrement_movable); + int r = boost::hof::flow(increment_movable(), decrement_movable(), increment_movable())(3); + BOOST_HOF_TEST_CHECK(r == 4); +} + +BOOST_HOF_TEST_CASE() +{ + const auto f = boost::hof::flow([](int i) { return i+1; }, [](int i) { return i-1; }, [](int i) { return i+1; }); +#ifndef _MSC_VER + static_assert(std::is_empty<decltype(f)>::value, "Compose function not empty"); +#endif + int r = f(3); + BOOST_HOF_TEST_CHECK(r == 4); +} + + +BOOST_HOF_STATIC_FUNCTION(f_flow_single_function) = boost::hof::flow(increment()); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(f_flow_single_function(3) == 4); + BOOST_HOF_STATIC_TEST_CHECK(f_flow_single_function(3) == 4); +} + +BOOST_HOF_STATIC_FUNCTION(f_flow_function) = boost::hof::flow(increment(), decrement(), increment()); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(f_flow_function(3) == 4); + BOOST_HOF_STATIC_TEST_CHECK(f_flow_function(3) == 4); +} + +BOOST_HOF_STATIC_FUNCTION(f_flow_function_4) = boost::hof::flow(increment(), negate(), decrement(), decrement()); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(f_flow_function_4(3) == -6); + BOOST_HOF_STATIC_TEST_CHECK(f_flow_function_4(3) == -6); +} + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(f_flow_lambda) = boost::hof::flow( + [](int i) { return i+1; }, + [](int i) { return i-1; }, + [](int i) { return i+1; } +); + +BOOST_HOF_TEST_CASE() +{ + int r = f_flow_lambda(3); + BOOST_HOF_TEST_CHECK(r == 4); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::flow(boost::hof::_1 + boost::hof::_1, boost::hof::_1 * boost::hof::_1)(3) == 36); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::flow(boost::hof::_1 + boost::hof::_1, boost::hof::_1 * boost::hof::_1)(3) == 36); +} +} diff --git a/src/boost/libs/hof/test/fold.cpp b/src/boost/libs/hof/test/fold.cpp new file mode 100644 index 000000000..cf1cf9cba --- /dev/null +++ b/src/boost/libs/hof/test/fold.cpp @@ -0,0 +1,93 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + fold.cpp + 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/hof/fold.hpp> +#include "test.hpp" + +struct max_f +{ + template<class T, class U> + constexpr T operator()(T x, U y) const noexcept + { + return x > y ? x : y; + } +}; + +struct sum_f +{ + template<class T, class U> + constexpr T operator()(T x, U y) const BOOST_HOF_RETURNS_DEDUCE_NOEXCEPT(x+y) + { + return x + y; + } +}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::fold(max_f(), 0)(2, 3, 4, 5)), "noexcept fold"); + static_assert(noexcept(boost::hof::fold(sum_f(), 0)(2, 3, 4, 5)), "noexcept fold"); + static_assert(!noexcept(boost::hof::fold(sum_f(), std::string())("hello", "-", "world")), "noexcept fold"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::fold(max_f(), 0)(2, 3, 4, 5) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::fold(max_f(), 0)(5, 4, 3, 2) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::fold(max_f(), 0)(2, 3, 5, 4) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fold(max_f(), 0)(2, 3, 4, 5) == 5); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fold(max_f(), 0)(5, 4, 3, 2) == 5); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fold(max_f(), 0)(2, 3, 5, 4) == 5); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::fold(max_f(), 0)() == 0); + BOOST_HOF_TEST_CHECK(boost::hof::fold(max_f(), 0)(5) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fold(max_f(), 0)() == 0); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fold(max_f(), 0)(5) == 5); +} + +template<class... Ts> +constexpr auto find_positive_max(Ts... xs) BOOST_HOF_RETURNS +( + boost::hof::fold(max_f(), 0)(xs...) +); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(find_positive_max() == 0); + BOOST_HOF_TEST_CHECK(find_positive_max(5) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(find_positive_max() == 0); + BOOST_HOF_STATIC_TEST_CHECK(find_positive_max(5) == 5); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::fold(max_f())(5) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fold(max_f())(5) == 5); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::fold(max_f())(2, 3, 4, 5) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::fold(max_f())(5, 4, 3, 2) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::fold(max_f())(2, 3, 5, 4) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fold(max_f())(2, 3, 4, 5) == 5); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fold(max_f())(5, 4, 3, 2) == 5); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::fold(max_f())(2, 3, 5, 4) == 5); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::fold(sum_f(), std::string())("hello", "-", "world") == "hello-world"); +} diff --git a/src/boost/libs/hof/test/function.cpp b/src/boost/libs/hof/test/function.cpp new file mode 100644 index 000000000..fc4a4774f --- /dev/null +++ b/src/boost/libs/hof/test/function.cpp @@ -0,0 +1,106 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + function.cpp + 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/hof/function.hpp> +#include <boost/hof/partial.hpp> +#include <boost/hof/infix.hpp> +#include <memory> +#include "test.hpp" + +namespace test_constexpr { + +struct sum_f +{ + template<class T, class U> + constexpr T operator()(T x, U y) const + { + return x+y; + } +}; + +BOOST_HOF_STATIC_FUNCTION(sum_init) = sum_f(); + +BOOST_HOF_TEST_CASE() +{ +// TODO: Should be empty on MSVC as well +#ifndef _MSC_VER + STATIC_ASSERT_EMPTY(sum_init); +#endif + BOOST_HOF_TEST_CHECK(3 == sum_init(1, 2)); + + BOOST_HOF_STATIC_TEST_CHECK(3 == sum_init(1, 2)); +} + +BOOST_HOF_STATIC_FUNCTION(sum_partial) = boost::hof::partial(sum_f()); +BOOST_HOF_TEST_CASE() +{ +#ifndef _MSC_VER + STATIC_ASSERT_EMPTY(sum_partial); +#endif + BOOST_HOF_TEST_CHECK(3 == sum_partial(1, 2)); + BOOST_HOF_TEST_CHECK(3 == sum_partial(1)(2)); + + BOOST_HOF_STATIC_TEST_CHECK(3 == sum_partial(1, 2)); + BOOST_HOF_STATIC_TEST_CHECK(3 == sum_partial(1)(2)); +} + +} + +namespace test_static { + +struct sum_f +{ + template<class T, class U> + constexpr T operator()(T x, U y) const + { + return x+y; + } +}; + +struct add_one_f +{ + template<class T> + constexpr T operator()(T x) const + { + return x+1; + } +}; + +BOOST_HOF_STATIC_FUNCTION(sum_partial) = boost::hof::partial(sum_f()); + +BOOST_HOF_TEST_CASE() +{ +#ifndef _MSC_VER + STATIC_ASSERT_EMPTY(sum_partial); +#endif + BOOST_HOF_TEST_CHECK(3 == sum_partial(1, 2)); + BOOST_HOF_TEST_CHECK(3 == sum_partial(1)(2)); +} + +BOOST_HOF_STATIC_FUNCTION(add_one_pipable) = boost::hof::pipable(add_one_f()); + +BOOST_HOF_TEST_CASE() +{ +// TODO: Make this work on msvc +#ifndef _MSC_VER + STATIC_ASSERT_EMPTY(add_one_pipable); +#endif + BOOST_HOF_TEST_CHECK(3 == add_one_pipable(2)); + BOOST_HOF_TEST_CHECK(3 == (2 | add_one_pipable)); +} + +BOOST_HOF_STATIC_FUNCTION(sum_infix) = boost::hof::infix(sum_f()); + +BOOST_HOF_TEST_CASE() +{ +// TODO: Make this work on msvc +#ifndef _MSC_VER + STATIC_ASSERT_EMPTY(sum_infix); +#endif + BOOST_HOF_TEST_CHECK(3 == (1 <sum_infix> 2)); +} + +} diff --git a/src/boost/libs/hof/test/identity.cpp b/src/boost/libs/hof/test/identity.cpp new file mode 100644 index 000000000..d19023f9d --- /dev/null +++ b/src/boost/libs/hof/test/identity.cpp @@ -0,0 +1,68 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + identity.cpp + 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/hof/identity.hpp> +#include <boost/hof/is_invocable.hpp> +#include <boost/hof/detail/move.hpp> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::identity(10) == 10); + BOOST_HOF_TEST_CHECK(boost::hof::identity(10) == 10); +} + +BOOST_HOF_TEST_CASE() +{ + int i = 3; + BOOST_HOF_TEST_CHECK(boost::hof::identity(i) == 3); + BOOST_HOF_TEST_CHECK(&boost::hof::identity(i) == &i); + static_assert(std::is_lvalue_reference<decltype(boost::hof::identity(i))>::value, "Not lvalue"); + static_assert(!std::is_lvalue_reference<decltype(boost::hof::identity(3))>::value, "Not rvalue"); +} + +BOOST_HOF_TEST_CASE() +{ + auto ls = boost::hof::identity({1, 2, 3, 4}); + std::vector<int> v{1, 2, 3, 4}; + BOOST_HOF_TEST_CHECK(std::equal(ls.begin(), ls.end(), v.begin())); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(std::vector<int>(boost::hof::identity({1, 2, 3})) == std::vector<int>{1, 2, 3}); +} + +BOOST_HOF_TEST_CASE() +{ + static_assert(boost::hof::is_invocable<decltype(boost::hof::identity), int>::value, "Identiy callable"); + static_assert(!boost::hof::is_invocable<decltype(boost::hof::identity), int, int>::value, "Identiy not callable"); + static_assert(!boost::hof::is_invocable<decltype(boost::hof::identity)>::value, "Identiy not callable"); +} + +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::identity({1, 2, 3})), "Noexcept identity"); + static_assert(noexcept(boost::hof::identity(1)), "Noexcept identity"); + int i = 5; + static_assert(noexcept(boost::hof::identity(i)), "Noexcept identity"); +} + +struct copy_throws +{ + copy_throws() {} + copy_throws(copy_throws const&) {} + copy_throws(copy_throws&&) noexcept {} +}; + +BOOST_HOF_TEST_CASE() +{ + copy_throws ct{}; + static_assert(noexcept(boost::hof::identity(ct)), "Noexcept identity"); + static_assert(noexcept(boost::hof::identity(boost::hof::move(ct))), "Noexcept identity"); + static_assert(!noexcept(boost::hof::identity(copy_throws{})), "Noexcept identity"); +} + diff --git a/src/boost/libs/hof/test/if.cpp b/src/boost/libs/hof/test/if.cpp new file mode 100644 index 000000000..ee5a98fd1 --- /dev/null +++ b/src/boost/libs/hof/test/if.cpp @@ -0,0 +1,154 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + if.cpp + 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/hof/if.hpp> +#include "test.hpp" + +#include <boost/hof/first_of.hpp> +#include <boost/hof/placeholders.hpp> + + +struct is_5 +{ + template<class T> + constexpr bool operator()(T i) const + { + return i == 5; + } +}; + +struct is_not_5 +{ + template<class T> + constexpr bool operator()(T i) const + { + return i != 5; + } +}; + +template<class F> +struct test_int +{ + template<class T> + constexpr bool operator()(T x) const + { + return boost::hof::first_of( + boost::hof::if_(std::is_integral<T>())(F()), + boost::hof::always(true) + )(x); + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(test_int<is_5>()(5)); + BOOST_HOF_TEST_CHECK(test_int<is_5>()(5L)); + BOOST_HOF_TEST_CHECK(test_int<is_5>()(5.0)); + BOOST_HOF_TEST_CHECK(test_int<is_5>()(6.0)); + + BOOST_HOF_TEST_CHECK(test_int<is_not_5>()(6)); + BOOST_HOF_TEST_CHECK(test_int<is_not_5>()(6L)); + BOOST_HOF_TEST_CHECK(test_int<is_not_5>()(5.0)); + BOOST_HOF_TEST_CHECK(test_int<is_not_5>()(6.0)); + + BOOST_HOF_STATIC_TEST_CHECK(test_int<is_5>()(5)); + BOOST_HOF_STATIC_TEST_CHECK(test_int<is_5>()(5L)); + BOOST_HOF_STATIC_TEST_CHECK(test_int<is_5>()(5.0)); + BOOST_HOF_STATIC_TEST_CHECK(test_int<is_5>()(6.0)); + + BOOST_HOF_STATIC_TEST_CHECK(test_int<is_not_5>()(6)); + BOOST_HOF_STATIC_TEST_CHECK(test_int<is_not_5>()(6L)); + BOOST_HOF_STATIC_TEST_CHECK(test_int<is_not_5>()(5.0)); + BOOST_HOF_STATIC_TEST_CHECK(test_int<is_not_5>()(6.0)); +} + +template<class F> +struct test_int_c +{ + template<class T> + constexpr bool operator()(T x) const + { + return boost::hof::first_of( + boost::hof::if_c<std::is_integral<T>::value>(F()), + boost::hof::always(true) + )(x); + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(test_int_c<is_5>()(5)); + BOOST_HOF_TEST_CHECK(test_int_c<is_5>()(5L)); + BOOST_HOF_TEST_CHECK(test_int_c<is_5>()(5.0)); + BOOST_HOF_TEST_CHECK(test_int_c<is_5>()(6.0)); + + BOOST_HOF_TEST_CHECK(test_int_c<is_not_5>()(6)); + BOOST_HOF_TEST_CHECK(test_int_c<is_not_5>()(6L)); + BOOST_HOF_TEST_CHECK(test_int_c<is_not_5>()(5.0)); + BOOST_HOF_TEST_CHECK(test_int_c<is_not_5>()(6.0)); + + BOOST_HOF_STATIC_TEST_CHECK(test_int_c<is_5>()(5)); + BOOST_HOF_STATIC_TEST_CHECK(test_int_c<is_5>()(5L)); + BOOST_HOF_STATIC_TEST_CHECK(test_int_c<is_5>()(5.0)); + BOOST_HOF_STATIC_TEST_CHECK(test_int_c<is_5>()(6.0)); + + BOOST_HOF_STATIC_TEST_CHECK(test_int_c<is_not_5>()(6)); + BOOST_HOF_STATIC_TEST_CHECK(test_int_c<is_not_5>()(6L)); + BOOST_HOF_STATIC_TEST_CHECK(test_int_c<is_not_5>()(5.0)); + BOOST_HOF_STATIC_TEST_CHECK(test_int_c<is_not_5>()(6.0)); +} + +struct sum_f +{ + template<class T> + constexpr int operator()(T x, T y) const + { + return boost::hof::first_of( + boost::hof::if_(std::is_integral<T>())(boost::hof::_ + boost::hof::_), + boost::hof::always(0) + )(x, y); + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(sum_f()(1, 2) == 3); + BOOST_HOF_TEST_CHECK(sum_f()(1.0, 2.0) == 0); + BOOST_HOF_TEST_CHECK(sum_f()("", "") == 0); + + BOOST_HOF_STATIC_TEST_CHECK(sum_f()(1, 2) == 3); + BOOST_HOF_STATIC_TEST_CHECK(sum_f()("", "") == 0); +} + + +struct sum_f_c +{ + template<class T> + constexpr int operator()(T x, T y) const + { + return boost::hof::first_of( + boost::hof::if_c<std::is_integral<T>::value>(boost::hof::_ + boost::hof::_), + boost::hof::always(0) + )(x, y); + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(sum_f_c()(1, 2) == 3); + BOOST_HOF_TEST_CHECK(sum_f_c()(1.0, 2.0) == 0); + BOOST_HOF_TEST_CHECK(sum_f_c()("", "") == 0); + + BOOST_HOF_STATIC_TEST_CHECK(sum_f_c()(1, 2) == 3); + BOOST_HOF_STATIC_TEST_CHECK(sum_f_c()("", "") == 0); +} + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::if_(std::is_integral<int>())(boost::hof::identity)(1)), "noexcept if"); +} +#endif diff --git a/src/boost/libs/hof/test/implicit.cpp b/src/boost/libs/hof/test/implicit.cpp new file mode 100644 index 000000000..2f6624f4d --- /dev/null +++ b/src/boost/libs/hof/test/implicit.cpp @@ -0,0 +1,56 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + implicit.cpp + 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/hof/implicit.hpp> +#include "test.hpp" + +template<class T> +struct auto_caster +{ + template<class U> + T operator()(U x) + { + return T(x); + } +}; + +template<class T> +struct auto_caster_noexcept +{ + template<class U> + T operator()(U x) noexcept + { + return T(x); + } +}; + +struct auto_caster_foo +{ + int i; + explicit auto_caster_foo(int ip) : i(ip) {} + +}; +// TODO: Test template constraint on conversion operator +static constexpr boost::hof::implicit<auto_caster> auto_cast = {}; + +BOOST_HOF_TEST_CASE() +{ + float f = 1.5; + int i = auto_cast(f); + // auto_caster_foo x = 1; + auto_caster_foo x = auto_cast(1); + BOOST_HOF_TEST_CHECK(1 == i); + BOOST_HOF_TEST_CHECK(1 == x.i); + +} +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + boost::hof::implicit<auto_caster_noexcept> lauto_cast{}; + float f = 1.5; + static_assert(noexcept(int(lauto_cast(f))), "noexcept implicit"); +} +#endif diff --git a/src/boost/libs/hof/test/indirect.cpp b/src/boost/libs/hof/test/indirect.cpp new file mode 100644 index 000000000..b1e3e548f --- /dev/null +++ b/src/boost/libs/hof/test/indirect.cpp @@ -0,0 +1,52 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + indirect.cpp + 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/hof/indirect.hpp> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::indirect(std::unique_ptr<binary_class>(new binary_class()))(1, 2)); + BOOST_HOF_TEST_CHECK(3 == boost::hof::reveal(boost::hof::indirect(std::unique_ptr<binary_class>(new binary_class())))(1, 2)); + + binary_class f; + + BOOST_HOF_TEST_CHECK(3 == boost::hof::indirect(&f)(1, 2)); + BOOST_HOF_TEST_CHECK(3 == boost::hof::reveal(boost::hof::indirect(&f))(1, 2)); +} +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + binary_class f; + static_assert(noexcept(boost::hof::indirect(&f)(1, 2)), "noexcept indirect"); +} +#endif + +struct mutable_function +{ + mutable_function() : value(0) {} + void operator()(int a) { value += a; } + int value; +}; + +BOOST_HOF_TEST_CASE() +{ + auto mf = mutable_function{}; + boost::hof::indirect(&mf)(15); + boost::hof::indirect(&mf)(2); + BOOST_HOF_TEST_CHECK(mf.value == 17); +} + + +BOOST_HOF_TEST_CASE() +{ + auto mf = std::make_shared<mutable_function>(); + boost::hof::indirect(mf)(15); + boost::hof::indirect(mf)(2); + BOOST_HOF_TEST_CHECK(mf->value == 17); +} + + diff --git a/src/boost/libs/hof/test/infix.cpp b/src/boost/libs/hof/test/infix.cpp new file mode 100644 index 000000000..6b79489f4 --- /dev/null +++ b/src/boost/libs/hof/test/infix.cpp @@ -0,0 +1,115 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + infix.cpp + 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/hof/infix.hpp> +#include <boost/hof/function.hpp> +#include <boost/hof/lambda.hpp> +#include <boost/hof/pipable.hpp> +#include <boost/hof/placeholders.hpp> +#include "test.hpp" + +struct sum_f +{ + template<class T, class U> + constexpr T operator()(T x, U y) const BOOST_HOF_RETURNS_DEDUCE_NOEXCEPT(x+y) + { + return x+y; + } +}; + +static constexpr boost::hof::infix_adaptor<sum_f> sum = {}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(1 <sum> 2), "noexcept infix"); + static_assert(!noexcept(std::string() <sum> std::string()), "noexcept infix"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == (1 <sum> 2)); + BOOST_HOF_STATIC_TEST_CHECK(3 == (1 <sum> 2)); + + BOOST_HOF_TEST_CHECK(3 == (sum(1, 2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == (sum(1, 2))); +} + +BOOST_HOF_STATIC_FUNCTION(sum1) = boost::hof::infix(sum_f()); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == (1 <sum1> 2)); + BOOST_HOF_STATIC_TEST_CHECK(3 == (1 <sum1> 2)); + + BOOST_HOF_TEST_CHECK(3 == (sum1(1, 2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == (sum1(1, 2))); +} + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(sum2) = boost::hof::infix([](int x, int y) { return x + y; }); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == (1 <sum2> 2)); + + BOOST_HOF_TEST_CHECK(3 == (sum2(1, 2))); +} + +BOOST_HOF_STATIC_FUNCTION(sum3) = boost::hof::infix(boost::hof::_ + boost::hof::_); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == (1 <sum3> 2)); + BOOST_HOF_STATIC_TEST_CHECK(3 == (1 <sum3> 2)); + + BOOST_HOF_TEST_CHECK(3 == (sum3(1, 2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == (sum3(1, 2))); +} + + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(sum4) = boost::hof::infix(boost::hof::infix([](int x, int y) { return x + y; })); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == (1 <sum4> 2)); + + BOOST_HOF_TEST_CHECK(3 == (sum4(1, 2))); +} + +BOOST_HOF_STATIC_FUNCTION(sum5) = boost::hof::infix(boost::hof::infix(boost::hof::_ + boost::hof::_)); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == (1 <sum5> 2)); + BOOST_HOF_STATIC_TEST_CHECK(3 == (1 <sum5> 2)); + + BOOST_HOF_TEST_CHECK(3 == (sum5(1, 2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == (sum5(1, 2))); +} + +BOOST_HOF_TEST_CASE() +{ +#if (defined(__GNUC__) && !defined (__clang__)) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wparentheses" +#endif + BOOST_HOF_TEST_CHECK(6 == (1 + 2 <sum> 3)); + BOOST_HOF_TEST_CHECK(3 == 1 <sum> 2); +#if (defined(__GNUC__) && !defined (__clang__)) +#pragma GCC diagnostic pop +#endif +} + +struct foo {}; + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::infix([](int, int) { return foo{}; }); + auto g = boost::hof::infix([](foo, foo) { return std::string("hello"); }); + BOOST_HOF_TEST_CHECK((1 <f> 2 <g> foo{}) == "hello"); + +} diff --git a/src/boost/libs/hof/test/is_invocable.cpp b/src/boost/libs/hof/test/is_invocable.cpp new file mode 100644 index 000000000..e65d49c15 --- /dev/null +++ b/src/boost/libs/hof/test/is_invocable.cpp @@ -0,0 +1,192 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + is_invocable.cpp + 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/hof/is_invocable.hpp> +#include <ciso646> +#include "test.hpp" + +template<int N> +struct callable_rank : callable_rank<N-1> +{}; + +template<> +struct callable_rank<0> +{}; + +BOOST_HOF_STATIC_TEST_CASE() +{ + struct is_callable_class + { + void operator()(int) const + { + } + }; + struct callable_test_param {}; + + void is_callable_function(int) + { + } + + struct is_callable_rank_class + { + void operator()(int, callable_rank<3>) const + { + } + + void operator()(int, callable_rank<4>) const + { + } + }; + + static_assert(boost::hof::is_invocable<is_callable_class, int>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_class, long>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_class, double>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_class, const int&>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_class, const long&>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_class, const double&>::value, "Not callable"); + static_assert(not boost::hof::is_invocable<is_callable_class, callable_test_param>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_class>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_class, int, int>::value, "callable failed"); + + typedef void (*is_callable_function_pointer)(int); + static_assert(boost::hof::is_invocable<is_callable_function_pointer, int>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_function_pointer, long>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_function_pointer, double>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_function_pointer, const int&>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_function_pointer, const long&>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_function_pointer, const double&>::value, "Not callable"); + static_assert(not boost::hof::is_invocable<is_callable_function_pointer, callable_test_param>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_function_pointer>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_function_pointer, int, int>::value, "callable failed"); + + static_assert(boost::hof::is_invocable<is_callable_rank_class, int, callable_rank<3>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, long, callable_rank<3>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, double, callable_rank<3>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const int&, callable_rank<3>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const long&, callable_rank<3>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const double&, callable_rank<3>>::value, "Not callable"); + + static_assert(boost::hof::is_invocable<is_callable_rank_class, int, callable_rank<4>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, long, callable_rank<4>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, double, callable_rank<4>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const int&, callable_rank<4>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const long&, callable_rank<4>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const double&, callable_rank<4>>::value, "Not callable"); + + static_assert(boost::hof::is_invocable<is_callable_rank_class, int, callable_rank<5>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, long, callable_rank<5>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, double, callable_rank<5>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const int&, callable_rank<5>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const long&, callable_rank<5>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const double&, callable_rank<5>>::value, "Not callable"); + + static_assert(boost::hof::is_invocable<is_callable_rank_class, int, callable_rank<6>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, long, callable_rank<6>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, double, callable_rank<6>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const int&, callable_rank<6>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const long&, callable_rank<6>>::value, "Not callable"); + static_assert(boost::hof::is_invocable<is_callable_rank_class, const double&, callable_rank<6>>::value, "Not callable"); + + static_assert(not boost::hof::is_invocable<is_callable_rank_class, int, callable_rank<1>>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, long, callable_rank<1>>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, double, callable_rank<1>>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, const int&, callable_rank<1>>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, const long&, callable_rank<1>>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, const double&, callable_rank<1>>::value, "callable failed"); + + static_assert(not boost::hof::is_invocable<is_callable_rank_class, callable_test_param, callable_test_param>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, callable_rank<3>, callable_test_param>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, callable_rank<4>, callable_test_param>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, callable_test_param, callable_rank<3>>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, callable_test_param, callable_rank<4>>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class>::value, "callable failed"); + static_assert(not boost::hof::is_invocable<is_callable_rank_class, int, int>::value, "callable failed"); +}; + +BOOST_HOF_STATIC_TEST_CASE() +{ + typedef int(callable_rank<0>::*fn)(int); + + static_assert(boost::hof::is_invocable<fn, callable_rank<0>&, int>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, callable_rank<1>&, int>::value, "Failed"); + static_assert(!boost::hof::is_invocable<fn, callable_rank<0>&>::value, "Failed"); + static_assert(!boost::hof::is_invocable<fn, callable_rank<0> const&, int>::value, "Failed"); +}; + +BOOST_HOF_STATIC_TEST_CASE() +{ + typedef int(callable_rank<0>::*fn)(int); + + typedef callable_rank<0>* T; + typedef callable_rank<1>* DT; + typedef const callable_rank<0>* CT; + typedef std::unique_ptr<callable_rank<0>> ST; + + static_assert(boost::hof::is_invocable<fn, T&, int>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, DT&, int>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, const T&, int>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, T&&, int>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, ST, int>::value, "Failed"); + static_assert(!boost::hof::is_invocable<fn, CT&, int>::value, "Failed"); + +}; + +BOOST_HOF_STATIC_TEST_CASE() +{ + typedef int(callable_rank<0>::*fn); + + static_assert(!boost::hof::is_invocable<fn>::value, "Failed"); +}; + +BOOST_HOF_STATIC_TEST_CASE() +{ + typedef int(callable_rank<0>::*fn); + + static_assert(boost::hof::is_invocable<fn, callable_rank<0>&>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, callable_rank<0>&&>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, const callable_rank<0>&>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, callable_rank<1>&>::value, "Failed"); +}; + +BOOST_HOF_STATIC_TEST_CASE() +{ + typedef int(callable_rank<0>::*fn); + + typedef callable_rank<0>* T; + typedef callable_rank<1>* DT; + typedef const callable_rank<0>* CT; + typedef std::unique_ptr<callable_rank<0>> ST; + + static_assert(boost::hof::is_invocable<fn, T&>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, DT&>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, const T&>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, T&&>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, ST>::value, "Failed"); + static_assert(boost::hof::is_invocable<fn, CT&>::value, "Failed"); + +}; + +BOOST_HOF_STATIC_TEST_CASE() +{ + typedef void(*fp)(callable_rank<0>&, int); + + static_assert(boost::hof::is_invocable<fp, callable_rank<0>&, int>::value, "Failed"); + static_assert(boost::hof::is_invocable<fp, callable_rank<1>&, int>::value, "Failed"); + static_assert(!boost::hof::is_invocable<fp, const callable_rank<0>&, int>::value, "Failed"); + static_assert(!boost::hof::is_invocable<fp>::value, "Failed"); + static_assert(!boost::hof::is_invocable<fp, callable_rank<0>&>::value, "Failed"); +}; + +BOOST_HOF_STATIC_TEST_CASE() +{ + typedef void(&fp)(callable_rank<0>&, int); + + static_assert(boost::hof::is_invocable<fp, callable_rank<0>&, int>::value, "Failed"); + static_assert(boost::hof::is_invocable<fp, callable_rank<1>&, int>::value, "Failed"); + static_assert(!boost::hof::is_invocable<fp, const callable_rank<0>&, int>::value, "Failed"); + static_assert(!boost::hof::is_invocable<fp>::value, "Failed"); + static_assert(!boost::hof::is_invocable<fp, callable_rank<0>&>::value, "Failed"); +}; diff --git a/src/boost/libs/hof/test/issue8.cpp b/src/boost/libs/hof/test/issue8.cpp new file mode 100644 index 000000000..08acb9a70 --- /dev/null +++ b/src/boost/libs/hof/test/issue8.cpp @@ -0,0 +1,48 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + issue8.cpp + 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 "test.hpp" +#include <vector> +#include <boost/hof/pipable.hpp> +#include <boost/hof/placeholders.hpp> +#include <algorithm> + + +struct filter_fn +{ + template<class Input, class P> + Input operator()(Input input, P pred) const + { + Input output(input.size()); + output.erase( + ::std::copy_if( + ::std::begin(input), + ::std::end(input), + ::std::begin(output), + pred + ), + ::std::end(output) + ); + return output; + } +}; + +static constexpr boost::hof::pipable_adaptor<filter_fn> filter = {}; + +BOOST_HOF_TEST_CASE() +{ + std::vector<int> data; + for(int i=0;i<6;i++) + { + data.push_back(i); + } + std::vector<int> r1 = data | filter(boost::hof::_1 > 1); + BOOST_HOF_TEST_CHECK(r1.size() == 4); + + std::vector<int> r2 = filter(data, boost::hof::_1 > 1); + BOOST_HOF_TEST_CHECK(r2.size() == 4); +} diff --git a/src/boost/libs/hof/test/lambda.cpp b/src/boost/libs/hof/test/lambda.cpp new file mode 100644 index 000000000..42e79959f --- /dev/null +++ b/src/boost/libs/hof/test/lambda.cpp @@ -0,0 +1,103 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + lambda.cpp + 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/hof/lambda.hpp> +#include <boost/hof/first_of.hpp> +#include <boost/hof/partial.hpp> +#include <boost/hof/infix.hpp> +#include <boost/hof/pipable.hpp> +#include <memory> +#include "test.hpp" + + +static constexpr auto add_one = BOOST_HOF_STATIC_LAMBDA(int x) +{ + return x + 1; +}; + +template<class F> +struct wrapper : F +{ + BOOST_HOF_INHERIT_CONSTRUCTOR(wrapper, F) +}; + +template<class T> +constexpr wrapper<T> wrap(T x) +{ + return x; +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == add_one(2)); +} + +BOOST_HOF_TEST_CASE() +{ + constexpr auto add_one_again = add_one; + BOOST_HOF_TEST_CHECK(3 == add_one_again(2)); +} + +BOOST_HOF_TEST_CASE() +{ + constexpr auto add_one_again = wrap(add_one); + BOOST_HOF_TEST_CHECK(3 == add_one_again(2)); +} + +namespace test_static { + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(add_one) = [](int x) +{ + return x + 1; +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(add_one(2) == 3); +} + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(sum_partial) = boost::hof::partial([](int x, int y) +{ + return x + y; +}); + +BOOST_HOF_TEST_CASE() +{ +#ifndef _MSC_VER + STATIC_ASSERT_EMPTY(sum_partial); +#endif + BOOST_HOF_TEST_CHECK(3 == sum_partial(1, 2)); + BOOST_HOF_TEST_CHECK(3 == sum_partial(1)(2)); +} + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(add_one_pipable) = boost::hof::pipable([](int x) +{ + return x + 1; +}); + +BOOST_HOF_TEST_CASE() +{ +#ifndef _MSC_VER + STATIC_ASSERT_EMPTY(add_one_pipable); +#endif + BOOST_HOF_TEST_CHECK(3 == add_one_pipable(2)); + BOOST_HOF_TEST_CHECK(3 == (2 | add_one_pipable)); +} + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(sum_infix) = boost::hof::infix([](int x, int y) +{ + return x + y; +}); + +BOOST_HOF_TEST_CASE() +{ +#ifndef _MSC_VER + STATIC_ASSERT_EMPTY(sum_infix); +#endif + BOOST_HOF_TEST_CHECK(3 == (1 <sum_infix> 2)); +} + +} diff --git a/src/boost/libs/hof/test/lazy.cpp b/src/boost/libs/hof/test/lazy.cpp new file mode 100644 index 000000000..bea58fe69 --- /dev/null +++ b/src/boost/libs/hof/test/lazy.cpp @@ -0,0 +1,713 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + lazy.cpp + 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/hof/lazy.hpp> +#include <memory> +#include "test.hpp" + +template<int N> +struct test_placeholder +{}; + +namespace std { + template<int N> + struct is_placeholder<test_placeholder<N>> + : std::integral_constant<int, N> + {}; +} + +BOOST_HOF_TEST_CASE() +{ + int i = 5; + + static_assert(std::is_reference<decltype(boost::hof::detail::ref_transformer()(std::ref(i))(0,0,0))>::value, "Reference wrapper failed"); + static_assert(std::is_reference<decltype(boost::hof::detail::pick_transformer(std::ref(i))(0,0,0))>::value, "Reference wrapper failed"); + static_assert(std::is_reference<decltype(boost::hof::detail::lazy_transform(std::ref(i), boost::hof::pack_basic(0,0,0)))>::value, "Reference wrapper failed"); + + BOOST_HOF_TEST_CHECK(&boost::hof::detail::ref_transformer()(std::ref(i))(0,0,0) == &i); + BOOST_HOF_TEST_CHECK(&boost::hof::detail::pick_transformer(std::ref(i))(0,0,0) == &i); + BOOST_HOF_TEST_CHECK(&boost::hof::detail::lazy_transform(std::ref(i), boost::hof::pack_basic(0,0,0)) == &i); +} + +BOOST_HOF_TEST_CASE() +{ + int i = 5; + + BOOST_HOF_TEST_CHECK(boost::hof::detail::id_transformer()(i)(0,0,0) == i); + BOOST_HOF_TEST_CHECK(boost::hof::detail::pick_transformer(i)(0,0,0) == i); + BOOST_HOF_TEST_CHECK(boost::hof::detail::lazy_transform(i, boost::hof::pack_basic(0,0,0)) == i); +} + +BOOST_HOF_TEST_CASE() +{ + auto id =[](int i){ return i;}; + auto fi = std::bind(id, 5); + + BOOST_HOF_TEST_CHECK(boost::hof::detail::bind_transformer()(fi)(0,0,0) == id(5)); + BOOST_HOF_TEST_CHECK(boost::hof::detail::pick_transformer(fi)(0,0,0) == id(5)); + BOOST_HOF_TEST_CHECK(boost::hof::detail::lazy_transform(fi, boost::hof::pack_basic(0,0,0)) == id(5)); +} + +struct f_0 { +constexpr long operator()() const +{ + return 17041L; +} +}; + +struct f_1 { +constexpr long operator()(long a) const +{ + return a; +} +}; + +struct f_2 { +constexpr long operator()(long a, long b) const +{ + return a + 10 * b; +} +}; + +static long global_result; + +struct fv_0 { +void operator()() const +{ + global_result = 17041L; +} +}; + +struct fv_1 { +void operator()(long a) const +{ + global_result = a; +} +}; + +struct fv_2 { +void operator()(long a, long b) const +{ + global_result = a + 10 * b; +} +}; + +struct Y +{ + short operator()(short & r) const { return ++r; } + int operator()(int a, int b) const { return a + 10 * b; } + long operator() (long a, long b, long c) const { return a + 10 * b + 100 * c; } + void operator() (long a, long b, long c, long d) const { global_result = a + 10 * b + 100 * c + 1000 * d; } +}; + +BOOST_HOF_TEST_CASE() +{ + short i(6); + + int const k = 3; + + BOOST_HOF_TEST_CHECK( boost::hof::lazy(Y())( std::ref(i))() == 7 ); + BOOST_HOF_TEST_CHECK( boost::hof::lazy(Y())( std::ref(i))() == 8 ); + BOOST_HOF_TEST_CHECK( boost::hof::lazy(Y())( i,std::placeholders::_1)(k) == 38 ); + BOOST_HOF_TEST_CHECK( boost::hof::lazy(Y())( i,std::placeholders::_1, 9)(k) == 938 ); + + global_result = 0; + boost::hof::lazy(Y())( i,std::placeholders::_1, 9, 4)(k); + BOOST_HOF_TEST_CHECK( global_result == 4938 ); + +} + +BOOST_HOF_TEST_CASE() +{ + int const x = 1; + int const y = 2; + + BOOST_HOF_TEST_CHECK( boost::hof::lazy(f_1())( boost::hof::lazy(f_1())(std::placeholders::_1))(x) == 1L ); + BOOST_HOF_TEST_CHECK( boost::hof::lazy(f_1())( boost::hof::lazy(f_2())(std::placeholders::_1, std::placeholders::_2))(x, y) == 21L ); + BOOST_HOF_TEST_CHECK( boost::hof::lazy(f_2())( boost::hof::lazy(f_1())(std::placeholders::_1), boost::hof::lazy(f_1())(std::placeholders::_1))(x) == 11L ); + BOOST_HOF_TEST_CHECK( boost::hof::lazy(f_2())( boost::hof::lazy(f_1())(std::placeholders::_1), boost::hof::lazy(f_1())( std::placeholders::_2))(x, y) == 21L ); + BOOST_HOF_TEST_CHECK( boost::hof::lazy(f_1())( boost::hof::lazy(f_0())())() == 17041L ); + + BOOST_HOF_STATIC_TEST_CHECK( boost::hof::lazy(f_1())( boost::hof::lazy(f_1())(test_placeholder<1>()))(x) == 1L ); + BOOST_HOF_STATIC_TEST_CHECK( boost::hof::lazy(f_1())( boost::hof::lazy(f_2())(test_placeholder<1>(), test_placeholder<2>()))(x, y) == 21L ); + BOOST_HOF_STATIC_TEST_CHECK( boost::hof::lazy(f_2())( boost::hof::lazy(f_1())(test_placeholder<1>()), boost::hof::lazy(f_1())(test_placeholder<1>()))(x) == 11L ); + BOOST_HOF_STATIC_TEST_CHECK( boost::hof::lazy(f_2())( boost::hof::lazy(f_1())(test_placeholder<1>()), boost::hof::lazy(f_1())( test_placeholder<2>()))(x, y) == 21L ); + BOOST_HOF_STATIC_TEST_CHECK( boost::hof::lazy(f_1())( boost::hof::lazy(f_0())())() == 17041L ); + + BOOST_HOF_TEST_CHECK( (boost::hof::lazy(fv_1())( boost::hof::lazy(f_1())(std::placeholders::_1))(x), (global_result == 1L)) ); + BOOST_HOF_TEST_CHECK( (boost::hof::lazy(fv_1())( boost::hof::lazy(f_2())(std::placeholders::_1, std::placeholders::_2))(x, y), (global_result == 21L)) ); + BOOST_HOF_TEST_CHECK( (boost::hof::lazy(fv_2())( boost::hof::lazy(f_1())(std::placeholders::_1), boost::hof::lazy(f_1())(std::placeholders::_1))(x), (global_result == 11L)) ); + BOOST_HOF_TEST_CHECK( (boost::hof::lazy(fv_2())( boost::hof::lazy(f_1())(std::placeholders::_1), boost::hof::lazy(f_1())( std::placeholders::_2))(x, y), (global_result == 21L)) ); + BOOST_HOF_TEST_CHECK( (boost::hof::lazy(fv_1())( boost::hof::lazy(f_0())())(), (global_result == 17041L)) ); +} + + +struct X +{ + mutable unsigned int hash; + + X(): hash(0) {} + + int f0() { f1(17); return 0; } + int g0() const { g1(17); return 0; } + + int f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; } + int g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; } + + int f2(int a1, int a2) { f1(a1); f1(a2); return 0; } + int g2(int a1, int a2) const { g1(a1); g1(a2); return 0; } + + int f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; } + int g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; } + + int f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; } + int g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; } + + int f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; } + int g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; } + + int f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; } + int g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; } + + int f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; } + int g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; } + + int f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; } + int g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; } +}; + +struct V +{ + mutable unsigned int hash; + + V(): hash(0) {} + + void f0() { f1(17); } + void g0() const { g1(17); } + + void f1(int a1) { hash = (hash * 17041 + a1) % 32768; } + void g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; } + + void f2(int a1, int a2) { f1(a1); f1(a2); } + void g2(int a1, int a2) const { g1(a1); g1(a2); } + + void f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); } + void g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); } + + void f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); } + void g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); } + + void f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); } + void g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); } + + void f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); } + void g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); } + + void f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); } + void g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); } + + void f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); } + void g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); } +}; + +BOOST_HOF_TEST_CASE() +{ + + X x; + + // 0 + + boost::hof::lazy(&X::f0)(&x)(); + boost::hof::lazy(&X::f0)(std::ref(x))(); + + boost::hof::lazy(&X::g0)(&x)(); + boost::hof::lazy(&X::g0)(x)(); + boost::hof::lazy(&X::g0)(std::ref(x))(); + + // 1 + + boost::hof::lazy(&X::f1)(&x, 1)(); + boost::hof::lazy(&X::f1)(std::ref(x), 1)(); + + boost::hof::lazy(&X::g1)(&x, 1)(); + boost::hof::lazy(&X::g1)(x, 1)(); + boost::hof::lazy(&X::g1)(std::ref(x), 1)(); + + // 2 + + boost::hof::lazy(&X::f2)(&x, 1, 2)(); + boost::hof::lazy(&X::f2)(std::ref(x), 1, 2)(); + + boost::hof::lazy(&X::g2)(&x, 1, 2)(); + boost::hof::lazy(&X::g2)(x, 1, 2)(); + boost::hof::lazy(&X::g2)(std::ref(x), 1, 2)(); + + // 3 + + boost::hof::lazy(&X::f3)(&x, 1, 2, 3)(); + boost::hof::lazy(&X::f3)(std::ref(x), 1, 2, 3)(); + + boost::hof::lazy(&X::g3)(&x, 1, 2, 3)(); + boost::hof::lazy(&X::g3)(x, 1, 2, 3)(); + boost::hof::lazy(&X::g3)(std::ref(x), 1, 2, 3)(); + + // 4 + + boost::hof::lazy(&X::f4)(&x, 1, 2, 3, 4)(); + boost::hof::lazy(&X::f4)(std::ref(x), 1, 2, 3, 4)(); + + boost::hof::lazy(&X::g4)(&x, 1, 2, 3, 4)(); + boost::hof::lazy(&X::g4)(x, 1, 2, 3, 4)(); + boost::hof::lazy(&X::g4)(std::ref(x), 1, 2, 3, 4)(); + + // 5 + + boost::hof::lazy(&X::f5)(&x, 1, 2, 3, 4, 5)(); + boost::hof::lazy(&X::f5)(std::ref(x), 1, 2, 3, 4, 5)(); + + boost::hof::lazy(&X::g5)(&x, 1, 2, 3, 4, 5)(); + boost::hof::lazy(&X::g5)(x, 1, 2, 3, 4, 5)(); + boost::hof::lazy(&X::g5)(std::ref(x), 1, 2, 3, 4, 5)(); + + // 6 + + boost::hof::lazy(&X::f6)(&x, 1, 2, 3, 4, 5, 6)(); + boost::hof::lazy(&X::f6)(std::ref(x), 1, 2, 3, 4, 5, 6)(); + + boost::hof::lazy(&X::g6)(&x, 1, 2, 3, 4, 5, 6)(); + boost::hof::lazy(&X::g6)(x, 1, 2, 3, 4, 5, 6)(); + boost::hof::lazy(&X::g6)(std::ref(x), 1, 2, 3, 4, 5, 6)(); + + // 7 + + boost::hof::lazy(&X::f7)(&x, 1, 2, 3, 4, 5, 6, 7)(); + boost::hof::lazy(&X::f7)(std::ref(x), 1, 2, 3, 4, 5, 6, 7)(); + + boost::hof::lazy(&X::g7)(&x, 1, 2, 3, 4, 5, 6, 7)(); + boost::hof::lazy(&X::g7)(x, 1, 2, 3, 4, 5, 6, 7)(); + boost::hof::lazy(&X::g7)(std::ref(x), 1, 2, 3, 4, 5, 6, 7)(); + + // 8 + + boost::hof::lazy(&X::f8)(&x, 1, 2, 3, 4, 5, 6, 7, 8)(); + boost::hof::lazy(&X::f8)(std::ref(x), 1, 2, 3, 4, 5, 6, 7, 8)(); + + boost::hof::lazy(&X::g8)(&x, 1, 2, 3, 4, 5, 6, 7, 8)(); + boost::hof::lazy(&X::g8)(x, 1, 2, 3, 4, 5, 6, 7, 8)(); + boost::hof::lazy(&X::g8)(std::ref(x), 1, 2, 3, 4, 5, 6, 7, 8)(); + + BOOST_HOF_TEST_CHECK( x.hash == 23558 ); +} + +BOOST_HOF_TEST_CASE() +{ + V v; + + // 0 + + boost::hof::lazy(&V::f0)(&v)(); + boost::hof::lazy(&V::f0)(std::ref(v))(); + + boost::hof::lazy(&V::g0)(&v)(); + boost::hof::lazy(&V::g0)(v)(); + boost::hof::lazy(&V::g0)(std::ref(v))(); + + // 1 + + boost::hof::lazy(&V::f1)(&v, 1)(); + boost::hof::lazy(&V::f1)(std::ref(v), 1)(); + + boost::hof::lazy(&V::g1)(&v, 1)(); + boost::hof::lazy(&V::g1)(v, 1)(); + boost::hof::lazy(&V::g1)(std::ref(v), 1)(); + + // 2 + + boost::hof::lazy(&V::f2)(&v, 1, 2)(); + boost::hof::lazy(&V::f2)(std::ref(v), 1, 2)(); + + boost::hof::lazy(&V::g2)(&v, 1, 2)(); + boost::hof::lazy(&V::g2)(v, 1, 2)(); + boost::hof::lazy(&V::g2)(std::ref(v), 1, 2)(); + + // 3 + + boost::hof::lazy(&V::f3)(&v, 1, 2, 3)(); + boost::hof::lazy(&V::f3)(std::ref(v), 1, 2, 3)(); + + boost::hof::lazy(&V::g3)(&v, 1, 2, 3)(); + boost::hof::lazy(&V::g3)(v, 1, 2, 3)(); + boost::hof::lazy(&V::g3)(std::ref(v), 1, 2, 3)(); + + // 4 + + boost::hof::lazy(&V::f4)(&v, 1, 2, 3, 4)(); + boost::hof::lazy(&V::f4)(std::ref(v), 1, 2, 3, 4)(); + + boost::hof::lazy(&V::g4)(&v, 1, 2, 3, 4)(); + boost::hof::lazy(&V::g4)(v, 1, 2, 3, 4)(); + boost::hof::lazy(&V::g4)(std::ref(v), 1, 2, 3, 4)(); + + // 5 + + boost::hof::lazy(&V::f5)(&v, 1, 2, 3, 4, 5)(); + boost::hof::lazy(&V::f5)(std::ref(v), 1, 2, 3, 4, 5)(); + + boost::hof::lazy(&V::g5)(&v, 1, 2, 3, 4, 5)(); + boost::hof::lazy(&V::g5)(v, 1, 2, 3, 4, 5)(); + boost::hof::lazy(&V::g5)(std::ref(v), 1, 2, 3, 4, 5)(); + + // 6 + + boost::hof::lazy(&V::f6)(&v, 1, 2, 3, 4, 5, 6)(); + boost::hof::lazy(&V::f6)(std::ref(v), 1, 2, 3, 4, 5, 6)(); + + boost::hof::lazy(&V::g6)(&v, 1, 2, 3, 4, 5, 6)(); + boost::hof::lazy(&V::g6)(v, 1, 2, 3, 4, 5, 6)(); + boost::hof::lazy(&V::g6)(std::ref(v), 1, 2, 3, 4, 5, 6)(); + + // 7 + + boost::hof::lazy(&V::f7)(&v, 1, 2, 3, 4, 5, 6, 7)(); + boost::hof::lazy(&V::f7)(std::ref(v), 1, 2, 3, 4, 5, 6, 7)(); + + boost::hof::lazy(&V::g7)(&v, 1, 2, 3, 4, 5, 6, 7)(); + boost::hof::lazy(&V::g7)(v, 1, 2, 3, 4, 5, 6, 7)(); + boost::hof::lazy(&V::g7)(std::ref(v), 1, 2, 3, 4, 5, 6, 7)(); + + // 8 + + boost::hof::lazy(&V::f8)(&v, 1, 2, 3, 4, 5, 6, 7, 8)(); + boost::hof::lazy(&V::f8)(std::ref(v), 1, 2, 3, 4, 5, 6, 7, 8)(); + + boost::hof::lazy(&V::g8)(&v, 1, 2, 3, 4, 5, 6, 7, 8)(); + boost::hof::lazy(&V::g8)(v, 1, 2, 3, 4, 5, 6, 7, 8)(); + boost::hof::lazy(&V::g8)(std::ref(v), 1, 2, 3, 4, 5, 6, 7, 8)(); + + BOOST_HOF_TEST_CHECK( v.hash == 23558 ); +} + +struct id +{ + int operator()(int i) const + { + return i; + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::lazy(id())(3)() == 3); +} + +struct deref +{ + int operator()(const std::unique_ptr<int>& i) const + { + return *i; + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::lazy(deref())(std::unique_ptr<int>(new int(3)))() == 3); +} + +void fv1( std::unique_ptr<int> p1 ) +{ + BOOST_HOF_TEST_CHECK( *p1 == 1 ); +} + +void fv2( std::unique_ptr<int> p1, std::unique_ptr<int> p2 ) +{ + BOOST_HOF_TEST_CHECK( *p1 == 1 ); + BOOST_HOF_TEST_CHECK( *p2 == 2 ); +} + +void fv3( std::unique_ptr<int> p1, std::unique_ptr<int> p2, std::unique_ptr<int> p3 ) +{ + BOOST_HOF_TEST_CHECK( *p1 == 1 ); + BOOST_HOF_TEST_CHECK( *p2 == 2 ); + BOOST_HOF_TEST_CHECK( *p3 == 3 ); +} + +void fv4( std::unique_ptr<int> p1, std::unique_ptr<int> p2, std::unique_ptr<int> p3, std::unique_ptr<int> p4 ) +{ + BOOST_HOF_TEST_CHECK( *p1 == 1 ); + BOOST_HOF_TEST_CHECK( *p2 == 2 ); + BOOST_HOF_TEST_CHECK( *p3 == 3 ); + BOOST_HOF_TEST_CHECK( *p4 == 4 ); +} + +void fv5( std::unique_ptr<int> p1, std::unique_ptr<int> p2, std::unique_ptr<int> p3, std::unique_ptr<int> p4, std::unique_ptr<int> p5 ) +{ + BOOST_HOF_TEST_CHECK( *p1 == 1 ); + BOOST_HOF_TEST_CHECK( *p2 == 2 ); + BOOST_HOF_TEST_CHECK( *p3 == 3 ); + BOOST_HOF_TEST_CHECK( *p4 == 4 ); + BOOST_HOF_TEST_CHECK( *p5 == 5 ); +} + +void fv6( std::unique_ptr<int> p1, std::unique_ptr<int> p2, std::unique_ptr<int> p3, std::unique_ptr<int> p4, std::unique_ptr<int> p5, std::unique_ptr<int> p6 ) +{ + BOOST_HOF_TEST_CHECK( *p1 == 1 ); + BOOST_HOF_TEST_CHECK( *p2 == 2 ); + BOOST_HOF_TEST_CHECK( *p3 == 3 ); + BOOST_HOF_TEST_CHECK( *p4 == 4 ); + BOOST_HOF_TEST_CHECK( *p5 == 5 ); + BOOST_HOF_TEST_CHECK( *p6 == 6 ); +} + +void fv7( std::unique_ptr<int> p1, std::unique_ptr<int> p2, std::unique_ptr<int> p3, std::unique_ptr<int> p4, std::unique_ptr<int> p5, std::unique_ptr<int> p6, std::unique_ptr<int> p7 ) +{ + BOOST_HOF_TEST_CHECK( *p1 == 1 ); + BOOST_HOF_TEST_CHECK( *p2 == 2 ); + BOOST_HOF_TEST_CHECK( *p3 == 3 ); + BOOST_HOF_TEST_CHECK( *p4 == 4 ); + BOOST_HOF_TEST_CHECK( *p5 == 5 ); + BOOST_HOF_TEST_CHECK( *p6 == 6 ); + BOOST_HOF_TEST_CHECK( *p7 == 7 ); +} + +void fv8( std::unique_ptr<int> p1, std::unique_ptr<int> p2, std::unique_ptr<int> p3, std::unique_ptr<int> p4, std::unique_ptr<int> p5, std::unique_ptr<int> p6, std::unique_ptr<int> p7, std::unique_ptr<int> p8 ) +{ + BOOST_HOF_TEST_CHECK( *p1 == 1 ); + BOOST_HOF_TEST_CHECK( *p2 == 2 ); + BOOST_HOF_TEST_CHECK( *p3 == 3 ); + BOOST_HOF_TEST_CHECK( *p4 == 4 ); + BOOST_HOF_TEST_CHECK( *p5 == 5 ); + BOOST_HOF_TEST_CHECK( *p6 == 6 ); + BOOST_HOF_TEST_CHECK( *p7 == 7 ); + BOOST_HOF_TEST_CHECK( *p8 == 8 ); +} + +void fv9( std::unique_ptr<int> p1, std::unique_ptr<int> p2, std::unique_ptr<int> p3, std::unique_ptr<int> p4, std::unique_ptr<int> p5, std::unique_ptr<int> p6, std::unique_ptr<int> p7, std::unique_ptr<int> p8, std::unique_ptr<int> p9 ) +{ + BOOST_HOF_TEST_CHECK( *p1 == 1 ); + BOOST_HOF_TEST_CHECK( *p2 == 2 ); + BOOST_HOF_TEST_CHECK( *p3 == 3 ); + BOOST_HOF_TEST_CHECK( *p4 == 4 ); + BOOST_HOF_TEST_CHECK( *p5 == 5 ); + BOOST_HOF_TEST_CHECK( *p6 == 6 ); + BOOST_HOF_TEST_CHECK( *p7 == 7 ); + BOOST_HOF_TEST_CHECK( *p8 == 8 ); + BOOST_HOF_TEST_CHECK( *p9 == 9 ); +} + +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> p1( new int(1) ); + + boost::hof::lazy( fv1 )( std::placeholders::_1 )( std::move( p1 ) ); +} +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> p1( new int(1) ); + std::unique_ptr<int> p2( new int(2) ); + + boost::hof::lazy( fv2 )( std::placeholders::_1, std::placeholders::_2 )( std::move( p1 ), std::move( p2 ) ); +} +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> p1( new int(1) ); + std::unique_ptr<int> p2( new int(2) ); + std::unique_ptr<int> p3( new int(3) ); + + boost::hof::lazy( fv3 )( std::placeholders::_1, std::placeholders::_2, std::placeholders::_3 )( std::move( p1 ), std::move( p2 ), std::move( p3 ) ); +} +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> p1( new int(1) ); + std::unique_ptr<int> p2( new int(2) ); + std::unique_ptr<int> p3( new int(3) ); + std::unique_ptr<int> p4( new int(4) ); + + boost::hof::lazy( fv4 )( std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4 )( std::move( p1 ), std::move( p2 ), std::move( p3 ), std::move( p4 ) ); +} +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> p1( new int(1) ); + std::unique_ptr<int> p2( new int(2) ); + std::unique_ptr<int> p3( new int(3) ); + std::unique_ptr<int> p4( new int(4) ); + std::unique_ptr<int> p5( new int(5) ); + + boost::hof::lazy( fv5 )( std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5 )( std::move( p1 ), std::move( p2 ), std::move( p3 ), std::move( p4 ), std::move( p5 ) ); +} +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> p1( new int(1) ); + std::unique_ptr<int> p2( new int(2) ); + std::unique_ptr<int> p3( new int(3) ); + std::unique_ptr<int> p4( new int(4) ); + std::unique_ptr<int> p5( new int(5) ); + std::unique_ptr<int> p6( new int(6) ); + + boost::hof::lazy( fv6 )( std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6 )( std::move( p1 ), std::move( p2 ), std::move( p3 ), std::move( p4 ), std::move( p5 ), std::move( p6 ) ); +} +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> p1( new int(1) ); + std::unique_ptr<int> p2( new int(2) ); + std::unique_ptr<int> p3( new int(3) ); + std::unique_ptr<int> p4( new int(4) ); + std::unique_ptr<int> p5( new int(5) ); + std::unique_ptr<int> p6( new int(6) ); + std::unique_ptr<int> p7( new int(7) ); + + boost::hof::lazy( fv7 )( std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7 )( std::move( p1 ), std::move( p2 ), std::move( p3 ), std::move( p4 ), std::move( p5 ), std::move( p6 ), std::move( p7 ) ); +} +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> p1( new int(1) ); + std::unique_ptr<int> p2( new int(2) ); + std::unique_ptr<int> p3( new int(3) ); + std::unique_ptr<int> p4( new int(4) ); + std::unique_ptr<int> p5( new int(5) ); + std::unique_ptr<int> p6( new int(6) ); + std::unique_ptr<int> p7( new int(7) ); + std::unique_ptr<int> p8( new int(8) ); + + boost::hof::lazy( fv8 )( std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7, std::placeholders::_8 )( std::move( p1 ), std::move( p2 ), std::move( p3 ), std::move( p4 ), std::move( p5 ), std::move( p6 ), std::move( p7 ), std::move( p8 ) ); +} +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> p1( new int(1) ); + std::unique_ptr<int> p2( new int(2) ); + std::unique_ptr<int> p3( new int(3) ); + std::unique_ptr<int> p4( new int(4) ); + std::unique_ptr<int> p5( new int(5) ); + std::unique_ptr<int> p6( new int(6) ); + std::unique_ptr<int> p7( new int(7) ); + std::unique_ptr<int> p8( new int(8) ); + std::unique_ptr<int> p9( new int(9) ); + + boost::hof::lazy( fv9 )( std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7, std::placeholders::_8, std::placeholders::_9 )( std::move( p1 ), std::move( p2 ), std::move( p3 ), std::move( p4 ), std::move( p5 ), std::move( p6 ), std::move( p7 ), std::move( p8 ), std::move( p9 ) ); +} + + +struct X_ref +{ + int f( int x ) + { + return x; + } + + int g( int x ) const + { + return -x; + } +}; + +BOOST_HOF_TEST_CASE() +{ + X_ref x; + + BOOST_HOF_TEST_CHECK( boost::hof::lazy( &X_ref::f )( std::ref( x ), std::placeholders::_1 )( 1 ) == 1 ); + BOOST_HOF_TEST_CHECK( boost::hof::lazy( &X_ref::g )( std::cref( x ), std::placeholders::_1 )( 2 ) == -2 ); +} + +BOOST_HOF_TEST_CASE() +{ + auto lazy_f_1 = boost::hof::lazy(f_1())(std::placeholders::_1); + static_assert(boost::hof::is_invocable<decltype(lazy_f_1), long>::value, "Invocable"); + static_assert(boost::hof::is_invocable<decltype(lazy_f_1), long, long>::value, "Invocable"); + + auto lazy_f_2 = boost::hof::lazy(f_2())(std::placeholders::_1, std::placeholders::_2); + static_assert(boost::hof::is_invocable<decltype(lazy_f_2), long, long>::value, "Invocable"); + static_assert(!boost::hof::is_invocable<decltype(lazy_f_2), long>::value, "Not SFINAE-friendly"); +} + +struct dummy_unary_fn +{ + template <typename S> + int operator()(S const &) const { return 0; } +}; + +struct bad_unary_fn +{ + template <typename S> + constexpr int operator()(S const &) const + { + static_assert(!std::is_same<S, S>::value, "Failure"); + return 0; + } +}; + +BOOST_HOF_TEST_CASE() +{ + auto b = boost::hof::lazy(dummy_unary_fn())(bad_unary_fn()); + b(0); +} + + +struct by_value_fn +{ + template<typename T, typename U> + void operator()(T &&, U &&) const + { + static_assert(std::is_same<U, int>::value, ""); + } +}; + +BOOST_HOF_TEST_CASE() +{ + boost::hof::lazy(by_value_fn{})(std::placeholders::_1, 42)("hello"); +} + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +struct copy_throws +{ + copy_throws() {} + copy_throws(copy_throws const&) {} + copy_throws(copy_throws&&) noexcept {} +}; + +struct no_throw_fo +{ + void operator()() const noexcept {} + void operator()(int) const noexcept {} + void operator()(copy_throws) const noexcept {} +}; + +struct throws_fo +{ + void operator()() const {} +}; + +struct member_obj +{ + int x; +}; + +BOOST_HOF_TEST_CASE() +{ + no_throw_fo obj; + copy_throws arg; + static_assert(noexcept(boost::hof::lazy(no_throw_fo{})()()), "noexcept lazy"); + static_assert(noexcept(boost::hof::lazy(obj)()()), "noexcept lazy"); + static_assert(!noexcept(boost::hof::lazy(obj)(arg)()), "noexcept lazy"); + static_assert(noexcept(boost::hof::lazy(obj)(1)()), "noexcept lazy"); + static_assert(noexcept(boost::hof::lazy(obj)(std::placeholders::_1)), "noexcept lazy"); + // static_assert(noexcept(boost::hof::lazy(obj)(std::placeholders::_1)()), "noexcept lazy"); + static_assert(noexcept(boost::hof::lazy(obj)(std::placeholders::_1)(1)), "noexcept lazy"); + static_assert(!noexcept(boost::hof::lazy(obj)(std::placeholders::_1)(arg)), "noexcept lazy"); + + static_assert(noexcept(boost::hof::lazy(obj)(std::move(arg))), "noexcept lazy"); + static_assert(!noexcept(boost::hof::lazy(obj)(std::move(arg))()), "noexcept lazy"); +} +BOOST_HOF_TEST_CASE() +{ + throws_fo obj; + static_assert(!noexcept(boost::hof::lazy(obj)()()), "noexcept lazy"); +} +BOOST_HOF_TEST_CASE() +{ + member_obj obj{42}; + static_assert(noexcept(boost::hof::lazy(&member_obj::x)(obj)()), "noexcept lazy"); + static_assert(noexcept(boost::hof::lazy(&member_obj::x)(std::placeholders::_1)(obj)), "noexcept lazy"); +} +#endif diff --git a/src/boost/libs/hof/test/lift.cpp b/src/boost/libs/hof/test/lift.cpp new file mode 100644 index 000000000..cae105783 --- /dev/null +++ b/src/boost/libs/hof/test/lift.cpp @@ -0,0 +1,58 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + lift.cpp + 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 "test.hpp" +#include <boost/hof/lift.hpp> +#include <boost/hof/function.hpp> +#include <boost/hof/detail/move.hpp> +#include <tuple> +#include <algorithm> + +template<class T, class U> +constexpr T sum(T x, U y) BOOST_HOF_RETURNS_DEDUCE_NOEXCEPT(x+y) +{ + return x + y; +} + +BOOST_HOF_LIFT_CLASS(max_f, std::max); +BOOST_HOF_LIFT_CLASS(sum_f, sum); + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(sum_f()(1, 2)), "noexcept lift"); + static_assert(!noexcept(sum_f()(std::string(), std::string())), "noexcept lift"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(max_f()(3, 4) == std::max(3, 4)); + + BOOST_HOF_TEST_CHECK(sum_f()(1, 2) == 3); + BOOST_HOF_STATIC_TEST_CHECK(sum_f()(1, 2) == 3); +} + +#if BOOST_HOF_HAS_GENERIC_LAMBDA +BOOST_HOF_TEST_CASE() +{ + auto my_max = BOOST_HOF_LIFT(std::max); + BOOST_HOF_TEST_CHECK(my_max(3, 4) == std::max(3, 4)); + + BOOST_HOF_TEST_CHECK(BOOST_HOF_LIFT(std::max)(3, 4) == std::max(3, 4)); + BOOST_HOF_TEST_CHECK(BOOST_HOF_LIFT(sum)(1, 2) == 3); +} + +BOOST_HOF_STATIC_FUNCTION(psum) = BOOST_HOF_LIFT(sum); +BOOST_HOF_STATIC_FUNCTION(pmax) = BOOST_HOF_LIFT(std::max); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(pmax(3, 4) == std::max(3, 4)); + + BOOST_HOF_TEST_CHECK(psum(1, 2) == 3); +} +#endif diff --git a/src/boost/libs/hof/test/limit.cpp b/src/boost/libs/hof/test/limit.cpp new file mode 100644 index 000000000..74697413e --- /dev/null +++ b/src/boost/libs/hof/test/limit.cpp @@ -0,0 +1,49 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + limit.cpp + 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/hof/limit.hpp> +#include <boost/hof/is_invocable.hpp> +#include <boost/hof/pack.hpp> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::limit(std::integral_constant<int, 2>())(binary_class()); + BOOST_HOF_TEST_CHECK(f(1, 2) == 3); + static_assert(boost::hof::function_param_limit<decltype(f)>::value == 2, "Function limit is 2"); +} + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::limit_c<2>(binary_class()); + BOOST_HOF_TEST_CHECK(f(1, 2) == 3); + static_assert(boost::hof::function_param_limit<decltype(f)>::value == 2, "Function limit is 2"); +} + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::limit_c<2>(boost::hof::always(3)); + BOOST_HOF_TEST_CHECK(f(1, 2) == 3); + BOOST_HOF_TEST_CHECK(f(1) == 3); + BOOST_HOF_TEST_CHECK(f() == 3); + static_assert(boost::hof::function_param_limit<decltype(f)>::value == 2, "Function limit is 2"); + static_assert(boost::hof::is_invocable<decltype(f), int>::value, "Invocable"); + static_assert(boost::hof::is_invocable<decltype(f), int, int>::value, "Invocable"); + static_assert(!boost::hof::is_invocable<decltype(f), int, int, int>::value, "Not Invocable"); +} + +BOOST_HOF_TEST_CASE() +{ + static_assert(!boost::hof::is_invocable<decltype(boost::hof::limit), int>::value, "Not integral constant"); +} + +BOOST_HOF_TEST_CASE() +{ + static_assert(boost::hof::function_param_limit<decltype(boost::hof::pack())>::value == 0, "Failed limit on pack"); + static_assert(boost::hof::function_param_limit<decltype(boost::hof::pack(1))>::value == 1, "Failed limit on pack"); + static_assert(boost::hof::function_param_limit<decltype(boost::hof::pack(1, 2))>::value == 2, "Failed limit on pack"); +} + diff --git a/src/boost/libs/hof/test/match.cpp b/src/boost/libs/hof/test/match.cpp new file mode 100644 index 000000000..0d09dfdf6 --- /dev/null +++ b/src/boost/libs/hof/test/match.cpp @@ -0,0 +1,193 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + match.cpp + 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/hof/match.hpp> +#include <boost/hof/static.hpp> +#include <boost/hof/lambda.hpp> +#include <boost/hof/placeholders.hpp> +#include <boost/hof/limit.hpp> +#include "test.hpp" + +#include <memory> + +namespace test1 +{ + struct int_class + { + int operator()(int) const + { + return 1; + } + }; + + struct foo + {}; + + struct foo_class + { + foo operator()(foo) const + { + return foo(); + } + }; + + static constexpr boost::hof::static_<boost::hof::match_adaptor<int_class, foo_class> > fun = {}; + + static_assert(std::is_same<int, decltype(fun(1))>::value, "Failed match"); + static_assert(std::is_same<foo, decltype(fun(foo()))>::value, "Failed match"); +} + +struct int_class +{ + constexpr int operator()(int) const + { + return 1; + } +}; + +struct foo +{}; + +struct foo_class +{ + constexpr int operator()(foo) const + { + return 2; + } +}; + +static constexpr boost::hof::match_adaptor<int_class, foo_class> fun = {}; + +BOOST_HOF_TEST_CASE() +{ + + BOOST_HOF_TEST_CHECK(fun(1) == 1); + BOOST_HOF_TEST_CHECK(fun(foo()) == 2); + + BOOST_HOF_STATIC_TEST_CHECK(fun(1) == 1); + BOOST_HOF_STATIC_TEST_CHECK(fun(foo()) == 2); +}; + +BOOST_HOF_TEST_CASE() +{ + + BOOST_HOF_TEST_CHECK(boost::hof::reveal(fun)(1) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::reveal(fun)(foo()) == 2); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reveal(fun)(1) == 1); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reveal(fun)(foo()) == 2); +}; + +BOOST_HOF_TEST_CASE() +{ + + constexpr auto lam = boost::hof::match( + BOOST_HOF_STATIC_LAMBDA(int) { return 1; }, + BOOST_HOF_STATIC_LAMBDA(foo) { return 2; } + ); + + BOOST_HOF_TEST_CHECK(lam(1) == 1); + BOOST_HOF_TEST_CHECK(lam(foo()) == 2); +}; + +BOOST_HOF_TEST_CASE() +{ + int i = 0; + auto lam = boost::hof::match( + [&](int) { return i+1; }, + [&](foo) { return i+2; } + ); +// Disable this check on msvc, since lambdas might be default constructible +#ifndef _MSC_VER + STATIC_ASSERT_NOT_DEFAULT_CONSTRUCTIBLE(decltype(lam)); +#endif + BOOST_HOF_TEST_CHECK(lam(1) == 1); + BOOST_HOF_TEST_CHECK(lam(foo()) == 2); +}; + + +BOOST_HOF_TEST_CASE() +{ + struct not_default_constructible + { + int i; + not_default_constructible(int x) : i(x) + {} + }; + STATIC_ASSERT_NOT_DEFAULT_CONSTRUCTIBLE(not_default_constructible); + not_default_constructible ndc = not_default_constructible(0); + auto lam = boost::hof::match( + [&](int) { return ndc.i+1; }, + [&](foo) { return ndc.i+2; } + ); +// Disable this check on msvc, since lambdas might be default constructible +#ifndef _MSC_VER + STATIC_ASSERT_NOT_DEFAULT_CONSTRUCTIBLE(decltype(lam)); +#endif + + BOOST_HOF_TEST_CHECK(lam(1) == 1); + BOOST_HOF_TEST_CHECK(lam(foo()) == 2); +}; + + +struct int_move_class +{ + std::unique_ptr<int> i; + int_move_class() : i(new int(1)) + {} + int operator()(int) const + { + return *i; + } +}; + +struct foo_move_class +{ + std::unique_ptr<int> i; + foo_move_class() : i(new int(2)) + {} + int operator()(foo) const + { + return *i; + } +}; + +BOOST_HOF_TEST_CASE() +{ + auto fun_move = boost::hof::match(int_move_class(), foo_move_class()); + BOOST_HOF_TEST_CHECK(fun_move(1) == 1); + BOOST_HOF_TEST_CHECK(fun_move(foo()) == 2); + +}; + +BOOST_HOF_TEST_CASE() +{ + const auto negate = (!boost::hof::_); + const auto sub = (boost::hof::_ - boost::hof::_); + BOOST_HOF_TEST_CHECK(boost::hof::match(negate, sub)(0) == negate(0)); + BOOST_HOF_TEST_CHECK(boost::hof::match(negate, sub)(0, 1) == sub(0, 1)); +} + +BOOST_HOF_TEST_CASE() +{ + const auto negate = (!boost::hof::_1); + const auto sub = (boost::hof::_1 - boost::hof::_2); + BOOST_HOF_TEST_CHECK(boost::hof::match(negate, sub)(0) == negate(0)); + // This is test is disabled because its invalid. It is valid to give more + // parameters than what are used by the placeholders. So negate(0, 1) is a + // valid call, which makes the following test fail with ambigous overload. + // BOOST_HOF_TEST_CHECK(boost::hof::match(negate, sub)(0, 1) == sub(0, 1)); +} + +BOOST_HOF_TEST_CASE() +{ + const auto negate = boost::hof::limit_c<1>(!boost::hof::_1); + const auto sub = boost::hof::limit_c<2>(boost::hof::_1 - boost::hof::_2); + BOOST_HOF_TEST_CHECK(boost::hof::match(negate, sub)(0) == negate(0)); + // This test will pass because we have limited the number of parameters. + BOOST_HOF_TEST_CHECK(boost::hof::match(negate, sub)(0, 1) == sub(0, 1)); +} + diff --git a/src/boost/libs/hof/test/mutable.cpp b/src/boost/libs/hof/test/mutable.cpp new file mode 100644 index 000000000..d071bc639 --- /dev/null +++ b/src/boost/libs/hof/test/mutable.cpp @@ -0,0 +1,72 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + mutable.cpp + 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/hof/mutable.hpp> +#include <boost/hof/lazy.hpp> +#include <boost/hof/detail/move.hpp> +#include <memory> +#include "test.hpp" + +struct mutable_fun +{ + int x; + mutable_fun() noexcept + : x(1) + {} + + int operator()(int i) noexcept + { + x+=i; + return x; + } +}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::mutable_(mutable_fun())(3)), "noexcept mutable_"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::mutable_(mutable_fun())(3) == 4); +} + +BOOST_HOF_TEST_CASE() +{ + auto mut_fun = mutable_fun(); + auto by_5 = boost::hof::lazy(boost::hof::mutable_(std::ref(mut_fun)))(5); + BOOST_HOF_TEST_CHECK(by_5() == 6); + BOOST_HOF_TEST_CHECK(by_5() == 11); +} + +struct mutable_move_fun +{ + std::unique_ptr<int> x; + mutable_move_fun() : x(new int(1)) + {} + + int operator()(int i) + { + *x+=i; + return *x; + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::mutable_(mutable_move_fun())(3) == 4); +} + +BOOST_HOF_TEST_CASE() +{ + auto mut_fun = mutable_move_fun(); + auto by_5 = boost::hof::lazy(boost::hof::mutable_(boost::hof::move(mut_fun)))(5); + BOOST_HOF_TEST_CHECK(by_5() == 6); + BOOST_HOF_TEST_CHECK(by_5() == 11); +} + diff --git a/src/boost/libs/hof/test/pack.cpp b/src/boost/libs/hof/test/pack.cpp new file mode 100644 index 000000000..ac64c39ca --- /dev/null +++ b/src/boost/libs/hof/test/pack.cpp @@ -0,0 +1,395 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + pack.cpp + 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/hof/pack.hpp> +#include <boost/hof/always.hpp> +#include <boost/hof/identity.hpp> +#include <memory> +#include "test.hpp" + +BOOST_HOF_TEST_CASE() +{ + auto p1 = boost::hof::pack_basic(1, 2); + auto p2 = p1; + BOOST_HOF_TEST_CHECK(p2(binary_class()) == p1(binary_class())); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_basic(1, 2)(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_basic(1, 2)(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack(1, 2)(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack(1, 2)(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_forward(1, 2)(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_forward(1, 2)(binary_class()) == 3 ); +} +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +struct copy_throws +{ + copy_throws() {} + copy_throws(copy_throws const&) {} + copy_throws(copy_throws&&) noexcept {} +}; + +BOOST_HOF_TEST_CASE() +{ + int i = 1; + copy_throws ct{}; + static_assert(!noexcept(boost::hof::pack(ct, ct)(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack(1, 2)(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_forward(ct, ct)(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_forward(i, i)(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_forward(1, 2)(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_basic(ct, ct)(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_basic(i, i)(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_basic(1, 2)(boost::hof::always())), "noexcept pack"); + + static_assert(noexcept(boost::hof::pack()(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_forward()(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_basic()(boost::hof::always())), "noexcept pack"); +} + +BOOST_HOF_TEST_CASE() +{ + copy_throws ct{}; + static_assert(!noexcept(boost::hof::pack_join(boost::hof::pack(ct), boost::hof::pack(ct))(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_join(boost::hof::pack(1), boost::hof::pack(1))(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_join(boost::hof::pack(), boost::hof::pack())(boost::hof::always())), "noexcept pack"); + auto p = boost::hof::pack(1); + static_assert(noexcept(boost::hof::pack_join(p, boost::hof::pack())(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_join(boost::hof::pack(), p)(boost::hof::always())), "noexcept pack"); + static_assert(noexcept(boost::hof::pack_join(p, p)(boost::hof::always())), "noexcept pack"); + auto pt = boost::hof::pack(ct); + static_assert(!noexcept(boost::hof::pack_join(pt, boost::hof::pack())(boost::hof::always())), "noexcept pack"); + static_assert(!noexcept(boost::hof::pack_join(boost::hof::pack(), pt)(boost::hof::always())), "noexcept pack"); + static_assert(!noexcept(boost::hof::pack_join(pt, pt)(boost::hof::always())), "noexcept pack"); + +} +#endif +BOOST_HOF_TEST_CASE() +{ + static constexpr int x = 1; + static constexpr int y = 2; + + auto p1 = boost::hof::pack_basic(x, y); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p1)>::value, "Pack default constructible"); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_basic(x, y)(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_basic(x, y)(binary_class()) == 3 ); + + auto p2 = boost::hof::pack(std::ref(x), std::ref(y)); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p2)>::value, "Pack default constructible"); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack(x, y)(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack(std::ref(x), std::ref(y))(binary_class()) == 3 ); + + auto p3 = boost::hof::pack_forward(x, y); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p3)>::value, "Pack default constructible"); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_forward(x, y)(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_forward(x, y)(binary_class()) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_basic()(boost::hof::always(3)) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_basic()(boost::hof::always(3)) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_basic(3)(boost::hof::identity) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_basic(3)(boost::hof::identity) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + auto p = boost::hof::pack(1); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(p, boost::hof::pack(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(p, p)(binary_class()) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(p, p, boost::hof::pack())(binary_class()) == 2); + +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(1), boost::hof::pack_basic(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(1), boost::hof::pack_basic(2))(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(1), boost::hof::pack(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(1), boost::hof::pack(2))(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(1), boost::hof::pack_forward(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(1), boost::hof::pack_forward(2))(binary_class()) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(), boost::hof::pack_basic(1, 2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(), boost::hof::pack_basic(1, 2))(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(), boost::hof::pack(1, 2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(), boost::hof::pack(1, 2))(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(), boost::hof::pack_forward(1, 2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(), boost::hof::pack_forward(1, 2))(binary_class()) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(1, 2), boost::hof::pack_basic())(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(1, 2), boost::hof::pack_basic())(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(1, 2), boost::hof::pack())(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(1, 2), boost::hof::pack())(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(1, 2), boost::hof::pack_forward())(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(1, 2), boost::hof::pack_forward())(binary_class()) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(1), boost::hof::pack_basic(), boost::hof::pack_basic(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(1), boost::hof::pack_basic(), boost::hof::pack_basic(2))(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(1), boost::hof::pack(), boost::hof::pack(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(1), boost::hof::pack(), boost::hof::pack(2))(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(1), boost::hof::pack_forward(), boost::hof::pack_forward(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(1), boost::hof::pack_forward(), boost::hof::pack_forward(2))(binary_class()) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(), boost::hof::pack_basic(1), boost::hof::pack_basic(), boost::hof::pack_basic(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(), boost::hof::pack_basic(1), boost::hof::pack_basic(), boost::hof::pack_basic(2))(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(), boost::hof::pack(1), boost::hof::pack(), boost::hof::pack(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(), boost::hof::pack(1), boost::hof::pack(), boost::hof::pack(2))(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(), boost::hof::pack_forward(1), boost::hof::pack_forward(), boost::hof::pack_forward(2))(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(), boost::hof::pack_forward(1), boost::hof::pack_forward(), boost::hof::pack_forward(2))(binary_class()) == 3 ); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(1), boost::hof::pack_basic(), boost::hof::pack_basic(2), boost::hof::pack_basic())(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(1), boost::hof::pack_basic(), boost::hof::pack_basic(2), boost::hof::pack_basic())(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(1), boost::hof::pack(), boost::hof::pack(2), boost::hof::pack())(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(1), boost::hof::pack(), boost::hof::pack(2), boost::hof::pack())(binary_class()) == 3 ); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(1), boost::hof::pack_forward(), boost::hof::pack_forward(2), boost::hof::pack_forward())(binary_class()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(1), boost::hof::pack_forward(), boost::hof::pack_forward(2), boost::hof::pack_forward())(binary_class()) == 3 ); +} + +struct deref +{ + int operator()(const std::unique_ptr<int>& i) const + { + return *i; + } +}; + +BOOST_HOF_TEST_CASE() +{ + std::unique_ptr<int> i(new int(3)); + BOOST_HOF_TEST_CHECK(boost::hof::pack_basic(i)(deref()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_basic(std::unique_ptr<int>(new int(3)))(deref()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_forward(std::unique_ptr<int>(new int(3)))(deref()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack(std::unique_ptr<int>(new int(3)))(deref()) == 3); + auto p = boost::hof::pack_basic(std::unique_ptr<int>(new int(3))); + BOOST_HOF_TEST_CHECK(p(deref()) == 3); + + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_basic(), boost::hof::pack_basic(std::unique_ptr<int>(new int(3))))(deref()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack_forward(), boost::hof::pack_forward(std::unique_ptr<int>(new int(3))))(deref()) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::pack_join(boost::hof::pack(), boost::hof::pack(std::unique_ptr<int>(new int(3))))(deref()) == 3); + // BOOST_HOF_TEST_CHECK(p(deref()) == 3); +} + +struct move_rvalue +{ + void operator()(std::string&& s) const + { + std::string ss = std::move(s); + BOOST_HOF_TEST_CHECK(ss == "abcdef"); + s = "00000"; + } +}; + +struct check_rvalue +{ + void operator()(std::string&& s) const + { + BOOST_HOF_TEST_CHECK(s == "abcdef"); + } +}; + +BOOST_HOF_TEST_CASE() +{ + auto p = boost::hof::pack_basic(std::string{"abcdef"}); + p(move_rvalue{}); + p(check_rvalue{}); +} + +BOOST_HOF_TEST_CASE() +{ + auto p = boost::hof::pack(std::string{"abcdef"}); + p(move_rvalue{}); + p(check_rvalue{}); +} + +struct empty1 +{}; + +struct empty2 +{}; + +BOOST_HOF_TEST_CASE() +{ + static_assert(boost::hof::detail::is_default_constructible<empty1, empty2>::value, "Not default constructible"); +} + +BOOST_HOF_TEST_CASE() +{ + static constexpr auto p = boost::hof::pack_basic(empty1()); + BOOST_HOF_TEST_CHECK(p(boost::hof::always(0)) == 0); + BOOST_HOF_STATIC_TEST_CHECK(p(boost::hof::always(0)) == 0); +#ifndef _MSC_VER + static_assert(std::is_empty<decltype(p)>::value, "Pack not empty"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(p)>::value, "Not default constructible"); + +} + +BOOST_HOF_TEST_CASE() +{ + static constexpr auto p = boost::hof::pack_basic(empty1(), empty2()); + BOOST_HOF_TEST_CHECK(p(boost::hof::always(0)) == 0); + BOOST_HOF_STATIC_TEST_CHECK(p(boost::hof::always(0)) == 0); +#ifndef _MSC_VER + static_assert(std::is_empty<decltype(p)>::value, "Pack not empty"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(p)>::value, "Not default constructible"); +} + +BOOST_HOF_TEST_CASE() +{ + static constexpr auto p = boost::hof::pack_basic(boost::hof::pack_basic(), boost::hof::pack_basic()); + BOOST_HOF_TEST_CHECK(p(boost::hof::always(0)) == 0); + BOOST_HOF_STATIC_TEST_CHECK(p(boost::hof::always(0)) == 0); +#ifndef _MSC_VER + static_assert(std::is_empty<decltype(p)>::value, "Pack not empty"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(p)>::value, "Not default constructible"); +} + +BOOST_HOF_TEST_CASE() +{ + static constexpr auto p = boost::hof::pack_basic(empty1(), empty2(), empty1()); + BOOST_HOF_TEST_CHECK(p(boost::hof::always(0)) == 0); + BOOST_HOF_STATIC_TEST_CHECK(p(boost::hof::always(0)) == 0); +#ifndef _MSC_VER + static_assert(std::is_empty<decltype(p)>::value, "Pack not empty"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(p)>::value, "Not default constructible"); +} + +BOOST_HOF_TEST_CASE() +{ + static constexpr auto p = boost::hof::pack_basic(empty1(), boost::hof::pack_basic(empty1(), empty2())); + BOOST_HOF_TEST_CHECK(p(boost::hof::always(0)) == 0); + BOOST_HOF_STATIC_TEST_CHECK(p(boost::hof::always(0)) == 0); +#ifndef _MSC_VER + static_assert(std::is_empty<decltype(p)>::value, "Pack not empty"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(p)>::value, "Not default constructible"); +} + +BOOST_HOF_TEST_CASE() +{ + static constexpr auto p = boost::hof::pack_basic(boost::hof::pack_basic(), boost::hof::pack_basic(boost::hof::pack_basic()), empty1(), boost::hof::pack_basic(empty1(), empty2())); + BOOST_HOF_TEST_CHECK(p(boost::hof::always(0)) == 0); + BOOST_HOF_STATIC_TEST_CHECK(p(boost::hof::always(0)) == 0); +#ifndef _MSC_VER + static_assert(std::is_empty<decltype(p)>::value, "Pack not empty"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(p)>::value, "Not default constructible"); +} + +struct not_default_constructible +{ + int i; + constexpr not_default_constructible(int x) : i(x) + {} +}; + +struct select_i +{ + template<class T> + constexpr int operator()(T&& x) const + { + return x.i; + } + + template<class T, class U> + constexpr int operator()(T&& x, U&& y) const + { + return x.i + y.i; + } + + template<class T, class U, class V> + constexpr int operator()(T&& x, U&& y, V&& z) const + { + return x.i + y.i + z.i; + } +}; + +BOOST_HOF_TEST_CASE() +{ + static_assert(!boost::hof::detail::is_default_constructible<not_default_constructible>::value, "Default constructible"); + auto p = boost::hof::pack_basic(not_default_constructible(3)); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p)>::value, "Pack default constructible"); + auto p1 = boost::hof::pack_forward(p); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p1)>::value, "Packs default constructible"); + auto p2 = boost::hof::pack_forward(p, p); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p2)>::value, "Packs default constructible"); + auto p3 = boost::hof::pack_forward(p, p, p); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p3)>::value, "Packs default constructible"); + BOOST_HOF_TEST_CHECK(p(select_i()) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_basic(not_default_constructible(3))(select_i()) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + static_assert(!boost::hof::detail::is_default_constructible<not_default_constructible>::value, "Default constructible"); + auto p = boost::hof::pack_basic(not_default_constructible(1), not_default_constructible(2)); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p)>::value, "Pack default constructible"); + auto p1 = boost::hof::pack_forward(p); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p1)>::value, "Packs default constructible"); + auto p2 = boost::hof::pack_forward(p, p); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p2)>::value, "Packs default constructible"); + auto p3 = boost::hof::pack_forward(p, p, p); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p3)>::value, "Packs default constructible"); + BOOST_HOF_TEST_CHECK(p(select_i()) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_basic(not_default_constructible(1), not_default_constructible(2))(select_i()) == 3); +} + +BOOST_HOF_TEST_CASE() +{ + static_assert(!boost::hof::detail::is_default_constructible<not_default_constructible>::value, "Default constructible"); + auto p = boost::hof::pack_basic(not_default_constructible(1), not_default_constructible(1), not_default_constructible(1)); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p)>::value, "Pack default constructible"); + auto p1 = boost::hof::pack_forward(p); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p1)>::value, "Packs default constructible"); + auto p2 = boost::hof::pack_forward(p, p); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p2)>::value, "Packs default constructible"); + auto p3 = boost::hof::pack_forward(p, p, p); + static_assert(!boost::hof::detail::is_default_constructible<decltype(p3)>::value, "Packs default constructible"); + BOOST_HOF_TEST_CHECK(p(select_i()) == 3); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::pack_basic(not_default_constructible(1), not_default_constructible(1), not_default_constructible(1))(select_i()) == 3); +} + + diff --git a/src/boost/libs/hof/test/partial.cpp b/src/boost/libs/hof/test/partial.cpp new file mode 100644 index 000000000..bb4d5b75a --- /dev/null +++ b/src/boost/libs/hof/test/partial.cpp @@ -0,0 +1,108 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + partial.cpp + 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/hof/partial.hpp> +#include <boost/hof/limit.hpp> +#include "test.hpp" + +static constexpr boost::hof::static_<boost::hof::partial_adaptor<binary_class> > binary_partial = {}; + +static constexpr boost::hof::static_<boost::hof::partial_adaptor<unary_class> > unary_partial = {}; + +static constexpr boost::hof::static_<boost::hof::partial_adaptor<mutable_class> > mutable_partial = {}; + +static constexpr boost::hof::static_<boost::hof::partial_adaptor<void_class> > void_partial = {}; + +static constexpr boost::hof::static_<boost::hof::partial_adaptor<mono_class> > mono_partial = {}; + +static constexpr boost::hof::static_<boost::hof::partial_adaptor<move_class> > move_partial = {}; + +constexpr boost::hof::partial_adaptor<binary_class> binary_partial_constexpr = {}; + +constexpr boost::hof::partial_adaptor<unary_class> unary_partial_constexpr = {}; + +constexpr boost::hof::partial_adaptor<void_class> void_partial_constexpr = {}; + +constexpr boost::hof::partial_adaptor<mono_class> mono_partial_constexpr = {}; + +BOOST_HOF_TEST_CASE() +{ + boost::hof::partial_adaptor<void_class>()(1); + + void_partial(1); + void_partial()(1); + BOOST_HOF_TEST_CHECK(3 == binary_partial(1)(2)); + BOOST_HOF_TEST_CHECK(3 == binary_partial(1, 2)); + BOOST_HOF_TEST_CHECK(3 == unary_partial()(3)); + BOOST_HOF_TEST_CHECK(3 == unary_partial(3)); + BOOST_HOF_TEST_CHECK(3 == mono_partial(2)); + BOOST_HOF_TEST_CHECK(3 == mono_partial()(2)); + + int i1 = 1; + BOOST_HOF_TEST_CHECK(3 == binary_partial(2)(i1)); + BOOST_HOF_TEST_CHECK(3 == mutable_partial(std::ref(i1))(2)); + BOOST_HOF_TEST_CHECK(3 == i1); + int i2 = 1; + BOOST_HOF_TEST_CHECK(3 == mutable_partial(i2, 2)); + BOOST_HOF_TEST_CHECK(3 == i2); + +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == (move_class()(1, 2))); + BOOST_HOF_TEST_CHECK(3 == (move_partial(1, 2))); + BOOST_HOF_TEST_CHECK(3 == (move_partial(1)(2))); + BOOST_HOF_TEST_CHECK(3 == (boost::hof::partial(move_class())(1)(2))); + BOOST_HOF_TEST_CHECK(3 == (boost::hof::partial(move_class())(1, 2))); +} + +BOOST_HOF_TEST_CASE() +{ + void_partial_constexpr(1); + void_partial_constexpr()(1); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_partial_constexpr(1)(2)); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_partial_constexpr(1, 2)); + BOOST_HOF_STATIC_TEST_CHECK(3 == unary_partial_constexpr()(3)); + BOOST_HOF_STATIC_TEST_CHECK(3 == unary_partial_constexpr(3)); + BOOST_HOF_STATIC_TEST_CHECK(3 == mono_partial_constexpr(2)); + BOOST_HOF_STATIC_TEST_CHECK(3 == mono_partial_constexpr()(2)); +} +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::partial(binary_class{})(1)(2)), "noexcept partial"); +} +#endif +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::partial(boost::hof::limit_c<2>(binary_class())); + static_assert(boost::hof::is_invocable<decltype(f), int>::value, "Passing the limit is not callable"); + static_assert(boost::hof::is_invocable<decltype(f), int, int>::value, "Passing the limit is not callable"); + static_assert(!boost::hof::is_invocable<decltype(f), int, int, int>::value, "Passing the limit is not callable"); + static_assert(!boost::hof::is_invocable<decltype(f), int, int, int, int>::value, "Passing the limit is not callable"); + + auto g = f(0); + static_assert(boost::hof::is_invocable<decltype(g), int>::value, "Passing the limit is not callable"); + static_assert(!boost::hof::is_invocable<decltype(g), int, int>::value, "Passing the limit is not callable"); + static_assert(!boost::hof::is_invocable<decltype(g), int, int, int>::value, "Passing the limit is not callable"); + static_assert(!boost::hof::is_invocable<decltype(g), int, int, int, int>::value, "Passing the limit is not callable"); +} + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::partial(binary_class()); + static_assert(boost::hof::is_invocable<decltype(f), int>::value, "Passing the limit is not callable"); + static_assert(boost::hof::is_invocable<decltype(f), int, int>::value, "Passing the limit is not callable"); + static_assert(boost::hof::is_invocable<decltype(f), int, int, int>::value, "Passing the limit is not callable"); + static_assert(boost::hof::is_invocable<decltype(f), int, int, int, int>::value, "Passing the limit is not callable"); + + auto g = f(0); + static_assert(boost::hof::is_invocable<decltype(g), int>::value, "Passing the limit is not callable"); + static_assert(boost::hof::is_invocable<decltype(g), int, int>::value, "Passing the limit is not callable"); + static_assert(boost::hof::is_invocable<decltype(g), int, int, int>::value, "Passing the limit is not callable"); + static_assert(boost::hof::is_invocable<decltype(g), int, int, int, int>::value, "Passing the limit is not callable"); +} diff --git a/src/boost/libs/hof/test/pipable.cpp b/src/boost/libs/hof/test/pipable.cpp new file mode 100644 index 000000000..45bf7fdfa --- /dev/null +++ b/src/boost/libs/hof/test/pipable.cpp @@ -0,0 +1,90 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + pipable.cpp + 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/hof/pipable.hpp> +#include <boost/hof/static.hpp> +#include <boost/hof/limit.hpp> +#include "test.hpp" + +static constexpr boost::hof::static_<boost::hof::pipable_adaptor<binary_class> > binary_pipable = {}; + +static constexpr boost::hof::static_<boost::hof::pipable_adaptor<unary_class> > unary_pipable = {}; + +static constexpr boost::hof::static_<boost::hof::pipable_adaptor<mutable_class> > mutable_pipable = {}; + +static constexpr boost::hof::static_<boost::hof::pipable_adaptor<void_class> > void_pipable = {}; + +static constexpr boost::hof::static_<boost::hof::pipable_adaptor<mono_class> > mono_pipable = {}; + +static constexpr boost::hof::static_<boost::hof::pipable_adaptor<move_class> > move_pipable = {}; + +constexpr boost::hof::pipable_adaptor<void_class> void_pipable_constexpr = {}; + +constexpr boost::hof::pipable_adaptor<binary_class> binary_pipable_constexpr = {}; + +constexpr boost::hof::pipable_adaptor<unary_class> unary_pipable_constexpr = {}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(1 | binary_pipable(2)), "noexcept pipable"); + static_assert(noexcept(binary_pipable(1, 2)), "noexcept pipable"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + void_pipable(1); + 1 | void_pipable; + BOOST_HOF_TEST_CHECK(3 == (1 | binary_pipable(2))); + BOOST_HOF_TEST_CHECK(3 == (binary_pipable(1, 2))); + BOOST_HOF_TEST_CHECK(3 == (3 | unary_pipable)); + BOOST_HOF_TEST_CHECK(3 == (3 | unary_pipable())); + BOOST_HOF_TEST_CHECK(3 == (unary_pipable(3))); + int i1 = 1; + BOOST_HOF_TEST_CHECK(3 == (2 | binary_pipable(i1))); + BOOST_HOF_TEST_CHECK(3 == (i1 | mutable_pipable(2))); + BOOST_HOF_TEST_CHECK(3 == (i1)); + int i2 = 1; + BOOST_HOF_TEST_CHECK(3 == (mutable_pipable(i2, 2))); + BOOST_HOF_TEST_CHECK(3 == (i2)); + BOOST_HOF_TEST_CHECK(3 == (mono_pipable(2))); + BOOST_HOF_TEST_CHECK(3 == (2| mono_pipable)); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == (move_class()(1, 2))); + BOOST_HOF_TEST_CHECK(3 == (move_pipable(1, 2))); + BOOST_HOF_TEST_CHECK(3 == (1 | move_pipable(2))); + BOOST_HOF_TEST_CHECK(3 == (1 | boost::hof::pipable(move_class())(2))); + BOOST_HOF_TEST_CHECK(3 == (boost::hof::pipable(move_class())(1, 2))); +} + +BOOST_HOF_TEST_CASE() +{ + void_pipable_constexpr(1); + 1 | void_pipable_constexpr; + BOOST_HOF_STATIC_TEST_CHECK(3 == (1 | binary_pipable_constexpr(2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == (binary_pipable_constexpr(1, 2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == (3 | unary_pipable_constexpr)); + BOOST_HOF_STATIC_TEST_CHECK(3 == (3 | unary_pipable_constexpr())); + BOOST_HOF_STATIC_TEST_CHECK(3 == (unary_pipable_constexpr(3))); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::limit_c<2>(binary_pipable_constexpr)(1, 2)); + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::limit_c<2>(binary_pipable_constexpr)(1, 2)); +} + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::pipable(boost::hof::limit_c<2>(binary_class())); + static_assert(boost::hof::is_invocable<decltype(f), int, int>::value, "Passing the limit is not callable"); + static_assert(!boost::hof::is_invocable<decltype(f), int, int, int>::value, "Passing the limit is not callable"); + static_assert(!boost::hof::is_invocable<decltype(f), int, int, int, int>::value, "Passing the limit is not callable"); +} diff --git a/src/boost/libs/hof/test/placeholders.cpp b/src/boost/libs/hof/test/placeholders.cpp new file mode 100644 index 000000000..352230a8f --- /dev/null +++ b/src/boost/libs/hof/test/placeholders.cpp @@ -0,0 +1,813 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + placeholders.cpp + 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/hof/placeholders.hpp> +#include "test.hpp" +#include <sstream> + +// TODO: Test assign operators + +#if BOOST_HOF_HAS_STATIC_TEST_CHECK +#define BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR constexpr +#else +#define BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR +#endif + +struct square +{ + template<class T> + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto operator()(T x) const BOOST_HOF_RETURNS(x*x); +}; + +#define CHECK_DEFAULT_CONSTRUCTION_OP(op, name) \ + static_assert(boost::hof::detail::is_default_constructible<boost::hof::operators::name>::value, "Operator not default constructible"); + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +#define PLACEHOLDER_CHECK(...) \ + BOOST_HOF_STATIC_TEST_CHECK(__VA_ARGS__); \ + BOOST_HOF_TEST_CHECK(__VA_ARGS__); \ + static_assert(noexcept(__VA_ARGS__), "noexcept placeholders") +#else +#define PLACEHOLDER_CHECK(...) \ + BOOST_HOF_STATIC_TEST_CHECK(__VA_ARGS__); \ + BOOST_HOF_TEST_CHECK(__VA_ARGS__) +#endif + +BOOST_HOF_TEST_CASE() +{ + static_assert(boost::hof::detail::is_default_constructible<boost::hof::placeholder<1>>::value, "Placeholder not default constructible"); + static_assert(boost::hof::detail::is_default_constructible<boost::hof::placeholder<2>>::value, "Placeholder not default constructible"); + static_assert(boost::hof::detail::is_default_constructible<boost::hof::placeholder<3>>::value, "Placeholder not default constructible"); + + BOOST_HOF_FOREACH_BINARY_OP(CHECK_DEFAULT_CONSTRUCTION_OP) + BOOST_HOF_FOREACH_ASSIGN_OP(CHECK_DEFAULT_CONSTRUCTION_OP) + BOOST_HOF_FOREACH_UNARY_OP(CHECK_DEFAULT_CONSTRUCTION_OP) +} + +BOOST_HOF_TEST_CASE() +{ + auto simple_print = boost::hof::reveal(std::ref(std::cout) << boost::hof::_); + simple_print("Hello"); +} + +BOOST_HOF_TEST_CASE() +{ + std::stringstream ss; + auto simple_print = boost::hof::reveal(std::ref(ss) << boost::hof::_); + simple_print("Hello"); + BOOST_HOF_TEST_CHECK(ss.str() == "Hello"); +} + +BOOST_HOF_TEST_CASE() +{ + const auto x_square_add = 2 + (4*4); + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_square_add = boost::hof::_1 + boost::hof::lazy(square())(boost::hof::_2); +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_square_add)>::value, "Not copyable"); +#endif + PLACEHOLDER_CHECK(f_square_add(2, 4) == x_square_add); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_invoke_2 = boost::hof::_1(3); +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_invoke_2)>::value, "Not copyable"); +#endif + PLACEHOLDER_CHECK(f_invoke_2(square()) == 9); +} + +BOOST_HOF_TEST_CASE() +{ + const auto x_add = 2 + 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_add = boost::hof::_1 + boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_add)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_add)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_add(2, 1) == x_add); + + const auto x_subtract = 2 - 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_subtract = boost::hof::_1 - boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_subtract)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_subtract)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_subtract(2, 1) == x_subtract); + + const auto x_multiply = 2 * 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_multiply = boost::hof::_1 * boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_multiply)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_multiply)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_multiply(2, 1) == x_multiply); + + const auto x_divide = 2 / 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_divide = boost::hof::_1 / boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_divide)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_divide)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_divide(2, 1) == x_divide); + + const auto x_remainder = 2 % 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_remainder = boost::hof::_1 % boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_remainder)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_remainder)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_remainder(2, 1) == x_remainder); + + const auto x_shift_right = 2 >> 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_right = boost::hof::_1 >> boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_shift_right)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_shift_right)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_shift_right(2, 1) == x_shift_right); + + const auto x_shift_left = 2 << 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_left = boost::hof::_1 << boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_shift_left)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_shift_left)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_shift_left(2, 1) == x_shift_left); + + const auto x_greater_than = 2 > 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than = boost::hof::_1 > boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_greater_than)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_greater_than)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_greater_than(2, 1) == x_greater_than); + + const auto x_less_than = 2 < 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than = boost::hof::_1 < boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_less_than)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_less_than)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_less_than(2, 1) == x_less_than); + + const auto x_less_than_equal = 2 <= 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than_equal = boost::hof::_1 <= boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_less_than_equal)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_less_than_equal)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_less_than_equal(2, 1) == x_less_than_equal); + + const auto x_greater_than_equal = 2 >= 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than_equal = boost::hof::_1 >= boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_greater_than_equal)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_greater_than_equal)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_greater_than_equal(2, 1) == x_greater_than_equal); + + const auto x_equal = 2 == 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_equal = boost::hof::_1 == boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_equal)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_equal)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_equal(2, 1) == x_equal); + + const auto x_not_equal = 2 != 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_equal = boost::hof::_1 != boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_not_equal)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_equal)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_not_equal(2, 1) == x_not_equal); + + const auto x_bit_and = 2 & 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_and = boost::hof::_1 & boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_bit_and)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_bit_and)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_bit_and(2, 1) == x_bit_and); + + const auto x_xor_ = 2 ^ 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_xor_ = boost::hof::_1 ^ boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_xor_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_xor_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_xor_(2, 1) == x_xor_); + + const auto x_bit_or = 2 | 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_or = boost::hof::_1 | boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_bit_or)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_bit_or)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_bit_or(2, 1) == x_bit_or); + + const auto x_and_ = true && false; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_and_ = boost::hof::_1 && boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_and_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_and_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_and_(true, false) == x_and_); + + const auto x_or_ = true; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_or_ = boost::hof::_1 || boost::hof::_2; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_or_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_or_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_or_(true, false) == x_or_); +} + +BOOST_HOF_TEST_CASE() +{ + + const auto x_not_ = !false; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_ = !boost::hof::_1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_not_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_not_(false) == x_not_); + + const auto x_not_0 = !0; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_0 = !boost::hof::_1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_not_0)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_0)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_not_0(0) == x_not_0); + + const auto x_compl_ = ~2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_compl_ = ~boost::hof::_1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_compl_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_compl_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_compl_(2) == x_compl_); + + const auto x_unary_plus = +2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_unary_plus = +boost::hof::_1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_unary_plus)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_unary_plus)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_unary_plus(2) == x_unary_plus); + + const auto x_unary_subtract = -2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_unary_subtract = -boost::hof::_1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_unary_subtract)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_unary_subtract)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_unary_subtract(2) == x_unary_subtract); + + const auto x_dereference = 2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_dereference = *boost::hof::_1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_dereference)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_dereference)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_dereference(&x_dereference) == x_dereference); + + // TODO: Test BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR increment and decrement +#ifndef _MSC_VER + auto x_increment = 2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_increment = ++boost::hof::_1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_increment)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_increment)>::value, "Not default constructible"); + f_increment(x_increment); + BOOST_HOF_TEST_CHECK(x_increment == 3); + + auto x_decrement = 2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_decrement = --boost::hof::_1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_decrement)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_decrement)>::value, "Not default constructible"); + f_decrement(x_decrement); + BOOST_HOF_TEST_CHECK(x_decrement == 1); +#endif + + // TODO: Test post increment and decrement +} + + +BOOST_HOF_TEST_CASE() +{ + const auto x_add = 2 + 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_add = boost::hof::_ + boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_add)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_add)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_add(2, 1) == x_add); + + const auto x_subtract = 2 - 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_subtract = boost::hof::_ - boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_subtract)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_subtract)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_subtract(2, 1) == x_subtract); + + const auto x_multiply = 2 * 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_multiply = boost::hof::_ * boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_multiply)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_multiply)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_multiply(2, 1) == x_multiply); + + const auto x_divide = 2 / 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_divide = boost::hof::_ / boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_divide)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_divide)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_divide(2, 1) == x_divide); + + const auto x_remainder = 2 % 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_remainder = boost::hof::_ % boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_remainder)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_remainder)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_remainder(2, 1) == x_remainder); + + const auto x_shift_right = 2 >> 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_right = boost::hof::_ >> boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_shift_right)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_shift_right)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_shift_right(2, 1) == x_shift_right); + + const auto x_shift_left = 2 << 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_left = boost::hof::_ << boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_shift_left)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_shift_left)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_shift_left(2, 1) == x_shift_left); + + const auto x_greater_than = 2 > 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than = boost::hof::_ > boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_greater_than)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_greater_than)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_greater_than(2, 1) == x_greater_than); + + const auto x_less_than = 2 < 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than = boost::hof::_ < boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_less_than)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_less_than)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_less_than(2, 1) == x_less_than); + + const auto x_less_than_equal = 2 <= 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than_equal = boost::hof::_ <= boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_less_than_equal)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_less_than_equal)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_less_than_equal(2, 1) == x_less_than_equal); + + const auto x_greater_than_equal = 2 >= 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than_equal = boost::hof::_ >= boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_greater_than_equal)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_greater_than_equal)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_greater_than_equal(2, 1) == x_greater_than_equal); + + const auto x_equal = 2 == 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_equal = boost::hof::_ == boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_equal)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_equal)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_equal(2, 1) == x_equal); + + const auto x_not_equal = 2 != 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_equal = boost::hof::_ != boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_not_equal)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_equal)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_not_equal(2, 1) == x_not_equal); + + const auto x_bit_and = 2 & 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_and = boost::hof::_ & boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_bit_and)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_bit_and)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_bit_and(2, 1) == x_bit_and); + + const auto x_xor_ = 2 ^ 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_xor_ = boost::hof::_ ^ boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_xor_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_xor_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_xor_(2, 1) == x_xor_); + + const auto x_bit_or = 2 | 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_or = boost::hof::_ | boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_bit_or)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_bit_or)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_bit_or(2, 1) == x_bit_or); + + const auto x_and_ = true && false; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_and_ = boost::hof::_ && boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_and_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_and_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_and_(true, false) == x_and_); + + const auto x_or_ = true; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_or_ = boost::hof::_ || boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_or_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_or_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_or_(true, false) == x_or_); +} + +BOOST_HOF_TEST_CASE() +{ + const auto x_add = 2 + 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_add = 2 + boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_add)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_add)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_add(1) == x_add); + + const auto x_subtract = 2 - 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_subtract = 2 - boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_subtract)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_subtract)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_subtract(1) == x_subtract); + + const auto x_multiply = 2 * 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_multiply = 2 * boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_multiply)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_multiply)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_multiply(1) == x_multiply); + + const auto x_divide = 2 / 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_divide = 2 / boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_divide)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_divide)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_divide(1) == x_divide); + + const auto x_remainder = 2 % 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_remainder = 2 % boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_remainder)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_remainder)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_remainder(1) == x_remainder); + + const auto x_shift_right = 2 >> 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_right = 2 >> boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_shift_right)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_shift_right)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_shift_right(1) == x_shift_right); + + const auto x_shift_left = 2 << 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_left = 2 << boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_shift_left)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_shift_left)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_shift_left(1) == x_shift_left); + + const auto x_greater_than = 2 > 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than = 2 > boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_greater_than)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_greater_than)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_greater_than(1) == x_greater_than); + + const auto x_less_than = 2 < 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than = 2 < boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_less_than)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_less_than)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_less_than(1) == x_less_than); + + const auto x_less_than_equal = 2 <= 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than_equal = 2 <= boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_less_than_equal)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_less_than_equal)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_less_than_equal(1) == x_less_than_equal); + + const auto x_greater_than_equal = 2 >= 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than_equal = 2 >= boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_greater_than_equal)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_greater_than_equal)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_greater_than_equal(1) == x_greater_than_equal); + + const auto x_equal = 2 == 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_equal = 2 == boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_equal)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_equal)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_equal(1) == x_equal); + + const auto x_not_equal = 2 != 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_equal = 2 != boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_not_equal)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_not_equal)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_not_equal(1) == x_not_equal); + + const auto x_bit_and = 2 & 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_and = 2 & boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_bit_and)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_bit_and)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_bit_and(1) == x_bit_and); + + const auto x_xor_ = 2 ^ 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_xor_ = 2 ^ boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_xor_)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_xor_)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_xor_(1) == x_xor_); + + const auto x_bit_or = 2 | 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_or = 2 | boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_bit_or)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_bit_or)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_bit_or(1) == x_bit_or); + + const auto x_and_ = true && false; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_and_ = true && boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_and_)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_and_)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_and_(false) == x_and_); + + const auto x_or_ = true; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_or_ = true || boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_or_)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_or_)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_or_(false) == x_or_); +} + +BOOST_HOF_TEST_CASE() +{ + const auto x_add = 2 + 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_add = boost::hof::_ + 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_add)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_add)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_add(2) == x_add); + + const auto x_subtract = 2 - 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_subtract = boost::hof::_ - 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_subtract)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_subtract)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_subtract(2) == x_subtract); + + const auto x_multiply = 2 * 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_multiply = boost::hof::_ * 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_multiply)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_multiply)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_multiply(2) == x_multiply); + + const auto x_divide = 2 / 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_divide = boost::hof::_ / 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_divide)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_divide)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_divide(2) == x_divide); + + const auto x_remainder = 2 % 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_remainder = boost::hof::_ % 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_remainder)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_remainder)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_remainder(2) == x_remainder); + + const auto x_shift_right = 2 >> 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_right = boost::hof::_ >> 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_shift_right)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_shift_right)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_shift_right(2) == x_shift_right); + + const auto x_shift_left = 2 << 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_left = boost::hof::_ << 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_shift_left)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_shift_left)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_shift_left(2) == x_shift_left); + + const auto x_greater_than = 2 > 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than = boost::hof::_ > 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_greater_than)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_greater_than)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_greater_than(2) == x_greater_than); + + const auto x_less_than = 2 < 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than = boost::hof::_ < 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_less_than)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_less_than)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_less_than(2) == x_less_than); + + const auto x_less_than_equal = 2 <= 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than_equal = boost::hof::_ <= 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_less_than_equal)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_less_than_equal)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_less_than_equal(2) == x_less_than_equal); + + const auto x_greater_than_equal = 2 >= 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than_equal = boost::hof::_ >= 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_greater_than_equal)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_greater_than_equal)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_greater_than_equal(2) == x_greater_than_equal); + + const auto x_equal = 2 == 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_equal = boost::hof::_ == 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_equal)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_equal)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_equal(2) == x_equal); + + const auto x_not_equal = 2 != 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_equal = boost::hof::_ != 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_not_equal)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_not_equal)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_not_equal(2) == x_not_equal); + + const auto x_bit_and = 2 & 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_and = boost::hof::_ & 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_bit_and)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_bit_and)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_bit_and(2) == x_bit_and); + + const auto x_xor_ = 2 ^ 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_xor_ = boost::hof::_ ^ 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_xor_)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_xor_)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_xor_(2) == x_xor_); + + const auto x_bit_or = 2 | 1; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_or = boost::hof::_ | 1; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_bit_or)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_bit_or)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_bit_or(2) == x_bit_or); + + const auto x_and_ = true && false; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_and_ = boost::hof::_ && false; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_and_)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_and_)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_and_(true) == x_and_); + + const auto x_or_ = true; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_or_ = boost::hof::_ || false; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_or_)>::value, "Not copyable"); +#endif + static_assert(!boost::hof::detail::is_default_constructible<decltype(f_or_)>::value, "default constructible"); + PLACEHOLDER_CHECK(f_or_(true) == x_or_); +} + +BOOST_HOF_TEST_CASE() +{ + + const auto x_not_ = !false; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_ = !boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_not_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_not_(false) == x_not_); + + const auto x_compl_ = ~2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_compl_ = ~boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_compl_)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_compl_)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_compl_(2) == x_compl_); + + const auto x_unary_plus = +2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_unary_plus = +boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_unary_plus)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_unary_plus)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_unary_plus(2) == x_unary_plus); + + const auto x_unary_subtract = -2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_unary_subtract = -boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_unary_subtract)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_unary_subtract)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_unary_subtract(2) == x_unary_subtract); + + const auto x_dereference = 2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_dereference = *boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_dereference)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_dereference)>::value, "Not default constructible"); + PLACEHOLDER_CHECK(f_dereference(&x_dereference) == x_dereference); + + // TODO: Test constexpr increment and decrement +#ifndef _MSC_VER + auto x_increment = 2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_increment = ++boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_increment)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_increment)>::value, "Not default constructible"); + f_increment(x_increment); + BOOST_HOF_TEST_CHECK(x_increment == 3); + + auto x_decrement = 2; + BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_decrement = --boost::hof::_; +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6 + static_assert(std::is_copy_constructible<decltype(f_decrement)>::value, "Not copyable"); +#endif + static_assert(boost::hof::detail::is_default_constructible<decltype(f_decrement)>::value, "Not default constructible"); + f_decrement(x_decrement); + BOOST_HOF_TEST_CHECK(x_decrement == 1); +#endif + + // TODO: Test post increment and decrement +} + diff --git a/src/boost/libs/hof/test/proj.cpp b/src/boost/libs/hof/test/proj.cpp new file mode 100644 index 000000000..c544fc4bd --- /dev/null +++ b/src/boost/libs/hof/test/proj.cpp @@ -0,0 +1,164 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + proj.cpp + 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/hof/proj.hpp> +#include <boost/hof/placeholders.hpp> +#include <boost/hof/mutable.hpp> +#include "test.hpp" + +#include <memory> + +struct foo +{ + constexpr foo(int xp) : x(xp) + {} + int x; +}; + +struct select_x +{ + template<class T> + constexpr auto operator()(T&& x) const BOOST_HOF_RETURNS(x.x); +}; + +BOOST_HOF_TEST_CASE() +{ +#ifndef _MSC_VER + constexpr +#endif + auto add = boost::hof::_ + boost::hof::_; + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::proj(select_x(), add)(foo(1), foo(2)) == 3); + // Using mutable_ as a workaround on libc++, since mem_fn does not meet the + // requirements of a FunctionObject + BOOST_HOF_TEST_CHECK(boost::hof::proj(boost::hof::mutable_(std::mem_fn(&foo::x)), add)(foo(1), foo(2)) == 3); + static_assert(boost::hof::detail::is_default_constructible<decltype(boost::hof::proj(select_x(), add))>::value, "Not default constructible"); +} + +BOOST_HOF_TEST_CASE() +{ +#ifndef _MSC_VER + constexpr +#endif + auto add = boost::hof::_ + boost::hof::_; + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::proj(select_x(), add)(foo(1), foo(2)) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::proj(&foo::x, add)(foo(1), foo(2)) == 3); + static_assert(boost::hof::detail::is_default_constructible<decltype(boost::hof::proj(select_x(), add))>::value, "Not default constructible"); +} + +BOOST_HOF_TEST_CASE() +{ + auto indirect_add = boost::hof::proj(*boost::hof::_, boost::hof::_ + boost::hof::_); + BOOST_HOF_TEST_CHECK(indirect_add(std::unique_ptr<int>(new int(1)), std::unique_ptr<int>(new int(2))) == 3); + static_assert(boost::hof::detail::is_default_constructible<decltype(indirect_add)>::value, "Not default constructible"); +} + +struct select_x_1 +{ + std::unique_ptr<int> i; + select_x_1() : i(new int(2)) + {} + template<class T> + auto operator()(T&& x) const BOOST_HOF_RETURNS(x.x * (*i)); +}; + +struct sum_1 +{ + std::unique_ptr<int> i; + sum_1() : i(new int(1)) + {} + template<class T, class U> + auto operator()(T&& x, U&& y) const BOOST_HOF_RETURNS(x + y + *i); +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::proj(select_x_1(), sum_1())(foo(1), foo(2)) == 7); +} + +BOOST_HOF_TEST_CASE() +{ + std::string s; + auto f = [&](const std::string& x) + { + s += x; + }; + boost::hof::proj(f)("hello", "-", "world"); + BOOST_HOF_TEST_CHECK(s == "hello-world"); + boost::hof::proj(f)(); + BOOST_HOF_TEST_CHECK(s == "hello-world"); +} + +BOOST_HOF_TEST_CASE() +{ + std::string s; + auto f = [&](const std::string& x) + { + s += x; + return s; + }; + auto last = [](const std::string& x, const std::string& y, const std::string& z) + { + BOOST_HOF_TEST_CHECK(x == "hello"); + BOOST_HOF_TEST_CHECK(y == "hello-"); + BOOST_HOF_TEST_CHECK(z == "hello-world"); + return z; + }; + BOOST_HOF_TEST_CHECK(boost::hof::proj(f, last)("hello", "-", "world") == "hello-world"); +} + +template<bool B> +struct bool_ +{ + static const bool value = B; +}; + +struct constexpr_check +{ + template<class T> + constexpr int operator()(T) const + { + static_assert(T::value, "Failed"); + return 0; + } +}; + +struct constexpr_check_each +{ + template<class T> + constexpr bool operator()(T x) const + { + return boost::hof::proj(constexpr_check())(x, x), true; + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(constexpr_check_each()(bool_<true>())); +} + +BOOST_HOF_TEST_CASE() +{ + boost::hof::proj(boost::hof::identity, boost::hof::identity)(0); +} + +struct bar {}; + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::proj(bar{}); + static_assert(!boost::hof::is_invocable<decltype(f), int>::value, "Not sfinae friendly"); + static_assert(!boost::hof::is_invocable<decltype(f), int, int>::value, "Not sfinae friendly"); + static_assert(!boost::hof::is_invocable<decltype(f), int, int, int>::value, "Not sfinae friendly"); +} + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::proj(bar{}, bar{}); + static_assert(!boost::hof::is_invocable<decltype(f), int>::value, "Not sfinae friendly"); + static_assert(!boost::hof::is_invocable<decltype(f), int, int>::value, "Not sfinae friendly"); + static_assert(!boost::hof::is_invocable<decltype(f), int, int, int>::value, "Not sfinae friendly"); + static_assert(!boost::hof::is_invocable<decltype(f)>::value, "Not sfinae friendly"); +} diff --git a/src/boost/libs/hof/test/protect.cpp b/src/boost/libs/hof/test/protect.cpp new file mode 100644 index 000000000..3059572d1 --- /dev/null +++ b/src/boost/libs/hof/test/protect.cpp @@ -0,0 +1,302 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + protect.cpp + 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/hof/protect.hpp> +#include <boost/hof/lazy.hpp> +#include <boost/hof/placeholders.hpp> +#include <memory> +#include "test.hpp" + +#include <boost/hof/function.hpp> + +int f(int x) +{ + return x; +} + +int& g(int& x) +{ + return x; +} + +template<class T> +const T& constify(const T& arg) +{ + return arg; +} + +BOOST_HOF_TEST_CASE() +{ + int i[9] = {0,1,2,3,4,5,6,7,8}; + + // non-const + + // test nullary + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(1))() == 1); + + // test lvalues + + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))(i[0]) == &i[0]); + + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))(i[0], i[1]) == &i[0]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))(i[0], i[1]) == &i[1]); + + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))(i[0], i[1], i[2]) == &i[0]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))(i[0], i[1], i[2]) == &i[1]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3))(i[0], i[1], i[2]) == &i[2]); + + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))(i[0], i[1], i[2], i[3]) == &i[0]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))(i[0], i[1], i[2], i[3]) == &i[1]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3))(i[0], i[1], i[2], i[3]) == &i[2]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4))(i[0], i[1], i[2], i[3]) == &i[3]); + + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))(i[0], i[1], i[2], i[3], i[4]) == &i[0]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))(i[0], i[1], i[2], i[3], i[4]) == &i[1]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3))(i[0], i[1], i[2], i[3], i[4]) == &i[2]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4))(i[0], i[1], i[2], i[3], i[4]) == &i[3]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5))(i[0], i[1], i[2], i[3], i[4]) == &i[4]); + + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[0]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[1]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[2]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[3]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[4]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_6))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[5]); + + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[0]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[1]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[2]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[3]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[4]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_6))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[5]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_7))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[6]); + + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[0]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[1]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[2]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[3]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[4]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_6))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[5]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_7))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[6]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_8))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[7]); + + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[0]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[1]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[2]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[3]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[4]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_6))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[5]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_7))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[6]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_8))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[7]); + BOOST_HOF_TEST_CHECK(&boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_9))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[8]); + + // test rvalues + + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0) == 0); + + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0, 1) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(0, 1) == 1); + + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0, 1, 2) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(0, 1, 2) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3))(0, 1, 2) == 2); + + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0, 1, 2, 3) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(0, 1, 2, 3) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3))(0, 1, 2, 3) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4))(0, 1, 2, 3) == 3); + + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0, 1, 2, 3, 4) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(0, 1, 2, 3, 4) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3))(0, 1, 2, 3, 4) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4))(0, 1, 2, 3, 4) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5))(0, 1, 2, 3, 4) == 4); + + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0, 1, 2, 3, 4, 5) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(0, 1, 2, 3, 4, 5) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3))(0, 1, 2, 3, 4, 5) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4))(0, 1, 2, 3, 4, 5) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5))(0, 1, 2, 3, 4, 5) == 4); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_6))(0, 1, 2, 3, 4, 5) == 5); + + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0, 1, 2, 3, 4, 5, 6) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(0, 1, 2, 3, 4, 5, 6) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3))(0, 1, 2, 3, 4, 5, 6) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4))(0, 1, 2, 3, 4, 5, 6) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5))(0, 1, 2, 3, 4, 5, 6) == 4); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_6))(0, 1, 2, 3, 4, 5, 6) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_7))(0, 1, 2, 3, 4, 5, 6) == 6); + + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0, 1, 2, 3, 4, 5, 6, 7) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(0, 1, 2, 3, 4, 5, 6, 7) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3))(0, 1, 2, 3, 4, 5, 6, 7) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4))(0, 1, 2, 3, 4, 5, 6, 7) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5))(0, 1, 2, 3, 4, 5, 6, 7) == 4); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_6))(0, 1, 2, 3, 4, 5, 6, 7) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_7))(0, 1, 2, 3, 4, 5, 6, 7) == 6); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_8))(0, 1, 2, 3, 4, 5, 6, 7) == 7); + + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 3); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 4); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_6))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_7))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 6); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_8))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 7); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_9))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 8); + + // test mixed perfect forwarding + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(i[0], 1) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(i[0], 1) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1))(0, i[1]) == 0); + BOOST_HOF_TEST_CHECK(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2))(0, i[1]) == 1); + + // const + + // test nullary + BOOST_HOF_TEST_CHECK(constify(constify(boost::hof::protect(boost::hof::lazy(f)(1))))() == 1); + + // test lvalues + BOOST_HOF_TEST_CHECK(&constify(constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))))(i[0]) == &i[0]); + + BOOST_HOF_TEST_CHECK(&constify(constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))))(i[0], i[1]) == &i[0]); + BOOST_HOF_TEST_CHECK(&constify(constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))))(i[0], i[1]) == &i[1]); + + BOOST_HOF_TEST_CHECK(&constify(constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1))))(i[0], i[1], i[2]) == &i[0]); + BOOST_HOF_TEST_CHECK(&constify(constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2))))(i[0], i[1], i[2]) == &i[1]); + BOOST_HOF_TEST_CHECK(&constify(constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3))))(i[0], i[1], i[2]) == &i[2]); + + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1)))(i[0], i[1], i[2], i[3]) == &i[0]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2)))(i[0], i[1], i[2], i[3]) == &i[1]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3)))(i[0], i[1], i[2], i[3]) == &i[2]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4)))(i[0], i[1], i[2], i[3]) == &i[3]); + + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1)))(i[0], i[1], i[2], i[3], i[4]) == &i[0]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2)))(i[0], i[1], i[2], i[3], i[4]) == &i[1]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3)))(i[0], i[1], i[2], i[3], i[4]) == &i[2]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4)))(i[0], i[1], i[2], i[3], i[4]) == &i[3]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5)))(i[0], i[1], i[2], i[3], i[4]) == &i[4]); + + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[0]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[1]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[2]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[3]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[4]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_6)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[5]); + + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[0]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[1]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[2]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[3]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[4]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_6)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[5]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_7)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[6]); + + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[0]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[1]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[2]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[3]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[4]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_6)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[5]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_7)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[6]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_8)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[7]); + + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_1)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[0]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_2)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[1]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_3)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[2]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_4)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[3]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_5)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[4]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_6)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[5]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_7)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[6]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_8)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[7]); + BOOST_HOF_TEST_CHECK(&constify(boost::hof::protect(boost::hof::lazy(g)(std::placeholders::_9)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[8]); + + // test rvalues + + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0) == 0); + + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0, 1) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(0, 1) == 1); + + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0, 1, 2) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(0, 1, 2) == 1); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3)))(0, 1, 2) == 2); + + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0, 1, 2, 3) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(0, 1, 2, 3) == 1); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3)))(0, 1, 2, 3) == 2); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4)))(0, 1, 2, 3) == 3); + + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0, 1, 2, 3, 4) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(0, 1, 2, 3, 4) == 1); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3)))(0, 1, 2, 3, 4) == 2); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4)))(0, 1, 2, 3, 4) == 3); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5)))(0, 1, 2, 3, 4) == 4); + + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0, 1, 2, 3, 4, 5) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(0, 1, 2, 3, 4, 5) == 1); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3)))(0, 1, 2, 3, 4, 5) == 2); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4)))(0, 1, 2, 3, 4, 5) == 3); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5)))(0, 1, 2, 3, 4, 5) == 4); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_6)))(0, 1, 2, 3, 4, 5) == 5); + + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0, 1, 2, 3, 4, 5, 6) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(0, 1, 2, 3, 4, 5, 6) == 1); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3)))(0, 1, 2, 3, 4, 5, 6) == 2); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4)))(0, 1, 2, 3, 4, 5, 6) == 3); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5)))(0, 1, 2, 3, 4, 5, 6) == 4); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_6)))(0, 1, 2, 3, 4, 5, 6) == 5); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_7)))(0, 1, 2, 3, 4, 5, 6) == 6); + + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0, 1, 2, 3, 4, 5, 6, 7) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(0, 1, 2, 3, 4, 5, 6, 7) == 1); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3)))(0, 1, 2, 3, 4, 5, 6, 7) == 2); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4)))(0, 1, 2, 3, 4, 5, 6, 7) == 3); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5)))(0, 1, 2, 3, 4, 5, 6, 7) == 4); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_6)))(0, 1, 2, 3, 4, 5, 6, 7) == 5); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_7)))(0, 1, 2, 3, 4, 5, 6, 7) == 6); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_8)))(0, 1, 2, 3, 4, 5, 6, 7) == 7); + + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 1); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_3)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 2); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_4)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 3); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_5)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 4); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_6)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 5); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_7)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 6); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_8)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 7); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_9)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 8); + + // test mixed perfect forwarding + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(i[0], 1) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(i[0], 1) == 1); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_1)))(0, i[1]) == 0); + BOOST_HOF_TEST_CHECK(constify(boost::hof::protect(boost::hof::lazy(f)(std::placeholders::_2)))(0, i[1]) == 1); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::lazy(boost::hof::apply)(boost::hof::protect(boost::hof::lazy(boost::hof::identity)(boost::hof::_1)), boost::hof::_1)(17) == 17); + BOOST_HOF_TEST_CHECK(boost::hof::lazy(boost::hof::apply)(boost::hof::protect(boost::hof::lazy(boost::hof::identity)(boost::hof::_1)), 17)() == 17); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::lazy(boost::hof::apply)(boost::hof::protect(boost::hof::lazy(boost::hof::identity)(boost::hof::_1)), boost::hof::_1)(17) == 17); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::lazy(boost::hof::apply)(boost::hof::protect(boost::hof::lazy(boost::hof::identity)(boost::hof::_1)), 17)() == 17); +} + +namespace test1 { + +int id(int x) +{ + return x; +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::lazy(boost::hof::apply)(boost::hof::protect(boost::hof::lazy(id)(std::placeholders::_1)), std::placeholders::_1)(17) == 17); + BOOST_HOF_TEST_CHECK(boost::hof::lazy(boost::hof::apply)(boost::hof::protect(boost::hof::lazy(id)(std::placeholders::_1)), 17)() == 17); +} + +} diff --git a/src/boost/libs/hof/test/repeat.cpp b/src/boost/libs/hof/test/repeat.cpp new file mode 100644 index 000000000..19b3b51d7 --- /dev/null +++ b/src/boost/libs/hof/test/repeat.cpp @@ -0,0 +1,66 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + repeat.cpp + 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/hof/repeat.hpp> +#include <limits> +#include "test.hpp" + +// TODO: Add tests for multiple parameters + +struct increment +{ + template<class T> + constexpr T operator()(T x) const noexcept + { + return x + 1; + } +}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::repeat(std::integral_constant<int, 5>())(increment())(1)), "noexcept repeat"); + static_assert(noexcept(boost::hof::repeat(5)(increment())(1)), "noexcept repeat"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::repeat(std::integral_constant<int, 5>())(increment())(1) == 6); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::repeat(std::integral_constant<int, 5>())(increment())(1) == 6); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::repeat(5)(increment())(1) == 6); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::repeat(5)(increment())(1) == 6); +} + +BOOST_HOF_TEST_CASE() +{ + int i = 5; + BOOST_HOF_TEST_CHECK(boost::hof::repeat(i)(increment())(1) == 6); +} + +BOOST_HOF_TEST_CASE() +{ + static const int i = 5; + BOOST_HOF_TEST_CHECK(boost::hof::repeat(i)(increment())(1) == 6); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::repeat(i)(increment())(1) == 6); +} + +// BOOST_HOF_TEST_CASE() +// { +// BOOST_HOF_TEST_CHECK(boost::hof::repeat(std::numeric_limits<int>::max()/4)(increment())(0) == std::numeric_limits<int>::max()/4); +// } + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::repeat(BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH+4)(increment())(0) == BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH+4); +#if BOOST_HOF_HAS_RELAXED_CONSTEXPR + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::repeat(BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH+4)(increment())(0) == BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH+4); +#endif +} diff --git a/src/boost/libs/hof/test/repeat_while.cpp b/src/boost/libs/hof/test/repeat_while.cpp new file mode 100644 index 000000000..3b1d9fc1f --- /dev/null +++ b/src/boost/libs/hof/test/repeat_while.cpp @@ -0,0 +1,95 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + repeat_while.cpp + 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/hof/repeat_while.hpp> +#include <boost/hof/reveal.hpp> +#include "test.hpp" + +// TODO: Test default construction, and static initialization + +struct increment_constant +{ + template<class T> + constexpr std::integral_constant<int, T::value + 1> operator()(T) const noexcept + { + return std::integral_constant<int, T::value + 1>(); + } +}; + +struct increment +{ + template<class T> + constexpr T operator()(T x) const noexcept + { + return x + 1; + } +}; + +struct not_6_constant +{ + template<class T> + constexpr std::integral_constant<bool, (T::value != 6)> + operator()(T) const noexcept + { + return std::integral_constant<bool, (T::value != 6)>(); + } +}; + +struct not_6 +{ + template<class T> + constexpr bool operator()(T x) const noexcept + { + return x != 6; + } +}; + +struct not_limit +{ + template<class T> + constexpr bool operator()(T x) const + { + return x != (BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH+4); + } +}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::repeat_while(not_6())(increment())(1)), "noexcept repeat_while"); + static_assert(noexcept(boost::hof::repeat_while(not_6_constant())(increment_constant())(std::integral_constant<int, 1>())), "noexcept repeat_while"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + static_assert + ( + std::is_same< + std::integral_constant<int, 6>, + decltype(boost::hof::repeat_while(not_6_constant())(increment_constant())(std::integral_constant<int, 1>())) + >::value, + "Error" + ); + + std::integral_constant<int, 6> x = boost::hof::repeat_while(not_6_constant())(increment_constant())(std::integral_constant<int, 1>()); + boost::hof::test::unused(x); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::repeat_while(not_6())(increment())(1) == 6); + BOOST_HOF_TEST_CHECK(boost::hof::repeat_while(not_6())(increment())(1) == 6); + BOOST_HOF_TEST_CHECK(boost::hof::reveal(boost::hof::repeat_while(not_6())(increment()))(1) == 6); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::repeat_while(not_limit())(increment())(1) == BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH+4); +#if BOOST_HOF_HAS_RELAXED_CONSTEXPR + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::repeat_while(not_limit())(increment())(1) == BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH+4); +#endif +} diff --git a/src/boost/libs/hof/test/result.cpp b/src/boost/libs/hof/test/result.cpp new file mode 100644 index 000000000..cae0bb78d --- /dev/null +++ b/src/boost/libs/hof/test/result.cpp @@ -0,0 +1,26 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + result.cpp + 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/hof/result.hpp> +#include <boost/hof/static.hpp> +#include "test.hpp" + + +static constexpr boost::hof::result_adaptor<int, unary_class> unary_int = {}; + +BOOST_HOF_TEST_CASE() +{ + STATIC_ASSERT_SAME(decltype(unary_int(false)), int); + BOOST_HOF_TEST_CHECK(unary_int(false) == 0); + BOOST_HOF_STATIC_TEST_CHECK(unary_int(false) == 0); +} + +static constexpr boost::hof::result_adaptor<void, unary_class> unary_void = {}; + +BOOST_HOF_TEST_CASE() +{ + STATIC_ASSERT_SAME(decltype(unary_void(false)), void); +} diff --git a/src/boost/libs/hof/test/returns.cpp b/src/boost/libs/hof/test/returns.cpp new file mode 100644 index 000000000..aec77819b --- /dev/null +++ b/src/boost/libs/hof/test/returns.cpp @@ -0,0 +1,56 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + returns.cpp + 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/hof/returns.hpp> +#include "test.hpp" + +#if !defined (__GNUC__) || defined (__clang__) +struct add_1 +{ + int a; + add_1() : a(1) {} + + BOOST_HOF_RETURNS_CLASS(add_1); + + template<class T> + auto operator()(T x) const + BOOST_HOF_RETURNS(x+BOOST_HOF_CONST_THIS->a); +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == add_1()(2)); +} +#endif +// TODO: check noexcept +struct id +{ + template<class T> + constexpr auto operator()(T x) const BOOST_HOF_RETURNS + (x); +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(id{}(3) == 3); + BOOST_HOF_STATIC_TEST_CHECK(id{}(3) == 3); +} + +struct void_ {}; +constexpr void_ no_op() { return void_{}; } + +struct id_comma +{ + template<class T> + constexpr auto operator()(T&& x) const BOOST_HOF_RETURNS + (no_op(), boost::hof::forward<T>(x)); +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(id_comma{}(3) == 3); + BOOST_HOF_STATIC_TEST_CHECK(id_comma{}(3) == 3); +} diff --git a/src/boost/libs/hof/test/reveal.cpp b/src/boost/libs/hof/test/reveal.cpp new file mode 100644 index 000000000..9e7014d26 --- /dev/null +++ b/src/boost/libs/hof/test/reveal.cpp @@ -0,0 +1,157 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + reveal.cpp + 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 "test.hpp" +#include <boost/hof/reveal.hpp> +#include <boost/hof/first_of.hpp> +#include <boost/hof/static.hpp> +#include <boost/hof/lambda.hpp> +#include <boost/hof/fix.hpp> + +namespace reveal_test { + +#define CONDITIONAL_FUNCTION(n) \ +struct t ## n {}; \ +struct f ## n \ +{ \ + constexpr int operator()(t ## n) const \ + { \ + return n; \ + } \ +}; + +CONDITIONAL_FUNCTION(1) +CONDITIONAL_FUNCTION(2) +CONDITIONAL_FUNCTION(3) + +typedef boost::hof::first_of_adaptor<f1, f2, f3> f_type; +static constexpr boost::hof::static_<f_type> f = {}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::reveal(f)(t1()) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::reveal(f)(t2()) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::reveal(f)(t3()) == 3); + + + static_assert(boost::hof::is_invocable<boost::hof::reveal_adaptor<f_type>, t1>::value, "Invocable"); + static_assert(boost::hof::is_invocable<boost::hof::reveal_adaptor<f_type>, t2>::value, "Invocable"); + static_assert(boost::hof::is_invocable<boost::hof::reveal_adaptor<f_type>, t3>::value, "Invocable"); + + static_assert(!boost::hof::is_invocable<boost::hof::reveal_adaptor<f_type>, int>::value, "Invocable"); + // boost::hof::reveal(f)(1); +} + +#ifndef _MSC_VER +static constexpr auto lam = boost::hof::first_of( + BOOST_HOF_STATIC_LAMBDA(t1) + { + return 1; + }, + BOOST_HOF_STATIC_LAMBDA(t2) + { + return 2; + }, + BOOST_HOF_STATIC_LAMBDA(t3) + { + return 3; + } +); + +BOOST_HOF_TEST_CASE() +{ + STATIC_ASSERT_EMPTY(lam); + STATIC_ASSERT_EMPTY(boost::hof::reveal(lam)); + BOOST_HOF_TEST_CHECK(boost::hof::reveal(lam)(t1()) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::reveal(lam)(t2()) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::reveal(lam)(t3()) == 3); + + // boost::hof::reveal(lam)(1); + // lam(1); +} +#endif + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(static_fun) = boost::hof::first_of( + [](t1) + { + return 1; + }, + [](t2) + { + return 2; + }, + [](t3) + { + return 3; + } +); + +BOOST_HOF_TEST_CASE() +{ +#ifndef _MSC_VER + STATIC_ASSERT_EMPTY(static_fun); + // STATIC_ASSERT_EMPTY(boost::hof::reveal(static_fun)); +#endif + BOOST_HOF_TEST_CHECK(boost::hof::reveal(static_fun)(t1()) == 1); + BOOST_HOF_TEST_CHECK(boost::hof::reveal(static_fun)(t2()) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::reveal(static_fun)(t3()) == 3); + + BOOST_HOF_TEST_CHECK(static_fun(t1()) == 1); + BOOST_HOF_TEST_CHECK(static_fun(t2()) == 2); + BOOST_HOF_TEST_CHECK(static_fun(t3()) == 3); + + // boost::hof::reveal(static_fun)(1); +} + +struct integral_type +{ + template<class T> + BOOST_HOF_USING_TYPENAME(failure_alias, std::enable_if<std::is_integral<T>::value>::type); + + struct failure + : boost::hof::as_failure<failure_alias> + {}; + + template<class T, class=typename std::enable_if<std::is_integral<T>::value>::type> + constexpr T operator()(T x) const + { + return x; + } +}; +struct foo {}; +struct dont_catch {}; + +struct catch_all +{ + template<class T> + BOOST_HOF_USING_TYPENAME(failure_alias, std::enable_if<!std::is_same<T, dont_catch>::value>::type); + + struct failure + : boost::hof::as_failure<failure_alias> + {}; + + template<class T, class=typename std::enable_if<!std::is_same<T, dont_catch>::value>::type> + constexpr int operator()(T) const + { + return -1; + } +}; + +static constexpr boost::hof::reveal_adaptor<boost::hof::first_of_adaptor<integral_type, catch_all>> check_failure = {}; + + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(check_failure(5) == 5); + BOOST_HOF_TEST_CHECK(check_failure(foo()) == -1); + + static_assert(!boost::hof::is_invocable<decltype(check_failure), dont_catch>::value, "Invocable"); + static_assert(!boost::hof::is_invocable<decltype(check_failure), int, int>::value, "Invocable"); + + // check_failure(dont_catch()); +} + +} diff --git a/src/boost/libs/hof/test/reverse_fold.cpp b/src/boost/libs/hof/test/reverse_fold.cpp new file mode 100644 index 000000000..9238e433e --- /dev/null +++ b/src/boost/libs/hof/test/reverse_fold.cpp @@ -0,0 +1,93 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + reverse_fold.cpp + 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/hof/reverse_fold.hpp> +#include "test.hpp" + +struct max_f +{ + template<class T, class U> + constexpr T operator()(T x, U y) const noexcept + { + return x > y ? x : y; + } +}; + +struct sum_f +{ + template<class T, class U> + constexpr T operator()(T x, U y) const BOOST_HOF_RETURNS_DEDUCE_NOEXCEPT(x+y) + { + return x + y; + } +}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::reverse_fold(max_f(), 0)(2, 3, 4, 5)), "noexcept reverse_fold"); + static_assert(noexcept(boost::hof::reverse_fold(sum_f(), 0)(2, 3, 4, 5)), "noexcept reverse_fold"); + static_assert(!noexcept(boost::hof::reverse_fold(sum_f(), std::string())("hello", "-", "world")), "noexcept reverse_fold"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)(2, 3, 4, 5) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)(5, 4, 3, 2) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)(2, 3, 5, 4) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)(2, 3, 4, 5) == 5); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)(5, 4, 3, 2) == 5); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)(2, 3, 5, 4) == 5); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)() == 0); + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)(5) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)() == 0); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reverse_fold(max_f(), 0)(5) == 5); +} + +template<class... Ts> +constexpr auto find_positive_max(Ts... xs) BOOST_HOF_RETURNS +( + boost::hof::reverse_fold(max_f(), 0)(xs...) +); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(find_positive_max() == 0); + BOOST_HOF_TEST_CHECK(find_positive_max(5) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(find_positive_max() == 0); + BOOST_HOF_STATIC_TEST_CHECK(find_positive_max(5) == 5); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(max_f())(5) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reverse_fold(max_f())(5) == 5); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(max_f())(2, 3, 4, 5) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(max_f())(5, 4, 3, 2) == 5); + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(max_f())(2, 3, 5, 4) == 5); + + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reverse_fold(max_f())(2, 3, 4, 5) == 5); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reverse_fold(max_f())(5, 4, 3, 2) == 5); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::reverse_fold(max_f())(2, 3, 5, 4) == 5); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::reverse_fold(sum_f(), std::string())("hello", "-", "world") == "world-hello"); +} diff --git a/src/boost/libs/hof/test/rotate.cpp b/src/boost/libs/hof/test/rotate.cpp new file mode 100644 index 000000000..13f15806d --- /dev/null +++ b/src/boost/libs/hof/test/rotate.cpp @@ -0,0 +1,71 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + rotate.cpp + 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/hof/rotate.hpp> +#include <boost/hof/placeholders.hpp> +#include <boost/hof/compose.hpp> +#include <boost/hof/repeat.hpp> +#include "test.hpp" + +struct head +{ + template<class T, class... Ts> + constexpr T operator()(T x, Ts&&...) const + BOOST_HOF_RETURNS_DEDUCE_NOEXCEPT(x) + { + return x; + } +}; + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::rotate(head{})(1, 2, 3, 4)), "noexcept rotate"); + static_assert(noexcept(boost::hof::repeat(std::integral_constant<int, 5>{})(boost::hof::rotate)(head{})(1, 2, 3, 4, 5, 6, 7, 8, 9)), "noexcept rotate"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(2 == boost::hof::rotate(head{})(1, 2, 3, 4)); + BOOST_HOF_STATIC_TEST_CHECK(2 == boost::hof::rotate(head{})(1, 2, 3, 4)); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::compose(boost::hof::rotate, boost::hof::rotate)(head{})(1, 2, 3, 4)); + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::compose(boost::hof::rotate, boost::hof::rotate)(head{})(1, 2, 3, 4)); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(6 == boost::hof::repeat(std::integral_constant<int, 5>{})(boost::hof::rotate)(head{})(1, 2, 3, 4, 5, 6, 7, 8, 9)); + BOOST_HOF_STATIC_TEST_CHECK(6 == boost::hof::repeat(std::integral_constant<int, 5>{})(boost::hof::rotate)(head{})(1, 2, 3, 4, 5, 6, 7, 8, 9)); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::rotate(boost::hof::_ - boost::hof::_)(2, 5)); + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::rotate(boost::hof::_ - boost::hof::_)(2, 5)); +} + +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7 +#define FINAL +#else +#define FINAL final +#endif + + +struct f FINAL { + int operator()(int i, void *) const { + return i; + } +}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::rotate(f())(nullptr, 2) == 2); +} diff --git a/src/boost/libs/hof/test/static.cpp b/src/boost/libs/hof/test/static.cpp new file mode 100644 index 000000000..f718dd404 --- /dev/null +++ b/src/boost/libs/hof/test/static.cpp @@ -0,0 +1,24 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + static.cpp + 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/hof/static.hpp> +#include "test.hpp" + +// TODO: Test infix + +static constexpr boost::hof::static_<binary_class> binary_static = {}; + +static constexpr boost::hof::static_<void_class> void_static = {}; + +static constexpr boost::hof::static_<mono_class> mono_static = {}; + + +BOOST_HOF_TEST_CASE() +{ + void_static(1); + BOOST_HOF_TEST_CHECK(3 == binary_static(1, 2)); + BOOST_HOF_TEST_CHECK(3 == mono_static(2)); +} diff --git a/src/boost/libs/hof/test/static_def/static_def.cpp b/src/boost/libs/hof/test/static_def/static_def.cpp new file mode 100644 index 000000000..83e9c7978 --- /dev/null +++ b/src/boost/libs/hof/test/static_def/static_def.cpp @@ -0,0 +1,59 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + static_def.cpp + 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 <cstdio> +#include "static_def.hpp" + +extern int f(); + +extern void* f_sum_lambda_addr(); +extern void* f_sum_fo_addr(); + +extern void* sum_lambda_addr(); +extern void* sum_fo_addr(); + +extern void* f_sum_var_addr(); +extern void* f_sum_constexpr_fo_addr(); + +extern void* sum_var_addr(); +extern void* sum_constexpr_fo_addr(); + +void* sum_lambda_addr() +{ + return (void*)&fit_test::fit_sum_lambda; +} +void* sum_fo_addr() +{ + return (void*)&fit_test::fit_sum_fo; +} + +void* sum_var_addr() +{ + return (void*)&fit_test::fit_sum_var; +} +void* sum_constexpr_fo_addr() +{ + return (void*)&fit_test::fit_sum_constexpr_fo; +} + +int main() +{ + if (fit_test::fit_sum_fo(1, 2) != 3) printf("FAILED\n"); + if (fit_test::fit_sum_lambda(1, 2) != 3) printf("FAILED\n"); + if (fit_test::fit_sum(1, 2) != 3) printf("FAILED\n"); + +#if BOOST_HOF_HAS_UNIQUE_STATIC_LAMBDA_FUNCTION_ADDR + if (sum_lambda_addr() != f_sum_lambda_addr()) printf("FAILED: Lambda\n"); + if (sum_fo_addr() != f_sum_fo_addr()) printf("FAILED: Function object\n"); +#endif + +#if BOOST_HOF_HAS_UNIQUE_STATIC_VAR + if (sum_var_addr() != f_sum_var_addr()) printf("FAILED: Lambda\n"); + if (sum_constexpr_fo_addr() != f_sum_constexpr_fo_addr()) printf("FAILED: Function object\n"); +#endif + return f(); +} diff --git a/src/boost/libs/hof/test/static_def/static_def.hpp b/src/boost/libs/hof/test/static_def/static_def.hpp new file mode 100644 index 000000000..10574c64d --- /dev/null +++ b/src/boost/libs/hof/test/static_def/static_def.hpp @@ -0,0 +1,61 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + static_def.hpp + 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) +==============================================================================*/ + +#ifndef GUARD_STATIC_DEF +#define GUARD_STATIC_DEF + +#include <boost/hof/function.hpp> +#include <boost/hof/lambda.hpp> + +// MSVC seems to not support unique addressing at all +#if defined (_MSC_VER) +#define BOOST_HOF_HAS_UNIQUE_STATIC_VAR 0 +#define BOOST_HOF_HAS_UNIQUE_STATIC_LAMBDA_FUNCTION_ADDR 0 +// Gcc 4.6 only supports unique addressing for non-lambdas +#elif defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7 +#define BOOST_HOF_HAS_UNIQUE_STATIC_VAR 1 +#define BOOST_HOF_HAS_UNIQUE_STATIC_LAMBDA_FUNCTION_ADDR 0 +#else +#define BOOST_HOF_HAS_UNIQUE_STATIC_VAR 1 +#define BOOST_HOF_HAS_UNIQUE_STATIC_LAMBDA_FUNCTION_ADDR 1 +#endif + +namespace fit_test { + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(fit_sum_lambda) = [](int x, int y) +{ + return x + y; +}; + +struct fit_sum_f +{ + constexpr int operator()(int x, int y) const + { + return x + y; + } +}; + +BOOST_HOF_STATIC_LAMBDA_FUNCTION(fit_sum_fo) = fit_sum_f(); + +BOOST_HOF_STATIC_FUNCTION(fit_sum_constexpr_fo) = fit_sum_f(); + +BOOST_HOF_DECLARE_STATIC_VAR(fit_sum_var, fit_sum_f); + +// BOOST_HOF_STATIC_FUNCTION(fit_sum) = [](auto x, auto y) +// { +// return x + y; +// }; + +template<class T> +T fit_sum(T x, T y) +{ + return x + y; +}; + +} + +#endif diff --git a/src/boost/libs/hof/test/static_def/static_def2.cpp b/src/boost/libs/hof/test/static_def/static_def2.cpp new file mode 100644 index 000000000..b5e86e56c --- /dev/null +++ b/src/boost/libs/hof/test/static_def/static_def2.cpp @@ -0,0 +1,58 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + static_def2.cpp + 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 <cstdio> +#include "static_def.hpp" + +extern void* f_sum_lambda_addr(); +extern void* f_sum_fo_addr(); + +extern void* sum_lambda_addr(); +extern void* sum_fo_addr(); + +extern void* f_sum_var_addr(); +extern void* f_sum_constexpr_fo_addr(); + +extern void* sum_var_addr(); +extern void* sum_constexpr_fo_addr(); + +void* f_sum_lambda_addr() +{ + return (void*)&fit_test::fit_sum_lambda; +} +void* f_sum_fo_addr() +{ + return (void*)&fit_test::fit_sum_fo; +} + +void* f_sum_var_addr() +{ + return (void*)&fit_test::fit_sum_var; +} +void* f_sum_constexpr_fo_addr() +{ + return (void*)&fit_test::fit_sum_constexpr_fo; +} + +int f() +{ + if (fit_test::fit_sum_fo(1, 2) != 3) printf("FAILED\n"); + if (fit_test::fit_sum_lambda(1, 2) != 3) printf("FAILED\n"); + if (fit_test::fit_sum(1, 2) != 3) printf("FAILED\n"); + +#if BOOST_HOF_HAS_UNIQUE_STATIC_LAMBDA_FUNCTION_ADDR + if (sum_lambda_addr() != f_sum_lambda_addr()) printf("FAILED: Lambda\n"); + if (sum_fo_addr() != f_sum_fo_addr()) printf("FAILED: Function object\n"); +#endif + +#if BOOST_HOF_HAS_UNIQUE_STATIC_VAR + if (sum_var_addr() != f_sum_var_addr()) printf("FAILED: Lambda\n"); + if (sum_constexpr_fo_addr() != f_sum_constexpr_fo_addr()) printf("FAILED: Function object\n"); +#endif + return 0; +} + diff --git a/src/boost/libs/hof/test/tap.cpp b/src/boost/libs/hof/test/tap.cpp new file mode 100644 index 000000000..25a92e4d0 --- /dev/null +++ b/src/boost/libs/hof/test/tap.cpp @@ -0,0 +1,25 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + tap.cpp + 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/hof/tap.hpp> +#include "test.hpp" + +struct sum_f +{ + template<class T, class U> + constexpr T operator()(T x, U y) const + { + return x+y; + } +}; + +static constexpr boost::hof::pipable_adaptor<sum_f> sum = {}; +// TODO: Test constexpr +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == (1 | sum(2))); + BOOST_HOF_TEST_CHECK(5 == (1 | sum(2) | boost::hof::tap([](int i) { BOOST_HOF_TEST_CHECK(3 == i); }) | sum(2))); +} diff --git a/src/boost/libs/hof/test/test.hpp b/src/boost/libs/hof/test/test.hpp new file mode 100644 index 000000000..17fbd3676 --- /dev/null +++ b/src/boost/libs/hof/test/test.hpp @@ -0,0 +1,190 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + test.hpp + 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) +==============================================================================*/ +#ifndef GUARD_TEST_H +#define GUARD_TEST_H + +#include <type_traits> +#include <tuple> +#include <iostream> +#include <functional> +#include <vector> +#include <memory> +#include <boost/hof/detail/forward.hpp> + +#ifndef BOOST_HOF_HAS_STATIC_TEST_CHECK +#if (defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7) || defined(_MSC_VER) +#define BOOST_HOF_HAS_STATIC_TEST_CHECK 0 +#else +#define BOOST_HOF_HAS_STATIC_TEST_CHECK 1 +#endif +#endif + + +#define BOOST_HOF_PP_CAT(x, y) BOOST_HOF_PP_PRIMITIVE_CAT(x, y) +#define BOOST_HOF_PP_PRIMITIVE_CAT(x, y) x ## y + +namespace boost { namespace hof { namespace test { + +typedef std::function<void()> test_case; +static std::vector<test_case> test_cases; + +struct auto_register +{ + auto_register(test_case tc) + { + test_cases.push_back(tc); + } +}; + +#define BOOST_HOF_DETAIL_TEST_CASE(name) \ +struct name \ +{ void operator()() const; }; \ +static boost::hof::test::auto_register BOOST_HOF_PP_CAT(name, _register) = boost::hof::test::auto_register(name()); \ +void name::operator()() const + +template<class T> +T bare(const T&); + +template<class T> +inline void unused(T&&) {} + +}}} // namespace boost::hof + +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7 +#define BOOST_HOF_STATIC_AUTO constexpr auto +#else +#define BOOST_HOF_STATIC_AUTO const constexpr auto +#endif + +#define STATIC_ASSERT_SAME(...) static_assert(std::is_same<__VA_ARGS__>::value, "Types are not the same") +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7 +#define STATIC_ASSERT_MOVE_ONLY(T) +#else +#define STATIC_ASSERT_MOVE_ONLY(T) static_assert(!std::is_copy_constructible<T>::value && std::is_move_constructible<T>::value, "Not movable") +#endif +#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 7 +#define STATIC_ASSERT_NOT_DEFAULT_CONSTRUCTIBLE(T) +#else +#define STATIC_ASSERT_NOT_DEFAULT_CONSTRUCTIBLE(T) static_assert(!std::is_default_constructible<T>::value, "Default constructible") +#endif +#define STATIC_ASSERT_EMPTY(x) static_assert(std::is_empty<decltype(boost::hof::test::bare(x))>::value, "Not empty"); + + +#define BOOST_HOF_TEST_CASE() BOOST_HOF_DETAIL_TEST_CASE(BOOST_HOF_PP_CAT(test_, __LINE__)) +#define BOOST_HOF_STATIC_TEST_CASE() struct BOOST_HOF_PP_CAT(test_, __LINE__) + +#define BOOST_HOF_TEST_TEMPLATE(...) typedef std::integral_constant<int, sizeof(__VA_ARGS__)> BOOST_HOF_PP_CAT(test_template_, __LINE__) + +#define BOOST_HOF_TEST_CHECK(...) if (!(__VA_ARGS__)) std::cout << "***** FAILED *****: " << #__VA_ARGS__ << "@" << __FILE__ << ": " << __LINE__ << std::endl +#define BOOST_HOF_STRINGIZE(...) #__VA_ARGS__ + +#if BOOST_HOF_HAS_STATIC_TEST_CHECK +#define BOOST_HOF_STATIC_TEST_CHECK(...) static_assert(__VA_ARGS__, BOOST_HOF_STRINGIZE(__VA_ARGS__)) +#else +#define BOOST_HOF_STATIC_TEST_CHECK(...) +#endif + +#ifndef BOOST_HOF_HAS_CONSTEXPR_TUPLE +#define BOOST_HOF_HAS_CONSTEXPR_TUPLE BOOST_HOF_HAS_STD_14 +#endif + +struct binary_class +{ + template<class T, class U> + constexpr T operator()(T x, U y) const noexcept + { + return x+y; + } + +}; + +struct mutable_class +{ + template<class F> + struct result; + + template<class F, class T, class U> + struct result<F(T&, U)> + { + typedef T type; + }; + + template<class T, class U> + T operator()(T & x, U y) const + { + return x+=y; + } + +}; + +struct unary_class +{ + template<class T> + constexpr T&& operator()(T&& x) const noexcept + { + return boost::hof::forward<T>(x); + } + +}; + +struct void_class +{ + template<class T> + void operator()(T) const + { + } +}; + +struct mono_class +{ + constexpr int operator()(int x) const + { + return x+1; + } +}; + +struct tuple_class +{ + // Note: Taking the tuple by value causes the compiler to ICE on gcc 4.7 + // when called in a constexpr context. + template<class T> + constexpr int operator()(const T& t) const + { + return std::get<0>(t) + 1; + } +}; + +template<class R> +struct explicit_class +{ + template<class T> + R operator()(T x) + { + return static_cast<R>(x); + } +}; + +struct move_class +{ + std::unique_ptr<int> i; + move_class() : i(new int(0)) + {} + + template<class T, class U> + constexpr T operator()(T x, U y) const + { + return x+y+*i; + } +}; + +int main() +{ + for(const auto& tc: boost::hof::test::test_cases) tc(); + return 0; +} + +#endif diff --git a/src/boost/libs/hof/test/tuple_for_each.cpp b/src/boost/libs/hof/test/tuple_for_each.cpp new file mode 100644 index 000000000..e784c1f2e --- /dev/null +++ b/src/boost/libs/hof/test/tuple_for_each.cpp @@ -0,0 +1,247 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + tuple_for_each.cpp + 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/hof/unpack.hpp> +#include <boost/hof/proj.hpp> +#include <boost/hof/function.hpp> +#include <boost/hof/reveal.hpp> +#include "test.hpp" + +struct tuple_for_each_f +{ + template<class Sequence, class F> + constexpr auto operator()(Sequence&& s, F && f) const BOOST_HOF_RETURNS + ( + boost::hof::unpack(boost::hof::proj(boost::hof::forward<F>(f)))(boost::hof::forward<Sequence>(s)), boost::hof::forward<F>(f) + ); +}; + +BOOST_HOF_STATIC_FUNCTION(tuple_for_each) = tuple_for_each_f{}; + +BOOST_HOF_TEST_CASE() +{ + std::tuple<int, short, char> tp{ 1, 2, 3 }; + + { + int s = 0; + + tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } + + { + int s = 0; + + tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } +} +BOOST_HOF_TEST_CASE() +{ + std::tuple<int, short, char> const tp{ 1, 2, 3 }; + + { + int s = 0; + + tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } + + { + int s = 0; + + tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } +} + +// #if defined( __clang_major__ ) && __clang_major__ == 3 && __clang_minor__ < 8 +// #else +BOOST_HOF_TEST_CASE() +{ + std::tuple<std::unique_ptr<int>, std::unique_ptr<int>, std::unique_ptr<int>> tp{ std::unique_ptr<int>(new int(1)), std::unique_ptr<int>(new int(2)), std::unique_ptr<int>(new int(3)) }; + + int s = 0; + + tuple_for_each( std::move(tp), [&]( std::unique_ptr<int> p ){ s = s * 10 + *p; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); +} + +BOOST_HOF_TEST_CASE() +{ + auto tp = boost::hof::pack(1, 2, 3); + + { + int s = 0; + + tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } + + { + int s = 0; + + tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } +} +BOOST_HOF_TEST_CASE() +{ + const auto tp = boost::hof::pack(1, 2, 3); + + { + int s = 0; + + tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } + + { + int s = 0; + + tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } +} +// #endif +BOOST_HOF_TEST_CASE() +{ + std::pair<int, short> tp{ 1, 2 }; + + { + int s = 0; + + tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 12 ); + } + + { + int s = 0; + + tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 12 ); + } +} +BOOST_HOF_TEST_CASE() +{ + std::pair<int, short> const tp{ 1, 2 }; + + { + int s = 0; + + tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 12 ); + } + + { + int s = 0; + + tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 12 ); + } +} +BOOST_HOF_TEST_CASE() +{ + std::array<int, 3> tp{{ 1, 2, 3 }}; + + { + int s = 0; + + tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } + + { + int s = 0; + + tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } +} +BOOST_HOF_TEST_CASE() +{ + std::array<int, 3> const tp{{ 1, 2, 3 }}; + + { + int s = 0; + + tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } + + { + int s = 0; + + tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } ); + + BOOST_HOF_TEST_CHECK( s == 123 ); + } +} +BOOST_HOF_TEST_CASE() +{ + std::tuple<> tp; + + BOOST_HOF_TEST_CHECK( tuple_for_each( tp, 11 ) == 11 ); + BOOST_HOF_TEST_CHECK( tuple_for_each( std::move( tp ), 12 ) == 12 ); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK( tuple_for_each( boost::hof::pack(), 11 ) == 11 ); + BOOST_HOF_STATIC_TEST_CHECK( tuple_for_each( boost::hof::pack(), 11 ) == 11 ); +} +BOOST_HOF_TEST_CASE() +{ + std::array<int, 0> tp; + + BOOST_HOF_TEST_CHECK( tuple_for_each( tp, 11 ) == 11 ); + BOOST_HOF_TEST_CHECK( tuple_for_each( std::move( tp ), 12 ) == 12 ); +} + +struct assert_is_integral +{ + template<class T> constexpr bool operator()( T ) const + { + BOOST_HOF_STATIC_TEST_CHECK( std::is_integral<T>::value ); + return true; + } +}; + +BOOST_HOF_TEST_CASE() +{ +#if !BOOST_HOF_HAS_CONSTEXPR_TUPLE + auto r = tuple_for_each( std::tuple<int, short, char>{1, 2, 3}, assert_is_integral() ); +#else + constexpr auto r = tuple_for_each( std::tuple<int, short, char>{1, 2, 3}, assert_is_integral() ); +#endif + (void)r; +} + +BOOST_HOF_TEST_CASE() +{ +#if !BOOST_HOF_HAS_CONSTEXPR_TUPLE + auto r = tuple_for_each( boost::hof::pack(1, 2, 3), assert_is_integral() ); +#else + constexpr auto r = tuple_for_each( boost::hof::pack(1, 2, 3), assert_is_integral() ); +#endif + (void)r; +} diff --git a/src/boost/libs/hof/test/tuple_transform.cpp b/src/boost/libs/hof/test/tuple_transform.cpp new file mode 100644 index 000000000..d6aef66f4 --- /dev/null +++ b/src/boost/libs/hof/test/tuple_transform.cpp @@ -0,0 +1,90 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + tuple_transform.cpp + 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/hof/proj.hpp> +#include <boost/hof/construct.hpp> +#include <boost/hof/unpack.hpp> +#include <boost/hof/function.hpp> +#include <boost/hof/placeholders.hpp> +#include <boost/hof/compose.hpp> +// Disable static checks for gcc 4.7 +#ifndef BOOST_HOF_HAS_STATIC_TEST_CHECK +#if (defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ < 8) +#define BOOST_HOF_HAS_STATIC_TEST_CHECK 0 +#endif +#endif +#include "test.hpp" + +struct tuple_transform_f +{ + template<class Sequence, class F> + constexpr auto operator()(Sequence&& s, F f) const BOOST_HOF_RETURNS + ( + boost::hof::unpack(boost::hof::proj(f, boost::hof::construct<std::tuple>()))(boost::hof::forward<Sequence>(s)) + ); +}; + +struct pack_transform_f +{ + template<class Sequence, class F> + constexpr auto operator()(Sequence&& s, F f) const BOOST_HOF_RETURNS + ( + boost::hof::unpack(boost::hof::proj(f, boost::hof::pack()))(boost::hof::forward<Sequence>(s)) + ); +}; + +BOOST_HOF_STATIC_FUNCTION(tuple_transform) = tuple_transform_f{}; +// BOOST_HOF_STATIC_FUNCTION(pack_transform) = pack_transform_f{}; + +#if !BOOST_HOF_HAS_CONSTEXPR_TUPLE +#define TUPLE_TRANSFORM_STATIC_CHECK(...) +#else +#define TUPLE_TRANSFORM_STATIC_CHECK BOOST_HOF_STATIC_TEST_CHECK + +#endif + +BOOST_HOF_TEST_CASE() +{ + auto t = std::make_tuple(1, 2); + auto r = tuple_transform(t, [](int i) { return i*i; }); + BOOST_HOF_TEST_CHECK(r == std::make_tuple(1, 4)); +} + +BOOST_HOF_TEST_CASE() +{ + TUPLE_TRANSFORM_STATIC_CHECK(tuple_transform(std::make_tuple(1, 2), boost::hof::_1 * boost::hof::_1) == std::make_tuple(1, 4)); +} + +#define TUPLE_TRANSFORM_CHECK_ID(x) \ +BOOST_HOF_TEST_CHECK(tuple_transform(x, boost::hof::identity) == x); \ +TUPLE_TRANSFORM_STATIC_CHECK(tuple_transform(x, boost::hof::identity) == x); + +BOOST_HOF_TEST_CASE() +{ + TUPLE_TRANSFORM_CHECK_ID(std::make_tuple(1, 2)); + TUPLE_TRANSFORM_CHECK_ID(std::make_tuple(1)); + TUPLE_TRANSFORM_CHECK_ID(std::make_tuple()); +} + +BOOST_HOF_TEST_CASE() +{ + auto x = tuple_transform(std::make_tuple(std::unique_ptr<int>(new int(3))), boost::hof::identity); + auto y = std::make_tuple(std::unique_ptr<int>(new int(3))); + BOOST_HOF_TEST_CHECK(x != y); + BOOST_HOF_TEST_CHECK(tuple_transform(x, *boost::hof::_1) == tuple_transform(y, *boost::hof::_1)); +} + +#define TUPLE_TRANSFORM_CHECK_COMPOSE(x, f, g) \ +BOOST_HOF_TEST_CHECK(tuple_transform(x, boost::hof::compose(f, g)) == tuple_transform(tuple_transform(x, g), f)); \ +TUPLE_TRANSFORM_STATIC_CHECK(tuple_transform(x, boost::hof::compose(f, g)) == tuple_transform(tuple_transform(x, g), f)); + +BOOST_HOF_TEST_CASE() +{ + TUPLE_TRANSFORM_CHECK_COMPOSE(std::make_tuple(1, 2, 3, 4), boost::hof::_1 * boost::hof::_1, boost::hof::_1 + boost::hof::_1); + TUPLE_TRANSFORM_CHECK_COMPOSE(std::make_tuple(1, 2, 3), boost::hof::_1 * boost::hof::_1, boost::hof::_1 + boost::hof::_1); + TUPLE_TRANSFORM_CHECK_COMPOSE(std::make_tuple(1), boost::hof::_1 * boost::hof::_1, boost::hof::_1 + boost::hof::_1); + TUPLE_TRANSFORM_CHECK_COMPOSE(std::make_tuple(), boost::hof::_1 * boost::hof::_1, boost::hof::_1 + boost::hof::_1); +} diff --git a/src/boost/libs/hof/test/unpack.cpp b/src/boost/libs/hof/test/unpack.cpp new file mode 100644 index 000000000..8d1e948e0 --- /dev/null +++ b/src/boost/libs/hof/test/unpack.cpp @@ -0,0 +1,255 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + unpack.cpp + 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/hof/unpack.hpp> +#include <boost/hof/static.hpp> +#include <boost/hof/lambda.hpp> +#include "test.hpp" + +#include <memory> + +static constexpr boost::hof::static_<boost::hof::unpack_adaptor<unary_class> > unary_unpack = {}; +static constexpr boost::hof::static_<boost::hof::unpack_adaptor<binary_class> > binary_unpack = {}; + +BOOST_HOF_STATIC_AUTO unary_unpack_constexpr = boost::hof::unpack_adaptor<unary_class>(); +#if BOOST_HOF_HAS_CONSTEXPR_TUPLE +BOOST_HOF_STATIC_AUTO binary_unpack_constexpr = boost::hof::unpack_adaptor<binary_class>(); +#endif + +BOOST_HOF_STATIC_AUTO unary_unpack_reveal = boost::hof::reveal_adaptor<boost::hof::unpack_adaptor<unary_class>>(); +BOOST_HOF_STATIC_AUTO binary_unpack_reveal = boost::hof::reveal_adaptor<boost::hof::unpack_adaptor<binary_class>>(); + +#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION +BOOST_HOF_TEST_CASE() +{ + static_assert(noexcept(boost::hof::unpack(unary_class())(boost::hof::pack(3))), "noexcept unpack"); + static_assert(noexcept(unary_unpack(boost::hof::pack(3))), "noexcept unpack"); + static_assert(noexcept(binary_unpack(boost::hof::pack(3), boost::hof::pack(2))), "noexcept unpack"); +} +#endif + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(unary_class())(std::make_tuple(3))); + BOOST_HOF_TEST_CHECK(3 == unary_unpack(std::make_tuple(3))); + BOOST_HOF_TEST_CHECK(3 == unary_unpack_reveal(std::make_tuple(3))); + int ifu = 3; + BOOST_HOF_TEST_CHECK(3 == unary_unpack(std::tuple<int&>(ifu))); + +#if BOOST_HOF_HAS_CONSTEXPR_TUPLE + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::unpack(unary_class())(std::make_tuple(3))); + BOOST_HOF_STATIC_TEST_CHECK(3 == unary_unpack_constexpr(std::make_tuple(3))); + BOOST_HOF_STATIC_TEST_CHECK(3 == unary_unpack_reveal(std::make_tuple(3))); +#endif +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(unary_class())(boost::hof::pack(3))); + BOOST_HOF_TEST_CHECK(3 == unary_unpack(boost::hof::pack(3))); + BOOST_HOF_TEST_CHECK(3 == unary_unpack_reveal(boost::hof::pack(3))); + int ifu = 3; + BOOST_HOF_TEST_CHECK(3 == unary_unpack(boost::hof::pack_forward(ifu))); + + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::unpack(unary_class())(boost::hof::pack(3))); + BOOST_HOF_STATIC_TEST_CHECK(3 == unary_unpack_constexpr(boost::hof::pack(3))); + BOOST_HOF_STATIC_TEST_CHECK(3 == unary_unpack_reveal(boost::hof::pack(3))); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(1, 2))); + BOOST_HOF_TEST_CHECK(3 == binary_unpack(std::make_tuple(1, 2))); + BOOST_HOF_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(1, 2))); + + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(1), std::make_tuple(2))); + BOOST_HOF_TEST_CHECK(3 == binary_unpack(std::make_tuple(1), std::make_tuple(2))); + BOOST_HOF_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(1), std::make_tuple(2))); + + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + BOOST_HOF_TEST_CHECK(3 == binary_unpack(std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + BOOST_HOF_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(), std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + BOOST_HOF_TEST_CHECK(3 == binary_unpack(std::make_tuple(), std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + BOOST_HOF_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(), std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(1), std::make_tuple(), std::make_tuple(2), std::make_tuple())); + BOOST_HOF_TEST_CHECK(3 == binary_unpack(std::make_tuple(1), std::make_tuple(), std::make_tuple(2), std::make_tuple())); + BOOST_HOF_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(1), std::make_tuple(), std::make_tuple(2), std::make_tuple())); + +#if BOOST_HOF_HAS_CONSTEXPR_TUPLE + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(1, 2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_constexpr(std::make_tuple(1, 2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(1, 2))); + + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(1), std::make_tuple(2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_constexpr(std::make_tuple(1), std::make_tuple(2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(1), std::make_tuple(2))); + + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_constexpr(std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(), std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_constexpr(std::make_tuple(), std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(), std::make_tuple(1), std::make_tuple(), std::make_tuple(2))); + + BOOST_HOF_STATIC_TEST_CHECK(3 == boost::hof::unpack(binary_class())(std::make_tuple(1), std::make_tuple(), std::make_tuple(2), std::make_tuple())); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_constexpr(std::make_tuple(1), std::make_tuple(), std::make_tuple(2), std::make_tuple())); + BOOST_HOF_STATIC_TEST_CHECK(3 == binary_unpack_reveal(std::make_tuple(1), std::make_tuple(), std::make_tuple(2), std::make_tuple())); +#endif +} + +BOOST_HOF_TEST_CASE() +{ + auto p1 = boost::hof::pack_basic(1, 2); + static_assert(boost::hof::is_unpackable<decltype(p1)>::value, "Not unpackable"); + static_assert(boost::hof::is_unpackable<decltype((p1))>::value, "Not unpackable"); + + auto p2 = boost::hof::pack_forward(1, 2); + static_assert(boost::hof::is_unpackable<decltype(p2)>::value, "Not unpackable"); + static_assert(boost::hof::is_unpackable<decltype((p2))>::value, "Not unpackable"); + + auto p3 = boost::hof::pack(1, 2); + static_assert(boost::hof::is_unpackable<decltype(p3)>::value, "Not unpackable"); + static_assert(boost::hof::is_unpackable<decltype((p3))>::value, "Not unpackable"); + + static_assert(boost::hof::is_unpackable<std::tuple<int>>::value, "Not unpackable"); + + static_assert(!boost::hof::is_unpackable<int>::value, "Unpackable"); + static_assert(!boost::hof::is_unpackable<void>::value, "Unpackable"); +} + +BOOST_HOF_TEST_CASE() +{ + typedef std::tuple<int, int> tuple_type; + static_assert(boost::hof::is_unpackable<tuple_type>::value, "Not unpackable"); + static_assert(boost::hof::is_unpackable<tuple_type&>::value, "Not unpackable"); + static_assert(boost::hof::is_unpackable<const tuple_type&>::value, "Not unpackable"); + static_assert(boost::hof::is_unpackable<tuple_type&&>::value, "Not unpackable"); + +} + +BOOST_HOF_STATIC_AUTO lambda_unary_unpack = boost::hof::unpack(BOOST_HOF_STATIC_LAMBDA(int x) +{ + return x; +}); + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == lambda_unary_unpack(std::make_tuple(3))); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == lambda_unary_unpack(boost::hof::pack(3))); +} + +struct unary_move +{ + std::unique_ptr<int> i; + unary_move() + : i(new int(2)) + {} + + template<class T> + T operator()(T x) const + { + return x + *i; + } +}; + +static constexpr boost::hof::static_<boost::hof::unpack_adaptor<unary_move> > unary_move_unpack = {}; + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(unary_move())(std::make_tuple(1))); + BOOST_HOF_TEST_CHECK(3 == unary_move_unpack(std::make_tuple(1))); +} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(unary_move())(boost::hof::pack(1))); + BOOST_HOF_TEST_CHECK(3 == unary_move_unpack(boost::hof::pack(1))); +} + +struct indirect_sum_f +{ + template<class T, class U> + auto operator()(T x, U y) const + BOOST_HOF_RETURNS(*x + *y); +}; + +#define MAKE_UNIQUE_PTR(x) std::unique_ptr<int>(new int(x)) + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(indirect_sum_f())(boost::hof::pack_basic(MAKE_UNIQUE_PTR(1), MAKE_UNIQUE_PTR(2)))); + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(indirect_sum_f())(boost::hof::pack_forward(MAKE_UNIQUE_PTR(1), MAKE_UNIQUE_PTR(2)))); + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(indirect_sum_f())(boost::hof::pack(MAKE_UNIQUE_PTR(1), MAKE_UNIQUE_PTR(2)))); + BOOST_HOF_TEST_CHECK(3 == boost::hof::unpack(indirect_sum_f())(std::make_tuple(MAKE_UNIQUE_PTR(1), MAKE_UNIQUE_PTR(2)))); +} + +template<class...> +struct deduce_types +{}; + +struct deducer +{ + template<class... Ts> + deduce_types<Ts...> operator()(Ts&&...) const; +}; + +static constexpr boost::hof::unpack_adaptor<deducer> deduce = {}; + +BOOST_HOF_TEST_CASE() +{ + STATIC_ASSERT_SAME(deduce_types<int, int>, decltype(deduce(std::make_tuple(1, 2)))); + STATIC_ASSERT_SAME(deduce_types<int, int>, decltype(deduce(std::make_tuple(1), std::make_tuple(2)))); + STATIC_ASSERT_SAME(deduce_types<int, int, int>, decltype(deduce(std::make_tuple(1), std::make_tuple(2), std::make_tuple(3)))); + STATIC_ASSERT_SAME(std::tuple<int&&, int&&>, decltype(std::forward_as_tuple(1, 2))); + // Disable this test, it seems that rvalue references get swalllowed by type deduction + // STATIC_ASSERT_SAME(deduce_types<int&&, int&&>, decltype(deduce(std::forward_as_tuple(1, 2)))); + + + STATIC_ASSERT_SAME(deduce_types<int, int>, decltype(deduce(boost::hof::pack_basic(1, 2)))); + STATIC_ASSERT_SAME(deduce_types<int, int>, decltype(deduce(boost::hof::pack_basic(1), boost::hof::pack_basic(2)))); + STATIC_ASSERT_SAME(deduce_types<int, int, int>, decltype(deduce(boost::hof::pack_basic(1), boost::hof::pack_basic(2), boost::hof::pack_basic(3)))); + // STATIC_ASSERT_SAME(deduce_types<int&&, int&&>, decltype(deduce(boost::hof::pack_forward(1, 2)))); +} + +struct not_unpackable +{}; + +BOOST_HOF_TEST_CASE() +{ + auto f = boost::hof::unpack(boost::hof::always(1)); + + static_assert(!boost::hof::is_invocable<decltype(f), not_unpackable>::value, "SFINAE for unpack failed"); +} + +struct simple_unpackable +{}; + +namespace boost { namespace hof { + +template<> +struct unpack_sequence<simple_unpackable> +{ + template<class F, class S> + constexpr static auto apply(F&& f, S&&) BOOST_HOF_RETURNS + ( + f(1) + ); +}; +}} // namespace boost::hof + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::unpack(boost::hof::identity)(simple_unpackable{}) == 1); + BOOST_HOF_STATIC_TEST_CHECK(boost::hof::unpack(boost::hof::identity)(simple_unpackable{}) == 1); +} diff --git a/src/boost/libs/hof/test/virtual_base.cpp b/src/boost/libs/hof/test/virtual_base.cpp new file mode 100644 index 000000000..b686b9762 --- /dev/null +++ b/src/boost/libs/hof/test/virtual_base.cpp @@ -0,0 +1,37 @@ +/*============================================================================= + Copyright (c) 2017 Paul Fultz II + virtual_base.cpp + 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/hof/flip.hpp> +#include <boost/hof/proj.hpp> +#include <boost/hof/construct.hpp> +#include <boost/hof/pipable.hpp> +#include <boost/hof/rotate.hpp> +#include "test.hpp" + +struct base { + base(int) {} + base(const base&) {} + virtual ~base(); +}; + +base::~base() {} + +struct derived : virtual base { + derived() : base(1) {} + derived(const derived&) : base(1) {} + int operator()(int i, void *) const { + return i; + } + ~derived(); +}; +derived::~derived() {} + +BOOST_HOF_TEST_CASE() +{ + BOOST_HOF_TEST_CHECK(boost::hof::flip(derived())(nullptr, 2) == 2); + BOOST_HOF_TEST_CHECK(boost::hof::rotate(derived())(nullptr, 2) == 2); + BOOST_HOF_TEST_CHECK((2 | boost::hof::pipable(derived())(nullptr)) == 2); +} |