ndk/tests/device/test-gnustl-full/unit/list_test.cpp

   1 //Has to be first for StackAllocator swap overload to be taken
   2 //into account (at least using GCC 4.0.1)
   3 #include "stack_allocator.h"
   4
   5 #include <list>
   6 #include <algorithm>
   7 #include <functional>
   8
   9 #include "cppunit/cppunit_proxy.h"
  10
  11 #if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
  12 using namespace std;
  13 #endif
  14
  15 //
  16 // TestCase class
  17 //
  18 class ListTest : public CPPUNIT_NS::TestCase
  19 {
  20   CPPUNIT_TEST_SUITE(ListTest);
  21   CPPUNIT_TEST(list1);
  22   CPPUNIT_TEST(list2);
  23   CPPUNIT_TEST(list3);
  24   CPPUNIT_TEST(list4);
  25   CPPUNIT_TEST(erase);
  26   CPPUNIT_TEST(resize);
  27   CPPUNIT_TEST(push_back);
  28   CPPUNIT_TEST(push_front);
  29   CPPUNIT_TEST(allocator_with_state);
  30   CPPUNIT_TEST(swap);
  31   CPPUNIT_TEST(adl);
  32   //CPPUNIT_TEST(const_list);
  33   CPPUNIT_TEST_SUITE_END();
  34
  35 protected:
  36   void list1();
  37   void list2();
  38   void list3();
  39   void list4();
  40   void erase();
  41   void resize();
  42   void push_back();
  43   void push_front();
  44   void allocator_with_state();
  45   void swap();
  46   void adl();
  47   //void const_list();
  48 };
  49
  50 CPPUNIT_TEST_SUITE_REGISTRATION(ListTest);
  51
  52 //
  53 // tests implementation
  54 //
  55 void ListTest::list1()
  56 {
  57   int array1 [] = { 9, 16, 36 };
  58   int array2 [] = { 1, 4 };
  59
  60   list<int> l1(array1, array1 + 3);
  61   list<int> l2(array2, array2 + 2);
  62   list<int>::iterator i1 = l1.begin();
  63   list<int>::iterator i2 = l2.begin();
  64   list<int>::const_iterator ci(i1);
  65   list<int>::const_iterator ci1(ci);
  66   l1.splice(i1, l2);
  67   i1 = l1.begin();
  68   CPPUNIT_ASSERT( *i1++ == 1 );
  69   CPPUNIT_ASSERT( *i1++ == 4 );
  70   CPPUNIT_ASSERT( *i1++ == 9 );
  71   CPPUNIT_ASSERT( *i1++ == 16 );
  72   CPPUNIT_ASSERT( *i1++ == 36 );
  73
  74 #if defined (STLPORT) && \
  75    (!defined (_STLP_DEBUG) || (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL))
  76   CPPUNIT_ASSERT( i2 == l1.begin() );
  77 #endif
  78
  79   //Default construct check (_STLP_DEF_CONST_PLCT_NEW_BUG)
  80   list<int> l(2);
  81   i1 = l.begin();
  82   CPPUNIT_ASSERT( *(i1++) == 0 );
  83   CPPUNIT_ASSERT( *i1 == 0 );
  84 #if 0
  85   //A small compilation time check to be activated from time to time,
  86   //compilation should fail.
  87   {
  88     list<char>::iterator l_char_ite;
  89     list<int>::iterator l_int_ite;
  90     CPPUNIT_ASSERT( l_char_ite != l_int_ite );
  91   }
  92 #endif
  93 }
  94
  95 void ListTest::list2()
  96 {
  97   int array1 [] = { 1, 16 };
  98   int array2 [] = { 4, 9 };
  99
 100   list<int> l1(array1, array1 + 2);
 101   list<int> l2(array2, array2 + 2);
 102   list<int>::iterator i = l1.begin();
 103   i++;
 104   l1.splice(i, l2, l2.begin(), l2.end());
 105   i = l1.begin();
 106   CPPUNIT_ASSERT(*i++==1);
 107   CPPUNIT_ASSERT(*i++==4);
 108   CPPUNIT_ASSERT(*i++==9);
 109   CPPUNIT_ASSERT(*i++==16);
 110 }
 111
 112 void ListTest::list3()
 113 {
 114   char array [] = { 'x', 'l', 'x', 't', 's', 's' };
 115
 116   list<char> str(array, array + 6);
 117   list<char>::iterator i;
 118
 119   str.reverse();
 120   i = str.begin();
 121   CPPUNIT_ASSERT(*i++=='s');
 122   CPPUNIT_ASSERT(*i++=='s');
 123   CPPUNIT_ASSERT(*i++=='t');
 124   CPPUNIT_ASSERT(*i++=='x');
 125   CPPUNIT_ASSERT(*i++=='l');
 126   CPPUNIT_ASSERT(*i++=='x');
 127
 128   str.remove('x');
 129   i = str.begin();
 130   CPPUNIT_ASSERT(*i++=='s');
 131   CPPUNIT_ASSERT(*i++=='s');
 132   CPPUNIT_ASSERT(*i++=='t');
 133   CPPUNIT_ASSERT(*i++=='l');
 134
 135   str.unique();
 136   i = str.begin();
 137   CPPUNIT_ASSERT(*i++=='s');
 138   CPPUNIT_ASSERT(*i++=='t');
 139   CPPUNIT_ASSERT(*i++=='l');
 140
 141   str.sort();
 142   i = str.begin();
 143   CPPUNIT_ASSERT(*i++=='l');
 144   CPPUNIT_ASSERT(*i++=='s');
 145   CPPUNIT_ASSERT(*i++=='t');
 146 }
 147
 148 void ListTest::list4()
 149 {
 150   int array1 [] = { 1, 3, 6, 7 };
 151   int array2 [] = { 2, 4 };
 152
 153   list<int> l1(array1, array1 + 4);
 154   list<int> l2(array2, array2 + 2);
 155   l1.merge(l2);
 156   list<int>::iterator i = l1.begin();
 157   CPPUNIT_ASSERT(*i++==1);
 158   CPPUNIT_ASSERT(*i++==2);
 159   CPPUNIT_ASSERT(*i++==3);
 160   CPPUNIT_ASSERT(*i++==4);
 161   CPPUNIT_ASSERT(*i++==6);
 162   CPPUNIT_ASSERT(*i++==7);
 163
 164   //We use distance to avoid a simple call to an internal counter
 165   CPPUNIT_ASSERT(distance(l1.begin(), l1.end()) == 6);
 166   CPPUNIT_ASSERT(distance(l2.begin(), l2.end()) == 0);
 167
 168   l1.swap(l2);
 169
 170   CPPUNIT_ASSERT(distance(l1.begin(), l1.end()) == 0);
 171   CPPUNIT_ASSERT(distance(l2.begin(), l2.end()) == 6);
 172 }
 173
 174 void ListTest::erase()
 175 {
 176   list<int> l;
 177   l.push_back( 1 );
 178   l.erase(l.begin());
 179   CPPUNIT_ASSERT( l.empty() );
 180
 181   int array[] = { 0, 1, 2, 3 };
 182   l.assign(array, array + 4);
 183   list<int>::iterator lit;
 184   lit = l.erase(l.begin());
 185   CPPUNIT_ASSERT( *lit == 1 );
 186
 187   lit = l.erase(l.begin(), --l.end());
 188   CPPUNIT_ASSERT( *lit == 3 );
 189
 190   l.clear();
 191   CPPUNIT_ASSERT( l.empty() );
 192 }
 193
 194
 195 void ListTest::resize()
 196 {
 197   {
 198     list<int> l;
 199     l.resize(5, 1);
 200
 201     size_t i;
 202     list<int>::iterator lit(l.begin());
 203     for (i = 0; i < 5; ++i) {
 204       CPPUNIT_ASSERT( lit != l.end() );
 205       CPPUNIT_ASSERT( *(lit++) == 1 );
 206     }
 207     CPPUNIT_ASSERT( lit == l.end() );
 208
 209     l.resize(3);
 210     lit = l.begin();
 211     for (i = 0; i < 3; ++i) {
 212       CPPUNIT_ASSERT( lit != l.end() );
 213       CPPUNIT_ASSERT( *(lit++) == 1 );
 214     }
 215     CPPUNIT_ASSERT( lit == l.end() );
 216   }
 217
 218   {
 219     list<int> l;
 220     l.resize(5);
 221
 222     size_t i;
 223     list<int>::iterator lit(l.begin());
 224     for (i = 0; i < 5; ++i) {
 225       CPPUNIT_ASSERT( lit != l.end() );
 226       CPPUNIT_ASSERT( *(lit++) == 0 );
 227     }
 228     CPPUNIT_ASSERT( lit == l.end() );
 229   }
 230 }
 231
 232 void ListTest::push_back()
 233 {
 234   list<int> l;
 235   l.push_back( 1 );
 236   l.push_back( 2 );
 237   l.push_back( 3 );
 238
 239   list<int>::reverse_iterator r = l.rbegin();
 240
 241   CPPUNIT_ASSERT( *r == 3 );
 242   l.push_back( 4 );
 243   /*
 244    * Following lines are commented, because ones show standard contradiction
 245    * (24.4.1 and 23.2.2.3); but present behaviour is valid, 24.4.1, paragraphs 1 and 2,
 246    * 24.4.1.3.3 and 23.1 paragraph 9 (Table 66). The 24.4.1 is more common rule,
 247    * so it has preference under 23.2.2.3, by my opinion.
 248    *
 249    *      - ptr
 250    */
 251   // CPPUNIT_ASSERT( *r == 3 );
 252   // ++r;
 253   // CPPUNIT_ASSERT( *r == 2 );
 254 }
 255
 256 void ListTest::push_front()
 257 {
 258   list<int> l;
 259   l.push_back( 1 );
 260   l.push_back( 2 );
 261   l.push_back( 3 );
 262
 263   list<int>::iterator i = l.begin();
 264
 265   CPPUNIT_ASSERT( *i == 1 );
 266   l.push_front( 0 );
 267   CPPUNIT_ASSERT( *i == 1 );
 268   ++i;
 269   CPPUNIT_ASSERT( *i == 2 );
 270 }
 271
 272 void ListTest::allocator_with_state()
 273 {
 274   char buf1[1024];
 275   StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));
 276
 277   char buf2[1024];
 278   StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));
 279
 280   typedef list<int, StackAllocator<int> > ListInt;
 281   {
 282     //Swap with both list non empty
 283     ListInt lint1(10, 0, stack1);
 284     ListInt lint1Cpy(lint1);
 285
 286     ListInt lint2(10, 1, stack2);
 287     ListInt lint2Cpy(lint2);
 288
 289     lint1.swap(lint2);
 290
 291     CPPUNIT_ASSERT( lint1.get_allocator().swaped() );
 292     CPPUNIT_ASSERT( lint2.get_allocator().swaped() );
 293
 294     CPPUNIT_ASSERT( lint1 == lint2Cpy );
 295     CPPUNIT_ASSERT( lint2 == lint1Cpy );
 296     CPPUNIT_ASSERT( lint1.get_allocator() == stack2 );
 297     CPPUNIT_ASSERT( lint2.get_allocator() == stack1 );
 298   }
 299   CPPUNIT_CHECK( stack1.ok() );
 300   CPPUNIT_CHECK( stack2.ok() );
 301   stack1.reset(); stack2.reset();
 302
 303   {
 304     //Swap with empty calle list
 305     ListInt lint1(10, 0, stack1);
 306     ListInt lint1Cpy(lint1);
 307
 308     ListInt lint2(stack2);
 309     ListInt lint2Cpy(lint2);
 310
 311     lint1.swap(lint2);
 312
 313     CPPUNIT_ASSERT( lint1.get_allocator().swaped() );
 314     CPPUNIT_ASSERT( lint2.get_allocator().swaped() );
 315
 316     CPPUNIT_ASSERT( lint1 == lint2Cpy );
 317     CPPUNIT_ASSERT( lint2 == lint1Cpy );
 318     CPPUNIT_ASSERT( lint1.get_allocator() == stack2 );
 319     CPPUNIT_ASSERT( lint2.get_allocator() == stack1 );
 320   }
 321   CPPUNIT_CHECK( stack1.ok() );
 322   CPPUNIT_CHECK( stack2.ok() );
 323   stack1.reset(); stack2.reset();
 324
 325   {
 326     //Swap with empty caller list
 327     ListInt lint1(stack1);
 328     ListInt lint1Cpy(lint1);
 329
 330     ListInt lint2(10, 0, stack2);
 331     ListInt lint2Cpy(lint2);
 332
 333     lint1.swap(lint2);
 334
 335     CPPUNIT_ASSERT( lint1.get_allocator().swaped() );
 336     CPPUNIT_ASSERT( lint2.get_allocator().swaped() );
 337
 338     CPPUNIT_ASSERT( lint1 == lint2Cpy );
 339     CPPUNIT_ASSERT( lint2 == lint1Cpy );
 340     CPPUNIT_ASSERT( lint1.get_allocator() == stack2 );
 341     CPPUNIT_ASSERT( lint2.get_allocator() == stack1 );
 342   }
 343   CPPUNIT_CHECK( stack1.ok() );
 344   CPPUNIT_CHECK( stack2.ok() );
 345   stack1.reset(); stack2.reset();
 346
 347   {
 348     ListInt lint1(10, 0, stack1);
 349     ListInt lint2(10, 1, stack2);
 350
 351     lint1.splice(lint1.begin(), lint2);
 352     CPPUNIT_ASSERT( lint1.size() == 20 );
 353     CPPUNIT_ASSERT( lint2.empty() );
 354   }
 355   CPPUNIT_CHECK( stack1.ok() );
 356   CPPUNIT_CHECK( stack2.ok() );
 357   stack1.reset(); stack2.reset();
 358
 359   {
 360     ListInt lint1(10, 0, stack1);
 361     ListInt lint2(10, 1, stack2);
 362
 363     lint1.splice(lint1.begin(), lint2, lint2.begin());
 364     CPPUNIT_ASSERT( lint1.size() == 11 );
 365     CPPUNIT_ASSERT( lint2.size() == 9 );
 366   }
 367   CPPUNIT_CHECK( stack1.ok() );
 368   CPPUNIT_CHECK( stack2.ok() );
 369   stack1.reset(); stack2.reset();
 370
 371   {
 372     ListInt lint1(10, 0, stack1);
 373     ListInt lint2(10, 1, stack2);
 374
 375     ListInt::iterator lit(lint2.begin());
 376     advance(lit, 5);
 377     lint1.splice(lint1.begin(), lint2, lint2.begin(), lit);
 378     CPPUNIT_ASSERT( lint1.size() == 15 );
 379     CPPUNIT_ASSERT( lint2.size() == 5 );
 380   }
 381   CPPUNIT_CHECK( stack1.ok() );
 382   CPPUNIT_CHECK( stack2.ok() );
 383   stack1.reset(); stack2.reset();
 384
 385   {
 386     ListInt lint1(10, 0, stack1);
 387     ListInt lint2(10, 1, stack2);
 388
 389     ListInt lintref(stack2);
 390     lintref.insert(lintref.begin(), 10, 1);
 391     lintref.insert(lintref.begin(), 10, 0);
 392
 393     lint1.merge(lint2);
 394     CPPUNIT_ASSERT( lint1.size() == 20 );
 395     CPPUNIT_ASSERT( lint1 == lintref );
 396     CPPUNIT_ASSERT( lint2.empty() );
 397   }
 398   CPPUNIT_CHECK( stack1.ok() );
 399   CPPUNIT_CHECK( stack2.ok() );
 400
 401 #if defined (STLPORT) && !defined (_STLP_NO_MEMBER_TEMPLATES) && \
 402     (!defined (_MSC_VER) || (_MSC_VER >= 1300))
 403   {
 404     //This is a compile time test.
 405     //We check that sort implementation is correct when list is instanciated
 406     //with an allocator that do not have a default constructor.
 407     ListInt lint1(10, 0, stack1);
 408     lint1.sort();
 409     lint1.sort(greater<int>());
 410   }
 411 #endif
 412 }
 413
 414 /*
 415 void ListTest::const_list()
 416 {
 417   list<const int> cint_list;
 418   cint_list.push_back(1);
 419   cint_list.push_front(2);
 420 }
 421 */
 422 void ListTest::swap()
 423 {
 424   list<int> lst1;
 425   list<int> lst2;
 426
 427   lst1.push_back(1);
 428   lst2.push_back(2);
 429
 430   lst1.swap( lst2 );
 431
 432   CPPUNIT_CHECK( lst1.front() == 2 );
 433   CPPUNIT_CHECK( lst2.front() == 1 );
 434   CPPUNIT_CHECK( lst1.size() == 1 );
 435   CPPUNIT_CHECK( lst2.size() == 1 );
 436
 437   lst1.pop_front();
 438   lst2.pop_front();
 439
 440   CPPUNIT_CHECK( lst1.empty() );
 441   CPPUNIT_CHECK( lst2.empty() );
 442 }
 443
 444 namespace foo {
 445   class bar {};
 446
 447   template <class _It>
 448   size_t distance(_It, _It);
 449 }
 450
 451 void ListTest::adl()
 452 {
 453   list<foo::bar> lbar;
 454   CPPUNIT_ASSERT( lbar.size() == 0);
 455 }
 456
 457 #if !defined (STLPORT) || \
 458     !defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
 459 /* Simple compilation test: Check that nested types like iterator
 460  * can be access even if type used to instanciate container is not
 461  * yet completely defined.
 462  */
 463 class IncompleteClass
 464 {
 465   list<IncompleteClass> instances;
 466   typedef list<IncompleteClass>::iterator it;
 467 };
 468 #endif