From 112735e16cba2703184ca5de91211c6a451efa8f Mon Sep 17 00:00:00 2001 From: badair Date: Tue, 12 Apr 2016 03:08:26 -0500 Subject: [PATCH] adding tests --- .gitignore | 1 + doc/callable_traits.qbk | 8 +- include/callable_traits/callable_traits.hpp | 2 +- .../detail/fwd/function_fwd.hpp | 10 +- .../callable_traits/detail/fwd/pmf_fwd.hpp | 6 +- include/callable_traits/detail/pmf.hpp | 7 +- include/callable_traits/detail/pmf_cc.hpp | 11 +- include/callable_traits/detail/qualifiers.hpp | 2 +- include/callable_traits/detail/traits.hpp | 10 +- include/callable_traits/detail/utility.hpp | 33 ++ .../callable_traits/detail/varargs_pmf_cc.hpp | 10 +- .../{is_unqualified.hpp => is_qualified.hpp} | 14 +- qtcreator/main/main.cpp | 167 ++++++-- test/add_function_const.cpp | 105 +++++ test/add_function_lvalue.cpp | 108 +++++ test/add_function_rvalue.cpp | 165 ++++++++ test/add_function_volatile.cpp | 73 ++++ test/best_match_bind.cpp | 91 ----- test/{bind_expression.cpp => bind_1.cpp} | 0 ...{bind_expression_parser.cpp => bind_2.cpp} | 0 test/detail/best_match.cpp | 43 ++ test/is_const_qualified.cpp | 163 ++++++++ test/is_cv_qualified.cpp | 163 ++++++++ test/is_qualified.cpp | 163 ++++++++ test/is_volatile_qualified.cpp | 163 ++++++++ test/pmf_qualifiers.cpp | 369 +++++++++--------- test/remove_function_const.cpp | 105 +++++ test/remove_function_reference.cpp | 132 +++++++ test/remove_function_volatile.cpp | 73 ++++ 29 files changed, 1872 insertions(+), 325 deletions(-) rename include/callable_traits/{is_unqualified.hpp => is_qualified.hpp} (60%) create mode 100644 test/add_function_const.cpp create mode 100644 test/add_function_lvalue.cpp create mode 100644 test/add_function_rvalue.cpp create mode 100644 test/add_function_volatile.cpp delete mode 100644 test/best_match_bind.cpp rename test/{bind_expression.cpp => bind_1.cpp} (100%) rename test/{bind_expression_parser.cpp => bind_2.cpp} (100%) create mode 100644 test/detail/best_match.cpp create mode 100644 test/is_const_qualified.cpp create mode 100644 test/is_cv_qualified.cpp create mode 100644 test/is_qualified.cpp create mode 100644 test/is_volatile_qualified.cpp create mode 100644 test/remove_function_const.cpp create mode 100644 test/remove_function_reference.cpp create mode 100644 test/remove_function_volatile.cpp diff --git a/.gitignore b/.gitignore index fa91f20..8297bce 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,4 @@ build*/ *.user /test/Makefile /example/Makefile +scripts/ diff --git a/doc/callable_traits.qbk b/doc/callable_traits.qbk index 1492524..526c15a 100644 --- a/doc/callable_traits.qbk +++ b/doc/callable_traits.qbk @@ -281,7 +281,7 @@ The simplest way to use [libname] is to include the main header file: [include_header [link callable_traits.ref_is_lvalue_qualified is_lvalue_qualified]] [include_header [link callable_traits.ref_is_reference_qualified is_reference_qualified]] [include_header [link callable_traits.ref_is_rvalue_qualified is_rvalue_qualified]] -[include_header [link callable_traits.ref_is_unqualified is_unqualified]] +[include_header [link callable_traits.ref_is_qualified is_qualified]] [include_header [link callable_traits.ref_is_volatile_qualified is_volatile_qualified]] [include_header [link callable_traits.ref_max_arity max_arity]] [include_header [link callable_traits.ref_min_arity min_arity]] @@ -502,11 +502,11 @@ TODO [is_rvalue_qualified] [endsect] -[section:ref_is_unqualified is_unqualified] +[section:ref_is_qualified is_qualified] TODO [heading Example] -[/import ../example/is_unqualified.cpp] -[is_unqualified] +[/import ../example/is_qualified.cpp] +[is_qualified] [endsect] [section:ref_is_volatile_qualified is_volatile_qualified] diff --git a/include/callable_traits/callable_traits.hpp b/include/callable_traits/callable_traits.hpp index 1b7ee6c..3ebe89e 100644 --- a/include/callable_traits/callable_traits.hpp +++ b/include/callable_traits/callable_traits.hpp @@ -33,7 +33,7 @@ Distributed under the Boost Software License, Version 1.0. #include #include #include -#include +#include #include #include #include diff --git a/include/callable_traits/detail/fwd/function_fwd.hpp b/include/callable_traits/detail/fwd/function_fwd.hpp index e9a14e5..a258ce7 100644 --- a/include/callable_traits/detail/fwd/function_fwd.hpp +++ b/include/callable_traits/detail/fwd/function_fwd.hpp @@ -14,10 +14,18 @@ namespace callable_traits { namespace detail { + template + using decay_if_ptr_or_integral_constant = typename std::conditional< + std::is_pointer::type>::value + || is_integral_constant::value, + shallow_decay, + T + >::type; + template struct function; } } -#endif \ No newline at end of file +#endif diff --git a/include/callable_traits/detail/fwd/pmf_fwd.hpp b/include/callable_traits/detail/fwd/pmf_fwd.hpp index 2787f12..a4d5d97 100644 --- a/include/callable_traits/detail/fwd/pmf_fwd.hpp +++ b/include/callable_traits/detail/fwd/pmf_fwd.hpp @@ -10,14 +10,16 @@ Distributed under the Boost Software License, Version 1.0. #ifndef CALLABLE_TRAITS_DETAIL_FWD_PMF_FWD_HPP #define CALLABLE_TRAITS_DETAIL_FWD_PMF_FWD_HPP +#include + namespace callable_traits { namespace detail { - template + template> struct pmf; } } -#endif \ No newline at end of file +#endif diff --git a/include/callable_traits/detail/pmf.hpp b/include/callable_traits/detail/pmf.hpp index 6d82cce..b6cfb36 100644 --- a/include/callable_traits/detail/pmf.hpp +++ b/include/callable_traits/detail/pmf.hpp @@ -10,6 +10,7 @@ Distributed under the Boost Software License, Version 1.0. #ifndef CALLABLE_TRAITS_DETAIL_PMF_HPP #define CALLABLE_TRAITS_DETAIL_PMF_HPP +#include #include #include #include @@ -38,11 +39,11 @@ namespace callable_traits { using set_varargs_member_function_qualifiers = typename set_varargs_member_function_qualifiers_t::type; - template + template struct pmf : default_callable_traits {}; - template - struct pmf > { + template + struct pmf > { using traits = pmf; static constexpr const bool value = traits::value; }; diff --git a/include/callable_traits/detail/pmf_cc.hpp b/include/callable_traits/detail/pmf_cc.hpp index 08d51f1..8f82546 100644 --- a/include/callable_traits/detail/pmf_cc.hpp +++ b/include/callable_traits/detail/pmf_cc.hpp @@ -30,8 +30,8 @@ struct set_member_function_qualifiers_t< using type = Return(CALLABLE_TRAITS_CC T::*)(Args...) QUAL; \ }; \ \ -template \ -struct pmf \ +template \ +struct pmf \ : qualifier_traits, default_callable_traits { \ \ static constexpr bool value = true; \ @@ -63,8 +63,11 @@ struct pmf using qualifiers = qualifier_traits; \ \ template \ - using set_qualifiers = set_member_function_qualifiers< \ - Flags, CALLABLE_TRAITS_CC_TAG, T, Return, Args...>; \ + using set_qualifiers = typename copy_cvr< \ + set_member_function_qualifiers< \ + Flags, CALLABLE_TRAITS_CC_TAG, T, Return, Args...>, \ + OriginalType \ + >::type; \ \ using remove_function_reference = set_qualifiers; \ \ diff --git a/include/callable_traits/detail/qualifiers.hpp b/include/callable_traits/detail/qualifiers.hpp index 594ccbb..f7263a8 100644 --- a/include/callable_traits/detail/qualifiers.hpp +++ b/include/callable_traits/detail/qualifiers.hpp @@ -134,7 +134,7 @@ namespace callable_traits { static constexpr flags q_flags = cv_flags | ref_flags; public: - using is_unqualified = std::integral_constant; + using is_qualified = std::integral_constant; using is_reference_qualified = std::integral_constant; using is_lvalue_reference_qualified = std::integral_constant; using is_rvalue_reference_qualified = std::integral_constant; diff --git a/include/callable_traits/detail/traits.hpp b/include/callable_traits/detail/traits.hpp index 5cf5c05..57726fd 100644 --- a/include/callable_traits/detail/traits.hpp +++ b/include/callable_traits/detail/traits.hpp @@ -22,20 +22,12 @@ namespace callable_traits { namespace detail { - template - using decay_if_ptr_or_integral_constant = typename std::conditional< - std::is_pointer::type>::value - || is_integral_constant::value, - shallow_decay, - T - >::type; - template> using traits = typename disjunction< bind_expression_traits, function_object, function>, - pmf, + pmf, pmd, function_object >::traits; diff --git a/include/callable_traits/detail/utility.hpp b/include/callable_traits/detail/utility.hpp index 93cf1f0..938c6b0 100644 --- a/include/callable_traits/detail/utility.hpp +++ b/include/callable_traits/detail/utility.hpp @@ -285,6 +285,39 @@ struct invalid_type { invalid_type() = delete; }; T >::type; + template + struct copy_cvr { + + private: + + using no_ref_U = typename std::remove_reference::type; + using no_ref_T = typename std::remove_reference::type; + + using C = typename std::conditional< + std::is_const::value, + typename std::add_const::type, + no_ref_T + >::type; + + using V = typename std::conditional< + std::is_volatile::value, + typename std::add_volatile::type, + C + >::type; + + public: + + using type = typename std::conditional< + std::is_lvalue_reference::value, + V &, + typename std::conditional< + std::is_rvalue_reference::value, + V &&, + V + >::type + >::type; + }; + //used to prepend a type to a tuple template struct prepend; diff --git a/include/callable_traits/detail/varargs_pmf_cc.hpp b/include/callable_traits/detail/varargs_pmf_cc.hpp index 08dbd8b..cc707b6 100644 --- a/include/callable_traits/detail/varargs_pmf_cc.hpp +++ b/include/callable_traits/detail/varargs_pmf_cc.hpp @@ -33,8 +33,8 @@ struct set_varargs_member_function_qualifiers_t < Return(CALLABLE_TRAITS_VARARGS_CC T::*)(Args..., ...) QUAL; \ }; \ \ -template \ -struct pmf \ +template \ +struct pmf \ : qualifier_traits, default_callable_traits { \ \ static constexpr bool value = true; \ @@ -64,9 +64,11 @@ struct pmf using qualifiers = qualifier_traits; \ \ template \ - using set_qualifiers = \ + using set_qualifiers = typename copy_cvr< \ set_varargs_member_function_qualifiers< \ - Flags, CALLABLE_TRAITS_CC_TAG, T, Return, Args...>; \ + Flags, CALLABLE_TRAITS_CC_TAG, T, Return, Args...>, \ + OriginalType \ + >::type; \ \ using remove_function_reference = set_qualifiers; \ \ diff --git a/include/callable_traits/is_unqualified.hpp b/include/callable_traits/is_qualified.hpp similarity index 60% rename from include/callable_traits/is_unqualified.hpp rename to include/callable_traits/is_qualified.hpp index 5efade7..122d1e5 100644 --- a/include/callable_traits/is_unqualified.hpp +++ b/include/callable_traits/is_qualified.hpp @@ -7,8 +7,8 @@ Distributed under the Boost Software License, Version 1.0. */ -#ifndef CALLABLE_TRAITS_IS_UNQUALIFIED_HPP -#define CALLABLE_TRAITS_IS_UNQUALIFIED_HPP +#ifndef CALLABLE_TRAITS_IS_QUALIFIED_HPP +#define CALLABLE_TRAITS_IS_QUALIFIED_HPP #include #include @@ -17,15 +17,15 @@ namespace callable_traits { template inline constexpr auto - is_unqualified() { - return typename detail::traits::is_unqualified{}; + is_qualified() { + return typename detail::traits::is_qualified{}; } template inline constexpr auto - is_unqualified(T&&) { - return typename detail::traits::is_unqualified{}; + is_qualified(T&&) { + return typename detail::traits::is_qualified{}; } } -#endif +#endif //CALLABLE_TRAITS_IS_QUALIFIED_HPP diff --git a/qtcreator/main/main.cpp b/qtcreator/main/main.cpp index 938e259..ef5da86 100644 --- a/qtcreator/main/main.cpp +++ b/qtcreator/main/main.cpp @@ -1,44 +1,163 @@ /* - Copyright Barrett Adair 2016 Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) */ -#include #include #include -#include -#include -#include -#include -#include -#include +#include +#include #ifndef CT_ASSERT #define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) #endif //CT_ASSERT -namespace ct = callable_traits; -namespace ctd = callable_traits::detail; +struct foo {}; -struct Vampire {}; -struct Robot {}; -struct Animal {}; -struct Dog : Animal {}; -struct Poodle : Dog {}; -struct ScaryMonster : Poodle, Robot, Vampire {}; +namespace ct = callable_traits; + +template +void assert_const_qualified() { + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); +} + + +template +void assert_not_const_qualified() { + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); +} int main() { { - using test = ctd::best_match< - Vampire, Robot, Poodle, Animal, Dog, int, ScaryMonster>; + using f = void(foo::*)(); + using l = void(foo::*)() &; + using r = void(foo::*)() && ; + using c = void(foo::*)() const; + using cl = void(foo::*)() const &; + using cr = void(foo::*)() const &&; + using v = void(foo::*)() volatile; + using vl = void(foo::*)() volatile &; + using vr = void(foo::*)() volatile &&; + using cv = void(foo::*)() const volatile; + using cvl = void(foo::*)() const volatile &; + using cvr = void(foo::*)() const volatile &&; - using expect = ScaryMonster; - - //expected failure - CT_ASSERT(std::is_same::value); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); } + + { + struct f { int operator()() { return 0; } }; + struct l { int operator()() & { return 0; } }; + struct r { int operator()() && { return 0; } }; + struct c { int operator()() const { return 0; } }; + struct cl { int operator()() const & { return 0; } }; + struct cr { int operator()() const && { return 0; } }; + struct v { int operator()() volatile { return 0; } }; + struct vl { int operator()() volatile & { return 0; } }; + struct vr { int operator()() volatile && { return 0; } }; + struct cv { int operator()() const volatile { return 0; } }; + struct cvl { int operator()() const volatile & { return 0; } }; + struct cvr { int operator()() const volatile && { return 0; } }; + + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + } + + { + using f = void(); + using l = void() &; + using r = void() && ; + using c = void() const; + using cl = void() const &; + using cr = void() const &&; + using v = void() volatile; + using vl = void() volatile &; + using vr = void() volatile &&; + using cv = void() const volatile; + using cvl = void() const volatile &; + using cvr = void() const volatile &&; + + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + } + + assert_not_const_qualified(); + assert_not_const_qualified(); } diff --git a/test/add_function_const.cpp b/test/add_function_const.cpp new file mode 100644 index 0000000..6e8a0e0 --- /dev/null +++ b/test/add_function_const.cpp @@ -0,0 +1,105 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo {}; + +namespace ct = callable_traits; + +int main() { + + { + using f = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...); + using l = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) &; + using r = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) && ; + using c = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const; + using cl = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const &; + using cr = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const &&; + using v = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) volatile; + using vl = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) volatile &; + using vr = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) volatile &&; + using cv = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const volatile; + using cvl = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const volatile &; + using cvr = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(foo::* volatile)(int, int); + using l = void(foo::* volatile)(int, int) &; + using r = void(foo::* volatile)(int, int) && ; + using c = void(foo::* volatile)(int, int) const; + using cl = void(foo::* volatile)(int, int) const &; + using cr = void(foo::* volatile)(int, int) const &&; + using v = void(foo::* volatile)(int, int) volatile; + using vl = void(foo::* volatile)(int, int) volatile &; + using vr = void(foo::* volatile)(int, int) volatile &&; + using cv = void(foo::* volatile)(int, int) const volatile; + using cvl = void(foo::* volatile)(int, int) const volatile &; + using cvr = void(foo::* volatile)(int, int) const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(); + using l = void() &; + using r = void() && ; + using c = void() const; + using cl = void() const &; + using cr = void() const &&; + using v = void() volatile; + using vl = void() volatile &; + using vr = void() volatile &&; + using cv = void() const volatile; + using cvl = void() const volatile &; + using cvr = void() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } +} diff --git a/test/add_function_lvalue.cpp b/test/add_function_lvalue.cpp new file mode 100644 index 0000000..b614192 --- /dev/null +++ b/test/add_function_lvalue.cpp @@ -0,0 +1,108 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo{}; + +namespace ct = callable_traits; + +int main() { + + { + using f = void(foo::*)(); + using l = void(foo::*)() &; + using r = void(foo::*)() &&; + using c = void(foo::*)() const; + using cl = void(foo::*)() const &; + using cr = void(foo::*)() const &&; + using v = void(foo::*)() volatile; + using vl = void(foo::*)() volatile &; + using vr = void(foo::*)() volatile &&; + using cv = void(foo::*)() const volatile; + using cvl = void(foo::*)() const volatile &; + using cvr = void(foo::*)() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + } + + { + using f = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...); + using l = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) &; + using r = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) &&; + using c = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) const; + using cl = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) const &; + using cr = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) const &&; + using v = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) volatile; + using vl = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) volatile &; + using vr = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) volatile &&; + using cv = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) const volatile; + using cvl = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) const volatile &; + using cvr = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*const &&)(...) const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + } + + { + using f = void(...); + using l = void(...) &; + using r = void(...) &&; + using c = void(...) const; + using cl = void(...) const &; + using cr = void(...) const &&; + using v = void(...) volatile; + using vl = void(...) volatile &; + using vr = void(...) volatile &&; + using cv = void(...) const volatile; + using cvl = void(...) const volatile &; + using cvr = void(...) const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + } +} diff --git a/test/add_function_rvalue.cpp b/test/add_function_rvalue.cpp new file mode 100644 index 0000000..5f2f9ac --- /dev/null +++ b/test/add_function_rvalue.cpp @@ -0,0 +1,165 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo{}; + +namespace ct = callable_traits; + +int main() { + { + using f = void(foo::*)(); + using l = void(foo::*)() &; + using r = void(foo::*)() &&; + using c = void(foo::*)() const; + using cl = void(foo::*)() const &; + using cr = void(foo::*)() const &&; + using v = void(foo::*)() volatile; + using vl = void(foo::*)() volatile &; + using vr = void(foo::*)() volatile &&; + using cv = void(foo::*)() const volatile; + using cvl = void(foo::*)() const volatile &; + using cvr = void(foo::*)() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(foo::*&)(); + using l = void(foo::*&)() &; + using r = void(foo::*&)() &&; + using c = void(foo::*&)() const; + using cl = void(foo::*&)() const &; + using cr = void(foo::*&)() const &&; + using v = void(foo::*&)() volatile; + using vl = void(foo::*&)() volatile &; + using vr = void(foo::*&)() volatile &&; + using cv = void(foo::*&)() const volatile; + using cvl = void(foo::*&)() const volatile &; + using cvr = void(foo::*&)() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(foo::*&&)(...); + using l = void(foo::*&&)(...) &; + using r = void(foo::*&&)(...) &&; + using c = void(foo::*&&)(...) const; + using cl = void(foo::*&&)(...) const &; + using cr = void(foo::*&&)(...) const &&; + using v = void(foo::*&&)(...) volatile; + using vl = void(foo::*&&)(...) volatile &; + using vr = void(foo::*&&)(...) volatile &&; + using cv = void(foo::*&&)(...) const volatile; + using cvl = void(foo::*&&)(...) const volatile &; + using cvr = void(foo::*&&)(...) const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(foo::* const)(); + using l = void(foo::* const)() &; + using r = void(foo::* const)() &&; + using c = void(foo::* const)() const; + using cl = void(foo::* const)() const &; + using cr = void(foo::* const)() const &&; + using v = void(foo::* const)() volatile; + using vl = void(foo::* const)() volatile &; + using vr = void(foo::* const)() volatile &&; + using cv = void(foo::* const)() const volatile; + using cvl = void(foo::* const)() const volatile &; + using cvr = void(foo::* const)() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(); + using l = void() &; + using r = void() &&; + using c = void() const; + using cl = void() const &; + using cr = void() const &&; + using v = void() volatile; + using vl = void() volatile &; + using vr = void() volatile &&; + using cv = void() const volatile; + using cvl = void() const volatile &; + using cvr = void() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(!std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } +} diff --git a/test/add_function_volatile.cpp b/test/add_function_volatile.cpp new file mode 100644 index 0000000..3b7c7ca --- /dev/null +++ b/test/add_function_volatile.cpp @@ -0,0 +1,73 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo{}; + +namespace ct = callable_traits; + +int main() { + + { + using f = int(foo::*)(int); + using l = int(foo::*)(int) &; + using r = int(foo::*)(int) &&; + using c = int(foo::*)(int) const; + using cl = int(foo::*)(int) const &; + using cr = int(foo::*)(int) const &&; + using v = int(foo::*)(int) volatile; + using vl = int(foo::*)(int) volatile &; + using vr = int(foo::*)(int) volatile &&; + using cv = int(foo::*)(int) const volatile; + using cvl = int(foo::*)(int) const volatile &; + using cvr = int(foo::*)(int) const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = foo(); + using l = foo() &; + using r = foo() &&; + using c = foo() const; + using cl = foo() const &; + using cr = foo() const &&; + using v = foo() volatile; + using vl = foo() volatile &; + using vr = foo() volatile &&; + using cv = foo() const volatile; + using cvl = foo() const volatile &; + using cvr = foo() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } +} diff --git a/test/best_match_bind.cpp b/test/best_match_bind.cpp deleted file mode 100644 index 22c09db..0000000 --- a/test/best_match_bind.cpp +++ /dev/null @@ -1,91 +0,0 @@ -/* - -Copyright Barrett Adair 2016 -Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) - -*/ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifndef CT_ASSERT -#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) -#endif //CT_ASSERT - -using namespace std::placeholders; -namespace ct = callable_traits; - -struct Vampire {}; -struct Robot {}; -struct Animal {}; -struct Dog : Animal {}; -struct Poodle : Dog {}; -struct VampireRobotPoodle : Poodle, Robot, Vampire {}; - - -auto take_vampire(const Vampire&) { - return 0; -} - -auto take_robot(const Robot&) { - return 0; -} - -auto take_dog(const Dog&) { - return 0; -} - -auto take_vampire_robot_poodle(const VampireRobotPoodle&) { - return 0; -} - -int foo(int, int, int, int) { - return 0; -} - -int main() { - - { - auto b = ct::bind( - foo, - ct::bind(take_vampire, _1), - ct::bind(take_robot, _1), - ct::bind(take_dog, _1), - ct::bind(take_vampire_robot_poodle, _1) - ); - - using args = ct::args; - using expected_args = std::tuple; - CT_ASSERT(std::is_same::value); - - VampireRobotPoodle vampire_robot_poodle; - assert(b(vampire_robot_poodle) == 0); - } - - { - auto b = ct::bind( - foo, - ct::bind(take_vampire_robot_poodle, _1), - ct::bind(take_vampire, _1), - ct::bind(take_robot, _1), - ct::bind(take_dog, _1) - ); - - using args = ct::args; - using expected_args = std::tuple; - CT_ASSERT(std::is_same::value); - - VampireRobotPoodle vampire_robot_poodle; - assert(b(vampire_robot_poodle) == 0); - } - - return 0; -} diff --git a/test/bind_expression.cpp b/test/bind_1.cpp similarity index 100% rename from test/bind_expression.cpp rename to test/bind_1.cpp diff --git a/test/bind_expression_parser.cpp b/test/bind_2.cpp similarity index 100% rename from test/bind_expression_parser.cpp rename to test/bind_2.cpp diff --git a/test/detail/best_match.cpp b/test/detail/best_match.cpp new file mode 100644 index 0000000..3dd7294 --- /dev/null +++ b/test/detail/best_match.cpp @@ -0,0 +1,43 @@ +/* + +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +namespace ct = callable_traits; +namespace ctd = callable_traits::detail; + +struct Vampire {}; +struct Robot {}; +struct Animal {}; +struct Dog : Animal {}; +struct Poodle : Dog {}; +struct ScaryMonster : Poodle, Robot, Vampire {}; + +int main() { + + { + using test = ctd::best_match< + Vampire, Robot, Poodle, Animal, Dog, ScaryMonster>; + + using expect = ScaryMonster; + + CT_ASSERT(std::is_same::value); + } +} diff --git a/test/is_const_qualified.cpp b/test/is_const_qualified.cpp new file mode 100644 index 0000000..b9419f4 --- /dev/null +++ b/test/is_const_qualified.cpp @@ -0,0 +1,163 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo {}; + +namespace ct = callable_traits; + +template +void assert_const_qualified() { + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_const_qualified(std::declval()))::value); +} + + +template +void assert_not_const_qualified() { + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_const_qualified(std::declval()))::value); +} + +int main() { + + { + using f = void(foo::*)(); + using l = void(foo::*)() &; + using r = void(foo::*)() && ; + using c = void(foo::*)() const; + using cl = void(foo::*)() const &; + using cr = void(foo::*)() const &&; + using v = void(foo::*)() volatile; + using vl = void(foo::*)() volatile &; + using vr = void(foo::*)() volatile &&; + using cv = void(foo::*)() const volatile; + using cvl = void(foo::*)() const volatile &; + using cvr = void(foo::*)() const volatile &&; + + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + } + + { + struct f { int operator()() { return 0; } }; + struct l { int operator()() & { return 0; } }; + struct r { int operator()() && { return 0; } }; + struct c { int operator()() const { return 0; } }; + struct cl { int operator()() const & { return 0; } }; + struct cr { int operator()() const && { return 0; } }; + struct v { int operator()() volatile { return 0; } }; + struct vl { int operator()() volatile & { return 0; } }; + struct vr { int operator()() volatile && { return 0; } }; + struct cv { int operator()() const volatile { return 0; } }; + struct cvl { int operator()() const volatile & { return 0; } }; + struct cvr { int operator()() const volatile && { return 0; } }; + + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_not_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + assert_const_qualified(); + } + + { + using f = void(); + using l = void() &; + using r = void() && ; + using c = void() const; + using cl = void() const &; + using cr = void() const &&; + using v = void() volatile; + using vl = void() volatile &; + using vr = void() volatile &&; + using cv = void() const volatile; + using cvl = void() const volatile &; + using cvr = void() const volatile &&; + + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(!ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + CT_ASSERT(ct::is_const_qualified()); + } + + assert_not_const_qualified(); + assert_not_const_qualified(); +} diff --git a/test/is_cv_qualified.cpp b/test/is_cv_qualified.cpp new file mode 100644 index 0000000..24447b0 --- /dev/null +++ b/test/is_cv_qualified.cpp @@ -0,0 +1,163 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo {}; + +namespace ct = callable_traits; + +template +void assert_cv_qualified() { + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_cv_qualified(std::declval()))::value); +} + + +template +void assert_not_cv_qualified() { + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_cv_qualified(std::declval()))::value); +} + +int main() { + + { + using f = void(foo::*)(); + using l = void(foo::*)() &; + using r = void(foo::*)() && ; + using c = void(foo::*)() const; + using cl = void(foo::*)() const &; + using cr = void(foo::*)() const &&; + using v = void(foo::*)() volatile; + using vl = void(foo::*)() volatile &; + using vr = void(foo::*)() volatile &&; + using cv = void(foo::*)() const volatile; + using cvl = void(foo::*)() const volatile &; + using cvr = void(foo::*)() const volatile &&; + + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_cv_qualified(); + assert_cv_qualified(); + assert_cv_qualified(); + } + + { + struct f { int operator()() { return 0; } }; + struct l { int operator()() & { return 0; } }; + struct r { int operator()() && { return 0; } }; + struct c { int operator()() const { return 0; } }; + struct cl { int operator()() const & { return 0; } }; + struct cr { int operator()() const && { return 0; } }; + struct v { int operator()() volatile { return 0; } }; + struct vl { int operator()() volatile & { return 0; } }; + struct vr { int operator()() volatile && { return 0; } }; + struct cv { int operator()() const volatile { return 0; } }; + struct cvl { int operator()() const volatile & { return 0; } }; + struct cvr { int operator()() const volatile && { return 0; } }; + + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_not_cv_qualified(); + assert_cv_qualified(); + assert_cv_qualified(); + assert_cv_qualified(); + } + + { + using f = void(); + using l = void() &; + using r = void() && ; + using c = void() const; + using cl = void() const &; + using cr = void() const &&; + using v = void() volatile; + using vl = void() volatile &; + using vr = void() volatile &&; + using cv = void() const volatile; + using cvl = void() const volatile &; + using cvr = void() const volatile &&; + + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(!ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + CT_ASSERT(ct::is_cv_qualified()); + } + + assert_not_cv_qualified(); + assert_not_cv_qualified(); +} diff --git a/test/is_qualified.cpp b/test/is_qualified.cpp new file mode 100644 index 0000000..b2691b5 --- /dev/null +++ b/test/is_qualified.cpp @@ -0,0 +1,163 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo {}; + +namespace ct = callable_traits; + +template +void assert_qualified() { + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_qualified(std::declval()))::value); +} + + +template +void assert_unqualified() { + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(!ct::is_qualified()); + + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_qualified(std::declval()))::value); +} + +int main() { + + { + using f = void(foo::*)(); + using l = void(foo::*)() &; + using r = void(foo::*)() && ; + using c = void(foo::*)() const; + using cl = void(foo::*)() const &; + using cr = void(foo::*)() const &&; + using v = void(foo::*)() volatile; + using vl = void(foo::*)() volatile &; + using vr = void(foo::*)() volatile &&; + using cv = void(foo::*)() const volatile; + using cvl = void(foo::*)() const volatile &; + using cvr = void(foo::*)() const volatile &&; + + assert_unqualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + } + + { + struct f { int operator()() { return 0; } }; + struct l { int operator()() & { return 0; } }; + struct r { int operator()() && { return 0; } }; + struct c { int operator()() const { return 0; } }; + struct cl { int operator()() const & { return 0; } }; + struct cr { int operator()() const && { return 0; } }; + struct v { int operator()() volatile { return 0; } }; + struct vl { int operator()() volatile & { return 0; } }; + struct vr { int operator()() volatile && { return 0; } }; + struct cv { int operator()() const volatile { return 0; } }; + struct cvl { int operator()() const volatile & { return 0; } }; + struct cvr { int operator()() const volatile && { return 0; } }; + + assert_unqualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + assert_qualified(); + } + + { + using f = void(); + using l = void() &; + using r = void() && ; + using c = void() const; + using cl = void() const &; + using cr = void() const &&; + using v = void() volatile; + using vl = void() volatile &; + using vr = void() volatile &&; + using cv = void() const volatile; + using cvl = void() const volatile &; + using cvr = void() const volatile &&; + + CT_ASSERT(!ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + CT_ASSERT(ct::is_qualified()); + } + + assert_unqualified(); + assert_unqualified(); +} diff --git a/test/is_volatile_qualified.cpp b/test/is_volatile_qualified.cpp new file mode 100644 index 0000000..01ce7b9 --- /dev/null +++ b/test/is_volatile_qualified.cpp @@ -0,0 +1,163 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo {}; + +namespace ct = callable_traits; + +template +void assert_volatile_qualified() { + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_volatile_qualified(std::declval()))::value); +} + + +template +void assert_not_volatile_qualified() { + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_volatile_qualified(std::declval()))::value); +} + +int main() { + + { + using f = void(foo::*)(); + using l = void(foo::*)() &; + using r = void(foo::*)() && ; + using c = void(foo::*)() const; + using cl = void(foo::*)() const &; + using cr = void(foo::*)() const &&; + using v = void(foo::*)() volatile; + using vl = void(foo::*)() volatile &; + using vr = void(foo::*)() volatile &&; + using cv = void(foo::*)() const volatile; + using cvl = void(foo::*)() const volatile &; + using cvr = void(foo::*)() const volatile &&; + + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + } + + { + struct f { int operator()() { return 0; } }; + struct l { int operator()() & { return 0; } }; + struct r { int operator()() && { return 0; } }; + struct c { int operator()() const { return 0; } }; + struct cl { int operator()() const & { return 0; } }; + struct cr { int operator()() const && { return 0; } }; + struct v { int operator()() volatile { return 0; } }; + struct vl { int operator()() volatile & { return 0; } }; + struct vr { int operator()() volatile && { return 0; } }; + struct cv { int operator()() const volatile { return 0; } }; + struct cvl { int operator()() const volatile & { return 0; } }; + struct cvr { int operator()() const volatile && { return 0; } }; + + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + assert_volatile_qualified(); + } + + { + using f = void(); + using l = void() &; + using r = void() && ; + using c = void() const; + using cl = void() const &; + using cr = void() const &&; + using v = void() volatile; + using vl = void() volatile &; + using vr = void() volatile &&; + using cv = void() const volatile; + using cvl = void() const volatile &; + using cvr = void() const volatile &&; + + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(!ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + CT_ASSERT(ct::is_volatile_qualified()); + } + + assert_not_volatile_qualified(); + assert_not_volatile_qualified(); +} diff --git a/test/pmf_qualifiers.cpp b/test/pmf_qualifiers.cpp index 2f7853d..357400a 100644 --- a/test/pmf_qualifiers.cpp +++ b/test/pmf_qualifiers.cpp @@ -17,196 +17,217 @@ struct foo{}; namespace ct = callable_traits; -using pmf = void(foo::*)(); -using pmf_l = void(foo::*)() &; -using pmf_r = void(foo::*)() &&; -using pmf_c = void(foo::*)() const; -using pmf_cl = void(foo::*)() const &; -using pmf_cr = void(foo::*)() const &&; -using pmf_v = void(foo::*)() volatile; -using pmf_vl = void(foo::*)() volatile &; -using pmf_vr = void(foo::*)() volatile &&; -using pmf_cv = void(foo::*)() const volatile; -using pmf_cvl = void(foo::*)() const volatile &; -using pmf_cvr = void(foo::*)() const volatile &&; +using f = void(foo::*)(); +using l = void(foo::*)() &; +using r = void(foo::*)() &&; +using c = void(foo::*)() const; +using cl = void(foo::*)() const &; +using cr = void(foo::*)() const &&; +using v = void(foo::*)() volatile; +using vl = void(foo::*)() volatile &; +using vr = void(foo::*)() volatile &&; +using cv = void(foo::*)() const volatile; +using cvl = void(foo::*)() const volatile &; +using cvr = void(foo::*)() const volatile &&; -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); -CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); -CT_ASSERT(!ct::is_const_qualified()); -CT_ASSERT(!ct::is_const_qualified(pmf{})); -CT_ASSERT(!ct::is_const_qualified()); -CT_ASSERT(!ct::is_const_qualified(pmf_l{})); -CT_ASSERT(!ct::is_const_qualified()); -CT_ASSERT(!ct::is_const_qualified(pmf_r{})); -CT_ASSERT(ct::is_const_qualified()); -CT_ASSERT(ct::is_const_qualified(pmf_c{})); -CT_ASSERT(ct::is_const_qualified()); -CT_ASSERT(ct::is_const_qualified(pmf_cl{})); -CT_ASSERT(ct::is_const_qualified()); -CT_ASSERT(ct::is_const_qualified(pmf_cr{})); -CT_ASSERT(!ct::is_const_qualified()); -CT_ASSERT(!ct::is_const_qualified(pmf_v{})); -CT_ASSERT(!ct::is_const_qualified()); -CT_ASSERT(!ct::is_const_qualified(pmf_vl{})); -CT_ASSERT(!ct::is_const_qualified()); -CT_ASSERT(!ct::is_const_qualified(pmf_vr{})); -CT_ASSERT(ct::is_const_qualified()); -CT_ASSERT(ct::is_const_qualified(pmf_cv{})); -CT_ASSERT(ct::is_const_qualified()); -CT_ASSERT(ct::is_const_qualified(pmf_cvl{})); -CT_ASSERT(ct::is_const_qualified()); -CT_ASSERT(ct::is_const_qualified(pmf_cvr{})); +//reference collapsing from & +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(std::is_same>{}); + +//reference collapsing from && +CT_ASSERT(std::is_same>{}); +CT_ASSERT(!std::is_same>{}); +CT_ASSERT(!std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(!std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(!std::is_same>{}); +CT_ASSERT(std::is_same>{}); +CT_ASSERT(!std::is_same>{}); + +CT_ASSERT(!ct::is_const_qualified()); +CT_ASSERT(!ct::is_const_qualified(f{})); +CT_ASSERT(!ct::is_const_qualified()); +CT_ASSERT(!ct::is_const_qualified(l{})); +CT_ASSERT(!ct::is_const_qualified()); +CT_ASSERT(!ct::is_const_qualified(r{})); +CT_ASSERT(ct::is_const_qualified()); +CT_ASSERT(ct::is_const_qualified(c{})); +CT_ASSERT(ct::is_const_qualified()); +CT_ASSERT(ct::is_const_qualified(cl{})); +CT_ASSERT(ct::is_const_qualified()); +CT_ASSERT(ct::is_const_qualified(cr{})); +CT_ASSERT(!ct::is_const_qualified()); +CT_ASSERT(!ct::is_const_qualified(v{})); +CT_ASSERT(!ct::is_const_qualified()); +CT_ASSERT(!ct::is_const_qualified(vl{})); +CT_ASSERT(!ct::is_const_qualified()); +CT_ASSERT(!ct::is_const_qualified(vr{})); +CT_ASSERT(ct::is_const_qualified()); +CT_ASSERT(ct::is_const_qualified(cv{})); +CT_ASSERT(ct::is_const_qualified()); +CT_ASSERT(ct::is_const_qualified(cvl{})); +CT_ASSERT(ct::is_const_qualified()); +CT_ASSERT(ct::is_const_qualified(cvr{})); -CT_ASSERT(!ct::is_volatile_qualified()); -CT_ASSERT(!ct::is_volatile_qualified(pmf{})); -CT_ASSERT(!ct::is_volatile_qualified()); -CT_ASSERT(!ct::is_volatile_qualified(pmf_l{})); -CT_ASSERT(!ct::is_volatile_qualified()); -CT_ASSERT(!ct::is_volatile_qualified(pmf_r{})); -CT_ASSERT(!ct::is_volatile_qualified()); -CT_ASSERT(!ct::is_volatile_qualified(pmf_c{})); -CT_ASSERT(!ct::is_volatile_qualified()); -CT_ASSERT(!ct::is_volatile_qualified(pmf_cl{})); -CT_ASSERT(!ct::is_volatile_qualified()); -CT_ASSERT(!ct::is_volatile_qualified(pmf_cr{})); -CT_ASSERT(ct::is_volatile_qualified()); -CT_ASSERT(ct::is_volatile_qualified(pmf_v{})); -CT_ASSERT(ct::is_volatile_qualified()); -CT_ASSERT(ct::is_volatile_qualified(pmf_vl{})); -CT_ASSERT(ct::is_volatile_qualified()); -CT_ASSERT(ct::is_volatile_qualified(pmf_vr{})); -CT_ASSERT(ct::is_volatile_qualified()); -CT_ASSERT(ct::is_volatile_qualified(pmf_cv{})); -CT_ASSERT(ct::is_volatile_qualified()); -CT_ASSERT(ct::is_volatile_qualified(pmf_cvl{})); -CT_ASSERT(ct::is_volatile_qualified()); -CT_ASSERT(ct::is_volatile_qualified(pmf_cvr{})); +CT_ASSERT(!ct::is_volatile_qualified()); +CT_ASSERT(!ct::is_volatile_qualified(f{})); +CT_ASSERT(!ct::is_volatile_qualified()); +CT_ASSERT(!ct::is_volatile_qualified(l{})); +CT_ASSERT(!ct::is_volatile_qualified()); +CT_ASSERT(!ct::is_volatile_qualified(r{})); +CT_ASSERT(!ct::is_volatile_qualified()); +CT_ASSERT(!ct::is_volatile_qualified(c{})); +CT_ASSERT(!ct::is_volatile_qualified()); +CT_ASSERT(!ct::is_volatile_qualified(cl{})); +CT_ASSERT(!ct::is_volatile_qualified()); +CT_ASSERT(!ct::is_volatile_qualified(cr{})); +CT_ASSERT(ct::is_volatile_qualified()); +CT_ASSERT(ct::is_volatile_qualified(v{})); +CT_ASSERT(ct::is_volatile_qualified()); +CT_ASSERT(ct::is_volatile_qualified(vl{})); +CT_ASSERT(ct::is_volatile_qualified()); +CT_ASSERT(ct::is_volatile_qualified(vr{})); +CT_ASSERT(ct::is_volatile_qualified()); +CT_ASSERT(ct::is_volatile_qualified(cv{})); +CT_ASSERT(ct::is_volatile_qualified()); +CT_ASSERT(ct::is_volatile_qualified(cvl{})); +CT_ASSERT(ct::is_volatile_qualified()); +CT_ASSERT(ct::is_volatile_qualified(cvr{})); -CT_ASSERT(!ct::is_reference_qualified()); -CT_ASSERT(!ct::is_reference_qualified(pmf{})); -CT_ASSERT(ct::is_reference_qualified()); -CT_ASSERT(ct::is_reference_qualified(pmf_l{})); -CT_ASSERT(ct::is_reference_qualified()); -CT_ASSERT(ct::is_reference_qualified(pmf_r{})); -CT_ASSERT(!ct::is_reference_qualified()); -CT_ASSERT(!ct::is_reference_qualified(pmf_c{})); -CT_ASSERT(ct::is_reference_qualified()); -CT_ASSERT(ct::is_reference_qualified(pmf_cl{})); -CT_ASSERT(ct::is_reference_qualified()); -CT_ASSERT(ct::is_reference_qualified(pmf_cr{})); -CT_ASSERT(!ct::is_reference_qualified()); -CT_ASSERT(!ct::is_reference_qualified(pmf_v{})); -CT_ASSERT(ct::is_reference_qualified()); -CT_ASSERT(ct::is_reference_qualified(pmf_vl{})); -CT_ASSERT(ct::is_reference_qualified()); -CT_ASSERT(ct::is_reference_qualified(pmf_vr{})); -CT_ASSERT(!ct::is_reference_qualified()); -CT_ASSERT(!ct::is_reference_qualified(pmf_cv{})); -CT_ASSERT(ct::is_reference_qualified()); -CT_ASSERT(ct::is_reference_qualified(pmf_cvl{})); -CT_ASSERT(ct::is_reference_qualified()); -CT_ASSERT(ct::is_reference_qualified(pmf_cvr{})); +CT_ASSERT(!ct::is_reference_qualified()); +CT_ASSERT(!ct::is_reference_qualified(f{})); +CT_ASSERT(ct::is_reference_qualified()); +CT_ASSERT(ct::is_reference_qualified(l{})); +CT_ASSERT(ct::is_reference_qualified()); +CT_ASSERT(ct::is_reference_qualified(r{})); +CT_ASSERT(!ct::is_reference_qualified()); +CT_ASSERT(!ct::is_reference_qualified(c{})); +CT_ASSERT(ct::is_reference_qualified()); +CT_ASSERT(ct::is_reference_qualified(cl{})); +CT_ASSERT(ct::is_reference_qualified()); +CT_ASSERT(ct::is_reference_qualified(cr{})); +CT_ASSERT(!ct::is_reference_qualified()); +CT_ASSERT(!ct::is_reference_qualified(v{})); +CT_ASSERT(ct::is_reference_qualified()); +CT_ASSERT(ct::is_reference_qualified(vl{})); +CT_ASSERT(ct::is_reference_qualified()); +CT_ASSERT(ct::is_reference_qualified(vr{})); +CT_ASSERT(!ct::is_reference_qualified()); +CT_ASSERT(!ct::is_reference_qualified(cv{})); +CT_ASSERT(ct::is_reference_qualified()); +CT_ASSERT(ct::is_reference_qualified(cvl{})); +CT_ASSERT(ct::is_reference_qualified()); +CT_ASSERT(ct::is_reference_qualified(cvr{})); -CT_ASSERT(!ct::is_lvalue_qualified()); -CT_ASSERT(!ct::is_lvalue_qualified(pmf{})); -CT_ASSERT(ct::is_lvalue_qualified()); -CT_ASSERT(ct::is_lvalue_qualified(pmf_l{})); -CT_ASSERT(!ct::is_lvalue_qualified()); -CT_ASSERT(!ct::is_lvalue_qualified(pmf_r{})); -CT_ASSERT(!ct::is_lvalue_qualified()); -CT_ASSERT(!ct::is_lvalue_qualified(pmf_c{})); -CT_ASSERT(ct::is_lvalue_qualified()); -CT_ASSERT(ct::is_lvalue_qualified(pmf_cl{})); -CT_ASSERT(!ct::is_lvalue_qualified()); -CT_ASSERT(!ct::is_lvalue_qualified(pmf_cr{})); -CT_ASSERT(!ct::is_lvalue_qualified()); -CT_ASSERT(!ct::is_lvalue_qualified(pmf_v{})); -CT_ASSERT(ct::is_lvalue_qualified()); -CT_ASSERT(ct::is_lvalue_qualified(pmf_vl{})); -CT_ASSERT(!ct::is_lvalue_qualified()); -CT_ASSERT(!ct::is_lvalue_qualified(pmf_vr{})); -CT_ASSERT(!ct::is_lvalue_qualified()); -CT_ASSERT(!ct::is_lvalue_qualified(pmf_cv{})); -CT_ASSERT(ct::is_lvalue_qualified()); -CT_ASSERT(ct::is_lvalue_qualified(pmf_cvl{})); -CT_ASSERT(!ct::is_lvalue_qualified()); -CT_ASSERT(!ct::is_lvalue_qualified(pmf_cvr{})); +CT_ASSERT(!ct::is_lvalue_qualified()); +CT_ASSERT(!ct::is_lvalue_qualified(f{})); +CT_ASSERT(ct::is_lvalue_qualified()); +CT_ASSERT(ct::is_lvalue_qualified(l{})); +CT_ASSERT(!ct::is_lvalue_qualified()); +CT_ASSERT(!ct::is_lvalue_qualified(r{})); +CT_ASSERT(!ct::is_lvalue_qualified()); +CT_ASSERT(!ct::is_lvalue_qualified(c{})); +CT_ASSERT(ct::is_lvalue_qualified()); +CT_ASSERT(ct::is_lvalue_qualified(cl{})); +CT_ASSERT(!ct::is_lvalue_qualified()); +CT_ASSERT(!ct::is_lvalue_qualified(cr{})); +CT_ASSERT(!ct::is_lvalue_qualified()); +CT_ASSERT(!ct::is_lvalue_qualified(v{})); +CT_ASSERT(ct::is_lvalue_qualified()); +CT_ASSERT(ct::is_lvalue_qualified(vl{})); +CT_ASSERT(!ct::is_lvalue_qualified()); +CT_ASSERT(!ct::is_lvalue_qualified(vr{})); +CT_ASSERT(!ct::is_lvalue_qualified()); +CT_ASSERT(!ct::is_lvalue_qualified(cv{})); +CT_ASSERT(ct::is_lvalue_qualified()); +CT_ASSERT(ct::is_lvalue_qualified(cvl{})); +CT_ASSERT(!ct::is_lvalue_qualified()); +CT_ASSERT(!ct::is_lvalue_qualified(cvr{})); -CT_ASSERT(!ct::is_rvalue_qualified()); -CT_ASSERT(!ct::is_rvalue_qualified(pmf{})); -CT_ASSERT(!ct::is_rvalue_qualified()); -CT_ASSERT(!ct::is_rvalue_qualified(pmf_l{})); -CT_ASSERT(ct::is_rvalue_qualified()); -CT_ASSERT(ct::is_rvalue_qualified(pmf_r{})); -CT_ASSERT(!ct::is_rvalue_qualified()); -CT_ASSERT(!ct::is_rvalue_qualified(pmf_c{})); -CT_ASSERT(!ct::is_rvalue_qualified()); -CT_ASSERT(!ct::is_rvalue_qualified(pmf_cl{})); -CT_ASSERT(ct::is_rvalue_qualified()); -CT_ASSERT(ct::is_rvalue_qualified(pmf_cr{})); -CT_ASSERT(!ct::is_rvalue_qualified()); -CT_ASSERT(!ct::is_rvalue_qualified(pmf_v{})); -CT_ASSERT(!ct::is_rvalue_qualified()); -CT_ASSERT(!ct::is_rvalue_qualified(pmf_vl{})); -CT_ASSERT(ct::is_rvalue_qualified()); -CT_ASSERT(ct::is_rvalue_qualified(pmf_vr{})); -CT_ASSERT(!ct::is_rvalue_qualified()); -CT_ASSERT(!ct::is_rvalue_qualified(pmf_cv{})); -CT_ASSERT(!ct::is_rvalue_qualified()); -CT_ASSERT(!ct::is_rvalue_qualified(pmf_cvl{})); -CT_ASSERT(ct::is_rvalue_qualified()); -CT_ASSERT(ct::is_rvalue_qualified(pmf_cvr{})); +CT_ASSERT(!ct::is_rvalue_qualified()); +CT_ASSERT(!ct::is_rvalue_qualified(f{})); +CT_ASSERT(!ct::is_rvalue_qualified()); +CT_ASSERT(!ct::is_rvalue_qualified(l{})); +CT_ASSERT(ct::is_rvalue_qualified()); +CT_ASSERT(ct::is_rvalue_qualified(r{})); +CT_ASSERT(!ct::is_rvalue_qualified()); +CT_ASSERT(!ct::is_rvalue_qualified(c{})); +CT_ASSERT(!ct::is_rvalue_qualified()); +CT_ASSERT(!ct::is_rvalue_qualified(cl{})); +CT_ASSERT(ct::is_rvalue_qualified()); +CT_ASSERT(ct::is_rvalue_qualified(cr{})); +CT_ASSERT(!ct::is_rvalue_qualified()); +CT_ASSERT(!ct::is_rvalue_qualified(v{})); +CT_ASSERT(!ct::is_rvalue_qualified()); +CT_ASSERT(!ct::is_rvalue_qualified(vl{})); +CT_ASSERT(ct::is_rvalue_qualified()); +CT_ASSERT(ct::is_rvalue_qualified(vr{})); +CT_ASSERT(!ct::is_rvalue_qualified()); +CT_ASSERT(!ct::is_rvalue_qualified(cv{})); +CT_ASSERT(!ct::is_rvalue_qualified()); +CT_ASSERT(!ct::is_rvalue_qualified(cvl{})); +CT_ASSERT(ct::is_rvalue_qualified()); +CT_ASSERT(ct::is_rvalue_qualified(cvr{})); int main() { return 0; } diff --git a/test/remove_function_const.cpp b/test/remove_function_const.cpp new file mode 100644 index 0000000..b5feb8a --- /dev/null +++ b/test/remove_function_const.cpp @@ -0,0 +1,105 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo {}; + +namespace ct = callable_traits; + +int main() { + + { + using f = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...); + using l = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) &; + using r = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) && ; + using c = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const; + using cl = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const &; + using cr = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const &&; + using v = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) volatile; + using vl = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) volatile &; + using vr = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) volatile &&; + using cv = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const volatile; + using cvl = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const volatile &; + using cvr = void(CALLABLE_TRAITS_DEFAULT_VARARGS_CC foo::*)(...) const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = foo const & (foo::* const volatile &)(int, int); + using l = foo const & (foo::* const volatile &)(int, int) &; + using r = foo const & (foo::* const volatile &)(int, int) && ; + using c = foo const & (foo::* const volatile &)(int, int) const; + using cl = foo const & (foo::* const volatile &)(int, int) const &; + using cr = foo const & (foo::* const volatile &)(int, int) const &&; + using v = foo const & (foo::* const volatile &)(int, int) volatile; + using vl = foo const & (foo::* const volatile &)(int, int) volatile &; + using vr = foo const & (foo::* const volatile &)(int, int) volatile &&; + using cv = foo const & (foo::* const volatile &)(int, int) const volatile; + using cvl = foo const & (foo::* const volatile &)(int, int) const volatile &; + using cvr = foo const & (foo::* const volatile &)(int, int) const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(); + using l = void() &; + using r = void() && ; + using c = void() const; + using cl = void() const &; + using cr = void() const &&; + using v = void() volatile; + using vl = void() volatile &; + using vr = void() volatile &&; + using cv = void() const volatile; + using cvl = void() const volatile &; + using cvr = void() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } +} diff --git a/test/remove_function_reference.cpp b/test/remove_function_reference.cpp new file mode 100644 index 0000000..b84e390 --- /dev/null +++ b/test/remove_function_reference.cpp @@ -0,0 +1,132 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo{}; + +namespace ct = callable_traits; + +int main() { + { + using f = void(foo::*)(); + using l = void(foo::*)() &; + using r = void(foo::*)() &&; + using c = void(foo::*)() const; + using cl = void(foo::*)() const &; + using cr = void(foo::*)() const &&; + using v = void(foo::*)() volatile; + using vl = void(foo::*)() volatile &; + using vr = void(foo::*)() volatile &&; + using cv = void(foo::*)() const volatile; + using cvl = void(foo::*)() const volatile &; + using cvr = void(foo::*)() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(foo::*&)(); + using l = void(foo::*&)() &; + using r = void(foo::*&)() &&; + using c = void(foo::*&)() const; + using cl = void(foo::*&)() const &; + using cr = void(foo::*&)() const &&; + using v = void(foo::*&)() volatile; + using vl = void(foo::*&)() volatile &; + using vr = void(foo::*&)() volatile &&; + using cv = void(foo::*&)() const volatile; + using cvl = void(foo::*&)() const volatile &; + using cvr = void(foo::*&)() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(foo::* const)(); + using l = void(foo::* const)() &; + using r = void(foo::* const)() &&; + using c = void(foo::* const)() const; + using cl = void(foo::* const)() const &; + using cr = void(foo::* const)() const &&; + using v = void(foo::* const)() volatile; + using vl = void(foo::* const)() volatile &; + using vr = void(foo::* const)() volatile &&; + using cv = void(foo::* const)() const volatile; + using cvl = void(foo::* const)() const volatile &; + using cvr = void(foo::* const)() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = void(); + using l = void() &; + using r = void() &&; + using c = void() const; + using cl = void() const &; + using cr = void() const &&; + using v = void() volatile; + using vl = void() volatile &; + using vr = void() volatile &&; + using cv = void() const volatile; + using cvl = void() const volatile &; + using cvr = void() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } +} diff --git a/test/remove_function_volatile.cpp b/test/remove_function_volatile.cpp new file mode 100644 index 0000000..58201d4 --- /dev/null +++ b/test/remove_function_volatile.cpp @@ -0,0 +1,73 @@ +/* +Copyright Barrett Adair 2016 +Distributed under the Boost Software License, Version 1.0. +(See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt) +*/ + +#include +#include +#include +#include + +#ifndef CT_ASSERT +#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) +#endif //CT_ASSERT + +struct foo{}; + +namespace ct = callable_traits; + +int main() { + + { + using f = char(foo::*)(foo*, int); + using l = char(foo::*)(foo*, int) &; + using r = char(foo::*)(foo*, int) &&; + using c = char(foo::*)(foo*, int) const; + using cl = char(foo::*)(foo*, int) const &; + using cr = char(foo::*)(foo*, int) const &&; + using v = char(foo::*)(foo*, int) volatile; + using vl = char(foo::*)(foo*, int) volatile &; + using vr = char(foo::*)(foo*, int) volatile &&; + using cv = char(foo::*)(foo*, int) const volatile; + using cvl = char(foo::*)(foo*, int) const volatile &; + using cvr = char(foo::*)(foo*, int) const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } + + { + using f = foo&&(); + using l = foo&&() &; + using r = foo&&() &&; + using c = foo&&() const; + using cl = foo&&() const &; + using cr = foo&&() const &&; + using v = foo&&() volatile; + using vl = foo&&() volatile &; + using vr = foo&&() volatile &&; + using cv = foo&&() const volatile; + using cvl = foo&&() const volatile &; + using cvr = foo&&() const volatile &&; + + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + CT_ASSERT(std::is_same>{}); + } +}