diff options
author | Paolo Carlini <paolo.carlini@oracle.com> | 2008-10-05 11:01:05 +0000 |
---|---|---|
committer | Paolo Carlini <paolo@gcc.gnu.org> | 2008-10-05 11:01:05 +0000 |
commit | 7a90b0ca0cbfa54ad48717911badcb1632f4b3fa (patch) | |
tree | 3142c4fab98b28909b8e15a6926252939d653897 /libstdc++-v3 | |
parent | b82657f4a84dd4abb65bbf4179a109f1d8a36e92 (diff) | |
download | gcc-7a90b0ca0cbfa54ad48717911badcb1632f4b3fa.zip gcc-7a90b0ca0cbfa54ad48717911badcb1632f4b3fa.tar.gz gcc-7a90b0ca0cbfa54ad48717911badcb1632f4b3fa.tar.bz2 |
invoke.cc: New.
2008-10-05 Paolo Carlini <paolo.carlini@oracle.com>
* testsuite/20_util/reference_wrapper/invoke.cc: New.
* testsuite/20_util/reference_wrapper/24803.cc: Likewise.
* testsuite/20_util/reference_wrapper/typedefs.cc: Likewise.
From-SVN: r140882
Diffstat (limited to 'libstdc++-v3')
-rw-r--r-- | libstdc++-v3/ChangeLog | 6 | ||||
-rw-r--r-- | libstdc++-v3/testsuite/20_util/reference_wrapper/24803.cc | 89 | ||||
-rw-r--r-- | libstdc++-v3/testsuite/20_util/reference_wrapper/invoke.cc | 115 | ||||
-rw-r--r-- | libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs.cc | 88 |
4 files changed, 298 insertions, 0 deletions
diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index b6d6122..153e694 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,9 @@ +2008-10-05 Paolo Carlini <paolo.carlini@oracle.com> + + * testsuite/20_util/reference_wrapper/invoke.cc: New. + * testsuite/20_util/reference_wrapper/24803.cc: Likewise. + * testsuite/20_util/reference_wrapper/typedefs.cc: Likewise. + 2008-10-01 Andrew Pinski <andrew_pinski@playstation.sony.com> * config/locale/generic/c_locale.cc (__convert_to_v): Fix diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/24803.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/24803.cc new file mode 100644 index 0000000..eb3d997 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/24803.cc @@ -0,0 +1,89 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <functional> + +struct test_type +{ + int member(); + int cmember()const; + int member2(char); + int cmember2(char)const; +}; + +struct functor1 : public std::unary_function<int, double> +{ + double operator()(int) const; +}; + +struct functor2 : public std::binary_function<int, char, double> +{ + double operator()(int, char) const; +}; + +template <class T> +void verify_return_type(T, T) +{ +} + +void test01() +{ + test_type* null_tt = 0; + const test_type* null_ttc = 0; + int zero; + + std::reference_wrapper<double (int)>* pr1; + verify_return_type((*pr1)(0), double()); + std::reference_wrapper<double (*)(int)>* pr2; + verify_return_type((*pr2)(0), double()); + std::reference_wrapper<int (test_type::*)()>* pr3; + verify_return_type((*pr3)(null_tt), int()); + std::reference_wrapper<int (test_type::*)()const>* pr4; + verify_return_type((*pr4)(null_ttc), int()); + std::reference_wrapper<functor1>* pr5; + + // libstdc++/24803 + // FIXME: verify_return_type((*pr5)(0), double()); + verify_return_type((*pr5)(zero), double()); + + std::reference_wrapper<double (int, char)>* pr1b; + verify_return_type((*pr1b)(0,0), double()); + std::reference_wrapper<double (*)(int, char)>* pr2b; + verify_return_type((*pr2b)(0,0), double()); + std::reference_wrapper<int (test_type::*)(char)>* pr3b; + verify_return_type((*pr3b)(null_tt,zero), int()); + std::reference_wrapper<int (test_type::*)()const>* pr4b; + verify_return_type((*pr4b)(null_ttc), int()); + std::reference_wrapper<functor2>* pr5b; + + // libstdc++/24803 + // FIXME: verify_return_type((*pr5b)(0,0), double()); + verify_return_type((*pr5b)(zero,zero), double()); +} diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke.cc new file mode 100644 index 0000000..77047db --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke.cc @@ -0,0 +1,115 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +#include <functional> +#include <type_traits> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +struct X +{ + typedef int result_type; + + X() : bar(17) {} + + int foo(float x) { return truncate_float(x); } + int foo_c(float x) const { return truncate_float(x); } + int foo_v(float x) volatile { return truncate_float(x); } + int foo_cv(float x) const volatile { return truncate_float(x); } + + int operator()(float x) + { + return foo(x) + 1; + } + + int operator()(float x) const + { + return foo_c(x) + 2; + } + + int bar; + + private: + X(const X&); + X& operator=(const X&); +}; + +int seventeen() { return 17; } + +struct get_seventeen +{ + typedef int result_type; + int operator()() const { return 17; } +}; + +void test01() +{ + using std::ref; + using std::cref; + + ::get_seventeen get_sev; + ::X x; + ::X* xp = &x; + int (::X::* p_foo)(float) = &::X::foo; + int (::X::* p_foo_c)(float) const = &::X::foo_c; + int (::X::* p_foo_v)(float) volatile = &::X::foo_v; + int (::X::* p_foo_cv)(float) const volatile = &::X::foo_cv; + int ::X::* p_bar = &::X::bar; + + const float pi = 3.14; + + // Functions + VERIFY(ref(truncate_float)(pi) == 3); + VERIFY(ref(seventeen)() == 17); + + // Function pointers + VERIFY(cref(&truncate_float)(pi) == 3); + VERIFY(cref(&seventeen)() == 17); + + // Member function pointers + VERIFY(ref(p_foo)(x, pi) == 3); + VERIFY(ref(p_foo)(xp, pi) == 3); + VERIFY(ref(p_foo_c)(x, pi) == 3); + VERIFY(ref(p_foo_c)(xp, pi) == 3); + VERIFY(ref(p_foo_v)(x, pi) == 3); + VERIFY(ref(p_foo_v)(xp, pi) == 3); + VERIFY(ref(p_foo_cv)(x, pi) == 3); + VERIFY(ref(p_foo_cv)(xp, pi) == 3); + + // Member data pointers + VERIFY(ref(p_bar)(x) == 17); + VERIFY(ref(p_bar)(xp) == 17); + + // Function objects + VERIFY(ref(get_sev)() == 17); + VERIFY(cref(get_sev)() == 17); + VERIFY(ref(x)(pi) == 4); + VERIFY(cref(x)(pi) == 5); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs.cc new file mode 100644 index 0000000..36b57a8 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs.cc @@ -0,0 +1,88 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +#include <functional> +#include <type_traits> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +struct X {}; + +struct int_result_type { typedef int result_type; }; + +struct derives_unary : std::unary_function<int, int> {}; + +struct derives_binary : std::binary_function<int, float, int> {}; + +struct derives_unary_binary + : std::unary_function<int, int>, + std::binary_function<int, float, int> +{ + typedef int result_type; +}; + +void test01() +{ + bool test __attribute__((unused)) = true; + + using std::reference_wrapper; + using std::is_same; + using std::is_convertible; + using std::unary_function; + using std::binary_function; + + // Check result_type typedef + VERIFY((is_same<reference_wrapper<int_result_type>::result_type, int>::value)); + VERIFY((is_same<reference_wrapper<derives_unary>::result_type, int>::value)); + VERIFY((is_same<reference_wrapper<derives_binary>::result_type, int>::value)); + VERIFY((is_same<reference_wrapper<derives_unary_binary>::result_type, int>::value)); + VERIFY((is_same<reference_wrapper<int(void)>::result_type, int>::value)); + VERIFY((is_same<reference_wrapper<int(*)(void)>::result_type, int>::value)); + VERIFY((is_same<reference_wrapper<int (::X::*)()>::result_type, int>::value)); + VERIFY((is_same<reference_wrapper<int (::X::*)(float)>::result_type, int>::value)); + + // Check derivation from unary_function + VERIFY((is_convertible<reference_wrapper<derives_unary>*, unary_function<int, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<derives_unary_binary>*, unary_function<int, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int(int)>*, unary_function<int, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int(*)(int)>*, unary_function<int, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int (::X::*)()>*, unary_function< ::X*, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int (::X::*)() const>*, unary_function<const ::X*, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int (::X::*)() volatile>*, unary_function<volatile ::X*, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int (::X::*)() const volatile>*, unary_function<const volatile ::X*, int>*>::value)); + + // Check derivation from binary_function + VERIFY((is_convertible<reference_wrapper<derives_binary>*, binary_function<int, float, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<derives_unary_binary>*, binary_function<int, float, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int(int, float)>*, binary_function<int, float, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int(*)(int, float)>*, binary_function<int, float, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int (::X::*)(float)>*, binary_function< ::X*, float, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int (::X::*)(float) const>*, binary_function<const ::X*, float, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int (::X::*)(float) volatile>*, binary_function<volatile ::X*, float, int>*>::value)); + VERIFY((is_convertible<reference_wrapper<int (::X::*)(float) const volatile>*, binary_function<const volatile ::X*, float, int>*>::value)); +} + +int main() +{ + test01(); + return 0; +} |