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 231
