From ca55a318e9b16bed3f249c169964ad7be8e6fb2a Mon Sep 17 00:00:00 2001 From: badair Date: Tue, 12 Apr 2016 03:19:28 -0500 Subject: [PATCH] adding tests --- doc/html/callable_traits/ref.html | 18 ++-- doc/html/index.html | 2 +- test/add_function_cv.cpp | 105 +++++++++++++++++++ test/is_lvalue_qualified.cpp | 165 ++++++++++++++++++++++++++++++ test/is_rvalue_qualified.cpp | 165 ++++++++++++++++++++++++++++++ 5 files changed, 442 insertions(+), 13 deletions(-) create mode 100644 test/add_function_cv.cpp create mode 100644 test/is_lvalue_qualified.cpp create mode 100644 test/is_rvalue_qualified.cpp diff --git a/doc/html/callable_traits/ref.html b/doc/html/callable_traits/ref.html index 93a0381..25f87ea 100644 --- a/doc/html/callable_traits/ref.html +++ b/doc/html/callable_traits/ref.html @@ -52,7 +52,7 @@
is_lvalue_qualified
is_reference_qualified
is_rvalue_qualified
-
is_unqualified
+
is_qualified
is_volatile_qualified
max_arity
min_arity
@@ -84,14 +84,8 @@

#include<callable_traits/add_calling_convention.hpp> -

-

#include<callable_traits/add_function_const.hpp> -

-

#include<callable_traits/add_function_cv.hpp> -

-

#include<callable_traits/add_function_lvalue.hpp> #include<callable_traits/add_function_rvalue.hpp> #include<callable_traits/add_varargs.hpp> @@ -113,7 +107,7 @@ #include<callable_traits/is_lvalue_qualified.hpp> #include<callable_traits/is_reference_qualified.hpp> #include<callable_traits/is_rvalue_qualified.hpp> - #include<callable_traits/is_unqualified.hpp> + #include<callable_traits/is_qualified.hpp> #include<callable_traits/is_volatile_qualified.hpp> #include<callable_traits/max_arity.hpp> #include<callable_traits/min_arity.hpp> @@ -1458,17 +1452,17 @@ because ScaryMonster is the narrowest of all _1 parameters. */

-is_unqualified +is_qualified

TODO

- - Example + + Example

- [is_unqualified] + [is_qualified]

diff --git a/doc/html/index.html b/doc/html/index.html index eddc360..2e68ebb 100644 --- a/doc/html/index.html +++ b/doc/html/index.html @@ -76,7 +76,7 @@
is_lvalue_qualified
is_reference_qualified
is_rvalue_qualified
-
is_unqualified
+
is_qualified
is_volatile_qualified
max_arity
min_arity
diff --git a/test/add_function_cv.cpp b/test/add_function_cv.cpp new file mode 100644 index 0000000..03440fa --- /dev/null +++ b/test/add_function_cv.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/is_lvalue_qualified.cpp b/test/is_lvalue_qualified.cpp new file mode 100644 index 0000000..50ee1b2 --- /dev/null +++ b/test/is_lvalue_qualified.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; + +template +void assert_lvalue_qualified() { + + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_lvalue_qualified(std::declval()))::value); +} + + +template +void assert_not_lvalue_qualified() { + + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_lvalue_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_lvalue_qualified(); + assert_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_lvalue_qualified(); + assert_not_lvalue_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_lvalue_qualified(); + assert_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_not_lvalue_qualified(); + assert_lvalue_qualified(); + assert_not_lvalue_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_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + CT_ASSERT(ct::is_lvalue_qualified()); + CT_ASSERT(!ct::is_lvalue_qualified()); + } + + assert_not_lvalue_qualified(); + assert_not_lvalue_qualified(); +} diff --git a/test/is_rvalue_qualified.cpp b/test/is_rvalue_qualified.cpp new file mode 100644 index 0000000..66ebeaa --- /dev/null +++ b/test/is_rvalue_qualified.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; + +template +void assert_rvalue_qualified() { + + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(decltype(ct::is_rvalue_qualified(std::declval()))::value); +} + + +template +void assert_not_rvalue_qualified() { + + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_qualified(std::declval()))::value); + CT_ASSERT(!decltype(ct::is_rvalue_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_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_rvalue_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_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_not_rvalue_qualified(); + assert_rvalue_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_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(!ct::is_rvalue_qualified()); + CT_ASSERT(ct::is_rvalue_qualified()); + } + + assert_not_rvalue_qualified(); + assert_not_rvalue_qualified(); +}