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