LCOV - code coverage report
Current view: top level - sw/qa/core - Test-BigPtrArray.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 267 268 99.6 %
Date: 2014-11-03 Functions: 32 32 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <rtl/strbuf.hxx>
      22             : #include <cppunit/TestAssert.h>
      23             : #include <cppunit/TestFixture.h>
      24             : #include <cppunit/extensions/HelperMacros.h>
      25             : #include <cppunit/plugin/TestPlugIn.h>
      26             : 
      27             : //#define TIMELOG for measuring performance
      28             : 
      29             : #include <string.h>
      30             : #include <stdlib.h>
      31             : 
      32             : #include <bparr.hxx>
      33             : #include <ndarr.hxx>
      34             : 
      35             : using namespace std;
      36             : 
      37             : namespace /* private */
      38             : {
      39             :     const sal_uLong NUM_ENTRIES = 10;
      40             : 
      41             :     class BigPtrEntryMock : public BigPtrEntry
      42             :     {
      43             :     public:
      44         294 :         BigPtrEntryMock(sal_uLong count) : count_(count)
      45             :         {
      46         294 :         }
      47             : 
      48         588 :         virtual ~BigPtrEntryMock()
      49         294 :         {
      50         588 :         }
      51             : 
      52         424 :         sal_uLong getCount() const
      53             :         {
      54         424 :             return count_;
      55             :         }
      56             : 
      57         468 :         sal_uLong Position() const
      58             :         {
      59         468 :             return GetPos();
      60             :         }
      61             : 
      62             :     private:
      63             :         sal_uLong count_;
      64             :     };
      65             : 
      66         162 :     void dumpBigPtrArray(const BigPtrArray& bparr)
      67             :     {
      68             :         (void)bparr;
      69         162 :     }
      70             : 
      71          24 :     void fillBigPtrArray(BigPtrArray& bparr, sal_uLong numEntries)
      72             :     {
      73         264 :         for (sal_uLong i = 0; i < numEntries; i++)
      74         240 :             bparr.Insert(new BigPtrEntryMock(i), bparr.Count());
      75          24 :     }
      76             : 
      77          28 :     void printMethodName(const char* name)
      78             :     {
      79             :         (void)name;
      80          28 :     }
      81             : 
      82          84 :     bool checkElementPositions(const BigPtrArray& bparr)
      83             :     {
      84         552 :         for (sal_uLong i = 0; i < bparr.Count(); i++)
      85             :         {
      86         468 :             if (static_cast<BigPtrEntryMock*>(bparr[i])->Position() != i)
      87           0 :                 return false;
      88             :         }
      89          84 :         return true;
      90             :     }
      91             : 
      92          18 :     void releaseBigPtrArrayContent(BigPtrArray& bparr)
      93             :     {
      94         212 :         for (sal_uLong i = 0; i < bparr.Count(); i++)
      95         194 :             delete bparr[i];
      96          18 :     }
      97             : }
      98             : 
      99          56 : class BigPtrArrayUnittest : public CppUnit::TestFixture
     100             : {
     101             : public:
     102             : 
     103          28 :     BigPtrArrayUnittest()
     104          28 :     {
     105          28 :     }
     106             : 
     107             :     /** Test constructor/destructor
     108             :         The size of the BigPtrArray
     109             :         aka the 'Count' should be 0
     110             :         initially.
     111             :     */
     112           2 :     void test_ctor()
     113             :     {
     114           2 :         printMethodName("test_ctor\n");
     115             : 
     116           2 :         BigPtrArray bparr;
     117             : 
     118           4 :         CPPUNIT_ASSERT_MESSAGE
     119             :         (
     120             :             "BigPtrArray ctor failed",
     121             :             bparr.Count() == 0
     122           4 :         );
     123           2 :     }
     124             : 
     125           2 :     void test_insert_entries_at_front()
     126             :     {
     127           2 :         printMethodName("test_insert_entries_at_front\n");
     128             : 
     129           2 :         BigPtrArray bparr;
     130             : 
     131          22 :         for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
     132             :         {
     133          20 :             sal_uLong oldCount = bparr.Count();
     134          20 :             bparr.Insert(new BigPtrEntryMock(i), 0);
     135          40 :             CPPUNIT_ASSERT_MESSAGE
     136             :             (
     137             :                 "test_insert_entries_at_front failed",
     138             :                 (bparr.Count() == oldCount + 1)
     139          20 :             );
     140             :         }
     141             : 
     142          22 :         for (sal_uLong i = 0, j = NUM_ENTRIES - 1; i < NUM_ENTRIES; i++, j--)
     143             :         {
     144          40 :             CPPUNIT_ASSERT_MESSAGE
     145             :             (
     146             :                 "test_insert_entries_at_front failed",
     147             :                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == j
     148          20 :             );
     149             :         }
     150             : 
     151           4 :         CPPUNIT_ASSERT_MESSAGE
     152             :         (
     153             :             "test_insert_entries_at_front failed",
     154             :             checkElementPositions(bparr)
     155           2 :         );
     156             : 
     157           2 :         releaseBigPtrArrayContent(bparr);
     158           2 :         dumpBigPtrArray(bparr);
     159           2 :     }
     160             : 
     161           2 :     void test_insert_entries_in_the_middle()
     162             :     {
     163           2 :         printMethodName("test_insert_entries_in_the_middle\n");
     164             : 
     165           2 :         BigPtrArray bparr;
     166             : 
     167           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     168           2 :         dumpBigPtrArray(bparr);
     169             : 
     170           2 :         sal_uLong oldCount = bparr.Count();
     171             : 
     172           2 :         bparr.Insert(new BigPtrEntryMock(NUM_ENTRIES), bparr.Count() / 2);
     173             : 
     174           4 :         CPPUNIT_ASSERT_MESSAGE
     175             :         (
     176             :             "test_insert_entries_in_the_middle failed",
     177             :             (oldCount + 1 == bparr.Count() && static_cast<BigPtrEntryMock*>(bparr[bparr.Count() / 2])->getCount() == NUM_ENTRIES)
     178           2 :         );
     179             : 
     180           4 :         CPPUNIT_ASSERT_MESSAGE
     181             :         (
     182             :             "test_insert_entries_in_the_middle failed",
     183             :             checkElementPositions(bparr)
     184           2 :         );
     185             : 
     186           2 :         releaseBigPtrArrayContent(bparr);
     187           2 :         dumpBigPtrArray(bparr);
     188           2 :     }
     189             : 
     190           2 :     void test_insert_at_already_used_index()
     191             :     {
     192           2 :         printMethodName("test_insert_at_already_used_index\n");
     193             : 
     194           2 :         BigPtrArray bparr;
     195             : 
     196           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     197           2 :         dumpBigPtrArray(bparr);
     198             : 
     199           2 :         const sal_uLong oldCount = bparr.Count();
     200             : 
     201             :         // insert 5 elements
     202          12 :         for (sal_uLong i = 0, j = 30; i < 5; i++, j++)
     203          10 :             bparr.Insert(new BigPtrEntryMock(j), i);
     204             : 
     205           4 :         CPPUNIT_ASSERT_MESSAGE
     206             :         (
     207             :             "test_insert_at_already_used_index failed",
     208             :             (oldCount + 5 == bparr.Count())
     209           2 :         );
     210             : 
     211             :         // now, first 5 elements have counts: 30,31,..34
     212             :         // next 10 elements have counts: 0,1,..9
     213          32 :         for (sal_uLong i = 0, j = 30; i < bparr.Count(); i++, j++)
     214             :         {
     215          60 :             CPPUNIT_ASSERT_MESSAGE
     216             :             (
     217             :                 "test_insert_at_already_used_index failed",
     218             :                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i < 5 ? j : i - 5)
     219          30 :             );
     220             :         }
     221             : 
     222           4 :         CPPUNIT_ASSERT_MESSAGE
     223             :         (
     224             :             "test_insert_at_already_used_index failed",
     225             :             checkElementPositions(bparr)
     226           2 :         );
     227             : 
     228           2 :         releaseBigPtrArrayContent(bparr);
     229           2 :         dumpBigPtrArray(bparr);
     230           2 :     }
     231             : 
     232           2 :     void test_insert_at_end()
     233             :     {
     234           2 :         printMethodName("test_insert_at_end\n");
     235             : 
     236           2 :         BigPtrArray bparr;
     237             : 
     238           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     239           2 :         dumpBigPtrArray(bparr);
     240             : 
     241           2 :         sal_uLong oldCount = bparr.Count();
     242           2 :         bparr.Insert(new BigPtrEntryMock(NUM_ENTRIES), bparr.Count());
     243             : 
     244           4 :         CPPUNIT_ASSERT_MESSAGE
     245             :         (
     246             :             "test_insert_at_end failed",
     247             :             (oldCount + 1 == bparr.Count() && static_cast<BigPtrEntryMock*>(bparr[bparr.Count()-1])->getCount() == NUM_ENTRIES)
     248           2 :         );
     249             : 
     250           4 :         CPPUNIT_ASSERT_MESSAGE
     251             :         (
     252             :             "test_insert_at_end failed",
     253             :             checkElementPositions(bparr)
     254           2 :         );
     255             : 
     256           2 :         releaseBigPtrArrayContent(bparr);
     257           2 :         dumpBigPtrArray(bparr);
     258           2 :     }
     259             : 
     260           2 :     void test_remove_at_front()
     261             :     {
     262           2 :         printMethodName("test_remove_at_front\n");
     263             : 
     264           2 :         BigPtrArray bparr;
     265             : 
     266           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     267           2 :         dumpBigPtrArray(bparr);
     268             : 
     269          22 :         for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
     270             :         {
     271          20 :             sal_uLong oldCount = bparr.Count();
     272             : 
     273          20 :             delete bparr[0]; // release content
     274          20 :             bparr.Remove(0); // remove item from container
     275             : 
     276          40 :             CPPUNIT_ASSERT_MESSAGE
     277             :             (
     278             :                 "test_remove_at_front failed (wrong count)",
     279             :                 (oldCount - 1 == bparr.Count())
     280          20 :             );
     281             : 
     282         110 :             for (sal_uLong j = 0, k = i + 1; j < bparr.Count(); j++, k++)
     283             :             {
     284         180 :                 CPPUNIT_ASSERT_MESSAGE
     285             :                 (
     286             :                     "test_remove_at_front failed",
     287             :                     static_cast<BigPtrEntryMock*>(bparr[j])->getCount() == k
     288          90 :                 );
     289             :             }
     290             : 
     291          40 :             CPPUNIT_ASSERT_MESSAGE
     292             :             (
     293             :                 "test_remove_at_front failed",
     294             :                 checkElementPositions(bparr)
     295          20 :             );
     296             : 
     297          20 :             dumpBigPtrArray(bparr);
     298           2 :         }
     299           2 :     }
     300             : 
     301           2 :     void test_remove_at_back()
     302             :     {
     303           2 :         printMethodName("test_remove_at_back\n");
     304             : 
     305           2 :         BigPtrArray bparr;
     306             : 
     307           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     308           2 :         dumpBigPtrArray(bparr);
     309             : 
     310          22 :         for (int i = NUM_ENTRIES - 1; i >= 0; i--)
     311             :         {
     312          20 :             sal_uLong oldCount = bparr.Count();
     313          20 :             delete bparr[i];
     314          20 :             bparr.Remove(i);
     315             : 
     316          40 :             CPPUNIT_ASSERT_MESSAGE
     317             :             (
     318             :                 "test_remove_at_back failed (wrong count)",
     319             :                 (oldCount - 1 == bparr.Count())
     320          20 :             );
     321             : 
     322         110 :             for (sal_uLong j = 0; j < bparr.Count(); j++)
     323             :             {
     324         180 :                 CPPUNIT_ASSERT_MESSAGE
     325             :                 (
     326             :                     "test_remove_at_back failed",
     327             :                     static_cast<BigPtrEntryMock*>(bparr[j])->getCount() == j
     328          90 :                 );
     329             :             }
     330             : 
     331          40 :             CPPUNIT_ASSERT_MESSAGE
     332             :             (
     333             :                 "test_remove_at_back failed",
     334             :                 checkElementPositions(bparr)
     335          20 :             );
     336             : 
     337          20 :             dumpBigPtrArray(bparr);
     338           2 :         }
     339           2 :     }
     340             : 
     341           2 :     void test_remove_in_the_middle()
     342             :     {
     343           2 :         printMethodName("test_remove_in_the_middle\n");
     344             : 
     345           2 :         BigPtrArray bparr;
     346             : 
     347           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     348           2 :         dumpBigPtrArray(bparr);
     349             : 
     350          24 :         while (bparr.Count())
     351             :         {
     352          20 :             sal_uLong oldCount = bparr.Count();
     353          20 :             sal_uLong oldElement = static_cast<BigPtrEntryMock*>(bparr[bparr.Count() / 2])->getCount();
     354             : 
     355          20 :             delete bparr[bparr.Count() / 2];
     356          20 :             bparr.Remove(bparr.Count() / 2);
     357             : 
     358          40 :             CPPUNIT_ASSERT_MESSAGE
     359             :             (
     360             :                 "test_remove_in_the_middle failed (wrong count)",
     361             :                 (oldCount - 1 == bparr.Count())
     362          20 :             );
     363             : 
     364         110 :             for (sal_uLong i = 0; i < bparr.Count(); i++)
     365             :             {
     366         180 :                 CPPUNIT_ASSERT_MESSAGE
     367             :                 (
     368             :                     "test_remove_in_the_middle failed",
     369             :                     static_cast<BigPtrEntryMock*>(bparr[i])->getCount() != oldElement
     370          90 :                 );
     371             :             }
     372             : 
     373          40 :             CPPUNIT_ASSERT_MESSAGE
     374             :             (
     375             :                 "test_remove_in_the_middle failed",
     376             :                 checkElementPositions(bparr)
     377          20 :             );
     378             : 
     379          20 :             dumpBigPtrArray(bparr);
     380           2 :         }
     381           2 :     }
     382             : 
     383           2 :     void test_remove_multiple_elements_at_once()
     384             :     {
     385           2 :         printMethodName("test_remove_multiple_elements_at_once\n");
     386             : 
     387           2 :         BigPtrArray bparr;
     388             : 
     389           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     390           2 :         dumpBigPtrArray(bparr);
     391             : 
     392          12 :         while(bparr.Count())
     393             :         {
     394           8 :             sal_uLong nRemove = (bparr.Count() > 3) ? 3 : bparr.Count();
     395           8 :             sal_uLong oldCount = bparr.Count();
     396             : 
     397          28 :             for (sal_uLong i = 0; i < nRemove; i++)
     398          20 :                 delete bparr[i];
     399             : 
     400           8 :             bparr.Remove(0, nRemove);
     401             : 
     402          16 :             CPPUNIT_ASSERT_MESSAGE
     403             :             (
     404             :                 "test_remove_multiple_elements_at_once failed",
     405             :                 (oldCount - nRemove == bparr.Count())
     406           8 :             );
     407             : 
     408          16 :             CPPUNIT_ASSERT_MESSAGE
     409             :             (
     410             :                 "test_remove_multiple_elements_at_once failed",
     411             :                 checkElementPositions(bparr)
     412           8 :             );
     413             : 
     414           8 :             dumpBigPtrArray(bparr);
     415           2 :         }
     416           2 :     }
     417             : 
     418           2 :     void test_remove_all_elements_at_once()
     419             :     {
     420           2 :         printMethodName("test_remove_all_elements_at_once\n");
     421             : 
     422           2 :         BigPtrArray bparr;
     423             : 
     424           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     425           2 :         dumpBigPtrArray(bparr);
     426             : 
     427           2 :         releaseBigPtrArrayContent(bparr);
     428           2 :         bparr.Remove(0, bparr.Count());
     429             : 
     430           4 :         CPPUNIT_ASSERT_MESSAGE
     431             :         (
     432             :             "test_remove_all_elements_at_once failed",
     433             :             bparr.Count() == 0
     434           2 :         );
     435             : 
     436           2 :         dumpBigPtrArray(bparr);
     437           2 :     }
     438             : 
     439           2 :     void test_move_elements_from_lower_to_higher_pos()
     440             :     {
     441           2 :         printMethodName("test_move_elements_from_lower_to_higher_pos\n");
     442             : 
     443           2 :         BigPtrArray bparr;
     444             : 
     445           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     446           2 :         dumpBigPtrArray(bparr);
     447             : 
     448          20 :         for (sal_uLong i = 0; i < NUM_ENTRIES - 1; i++)
     449             :         {
     450          18 :             bparr.Move(i, i + 2);
     451          18 :             dumpBigPtrArray(bparr);
     452             :         }
     453             : 
     454          20 :         for (sal_uLong i = 0; i < (NUM_ENTRIES - 1); i++)
     455             :         {
     456          36 :             CPPUNIT_ASSERT_MESSAGE
     457             :             (
     458             :                 "test_move_elements_from_lower_to_higher_pos failed",
     459             :                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i + 1)
     460          18 :             );
     461             :         }
     462             : 
     463           4 :         CPPUNIT_ASSERT_MESSAGE
     464             :         (
     465             :             "test_move_elements_from_lower_to_higher_pos failed",
     466             :             static_cast<BigPtrEntryMock*>(bparr[NUM_ENTRIES -1])->getCount() == 0
     467           2 :         );
     468             : 
     469           4 :         CPPUNIT_ASSERT_MESSAGE
     470             :         (
     471             :             "test_move_elements_from_lower_to_higher_pos failed",
     472             :             checkElementPositions(bparr)
     473           2 :         );
     474             : 
     475           2 :         releaseBigPtrArrayContent(bparr);
     476           2 :     }
     477             : 
     478           2 :     void test_move_elements_from_higher_to_lower_pos()
     479             :     {
     480           2 :         printMethodName("test_move_elements_from_higher_to_lower_pos\n");
     481             : 
     482           2 :         BigPtrArray bparr;
     483             : 
     484           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     485           2 :         dumpBigPtrArray(bparr);
     486             : 
     487          20 :         for (int i = NUM_ENTRIES - 1; i >= 1; i--)
     488             :         {
     489          18 :             bparr.Move(i, i - 1);
     490          18 :             dumpBigPtrArray(bparr);
     491             :         }
     492             : 
     493           4 :         CPPUNIT_ASSERT_MESSAGE
     494             :         (
     495             :             "test_move_elements_from_higher_to_lower_pos failed",
     496             :             static_cast<BigPtrEntryMock*>(bparr[0])->getCount() == (NUM_ENTRIES - 1)
     497           2 :         );
     498             : 
     499          20 :         for (sal_uLong i = 1; i < NUM_ENTRIES; i++)
     500             :         {
     501          36 :             CPPUNIT_ASSERT_MESSAGE
     502             :             (
     503             :                 "test_move_elements_from_higher_to_lower_pos failed",
     504             :                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i - 1)
     505          18 :             );
     506             :         }
     507             : 
     508           4 :         CPPUNIT_ASSERT_MESSAGE
     509             :         (
     510             :             "test_move_elements_from_higher_to_lower_pos failed",
     511             :             checkElementPositions(bparr)
     512           2 :         );
     513             : 
     514           2 :         releaseBigPtrArrayContent(bparr);
     515           2 :     }
     516             : 
     517           2 :     void test_move_to_same_position()
     518             :     {
     519           2 :         printMethodName("test_move_to_same_position\n");
     520             : 
     521           2 :         BigPtrArray bparr;
     522             : 
     523           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     524           2 :         dumpBigPtrArray(bparr);
     525             : 
     526          22 :         for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
     527             :         {
     528          20 :             bparr.Move(i, i);
     529             :         }
     530             : 
     531           2 :         dumpBigPtrArray(bparr);
     532             : 
     533          22 :         for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
     534             :         {
     535          40 :             CPPUNIT_ASSERT_MESSAGE
     536             :             (
     537             :                 "test_move_to_same_position failed",
     538             :                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == i
     539          20 :             );
     540             :         }
     541             : 
     542           4 :         CPPUNIT_ASSERT_MESSAGE
     543             :         (
     544             :             "test_move_to_same_position failed",
     545             :             checkElementPositions(bparr)
     546           2 :         );
     547             : 
     548           2 :         releaseBigPtrArrayContent(bparr);
     549           2 :         dumpBigPtrArray(bparr);
     550           2 :     }
     551             : 
     552           2 :     void test_replace_elements()
     553             :     {
     554           2 :         printMethodName("test_replace_elements\n");
     555             : 
     556           2 :         BigPtrArray bparr;
     557             : 
     558           2 :         fillBigPtrArray(bparr, NUM_ENTRIES);
     559           2 :         dumpBigPtrArray(bparr);
     560             : 
     561          22 :         for (sal_uLong i = 0, j = NUM_ENTRIES - 1; i < NUM_ENTRIES; i++, j--)
     562             :         {
     563          20 :             delete bparr[i];
     564          20 :             bparr.Replace(i, new BigPtrEntryMock(j));
     565          20 :             dumpBigPtrArray(bparr);
     566             :         }
     567             : 
     568          22 :         for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
     569             :         {
     570          40 :             CPPUNIT_ASSERT_MESSAGE
     571             :             (
     572             :                 "test_replace_elements failed",
     573             :                 static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (NUM_ENTRIES - i - 1)
     574          20 :             );
     575             :         }
     576             : 
     577           4 :         CPPUNIT_ASSERT_MESSAGE
     578             :         (
     579             :             "test_replace_elements failed",
     580             :             checkElementPositions(bparr)
     581           2 :         );
     582             : 
     583           2 :         releaseBigPtrArrayContent(bparr);
     584           2 :     }
     585             : 
     586           4 :     CPPUNIT_TEST_SUITE(BigPtrArrayUnittest);
     587           2 :     CPPUNIT_TEST(test_ctor);
     588           2 :     CPPUNIT_TEST(test_insert_entries_at_front);
     589           2 :     CPPUNIT_TEST(test_insert_entries_in_the_middle);
     590           2 :     CPPUNIT_TEST(test_insert_at_already_used_index);
     591           2 :     CPPUNIT_TEST(test_insert_at_end);
     592           2 :     CPPUNIT_TEST(test_remove_at_front);
     593           2 :     CPPUNIT_TEST(test_remove_at_back);
     594           2 :     CPPUNIT_TEST(test_remove_in_the_middle);
     595           2 :     CPPUNIT_TEST(test_remove_multiple_elements_at_once);
     596           2 :     CPPUNIT_TEST(test_remove_all_elements_at_once);
     597           2 :     CPPUNIT_TEST(test_move_elements_from_lower_to_higher_pos);
     598           2 :     CPPUNIT_TEST(test_move_elements_from_higher_to_lower_pos);
     599           2 :     CPPUNIT_TEST(test_move_to_same_position);
     600           2 :     CPPUNIT_TEST(test_replace_elements);
     601           4 :     CPPUNIT_TEST_SUITE_END();
     602             : };
     603             : 
     604             : const char* START = "START: ";
     605             : const char* END = "END: ";
     606             : 
     607             : #if defined TIMELOG
     608             : 
     609             : class PerformanceTracer
     610             : {
     611             : public:
     612             : 
     613             : public:
     614             :     PerformanceTracer(const string& methodName) :
     615             :         startString_(START),
     616             :         endString_(END)
     617             :     {
     618             :         startString_ += methodName;
     619             :         endString_ += methodName;
     620             :     }
     621             : 
     622             :     ~PerformanceTracer()
     623             :     {
     624             :     }
     625             : 
     626             : private:
     627             :     string startString_;
     628             :     string endString_;
     629             : };
     630             : 
     631             : class BigPtrArrayPerformanceTest : public CppUnit::TestFixture
     632             : {
     633             : public:
     634             :     BigPtrArrayPerformanceTest()
     635             :     {
     636             :     }
     637             : 
     638             :     void test_insert_at_end_1000()
     639             :     { test_insert_at_end("1000"); }
     640             : 
     641             :     void test_insert_at_end_10000()
     642             :     { test_insert_at_end("10000"); }
     643             : 
     644             :     void test_insert_at_end_100000()
     645             :     { test_insert_at_end("100000"); }
     646             : 
     647             :     void test_insert_at_end_1000000()
     648             :     { test_insert_at_end("1000000"); }
     649             : 
     650             :     void test_insert_at_front_1000()
     651             :     { test_insert_at_front("1000"); }
     652             : 
     653             :     void test_insert_at_front_10000()
     654             :     { test_insert_at_front("10000"); }
     655             : 
     656             :     void test_insert_at_front_100000()
     657             :     { test_insert_at_front("100000"); }
     658             : 
     659             :     void test_insert_at_front_1000000()
     660             :     { test_insert_at_front("1000000"); }
     661             : 
     662             :     CPPUNIT_TEST_SUITE(BigPtrArrayPerformanceTest);
     663             :     CPPUNIT_TEST(test_insert_at_end_1000);
     664             :     CPPUNIT_TEST(test_insert_at_end_10000);
     665             :     CPPUNIT_TEST(test_insert_at_end_100000);
     666             :     CPPUNIT_TEST(test_insert_at_end_1000000);
     667             :     CPPUNIT_TEST(test_insert_at_front_1000);
     668             :     CPPUNIT_TEST(test_insert_at_front_10000);
     669             :     CPPUNIT_TEST(test_insert_at_front_100000);
     670             :     CPPUNIT_TEST(test_insert_at_front_1000000);
     671             :     CPPUNIT_TEST_SUITE_END();
     672             : 
     673             : private:
     674             :     void test_insert_at_end(const char* numElements)
     675             :     {
     676             :         OStringBuffer buff("test_insert_at_end ");
     677             :         buff.append(numElements);
     678             :         int n = atoi(numElements);
     679             :         PerformanceTracer tracer(buff.getStr());
     680             :         BigPtrArray bparr;
     681             :         for (int i = 0; i < n; i++)
     682             :             bparr.Insert(new BigPtrEntryMock(i), bparr.Count());
     683             : 
     684             :         releaseBigPtrArrayContent(bparr);
     685             :     }
     686             : 
     687             :     void test_insert_at_front(const char* numElements)
     688             :     {
     689             :         OStringBuffer buff("test_insert_at_front ");
     690             :         buff.append(numElements);
     691             :         int n = atoi(numElements);
     692             :         PerformanceTracer tracer(buff.getStr());
     693             :         BigPtrArray bparr;
     694             :         for (int i = 0; i < n; i++)
     695             :             bparr.Insert(new BigPtrEntryMock(i), 0);
     696             : 
     697             :         releaseBigPtrArrayContent(bparr);
     698             :     }
     699             : };
     700             : 
     701             : #endif
     702             : 
     703             : // register test suites
     704           6 : CPPUNIT_TEST_SUITE_REGISTRATION(BigPtrArrayUnittest);
     705             : #ifdef TIMELOG
     706             : CPPUNIT_TEST_SUITE_REGISTRATION(BigPtrArrayPerformanceTest);
     707             : #endif
     708             : 
     709             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10