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 <algorithm> 6 #if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) 7 # include <slist> 8 # if !defined (_STLP_USE_NO_IOSTREAMS) 9 # include <sstream> 10 # endif 11 # include <iterator> 12 # include <functional> 13 #endif 14 15 #include "cppunit/cppunit_proxy.h" 16 17 #if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES) 18 using namespace std; 19 #endif 20 21 #if !defined (STLPORT) && defined(__GNUC__) 22 using namespace __gnu_cxx; 23 #endif 24 25 // 26 // TestCase class 27 // 28 class SlistTest : public CPPUNIT_NS::TestCase 29 { 30 CPPUNIT_TEST_SUITE(SlistTest); 31 #if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS) || defined (_STLP_USE_NO_IOSTREAMS) 32 CPPUNIT_IGNORE; 33 #endif 34 CPPUNIT_TEST(slist1); 35 #if defined (STLPORT) && defined (_STLP_USE_NO_IOSTREAMS) 36 CPPUNIT_STOP_IGNORE; 37 #endif 38 CPPUNIT_TEST(erase); 39 CPPUNIT_TEST(insert); 40 CPPUNIT_TEST(splice); 41 CPPUNIT_TEST(allocator_with_state); 42 CPPUNIT_TEST_SUITE_END(); 43 44 protected: 45 void slist1(); 46 void erase(); 47 void insert(); 48 void splice(); 49 void allocator_with_state(); 50 }; 51 52 CPPUNIT_TEST_SUITE_REGISTRATION(SlistTest); 53 54 // 55 // tests implementation 56 // 57 void SlistTest::slist1() 58 { 59 #if defined (STLPORT) && !defined (_STLP_USE_NO_IOSTREAMS) && !defined (_STLP_NO_EXTENSIONS) 60 /* 61 original: xlxtss 62 reversed: sstxlx 63 removed: sstl 64 uniqued: stl 65 sorted: lst 66 */ 67 68 char array [] = { 'x', 'l', 'x', 't', 's', 's' }; 69 ostringstream os; 70 ostream_iterator<char> o(os,""); 71 slist<char> str(array+0, array + 6); 72 slist<char>::iterator i; 73 //Check const_iterator construction from iterator 74 slist<char>::const_iterator ci(i); 75 slist<char>::const_iterator ci2(ci); 76 // cout << "reversed: "; 77 str.reverse(); 78 for(i = str.begin(); i != str.end(); i++) 79 os << *i; 80 stringbuf* buff=os.rdbuf(); 81 string result=buff->str(); 82 CPPUNIT_ASSERT(!strcmp(result.c_str(),"sstxlx")); 83 84 //cout << "removed: "; 85 str.remove('x'); 86 ostringstream os2; 87 for(i = str.begin(); i != str.end(); i++) 88 os2 << *i; 89 buff=os2.rdbuf(); 90 result=buff->str(); 91 CPPUNIT_ASSERT(!strcmp(result.c_str(),"sstl")); 92 93 94 //cout << "uniqued: "; 95 str.unique(); 96 ostringstream os3; 97 for(i = str.begin(); i != str.end(); i++) 98 os3 << *i; 99 buff=os3.rdbuf(); 100 result=buff->str(); 101 CPPUNIT_ASSERT(!strcmp(result.c_str(),"stl")); 102 103 //cout << "sorted: "; 104 str.sort(); 105 ostringstream os4; 106 for(i = str.begin(); i != str.end(); i++) 107 os4 << *i; 108 buff = os4.rdbuf(); 109 result = buff->str(); 110 CPPUNIT_ASSERT(!strcmp(result.c_str(),"lst")); 111 112 //A small compilation time check to be activated from time to time: 113 # if 0 114 { 115 slist<char>::iterator sl_char_ite; 116 slist<int>::iterator sl_int_ite; 117 CPPUNIT_ASSERT( sl_char_ite != sl_int_ite ); 118 } 119 # endif 120 #endif 121 } 122 123 void SlistTest::erase() 124 { 125 #if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) 126 int array[] = { 0, 1, 2, 3, 4 }; 127 slist<int> sl(array, array + 5); 128 slist<int>::iterator slit; 129 130 slit = sl.erase(sl.begin()); 131 CPPUNIT_ASSERT( *slit == 1); 132 133 ++slit++; ++slit; 134 slit = sl.erase(sl.begin(), slit); 135 CPPUNIT_ASSERT( *slit == 3 ); 136 137 sl.assign(array, array + 5); 138 139 slit = sl.erase_after(sl.begin()); 140 CPPUNIT_ASSERT( *slit == 2 ); 141 142 slit = sl.begin(); ++slit; ++slit; 143 slit = sl.erase_after(sl.begin(), slit); 144 CPPUNIT_ASSERT( *slit == 3 ); 145 146 sl.erase_after(sl.before_begin()); 147 CPPUNIT_ASSERT( sl.front() == 3 ); 148 #endif 149 } 150 151 void SlistTest::insert() 152 { 153 #if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) 154 int array[] = { 0, 1, 2, 3, 4 }; 155 156 //insert 157 { 158 slist<int> sl; 159 160 sl.insert(sl.begin(), 5); 161 CPPUNIT_ASSERT( sl.front() == 5 ); 162 CPPUNIT_ASSERT( sl.size() == 1 ); 163 164 //debug mode check: 165 //sl.insert(sl.before_begin(), array, array + 5); 166 167 sl.insert(sl.begin(), array, array + 5); 168 CPPUNIT_ASSERT( sl.size() == 6 ); 169 int i; 170 slist<int>::iterator slit(sl.begin()); 171 for (i = 0; slit != sl.end(); ++slit, ++i) { 172 CPPUNIT_ASSERT( *slit == i ); 173 } 174 } 175 176 //insert_after 177 { 178 slist<int> sl; 179 180 //debug check: 181 //sl.insert_after(sl.begin(), 5); 182 183 sl.insert_after(sl.before_begin(), 5); 184 CPPUNIT_ASSERT( sl.front() == 5 ); 185 CPPUNIT_ASSERT( sl.size() == 1 ); 186 187 sl.insert_after(sl.before_begin(), array, array + 5); 188 CPPUNIT_ASSERT( sl.size() == 6 ); 189 int i; 190 slist<int>::iterator slit(sl.begin()); 191 for (i = 0; slit != sl.end(); ++slit, ++i) { 192 CPPUNIT_ASSERT( *slit == i ); 193 } 194 } 195 #endif 196 } 197 198 void SlistTest::splice() 199 { 200 #if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) 201 int array[] = { 0, 1, 2, 3, 4 }; 202 203 //splice 204 { 205 slist<int> sl1(array, array + 5); 206 slist<int> sl2(array, array + 5); 207 slist<int>::iterator slit; 208 209 //a no op: 210 sl1.splice(sl1.begin(), sl1, sl1.begin()); 211 CPPUNIT_ASSERT( sl1 == sl2 ); 212 213 slit = sl1.begin(); ++slit; 214 //a no op: 215 sl1.splice(slit, sl1, sl1.begin()); 216 CPPUNIT_ASSERT( sl1 == sl2 ); 217 218 sl1.splice(sl1.end(), sl1, sl1.begin()); 219 slit = sl1.begin(); 220 CPPUNIT_ASSERT( *(slit++) == 1 ); 221 CPPUNIT_ASSERT( *(slit++) == 2 ); 222 CPPUNIT_ASSERT( *(slit++) == 3 ); 223 CPPUNIT_ASSERT( *(slit++) == 4 ); 224 CPPUNIT_ASSERT( *slit == 0 ); 225 sl1.splice(sl1.begin(), sl1, slit); 226 CPPUNIT_ASSERT( sl1 == sl2 ); 227 228 sl1.splice(sl1.begin(), sl2); 229 size_t i; 230 for (i = 0, slit = sl1.begin(); slit != sl1.end(); ++slit, ++i) { 231 if (i == 5) i = 0; 232 CPPUNIT_ASSERT( *slit == array[i] ); 233 } 234 235 slit = sl1.begin(); 236 advance(slit, 5); 237 CPPUNIT_ASSERT( *slit == 0 ); 238 sl2.splice(sl2.begin(), sl1, sl1.begin(), slit); 239 CPPUNIT_ASSERT( sl1 == sl2 ); 240 241 slit = sl1.begin(); ++slit; 242 sl1.splice(sl1.begin(), sl1, slit, sl1.end()); 243 slit = sl1.begin(); 244 CPPUNIT_ASSERT( *(slit++) == 1 ); 245 CPPUNIT_ASSERT( *(slit++) == 2 ); 246 CPPUNIT_ASSERT( *(slit++) == 3 ); 247 CPPUNIT_ASSERT( *(slit++) == 4 ); 248 CPPUNIT_ASSERT( *slit == 0 ); 249 250 // a no op 251 sl2.splice(sl2.end(), sl2, sl2.begin(), sl2.end()); 252 for (i = 0, slit = sl2.begin(); slit != sl2.end(); ++slit, ++i) { 253 CPPUNIT_ASSERT( i < 5 ); 254 CPPUNIT_ASSERT( *slit == array[i] ); 255 } 256 257 slit = sl2.begin(); 258 advance(slit, 3); 259 sl2.splice(sl2.end(), sl2, sl2.begin(), slit); 260 slit = sl2.begin(); 261 CPPUNIT_ASSERT( *(slit++) == 3 ); 262 CPPUNIT_ASSERT( *(slit++) == 4 ); 263 CPPUNIT_ASSERT( *(slit++) == 0 ); 264 CPPUNIT_ASSERT( *(slit++) == 1 ); 265 CPPUNIT_ASSERT( *slit == 2 ); 266 } 267 268 //splice_after 269 { 270 slist<int> sl1(array, array + 5); 271 slist<int> sl2(array, array + 5); 272 slist<int>::iterator slit; 273 274 //a no op: 275 sl1.splice_after(sl1.begin(), sl1, sl1.begin()); 276 CPPUNIT_ASSERT( sl1 == sl2 ); 277 278 sl1.splice_after(sl1.before_begin(), sl1, sl1.begin()); 279 slit = sl1.begin(); 280 CPPUNIT_ASSERT( *(slit++) == 1 ); 281 CPPUNIT_ASSERT( *(slit++) == 0 ); 282 CPPUNIT_ASSERT( *(slit++) == 2 ); 283 CPPUNIT_ASSERT( *(slit++) == 3 ); 284 CPPUNIT_ASSERT( *slit == 4 ); 285 sl1.splice_after(sl1.before_begin(), sl1, sl1.begin()); 286 CPPUNIT_ASSERT( sl1 == sl2 ); 287 288 sl1.splice_after(sl1.before_begin(), sl2); 289 size_t i; 290 for (i = 0, slit = sl1.begin(); slit != sl1.end(); ++slit, ++i) { 291 if (i == 5) i = 0; 292 CPPUNIT_ASSERT( *slit == array[i] ); 293 } 294 295 slit = sl1.begin(); 296 advance(slit, 4); 297 CPPUNIT_ASSERT( *slit == 4 ); 298 sl2.splice_after(sl2.before_begin(), sl1, sl1.before_begin(), slit); 299 CPPUNIT_ASSERT( sl1 == sl2 ); 300 301 sl1.splice_after(sl1.before_begin(), sl1, sl1.begin(), sl1.previous(sl1.end())); 302 slit = sl1.begin(); 303 CPPUNIT_ASSERT( *(slit++) == 1 ); 304 CPPUNIT_ASSERT( *(slit++) == 2 ); 305 CPPUNIT_ASSERT( *(slit++) == 3 ); 306 CPPUNIT_ASSERT( *(slit++) == 4 ); 307 CPPUNIT_ASSERT( *slit == 0 ); 308 309 // a no op 310 sl2.splice_after(sl2.before_begin(), sl2, sl2.before_begin(), sl2.previous(sl2.end())); 311 for (i = 0, slit = sl2.begin(); slit != sl2.end(); ++slit, ++i) { 312 CPPUNIT_ASSERT( i < 5 ); 313 CPPUNIT_ASSERT( *slit == array[i] ); 314 } 315 316 slit = sl2.begin(); 317 advance(slit, 2); 318 sl2.splice_after(sl2.previous(sl2.end()), sl2, sl2.before_begin(), slit); 319 slit = sl2.begin(); 320 CPPUNIT_ASSERT( *(slit++) == 3 ); 321 CPPUNIT_ASSERT( *(slit++) == 4 ); 322 CPPUNIT_ASSERT( *(slit++) == 0 ); 323 CPPUNIT_ASSERT( *(slit++) == 1 ); 324 CPPUNIT_ASSERT( *slit == 2 ); 325 } 326 #endif 327 } 328 329 330 void SlistTest::allocator_with_state() 331 { 332 #if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) 333 char buf1[1024]; 334 StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1)); 335 336 char buf2[1024]; 337 StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2)); 338 339 typedef slist<int, StackAllocator<int> > SlistInt; 340 { 341 SlistInt slint1(10, 0, stack1); 342 SlistInt slint1Cpy(slint1); 343 344 SlistInt slint2(10, 1, stack2); 345 SlistInt slint2Cpy(slint2); 346 347 slint1.swap(slint2); 348 349 CPPUNIT_ASSERT( slint1.get_allocator().swaped() ); 350 CPPUNIT_ASSERT( slint2.get_allocator().swaped() ); 351 352 CPPUNIT_ASSERT( slint1 == slint2Cpy ); 353 CPPUNIT_ASSERT( slint2 == slint1Cpy ); 354 CPPUNIT_ASSERT( slint1.get_allocator() == stack2 ); 355 CPPUNIT_ASSERT( slint2.get_allocator() == stack1 ); 356 } 357 CPPUNIT_CHECK( stack1.ok() ); 358 CPPUNIT_CHECK( stack2.ok() ); 359 stack1.reset(); stack2.reset(); 360 361 { 362 SlistInt slint1(stack1); 363 SlistInt slint1Cpy(slint1); 364 365 SlistInt slint2(10, 1, stack2); 366 SlistInt slint2Cpy(slint2); 367 368 slint1.swap(slint2); 369 370 CPPUNIT_ASSERT( slint1.get_allocator().swaped() ); 371 CPPUNIT_ASSERT( slint2.get_allocator().swaped() ); 372 373 CPPUNIT_ASSERT( slint1 == slint2Cpy ); 374 CPPUNIT_ASSERT( slint2 == slint1Cpy ); 375 CPPUNIT_ASSERT( slint1.get_allocator() == stack2 ); 376 CPPUNIT_ASSERT( slint2.get_allocator() == stack1 ); 377 } 378 CPPUNIT_CHECK( stack1.ok() ); 379 CPPUNIT_CHECK( stack2.ok() ); 380 stack1.reset(); stack2.reset(); 381 382 { 383 SlistInt slint1(10, 0, stack1); 384 SlistInt slint1Cpy(slint1); 385 386 SlistInt slint2(stack2); 387 SlistInt slint2Cpy(slint2); 388 389 slint1.swap(slint2); 390 391 CPPUNIT_ASSERT( slint1.get_allocator().swaped() ); 392 CPPUNIT_ASSERT( slint2.get_allocator().swaped() ); 393 394 CPPUNIT_ASSERT( slint1 == slint2Cpy ); 395 CPPUNIT_ASSERT( slint2 == slint1Cpy ); 396 CPPUNIT_ASSERT( slint1.get_allocator() == stack2 ); 397 CPPUNIT_ASSERT( slint2.get_allocator() == stack1 ); 398 } 399 CPPUNIT_CHECK( stack1.ok() ); 400 CPPUNIT_CHECK( stack2.ok() ); 401 stack1.reset(); stack2.reset(); 402 403 //splice(iterator, slist) 404 { 405 SlistInt slint1(10, 0, stack1); 406 SlistInt slint2(10, 1, stack2); 407 408 slint1.splice(slint1.begin(), slint2); 409 CPPUNIT_ASSERT( slint1.size() == 20 ); 410 CPPUNIT_ASSERT( slint2.empty() ); 411 } 412 CPPUNIT_CHECK( stack1.ok() ); 413 CPPUNIT_CHECK( stack2.ok() ); 414 stack1.reset(); stack2.reset(); 415 416 //splice(iterator, slist, iterator) 417 { 418 SlistInt slint1(10, 0, stack1); 419 SlistInt slint2(10, 1, stack2); 420 421 slint1.splice(slint1.begin(), slint2, slint2.begin()); 422 CPPUNIT_ASSERT( slint1.size() == 11 ); 423 CPPUNIT_ASSERT( slint2.size() == 9 ); 424 } 425 CPPUNIT_CHECK( stack1.ok() ); 426 CPPUNIT_CHECK( stack2.ok() ); 427 stack1.reset(); stack2.reset(); 428 429 //splice(iterator, slist, iterator, iterator) 430 { 431 SlistInt slint1(10, 0, stack1); 432 SlistInt slint2(10, 1, stack2); 433 434 SlistInt::iterator lit(slint2.begin()); 435 advance(lit, 5); 436 slint1.splice(slint1.begin(), slint2, slint2.begin(), lit); 437 CPPUNIT_ASSERT( slint1.size() == 15 ); 438 CPPUNIT_ASSERT( slint2.size() == 5 ); 439 } 440 CPPUNIT_CHECK( stack1.ok() ); 441 CPPUNIT_CHECK( stack2.ok() ); 442 stack1.reset(); stack2.reset(); 443 444 //splice_after(iterator, slist) 445 { 446 SlistInt slint1(10, 0, stack1); 447 SlistInt slint2(10, 1, stack2); 448 449 slint1.splice_after(slint1.before_begin(), slint2); 450 CPPUNIT_ASSERT( slint1.size() == 20 ); 451 CPPUNIT_ASSERT( slint2.empty() ); 452 } 453 CPPUNIT_CHECK( stack1.ok() ); 454 CPPUNIT_CHECK( stack2.ok() ); 455 stack1.reset(); stack2.reset(); 456 457 //splice_after(iterator, slist, iterator) 458 { 459 SlistInt slint1(10, 0, stack1); 460 SlistInt slint2(10, 1, stack2); 461 462 slint1.splice_after(slint1.before_begin(), slint2, slint2.before_begin()); 463 CPPUNIT_ASSERT( slint1.size() == 11 ); 464 CPPUNIT_ASSERT( slint2.size() == 9 ); 465 } 466 CPPUNIT_CHECK( stack1.ok() ); 467 CPPUNIT_CHECK( stack2.ok() ); 468 stack1.reset(); stack2.reset(); 469 470 //splice_after(iterator, slist, iterator, iterator) 471 { 472 SlistInt slint1(10, 0, stack1); 473 SlistInt slint2(10, 1, stack2); 474 475 SlistInt::iterator lit(slint2.begin()); 476 advance(lit, 4); 477 slint1.splice_after(slint1.before_begin(), slint2, slint2.before_begin(), lit); 478 CPPUNIT_ASSERT( slint1.size() == 15 ); 479 CPPUNIT_ASSERT( slint2.size() == 5 ); 480 } 481 CPPUNIT_CHECK( stack1.ok() ); 482 CPPUNIT_CHECK( stack2.ok() ); 483 stack1.reset(); stack2.reset(); 484 485 //merge(slist) 486 { 487 SlistInt slint1(10, 0, stack1); 488 SlistInt slint2(10, 1, stack2); 489 490 SlistInt slintref(stack2); 491 slintref.insert_after(slintref.before_begin(), 10, 1); 492 slintref.insert_after(slintref.before_begin(), 10, 0); 493 494 slint1.merge(slint2); 495 CPPUNIT_ASSERT( slint1.size() == 20 ); 496 CPPUNIT_ASSERT( slint1 == slintref ); 497 CPPUNIT_ASSERT( slint2.empty() ); 498 } 499 CPPUNIT_CHECK( stack1.ok() ); 500 CPPUNIT_CHECK( stack2.ok() ); 501 502 //merge(slist, predicate) 503 # if (!defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)) && \ 504 (!defined (_MSC_VER) || (_MSC_VER >= 1300)) 505 { 506 SlistInt slint1(10, 0, stack1); 507 SlistInt slint2(10, 1, stack2); 508 509 SlistInt slintref(stack2); 510 slintref.insert_after(slintref.before_begin(), 10, 0); 511 slintref.insert_after(slintref.before_begin(), 10, 1); 512 513 slint1.merge(slint2, greater<int>()); 514 CPPUNIT_ASSERT( slint1.size() == 20 ); 515 CPPUNIT_ASSERT( slint1 == slintref ); 516 CPPUNIT_ASSERT( slint2.empty() ); 517 } 518 CPPUNIT_CHECK( stack1.ok() ); 519 CPPUNIT_CHECK( stack2.ok() ); 520 521 //sort 522 { 523 //This is rather a compile time test. 524 //We check that sort implementation is correct when list is instanciated 525 //with an allocator that do not have a default constructor. 526 SlistInt slint1(stack1); 527 slint1.push_front(1); 528 slint1.insert_after(slint1.before_begin(), 10, 0); 529 greater<int> gt; 530 slint1.sort(gt); 531 CPPUNIT_ASSERT( slint1.front() == 1 ); 532 slint1.sort(); 533 SlistInt::iterator slit(slint1.begin()); 534 advance(slit, 10); 535 CPPUNIT_ASSERT( *slit == 1 ); 536 } 537 # endif 538 #endif 539 } 540 541 #if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) && \ 542 (!defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)) 543 # if !defined (__DMC__) 544 /* Simple compilation test: Check that nested types like iterator 545 * can be access even if type used to instanciate container is not 546 * yet completely defined. 547 */ 548 class IncompleteClass 549 { 550 slist<IncompleteClass> instances; 551 typedef slist<IncompleteClass>::iterator it; 552 }; 553 # endif 554 #endif 555
