[v3] Add some tests

[Paolo Carlini <paolo dot carlini at oracle dot com>]

Hi,

tested x86_64-linux, committed to mainline.

Paolo.

//////////////////////

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.

Index: testsuite/20_util/reference_wrapper/invoke.cc
===================================================================
*** testsuite/20_util/reference_wrapper/invoke.cc	(revision 0)
--- testsuite/20_util/reference_wrapper/invoke.cc	(revision 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;
+ }
Index: testsuite/20_util/reference_wrapper/24803.cc
===================================================================
*** testsuite/20_util/reference_wrapper/24803.cc	(revision 0)
--- testsuite/20_util/reference_wrapper/24803.cc	(revision 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());
+ }
Index: testsuite/20_util/reference_wrapper/typedefs.cc
===================================================================
*** testsuite/20_util/reference_wrapper/typedefs.cc	(revision 0)
--- testsuite/20_util/reference_wrapper/typedefs.cc	(revision 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;
+ }