Skip to content

Commit ebcf50d

Browse files
RaelrRaelr
committed
Added unit tests for new iteration functions for collections
1 parent 44cdb79 commit ebcf50d

File tree

4 files changed

+551
-1
lines changed

4 files changed

+551
-1
lines changed

‎engine/utils/collections/HeapArray.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -243,7 +243,7 @@ class MHArray
243243
return;
244244
}
245245

246-
// Every 8 positions are represented with one 8 bit unsigned integer. As such, every 8
246+
// Every 8 positions are represented with one 8-bit unsigned integer. As such, every 8
247247
// elements in the array represents one to the size of our collection of byte masks.
248248
size_t newByteCount = ((newSize / BitUtils::BYTE_SIZE_IN_BITS) + 1);
249249

‎tests/utils/test_HeapArray.cpp‎

Lines changed: 222 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -609,3 +609,225 @@ UTEST(test_MHArray, ClearEmptyArray)
609609
ASSERT_EQ(array.Count(), 0);
610610
ASSERT_EQ(array.Data(), nullptr);
611611
}
612+
613+
UTEST(test_MHArray, IterateWithFunction)
614+
{
615+
MHArray<uint32_t> array = {1, 2, 3, 4, 5};
616+
617+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
618+
619+
size_t i = 0;
620+
array.ForEach([&](uint32_t& val) {
621+
ASSERT_EQ(expectedResults[i], val);
622+
i++;
623+
});
624+
}
625+
626+
UTEST(test_MHArray, IterateWithFunctionAndIndex)
627+
{
628+
MHArray<uint32_t> array = {1, 2, 3, 4, 5};
629+
630+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
631+
632+
array.ForEachI([&](uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
633+
}
634+
635+
UTEST(test_MHArray, IterateWithConstFunction)
636+
{
637+
MHArray<uint32_t> array = {1, 2, 3, 4, 5};
638+
639+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
640+
641+
size_t i = 0;
642+
array.ForEach([&](const uint32_t& val) {
643+
ASSERT_EQ(expectedResults[i], val);
644+
i++;
645+
});
646+
}
647+
648+
UTEST(test_MHArray, IterateWithConstFunctionOnConstArray)
649+
{
650+
const MHArray<uint32_t> array = {1, 2, 3, 4, 5};
651+
652+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
653+
654+
size_t i = 0;
655+
array.ForEach([&](const uint32_t& val) {
656+
ASSERT_EQ(expectedResults[i], val);
657+
i++;
658+
});
659+
}
660+
661+
UTEST(test_MHArray, IterateWithConstFunctionAndIndex)
662+
{
663+
MHArray<uint32_t> array = {1, 2, 3, 4, 5};
664+
665+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
666+
667+
array.ForEachI([&](const uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
668+
}
669+
670+
UTEST(test_MHArray, IterateWithConstFunctionAndIndexOnConstArray)
671+
{
672+
const MHArray<uint32_t> array = {1, 2, 3, 4, 5};
673+
674+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
675+
676+
array.ForEachI([&](const uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
677+
}
678+
679+
UTEST(test_MHArray, IterateWithFunctionOverZeroSizedArray)
680+
{
681+
MHArray<uint32_t> array;
682+
683+
size_t i = 0;
684+
array.ForEach([&](uint32_t& val) { i++; });
685+
686+
ASSERT_EQ(i, 0);
687+
}
688+
689+
UTEST(test_MHArray, IterateWithFunctionOverEmptyArray)
690+
{
691+
MHArray<uint32_t> array(5);
692+
693+
size_t i = 0;
694+
array.ForEach([&](uint32_t& val) { i++; });
695+
696+
ASSERT_EQ(i, 5);
697+
}
698+
699+
UTEST(test_MHArray, IterateWithFunctionOverZeroSizedArrayWithIndex)
700+
{
701+
MHArray<uint32_t> array;
702+
703+
size_t iterations = 0;
704+
array.ForEachI([&](uint32_t& val, size_t i) { iterations++; });
705+
706+
ASSERT_EQ(iterations, 0);
707+
}
708+
709+
UTEST(test_MHArray, IterateWithFunctionOverEmptyArrayWithIndex)
710+
{
711+
MHArray<uint32_t> array(5);
712+
713+
size_t iterations = 0;
714+
array.ForEachI([&](uint32_t& val, size_t i) { iterations++; });
715+
716+
ASSERT_EQ(iterations, 5);
717+
}
718+
719+
UTEST(test_MHArray, IterateWithManagedFunction)
720+
{
721+
MHArray<uint32_t> array = {1, 2, 3, 4, 5};
722+
723+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
724+
725+
size_t i = 0;
726+
array.MForEach([&](uint32_t& val) {
727+
ASSERT_EQ(expectedResults[i], val);
728+
i++;
729+
});
730+
}
731+
732+
UTEST(test_MHArray, IterateWithManagedFunctionAndIndex)
733+
{
734+
MHArray<uint32_t> array = {1, 2, 3, 4, 5};
735+
736+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
737+
738+
array.MForEachI([&](uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
739+
}
740+
741+
UTEST(test_MHArray, IterateWithManagedFunctionOnConstArray)
742+
{
743+
const MHArray<uint32_t> array = {1, 2, 3, 4, 5};
744+
745+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
746+
747+
size_t i = 0;
748+
array.MForEach([&](const uint32_t& val) {
749+
ASSERT_EQ(expectedResults[i], val);
750+
i++;
751+
});
752+
}
753+
754+
UTEST(test_MHArray, IterateWithManagedFunctionAndIndexOnConstArray)
755+
{
756+
const MHArray<uint32_t> array = {1, 2, 3, 4, 5};
757+
758+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
759+
760+
array.MForEachI([&](const uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
761+
}
762+
763+
UTEST(test_MHArray, IterateWithManagedFunctionAndConstant)
764+
{
765+
MHArray<uint32_t> array = {1, 2, 3, 4, 5};
766+
767+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
768+
769+
size_t i = 0;
770+
array.MForEach([&](const uint32_t& val) {
771+
ASSERT_EQ(expectedResults[i], val);
772+
i++;
773+
});
774+
}
775+
776+
UTEST(test_MHArray, IterateWithManagedFunctionAndIndexAndConstant)
777+
{
778+
MHArray<uint32_t> array = {1, 2, 3, 4, 5};
779+
780+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
781+
782+
array.MForEachI([&](const uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
783+
}
784+
785+
UTEST(test_MHArray, IterateWithManagedFunctionWithGaps)
786+
{
787+
MHArray<uint32_t> array(5);
788+
789+
array[1] = 2;
790+
array[3] = 4;
791+
array[4] = 0;
792+
793+
uint32_t expectedResults[] = {2, 4, 0};
794+
795+
size_t i = 0;
796+
array.MForEach([&](uint32_t& val) {
797+
ASSERT_EQ(expectedResults[i], val);
798+
i++;
799+
});
800+
}
801+
802+
UTEST(test_MHArray, IterateWithManagedFunctionAndIndexWithGaps)
803+
{
804+
MHArray<uint32_t> array(5);
805+
806+
array[1] = 2;
807+
array[3] = 4;
808+
array[4] = 0;
809+
810+
uint32_t expectedResults[] = {2, 4, 0};
811+
812+
array.MForEachI([&](uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
813+
}
814+
815+
UTEST(test_MHArray, IterateOverEmptyArrayWithManagedFunction)
816+
{
817+
MHArray<uint32_t> array;
818+
819+
size_t iterations = 0;
820+
array.MForEach([&](uint32_t& val) { iterations++; });
821+
822+
ASSERT_EQ(0, iterations);
823+
}
824+
825+
UTEST(test_MHArray, IterateOverEmptyArrayWithManagedFunctionAndIndex)
826+
{
827+
MHArray<uint32_t> array;
828+
829+
size_t iterations = 0;
830+
array.MForEachI([&](uint32_t& val, size_t i) { iterations++; });
831+
832+
ASSERT_EQ(0, iterations);
833+
}

‎tests/utils/test_SArray.cpp‎

Lines changed: 106 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -224,4 +224,110 @@ UTEST(test_SArray, IterateOverSingleElementSArray)
224224
{
225225
ASSERT_EQ(expectedResults[index++], *it);
226226
}
227+
}
228+
229+
UTEST(test_SArray, IterateWithFunction)
230+
{
231+
SArray<uint32_t, 5> array = {1, 2, 3, 4, 5};
232+
233+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
234+
235+
size_t i = 0;
236+
array.ForEach([&](uint32_t& val) {
237+
ASSERT_EQ(expectedResults[i], val);
238+
i++;
239+
});
240+
}
241+
242+
UTEST(test_SArray, IterateWithFunctionAndIndex)
243+
{
244+
SArray<uint32_t, 5> array = {1, 2, 3, 4, 5};
245+
246+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
247+
248+
array.ForEachI([&](uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
249+
}
250+
251+
UTEST(test_SArray, IterateWithConstFunction)
252+
{
253+
SArray<uint32_t, 5> array = {1, 2, 3, 4, 5};
254+
255+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
256+
257+
size_t i = 0;
258+
array.ForEach([&](const uint32_t& val) {
259+
ASSERT_EQ(expectedResults[i], val);
260+
i++;
261+
});
262+
}
263+
264+
UTEST(test_SArray, IterateWithConstFunctionAndIndex)
265+
{
266+
SArray<uint32_t, 5> array = {1, 2, 3, 4, 5};
267+
268+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
269+
270+
array.ForEachI([&](const uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
271+
}
272+
273+
UTEST(test_SArray, IterateWithConstFunctionOnConstArray)
274+
{
275+
const SArray<uint32_t, 5> array = {1, 2, 3, 4, 5};
276+
277+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
278+
279+
size_t i = 0;
280+
array.ForEach([&](const uint32_t& val) {
281+
ASSERT_EQ(expectedResults[i], val);
282+
i++;
283+
});
284+
}
285+
286+
UTEST(test_SArray, IterateWithConstFunctionAndIndexOnConstArray)
287+
{
288+
const SArray<uint32_t, 5> array = {1, 2, 3, 4, 5};
289+
290+
uint32_t expectedResults[] = {1, 2, 3, 4, 5};
291+
292+
array.ForEachI([&](const uint32_t& val, size_t i) { ASSERT_EQ(expectedResults[i], val); });
293+
}
294+
295+
UTEST(test_SArray, IterateWithFunctionOverZeroSizedArray)
296+
{
297+
SArray<uint32_t, 0> array;
298+
299+
size_t i = 0;
300+
array.ForEach([&](uint32_t& val) { i++; });
301+
302+
ASSERT_EQ(i, 0);
303+
}
304+
305+
UTEST(test_SArray, IterateWithFunctionOverEmptyArray)
306+
{
307+
SArray<uint32_t, 5> array;
308+
309+
size_t i = 0;
310+
array.ForEach([&](uint32_t& val) { i++; });
311+
312+
ASSERT_EQ(i, 5);
313+
}
314+
315+
UTEST(test_SArray, IterateWithFunctionOverZeroSizedArrayWithIndex)
316+
{
317+
SArray<uint32_t, 0> array;
318+
319+
size_t iterations = 0;
320+
array.ForEachI([&](uint32_t& val, size_t i) { iterations++; });
321+
322+
ASSERT_EQ(iterations, 0);
323+
}
324+
325+
UTEST(test_SArray, IterateWithFunctionOverEmptyArrayWithIndex)
326+
{
327+
SArray<uint32_t, 5> array;
328+
329+
size_t iterations = 0;
330+
array.ForEachI([&](uint32_t& val, size_t i) { iterations++; });
331+
332+
ASSERT_EQ(iterations, 5);
227333
}

0 commit comments

Comments
 (0)