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 <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 177 : BigPtrEntryMock(sal_uLong count) : count_(count)
46 : {
47 177 : }
48 :
49 354 : ~BigPtrEntryMock()
50 177 : {
51 354 : }
52 :
53 262 : sal_uLong getCount() const
54 : {
55 262 : return count_;
56 : }
57 :
58 20 : void setCount(sal_uLong newCount)
59 : {
60 20 : count_ = newCount;
61 20 : }
62 :
63 224 : sal_uLong Position() const
64 : {
65 224 : return GetPos();
66 : }
67 :
68 : private:
69 : sal_uLong count_;
70 : };
71 :
72 20 : bool AddToCount(const ElementPtr& rElem, void* pArgs)
73 : {
74 20 : BigPtrEntryMock* const pbem = static_cast<BigPtrEntryMock* const>(rElem);
75 20 : pbem->setCount(pbem->getCount() + *((sal_uLong*)pArgs));
76 20 : return true;
77 : }
78 :
79 85 : void dumpBigPtrArray(const BigPtrArray& bparr)
80 : {
81 : (void)bparr;
82 85 : }
83 :
84 15 : void fillBigPtrArray(BigPtrArray& bparr, sal_uLong numEntries)
85 : {
86 165 : for (sal_uLong i = 0; i < numEntries; i++)
87 150 : bparr.Insert(new BigPtrEntryMock(i), bparr.Count());
88 15 : }
89 :
90 17 : void printMethodName(const char* name)
91 : {
92 : (void)name;
93 17 : }
94 :
95 41 : bool checkElementPositions(const BigPtrArray& bparr)
96 : {
97 265 : for (sal_uLong i = 0; i < bparr.Count(); i++)
98 : {
99 224 : if (static_cast<BigPtrEntryMock*>(bparr[i])->Position() != i)
100 0 : return false;
101 : }
102 41 : return true;
103 : }
104 :
105 12 : void releaseBigPtrArrayContent(BigPtrArray& bparr)
106 : {
107 139 : for (sal_uLong i = 0; i < bparr.Count(); i++)
108 127 : delete bparr[i];
109 12 : }
110 :
111 : #ifdef TIMELOG
112 : RTL_LOGFILE_CONTEXT(logFile, "BigPtrArray performance measures" );
113 : #endif
114 : }
115 :
116 34 : class BigPtrArrayUnittest : public CppUnit::TestFixture
117 : {
118 : public:
119 :
120 17 : BigPtrArrayUnittest()
121 17 : {
122 17 : }
123 :
124 : /** Test constructor/destructor
125 : The size of the BigPtrArray
126 : aka the 'Count' should be 0
127 : initially.
128 : */
129 1 : void test_ctor()
130 : {
131 1 : printMethodName("test_ctor\n");
132 :
133 1 : BigPtrArray bparr;
134 :
135 2 : CPPUNIT_ASSERT_MESSAGE
136 : (
137 : "BigPtrArray ctor failed",
138 : bparr.Count() == 0
139 2 : );
140 1 : }
141 :
142 1 : void test_insert_entries_at_front()
143 : {
144 1 : 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 1 : BigPtrArray bparr;
151 :
152 11 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
153 : {
154 10 : sal_uLong oldCount = bparr.Count();
155 10 : bparr.Insert(new BigPtrEntryMock(i), 0);
156 20 : CPPUNIT_ASSERT_MESSAGE
157 : (
158 : "test_insert_entries_at_front failed",
159 : (bparr.Count() == oldCount + 1)
160 10 : );
161 : }
162 :
163 : #ifdef TIMELOG
164 : RTL_LOGFILE_CONTEXT_TRACE(logFile, "END: test_insert_entries_at_front");
165 : #endif
166 :
167 11 : for (sal_uLong i = 0, j = NUM_ENTRIES - 1; i < NUM_ENTRIES; i++, j--)
168 : {
169 20 : CPPUNIT_ASSERT_MESSAGE
170 : (
171 : "test_insert_entries_at_front failed",
172 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == j
173 10 : );
174 : }
175 :
176 2 : CPPUNIT_ASSERT_MESSAGE
177 : (
178 : "test_insert_entries_at_front failed",
179 : checkElementPositions(bparr)
180 1 : );
181 :
182 1 : releaseBigPtrArrayContent(bparr);
183 1 : dumpBigPtrArray(bparr);
184 1 : }
185 :
186 1 : void test_insert_entries_in_the_middle()
187 : {
188 1 : 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 1 : BigPtrArray bparr;
195 :
196 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
197 1 : dumpBigPtrArray(bparr);
198 :
199 1 : sal_uLong oldCount = bparr.Count();
200 :
201 1 : 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 2 : 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 1 : );
212 :
213 2 : CPPUNIT_ASSERT_MESSAGE
214 : (
215 : "test_insert_entries_in_the_middle failed",
216 : checkElementPositions(bparr)
217 1 : );
218 :
219 1 : releaseBigPtrArrayContent(bparr);
220 1 : dumpBigPtrArray(bparr);
221 1 : }
222 :
223 1 : void test_insert_at_already_used_index()
224 : {
225 1 : 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 1 : BigPtrArray bparr;
232 :
233 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
234 1 : dumpBigPtrArray(bparr);
235 :
236 1 : sal_uLong oldCount = bparr.Count();
237 :
238 6 : for (sal_uLong i = 0, j = -5; i < 5; i++, j++)
239 5 : 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 2 : CPPUNIT_ASSERT_MESSAGE
246 : (
247 : "test_insert_at_already_used_index failed",
248 : (oldCount + 5 == bparr.Count())
249 1 : );
250 :
251 16 : for (sal_uLong i = 0, j = -5; i < bparr.Count(); i++, j++)
252 : {
253 30 : CPPUNIT_ASSERT_MESSAGE
254 : (
255 : "test_insert_at_already_used_index failed",
256 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == j
257 15 : );
258 : }
259 :
260 2 : CPPUNIT_ASSERT_MESSAGE
261 : (
262 : "test_insert_at_already_used_index failed",
263 : checkElementPositions(bparr)
264 1 : );
265 :
266 1 : releaseBigPtrArrayContent(bparr);
267 1 : dumpBigPtrArray(bparr);
268 1 : }
269 :
270 1 : void test_insert_at_end()
271 : {
272 1 : printMethodName("test_insert_at_end\n");
273 :
274 1 : BigPtrArray bparr;
275 :
276 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
277 1 : dumpBigPtrArray(bparr);
278 :
279 1 : sal_uLong oldCount = bparr.Count();
280 1 : bparr.Insert(new BigPtrEntryMock(NUM_ENTRIES), bparr.Count());
281 :
282 2 : 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 1 : );
287 :
288 2 : CPPUNIT_ASSERT_MESSAGE
289 : (
290 : "test_insert_at_end failed",
291 : checkElementPositions(bparr)
292 1 : );
293 :
294 1 : releaseBigPtrArrayContent(bparr);
295 1 : dumpBigPtrArray(bparr);
296 1 : }
297 :
298 1 : void test_remove_at_front()
299 : {
300 1 : 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 1 : BigPtrArray bparr;
307 :
308 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
309 1 : dumpBigPtrArray(bparr);
310 :
311 11 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
312 : {
313 10 : sal_uLong oldCount = bparr.Count();
314 :
315 10 : delete bparr[0]; // release content
316 10 : bparr.Remove(0); // remove item from container
317 :
318 20 : CPPUNIT_ASSERT_MESSAGE
319 : (
320 : "test_remove_at_front failed (wrong count)",
321 : (oldCount - 1 == bparr.Count())
322 10 : );
323 :
324 55 : for (sal_uLong j = 0, k = i + 1; j < bparr.Count(); j++, k++)
325 : {
326 90 : CPPUNIT_ASSERT_MESSAGE
327 : (
328 : "test_remove_at_front failed",
329 : static_cast<BigPtrEntryMock*>(bparr[j])->getCount() == k
330 45 : );
331 : }
332 :
333 20 : CPPUNIT_ASSERT_MESSAGE
334 : (
335 : "test_remove_at_front failed",
336 : checkElementPositions(bparr)
337 10 : );
338 :
339 10 : dumpBigPtrArray(bparr);
340 1 : }
341 :
342 : #ifdef TIMELOG
343 : RTL_LOGFILE_CONTEXT_TRACE(logFile, "END: test_remove_at_front");
344 : #endif
345 1 : }
346 :
347 1 : void test_remove_at_back()
348 : {
349 1 : printMethodName("test_remove_at_back\n");
350 :
351 1 : BigPtrArray bparr;
352 :
353 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
354 1 : dumpBigPtrArray(bparr);
355 :
356 11 : for (int i = NUM_ENTRIES - 1; i >= 0; i--)
357 : {
358 10 : sal_uLong oldCount = bparr.Count();
359 10 : delete bparr[i];
360 10 : bparr.Remove(i);
361 :
362 20 : CPPUNIT_ASSERT_MESSAGE
363 : (
364 : "test_remove_at_back failed (wrong count)",
365 : (oldCount - 1 == bparr.Count())
366 10 : );
367 :
368 55 : for (sal_uLong j = 0; j < bparr.Count(); j++)
369 : {
370 90 : CPPUNIT_ASSERT_MESSAGE
371 : (
372 : "test_remove_at_back failed",
373 : static_cast<BigPtrEntryMock*>(bparr[j])->getCount() == j
374 45 : );
375 : }
376 :
377 20 : CPPUNIT_ASSERT_MESSAGE
378 : (
379 : "test_remove_at_back failed",
380 : checkElementPositions(bparr)
381 10 : );
382 :
383 10 : dumpBigPtrArray(bparr);
384 1 : }
385 1 : }
386 :
387 1 : void test_remove_in_the_middle()
388 : {
389 1 : 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 1 : BigPtrArray bparr;
396 :
397 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
398 1 : dumpBigPtrArray(bparr);
399 :
400 12 : while (bparr.Count())
401 : {
402 10 : sal_uLong oldCount = bparr.Count();
403 10 : sal_uLong oldElement = static_cast<BigPtrEntryMock*>(bparr[bparr.Count() / 2])->getCount();
404 :
405 10 : delete bparr[bparr.Count() / 2];
406 10 : bparr.Remove(bparr.Count() / 2);
407 :
408 20 : CPPUNIT_ASSERT_MESSAGE
409 : (
410 : "test_remove_in_the_middle failed (wrong count)",
411 : (oldCount - 1 == bparr.Count())
412 10 : );
413 :
414 55 : for (sal_uLong i = 0; i < bparr.Count(); i++)
415 : {
416 90 : CPPUNIT_ASSERT_MESSAGE
417 : (
418 : "test_remove_in_the_middle failed",
419 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() != oldElement
420 45 : );
421 : }
422 :
423 20 : CPPUNIT_ASSERT_MESSAGE
424 : (
425 : "test_remove_in_the_middle failed",
426 : checkElementPositions(bparr)
427 10 : );
428 :
429 10 : dumpBigPtrArray(bparr);
430 1 : }
431 : #ifdef TIMELOG
432 : RTL_LOGFILE_CONTEXT_TRACE(logFile, "END: test_remove_in_the_middle");
433 : #endif
434 1 : }
435 :
436 1 : void test_remove_multiple_elements_at_once()
437 : {
438 1 : printMethodName("test_remove_multiple_elements_at_once\n");
439 :
440 1 : BigPtrArray bparr;
441 :
442 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
443 1 : dumpBigPtrArray(bparr);
444 :
445 6 : while(bparr.Count())
446 : {
447 4 : sal_uLong nRemove = (bparr.Count() > 3) ? 3 : bparr.Count();
448 4 : sal_uLong oldCount = bparr.Count();
449 :
450 14 : for (sal_uLong i = 0; i < nRemove; i++)
451 10 : delete bparr[i];
452 :
453 4 : bparr.Remove(0, nRemove);
454 :
455 8 : CPPUNIT_ASSERT_MESSAGE
456 : (
457 : "test_remove_multiple_elements_at_once failed",
458 : (oldCount - nRemove == bparr.Count())
459 4 : );
460 :
461 8 : CPPUNIT_ASSERT_MESSAGE
462 : (
463 : "test_remove_multiple_elements_at_once failed",
464 : checkElementPositions(bparr)
465 4 : );
466 :
467 4 : dumpBigPtrArray(bparr);
468 1 : }
469 1 : }
470 :
471 1 : void test_remove_all_elements_at_once()
472 : {
473 1 : printMethodName("test_remove_all_elements_at_once\n");
474 :
475 1 : BigPtrArray bparr;
476 :
477 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
478 1 : dumpBigPtrArray(bparr);
479 :
480 1 : releaseBigPtrArrayContent(bparr);
481 1 : bparr.Remove(0, bparr.Count());
482 :
483 2 : CPPUNIT_ASSERT_MESSAGE
484 : (
485 : "test_remove_all_elements_at_once failed",
486 : bparr.Count() == 0
487 1 : );
488 :
489 1 : dumpBigPtrArray(bparr);
490 1 : }
491 :
492 1 : void test_move_elements_from_lower_to_higher_pos()
493 : {
494 1 : printMethodName("test_move_elements_from_lower_to_higher_pos\n");
495 :
496 1 : BigPtrArray bparr;
497 :
498 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
499 1 : dumpBigPtrArray(bparr);
500 :
501 10 : for (sal_uLong i = 0; i < NUM_ENTRIES - 1; i++)
502 : {
503 9 : bparr.Move(i, i + 2);
504 9 : dumpBigPtrArray(bparr);
505 : }
506 :
507 10 : for (sal_uLong i = 0; i < (NUM_ENTRIES - 1); i++)
508 : {
509 18 : CPPUNIT_ASSERT_MESSAGE
510 : (
511 : "test_move_elements_from_lower_to_higher_pos failed",
512 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i + 1)
513 9 : );
514 : }
515 :
516 2 : 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 1 : );
521 :
522 2 : CPPUNIT_ASSERT_MESSAGE
523 : (
524 : "test_move_elements_from_lower_to_higher_pos failed",
525 : checkElementPositions(bparr)
526 1 : );
527 :
528 1 : releaseBigPtrArrayContent(bparr);
529 1 : }
530 :
531 1 : void test_move_elements_from_higher_to_lower_pos()
532 : {
533 1 : printMethodName("test_move_elements_from_higher_to_lower_pos\n");
534 :
535 1 : BigPtrArray bparr;
536 :
537 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
538 1 : dumpBigPtrArray(bparr);
539 :
540 10 : for (int i = NUM_ENTRIES - 1; i >= 1; i--)
541 : {
542 9 : bparr.Move(i, i - 1);
543 9 : dumpBigPtrArray(bparr);
544 : }
545 :
546 2 : 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 1 : );
551 :
552 10 : for (sal_uLong i = 1; i < NUM_ENTRIES; i++)
553 : {
554 18 : CPPUNIT_ASSERT_MESSAGE
555 : (
556 : "test_move_elements_from_higher_to_lower_pos failed",
557 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i - 1)
558 9 : );
559 : }
560 :
561 2 : CPPUNIT_ASSERT_MESSAGE
562 : (
563 : "test_move_elements_from_higher_to_lower_pos failed",
564 : checkElementPositions(bparr)
565 1 : );
566 :
567 1 : releaseBigPtrArrayContent(bparr);
568 1 : }
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 1 : void test_replace_elements()
606 : {
607 1 : printMethodName("test_replace_elements\n");
608 :
609 1 : BigPtrArray bparr;
610 :
611 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
612 1 : dumpBigPtrArray(bparr);
613 :
614 11 : for (sal_uLong i = 0, j = NUM_ENTRIES - 1; i < NUM_ENTRIES; i++, j--)
615 : {
616 10 : delete bparr[i];
617 10 : bparr.Replace(i, new BigPtrEntryMock(j));
618 10 : dumpBigPtrArray(bparr);
619 : }
620 :
621 11 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
622 : {
623 20 : CPPUNIT_ASSERT_MESSAGE
624 : (
625 : "test_replace_elements failed",
626 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (NUM_ENTRIES - i - 1)
627 10 : );
628 : }
629 :
630 2 : CPPUNIT_ASSERT_MESSAGE
631 : (
632 : "test_replace_elements failed",
633 : checkElementPositions(bparr)
634 1 : );
635 :
636 1 : releaseBigPtrArrayContent(bparr);
637 1 : }
638 :
639 1 : void test_for_each()
640 : {
641 1 : printMethodName("test_for_each\n");
642 :
643 1 : BigPtrArray bparr;
644 :
645 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
646 1 : dumpBigPtrArray(bparr);
647 :
648 1 : sal_uLong addCount = 1;
649 1 : bparr.ForEach(AddToCount, &addCount);
650 :
651 11 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
652 : {
653 20 : CPPUNIT_ASSERT_MESSAGE
654 : (
655 : "test_for_each failed",
656 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i+1)
657 10 : );
658 : }
659 :
660 1 : releaseBigPtrArrayContent(bparr);
661 1 : dumpBigPtrArray(bparr);
662 1 : }
663 :
664 1 : void test_for_some1()
665 : {
666 1 : printMethodName("test_for_some1\n");
667 :
668 1 : BigPtrArray bparr;
669 :
670 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
671 1 : dumpBigPtrArray(bparr);
672 :
673 1 : sal_uLong addCount = 1;
674 1 : bparr.ForEach(0, NUM_ENTRIES / 2, AddToCount, &addCount);
675 :
676 1 : sal_uLong i = 0;
677 6 : for (/* */; i < NUM_ENTRIES / 2; i++)
678 : {
679 10 : CPPUNIT_ASSERT_MESSAGE
680 : (
681 : "test_for_some1 failed",
682 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i+1)
683 5 : );
684 : }
685 :
686 6 : for (/* */; i < NUM_ENTRIES; i++)
687 : {
688 10 : CPPUNIT_ASSERT_MESSAGE
689 : (
690 : "test_for_some1 failed",
691 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i)
692 5 : );
693 : }
694 :
695 1 : releaseBigPtrArrayContent(bparr);
696 1 : dumpBigPtrArray(bparr);
697 1 : }
698 :
699 1 : void test_for_some2()
700 : {
701 1 : printMethodName("test_for_some2\n");
702 :
703 1 : BigPtrArray bparr;
704 :
705 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
706 1 : dumpBigPtrArray(bparr);
707 :
708 1 : sal_uLong addCount = 1;
709 1 : bparr.ForEach(NUM_ENTRIES / 2, NUM_ENTRIES, AddToCount, &addCount);
710 :
711 1 : sal_uLong i = 0;
712 6 : for (/* */; i < NUM_ENTRIES / 2; i++)
713 : {
714 10 : CPPUNIT_ASSERT_MESSAGE
715 : (
716 : "test_for_some2 failed",
717 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i)
718 5 : );
719 : }
720 :
721 6 : for (/* */; i < NUM_ENTRIES; i++)
722 : {
723 10 : CPPUNIT_ASSERT_MESSAGE
724 : (
725 : "test_for_some2 failed",
726 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i+1)
727 5 : );
728 : }
729 :
730 1 : releaseBigPtrArrayContent(bparr);
731 1 : dumpBigPtrArray(bparr);
732 1 : }
733 :
734 1 : void test_for_some3()
735 : {
736 1 : printMethodName("test_for_some3\n");
737 :
738 1 : BigPtrArray bparr;
739 :
740 1 : fillBigPtrArray(bparr, NUM_ENTRIES);
741 1 : dumpBigPtrArray(bparr);
742 :
743 1 : sal_uLong addCount = 1;
744 1 : bparr.ForEach(0, 0, AddToCount, &addCount);
745 :
746 11 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
747 : {
748 20 : CPPUNIT_ASSERT_MESSAGE
749 : (
750 : "test_for_some3 failed",
751 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == i
752 10 : );
753 : }
754 1 : releaseBigPtrArrayContent(bparr);
755 1 : }
756 :
757 2 : CPPUNIT_TEST_SUITE(BigPtrArrayUnittest);
758 1 : CPPUNIT_TEST(test_ctor);
759 1 : CPPUNIT_TEST(test_insert_entries_at_front);
760 1 : CPPUNIT_TEST(test_insert_entries_in_the_middle);
761 1 : CPPUNIT_TEST(test_insert_at_already_used_index);
762 1 : CPPUNIT_TEST(test_insert_at_end);
763 1 : CPPUNIT_TEST(test_remove_at_front);
764 1 : CPPUNIT_TEST(test_remove_at_back);
765 1 : CPPUNIT_TEST(test_remove_in_the_middle);
766 1 : CPPUNIT_TEST(test_remove_multiple_elements_at_once);
767 1 : CPPUNIT_TEST(test_remove_all_elements_at_once);
768 1 : CPPUNIT_TEST(test_move_elements_from_lower_to_higher_pos);
769 1 : CPPUNIT_TEST(test_move_elements_from_higher_to_lower_pos);
770 1 : CPPUNIT_TEST(test_replace_elements);
771 1 : CPPUNIT_TEST(test_for_each);
772 1 : CPPUNIT_TEST(test_for_some1);
773 1 : CPPUNIT_TEST(test_for_some2);
774 1 : CPPUNIT_TEST(test_for_some3);
775 2 : 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 0 : class BigPtrArrayPerformanceTest : public CppUnit::TestFixture
810 : {
811 : public:
812 0 : BigPtrArrayPerformanceTest()
813 0 : {
814 0 : }
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 3 : 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: */
|
