sw/qa/core/Test-BigPtrArray.cxx

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