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