diff options
Diffstat (limited to 'libstdc++-v3/testsuite/tr1/3_function_objects')
20 files changed, 1474 insertions, 0 deletions
diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/bind/all_bound.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/bind/all_bound.cc new file mode 100644 index 000000000..3641cc36e --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/bind/all_bound.cc @@ -0,0 +1,42 @@ +// 2005-03-20 Douglas Gregor <doug.gregor -at- gmail.com> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.6 function object binders +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Operations on empty function<> objects +void test01() +{ + VERIFY( std::tr1::bind(std::plus<int>(), 3, 5)() == 8 ); + VERIFY( std::tr1::bind(std::minus<int>(), 3, 5)() == -2 ); + VERIFY( std::tr1::bind<int>(std::plus<int>(), 3, 5)() == 8 ); + VERIFY( std::tr1::bind<int>(std::minus<int>(), 3, 5)() == -2 ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/bind/nested.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/bind/nested.cc new file mode 100644 index 000000000..b5fdd7fa5 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/bind/nested.cc @@ -0,0 +1,44 @@ +// 2005-03-20 Douglas Gregor <doug.gregor -at- gmail.com> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.6 function object binders +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Operations on empty function<> objects +void test01() +{ + using namespace std::tr1::placeholders; + + int five = 5; + int seven = 7; + VERIFY( std::tr1::bind(std::multiplies<int>(), _1, std::tr1::bind(std::minus<int>(), 6, _2))(five, seven) == -5 ); + VERIFY( std::tr1::bind(std::multiplies<int>(), _1, std::tr1::bind(std::minus<int>(), 6, _2))(seven, five) == 7 ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/bind/placeholders.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/bind/placeholders.cc new file mode 100644 index 000000000..b82f06387 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/bind/placeholders.cc @@ -0,0 +1,44 @@ +// 2005-03-20 Douglas Gregor <doug.gregor -at- gmail.com> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.6 function object binders +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Operations on empty function<> objects +void test01() +{ + using namespace std::tr1::placeholders; + + int five = 5; + int seven = 7; + VERIFY( std::tr1::bind(std::minus<int>(), _1, _2)(five, seven) == -2 ); + VERIFY( std::tr1::bind(std::minus<int>(), _2, _1)(five, seven) == 2 ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/bind/ref.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/bind/ref.cc new file mode 100644 index 000000000..7f7215626 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/bind/ref.cc @@ -0,0 +1,59 @@ +// 2005-03-20 Douglas Gregor <doug.gregor -at- gmail.com> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.6 function object binders +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +struct X +{ + X() : bar(17) {} + + int foo(int x, int y) { return bar + x + y; } + + int bar; + +private: + X(const X&); + X& operator=(const X&); +}; + +// Operations on empty function<> objects +void test01() +{ + using std::tr1::bind; + using std::tr1::ref; + ::X x; + + VERIFY( bind(&::X::foo, ref(x), 1, 2)() == 20 ); + VERIFY( bind<int>(&::X::foo, ref(x), 1, 2)() == 20 ); + VERIFY( bind(&::X::bar, ref(x))() == 17 ); + VERIFY( bind<int>(&::X::bar, ref(x))() == 17 ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/function/1.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/function/1.cc new file mode 100644 index 000000000..fddda85e7 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/function/1.cc @@ -0,0 +1,94 @@ +// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.7.2 polymorphic function object wrapper +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Operations on empty function<> objects +void test01() +{ + using std::tr1::function; + using std::tr1::bad_function_call; + + // Default-construction + function<int(float)> f1; + VERIFY( ((bool)f1 == false) ); + VERIFY( !f1 ); + VERIFY( f1 == 0 ); + VERIFY( 0 == f1 ); + VERIFY( !(f1 != 0) ); + VERIFY( !(0 != f1) ); + + // Copy-construction + function<int(float)> f2(f1); + VERIFY( !f2 ); + + // Construct with NULL pointer + function<int(float)> f3(0); + VERIFY( !f3 ); + + // Assignment + f1 = f2; + VERIFY( !f1); + + // Assignment to NULL pointer + f1 = 0; + VERIFY( !f1 ); + + // Swap + swap(f1, f2); + VERIFY( !f1 ); + VERIFY( !f2 ); + + // Invocation should throw bad_function_call + bool thrown = false; + try + { + f1(3.14159f); + VERIFY( false ); + } + catch (bad_function_call) + { + thrown = true; + } + VERIFY( thrown ); + + // target_type returns typeid(void) + VERIFY( f1.target_type() == typeid(void) ); + + // target() always returns a NULL pointer + VERIFY( f1.target<int (*)(float)>() == 0); + + // Check const version + const function<int(float)>& f1c = f1; + VERIFY( f1c.target<int (*)(float)>() == 0 ); + VERIFY( !f1c ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/function/2.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/function/2.cc new file mode 100644 index 000000000..63b3b0331 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/function/2.cc @@ -0,0 +1,77 @@ +// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.7.2 polymorphic function object wrapper +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Put function pointers into function<> wrappers +void test02() +{ + using std::tr1::function; + + function<int(float)> f1(truncate_float); + VERIFY( f1 ); + VERIFY( !!f1 ); + VERIFY( !(f1 == 0) ); + VERIFY( !(0 == f1) ); + VERIFY( f1 != 0 ); + VERIFY( 0 != f1 ); + + // Copy-construction + function<int(float)> f2(f1); + VERIFY( f2 ); + + // Invocation + VERIFY( f1(3.1f) == 3 ); + VERIFY( f2(3.1f) == 3 ); + + // Assignment to zero + f1 = 0; + VERIFY( !f1 ); + + // Swap + f1.swap(f2); + VERIFY( f1 ); + VERIFY( !f2 ); + VERIFY( f1(3.1f) == 3 ); + + // Assignment from a function pointer + f2 = truncate_float; + VERIFY( f2(3.1f) == 3 ); + + // target_type and target() functions + const function<int(float)>& f1c = f1; + VERIFY( typeid(int(*)(float)) == f1.target_type() ); + VERIFY( f2.target<int(*)(float)>() != 0 ); + VERIFY( *f2.target<int(*)(float)>() == &truncate_float ); + VERIFY( f1c.target<int(*)(float)>() != 0 ); + VERIFY( *f1c.target<int(*)(float)>() == &truncate_float ); +} + +int main() +{ + test02(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/function/3.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/function/3.cc new file mode 100644 index 000000000..0019f301c --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/function/3.cc @@ -0,0 +1,77 @@ +// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.7.2 polymorphic function object wrapper +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Put nearly-matching function pointers into function<> wrappers +void test03() +{ + using std::tr1::function; + + function<int(float)> f1(truncate_double); + VERIFY( f1 ); + VERIFY( !!f1 ); + VERIFY( !(f1 == 0) ); + VERIFY( !(0 == f1) ); + VERIFY( f1 != 0 ); + VERIFY( 0 != f1 ); + + // Copy-construction + function<int(float)> f2(f1); + VERIFY( f2 ); + + // Invocation + VERIFY( f1(3.1f) == 3 ); + VERIFY( f2(3.1f) == 3 ); + + // Assignment to zero + f1 = 0; + VERIFY( !f1 ); + + // Swap + f1.swap(f2); + VERIFY( f1 ); + VERIFY( !f2 ); + VERIFY( f1(3.1f) == 3 ); + + // Assignment from a function pointer + f2 = truncate_double; + VERIFY( f2(3.1f) == 3 ); + + // target_type and target() functions + const function<int(float)>& f1c = f1; + VERIFY( typeid(long(*)(double)) == f1.target_type() ); + VERIFY( f2.target<long(*)(double)>() != 0 ); + VERIFY( *f2.target<long(*)(double)>() == &truncate_double ); + VERIFY( f1c.target<long(*)(double)>() != 0 ); + VERIFY( *f1c.target<long(*)(double)>() == &truncate_double ); +} + +int main() +{ + test03(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/function/4.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/function/4.cc new file mode 100644 index 000000000..2a10ff339 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/function/4.cc @@ -0,0 +1,81 @@ +// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.7.2 polymorphic function object wrapper +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Put function objects into function<> wrappers +void test04() +{ + using std::tr1::function; + + do_truncate_float_t truncate_float; + + function<int(float)> f1(truncate_float); + VERIFY( f1 ); + VERIFY( !!f1 ); + VERIFY( !(f1 == 0) ); + VERIFY( !(0 == f1) ); + VERIFY( f1 != 0 ); + VERIFY( 0 != f1 ); + + // Copy-construction + function<int(float)> f2(f1); + VERIFY( f2 ); + + // Invocation + VERIFY( f1(3.1f) == 3 ); + VERIFY( f2(3.1f) == 3 ); + + // Assignment to zero + f1 = 0; + VERIFY( !f1 ); + + // Swap + f1.swap(f2); + VERIFY( f1 ); + VERIFY( !f2 ); + VERIFY( f1(3.1f) == 3 ); + + // Assignment from a function pointer + f2 = do_truncate_float_t(); + VERIFY( f2(3.1f) == 3 ); + + // target_type and target() functions + const function<int(float)>& f1c = f1; + VERIFY( typeid(do_truncate_float_t) == f1.target_type() ); + VERIFY( f2.target<do_truncate_float_t>() != 0 ); + VERIFY( f1c.target<do_truncate_float_t>() != 0 ); +} + +int main() +{ + test04(); + + VERIFY( do_truncate_double_t::live_objects == 0 ); + VERIFY( do_truncate_float_t::live_objects == 0 ); + + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/function/5.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/function/5.cc new file mode 100644 index 000000000..1b49c3033 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/function/5.cc @@ -0,0 +1,106 @@ +// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.7.2 polymorphic function object wrapper +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Put member pointers into function<> wrappers +void test05() +{ + using std::tr1::function; + + X x; + x.bar = 17; + + function<int(X&)> frm(&X::bar); + VERIFY( frm ); + VERIFY( frm(x) == 17 ); + VERIFY( typeid(int X::*) == frm.target_type() ); + VERIFY( *frm.target<int X::*>() == &X::bar ); + + function<int(X&)> fr(&X::foo); + VERIFY( fr ); + VERIFY( fr(x) == 1 ); + VERIFY( typeid(int (X::*)()) == fr.target_type() ); + VERIFY( *fr.target<int (X::*)()>() == &X::foo ); + + function<int(const X&)> frc(&X::foo_c); + VERIFY( frc ); + VERIFY( frc(x) == 2 ); + VERIFY( typeid(int (X::*)() const) == frc.target_type() ); + VERIFY( *frc.target<int (X::*)() const >() == &X::foo_c ); + + function<int(volatile X&)> frv(&X::foo_v); + VERIFY( frv ); + VERIFY( frv(x) == 3 ); + VERIFY( typeid(int (X::*)() volatile) == frv.target_type() ); + VERIFY( *frv.target<int (X::*)() volatile >() == &X::foo_v ); + VERIFY( frv.target<int (X::*)() const volatile>() == 0 ); + + function<int(const volatile X&)> frcv(&X::foo_cv); + VERIFY( frcv ); + VERIFY( frcv(x) == 4 ); + VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() ); + VERIFY( *frcv.target<int (X::*)() const volatile >() == &X::foo_cv ); + VERIFY( frcv.target<int (X::*)() const>() == 0 ); + + function<int(X*)> grm(&X::bar); + VERIFY( grm ); + VERIFY( grm(&x) == 17 ); + VERIFY( typeid(int X::*) == grm.target_type() ); + VERIFY( *grm.target<int X::*>() == &X::bar ); + + function<int(X*)> gr(&X::foo); + VERIFY( gr ); + VERIFY( gr(&x) == 1 ); + VERIFY( typeid(int (X::*)()) == gr.target_type() ); + VERIFY( *gr.target<int (X::*)()>() == &X::foo ); + + function<int(const X*)> grc(&X::foo_c); + VERIFY( grc ); + VERIFY( grc(&x) == 2 ); + VERIFY( typeid(int (X::*)() const) == grc.target_type() ); + VERIFY( *grc.target<int (X::*)() const >() == &X::foo_c ); + + function<int(volatile X*)> grv(&X::foo_v); + VERIFY( grv ); + VERIFY( grv(&x) == 3 ); + VERIFY( typeid(int (X::*)() volatile) == grv.target_type() ); + VERIFY( *grv.target<int (X::*)() volatile >() == &X::foo_v ); + VERIFY( grv.target<int (X::*)() const volatile>() == 0 ); + + function<int(const volatile X*)> grcv(&X::foo_cv); + VERIFY( grcv ); + VERIFY( grcv(&x) == 4 ); + VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() ); + VERIFY( *grcv.target<int (X::*)() const volatile >() == &X::foo_cv ); + VERIFY( grcv.target<int (X::*)() const>() == 0 ); +} + +int main() +{ + test05(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/function/6.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/function/6.cc new file mode 100644 index 000000000..fde3099eb --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/function/6.cc @@ -0,0 +1,82 @@ +// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.7.2 polymorphic function object wrapper +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +struct secret {}; + +struct noncopyable_function_object_type +{ + noncopyable_function_object_type(secret) {} + + int operator()() const { return 42; } + int operator()() { return 17; } + + private: + noncopyable_function_object_type(); + noncopyable_function_object_type(const noncopyable_function_object_type&); + void operator=(const noncopyable_function_object_type&); +}; + +// Put reference_wrappers into function<> wrappers +void test06() +{ + using std::tr1::function; + using std::tr1::ref; + using std::tr1::cref; + + secret password; + noncopyable_function_object_type x(password); + + function<int()> f(ref(x)); + VERIFY( f ); + VERIFY( f() == 17 ); + VERIFY( f.target_type() == typeid(noncopyable_function_object_type) ); + VERIFY( f.target<noncopyable_function_object_type>() == &x ); + + function<int()> g = f; + VERIFY( g ); + VERIFY( g() == 17 ); + VERIFY( g.target_type() == typeid(noncopyable_function_object_type) ); + VERIFY( g.target<noncopyable_function_object_type>() == &x ); + + function<int()> h = cref(x); + VERIFY( h ); + VERIFY( h() == 42 ); + VERIFY( h.target_type() == typeid(noncopyable_function_object_type) ); + VERIFY( h.target<const noncopyable_function_object_type>() == &x ); + VERIFY( h.target<const noncopyable_function_object_type>() == &x ); + + const function<int()>& hc = h; + VERIFY( h.target<noncopyable_function_object_type>() == 0 ); + VERIFY( hc.target<noncopyable_function_object_type>() == &x ); +} + +int main() +{ + test06(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/function/7.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/function/7.cc new file mode 100644 index 000000000..6095212bb --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/function/7.cc @@ -0,0 +1,81 @@ +// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.7.2 polymorphic function object wrapper +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Put reference_wrappers to function pointers into function<> wrappers +void test07() +{ + using std::tr1::function; + using std::tr1::ref; + using std::tr1::cref; + + int (*fptr)(float) = truncate_float; + + function<int(float)> f1(ref(fptr)); + VERIFY( f1 ); + VERIFY( !!f1 ); + VERIFY( !(f1 == 0) ); + VERIFY( !(0 == f1) ); + VERIFY( f1 != 0 ); + VERIFY( 0 != f1 ); + + // Invocation + VERIFY( f1(3.1f) == 3 ); + + // target_type and target() functions + const function<int(float)>& f1c = f1; + VERIFY( typeid(int(*)(float)) == f1.target_type() ); + VERIFY( f1.target<int(*)(float)>() != 0 ); + VERIFY( f1.target<int(*)(float)>() == &fptr ); + VERIFY( f1c.target<int(*)(float)>() != 0 ); + VERIFY( f1c.target<int(*)(float)>() == &fptr ); + + function<int(float)> f2(cref(fptr)); + VERIFY( f2 ); + VERIFY( !!f2 ); + VERIFY( !(f2 == 0) ); + VERIFY( !(0 == f2) ); + VERIFY( f2 != 0 ); + VERIFY( 0 != f2 ); + + // Invocation + VERIFY( f2(3.1f) == 3 ); + + // target_type and target() functions + const function<int(float)>& f2c = f2; + VERIFY( typeid(int(*)(float)) == f2.target_type() ); + VERIFY( f2.target<int(*)(float)>() == 0 ); + VERIFY( f2.target<int(* const)(float)>() == &fptr ); + VERIFY( f2c.target<int(*)(float)>() != 0 ); + VERIFY( f2c.target<int(*)(float)>() == &fptr ); +} + +int main() +{ + test07(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/function/8.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/function/8.cc new file mode 100644 index 000000000..d8d6a5df1 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/function/8.cc @@ -0,0 +1,147 @@ +// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.7.2 polymorphic function object wrapper +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Put reference_wrappers to member pointers +void test08() +{ + using std::tr1::function; + using std::tr1::ref; + using std::tr1::cref; + + int X::* X_bar = &X::bar; + int (X::* X_foo)() = &X::foo; + int (X::* X_foo_c)() const = &X::foo_c; + int (X::* X_foo_v)() volatile = &X::foo_v; + int (X::* X_foo_cv)() const volatile = &X::foo_cv; + + X x; + x.bar = 17; + + function<int(X&)> frm(ref(X_bar)); + VERIFY( frm ); + VERIFY( frm(x) == 17 ); + VERIFY( typeid(int X::*) == frm.target_type() ); + VERIFY( frm.target<int X::*>() == &X_bar ); + + function<int(X&)> fr(ref(X_foo)); + VERIFY( fr ); + VERIFY( fr(x) == 1 ); + VERIFY( typeid(int (X::*)()) == fr.target_type() ); + VERIFY( fr.target<int (X::*)()>() == &X_foo ); + + function<int(const X&)> frc(ref(X_foo_c)); + VERIFY( frc ); + VERIFY( frc(x) == 2 ); + VERIFY( typeid(int (X::*)() const) == frc.target_type() ); + VERIFY( frc.target<int (X::*)() const >() == &X_foo_c ); + + function<int(volatile X&)> frv(ref(X_foo_v)); + VERIFY( frv ); + VERIFY( frv(x) == 3 ); + VERIFY( typeid(int (X::*)() volatile) == frv.target_type() ); + VERIFY( *frv.target<int (X::*)() volatile >() == X_foo_v ); + VERIFY( frv.target<int (X::*)() const volatile>() == 0 ); + + function<int(const volatile X&)> frcv(ref(X_foo_cv)); + VERIFY( frcv ); + VERIFY( frcv(x) == 4 ); + VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() ); + VERIFY( *frcv.target<int (X::*)() const volatile >() == X_foo_cv ); + VERIFY( frcv.target<int (X::*)() const>() == 0 ); + + function<int(X*)> grm(ref(X_bar)); + VERIFY( grm ); + VERIFY( grm(&x) == 17 ); + VERIFY( typeid(int X::*) == grm.target_type() ); + VERIFY( *grm.target<int X::*>() == X_bar ); + + function<int(X*)> gr(ref(X_foo)); + VERIFY( gr ); + VERIFY( gr(&x) == 1 ); + VERIFY( typeid(int (X::*)()) == gr.target_type() ); + VERIFY( *gr.target<int (X::*)()>() == X_foo ); + + function<int(const X*)> grc(ref(X_foo_c)); + VERIFY( grc ); + VERIFY( grc(&x) == 2 ); + VERIFY( typeid(int (X::*)() const) == grc.target_type() ); + VERIFY( *grc.target<int (X::*)() const >() == X_foo_c ); + + function<int(volatile X*)> grv(ref(X_foo_v)); + VERIFY( grv ); + VERIFY( grv(&x) == 3 ); + VERIFY( typeid(int (X::*)() volatile) == grv.target_type() ); + VERIFY( *grv.target<int (X::*)() volatile >() == X_foo_v ); + VERIFY( grv.target<int (X::*)() const volatile>() == 0 ); + + function<int(const volatile X*)> grcv(ref(X_foo_cv)); + VERIFY( grcv ); + VERIFY( grcv(&x) == 4 ); + VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() ); + VERIFY( *grcv.target<int (X::*)() const volatile >() == X_foo_cv ); + VERIFY( grcv.target<int (X::*)() const>() == 0 ); + + function<int(X&)> hrm(cref(X_bar)); + VERIFY( hrm ); + VERIFY( hrm(x) == 17 ); + VERIFY( typeid(int X::*) == hrm.target_type() ); + VERIFY( hrm.target<int X::*>() == 0 ); + VERIFY( hrm.target<int X::* const>() == &X_bar ); + + function<int(X&)> hr(cref(X_foo)); + VERIFY( hr ); + VERIFY( hr(x) == 1 ); + VERIFY( typeid(int (X::*)()) == hr.target_type() ); + VERIFY( hr.target<int (X::* const)()>() == &X_foo ); + + function<int(const X&)> hrc(cref(X_foo_c)); + VERIFY( hrc ); + VERIFY( hrc(x) == 2 ); + VERIFY( typeid(int (X::*)() const) == hrc.target_type() ); + VERIFY( hrc.target<int (X::* const)() const >() == &X_foo_c ); + + function<int(volatile X&)> hrv(cref(X_foo_v)); + VERIFY( hrv ); + VERIFY( hrv(x) == 3 ); + VERIFY( typeid(int (X::*)() volatile) == hrv.target_type() ); + VERIFY( hrv.target<int (X::* const)() volatile >() == &X_foo_v ); + VERIFY( hrv.target<int (X::* const)() const volatile>() == 0 ); + + function<int(const volatile X&)> hrcv(cref(X_foo_cv)); + VERIFY( hrcv ); + VERIFY( hrcv(x) == 4 ); + VERIFY( typeid(int (X::*)() const volatile) == hrcv.target_type() ); + VERIFY( hrcv.target<int (X::* const)() const volatile >() == &X_foo_cv ); + VERIFY( hrcv.target<int (X::* const)() const>() == 0 ); +} + +int main() +{ + test08(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/function/9.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/function/9.cc new file mode 100644 index 000000000..ed1dfafa9 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/function/9.cc @@ -0,0 +1,54 @@ +// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.7.2 polymorphic function object wrapper +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +using namespace __gnu_test; + +bool test __attribute__((unused)) = true; + +// Put function objects into a void-returning function<> wrapper +void test09() +{ + using std::tr1::function; + using std::tr1::ref; + using std::tr1::cref; + + int (X::*X_foo_c)() const = &X::foo_c; + function<void(X&)> f(&X::bar); + f = &X::foo; + f = ref(X_foo_c); + f = cref(X_foo_c); + + function<void(float)> g = &truncate_float; + g = do_truncate_float_t(); +} + +int main() +{ + test09(); + + VERIFY( do_truncate_double_t::live_objects == 0 ); + VERIFY( do_truncate_float_t::live_objects == 0 ); + + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/headers/functional/synopsis.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/headers/functional/synopsis.cc new file mode 100644 index 000000000..e83e0d54f --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/headers/functional/synopsis.cc @@ -0,0 +1,79 @@ +// { dg-do compile } + +// 2007-02-04 Benjamin Kosnik <bkoz@redhat.com> +// +// Copyright (C) 2007, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <tr1/functional> + +namespace std { +namespace tr1 { + + // [3.4] class template result_of + template <class FunctionCallType> class result_of; + +#if 0 + // [3.5] function template mem_fn + template<class R, class T> unspecified mem_fn(R T::* pm); +#endif + + // [3.6] function object binders + template<class T> struct is_bind_expression; + template<class T> struct is_placeholder; + +#if 0 + template<class F, class T1, ..., class TN> + unspecified bind(F f, T1 t1, ..., TN tN); + + template<class R, class F, class T1, ..., class Tn > + unspecified bind(F f, T1 t1, ..., TN tN); + + namespace placeholders { + // M is the implementation-defined number of placeholders + extern unspecified _1; + extern unspecified _2; + . + . + . + extern unspecified _M; + } +#endif + + // [3.7] polymorphic function wrappers + class bad_function_call; + template<class Function> class function; + template<class Function> + void swap(function<Function>&, function<Function>&); + template<class Function1, class Function2> + void operator==(const function<Function1>&, const function<Function2>&); + template<class Function1, class Function2> + void operator!=(const function<Function1>&, const function<Function2>&); + +#if 0 + template <class Function> + bool operator==(const function<Function>&, unspecified-null-pointer-type); + template <class Function> + bool operator==(unspecified-null-pointer-type, const function<Function>&); + template <class Function> + bool operator!=(const function<Function>&, unspecified-null-pointer-type); + template <class Function> + bool operator!=(unspecified-null-pointer-type, const function<Function>&); +#endif + +} // namespace tr1 +} // namespace std diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/headers/functional/types_std_tr1.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/headers/functional/types_std_tr1.cc new file mode 100644 index 000000000..075a852c6 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/headers/functional/types_std_tr1.cc @@ -0,0 +1,25 @@ +// { dg-do compile } + +// Copyright (C) 2007, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <tr1/functional> + +namespace gnu +{ + using std::tr1::bad_function_call; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/headers/functional/using_namespace_std_tr1_placeholders.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/headers/functional/using_namespace_std_tr1_placeholders.cc new file mode 100644 index 000000000..9cfa9f61e --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/headers/functional/using_namespace_std_tr1_placeholders.cc @@ -0,0 +1,25 @@ +// { dg-do compile } + +// Copyright (C) 2007, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <tr1/functional> + +namespace gnu +{ + using namespace std::tr1::placeholders; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/mem_fn.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/mem_fn.cc new file mode 100644 index 000000000..7a6e66125 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/mem_fn.cc @@ -0,0 +1,80 @@ +// 2005-01-26 Douglas Gregor <dgregor@cs.indiana.edu> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.5 function template mem_fn +#include <tr1/functional> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +struct X { int bar; }; + +struct Y : X { }; + +template<typename T> +struct dumb_ptr +{ + dumb_ptr(T* p) : p(p) {} + + T& operator*() const { return *p; } + + private: + T* p; +}; + +// Test mem_fn with a data member +void test01(int r = 0) +{ + using std::tr1::mem_fn; + + X x; + Y y; + const X& xc = x; + const Y& yc = y; + X* xp = &x; + Y* yp =&y; + const X* xpc = xp; + const Y* ypc = yp; + dumb_ptr<X> xd(xp); + dumb_ptr<Y> yd(yp); + const dumb_ptr<X>& xdc = xd; + const dumb_ptr<Y>& ydc = yd; + + int& bx = mem_fn(&X::bar)(x); + const int& bxc = mem_fn(&X::bar)(xc); + int& bxp = mem_fn(&X::bar)(xp); + const int& bxpc = mem_fn(&X::bar)(xpc); + const int& bxd = mem_fn(&X::bar)(xd); + const int& bxdc = mem_fn(&X::bar)(xdc); + + int& by = mem_fn(&X::bar)(y); + const int& byc = mem_fn(&X::bar)(yc); + int& byp = mem_fn(&X::bar)(yp); + const int& bypc = mem_fn(&X::bar)(ypc); + const int& byd = mem_fn(&X::bar)(yd); + const int& bydc = mem_fn(&X::bar)(ydc); + + // Avoid unused variable warnings. + r = bx + bxc + bxp + bxpc + bxd + bxdc + by + byc + byp + bypc + byd + bydc; +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/reference_wrapper/invoke.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/reference_wrapper/invoke.cc new file mode 100644 index 000000000..2ab059b42 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/reference_wrapper/invoke.cc @@ -0,0 +1,115 @@ +// 2005-02-27 Douglas Gregor <doug.gregor -at- gmail.com> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 2.1 reference wrappers +#include <tr1/functional> +#include <tr1/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::tr1::ref; + using std::tr1::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/tr1/3_function_objects/reference_wrapper/typedefs.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/reference_wrapper/typedefs.cc new file mode 100644 index 000000000..851b26b9e --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/reference_wrapper/typedefs.cc @@ -0,0 +1,88 @@ +// 2005-02-27 Douglas Gregor <doug.gregor -at- gmail.com> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 2.1 reference wrappers +#include <tr1/functional> +#include <tr1/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::tr1::reference_wrapper; + using std::tr1::is_same; + using std::tr1::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; +} diff --git a/libstdc++-v3/testsuite/tr1/3_function_objects/result_of.cc b/libstdc++-v3/testsuite/tr1/3_function_objects/result_of.cc new file mode 100644 index 000000000..1c137bf99 --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/3_function_objects/result_of.cc @@ -0,0 +1,74 @@ +// 2005-01-26 Douglas Gregor <doug.gregor -at- gmail.com> +// +// Copyright (C) 2005, 2009 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 3, 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 COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// 3.4 function return types +#include <tr1/functional> +#include <tr1/type_traits> +#include <testsuite_hooks.h> +#include <testsuite_tr1.h> + +class X {}; + +struct int_result_type { typedef int result_type; }; + +struct int_result_of +{ + template<typename F> struct result { typedef int type; }; +}; + +struct int_result_type_and_float_result_of +{ + typedef int result_type; + template<typename F> struct result { typedef float type; }; +}; + +void test01() +{ + bool test __attribute__((unused)) = true; + + using std::tr1::result_of; + using std::tr1::is_same; + using namespace __gnu_test; + + typedef int (*func_ptr)(float, double); + typedef int (&func_ref)(float, double); + typedef int (::X::*mem_func_ptr)(float); + typedef int (::X::*mem_func_ptr_c)(float) const; + typedef int (::X::*mem_func_ptr_v)(float) volatile; + typedef int (::X::*mem_func_ptr_cv)(float) const volatile; + + VERIFY((is_same<result_of<int_result_type(float)>::type, int>::value)); + VERIFY((is_same<result_of<int_result_of(double)>::type, int>::value)); + VERIFY((is_same<result_of<int_result_of(void)>::type, void>::value)); + VERIFY((is_same<result_of<const int_result_of(double)>::type, int>::value)); + VERIFY((is_same<result_of<volatile int_result_of(void)>::type, void>::value)); + VERIFY((is_same<result_of<int_result_type_and_float_result_of(char)>::type, int>::value)); + VERIFY((is_same<result_of<func_ptr(char, float)>::type, int>::value)); + VERIFY((is_same<result_of<func_ref(char, float)>::type, int>::value)); + VERIFY((is_same<result_of<mem_func_ptr(::X,char)>::type, int>::value)); + VERIFY((is_same<result_of<mem_func_ptr_c(::X,char)>::type, int>::value)); + VERIFY((is_same<result_of<mem_func_ptr_v(::X,char)>::type, int>::value)); + VERIFY((is_same<result_of<mem_func_ptr_cv(::X,char)>::type, int>::value)); +} + +int main() +{ + test01(); + return 0; +} |