From 7a90b0ca0cbfa54ad48717911badcb1632f4b3fa Mon Sep 17 00:00:00 2001 From: Paolo Carlini Date: Sun, 5 Oct 2008 11:01:05 +0000 Subject: [PATCH] invoke.cc: New. 2008-10-05 Paolo Carlini * 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 --- libstdc++-v3/ChangeLog | 6 + .../20_util/reference_wrapper/24803.cc | 89 ++++++++++++++ .../20_util/reference_wrapper/invoke.cc | 115 ++++++++++++++++++ .../20_util/reference_wrapper/typedefs.cc | 88 ++++++++++++++ 4 files changed, 298 insertions(+) create mode 100644 libstdc++-v3/testsuite/20_util/reference_wrapper/24803.cc create mode 100644 libstdc++-v3/testsuite/20_util/reference_wrapper/invoke.cc create mode 100644 libstdc++-v3/testsuite/20_util/reference_wrapper/typedefs.cc diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index b6d61220630..153e6947eb7 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,9 @@ +2008-10-05 Paolo Carlini + + * 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 * 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 00000000000..eb3d9975a9c --- /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 + +struct test_type +{ + int member(); + int cmember()const; + int member2(char); + int cmember2(char)const; +}; + +struct functor1 : public std::unary_function +{ + double operator()(int) const; +}; + +struct functor2 : public std::binary_function +{ + double operator()(int, char) const; +}; + +template +void verify_return_type(T, T) +{ +} + +void test01() +{ + test_type* null_tt = 0; + const test_type* null_ttc = 0; + int zero; + + std::reference_wrapper* pr1; + verify_return_type((*pr1)(0), double()); + std::reference_wrapper* pr2; + verify_return_type((*pr2)(0), double()); + std::reference_wrapper* pr3; + verify_return_type((*pr3)(null_tt), int()); + std::reference_wrapper* pr4; + verify_return_type((*pr4)(null_ttc), int()); + std::reference_wrapper* pr5; + + // libstdc++/24803 + // FIXME: verify_return_type((*pr5)(0), double()); + verify_return_type((*pr5)(zero), double()); + + std::reference_wrapper* pr1b; + verify_return_type((*pr1b)(0,0), double()); + std::reference_wrapper* pr2b; + verify_return_type((*pr2b)(0,0), double()); + std::reference_wrapper* pr3b; + verify_return_type((*pr3b)(null_tt,zero), int()); + std::reference_wrapper* pr4b; + verify_return_type((*pr4b)(null_ttc), int()); + std::reference_wrapper* 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 00000000000..77047db06c4 --- /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 +#include +#include +#include + +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 00000000000..36b57a89a03 --- /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 +#include +#include +#include + +using namespace __gnu_test; + +struct X {}; + +struct int_result_type { typedef int result_type; }; + +struct derives_unary : std::unary_function {}; + +struct derives_binary : std::binary_function {}; + +struct derives_unary_binary + : std::unary_function, + std::binary_function +{ + 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::result_type, int>::value)); + VERIFY((is_same::result_type, int>::value)); + VERIFY((is_same::result_type, int>::value)); + VERIFY((is_same::result_type, int>::value)); + VERIFY((is_same::result_type, int>::value)); + VERIFY((is_same::result_type, int>::value)); + VERIFY((is_same::result_type, int>::value)); + VERIFY((is_same::result_type, int>::value)); + + // Check derivation from unary_function + VERIFY((is_convertible*, unary_function*>::value)); + VERIFY((is_convertible*, unary_function*>::value)); + VERIFY((is_convertible*, unary_function*>::value)); + VERIFY((is_convertible*, unary_function*>::value)); + VERIFY((is_convertible*, unary_function< ::X*, int>*>::value)); + VERIFY((is_convertible*, unary_function*>::value)); + VERIFY((is_convertible*, unary_function*>::value)); + VERIFY((is_convertible*, unary_function*>::value)); + + // Check derivation from binary_function + VERIFY((is_convertible*, binary_function*>::value)); + VERIFY((is_convertible*, binary_function*>::value)); + VERIFY((is_convertible*, binary_function*>::value)); + VERIFY((is_convertible*, binary_function*>::value)); + VERIFY((is_convertible*, binary_function< ::X*, float, int>*>::value)); + VERIFY((is_convertible*, binary_function*>::value)); + VERIFY((is_convertible*, binary_function*>::value)); + VERIFY((is_convertible*, binary_function*>::value)); +} + +int main() +{ + test01(); + return 0; +}