sw/qa/core/Test-BigPtrArray.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: Test-BigPtrArray.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sw.hxx"
  33 #define TIMELOG
  34
  35 #include <cppunit/simpleheader.hxx>
  36 #include <bparr.hxx>
  37 #include <string>
  38 #include <stdlib.h>
  39 #include <rtl/logfile.hxx>
  40
  41 #undef ENABLE_DEBUG_OUTPUT
  42
  43 using namespace std;
  44
  45
  46 namespace /* private */
  47 {
  48     const int NUM_ENTRIES = 100000;
  49
  50     class BigPtrEntryMock : public BigPtrEntry
  51     {
  52     public:
  53         BigPtrEntryMock(int count) : count_(count)
  54         {
  55         }
  56
  57         ~BigPtrEntryMock()
  58         {
  59         #ifdef ENABLE_DEBUG_OUTPUT
  60             printf("Destructor called (%i)\n", count_);
  61         #endif
  62         }
  63
  64         int getCount() const
  65         {
  66             return count_;
  67         }
  68
  69         void setCount(int newCount)
  70         {
  71             count_ = newCount;
  72         }
  73
  74         ULONG Position() const
  75         {
  76             return GetPos();
  77         }
  78
  79     private:
  80         int count_;
  81     };
  82
  83     BOOL AddToCount(const ElementPtr& rElem, void* pArgs)
  84     {
  85         BigPtrEntryMock* const pbem = static_cast<BigPtrEntryMock* const>(rElem);
  86         pbem->setCount(pbem->getCount() + *((int*)pArgs));
  87         return true;
  88     }
  89
  90     void dumpBigPtrArray(const BigPtrArray& bparr)
  91     {
  92     #ifdef ENABLE_DEBUG_OUTPUT
  93         for (int i = 0; i < bparr.Count(); i++)
  94             printf("bparr[%i,%i]: %i\n", i, static_cast<BigPtrEntryMock*>(bparr[i])->Position(), static_cast<BigPtrEntryMock*>(bparr[i])->getCount());
  95
  96         printf("\n");
  97     #endif
  98     }
  99
 100     void fillBigPtrArray(BigPtrArray& bparr, ULONG numEntries)
 101     {
 102         for (int i = 0; i < numEntries; i++)
 103             bparr.Insert(new BigPtrEntryMock(i), bparr.Count());
 104     }
 105
 106     void printMethodName(const char* name)
 107     {
 108     #ifdef ENABLE_DEBUG_OUTPUT
 109         printf(name);
 110     #endif
 111     }
 112
 113     bool checkElementPositions(const BigPtrArray& bparr)
 114     {
 115         for (int i = 0; i < bparr.Count(); i++)
 116         {
 117             if (static_cast<BigPtrEntryMock*>(bparr[i])->Position() != i)
 118                 return false;
 119         }
 120         return true;
 121     }
 122
 123     void releaseBigPtrArrayContent(BigPtrArray& bparr)
 124     {
 125         for (int i = 0; i < bparr.Count(); i++)
 126             delete bparr[i];
 127     }
 128
 129     RTL_LOGFILE_CONTEXT(logFile, "BigPtrArray performance measures" );
 130 }
 131
 132 class BigPtrArrayUnittest : public CppUnit::TestFixture
 133 {
 134 public:
 135
 136     BigPtrArrayUnittest()
 137     {
 138     }
 139
 140     /** Test constructor/destructor
 141         The size of the BigPtrArray
 142         aka the 'Count' should be 0
 143         initially.
 144     */
 145     void test_ctor()
 146     {
 147         printMethodName("test_ctor\n");
 148
 149         BigPtrArray bparr;
 150
 151         CPPUNIT_ASSERT_MESSAGE
 152         (
 153             "BigPtrArray ctor failed",
 154             bparr.Count() == 0
 155         );
 156     }
 157
 158     void test_insert_entries_at_front()
 159     {
 160         printMethodName("test_insert_entries_at_front\n");
 161
 162         RTL_LOGFILE_CONTEXT_TRACE(logFile, "START: test_insert_entries_at_front");
 163
 164         BigPtrArray bparr;
 165
 166         for (int i = 0; i < NUM_ENTRIES; i++)
 167         {
 168             ULONG oldCount = bparr.Count();
 169             bparr.Insert(new BigPtrEntryMock(i), 0);
 170             CPPUNIT_ASSERT_MESSAGE
 171             (
 172                 "test_insert_entries_at_front failed",
 173                 (bparr.Count() == oldCount + 1)
 174             )
 175         }
 176
 177         RTL_LOGFILE_CONTEXT_TRACE(logFile, "END: test_insert_entries_at_front");
 178
 179         for (int i = 0, j = NUM_ENTRIES - 1; i < NUM_ENTRIES; i++, j--)
 180         {
 181             CPPUNIT_ASSERT_MESSAGE
 182             (
 183                 "test_insert_entries_at_front failed",
 184                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == j
 185             )
 186         }
 187
 188         CPPUNIT_ASSERT_MESSAGE
 189         (
 190             "test_insert_entries_at_front failed",
 191             checkElementPositions(bparr)
 192         )
 193
 194         releaseBigPtrArrayContent(bparr);
 195         dumpBigPtrArray(bparr);
 196     }
 197
 198     void test_insert_entries_in_the_middle()
 199     {
 200         printMethodName("test_insert_entries_in_the_middle\n");
 201
 202         RTL_LOGFILE_CONTEXT_TRACE(logFile, "START: test_insert_entries_in_the_middle");
 203
 204         BigPtrArray bparr;
 205
 206         fillBigPtrArray(bparr, NUM_ENTRIES);
 207         dumpBigPtrArray(bparr);
 208
 209         ULONG oldCount = bparr.Count();
 210
 211         bparr.Insert(new BigPtrEntryMock(NUM_ENTRIES), bparr.Count() / 2);
 212
 213         RTL_LOGFILE_CONTEXT_TRACE(logFile, "END: test_insert_entries_in_the_middle");
 214
 215         CPPUNIT_ASSERT_MESSAGE
 216         (
 217             "test_insert_entries_in_the_middle failed",
 218             (oldCount + 1 == bparr.Count() && static_cast<BigPtrEntryMock*>(bparr[bparr.Count() / 2])->getCount() == NUM_ENTRIES)
 219         )
 220
 221         CPPUNIT_ASSERT_MESSAGE
 222         (
 223             "test_insert_entries_in_the_middle failed",
 224             checkElementPositions(bparr)
 225         )
 226
 227         releaseBigPtrArrayContent(bparr);
 228         dumpBigPtrArray(bparr);
 229     }
 230
 231     void test_insert_at_already_used_index()
 232     {
 233         printMethodName("test_insert_at_already_used_index\n");
 234
 235         RTL_LOGFILE_CONTEXT_TRACE(logFile, "START: test_insert_at_already_used_index");
 236
 237         BigPtrArray bparr;
 238
 239         fillBigPtrArray(bparr, NUM_ENTRIES);
 240         dumpBigPtrArray(bparr);
 241
 242         int oldCount = bparr.Count();
 243
 244         for (int i = 0, j = -5; i < 5; i++, j++)
 245             bparr.Insert(new BigPtrEntryMock(j), i);
 246
 247         RTL_LOGFILE_CONTEXT_TRACE(logFile, "END: test_insert_at_already_used_index");
 248
 249         CPPUNIT_ASSERT_MESSAGE
 250         (
 251             "test_insert_at_already_used_index failed",
 252             (oldCount + 5 == bparr.Count())
 253         )
 254
 255         for (int i = 0, j = -5; i < bparr.Count(); i++, j++)
 256         {
 257             CPPUNIT_ASSERT_MESSAGE
 258             (
 259                 "test_insert_at_already_used_index failed",
 260                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == j
 261             )
 262         }
 263
 264         CPPUNIT_ASSERT_MESSAGE
 265         (
 266             "test_insert_at_already_used_index failed",
 267             checkElementPositions(bparr)
 268         )
 269
 270         releaseBigPtrArrayContent(bparr);
 271         dumpBigPtrArray(bparr);
 272     }
 273
 274     void test_insert_at_end()
 275     {
 276         printMethodName("test_insert_at_end\n");
 277
 278         BigPtrArray bparr;
 279
 280         fillBigPtrArray(bparr, NUM_ENTRIES);
 281         dumpBigPtrArray(bparr);
 282
 283         ULONG oldCount = bparr.Count();
 284         bparr.Insert(new BigPtrEntryMock(NUM_ENTRIES), bparr.Count());
 285
 286         CPPUNIT_ASSERT_MESSAGE
 287         (
 288             "test_insert_at_end failed",
 289             (oldCount + 1 == bparr.Count() && static_cast<BigPtrEntryMock*>(bparr[bparr.Count()-1])->getCount() == NUM_ENTRIES)
 290         )
 291
 292         CPPUNIT_ASSERT_MESSAGE
 293         (
 294             "test_insert_at_end failed",
 295             checkElementPositions(bparr)
 296         )
 297
 298         releaseBigPtrArrayContent(bparr);
 299         dumpBigPtrArray(bparr);
 300     }
 301
 302     void test_remove_at_front()
 303     {
 304         printMethodName("test_remove_at_front\n");
 305
 306         RTL_LOGFILE_CONTEXT_TRACE(logFile, "START: test_remove_at_front");
 307
 308         BigPtrArray bparr;
 309
 310         fillBigPtrArray(bparr, NUM_ENTRIES);
 311         dumpBigPtrArray(bparr);
 312
 313         for (int i = 0; i < NUM_ENTRIES; i++)
 314         {
 315             ULONG oldCount = bparr.Count();
 316
 317             delete bparr[0]; // release content
 318             bparr.Remove(0); // remove item from container
 319
 320             CPPUNIT_ASSERT_MESSAGE
 321             (
 322                 "test_remove_at_front failed (wrong count)",
 323                 (oldCount - 1 == bparr.Count())
 324             )
 325
 326             for (int j = 0, k = i + 1; j < bparr.Count(); j++, k++)
 327             {
 328                 CPPUNIT_ASSERT_MESSAGE
 329                 (
 330                     "test_remove_at_front failed",
 331                     static_cast<BigPtrEntryMock*>(bparr[j])->getCount() == k
 332                 )
 333             }
 334
 335             CPPUNIT_ASSERT_MESSAGE
 336             (
 337                 "test_remove_at_front failed",
 338                 checkElementPositions(bparr)
 339             )
 340
 341             dumpBigPtrArray(bparr);
 342         }
 343
 344         RTL_LOGFILE_CONTEXT_TRACE(logFile, "END: test_remove_at_front");
 345     }
 346
 347     void test_remove_at_back()
 348     {
 349         printMethodName("test_remove_at_back\n");
 350
 351         BigPtrArray bparr;
 352
 353         fillBigPtrArray(bparr, NUM_ENTRIES);
 354         dumpBigPtrArray(bparr);
 355
 356         for (int i = NUM_ENTRIES - 1; i >= 0; i--)
 357         {
 358             ULONG oldCount = bparr.Count();
 359             delete bparr[i];
 360             bparr.Remove(i);
 361
 362             CPPUNIT_ASSERT_MESSAGE
 363             (
 364                 "test_remove_at_back failed (wrong count)",
 365                 (oldCount - 1 == bparr.Count())
 366             )
 367
 368             for (int j = 0; j < bparr.Count(); j++)
 369             {
 370                 CPPUNIT_ASSERT_MESSAGE
 371                 (
 372                     "test_remove_at_back failed",
 373                     static_cast<BigPtrEntryMock*>(bparr[j])->getCount() == j
 374                 )
 375             }
 376
 377             CPPUNIT_ASSERT_MESSAGE
 378             (
 379                 "test_remove_at_back failed",
 380                 checkElementPositions(bparr)
 381             )
 382
 383             dumpBigPtrArray(bparr);
 384         }
 385     }
 386
 387     void test_remove_in_the_middle()
 388     {
 389         printMethodName("test_remove_in_the_middle\n");
 390
 391         RTL_LOGFILE_CONTEXT_TRACE(logFile, "START: test_remove_in_the_middle");
 392
 393         BigPtrArray bparr;
 394
 395         fillBigPtrArray(bparr, NUM_ENTRIES);
 396         dumpBigPtrArray(bparr);
 397
 398         while (bparr.Count())
 399         {
 400             ULONG oldCount = bparr.Count();
 401             int oldElement = static_cast<BigPtrEntryMock*>(bparr[bparr.Count() / 2])->getCount();
 402
 403             delete bparr[bparr.Count() / 2];
 404             bparr.Remove(bparr.Count() / 2);
 405
 406             CPPUNIT_ASSERT_MESSAGE
 407             (
 408                 "test_remove_in_the_middle failed (wrong count)",
 409                 (oldCount - 1 == bparr.Count())
 410             )
 411
 412             for (int i = 0; i < bparr.Count(); i++)
 413             {
 414                 CPPUNIT_ASSERT_MESSAGE
 415                 (
 416                     "test_remove_in_the_middle failed",
 417                     static_cast<BigPtrEntryMock*>(bparr[i])->getCount() != oldElement
 418                 )
 419             }
 420
 421             CPPUNIT_ASSERT_MESSAGE
 422             (
 423                 "test_remove_in_the_middle failed",
 424                 checkElementPositions(bparr)
 425             )
 426
 427             dumpBigPtrArray(bparr);
 428         }
 429         RTL_LOGFILE_CONTEXT_TRACE(logFile, "END: test_remove_in_the_middle");
 430     }
 431
 432     void test_remove_multiple_elements_at_once()
 433     {
 434         printMethodName("test_remove_multiple_elements_at_once\n");
 435
 436         BigPtrArray bparr;
 437
 438         fillBigPtrArray(bparr, NUM_ENTRIES);
 439         dumpBigPtrArray(bparr);
 440
 441         while(bparr.Count())
 442         {
 443             ULONG nRemove = (bparr.Count() > 3) ? 3 : bparr.Count();
 444             ULONG oldCount = bparr.Count();
 445
 446             for (int i = 0; i < nRemove; i++)
 447                 delete bparr[i];
 448
 449             bparr.Remove(0, nRemove);
 450
 451             CPPUNIT_ASSERT_MESSAGE
 452             (
 453                 "test_remove_multiple_elements_at_once failed",
 454                 (oldCount - nRemove == bparr.Count())
 455             )
 456
 457             CPPUNIT_ASSERT_MESSAGE
 458             (
 459                 "test_remove_multiple_elements_at_once failed",
 460                 checkElementPositions(bparr)
 461             )
 462
 463             dumpBigPtrArray(bparr);
 464         }
 465     }
 466
 467     void test_remove_all_elements_at_once()
 468     {
 469         printMethodName("test_remove_all_elements_at_once\n");
 470
 471         BigPtrArray bparr;
 472
 473         fillBigPtrArray(bparr, NUM_ENTRIES);
 474         dumpBigPtrArray(bparr);
 475
 476         releaseBigPtrArrayContent(bparr);
 477         bparr.Remove(0, bparr.Count());
 478
 479         CPPUNIT_ASSERT_MESSAGE
 480         (
 481             "test_remove_all_elements_at_once failed",
 482             bparr.Count() == 0
 483         )
 484
 485         dumpBigPtrArray(bparr);
 486     }
 487
 488     void test_move_elements_from_lower_to_higher_pos()
 489     {
 490         printMethodName("test_move_elements_from_lower_to_higher_pos\n");
 491
 492         BigPtrArray bparr;
 493
 494         fillBigPtrArray(bparr, NUM_ENTRIES);
 495         dumpBigPtrArray(bparr);
 496
 497         for (int i = 0; i < NUM_ENTRIES - 1; i++)
 498         {
 499             bparr.Move(i, i + 2);
 500             dumpBigPtrArray(bparr);
 501         }
 502
 503         for (int i = 0; i < (NUM_ENTRIES - 1); i++)
 504         {
 505             CPPUNIT_ASSERT_MESSAGE
 506             (
 507                 "test_move_elements_from_lower_to_higher_pos failed",
 508                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i + 1)
 509             )
 510         }
 511
 512         CPPUNIT_ASSERT_MESSAGE
 513         (
 514             "test_move_elements_from_lower_to_higher_pos failed",
 515             static_cast<BigPtrEntryMock*>(bparr[NUM_ENTRIES -1])->getCount() == 0
 516         )
 517
 518         CPPUNIT_ASSERT_MESSAGE
 519         (
 520             "test_move_elements_from_lower_to_higher_pos failed",
 521             checkElementPositions(bparr)
 522         )
 523
 524         releaseBigPtrArrayContent(bparr);
 525     }
 526
 527     void test_move_elements_from_higher_to_lower_pos()
 528     {
 529         printMethodName("test_move_elements_from_higher_to_lower_pos\n");
 530
 531         BigPtrArray bparr;
 532
 533         fillBigPtrArray(bparr, NUM_ENTRIES);
 534         dumpBigPtrArray(bparr);
 535
 536         for (int i = NUM_ENTRIES - 1; i >= 1; i--)
 537         {
 538             bparr.Move(i, i - 1);
 539             dumpBigPtrArray(bparr);
 540         }
 541
 542         CPPUNIT_ASSERT_MESSAGE
 543         (
 544             "test_move_elements_from_higher_to_lower_pos failed",
 545             static_cast<BigPtrEntryMock*>(bparr[0])->getCount() == (NUM_ENTRIES - 1)
 546         )
 547
 548         for (int i = 1; i < NUM_ENTRIES; i++)
 549         {
 550             CPPUNIT_ASSERT_MESSAGE
 551             (
 552                 "test_move_elements_from_higher_to_lower_pos failed",
 553                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i - 1)
 554             )
 555         }
 556
 557         CPPUNIT_ASSERT_MESSAGE
 558         (
 559             "test_move_elements_from_higher_to_lower_pos failed",
 560             checkElementPositions(bparr)
 561         )
 562
 563         releaseBigPtrArrayContent(bparr);
 564     }
 565
 566     void test_move_to_same_position()
 567     {
 568         printMethodName("test_move_to_same_position\n");
 569
 570         BigPtrArray bparr;
 571
 572         fillBigPtrArray(bparr, NUM_ENTRIES);
 573         dumpBigPtrArray(bparr);
 574
 575         for (int i = 0; i < NUM_ENTRIES; i++)
 576         {
 577             bparr.Move(i, i);
 578         }
 579
 580         dumpBigPtrArray(bparr);
 581
 582         for (int i = 0; i < NUM_ENTRIES; i++)
 583         {
 584             CPPUNIT_ASSERT_MESSAGE
 585             (
 586                 "test_move_to_same_position failed",
 587                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == i
 588             )
 589         }
 590
 591         CPPUNIT_ASSERT_MESSAGE
 592         (
 593             "test_move_to_same_position failed",
 594             checkElementPositions(bparr)
 595         )
 596
 597         releaseBigPtrArrayContent(bparr);
 598         dumpBigPtrArray(bparr);
 599     }
 600
 601     void test_replace_elements()
 602     {
 603         printMethodName("test_replace_elements\n");
 604
 605         BigPtrArray bparr;
 606
 607         fillBigPtrArray(bparr, NUM_ENTRIES);
 608         dumpBigPtrArray(bparr);
 609
 610         for (int i = 0, j = NUM_ENTRIES - 1; i < NUM_ENTRIES; i++, j--)
 611         {
 612             delete bparr[i];
 613             bparr.Replace(i, new BigPtrEntryMock(j));
 614             dumpBigPtrArray(bparr);
 615         }
 616
 617         for (int i = 0; i < NUM_ENTRIES; i++)
 618         {
 619             CPPUNIT_ASSERT_MESSAGE
 620             (
 621                 "test_replace_elements failed",
 622                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (NUM_ENTRIES - i - 1)
 623             )
 624         }
 625
 626         CPPUNIT_ASSERT_MESSAGE
 627         (
 628             "test_replace_elements failed",
 629             checkElementPositions(bparr)
 630         )
 631
 632         releaseBigPtrArrayContent(bparr);
 633     }
 634
 635     void test_for_each()
 636     {
 637         printMethodName("test_for_each\n");
 638
 639         BigPtrArray bparr;
 640
 641         fillBigPtrArray(bparr, NUM_ENTRIES);
 642         dumpBigPtrArray(bparr);
 643
 644         int addCount = 1;
 645         bparr.ForEach(AddToCount, &addCount);
 646
 647         for (int i = 0; i < NUM_ENTRIES; i++)
 648         {
 649             CPPUNIT_ASSERT_MESSAGE
 650             (
 651                 "test_for_each failed",
 652                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i+1)
 653             )
 654         }
 655
 656         releaseBigPtrArrayContent(bparr);
 657         dumpBigPtrArray(bparr);
 658     }
 659
 660     void test_for_some1()
 661     {
 662          printMethodName("test_for_some1\n");
 663
 664         BigPtrArray bparr;
 665
 666         fillBigPtrArray(bparr, NUM_ENTRIES);
 667         dumpBigPtrArray(bparr);
 668
 669         int addCount = 1;
 670         bparr.ForEach(0, NUM_ENTRIES / 2, AddToCount, &addCount);
 671
 672         int i = 0;
 673         for (/* */; i < NUM_ENTRIES / 2; i++)
 674         {
 675             CPPUNIT_ASSERT_MESSAGE
 676             (
 677                 "test_for_some1 failed",
 678                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i+1)
 679             )
 680         }
 681
 682         for (/* */; i < NUM_ENTRIES; i++)
 683         {
 684             CPPUNIT_ASSERT_MESSAGE
 685             (
 686                 "test_for_some1 failed",
 687                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i)
 688             )
 689         }
 690
 691         releaseBigPtrArrayContent(bparr);
 692         dumpBigPtrArray(bparr);
 693     }
 694
 695     void test_for_some2()
 696     {
 697         printMethodName("test_for_some2\n");
 698
 699         BigPtrArray bparr;
 700
 701         fillBigPtrArray(bparr, NUM_ENTRIES);
 702         dumpBigPtrArray(bparr);
 703
 704         int addCount = 1;
 705         bparr.ForEach(NUM_ENTRIES / 2, NUM_ENTRIES, AddToCount, &addCount);
 706
 707         int i = 0;
 708         for (/* */; i < NUM_ENTRIES / 2; i++)
 709         {
 710             CPPUNIT_ASSERT_MESSAGE
 711             (
 712                 "test_for_some2 failed",
 713                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i)
 714             )
 715         }
 716
 717         for (/* */; i < NUM_ENTRIES; i++)
 718         {
 719             CPPUNIT_ASSERT_MESSAGE
 720             (
 721                 "test_for_some2 failed",
 722                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i+1)
 723             )
 724         }
 725
 726         releaseBigPtrArrayContent(bparr);
 727         dumpBigPtrArray(bparr);
 728     }
 729
 730     void test_for_some3()
 731     {
 732         printMethodName("test_for_some3\n");
 733
 734         BigPtrArray bparr;
 735
 736         fillBigPtrArray(bparr, NUM_ENTRIES);
 737         dumpBigPtrArray(bparr);
 738
 739         int addCount = 1;
 740         bparr.ForEach(0, 0, AddToCount, &addCount);
 741
 742         for (int i = 0; i < NUM_ENTRIES; i++)
 743         {
 744             CPPUNIT_ASSERT_MESSAGE
 745             (
 746                 "test_for_some3 failed",
 747                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == i
 748             )
 749         }
 750         releaseBigPtrArrayContent(bparr);
 751     }
 752
 753     CPPUNIT_TEST_SUITE(BigPtrArrayUnittest);
 754     CPPUNIT_TEST(test_ctor);
 755     CPPUNIT_TEST(test_insert_entries_at_front);
 756     CPPUNIT_TEST(test_insert_entries_in_the_middle);
 757     CPPUNIT_TEST(test_insert_at_already_used_index);
 758     CPPUNIT_TEST(test_insert_at_end);
 759     CPPUNIT_TEST(test_remove_at_front);
 760     CPPUNIT_TEST(test_remove_at_back);
 761     CPPUNIT_TEST(test_remove_in_the_middle);
 762     CPPUNIT_TEST(test_remove_multiple_elements_at_once);
 763     CPPUNIT_TEST(test_remove_all_elements_at_once);
 764     CPPUNIT_TEST(test_move_elements_from_lower_to_higher_pos);
 765     CPPUNIT_TEST(test_move_elements_from_higher_to_lower_pos);
 766     CPPUNIT_TEST(test_replace_elements);
 767     CPPUNIT_TEST(test_for_each);
 768     CPPUNIT_TEST(test_for_some1);
 769     CPPUNIT_TEST(test_for_some2);
 770     CPPUNIT_TEST(test_for_some3);
 771     CPPUNIT_TEST_SUITE_END();
 772 };
 773
 774 const char* START = "START: ";
 775 const char* END = "END: ";
 776
 777 class PerformanceTracer
 778 {
 779 public:
 780
 781 public:
 782     PerformanceTracer(const string& methodName) :
 783         startString_(START),
 784         endString_(END)
 785     {
 786         startString_ += methodName;
 787         endString_ += methodName;
 788         RTL_LOGFILE_CONTEXT_TRACE(logFile, startString_.c_str());
 789     }
 790
 791     ~PerformanceTracer()
 792     {
 793         RTL_LOGFILE_CONTEXT_TRACE(logFile, endString_.c_str());
 794     }
 795
 796 private:
 797     string startString_;
 798     string endString_;
 799 };
 800
 801 class BigPtrArrayPerformanceTest : public CppUnit::TestFixture
 802 {
 803 public:
 804     BigPtrArrayPerformanceTest()
 805     {
 806     }
 807
 808     void test_insert_at_end_1000()
 809     { test_insert_at_end("1000"); }
 810
 811     void test_insert_at_end_10000()
 812     { test_insert_at_end("10000"); }
 813
 814     void test_insert_at_end_100000()
 815     { test_insert_at_end("100000"); }
 816
 817     void test_insert_at_end_1000000()
 818     { test_insert_at_end("1000000"); }
 819
 820     void test_insert_at_front_1000()
 821     { test_insert_at_front("1000"); }
 822
 823     void test_insert_at_front_10000()
 824     { test_insert_at_front("10000"); }
 825
 826     void test_insert_at_front_100000()
 827     { test_insert_at_front("100000"); }
 828
 829     void test_insert_at_front_1000000()
 830     { test_insert_at_front("1000000"); }
 831
 832     CPPUNIT_TEST_SUITE(BigPtrArrayPerformanceTest);
 833     CPPUNIT_TEST(test_insert_at_end_1000);
 834     CPPUNIT_TEST(test_insert_at_end_10000);
 835     CPPUNIT_TEST(test_insert_at_end_100000);
 836     CPPUNIT_TEST(test_insert_at_end_1000000);
 837     CPPUNIT_TEST(test_insert_at_front_1000);
 838     CPPUNIT_TEST(test_insert_at_front_10000);
 839     CPPUNIT_TEST(test_insert_at_front_100000);
 840     CPPUNIT_TEST(test_insert_at_front_1000000);
 841     CPPUNIT_TEST_SUITE_END();
 842
 843 private:
 844     void test_insert_at_end(const char* numElements)
 845     {
 846         char buff[100] = { 0 };
 847         strcat(buff, "test_insert_at_end ");
 848         strcat(buff, numElements);
 849         int n = atoi(numElements);
 850         PerformanceTracer tracer(buff);
 851         BigPtrArray bparr;
 852         for (int i = 0; i < n; i++)
 853             bparr.Insert(new BigPtrEntryMock(i), bparr.Count());
 854
 855         releaseBigPtrArrayContent(bparr);
 856     }
 857
 858     void test_insert_at_front(const char* numElements)
 859     {
 860         char buff[100] = { 0 };
 861         strcat(buff, "test_insert_at_front ");
 862         strcat(buff, numElements);
 863         int n = atoi(numElements);
 864         PerformanceTracer tracer(buff);
 865         BigPtrArray bparr;
 866         for (int i = 0; i < n; i++)
 867             bparr.Insert(new BigPtrEntryMock(i), 0);
 868
 869         releaseBigPtrArrayContent(bparr);
 870     }
 871 };
 872
 873
 874 //#####################################
 875 // register test suites
 876 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(BigPtrArrayUnittest, "BigPtrArrayUnittest");
 877 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(BigPtrArrayPerformanceTest, "BigPtrArrayPerformanceTest");
 878
 879 NOADDITIONAL;
 880