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 294 : BigPtrEntryMock(sal_uLong count) : count_(count)
45 : {
46 294 : }
47 :
48 588 : virtual ~BigPtrEntryMock()
49 294 : {
50 588 : }
51 :
52 424 : sal_uLong getCount() const
53 : {
54 424 : return count_;
55 : }
56 :
57 468 : sal_uLong Position() const
58 : {
59 468 : return GetPos();
60 : }
61 :
62 : private:
63 : sal_uLong count_;
64 : };
65 :
66 162 : void dumpBigPtrArray(const BigPtrArray& bparr)
67 : {
68 : (void)bparr;
69 162 : }
70 :
71 24 : void fillBigPtrArray(BigPtrArray& bparr, sal_uLong numEntries)
72 : {
73 264 : for (sal_uLong i = 0; i < numEntries; i++)
74 240 : bparr.Insert(new BigPtrEntryMock(i), bparr.Count());
75 24 : }
76 :
77 28 : void printMethodName(const char* name)
78 : {
79 : (void)name;
80 28 : }
81 :
82 84 : bool checkElementPositions(const BigPtrArray& bparr)
83 : {
84 552 : for (sal_uLong i = 0; i < bparr.Count(); i++)
85 : {
86 468 : if (static_cast<BigPtrEntryMock*>(bparr[i])->Position() != i)
87 0 : return false;
88 : }
89 84 : return true;
90 : }
91 :
92 18 : void releaseBigPtrArrayContent(BigPtrArray& bparr)
93 : {
94 212 : for (sal_uLong i = 0; i < bparr.Count(); i++)
95 194 : delete bparr[i];
96 18 : }
97 : }
98 :
99 56 : class BigPtrArrayUnittest : public CppUnit::TestFixture
100 : {
101 : public:
102 :
103 28 : BigPtrArrayUnittest()
104 28 : {
105 28 : }
106 :
107 : /** Test constructor/destructor
108 : The size of the BigPtrArray
109 : aka the 'Count' should be 0
110 : initially.
111 : */
112 2 : void test_ctor()
113 : {
114 2 : printMethodName("test_ctor\n");
115 :
116 2 : BigPtrArray bparr;
117 :
118 4 : CPPUNIT_ASSERT_MESSAGE
119 : (
120 : "BigPtrArray ctor failed",
121 : bparr.Count() == 0
122 4 : );
123 2 : }
124 :
125 2 : void test_insert_entries_at_front()
126 : {
127 2 : printMethodName("test_insert_entries_at_front\n");
128 :
129 2 : BigPtrArray bparr;
130 :
131 22 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
132 : {
133 20 : sal_uLong oldCount = bparr.Count();
134 20 : bparr.Insert(new BigPtrEntryMock(i), 0);
135 40 : CPPUNIT_ASSERT_MESSAGE
136 : (
137 : "test_insert_entries_at_front failed",
138 : (bparr.Count() == oldCount + 1)
139 20 : );
140 : }
141 :
142 22 : for (sal_uLong i = 0, j = NUM_ENTRIES - 1; i < NUM_ENTRIES; i++, j--)
143 : {
144 40 : CPPUNIT_ASSERT_MESSAGE
145 : (
146 : "test_insert_entries_at_front failed",
147 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == j
148 20 : );
149 : }
150 :
151 4 : CPPUNIT_ASSERT_MESSAGE
152 : (
153 : "test_insert_entries_at_front failed",
154 : checkElementPositions(bparr)
155 2 : );
156 :
157 2 : releaseBigPtrArrayContent(bparr);
158 2 : dumpBigPtrArray(bparr);
159 2 : }
160 :
161 2 : void test_insert_entries_in_the_middle()
162 : {
163 2 : printMethodName("test_insert_entries_in_the_middle\n");
164 :
165 2 : BigPtrArray bparr;
166 :
167 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
168 2 : dumpBigPtrArray(bparr);
169 :
170 2 : sal_uLong oldCount = bparr.Count();
171 :
172 2 : bparr.Insert(new BigPtrEntryMock(NUM_ENTRIES), bparr.Count() / 2);
173 :
174 4 : 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 2 : );
179 :
180 4 : CPPUNIT_ASSERT_MESSAGE
181 : (
182 : "test_insert_entries_in_the_middle failed",
183 : checkElementPositions(bparr)
184 2 : );
185 :
186 2 : releaseBigPtrArrayContent(bparr);
187 2 : dumpBigPtrArray(bparr);
188 2 : }
189 :
190 2 : void test_insert_at_already_used_index()
191 : {
192 2 : printMethodName("test_insert_at_already_used_index\n");
193 :
194 2 : BigPtrArray bparr;
195 :
196 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
197 2 : dumpBigPtrArray(bparr);
198 :
199 2 : const sal_uLong oldCount = bparr.Count();
200 :
201 : // insert 5 elements
202 12 : for (sal_uLong i = 0, j = 30; i < 5; i++, j++)
203 10 : bparr.Insert(new BigPtrEntryMock(j), i);
204 :
205 4 : CPPUNIT_ASSERT_MESSAGE
206 : (
207 : "test_insert_at_already_used_index failed",
208 : (oldCount + 5 == bparr.Count())
209 2 : );
210 :
211 : // now, first 5 elements have counts: 30,31,..34
212 : // next 10 elements have counts: 0,1,..9
213 32 : for (sal_uLong i = 0, j = 30; i < bparr.Count(); i++, j++)
214 : {
215 60 : 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 30 : );
220 : }
221 :
222 4 : CPPUNIT_ASSERT_MESSAGE
223 : (
224 : "test_insert_at_already_used_index failed",
225 : checkElementPositions(bparr)
226 2 : );
227 :
228 2 : releaseBigPtrArrayContent(bparr);
229 2 : dumpBigPtrArray(bparr);
230 2 : }
231 :
232 2 : void test_insert_at_end()
233 : {
234 2 : printMethodName("test_insert_at_end\n");
235 :
236 2 : BigPtrArray bparr;
237 :
238 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
239 2 : dumpBigPtrArray(bparr);
240 :
241 2 : sal_uLong oldCount = bparr.Count();
242 2 : bparr.Insert(new BigPtrEntryMock(NUM_ENTRIES), bparr.Count());
243 :
244 4 : 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 2 : );
249 :
250 4 : CPPUNIT_ASSERT_MESSAGE
251 : (
252 : "test_insert_at_end failed",
253 : checkElementPositions(bparr)
254 2 : );
255 :
256 2 : releaseBigPtrArrayContent(bparr);
257 2 : dumpBigPtrArray(bparr);
258 2 : }
259 :
260 2 : void test_remove_at_front()
261 : {
262 2 : printMethodName("test_remove_at_front\n");
263 :
264 2 : BigPtrArray bparr;
265 :
266 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
267 2 : dumpBigPtrArray(bparr);
268 :
269 22 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
270 : {
271 20 : sal_uLong oldCount = bparr.Count();
272 :
273 20 : delete bparr[0]; // release content
274 20 : bparr.Remove(0); // remove item from container
275 :
276 40 : CPPUNIT_ASSERT_MESSAGE
277 : (
278 : "test_remove_at_front failed (wrong count)",
279 : (oldCount - 1 == bparr.Count())
280 20 : );
281 :
282 110 : for (sal_uLong j = 0, k = i + 1; j < bparr.Count(); j++, k++)
283 : {
284 180 : CPPUNIT_ASSERT_MESSAGE
285 : (
286 : "test_remove_at_front failed",
287 : static_cast<BigPtrEntryMock*>(bparr[j])->getCount() == k
288 90 : );
289 : }
290 :
291 40 : CPPUNIT_ASSERT_MESSAGE
292 : (
293 : "test_remove_at_front failed",
294 : checkElementPositions(bparr)
295 20 : );
296 :
297 20 : dumpBigPtrArray(bparr);
298 2 : }
299 2 : }
300 :
301 2 : void test_remove_at_back()
302 : {
303 2 : printMethodName("test_remove_at_back\n");
304 :
305 2 : BigPtrArray bparr;
306 :
307 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
308 2 : dumpBigPtrArray(bparr);
309 :
310 22 : for (int i = NUM_ENTRIES - 1; i >= 0; i--)
311 : {
312 20 : sal_uLong oldCount = bparr.Count();
313 20 : delete bparr[i];
314 20 : bparr.Remove(i);
315 :
316 40 : CPPUNIT_ASSERT_MESSAGE
317 : (
318 : "test_remove_at_back failed (wrong count)",
319 : (oldCount - 1 == bparr.Count())
320 20 : );
321 :
322 110 : for (sal_uLong j = 0; j < bparr.Count(); j++)
323 : {
324 180 : CPPUNIT_ASSERT_MESSAGE
325 : (
326 : "test_remove_at_back failed",
327 : static_cast<BigPtrEntryMock*>(bparr[j])->getCount() == j
328 90 : );
329 : }
330 :
331 40 : CPPUNIT_ASSERT_MESSAGE
332 : (
333 : "test_remove_at_back failed",
334 : checkElementPositions(bparr)
335 20 : );
336 :
337 20 : dumpBigPtrArray(bparr);
338 2 : }
339 2 : }
340 :
341 2 : void test_remove_in_the_middle()
342 : {
343 2 : printMethodName("test_remove_in_the_middle\n");
344 :
345 2 : BigPtrArray bparr;
346 :
347 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
348 2 : dumpBigPtrArray(bparr);
349 :
350 24 : while (bparr.Count())
351 : {
352 20 : sal_uLong oldCount = bparr.Count();
353 20 : sal_uLong oldElement = static_cast<BigPtrEntryMock*>(bparr[bparr.Count() / 2])->getCount();
354 :
355 20 : delete bparr[bparr.Count() / 2];
356 20 : bparr.Remove(bparr.Count() / 2);
357 :
358 40 : CPPUNIT_ASSERT_MESSAGE
359 : (
360 : "test_remove_in_the_middle failed (wrong count)",
361 : (oldCount - 1 == bparr.Count())
362 20 : );
363 :
364 110 : for (sal_uLong i = 0; i < bparr.Count(); i++)
365 : {
366 180 : CPPUNIT_ASSERT_MESSAGE
367 : (
368 : "test_remove_in_the_middle failed",
369 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() != oldElement
370 90 : );
371 : }
372 :
373 40 : CPPUNIT_ASSERT_MESSAGE
374 : (
375 : "test_remove_in_the_middle failed",
376 : checkElementPositions(bparr)
377 20 : );
378 :
379 20 : dumpBigPtrArray(bparr);
380 2 : }
381 2 : }
382 :
383 2 : void test_remove_multiple_elements_at_once()
384 : {
385 2 : printMethodName("test_remove_multiple_elements_at_once\n");
386 :
387 2 : BigPtrArray bparr;
388 :
389 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
390 2 : dumpBigPtrArray(bparr);
391 :
392 12 : while(bparr.Count())
393 : {
394 8 : sal_uLong nRemove = (bparr.Count() > 3) ? 3 : bparr.Count();
395 8 : sal_uLong oldCount = bparr.Count();
396 :
397 28 : for (sal_uLong i = 0; i < nRemove; i++)
398 20 : delete bparr[i];
399 :
400 8 : bparr.Remove(0, nRemove);
401 :
402 16 : CPPUNIT_ASSERT_MESSAGE
403 : (
404 : "test_remove_multiple_elements_at_once failed",
405 : (oldCount - nRemove == bparr.Count())
406 8 : );
407 :
408 16 : CPPUNIT_ASSERT_MESSAGE
409 : (
410 : "test_remove_multiple_elements_at_once failed",
411 : checkElementPositions(bparr)
412 8 : );
413 :
414 8 : dumpBigPtrArray(bparr);
415 2 : }
416 2 : }
417 :
418 2 : void test_remove_all_elements_at_once()
419 : {
420 2 : printMethodName("test_remove_all_elements_at_once\n");
421 :
422 2 : BigPtrArray bparr;
423 :
424 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
425 2 : dumpBigPtrArray(bparr);
426 :
427 2 : releaseBigPtrArrayContent(bparr);
428 2 : bparr.Remove(0, bparr.Count());
429 :
430 4 : CPPUNIT_ASSERT_MESSAGE
431 : (
432 : "test_remove_all_elements_at_once failed",
433 : bparr.Count() == 0
434 2 : );
435 :
436 2 : dumpBigPtrArray(bparr);
437 2 : }
438 :
439 2 : void test_move_elements_from_lower_to_higher_pos()
440 : {
441 2 : printMethodName("test_move_elements_from_lower_to_higher_pos\n");
442 :
443 2 : BigPtrArray bparr;
444 :
445 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
446 2 : dumpBigPtrArray(bparr);
447 :
448 20 : for (sal_uLong i = 0; i < NUM_ENTRIES - 1; i++)
449 : {
450 18 : bparr.Move(i, i + 2);
451 18 : dumpBigPtrArray(bparr);
452 : }
453 :
454 20 : for (sal_uLong i = 0; i < (NUM_ENTRIES - 1); i++)
455 : {
456 36 : CPPUNIT_ASSERT_MESSAGE
457 : (
458 : "test_move_elements_from_lower_to_higher_pos failed",
459 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i + 1)
460 18 : );
461 : }
462 :
463 4 : 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 2 : );
468 :
469 4 : CPPUNIT_ASSERT_MESSAGE
470 : (
471 : "test_move_elements_from_lower_to_higher_pos failed",
472 : checkElementPositions(bparr)
473 2 : );
474 :
475 2 : releaseBigPtrArrayContent(bparr);
476 2 : }
477 :
478 2 : void test_move_elements_from_higher_to_lower_pos()
479 : {
480 2 : printMethodName("test_move_elements_from_higher_to_lower_pos\n");
481 :
482 2 : BigPtrArray bparr;
483 :
484 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
485 2 : dumpBigPtrArray(bparr);
486 :
487 20 : for (int i = NUM_ENTRIES - 1; i >= 1; i--)
488 : {
489 18 : bparr.Move(i, i - 1);
490 18 : dumpBigPtrArray(bparr);
491 : }
492 :
493 4 : 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 2 : );
498 :
499 20 : for (sal_uLong i = 1; i < NUM_ENTRIES; i++)
500 : {
501 36 : CPPUNIT_ASSERT_MESSAGE
502 : (
503 : "test_move_elements_from_higher_to_lower_pos failed",
504 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (i - 1)
505 18 : );
506 : }
507 :
508 4 : CPPUNIT_ASSERT_MESSAGE
509 : (
510 : "test_move_elements_from_higher_to_lower_pos failed",
511 : checkElementPositions(bparr)
512 2 : );
513 :
514 2 : releaseBigPtrArrayContent(bparr);
515 2 : }
516 :
517 2 : void test_move_to_same_position()
518 : {
519 2 : printMethodName("test_move_to_same_position\n");
520 :
521 2 : BigPtrArray bparr;
522 :
523 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
524 2 : dumpBigPtrArray(bparr);
525 :
526 22 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
527 : {
528 20 : bparr.Move(i, i);
529 : }
530 :
531 2 : dumpBigPtrArray(bparr);
532 :
533 22 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
534 : {
535 40 : CPPUNIT_ASSERT_MESSAGE
536 : (
537 : "test_move_to_same_position failed",
538 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == i
539 20 : );
540 : }
541 :
542 4 : CPPUNIT_ASSERT_MESSAGE
543 : (
544 : "test_move_to_same_position failed",
545 : checkElementPositions(bparr)
546 2 : );
547 :
548 2 : releaseBigPtrArrayContent(bparr);
549 2 : dumpBigPtrArray(bparr);
550 2 : }
551 :
552 2 : void test_replace_elements()
553 : {
554 2 : printMethodName("test_replace_elements\n");
555 :
556 2 : BigPtrArray bparr;
557 :
558 2 : fillBigPtrArray(bparr, NUM_ENTRIES);
559 2 : dumpBigPtrArray(bparr);
560 :
561 22 : for (sal_uLong i = 0, j = NUM_ENTRIES - 1; i < NUM_ENTRIES; i++, j--)
562 : {
563 20 : delete bparr[i];
564 20 : bparr.Replace(i, new BigPtrEntryMock(j));
565 20 : dumpBigPtrArray(bparr);
566 : }
567 :
568 22 : for (sal_uLong i = 0; i < NUM_ENTRIES; i++)
569 : {
570 40 : CPPUNIT_ASSERT_MESSAGE
571 : (
572 : "test_replace_elements failed",
573 : static_cast<BigPtrEntryMock*>(bparr[i])->getCount() == (NUM_ENTRIES - i - 1)
574 20 : );
575 : }
576 :
577 4 : CPPUNIT_ASSERT_MESSAGE
578 : (
579 : "test_replace_elements failed",
580 : checkElementPositions(bparr)
581 2 : );
582 :
583 2 : releaseBigPtrArrayContent(bparr);
584 2 : }
585 :
586 4 : CPPUNIT_TEST_SUITE(BigPtrArrayUnittest);
587 2 : CPPUNIT_TEST(test_ctor);
588 2 : CPPUNIT_TEST(test_insert_entries_at_front);
589 2 : CPPUNIT_TEST(test_insert_entries_in_the_middle);
590 2 : CPPUNIT_TEST(test_insert_at_already_used_index);
591 2 : CPPUNIT_TEST(test_insert_at_end);
592 2 : CPPUNIT_TEST(test_remove_at_front);
593 2 : CPPUNIT_TEST(test_remove_at_back);
594 2 : CPPUNIT_TEST(test_remove_in_the_middle);
595 2 : CPPUNIT_TEST(test_remove_multiple_elements_at_once);
596 2 : CPPUNIT_TEST(test_remove_all_elements_at_once);
597 2 : CPPUNIT_TEST(test_move_elements_from_lower_to_higher_pos);
598 2 : CPPUNIT_TEST(test_move_elements_from_higher_to_lower_pos);
599 2 : CPPUNIT_TEST(test_move_to_same_position);
600 2 : CPPUNIT_TEST(test_replace_elements);
601 4 : 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 : 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 6 : 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: */
|
