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