1 /*
2 * unittests/core/Array.cc
3 * Apto
4 *
5 * Created by David on 2/14/11.
6 * Copyright 2011 David Michael Bryson. All rights reserved.
7 * http://programerror.com/software/apto
8 *
9 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
10 * following conditions are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
13 * following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
15 * following disclaimer in the documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of David Michael Bryson, nor the names of contributors may be used to endorse or promote
17 * products derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY DAVID MICHAEL BRYSON AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 * DISCLAIMED. IN NO EVENT SHALL DAVID MICHAEL BRYSON OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
23 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
25 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 * Authors: David M. Bryson <david@programerror.com>
28 *
29 */
30
31 #include "apto/core/Array.h"
32
33 #include "gtest/gtest.h"
34
35
36 // Array<int, Basic>
37 // --------------------------------------------------------------------------------------------------------------
38
TEST(CoreBasicArray,Construction)39 TEST(CoreBasicArray, Construction) {
40 Apto::Array<int, Apto::Basic> default_constructor;
41 EXPECT_EQ(0, default_constructor.GetSize());
42 Apto::Array<int, Apto::Basic> constructor_sz_3(3);
43 EXPECT_EQ(3, constructor_sz_3.GetSize());
44 }
45
TEST(CoreBasicArray,Indexing)46 TEST(CoreBasicArray, Indexing) {
47 Apto::Array<int, Apto::Basic> array(5);
48 for (int i = 0; i < array.GetSize(); i++) array[i] = i;
49
50 EXPECT_EQ(0, array[0]);
51 EXPECT_EQ(1, array[1]);
52 EXPECT_EQ(2, array[2]);
53 EXPECT_EQ(3, array[3]);
54 EXPECT_EQ(4, array[4]);
55
56 array[3] = 12;
57
58 EXPECT_EQ(12, array[3]);
59 }
60
TEST(CoreBasicArray,Assignment)61 TEST(CoreBasicArray, Assignment) {
62 Apto::Array<int, Apto::Basic> array1(5);
63 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
64
65 Apto::Array<int, Apto::Basic> array2(6);
66 for (int i = 0; i < array2.GetSize(); i++) array2[i] = 5 + i;
67
68 EXPECT_NE(array1.GetSize(), array2.GetSize());
69 EXPECT_NE(array1[3], array2[3]);
70
71 array1 = array2;
72
73 EXPECT_EQ(array1.GetSize(), array2.GetSize());
74 EXPECT_EQ(array1[3], array2[3]);
75
76 Apto::Array<int, Apto::Basic> array_copy_constructor(array2);
77 EXPECT_EQ(array2.GetSize(), array_copy_constructor.GetSize());
78 EXPECT_EQ(array2[3], array_copy_constructor[3]);
79 }
80
TEST(CoreBasicArray,Resize)81 TEST(CoreBasicArray, Resize) {
82 Apto::Array<int, Apto::Basic> array1(5);
83 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
84 EXPECT_EQ(5, array1.GetSize());
85 EXPECT_EQ(4, array1[4]);
86
87 array1.Resize(20);
88 EXPECT_EQ(20, array1.GetSize());
89 EXPECT_EQ(4, array1[4]);
90
91 for (int i = 0; i < array1.GetSize(); i++) array1[i] = 10 + i;
92 EXPECT_EQ(14, array1[4]);
93 EXPECT_EQ(19, array1[9]);
94
95 array1.Resize(5);
96 EXPECT_EQ(14, array1[4]);
97
98 array1.ResizeClear(3);
99 EXPECT_EQ(3, array1.GetSize());
100 }
101
TEST(CoreBasicArray,PushPop)102 TEST(CoreBasicArray, PushPop) {
103 Apto::Array<int, Apto::Basic> array;
104 EXPECT_EQ(0, array.GetSize());
105
106 for (int i = 0; i < 3; i++) array.Push(i);
107 EXPECT_EQ(3, array.GetSize());
108 EXPECT_EQ(2, array[2]);
109
110 EXPECT_EQ(2, array.Pop());
111 EXPECT_EQ(2, array.GetSize());
112 EXPECT_EQ(1, array.Pop());
113 array.Push(8);
114 EXPECT_EQ(8, array.Pop());
115 EXPECT_EQ(1, array.GetSize());
116 }
117
TEST(CoreBasicArray,Swap)118 TEST(CoreBasicArray, Swap) {
119 Apto::Array<int, Apto::Basic> array(3);
120 for (int i = 0; i < 3; i++) array[i] = i;
121
122 EXPECT_EQ(0, array[0]);
123 EXPECT_EQ(1, array[1]);
124 EXPECT_EQ(2, array[2]);
125
126 array.Swap(0, 2);
127
128 EXPECT_EQ(2, array[0]);
129 EXPECT_EQ(1, array[1]);
130 EXPECT_EQ(0, array[2]);
131 }
132
TEST(CoreBasicArray,SetAll)133 TEST(CoreBasicArray, SetAll) {
134 Apto::Array<int, Apto::Basic> array(3);
135
136 array.SetAll(2);
137 for (int i = 0; i < array.GetSize(); i++) EXPECT_EQ(2, array[i]);
138
139 array.SetAll(26);
140 for (int i = 0; i < array.GetSize(); i++) EXPECT_EQ(26, array[i]);
141 }
142
TEST(CoreBasicArray,Iterators)143 TEST(CoreBasicArray, Iterators) {
144 Apto::Array<int, Apto::Basic> array(5);
145 for (int i = 0; i < 5; i++) array[i] = i;
146
147 Apto::Array<int, Apto::Basic>::Iterator it = array.Begin();
148 int i = 0;
149 while (it.Next()) {
150 EXPECT_EQ(i, *it.Get());
151 i++;
152 }
153
154 const Apto::Array<int, Apto::Basic>& const_array = array;
155 Apto::Array<int, Apto::Basic>::ConstIterator cit = const_array.Begin();
156 i = 0;
157 while (cit.Next()) {
158 EXPECT_EQ(i, *cit.Get());
159 i++;
160 }
161 }
162
163
TEST(CoreBasicArray,Comparison)164 TEST(CoreBasicArray, Comparison) {
165 Apto::Array<int, Apto::Basic> array1(3);
166 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
167
168 Apto::Array<int, Apto::Basic> array2(array1);
169 array2[1] = 5;
170
171 EXPECT_TRUE(array1 == array1);
172 EXPECT_TRUE(array2 == array2);
173 EXPECT_TRUE(array1 != array2);
174 EXPECT_FALSE(array1 == array2);
175 EXPECT_FALSE(array1 != array1);
176 EXPECT_FALSE(array2 != array2);
177 }
178
179
TEST(CoreBasicArray,Concatenation)180 TEST(CoreBasicArray, Concatenation) {
181 Apto::Array<int, Apto::Basic> array1(3);
182 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
183
184 Apto::Array<int, Apto::Basic> array2(1);
185 array2[0] = 5;
186
187 array2 += array2;
188 EXPECT_EQ(2, array2.GetSize());
189 EXPECT_EQ(5, array2[0]);
190 EXPECT_EQ(5, array2[1]);
191
192 array1 += array2;
193
194 EXPECT_EQ(0, array1[0]);
195 EXPECT_EQ(1, array1[1]);
196 EXPECT_EQ(2, array1[2]);
197 EXPECT_EQ(5, array1[3]);
198 EXPECT_EQ(5, array1[4]);
199
200 Apto::Array<int, Apto::Basic> array3 = array2 + array2;
201 EXPECT_EQ(4, array3.GetSize());
202 EXPECT_EQ(5, array3[0]);
203 EXPECT_EQ(5, array3[1]);
204 EXPECT_EQ(5, array3[2]);
205 EXPECT_EQ(5, array3[3]);
206
207 array2 = array2 + array2;
208 EXPECT_TRUE(array2 == array3);
209 }
210
211
212
213 // Array<int, Smart>
214 // --------------------------------------------------------------------------------------------------------------
215
TEST(CoreSmartArray,Construction)216 TEST(CoreSmartArray, Construction) {
217 Apto::Array<int, Apto::Smart> default_constructor;
218 EXPECT_EQ(0, default_constructor.GetSize());
219 Apto::Array<int, Apto::Smart> constructor_sz_3(3);
220 EXPECT_EQ(3, constructor_sz_3.GetSize());
221 }
222
TEST(CoreSmartArray,Indexing)223 TEST(CoreSmartArray, Indexing) {
224 Apto::Array<int, Apto::Smart> array(5);
225 for (int i = 0; i < array.GetSize(); i++) array[i] = i;
226
227 EXPECT_EQ(0, array[0]);
228 EXPECT_EQ(1, array[1]);
229 EXPECT_EQ(2, array[2]);
230 EXPECT_EQ(3, array[3]);
231 EXPECT_EQ(4, array[4]);
232
233 array[3] = 12;
234
235 EXPECT_EQ(12, array[3]);
236 }
237
TEST(CoreSmartArray,Assignment)238 TEST(CoreSmartArray, Assignment) {
239 Apto::Array<int, Apto::Smart> array1(5);
240 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
241
242 Apto::Array<int, Apto::Smart> array2(6);
243 for (int i = 0; i < array2.GetSize(); i++) array2[i] = 5 + i;
244
245 EXPECT_NE(array1.GetSize(), array2.GetSize());
246 EXPECT_NE(array1[3], array2[3]);
247
248 array1 = array2;
249
250 EXPECT_EQ(array1.GetSize(), array2.GetSize());
251 EXPECT_EQ(array1[3], array2[3]);
252
253 Apto::Array<int, Apto::Smart> array_copy_constructor(array2);
254 EXPECT_EQ(array2.GetSize(), array_copy_constructor.GetSize());
255 EXPECT_EQ(array2[3], array_copy_constructor[3]);
256 }
257
TEST(CoreSmartArray,Resize)258 TEST(CoreSmartArray, Resize) {
259 Apto::Array<int, Apto::Smart> array1(5);
260 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
261 EXPECT_EQ(5, array1.GetSize());
262 EXPECT_EQ(4, array1[4]);
263
264 EXPECT_EQ(0, array1.GetReserve());
265 array1.SetReserve(100);
266 EXPECT_EQ(100, array1.GetReserve());
267 array1.Resize(20);
268 EXPECT_EQ(20, array1.GetSize());
269 EXPECT_EQ(4, array1[4]);
270 EXPECT_EQ(100, array1.GetCapacity());
271
272 for (int i = 0; i < array1.GetSize(); i++) array1[i] = 10 + i;
273 EXPECT_EQ(14, array1[4]);
274 EXPECT_EQ(19, array1[9]);
275
276 array1.Resize(5);
277 EXPECT_EQ(14, array1[4]);
278
279 array1.SetReserve(20);
280 array1.ResizeClear(3);
281 EXPECT_EQ(3, array1.GetSize());
282 EXPECT_EQ(20, array1.GetCapacity());
283 }
284
TEST(CoreSmartArray,PushPop)285 TEST(CoreSmartArray, PushPop) {
286 Apto::Array<int, Apto::Smart> array;
287 EXPECT_EQ(0, array.GetSize());
288
289 for (int i = 0; i < 3; i++) array.Push(i);
290 EXPECT_EQ(3, array.GetSize());
291 EXPECT_EQ(2, array[2]);
292
293 EXPECT_EQ(2, array.Pop());
294 EXPECT_EQ(2, array.GetSize());
295 EXPECT_EQ(1, array.Pop());
296 array.Push(8);
297 EXPECT_EQ(8, array.Pop());
298 EXPECT_EQ(1, array.GetSize());
299 }
300
TEST(CoreSmartArray,Swap)301 TEST(CoreSmartArray, Swap) {
302 Apto::Array<int, Apto::Smart> array(3);
303 for (int i = 0; i < 3; i++) array[i] = i;
304
305 EXPECT_EQ(0, array[0]);
306 EXPECT_EQ(1, array[1]);
307 EXPECT_EQ(2, array[2]);
308
309 array.Swap(0, 2);
310
311 EXPECT_EQ(2, array[0]);
312 EXPECT_EQ(1, array[1]);
313 EXPECT_EQ(0, array[2]);
314 }
315
TEST(CoreSmartArray,SetAll)316 TEST(CoreSmartArray, SetAll) {
317 Apto::Array<int, Apto::Smart> array(3);
318
319 array.SetAll(2);
320 for (int i = 0; i < array.GetSize(); i++) EXPECT_EQ(2, array[i]);
321
322 array.SetAll(26);
323 for (int i = 0; i < array.GetSize(); i++) EXPECT_EQ(26, array[i]);
324 }
325
TEST(CoreSmartArray,Iterators)326 TEST(CoreSmartArray, Iterators) {
327 Apto::Array<int, Apto::Smart> array(5);
328 for (int i = 0; i < 5; i++) array[i] = i;
329
330 Apto::Array<int, Apto::Smart>::Iterator it = array.Begin();
331 int i = 0;
332 while (it.Next()) {
333 EXPECT_EQ(i, *it.Get());
334 i++;
335 }
336
337 const Apto::Array<int, Apto::Smart>& const_array = array;
338 Apto::Array<int, Apto::Smart>::ConstIterator cit = const_array.Begin();
339 i = 0;
340 while (cit.Next()) {
341 EXPECT_EQ(i, *cit.Get());
342 i++;
343 }
344 }
345
346
TEST(CoreSmartArray,Comparison)347 TEST(CoreSmartArray, Comparison) {
348 Apto::Array<int, Apto::Smart> array1(3);
349 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
350
351 Apto::Array<int, Apto::Smart> array2(array1);
352 array2[1] = 5;
353
354 EXPECT_TRUE(array1 == array1);
355 EXPECT_TRUE(array2 == array2);
356 EXPECT_TRUE(array1 != array2);
357 EXPECT_FALSE(array1 == array2);
358 EXPECT_FALSE(array1 != array1);
359 EXPECT_FALSE(array2 != array2);
360 }
361
362
TEST(CoreSmartArray,Concatenation)363 TEST(CoreSmartArray, Concatenation) {
364 Apto::Array<int, Apto::Smart> array1(3);
365 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
366
367 Apto::Array<int, Apto::Smart> array2(1);
368 array2[0] = 5;
369
370 array2 += array2;
371 EXPECT_EQ(2, array2.GetSize());
372 EXPECT_EQ(5, array2[0]);
373 EXPECT_EQ(5, array2[1]);
374
375 array1 += array2;
376
377 EXPECT_EQ(0, array1[0]);
378 EXPECT_EQ(1, array1[1]);
379 EXPECT_EQ(2, array1[2]);
380 EXPECT_EQ(5, array1[3]);
381 EXPECT_EQ(5, array1[4]);
382
383 Apto::Array<int, Apto::Smart> array3 = array2 + array2;
384 EXPECT_EQ(4, array3.GetSize());
385 EXPECT_EQ(5, array3[0]);
386 EXPECT_EQ(5, array3[1]);
387 EXPECT_EQ(5, array3[2]);
388 EXPECT_EQ(5, array3[3]);
389
390 array2 = array2 + array2;
391 EXPECT_TRUE(array2 == array3);
392 }
393
394
395 // Array<int, ManagedPointer>
396 // --------------------------------------------------------------------------------------------------------------
397
TEST(CoreManagedPointerArray,Construction)398 TEST(CoreManagedPointerArray, Construction) {
399 Apto::Array<int, Apto::ManagedPointer> default_constructor;
400 EXPECT_EQ(0, default_constructor.GetSize());
401 Apto::Array<int, Apto::ManagedPointer> constructor_sz_3(3);
402 EXPECT_EQ(3, constructor_sz_3.GetSize());
403 }
404
TEST(CoreManagedPointerArray,Indexing)405 TEST(CoreManagedPointerArray, Indexing) {
406 Apto::Array<int, Apto::ManagedPointer> array(5);
407 for (int i = 0; i < array.GetSize(); i++) array[i] = i;
408
409 EXPECT_EQ(0, array[0]);
410 EXPECT_EQ(1, array[1]);
411 EXPECT_EQ(2, array[2]);
412 EXPECT_EQ(3, array[3]);
413 EXPECT_EQ(4, array[4]);
414
415 array[3] = 12;
416
417 EXPECT_EQ(12, array[3]);
418 }
419
TEST(CoreManagedPointerArray,Assignment)420 TEST(CoreManagedPointerArray, Assignment) {
421 Apto::Array<int, Apto::ManagedPointer> array1(5);
422 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
423
424 Apto::Array<int, Apto::ManagedPointer> array2(6);
425 for (int i = 0; i < array2.GetSize(); i++) array2[i] = 5 + i;
426
427 EXPECT_NE(array1.GetSize(), array2.GetSize());
428 EXPECT_NE(array1[3], array2[3]);
429
430 array1 = array2;
431
432 EXPECT_EQ(array1.GetSize(), array2.GetSize());
433 EXPECT_EQ(array1[3], array2[3]);
434
435 Apto::Array<int, Apto::ManagedPointer> array_copy_constructor(array2);
436 EXPECT_EQ(array2.GetSize(), array_copy_constructor.GetSize());
437 EXPECT_EQ(array2[3], array_copy_constructor[3]);
438 }
439
TEST(CoreManagedPointerArray,Resize)440 TEST(CoreManagedPointerArray, Resize) {
441 Apto::Array<int, Apto::ManagedPointer> array1(5);
442 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
443 EXPECT_EQ(5, array1.GetSize());
444 EXPECT_EQ(4, array1[4]);
445
446 array1.Resize(20);
447 EXPECT_EQ(20, array1.GetSize());
448 EXPECT_EQ(4, array1[4]);
449
450 for (int i = 0; i < array1.GetSize(); i++) array1[i] = 10 + i;
451 EXPECT_EQ(14, array1[4]);
452 EXPECT_EQ(19, array1[9]);
453
454 array1.Resize(5);
455 EXPECT_EQ(14, array1[4]);
456
457 array1.ResizeClear(3);
458 EXPECT_EQ(3, array1.GetSize());
459 }
460
TEST(CoreManagedPointerArray,PushPop)461 TEST(CoreManagedPointerArray, PushPop) {
462 Apto::Array<int, Apto::ManagedPointer> array;
463 EXPECT_EQ(0, array.GetSize());
464
465 for (int i = 0; i < 3; i++) array.Push(i);
466 EXPECT_EQ(3, array.GetSize());
467 EXPECT_EQ(2, array[2]);
468
469 EXPECT_EQ(2, array.Pop());
470 EXPECT_EQ(2, array.GetSize());
471 EXPECT_EQ(1, array.Pop());
472 array.Push(8);
473 EXPECT_EQ(8, array.Pop());
474 EXPECT_EQ(1, array.GetSize());
475 }
476
TEST(CoreManagedPointerArray,Swap)477 TEST(CoreManagedPointerArray, Swap) {
478 Apto::Array<int, Apto::ManagedPointer> array(3);
479 for (int i = 0; i < 3; i++) array[i] = i;
480
481 EXPECT_EQ(0, array[0]);
482 EXPECT_EQ(1, array[1]);
483 EXPECT_EQ(2, array[2]);
484
485 array.Swap(0, 2);
486
487 EXPECT_EQ(2, array[0]);
488 EXPECT_EQ(1, array[1]);
489 EXPECT_EQ(0, array[2]);
490 }
491
TEST(CoreManagedPointerArray,SetAll)492 TEST(CoreManagedPointerArray, SetAll) {
493 Apto::Array<int, Apto::ManagedPointer> array(3);
494
495 array.SetAll(2);
496 for (int i = 0; i < array.GetSize(); i++) EXPECT_EQ(2, array[i]);
497
498 array.SetAll(26);
499 for (int i = 0; i < array.GetSize(); i++) EXPECT_EQ(26, array[i]);
500 }
501
TEST(CoreManagedPointerArray,Iterators)502 TEST(CoreManagedPointerArray, Iterators) {
503 Apto::Array<int, Apto::ManagedPointer> array(5);
504 for (int i = 0; i < 5; i++) array[i] = i;
505
506 Apto::Array<int, Apto::ManagedPointer>::Iterator it = array.Begin();
507 int i = 0;
508 while (it.Next()) {
509 EXPECT_EQ(i, *it.Get());
510 i++;
511 }
512
513 const Apto::Array<int, Apto::ManagedPointer>& const_array = array;
514 Apto::Array<int, Apto::ManagedPointer>::ConstIterator cit = const_array.Begin();
515 i = 0;
516 while (cit.Next()) {
517 EXPECT_EQ(i, *cit.Get());
518 i++;
519 }
520 }
521
522
TEST(CoreManagedPointerArray,Comparison)523 TEST(CoreManagedPointerArray, Comparison) {
524 Apto::Array<int, Apto::ManagedPointer> array1(3);
525 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
526
527 Apto::Array<int, Apto::ManagedPointer> array2(array1);
528 array2[1] = 5;
529
530 EXPECT_TRUE(array1 == array1);
531 EXPECT_TRUE(array2 == array2);
532 EXPECT_TRUE(array1 != array2);
533 EXPECT_FALSE(array1 == array2);
534 EXPECT_FALSE(array1 != array1);
535 EXPECT_FALSE(array2 != array2);
536 }
537
538
TEST(CoreManagedPointerArray,Concatenation)539 TEST(CoreManagedPointerArray, Concatenation) {
540 Apto::Array<int, Apto::ManagedPointer> array1(3);
541 for (int i = 0; i < array1.GetSize(); i++) array1[i] = i;
542
543 Apto::Array<int, Apto::ManagedPointer> array2(1);
544 array2[0] = 5;
545
546 array2 += array2;
547 EXPECT_EQ(2, array2.GetSize());
548 EXPECT_EQ(5, array2[0]);
549 EXPECT_EQ(5, array2[1]);
550
551 array1 += array2;
552
553 EXPECT_EQ(0, array1[0]);
554 EXPECT_EQ(1, array1[1]);
555 EXPECT_EQ(2, array1[2]);
556 EXPECT_EQ(5, array1[3]);
557 EXPECT_EQ(5, array1[4]);
558
559 Apto::Array<int, Apto::ManagedPointer> array3 = array2 + array2;
560 EXPECT_EQ(4, array3.GetSize());
561 EXPECT_EQ(5, array3[0]);
562 EXPECT_EQ(5, array3[1]);
563 EXPECT_EQ(5, array3[2]);
564 EXPECT_EQ(5, array3[3]);
565
566 array2 = array2 + array2;
567 EXPECT_TRUE(array2 == array3);
568 }
569
570
571