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