lib/3rdparty/stlport/test/unit/mfunptr_test.cpp

   1 #include <functional>
   2 #include <memory>
   3 #include <vector>
   4 #include <algorithm>
   5
   6 #include "cppunit/cppunit_proxy.h"
   7
   8 #if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
   9 using namespace std;
  10 #endif
  11
  12 //
  13 // TestCase class
  14 //
  15 class MemFunPtrTest : public CPPUNIT_NS::TestCase
  16 {
  17   CPPUNIT_TEST_SUITE(MemFunPtrTest);
  18   CPPUNIT_TEST(mem_ptr_fun);
  19 #if defined (STLPORT) && !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
  20   //This test require partial template specialization feature to avoid the
  21   //reference to reference problem. No workaround yet for limited compilers.
  22   CPPUNIT_IGNORE;
  23 #endif
  24   CPPUNIT_TEST(find);
  25   CPPUNIT_TEST_SUITE_END();
  26
  27 protected:
  28   // compile test not neccessary to run but...
  29   void mem_ptr_fun();
  30   void find();
  31 };
  32
  33 CPPUNIT_TEST_SUITE_REGISTRATION(MemFunPtrTest);
  34
  35 #if defined(_STLP_DONT_RETURN_VOID) && (defined(_STLP_NO_MEMBER_TEMPLATE_CLASSES) && defined(_STLP_NO_CLASS_PARTIAL_SPECIALIZATION))
  36 #  define _STLP_DONT_TEST_RETURN_VOID
  37 #endif
  38 //else there is no workaround for the return void bug
  39
  40 struct S1 { } s1;
  41 struct S2 { } s2;
  42
  43 int f1(S1&);
  44 int f2(S1&, S2&);
  45 int f1c(const S1&);
  46 int f2c(const S1&, const S2&);
  47
  48 void vf1(S1&);
  49 void vf2(S1&, S2&);
  50 void vf1c(const S1&);
  51 void vf2c(const S1&, const S2&);
  52
  53 class Class {
  54 public:
  55   int f0();
  56   int f1(const S1&);
  57
  58   void vf0();
  59   void vf1(const S1&);
  60
  61   int f0c() const;
  62   int f1c(const S1&) const;
  63
  64   void vf0c() const;
  65   void vf1c(const S1&) const;
  66 };
  67
  68 //
  69 // tests implementation
  70 //
  71 void MemFunPtrTest::mem_ptr_fun()
  72 {
  73   Class obj;
  74   const Class& objc = obj;
  75
  76   // ptr_fun
  77
  78   ptr_fun(f1)(s1);
  79   ptr_fun(f2)(s1, s2);
  80
  81   ptr_fun(f1c)(s1);
  82   ptr_fun(f2c)(s1, s2);
  83
  84 #ifndef _STLP_DONT_TEST_RETURN_VOID
  85   ptr_fun(vf1)(s1);
  86   ptr_fun(vf2)(s1, s2);
  87
  88   ptr_fun(vf1c)(s1);
  89   ptr_fun(vf2c)(s1, s2);
  90 #endif /* _STLP_DONT_TEST_RETURN_VOID */
  91
  92   // mem_fun
  93
  94   mem_fun(&Class::f0)(&obj);
  95   mem_fun(&Class::f1)(&obj, s1);
  96
  97 #ifndef _STLP_DONT_TEST_RETURN_VOID
  98   mem_fun(&Class::vf0)(&obj);
  99   mem_fun(&Class::vf1)(&obj, s1);
 100 #endif /* _STLP_DONT_TEST_RETURN_VOID */
 101
 102   // mem_fun (const)
 103
 104   mem_fun(&Class::f0c)(&objc);
 105   mem_fun(&Class::f1c)(&objc, s1);
 106
 107 #ifndef _STLP_DONT_TEST_RETURN_VOID
 108   mem_fun(&Class::vf0c)(&objc);
 109   mem_fun(&Class::vf1c)(&objc, s1);
 110 #endif /* _STLP_DONT_TEST_RETURN_VOID */
 111
 112   // mem_fun_ref
 113
 114   mem_fun_ref(&Class::f0)(obj);
 115   mem_fun_ref(&Class::f1)(obj, s1);
 116
 117 #ifndef _STLP_DONT_TEST_RETURN_VOID
 118   mem_fun_ref(&Class::vf0)(obj);
 119   mem_fun_ref(&Class::vf1)(obj, s1);
 120 #endif /* _STLP_DONT_TEST_RETURN_VOID */
 121
 122   // mem_fun_ref (const)
 123   mem_fun_ref(&Class::f0c)(objc);
 124   mem_fun_ref(&Class::f1c)(objc, s1);
 125
 126 #ifndef _STLP_DONT_TEST_RETURN_VOID
 127   mem_fun_ref(&Class::vf0c)(objc);
 128   mem_fun_ref(&Class::vf1c)(objc, s1);
 129 #endif /* _STLP_DONT_TEST_RETURN_VOID */
 130 }
 131 int f1(S1&)
 132 {return 1;}
 133
 134 int f2(S1&, S2&)
 135 {return 2;}
 136
 137 int f1c(const S1&)
 138 {return 1;}
 139
 140 int f2c(const S1&, const S2&)
 141 {return 2;}
 142
 143 void vf1(S1&)
 144 {}
 145
 146 void vf2(S1&, S2&)
 147 {}
 148
 149 void vf1c(const S1&)
 150 {}
 151
 152 void vf2c(const S1&, const S2&)
 153 {}
 154
 155 int Class::f0()
 156 {return 0;}
 157
 158 int Class::f1(const S1&)
 159 {return 1;}
 160
 161 void Class::vf0()
 162 {}
 163
 164 void Class::vf1(const S1&)
 165 {}
 166
 167 int Class::f0c() const
 168 {return 0;}
 169
 170 int Class::f1c(const S1&) const
 171 {return 1;}
 172
 173 void Class::vf0c() const
 174 {}
 175
 176 void Class::vf1c(const S1&) const
 177 {}
 178
 179 struct V {
 180   public:
 181     V(int _v) :
 182       v(_v)
 183     { }
 184
 185   bool f( int _v ) const { return (v == _v); }
 186
 187   int v;
 188 #if defined (__DMC__)
 189   V(){}
 190 #endif
 191 };
 192
 193 void MemFunPtrTest::find()
 194 {
 195 #if !defined (STLPORT) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
 196   vector<V> v;
 197
 198   v.push_back( V(1) );
 199   v.push_back( V(2) );
 200   v.push_back( V(3) );
 201
 202   // step-by-step complication of work for compiler:
 203
 204   // step 1:
 205   const_mem_fun1_ref_t<bool,V,int> pmf = mem_fun_ref( &V::f );
 206   binder2nd<const_mem_fun1_ref_t<bool,V,int> > b(pmf, 2);
 207   vector<V>::iterator i = find_if( v.begin(), v.end(), b );
 208   CPPUNIT_ASSERT(i != v.end());
 209   CPPUNIT_ASSERT(i->v == 2);
 210
 211   // step 2, just check that compiler understand what pass to bind2nd:
 212   binder2nd<const_mem_fun1_ref_t<bool,V,int> > b2 = bind2nd( pmf, 2 );
 213
 214   // step 3, the same as step 1, but more intellect from compiler required:
 215   binder2nd<const_mem_fun1_ref_t<bool,V,int> > b3 = bind2nd( mem_fun_ref( &V::f ), 2 );
 216
 217   vector<V>::iterator j = find_if( v.begin(), v.end(), b3 );
 218   CPPUNIT_ASSERT(j != v.end());
 219   CPPUNIT_ASSERT(j->v == 2);
 220
 221   // step 4, more brief, more complex:
 222   vector<V>::iterator k = find_if( v.begin(), v.end(), bind2nd( mem_fun_ref( &V::f ), 2 ) );
 223   CPPUNIT_ASSERT(k != v.end());
 224   CPPUNIT_ASSERT(k->v == 2);
 225 #endif
 226 }
 227
 228 #ifdef _STLP_DONT_TEST_RETURN_VOID
 229 #  undef _STLP_DONT_TEST_RETURN_VOID
 230 #endif