jcrussell/libsst
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
71230f918f95b75d8569cd2ccd6395d0919f873d
libsst/ZTestSuite/Test-ZArrayAlgo.cpp
James Russell eca1e8c458 Initial commit
2026-04-03 00:22:39 -05:00

3164 lines
100 KiB
C++
Raw Blame History

#include "ZUnitTest.hpp"
#include <ZSTL/ZArrayAlgo.hpp>
static const char* test_Append();
static const char* test_Append_Region();
static const char* test_Apply();
static const char* test_Apply_Region();
static const char* test_Concatenate();
static const char* test_Concatenate_Region();
static const char* test_Contains();
static const char* test_Contains_Region();
static const char* test_ContainsSub();
static const char* test_ContainsSub_Region();
static const char* test_Copy();
static const char* test_Copy_Region();
static const char* test_Count();
static const char* test_Count_Region();
static const char* test_Equal();
static const char* test_Equal_In_Region();
static const char* test_Fill();
static const char* test_Fill_Region();
static const char* test_Find();
static const char* test_Find_Region();
static const char* test_FindAll();
static const char* test_FindAll_Region();
static const char* test_FindAllOf();
static const char* test_FindAllOf_Region();
static const char* test_FindIf();
static const char* test_FindIf_In_Region();
static const char* test_FindFirst();
static const char* test_FindFirst_In_Region();
static const char* test_FindFirstOf();
static const char* test_FindFirstOf_In_Region();
static const char* test_FindFirstNot();
static const char* test_FindFirstNot_In_Region();
static const char* test_FindFirstNotOf();
static const char* test_FindFirstNotOf_In_Region();
static const char* test_FindLast();
static const char* test_FindLast_In_Region();
static const char* test_FindLastOf();
static const char* test_FindLastOf_In_Region();
static const char* test_FindLastNot();
static const char* test_FindLastNot_In_Region();
static const char* test_FindLastNotOf();
static const char* test_FindLastNotOf_In_Region();
static const char* test_FindSub();
static const char* test_FindSub_In_Region();
static const char* test_FoldLeft();
static const char* test_FoldLeft_Region();
static const char* test_FoldRight();
static const char* test_FoldRight_Region();
static const char* test_Generate();
static const char* test_Generate_In_Region();
static const char* test_Max();
static const char* test_Max_In_Region();
static const char* test_Max_Comparator();
static const char* test_Max_Comparator_In_Region();
static const char* test_Min();
static const char* test_Min_In_Region();
static const char* test_Min_Comparator();
static const char* test_Min_Comparator_In_Region();
static const char* test_Remove();
static const char* test_Remove_In_Region();
static const char* test_RemoveAll();
static const char* test_RemoveAll_In_Region();
static const char* test_RemoveIf();
static const char* test_RemoveIf_In_Region();
static const char* test_RemoveUpTo();
static const char* test_RemoveUpTo_In_Region();
static const char* test_Replace();
static const char* test_Replace_In_Region();
static const char* test_ReplaceIf();
static const char* test_ReplaceIf_In_Region();
static const char* test_Reverse();
static const char* test_Reverse_Region();
static const char* test_Rotate();
static const char* test_Rotate_Region();
static const char* test_SetIntersection();
static const char* test_SetIntersection_In_Region();
static const char* test_SetUnion();
static const char* test_SetUnion_In_Region();
static const char* test_Slice();
static const char* test_Sort();
static const char* test_Sort_Region();
static const char* test_Sort_Comparator();
static const char* test_Sort_Comparator_Algorithm();
static const char* test_Sort_Comparator_Algorithm_Region();
static const char* test_Split();
static const char* test_Split_Count();
static const char* test_Split_Count_Region();
static const char* test_Sum();
static const char* test_Sum_Region();
static const char* test_SwapElements();
static const char* test_Map();
static const char* test_Map_Region();
static const char* test_Unique();
static const char* test_Unique_In_Region();
//List of unit tests
ZUnitTest ZArrayAlgoUnitTests[] =
{
{ "ZArrayAlgo: Append", test_Append },
{ "ZArrayAlgo: Append region", test_Append_Region },
{ "ZArrayAlgo: Apply", test_Apply} ,
{ "ZArrayAlgo: Apply to region", test_Apply_Region} ,
{ "ZArrayAlgo: Concatenate", test_Concatenate },
{ "ZArrayAlgo: Concatenate region", test_Concatenate_Region },
{ "ZArrayAlgo: Contains", test_Contains },
{ "ZArrayAlgo: Contains region", test_Contains_Region },
{ "ZArrayAlgo: ContainsSub", test_ContainsSub },
{ "ZArrayAlgo: ContainsSub region", test_ContainsSub_Region },
{ "ZArrayAlgo: Copy", test_Copy },
{ "ZArrayAlgo: Copy region", test_Copy_Region },
{ "ZArrayAlgo: Count", test_Count },
{ "ZArrayAlgo: Count region", test_Count_Region },
{ "ZArrayAlgo: Equal", test_Equal },
{ "ZArrayAlgo: Equal in region", test_Equal_In_Region },
{ "ZArrayAlgo: Fill", test_Fill },
{ "ZArrayAlgo: Fill region", test_Fill_Region },
{ "ZArrayAlgo: Find ", test_Find },
{ "ZArrayAlgo: Find in region", test_Find_Region },
{ "ZArrayAlgo: FindAll ", test_FindAll },
{ "ZArrayAlgo: FindAll region ", test_FindAll_Region },
{ "ZArrayAlgo: FindAllOf ", test_FindAllOf },
{ "ZArrayAlgo: FindAllOf region ", test_FindAllOf_Region },
{ "ZArrayAlgo: FindIf", test_FindIf },
{ "ZArrayAlgo: FindIf in region", test_FindIf_In_Region },
{ "ZArrayAlgo: FindFirst", test_FindFirst },
{ "ZArrayAlgo: FindFirst in region", test_FindFirst_In_Region },
{ "ZArrayAlgo: FindFirstOf", test_FindFirstOf },
{ "ZArrayAlgo: FindFirstOf in region", test_FindFirstOf_In_Region },
{ "ZArrayAlgo: FindFirstNot", test_FindFirstNot },
{ "ZArrayAlgo: FindFirstNot in region", test_FindFirstNot_In_Region },
{ "ZArrayAlgo: FindFirstNotOf", test_FindFirstNotOf },
{ "ZArrayAlgo: FindFirstNotOf in region", test_FindFirstNotOf_In_Region },
{ "ZArrayAlgo: FindLast", test_FindLast},
{ "ZArrayAlgo: FindLast in region", test_FindLast_In_Region},
{ "ZArrayAlgo: FindLastOf", test_FindLastOf} ,
{ "ZArrayAlgo: FindLastOf in region", test_FindLastOf_In_Region} ,
{ "ZArrayAlgo: FindLastNot", test_FindLastNot},
{ "ZArrayAlgo: FindLastNot in region", test_FindLastNot_In_Region} ,
{ "ZArrayAlgo: FindLastNotOf", test_FindLastNotOf},
{ "ZArrayAlgo: FindLastNotOf in region", test_FindLastNotOf_In_Region} ,
{ "ZArrayAlgo: FindSub", test_FindSub },
{ "ZArrayAlgo: FindSub in region", test_FindSub_In_Region },
{ "ZArrayAlgo: FoldLeft", test_FoldLeft },
{ "ZArrayAlgo: FoldLeft region", test_FoldLeft_Region },
{ "ZArrayAlgo: FoldRight", test_FoldRight },
{ "ZArrayAlgo: FoldRight region", test_FoldRight_Region },
{ "ZArrayAlgo: Generate", test_Generate},
{ "ZArrayAlgo: Generate in region", test_Generate_In_Region} ,
{ "ZArrayAlgo: Map", test_Map} ,
{ "ZArrayAlgo: Map region", test_Map_Region} ,
{ "ZArrayAlgo: Max", test_Max} ,
{ "ZArrayAlgo: Max in region", test_Max_In_Region} ,
{ "ZArrayAlgo: Max with comparator", test_Max_Comparator} ,
{ "ZArrayAlgo: Max with comparator in region", test_Max_Comparator_In_Region} ,
{ "ZArrayAlgo: Min", test_Min} ,
{ "ZArrayAlgo: Min in region", test_Min_In_Region} ,
{ "ZArrayAlgo: Min comparator", test_Min_Comparator} ,
{ "ZArrayAlgo: Min comparator in region", test_Min_Comparator_In_Region} ,
{ "ZArrayAlgo: Remove", test_Remove} ,
{ "ZArrayAlgo: Remove in region", test_Remove_In_Region} ,
{ "ZArrayAlgo: RemoveAll", test_RemoveAll} ,
{ "ZArrayAlgo: RemoveAll in region", test_RemoveAll_In_Region} ,
{ "ZArrayAlgo: RemoveIf", test_RemoveIf} ,
{ "ZArrayAlgo: RemoveIf in region", test_RemoveIf_In_Region} ,
{ "ZArrayAlgo: RemoveUpTo", test_RemoveUpTo} ,
{ "ZArrayAlgo: RemoveUpTo in region", test_RemoveUpTo_In_Region} ,
{ "ZArrayAlgo: Replace", test_Replace} ,
{ "ZArrayAlgo: Replace in region", test_Replace_In_Region} ,
{ "ZArrayAlgo: ReplaceIf", test_ReplaceIf} ,
{ "ZArrayAlgo: ReplaceIf in region", test_ReplaceIf_In_Region} ,
{ "ZArrayAlgo: Reverse", test_Reverse} ,
{ "ZArrayAlgo: Reverse region", test_Reverse_Region} ,
{ "ZArrayAlgo: Rotate", test_Rotate} ,
{ "ZArrayAlgo: Rotate region", test_Rotate_Region} ,
{ "ZArrayAlgo: SetIntersection", test_SetIntersection} ,
{ "ZArrayAlgo: SetIntersection in region", test_SetIntersection_In_Region} ,
{ "ZArrayAlgo: SetUnion", test_SetUnion} ,
{ "ZArrayAlgo: SetUnion in region", test_SetUnion_In_Region} ,
{ "ZArrayAlgo: Slice", test_Slice },
{ "ZArrayAlgo: Sort", test_Sort} ,
{ "ZArrayAlgo: Sort region", test_Sort_Region} ,
{ "ZArrayAlgo: Sort given comparator", test_Sort_Comparator} ,
{ "ZArrayAlgo: Sort given comparator and algorithm", test_Sort_Comparator_Algorithm} ,
{ "ZArrayAlgo: Sort given comparator and algorithm in region", test_Sort_Comparator_Algorithm_Region},
{ "ZArrayAlgo: Split", test_Split },
{ "ZArrayAlgo: Split with count", test_Split_Count },
{ "ZArrayAlgo: Split with count in region", test_Split_Count_Region },
{ "ZArrayAlgo: Sum", test_Sum },
{ "ZArrayAlgo: Sum region", test_Sum_Region },
{ "ZArrayAlgo: SwapElements", test_SwapElements} ,
{ "ZArrayAlgo: Unique", test_Unique} ,
{ "ZArrayAlgo: Unique given comparator in region", test_Unique_In_Region}
};
//Now declare the ZUnitTestBlock associated with this.
DECLARE_ZTESTBLOCK(ZArrayAlgo);
/*************************************************************************/
class ArrayValueTestClass
{
public:
int val;
ArrayValueTestClass() : val( 0 ) {}
ArrayValueTestClass(int v) : val(v) {}
ArrayValueTestClass operator + (const ArrayValueTestClass& _other)
{
return ArrayValueTestClass(val + _other.val);
}
};
struct IfTestFunctor {
bool operator () (const int& val) { return val > 3; }
};
/*************************************************************************/
static const char* test_Append()
{
ZArray<int> list;
ZArray<int> list2;
ZArray<int> out;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
list2.PushBack(6);
ZArrayAlgo::Append(list,list2);
TASSERT(list.Size() == 6, "Append() created list!\n");
TASSERT(list.PopFront() == 1, "Append() corrupted list!\n");
TASSERT(list.PopFront() == 2, "Append() corrupted list!\n");
TASSERT(list.PopFront() == 3, "Append() corrupted list!\n");
TASSERT(list.PopFront() == 4, "Append() corrupted list!\n");
TASSERT(list.PopFront() == 5, "Append() corrupted list!\n");
TASSERT(list.PopFront() == 6, "Append() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Append_Region()
{
ZArray<int> list;
ZArray<int> list2;
ZArray<int> out;
list.PushBack(1);
list.PushBack(2);
list2.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
list2.PushBack(6);
ZArrayAlgo::Append(list,list2,1,3);
TASSERT(list.Size() == 4, "Append() corrupted list!\n");
TASSERT(list.PopFront() == 1, "Append() corrupted list!\n");
TASSERT(list.PopFront() == 2, "Append() corrupted list!\n");
TASSERT(list.PopFront() == 4, "Append() corrupted list!\n");
TASSERT(list.PopFront() == 5, "Append() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
struct ApplyTestFunctor{ void operator()(int& _val) const { _val *= -1 ;} };
static const char* test_Apply()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ZArrayAlgo::Apply(list, ApplyTestFunctor());
TASSERT(list.Size() == 5, "Apply() changed list length!\n");
TASSERT(list.PopFront() == -1, "Apply() did not apply functor!\n");
TASSERT(list.PopFront() == -2, "Apply() did not apply functor!\n");
TASSERT(list.PopFront() == -3, "Apply() did not apply functor!\n");
TASSERT(list.PopFront() == -4, "Apply() did not apply functor!\n");
TASSERT(list.PopFront() == -5, "Apply() did not apply functor!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Apply_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ZArrayAlgo::Apply(list, ApplyTestFunctor(), 1, 4);
TASSERT(list.Size() == 5, "Apply() changed list length!\n");
TASSERT(list.PopFront() == 1, "Apply() did not apply functor!\n");
TASSERT(list.PopFront() == -2, "Apply() did not apply functor!\n");
TASSERT(list.PopFront() == -3, "Apply() did not apply functor!\n");
TASSERT(list.PopFront() == -4, "Apply() did not apply functor!\n");
TASSERT(list.PopFront() == 5, "Apply() did not apply functor!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Concatenate()
{
ZArray<int> list;
ZArray<int> list2;
ZArray<int> out;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
list2.PushBack(6);
out = ZArrayAlgo::Concatenate(list,list2);
TASSERT(out.Size() == 6, "Append() created list of incorrect size!\n");
TASSERT(out.PopFront() == 1, "Append() corrupted list!\n");
TASSERT(out.PopFront() == 2, "Append() corrupted list!\n");
TASSERT(out.PopFront() == 3, "Append() corrupted list!\n");
TASSERT(out.PopFront() == 4, "Append() corrupted list!\n");
TASSERT(out.PopFront() == 5, "Append() corrupted list!\n");
TASSERT(out.PopFront() == 6, "Append() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Concatenate_Region()
{
ZArray<int> list;
ZArray<int> list2;
ZArray<int> out;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list2.PushBack(5);
list2.PushBack(6);
list2.PushBack(7);
list2.PushBack(8);
out = ZArrayAlgo::Concatenate(list,1,3,list2,1,3);
TASSERT(out.Size() == 4, "Append() created list of incorrect size!\n");
TASSERT(out.PopFront() == 2, "Append() corrupted list!\n");
TASSERT(out.PopFront() == 3, "Append() corrupted list!\n");
TASSERT(out.PopFront() == 6, "Append() corrupted list!\n");
TASSERT(out.PopFront() == 7, "Append() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Contains()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
TASSERT( ZArrayAlgo::Contains(list, 2) == true, "Contains() missed an existing element!\n");
TASSERT( ZArrayAlgo::Contains(list, 5) == false, "Contains() found an nonexisting element!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Contains_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
TASSERT( ZArrayAlgo::Contains(list, 2, 1, 5) == true, "Contains() missed an existing element inside of range!\n");
TASSERT( ZArrayAlgo::Contains(list, 6, 1, 5) == false, "Contains() found an existing element outside of range!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_ContainsSub()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
ZArray<int> list2;
list2.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
ZArray<int> list3;
list3.PushBack(3);
list3.PushBack(5);
TASSERT(ZArrayAlgo::ContainsSub(list, list2), "ContainsSub() failed to return true when sub list is contained!");
TASSERT(!ZArrayAlgo::ContainsSub(list, list3), "ContainsSub() failed to return false when sub list is not contained!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_ContainsSub_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
ZArray<int> list2;
list2.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
TASSERT(ZArrayAlgo::ContainsSub(list, 2, 5, list2, 0, list2.Size()), "ContainsSub() failed to return true when sub list is contained in region 1!");
TASSERT(!ZArrayAlgo::ContainsSub(list, 3, 5, list2, 0, list2.Size()), "ContainsSub() failed to return false when sub list is not contained in region!");
TASSERT(ZArrayAlgo::ContainsSub(list, 3, 5, list2, 1, 3), "ContainsSub() failed to return true when sub list is contained in region 2!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Copy()
{
ZArray<int> list;
ZArray<int> list2;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list2.PushBack(5);
list2.PushBack(6);
list2.PushBack(7);
list2.PushBack(8);
ZArrayAlgo::Copy(list2, list);
TASSERT( list2.PopFront() == 1, "Copy() failed to copy correct element!\n");
TASSERT( list2.PopFront() == 2, "Copy() failed to copy correct element!\n");
TASSERT( list2.PopFront() == 3, "Copy() failed to copy correct element!\n");
TASSERT( list2.PopFront() == 8, "Copy() overrode out-of-range element!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Copy_Region()
{
ZArray<int> list;
ZArray<int> list2;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list2.PushBack(5);
list2.PushBack(6);
list2.PushBack(7);
list2.PushBack(8);
ZArrayAlgo::Copy(list2, 1, 3, list, 2, 4);
TASSERT( list2.PopFront() == 5, "Copy() failed to copy correct element!\n");
TASSERT( list2.PopFront() == 3, "Copy() failed to copy correct element!\n");
TASSERT( list2.PopFront() == 4, "Copy() failed to copy correct element!\n");
TASSERT( list2.PopFront() == 8, "Copy() failed to copy correct element!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Count()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
TASSERT( ZArrayAlgo::Count(list, 2) == 4, "Count() failed to get accurate count of existing element!\n");
TASSERT( ZArrayAlgo::Count(list, 5) == 0, "Count() failed to get accurate count of nonexisting element!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Count_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
TASSERT( ZArrayAlgo::Count(list, 2, 2, 6) == 3, "Count() failed to get accurate count of existing element!\n");
TASSERT( ZArrayAlgo::Count(list, 1, 2, 6) == 0, "Count() failed to get accurate count of existing element outside of range!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Equal()
{
ZArray<int> list;
ZArray<int> list2a;
ZArray<int> list2b;
ZArray<int> list3;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list2a.PushBack(1);
list2a.PushBack(2);
list2a.PushBack(3);
list2a.PushBack(4);
list3.PushBack(5);
list3.PushBack(6);
list3.PushBack(7);
list3.PushBack(8);
TASSERT( ZArrayAlgo::Equal(list, list2a) == true, "Equal() reported nonequailty on identical lists!\n");
TASSERT( ZArrayAlgo::Equal(list, list3) == false, "Equal() reported equality on different lists!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Equal_In_Region()
{
ZArray<int> list;
ZArray<int> list2a;
ZArray<int> list2b;
ZArray<int> list3;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list2a.PushBack(1);
list2a.PushBack(2);
list2a.PushBack(3);
list2a.PushBack(4);
list2b.PushBack(0);
list2b.PushBack(1);
list2b.PushBack(2);
list2b.PushBack(3);
list3.PushBack(5);
list3.PushBack(6);
list3.PushBack(7);
list3.PushBack(8);
TASSERT( ZArrayAlgo::Equal(list, 1, 4, list2a, 1, 4) == true, "Equal() reported nonequailty on identical sublists!\n");
TASSERT( ZArrayAlgo::Equal(list, 0, 3, list2b, 1, 4) == true, "Equal() reported nonequailty on identical sublists!\n");
TASSERT( ZArrayAlgo::Equal(list, 1, 4, list3, 1, 4) == false, "Equal() reported equality on different lists!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Fill()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
ZArrayAlgo::Fill(list, 4);
TASSERT( list.Size() == 3, "Fill() changed size of array!\n");
TASSERT( list.PopFront() == 4, "Fill() didn't fill array correctly!\n");
TASSERT( list.PopFront() == 4, "Fill() didn't fill array correctly!\n");
TASSERT( list.PopFront() == 4, "Fill() didn't fill array correctly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Fill_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ZArrayAlgo::Fill(list, 6, 1, 4);
TASSERT( list.Size() == 5, "Fill() changed size of array!\n");
TASSERT( list.PopFront() == 1, "Fill() didn't fill array correctly!\n");
TASSERT( list.PopFront() == 6, "Fill() didn't fill array correctly!\n");
TASSERT( list.PopFront() == 6, "Fill() didn't fill array correctly!\n");
TASSERT( list.PopFront() == 6, "Fill() didn't fill array correctly!\n");
TASSERT( list.PopFront() == 5, "Fill() didn't fill array correctly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Find()
{
ZArray<int> list;
list.PushBack(0); // 0
list.PushBack(1); // 1
list.PushBack(0); // 2
list.PushBack(3); // 3
list.PushBack(3); // 4
list.PushBack(0); // 5
list.PushBack(6); // 6
list.PushBack(3); // 7
list.PushBack(0); // 8
list.PushBack(3); // 9
list.PushBack(3); // 10
list.PushBack(0); // 11
TASSERT( ZArrayAlgo::Find(list,42,0) == ZSTL::InvalidPos, "Find() found missing element!\n");
TASSERT( ZArrayAlgo::Find(list,0,0) == 0, "Find() missed element at front!\n");
TASSERT( ZArrayAlgo::Find(list,0,4) == 11, "Find() miscounted elements!\n");
TASSERT( ZArrayAlgo::Find(list,0,23) == ZSTL::InvalidPos, "Find() found excess (nonexistent) element!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Find_Region()
{
ZArray<int> list;
list.PushBack(0); // 0
list.PushBack(1); // 1
list.PushBack(0); // 2
list.PushBack(3); // 3
list.PushBack(3); // 4
list.PushBack(0); // 5
list.PushBack(6); // 6
list.PushBack(3); // 7
list.PushBack(0); // 8
list.PushBack(3); // 9
list.PushBack(3); // 10
list.PushBack(0); // 11
TASSERT( ZArrayAlgo::Find(list,42,0,2,10) == ZSTL::InvalidPos, "Find() found missing element!\n");
TASSERT( ZArrayAlgo::Find(list,0,0,2,10) == 2, "Find() missed element at front!\n");
TASSERT( ZArrayAlgo::Find(list,0,2,2,10) == 8, "Find() miscounted elements!\n");
TASSERT( ZArrayAlgo::Find(list,0,23,2,10) == ZSTL::InvalidPos, "Find() found excess (nonexistent) element!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindAll()
{
ZArray<int> list;
list.PushBack(0); // 0
list.PushBack(1); // 1
list.PushBack(0); // 2
list.PushBack(3); // 3
list.PushBack(3); // 4
list.PushBack(0); // 5
list.PushBack(6); // 6
list.PushBack(3); // 7
list.PushBack(0); // 8
list.PushBack(3); // 9
list.PushBack(3); // 10
list.PushBack(0); // 11
ZArray<size_t> inds;
// search for nonexistent value
inds = ZArrayAlgo::FindAll(list, 10);
TASSERT(inds.Empty(), "FindAll() found nonexistent elements!\n");
// search for multiple elements
inds = ZArrayAlgo::FindAll(list, 3);
TASSERT(inds.Size() == 5, "FindAll() did not find all elements!\n");
TASSERT(inds.PopFront() == 3,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 4,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 7,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 9,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 10,"FindAll() found element in incorrect position!\n");
// search for existing elements in middle and ends
inds = ZArrayAlgo::FindAll(list, 0);
TASSERT(inds.Size() == 5, "FindAll() did not find all elements!\n");
TASSERT(inds.PopFront() == 0,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 2,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 5,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 8,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 11,"FindAll() found element in incorrect position!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindAll_Region()
{
ZArray<int> list;
list.PushBack(0); // 0
list.PushBack(1); // 1
list.PushBack(0); // 2
list.PushBack(3); // 3
list.PushBack(3); // 4
list.PushBack(0); // 5
list.PushBack(6); // 6
list.PushBack(3); // 7
list.PushBack(0); // 8
list.PushBack(3); // 9
list.PushBack(3); // 10
list.PushBack(0); // 11
ZArray<size_t> inds;
// search for nonexistent value
inds = ZArrayAlgo::FindAll(list, 10, 3, 9);
TASSERT(inds.Empty(), "FindAll() found nonexistent elements!\n");
// search for multiple elements
inds = ZArrayAlgo::FindAll(list, 3, 3, 9);
TASSERT(inds.Size() == 3, "FindAll() did not find all elements!\n");
TASSERT(inds.PopFront() == 3,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 4,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 7,"FindAll() found element in incorrect position!\n");
// search for existing elements in middle and ends
inds = ZArrayAlgo::FindAll(list, 0, 3, 12);
TASSERT(inds.Size() == 3, "FindAll() did not find all elements!\n");
TASSERT(inds.PopFront() == 5,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 8,"FindAll() found element in incorrect position!\n");
TASSERT(inds.PopFront() == 11,"FindAll() found element in incorrect position!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindAllOf()
{
ZArray<int> list;
list.PushBack(0); // 0
list.PushBack(1); // 1
list.PushBack(0); // 2
list.PushBack(3); // 3
list.PushBack(3); // 4
list.PushBack(0); // 5
list.PushBack(6); // 6
list.PushBack(3); // 7
list.PushBack(0); // 8
list.PushBack(3); // 9
list.PushBack(3); // 10
list.PushBack(0); // 11
ZArray<size_t> inds;
// search for nonexistent value
const int badvalues[] = {7,9,-3};
inds = ZArrayAlgo::FindAllOf(list, ZArray<int>(badvalues));
TASSERT(inds.Empty(), "FindAll() found nonexistent elements!\n");
// search for existent values
const int goodvalues[] = {1,6};
inds = ZArrayAlgo::FindAllOf(list, ZArray<int>(goodvalues));
TASSERT(inds.Size() == 2, "FindAll() found wrong number of elements!\n");
TASSERT(inds.PopFront() == 1, "FindAll() found element in wrong position!\n");
TASSERT(inds.PopFront() == 6, "FindAll() found element in wrong position!\n");
// search for existent values, including those on ends
const int goodvalues2[] = {1,3};
inds = ZArrayAlgo::FindAllOf(list, ZArray<int>(goodvalues2));
TASSERT(inds.Size() == 6, "FindAll() found wrong number of elements!\n");
TASSERT(inds.PopFront() == 1, "FindAll() found element in wrong position!\n");
TASSERT(inds.PopFront() == 3, "FindAll() found element in wrong position!\n");
TASSERT(inds.PopFront() == 4, "FindAll() found element in wrong position!\n");
TASSERT(inds.PopFront() == 7, "FindAll() found element in wrong position!\n");
TASSERT(inds.PopFront() == 9, "FindAll() found element in wrong position!\n");
TASSERT(inds.PopFront() == 10, "FindAll() found element in wrong position!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindAllOf_Region()
{
ZArray<int> list;
list.PushBack(0); // 0
list.PushBack(1); // 1
list.PushBack(0); // 2
list.PushBack(3); // 3
list.PushBack(3); // 4
list.PushBack(5); // 5
list.PushBack(6); // 6
list.PushBack(3); // 7
list.PushBack(0); // 8
list.PushBack(3); // 9
list.PushBack(3); // 10
list.PushBack(0); // 11
ZArray<size_t> inds;
// search for nonexistent value
const int badvals[] = {13,43,14,42};
inds = ZArrayAlgo::FindAllOf(list, 2, 9, ZArray<int>(badvals), 0, 4);
TASSERT(inds.Empty(), "FindAll() found nonexistent elements!\n");
// search for value in empty region
const int goodvals[] = {1,3,5,6};
inds = ZArrayAlgo::FindAllOf(list, 0, 1, ZArray<int>(goodvals), 0, 4);
TASSERT(inds.Empty(), "FindAll() found nonexistent elements in empty region!\n");
// search for existent values in subregion of target list
inds = ZArrayAlgo::FindAllOf(list, 2, 9, ZArray<int>(goodvals), 1, 3);
TASSERT(inds.Size() == 4, "FindAll() found wrong number of elements!\n");
TASSERT(inds.PopFront() == 3, "FindAll() found element in wrong position!\n");
TASSERT(inds.PopFront() == 4, "FindAll() found element in wrong position!\n");
TASSERT(inds.PopFront() == 5, "FindAll() found element in wrong position!\n");
TASSERT(inds.PopFront() == 7, "FindAll() found element in wrong position!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindIf()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ZArray<int> list2;
list2.PushBack(1);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(1);
TASSERT( ZArrayAlgo::FindIf(list, IfTestFunctor()) == 3, "FindIf() failed to find first element matching functor!\n");
TASSERT( ZArrayAlgo::FindIf(list2, IfTestFunctor()) == ZSTL::InvalidPos, "FindIf() failed to not find first element matching functor!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindIf_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::FindIf(list, IfTestFunctor(), 1, 4) == 3, "FindIf() failed to find first element matching functor in subregion!\n");
TASSERT( ZArrayAlgo::FindIf(list, IfTestFunctor(), 1, 3) == ZSTL::InvalidPos, "FindIf() found nonconforming element in range!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindFirst()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::FindFirst(list, 3) == 2, "FindFirst() failed to find first element in correct position!\n");
TASSERT( ZArrayAlgo::FindFirst(list, 7) == ZSTL::InvalidPos, "FindFirst() found element not in list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindFirst_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
list.PushBack(7);
TASSERT( ZArrayAlgo::FindFirst(list, 4, 2, 5) == 3, "FindFirst() failed to find first element in correct position in region!\n");
TASSERT( ZArrayAlgo::FindFirst(list, 4, 4, 7) == ZSTL::InvalidPos, "FindFirst() found element not in region!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindFirstOf()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ZArray<int> values1;
ZArray<int> values2;
values1.PushBack(3);
values1.PushBack(5);
values2.PushBack(6);
values2.PushBack(7);
TASSERT( ZArrayAlgo::FindFirstOf(list, values1) == 2, "FindFirstOf() failed to find first element in correct position!\n");
TASSERT( ZArrayAlgo::FindFirstOf(list, values2) == ZSTL::InvalidPos, "FindFirstOf() found element not in list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindFirstOf_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ZArray<int> values1;
ZArray<int> values2;
values1.PushBack(3);
values1.PushBack(5);
values2.PushBack(6);
values2.PushBack(7);
TASSERT( ZArrayAlgo::FindFirstOf(list, 3, 5, values1, 0, values1.Size()) == 4, "FindFirstOf() failed to find first element in correct position in region!\n");
TASSERT( ZArrayAlgo::FindFirstOf(list, 2, 4, values2, 0, values2.Size()) ==ZSTL::InvalidPos, "FindFirstOf() found element not in region!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindFirstNot()
{
ZArray<int> list;
ZArray<int> list2;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::FindFirstNot(list, 3) == 3, "FindFirstNotOf() failed to find first element not of given type in correct position!\n");
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
TASSERT( ZArrayAlgo::FindFirstNot(list2, 3) == ZSTL::InvalidPos, "FindFirstNotOf() failed to find nonexistent nonelement nonoccurence\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindFirstNot_In_Region()
{
ZArray<int> list;
ZArray<int> list2;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::FindFirstNot(list, 3, 1, 4) == 3, "FindFirstNotOf() failed to find first element not of given type in correct position!\n");
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
TASSERT( ZArrayAlgo::FindFirstNot(list2, 3, 1, 4) == ZSTL::InvalidPos, "FindFirstNotOf() failed to find nonexistent nonelement nonoccurence\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindFirstNotOf()
{
ZArray<int> list;
ZArray<int> list2;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ZArray<int> values1;
values1.PushBack(3);
values1.PushBack(4);
TASSERT( ZArrayAlgo::FindFirstNotOf(list, values1) == 4, "FindFirstNotOf() failed to find first element not of given type in correct position!\n");
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
TASSERT( ZArrayAlgo::FindFirstNotOf(list2, values1) == ZSTL::InvalidPos, "FindFirstNotOf() failed to find nonexistent nonelement nonoccurence\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindFirstNotOf_In_Region()
{
ZArray<int> list;
ZArray<int> list2;
list.PushBack(1);
list.PushBack(3);
list.PushBack(3);
list.PushBack(5);
list.PushBack(4);
ZArray<int> values1;
values1.PushBack(3);
values1.PushBack(4);
TASSERT(ZArrayAlgo::FindFirstNotOf(list, 0, 4, values1, 0, values1.Size()) == 0, "FindFirstNotOf() failed to find first element not of given type in correct position in start region!");
TASSERT(ZArrayAlgo::FindFirstNotOf(list, 1, 4, values1, 0, values1.Size()) == 3, "FindFirstNotOf() failed to find first element not of given type in correct position in end region!");
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(3);
list2.PushBack(3);
TASSERT(ZArrayAlgo::FindFirstNotOf(list2, 2, 4, values1, 0, values1.Size()) == ZSTL::InvalidPos, "FindFirstNotOf() failed to find nonexistent nonelement nonoccurence in region!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindLast()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::FindLast(list, 3) == 2, "FindLastOf() failed to find last element not of given type in correct position!\n");
TASSERT( ZArrayAlgo::FindLast(list, 2) == ZSTL::InvalidPos, "FindLastOf() failed to find nonexistent nonelement nonoccurence\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindLast_In_Region()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
TASSERT( ZArrayAlgo::FindLast(list, 3, 1, 4) == 2, "FindLastOf() failed to find last element not of given type in correct position!\n");
TASSERT( ZArrayAlgo::FindLast(list, 3, 3, 6) == ZSTL::InvalidPos, "FindLastOf() failed to find nonexistent nonelement nonoccurence\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindLastOf()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ZArray<int> values1;
ZArray<int> values2;
values1.PushBack(4);
values1.PushBack(3);
values2.PushBack(1);
values2.PushBack(2);
TASSERT( ZArrayAlgo::FindLastOf(list, values1) == 3, "FindLastOf() failed to find last element not of given type in correct position!\n");
TASSERT( ZArrayAlgo::FindLastOf(list, values2) == ZSTL::InvalidPos, "FindLastOf() failed to find nonexistent nonelement nonoccurence\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindLastOf_In_Region()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ZArray<int> values1;
ZArray<int> values2;
values1.PushBack(4);
values1.PushBack(3);
values2.PushBack(1);
values2.PushBack(2);
TASSERT( ZArrayAlgo::FindLastOf(list, 1, 3, values1, 0, values1.Size()) == 2, "FindLastOf() failed to find last element not of given type in correct position in region!");
TASSERT( ZArrayAlgo::FindLastOf(list, 2, 4, values2, 0, values2.Size()) == ZSTL::InvalidPos, "FindLastOf() failed to find nonexistent nonelement nonoccurence in region!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindLastNot()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
list.PushBack(3);
list.PushBack(3);
list.PushBack(7);
list.PushBack(8);
list.PushBack(3);
TASSERT( ZArrayAlgo::FindLastNot(list, 3) == 9, "FindLastNotOf() returned incorrect position!\n");
TASSERT( ZArrayAlgo::FindLastNot(list, 11) == 10, "FindLastNotOf() returned incorrect position!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindLastNot_In_Region()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
list.PushBack(3);
list.PushBack(3);
list.PushBack(7);
list.PushBack(8);
list.PushBack(3);
TASSERT( ZArrayAlgo::FindLastNot(list, 3, 1, 7) == 5, "FindLastNotOf() returned incorrect position!\n");
TASSERT( ZArrayAlgo::FindLastNot(list, 11, 1, 7) == 6, "FindLastNotOf() returned incorrect position!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindLastNotOf()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
list.PushBack(3);
list.PushBack(3);
list.PushBack(7);
list.PushBack(8);
list.PushBack(3);
ZArray<int> values1;
ZArray<int> values2;
values1.PushBack(4);
values1.PushBack(3);
values2.PushBack(1);
values2.PushBack(2);
TASSERT( ZArrayAlgo::FindLastNotOf(list, values1) == 9, "FindLastNotOf() returned incorrect position!\n");
TASSERT( ZArrayAlgo::FindLastNotOf(list, values2) == 10, "FindLastNotOf() returned incorrect position!\n");
TASSERT( ZArrayAlgo::FindLastNotOf(list, list) == ZSTL::InvalidPos, "FindLastNotOf() returned incorrect position!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindLastNotOf_In_Region()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
list.PushBack(3);
list.PushBack(3);
list.PushBack(7);
list.PushBack(8);
list.PushBack(3);
ZArray<int> values1;
ZArray<int> values2;
values1.PushBack(4);
values1.PushBack(3);
values2.PushBack(1);
values2.PushBack(2);
TASSERT( ZArrayAlgo::FindLastNotOf(list, 1, 7, values1, 0, values1.Size()) == 5, "FindLastNotOf() returned incorrect position!\n");
TASSERT( ZArrayAlgo::FindLastNotOf(list, 1, 7, values2, 0, values2.Size()) == 6, "FindLastNotOf() returned incorrect position!\n");
TASSERT( ZArrayAlgo::FindLastNotOf(list, 1, 7, list, 0, list.Size()) == ZSTL::InvalidPos, "FindLastNotOf() returned incorrect position!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindSub()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
list.PushBack(3);
list.PushBack(3);
list.PushBack(7);
list.PushBack(8);
list.PushBack(3);
ZArray<int> values1;
ZArray<int> values2;
values1.PushBack(4);
values1.PushBack(5);
values1.PushBack(6);
values2.PushBack(3);
values2.PushBack(3);
values2.PushBack(8);
TASSERT( ZArrayAlgo::FindSub(list, values1) == 3, "FindSub() returned incorrect position!");
TASSERT( ZArrayAlgo::FindSub(list, values2) == ZSTL::InvalidPos, "FindSub() failed to return invalid position with invalid sub array!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FindSub_In_Region()
{
ZArray<int> list;
list.PushBack(3);
list.PushBack(3);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
list.PushBack(3);
list.PushBack(3);
list.PushBack(7);
list.PushBack(8);
list.PushBack(3);
ZArray<int> values1;
ZArray<int> values2;
values1.PushBack(4);
values1.PushBack(5);
values1.PushBack(6);
values2.PushBack(3);
values2.PushBack(3);
values2.PushBack(8);
TASSERT( ZArrayAlgo::FindSub(list, 2, 6, values1, 0, values1.Size()) == 3, "FindSub() returned incorrect position in region!");
TASSERT( ZArrayAlgo::FindSub(list, 2, 4, values1, 0, values1.Size()) == ZSTL::InvalidPos, "FindSub() returned valid position in region with invalid sub-array region!");
TASSERT( ZArrayAlgo::FindSub(list, 2, 8, values1, 1, values1.Size()) == 4, "FindSub() returned incorrect position in region!");
TASSERT( ZArrayAlgo::FindSub(list, 2, list.Size(), values2, 1, values2.Size()) == ZSTL::InvalidPos, "FindSub() failed to return invalid position with invalid sub array!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
class FoldLeftTestFunctor
{
public:
FoldLeftTestFunctor() {}
~FoldLeftTestFunctor() {}
int operator () (const ArrayValueTestClass& _lhs, const ArrayValueTestClass& _rhs) const
{
if (_rhs.val > 3)
return _lhs.val + _rhs.val;
else
return _lhs.val;
}
};
static const char* test_FoldLeft()
{
ZArray<int> list;
int ans;
ZArray<ArrayValueTestClass> list2;
ArrayValueTestClass ans2;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ans = ZArrayAlgo::FoldLeft(list, FoldLeftTestFunctor(), 10); //only add values greater than 3
TASSERT (ans == 19, "FoldLeft() failed to accumulate correctly!\n");
list2.PushBack(1);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
ans2 = ZArrayAlgo::FoldLeft(list2, FoldLeftTestFunctor(), ArrayValueTestClass(10)); //only add values greater than 3
TASSERT (ans2.val == 19, "FoldLeft() failed to accumulate correctly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FoldLeft_Region()
{
ZArray<int> list;
int ans;
ZArray<ArrayValueTestClass> list2;
ArrayValueTestClass ans2;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ans = ZArrayAlgo::FoldLeft(list, FoldLeftTestFunctor(), 10, 1, 4); //only add values greater than 3
TASSERT (ans == 14, "FoldLeft() failed to accumulate correctly in region!\n");
list2.PushBack(1);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
ans2 = ZArrayAlgo::FoldLeft(list2, FoldLeftTestFunctor(), ArrayValueTestClass(10), 1, 4); //only add values greater than 3
TASSERT (ans2.val == 14, "FoldLeft() failed to accumulate correctly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
class FoldRightTestFunctor
{
public:
FoldRightTestFunctor() {}
~FoldRightTestFunctor() {}
int operator () (const int& _lhs, const int& _rhs) const
{
return _lhs - _rhs;
}
};
static const char* test_FoldRight()
{
ZArray<int> list;
int ans;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ans = ZArrayAlgo::FoldLeft(list, FoldRightTestFunctor(), 10);
TASSERT(ans == -5, "FoldLeft() with subtraction operator returned incorrect value!");
ans = ZArrayAlgo::FoldRight(list, FoldRightTestFunctor(), 10);
TASSERT (ans == -7, "FoldRight() with subtraction operator returned incorrect value!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_FoldRight_Region()
{
ZArray<int> list;
int ans;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ans = ZArrayAlgo::FoldLeft(list, FoldRightTestFunctor(), 10, 0, 4);
TASSERT(ans == 0, "FoldLeft() with subtraction operator returned incorrect value in region!");
ans = ZArrayAlgo::FoldRight(list, FoldRightTestFunctor(), 10, 1, 5);
TASSERT (ans == 8, "FoldRight() with subtraction operator returned incorrect value in region!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
struct GenerateTestFunctor
{
int operator () ( size_t _index, size_t _count )
{
return ((int)_count) - ((int)_index);
}
};
static const char* test_Generate()
{
ZArray<int> list;
list.Resize(5);
ZArrayAlgo::Generate(list, GenerateTestFunctor());
TASSERT( list.Size() == 5, "Generate() changed size of list!\n");
TASSERT( list.PopFront() == 5, "Generate() producted incorrect list!\n");
TASSERT( list.PopFront() == 4, "Generate() producted incorrect list!\n");
TASSERT( list.PopFront() == 3, "Generate() producted incorrect list!\n");
TASSERT( list.PopFront() == 2, "Generate() producted incorrect list!\n");
TASSERT( list.PopFront() == 1, "Generate() producted incorrect list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Generate_In_Region()
{
ZArray<int> list;
list.PushBack(9);
list.PushBack(9);
list.PushBack(9);
list.PushBack(9);
list.PushBack(9);
ZArrayAlgo::Generate(list, GenerateTestFunctor(), 1, 4);
TASSERT( list.Size() == 5, "Generate() changed size of list!\n");
TASSERT( list.PopFront() == 9, "Generate() producted incorrect list!\n");
TASSERT( list.PopFront() == 3, "Generate() producted incorrect list!\n");
TASSERT( list.PopFront() == 2, "Generate() producted incorrect list!\n");
TASSERT( list.PopFront() == 1, "Generate() producted incorrect list!\n");
TASSERT( list.PopFront() == 9, "Generate() producted incorrect list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
struct MapTestFunctor { void operator() (int& _val) const { _val *= -1; } };
static const char* test_Map()
{
ZArray<int> list;
ZArray<int> out;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
out = ZArrayAlgo::Map(list, MapTestFunctor());
TASSERT( list.Size() == 5, "Map() changed input array size!\n");
TASSERT( list.PopFront() == 1, "Map() changed input array!\n");
TASSERT( list.PopFront() == 2, "Map() changed input array!\n");
TASSERT( list.PopFront() == 3, "Map() changed input array!\n");
TASSERT( list.PopFront() == 4, "Map() changed input array!\n");
TASSERT( list.PopFront() == 5, "Map() changed input array!\n");
TASSERT( out.Size() == 5, "Map() returned range of incorrect size!\n");
TASSERT( out.PopFront() == -1, "Map() returned incorrect range!\n");
TASSERT( out.PopFront() == -2, "Map() returned incorrect range!\n");
TASSERT( out.PopFront() == -3, "Map() returned incorrect range!\n");
TASSERT( out.PopFront() == -4, "Map() returned incorrect range!\n");
TASSERT( out.PopFront() == -5, "Map() returned incorrect range!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Map_Region()
{
ZArray<int> list;
ZArray<int> out;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
out = ZArrayAlgo::Map(list, MapTestFunctor(), 1, 4);
TASSERT( list.Size() == 5, "Map() changed input array size!\n");
TASSERT( list.PopFront() == 1, "Map() changed input array!\n");
TASSERT( list.PopFront() == 2, "Map() changed input array!\n");
TASSERT( list.PopFront() == 3, "Map() changed input array!\n");
TASSERT( list.PopFront() == 4, "Map() changed input array!\n");
TASSERT( list.PopFront() == 5, "Map() changed input array!\n");
TASSERT( out.Size() == 3, "Map() returned range of incorrect size!\n");
TASSERT( out.PopFront() == -2, "Map() returned incorrect range!\n");
TASSERT( out.PopFront() == -3, "Map() returned incorrect range!\n");
TASSERT( out.PopFront() == -4, "Map() returned incorrect range!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Max()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(5);
list.PushBack(4);
list.PushBack(2);
list.PushBack(7);
list.PushBack(3);
list.PushBack(0);
list.PushBack(5);
ZArray<int> list2;
list2.PushBack(1);
list2.PushBack(2);
list2.PushBack(5);
list2.PushBack(5);
list2.PushBack(5);
list2.PushBack(4);
list2.PushBack(2);
TASSERT( ZArrayAlgo::Max(list) == 5, "Max() failed to find max at expected place!\n");
TASSERT( ZArrayAlgo::Max(list2) == 2, "Max() failed to find max at expected place for multiple max values!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Max_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(5);
list.PushBack(4);
list.PushBack(2);
list.PushBack(7);
list.PushBack(3);
list.PushBack(0);
list.PushBack(5);
ZArray<int> list2;
list2.PushBack(1);
list2.PushBack(2);
list2.PushBack(5);
list2.PushBack(5);
list2.PushBack(5);
list2.PushBack(4);
list2.PushBack(2);
TASSERT( ZArrayAlgo::Max(list, 3, 8 ) == 5, "Max() failed to find max at expected place!\n");
TASSERT( ZArrayAlgo::Max(list2, 1, 6) == 2, "Max() failed to find max at expected place for multiple max values!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
struct TestComparatorFunctor
{
//operator overload which returns 1 if a < b, 0 if a == b, and -1 if a > b
//this basically means that this comparator returns the reverse of usual
int operator () (const int& _a, const int& _b) const
{
if (_a < _b)
{
return 1;
}
else if (_b < _a)
{
return -1;
}
else
{
return 0;
}
}
};
static const char* test_Max_Comparator()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(5);
list.PushBack(4);
list.PushBack(2);
list.PushBack(7);
list.PushBack(3);
list.PushBack(0);
list.PushBack(5);
ZArray<int> list2;
list2.PushBack(4);
list2.PushBack(1);
list2.PushBack(2);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(4);
list2.PushBack(2);
TASSERT( ZArrayAlgo::Max(list, TestComparatorFunctor()) == 7, "Max() failed to find max at expected place!\n");
TASSERT( ZArrayAlgo::Max(list2, TestComparatorFunctor()) == 1, "Max() failed to find max at expected place for multiple max values!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Max_Comparator_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(5);
list.PushBack(4);
list.PushBack(2);
list.PushBack(7);
list.PushBack(3);
list.PushBack(0);
list.PushBack(5);
ZArray<int> list2;
list2.PushBack(4);
list2.PushBack(1);
list2.PushBack(2);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(4);
list2.PushBack(2);
TASSERT( ZArrayAlgo::Max(list, TestComparatorFunctor(), 0, 4) == 0, "Max() failed to find max at expected place in region!");
TASSERT( ZArrayAlgo::Max(list2, TestComparatorFunctor(), 4, 6) == 4, "Max() failed to find max at expected place for multiple max values in region!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Min()
{
ZArray<int> list;
list.PushBack(2);
list.PushBack(7);
list.PushBack(5);
list.PushBack(1);
list.PushBack(4);
list.PushBack(2);
list.PushBack(3);
list.PushBack(0);
list.PushBack(5);
ZArray<int> list2;
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(4);
list2.PushBack(2);
TASSERT( ZArrayAlgo::Min(list) == 7, "Min() failed to find min at expected place!\n");
TASSERT( ZArrayAlgo::Min(list2) == 4, "Min() failed to find min at expected place for multiple max values!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Min_In_Region()
{
ZArray<int> list;
list.PushBack(2);
list.PushBack(7);
list.PushBack(5);
list.PushBack(1);
list.PushBack(4);
list.PushBack(2);
list.PushBack(3);
list.PushBack(0);
list.PushBack(5);
ZArray<int> list2;
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(4);
list2.PushBack(2);
TASSERT( ZArrayAlgo::Min(list, 1, 6) == 3, "Min() failed to find min at expected place!\n");
TASSERT( ZArrayAlgo::Min(list2, 3, 7) == 4, "Min() failed to find min at expected place for multiple max values!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Min_Comparator()
{
ZArray<int> list;
list.PushBack(2);
list.PushBack(7);
list.PushBack(5);
list.PushBack(1);
list.PushBack(4);
list.PushBack(2);
list.PushBack(3);
list.PushBack(0);
list.PushBack(5);
ZArray<int> list2;
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(1);
list2.PushBack(4);
list2.PushBack(2);
TASSERT( ZArrayAlgo::Min(list, TestComparatorFunctor()) == 1, "Min() failed to find min at expected place!\n");
TASSERT( ZArrayAlgo::Min(list2, TestComparatorFunctor()) == 7, "Min() failed to find min at expected place for multiple max values!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Min_Comparator_In_Region()
{
ZArray<int> list;
list.PushBack(2);
list.PushBack(7);
list.PushBack(5);
list.PushBack(1);
list.PushBack(4);
list.PushBack(2);
list.PushBack(3);
list.PushBack(0);
list.PushBack(5);
ZArray<int> list2;
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(2);
list2.PushBack(4);
list2.PushBack(4);
list2.PushBack(4);
list2.PushBack(4);
list2.PushBack(2);
TASSERT( ZArrayAlgo::Min(list, TestComparatorFunctor(), 2, 6) == 2, "Min() failed to find min at expected place in region!");
TASSERT( ZArrayAlgo::Min(list2, TestComparatorFunctor(), 0, 4) == 0, "Min() failed to find min at expected place for multiple max values in region!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Remove()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT(ZArrayAlgo::Remove(list, 8) == ZSTL::InvalidPos, "Remove() did not take out element at correct position!\n");
TASSERT(list.Size() == 7, "Remove() did not change list size correctly!\n");
TASSERT(ZArrayAlgo::Remove(list, 2) == 1, "Remove() did not take out element at correct position!\n");
TASSERT(list.Size() == 6, "Remove() did not change list size correctly!\n");
TASSERT(ZArrayAlgo::Remove(list, 5) == 5, "Remove() did not take out element at correct position!\n");
TASSERT(list.Size() == 5, "Remove() did not change list size correctly!\n");
TASSERT(ZArrayAlgo::Remove(list, 1) == 0, "Remove() did not take out element at correct position!\n");
TASSERT(list.Size() == 4, "Remove() did not change list size correctly!\n");
TASSERT( list.PopFront() == 2, "Remove() created incorrect list!\n");
TASSERT( list.PopFront() == 2, "Remove() created incorrect list!\n");
TASSERT( list.PopFront() == 3, "Remove() created incorrect list!\n");
TASSERT( list.PopFront() == 4, "Remove() created incorrect list!\n");
TASSERT( list.Empty(), "Remove() created incorrectly sized list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Remove_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT(ZArrayAlgo::Remove(list, 8, 1, 6 ) == ZSTL::InvalidPos, "Remove() did not take out element at correct position!\n");
TASSERT(list.Size() == 7, "Remove() did not change list size correctly!\n");
TASSERT(ZArrayAlgo::Remove(list, 2, 1, 6 ) == 1, "Remove() did not take out element at correct position!\n");
TASSERT(list.Size() == 6, "Remove() did not change list size correctly!\n");
TASSERT(ZArrayAlgo::Remove(list, 5, 1, 6 ) == 5, "Remove() did not take out element at correct position!\n");
TASSERT(list.Size() == 5, "Remove() did not change list size correctly!\n");
TASSERT(ZArrayAlgo::Remove(list, 1, 1, 5 ) == ZSTL::InvalidPos, "Remove() took out an element at the wrong place!\n");
TASSERT(list.Size() == 5, "Remove() changed list size correctly!\n");
TASSERT( list.PopFront() == 1, "Remove() created incorrect list!\n");
TASSERT( list.PopFront() == 2, "Remove() created incorrect list!\n");
TASSERT( list.PopFront() == 2, "Remove() created incorrect list!\n");
TASSERT( list.PopFront() == 3, "Remove() created incorrect list!\n");
TASSERT( list.PopFront() == 4, "Remove() created incorrect list!\n");
TASSERT( list.Empty(), "Remove() created incorrectly sized list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_RemoveAll()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::RemoveAll(list, 2) == 3, "RemoveAll() claims wrong number of removals!\n");
TASSERT( list.Size() == 4, "RemoveAll() failed to remove all elements of supplied value!\n");
TASSERT( list.PopFront() == 1, "RemoveAll() corrupted list!\n");
TASSERT( list.PopFront() == 3, "RemoveAll() corrupted list!\n");
TASSERT( list.PopFront() == 4, "RemoveAll() corrupted list!\n");
TASSERT( list.PopFront() == 5, "RemoveAll() corrupted list!\n");
TASSERT( list.Empty(), "RemoveAll() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_RemoveAll_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::RemoveAll(list, 2, 2,7 ) == 2, "RemoveAll() claims wrong number of removals!\n");
TASSERT( list.Size() == 5, "RemoveAll() failed to remove all elements of supplied value!\n");
TASSERT( list.PopFront() == 1, "RemoveAll() corrupted list!\n");
TASSERT( list.PopFront() == 2, "RemoveAll() corrupted list!\n");
TASSERT( list.PopFront() == 3, "RemoveAll() corrupted list!\n");
TASSERT( list.PopFront() == 4, "RemoveAll() corrupted list!\n");
TASSERT( list.PopFront() == 5, "RemoveAll() corrupted list!\n");
TASSERT( list.Empty(), "RemoveAll() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
// returns true if given odd number
struct RemoveIfTestFunctor{ bool operator()(int _val) { return (_val%2) == 1;}};
static const char* test_RemoveIf()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::RemoveIf(list,RemoveIfTestFunctor()) == 3, "RemoveIf() claims wrong number of removals!\n");
TASSERT( list.Size() == 4, "RemoveIf() failed to remove all elements of supplied value!\n");
TASSERT( list.PopFront() == 2, "RemoveIf() corrupted list!\n");
TASSERT( list.PopFront() == 2, "RemoveIf() corrupted list!\n");
TASSERT( list.PopFront() == 2, "RemoveIf() corrupted list!\n");
TASSERT( list.PopFront() == 4, "RemoveIf() corrupted list!\n");
TASSERT( list.Empty(), "RemoveIf() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_RemoveIf_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::RemoveIf(list,RemoveIfTestFunctor(), 1, 5) == 1, "RemoveIf() claims wrong number of removals!\n");
TASSERT( list.Size() == 6, "RemoveIf() failed to remove all elements of supplied value!\n");
TASSERT( list.PopFront() == 1, "RemoveIf() corrupted list!\n");
TASSERT( list.PopFront() == 2, "RemoveIf() corrupted list!\n");
TASSERT( list.PopFront() == 2, "RemoveIf() corrupted list!\n");
TASSERT( list.PopFront() == 2, "RemoveIf() corrupted list!\n");
TASSERT( list.PopFront() == 4, "RemoveIf() corrupted list!\n");
TASSERT( list.PopFront() == 5, "RemoveIf() corrupted list!\n");
TASSERT( list.Empty(), "RemoveIf() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_RemoveUpTo()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::RemoveUpTo(list, 2, 2) == 2, "RemoveUpTo() claims incorrect number of removals!\n");
TASSERT( list.Size() == 5, "RemoveUpTo() resized list to incorrect size!\n");
TASSERT( list.At(0) == 1, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(1) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(2) == 3, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(3) == 4, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(4) == 5, "RemoveUpTo() corrupted list!\n");
TASSERT( ZArrayAlgo::RemoveUpTo(list, 3, 12) == 1, "RemoveUpTo() claims incorrect number of removals!\n");
TASSERT( list.Size() == 4, "RemoveUpTo() resized list to incorrect size!\n");
TASSERT( list.At(0) == 1, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(1) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(2) == 4, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(3) == 5, "RemoveUpTo() corrupted list!\n");
TASSERT( ZArrayAlgo::RemoveUpTo(list, 1337, 12) == 0, "RemoveUpTo() claims incorrect number of removals!\n");
TASSERT( list.Size() == 4, "RemoveUpTo() resized list to incorrect size!\n");
TASSERT( list.At(0) == 1, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(1) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(2) == 4, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(3) == 5, "RemoveUpTo() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_RemoveUpTo_In_Region()
{
ZArray<int> list;
list.PushBack(2);
list.PushBack(2);
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::RemoveUpTo(list, 2, 2, 2, 9) == 2, "RemoveUpTo() claims incorrect number of removals!\n");
TASSERT( list.Size() == 7, "RemoveUpTo() resized list to incorrect size!\n");
TASSERT( list.At(0) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(1) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(2) == 1, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(3) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(4) == 3, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(5) == 4, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(6) == 5, "RemoveUpTo() corrupted list!\n");
TASSERT( ZArrayAlgo::RemoveUpTo(list, 3, 12, 2, 7) == 1, "RemoveUpTo() claims incorrect number of removals!\n");
TASSERT( list.Size() == 6, "RemoveUpTo() resized list to incorrect size!\n");
TASSERT( list.At(0) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(1) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(2) == 1, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(3) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(4) == 4, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(5) == 5, "RemoveUpTo() corrupted list!\n");
TASSERT( ZArrayAlgo::RemoveUpTo(list, 1337, 12, 2, 6) == 0, "RemoveUpTo() claims incorrect number of removals!\n");
TASSERT( list.Size() == 6, "RemoveUpTo() resized list to incorrect size!\n");
TASSERT( list.At(0) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(1) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(2) == 1, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(3) == 2, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(4) == 4, "RemoveUpTo() corrupted list!\n");
TASSERT( list.At(5) == 5, "RemoveUpTo() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Replace()
{
ZArray<int> list;
list.PushBack(2);
list.PushBack(2);
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::Replace(list, 2, 42) == 5, "Replace() claims wrong number of replacements!\n");
TASSERT( list.Size() == 9, "Replace() changed size of list!\n");
TASSERT( list.PopFront() == 42, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 42, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 1, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 42, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 42, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 42, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 3, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 4, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 5, "Replace() did not replace element correctly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Replace_In_Region()
{
ZArray<int> list;
list.PushBack(2);
list.PushBack(2);
list.PushBack(1);
list.PushBack(2);
list.PushBack(2);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::Replace(list, 2, 42, 2, 9) == 3, "Replace() claims wrong number of replacements!\n");
TASSERT( list.Size() == 9, "Replace() changed size of list!\n");
TASSERT( list.PopFront() == 2, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 2, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 1, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 42, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 42, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 42, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 3, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 4, "Replace() did not replace element correctly!\n");
TASSERT( list.PopFront() == 5, "Replace() did not replace element correctly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
// returns true if given odd number
struct ReplaceIfTestFunctor{ bool operator ()(int _val){ return (_val%2) == 1;} };
static const char* test_ReplaceIf()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
TASSERT( ZArrayAlgo::ReplaceIf(list, ReplaceIfTestFunctor(), 42) == 3, "ReplaceIf() claims wrong number of replacements!\n");
TASSERT( list.Size() == 6, "ReplaceIf() changed size of list!\n");
TASSERT( list.PopFront() == 42, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 2, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 42, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 4, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 42, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 6, "ReplaceIf() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_ReplaceIf_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
TASSERT( ZArrayAlgo::ReplaceIf(list, ReplaceIfTestFunctor(), 42, 1, 3) == 1, "ReplaceIf() claims wrong number of replacements!\n");
TASSERT( list.Size() == 6, "ReplaceIf() changed size of list!\n");
TASSERT( list.PopFront() == 1, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 2, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 42, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 4, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 5, "ReplaceIf() corrupted list!\n");
TASSERT( list.PopFront() == 6, "ReplaceIf() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Reverse()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
ZArrayAlgo::Reverse(list);
TASSERT( list.Size() == 6, "Reverse() changed size of list!\n");
TASSERT( list.PopFront() == 6, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 5, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 4, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 3, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 2, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 1, "Reverse() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Reverse_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
// test reverse on same element
ZArrayAlgo::Reverse(list,0,0);
ZArrayAlgo::Reverse(list,3,3);
TASSERT( list.Size() == 6, "Reverse() changed size of list!\n");
TASSERT( list.At(0) == 1, "Reverse() corrupted list!\n");
TASSERT( list.At(1) == 2, "Reverse() corrupted list!\n");
TASSERT( list.At(2) == 3, "Reverse() corrupted list!\n");
TASSERT( list.At(3) == 4, "Reverse() corrupted list!\n");
TASSERT( list.At(4) == 5, "Reverse() corrupted list!\n");
TASSERT( list.At(5) == 6, "Reverse() corrupted list!\n");
// okay, real test
ZArrayAlgo::Reverse(list,2,5);
TASSERT( list.Size() == 6, "Reverse() changed size of list!\n");
TASSERT( list.PopFront() == 1, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 2, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 5, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 4, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 3, "Reverse() corrupted list!\n");
TASSERT( list.PopFront() == 6, "Reverse() corrupted list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Rotate()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
// test rotate at front
ZArrayAlgo::Rotate(list, 0);
TASSERT( list.Size() == 6, "Rotate() changed length of array!\n");
TASSERT( list.PopFront() == 1, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 2, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 3, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 4, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 5, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 6, "Rotate() misordered list!\n");
// test rotate at middle
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
ZArrayAlgo::Rotate(list, 3);
TASSERT( list.Size() == 6, "Rotate() changed length of array!\n");
TASSERT( list.PopFront() == 4, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 5, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 6, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 1, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 2, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 3, "Rotate() misordered list!\n");
// test pivot back
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
ZArrayAlgo::Rotate(list, 5);
TASSERT( list.Size() == 6, "Rotate() changed length of array!\n");
TASSERT( list.PopFront() == 6, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 1, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 2, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 3, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 4, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 5, "Rotate() misordered list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Rotate_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list.PushBack(6);
// test rotate at front
ZArrayAlgo::Rotate(list, 1, 0, 3);
TASSERT( list.Size() == 6, "Rotate() changed length of array!\n");
TASSERT( list.PopFront() == 2, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 3, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 1, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 4, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 5, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 6, "Rotate() misordered list!\n");
// test rotate at middle
list.PushBack(1); //0
list.PushBack(2); //1
list.PushBack(3); //2 =
list.PushBack(4); //3 | <
list.PushBack(5); //4 =
list.PushBack(6); //5
ZArrayAlgo::Rotate(list, 3, 2, 5);
TASSERT( list.Size() == 6, "Rotate() changed length of array!\n");
TASSERT( list.PopFront() == 1, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 2, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 4, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 5, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 3, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 6, "Rotate() misordered list!\n");
// test pivot back
list.PushBack(1); //0
list.PushBack(2); //1
list.PushBack(3); //2
list.PushBack(4); //3 =
list.PushBack(5); //4 |
list.PushBack(6); //5 = <
ZArrayAlgo::Rotate(list, 5, 3, 6);
TASSERT( list.Size() == 6, "Rotate() changed length of array!\n");
TASSERT( list.PopFront() == 1, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 2, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 3, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 6, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 4, "Rotate() misordered list!\n");
TASSERT( list.PopFront() == 5, "Rotate() misordered list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_SetIntersection()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
ZArray<int> list2;
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
ZArray<int> intersection = ZArrayAlgo::SetIntersection(list, list2);
TASSERT( intersection.Size() == 3, "SetIntersection() created wrong size intersection set\n");
TASSERT( intersection.PopFront() == 2, "SetIntersection() produced wrong value!\n");
TASSERT( intersection.PopFront() == 3, "SetIntersection() produced wrong value!\n");
TASSERT( intersection.PopFront() == 4, "SetIntersection() produced wrong value!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_SetIntersection_In_Region()
{
ZArray<int> list;
list.PushBack(1); // 0
list.PushBack(2); // 1 =
list.PushBack(3); // 2 |
list.PushBack(4); // 3 |
list.PushBack(5); // 4 |
list.PushBack(6); // 5 =
list.PushBack(7); // 6
ZArray<int> list2;
list2.PushBack(1); // 0
list2.PushBack(2); // 1
list2.PushBack(3); // 2
list2.PushBack(4); // 3 =
list2.PushBack(5); // 4 |
list2.PushBack(6); // 5 |
list2.PushBack(7); // 6 =
ZArray<int> intersection = ZArrayAlgo::SetIntersection(list, 1, 6, list2, 3, 7);
TASSERT( intersection.Size() == 3, "SetIntersection() created wrong size intersection set\n");
TASSERT( intersection.PopFront() == 4, "SetIntersection() produced wrong value!\n");
TASSERT( intersection.PopFront() == 5, "SetIntersection() produced wrong value!\n");
TASSERT( intersection.PopFront() == 6, "SetIntersection() produced wrong value!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_SetUnion()
{
ZArray<int> list;
list.PushBack(1); // 0
list.PushBack(2); // 1 =
list.PushBack(3); // 2 |
list.PushBack(4); // 3 |
list.PushBack(5); // 4 |
ZArray<int> list2;
list2.PushBack(1); // 0
list2.PushBack(2); // 1
list2.PushBack(3); // 2
ZArray<int> list3;
list3.PushBack(3); // 0
list3.PushBack(4); // 1
list3.PushBack(5); // 2
ZArray<int> same = ZArrayAlgo::SetUnion(list,list2);
TASSERT(same.Size() == 5, "SetUnion() created wrong sized list!\n");
TASSERT(same.PopFront() == 1, "SetUnion() created wrong list!\n");
TASSERT(same.PopFront() == 2, "SetUnion() created wrong list!\n");
TASSERT(same.PopFront() == 3, "SetUnion() created wrong list!\n");
TASSERT(same.PopFront() == 4, "SetUnion() created wrong list!\n");
TASSERT(same.PopFront() == 5, "SetUnion() created wrong list!\n");
ZArray<int> diff = ZArrayAlgo::SetUnion(list2,list3);
TASSERT(diff.Size() == 5, "SetUnion() created wrong sized list!\n");
TASSERT(diff.PopFront() == 1, "SetUnion() created wrong list!\n");
TASSERT(diff.PopFront() == 2, "SetUnion() created wrong list!\n");
TASSERT(diff.PopFront() == 3, "SetUnion() created wrong list!\n");
TASSERT(diff.PopFront() == 4, "SetUnion() created wrong list!\n");
TASSERT(diff.PopFront() == 5, "SetUnion() created wrong list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_SetUnion_In_Region()
{
ZArray<int> list;
list.PushBack(1); // 0
list.PushBack(2); // 1 =
list.PushBack(3); // 2 |
list.PushBack(4); // 3 |
list.PushBack(5); // 4 =
list.PushBack(6); // 5
list.PushBack(7); // 6
ZArray<int> list2;
list2.PushBack(1); // 0
list2.PushBack(2); // 1
list2.PushBack(3); // 2
list2.PushBack(4); // 3 =
list2.PushBack(5); // 4 |
list2.PushBack(6); // 5 |
list2.PushBack(7); // 6 =
ZArray<int> diff = ZArrayAlgo::SetUnion(list,1,4,list2,3,6);
TASSERT(diff.Size() == 5, "SetUnion() created wrong sized list!\n");
TASSERT(diff.PopFront() == 2, "SetUnion() created wrong list!\n");
TASSERT(diff.PopFront() == 3, "SetUnion() created wrong list!\n");
TASSERT(diff.PopFront() == 4, "SetUnion() created wrong list!\n");
TASSERT(diff.PopFront() == 5, "SetUnion() created wrong list!\n");
TASSERT(diff.PopFront() == 6, "SetUnion() created wrong list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Slice()
{
ZArray<int> list;
ZArray<int> list2;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
list2 = ZArrayAlgo::Slice(list,1,3);
TASSERT( list.Size() == 3, "Slice() removed the wrong number of elements!\n");
TASSERT( list.PopFront() == 1, "Slice() produced incorrect mutated list!\n");
TASSERT( list.PopFront() == 4, "Slice() produced incorrect mutated list!\n");
TASSERT( list.PopFront() == 5, "Slice() produced incorrect mutated list!\n");
TASSERT( list2.PopFront() == 2, "Slice() produced incorrect excise list!\n");
TASSERT( list2.PopFront() == 3, "Slice() produced incorrect excise list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Sort()
{
ZArray<int> list;
list.PushBack(4);
list.PushBack(1);
list.PushBack(3);
list.PushBack(6);
list.PushBack(7);
list.PushBack(2);
list.PushBack(5);
ZArrayAlgo::Sort(list);
TASSERT(list.Size() == 7, "Sort() changed array size!\n");
TASSERT(list.PopFront() == 1, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 2, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 3, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 4, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 5, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 6, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 7, "Sort() didn't sort list properly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Sort_Region()
{
ZArray<int> list;
list.PushBack(4);
list.PushBack(1);
list.PushBack(3);
list.PushBack(6);
list.PushBack(7);
list.PushBack(2);
list.PushBack(5);
ZArrayAlgo::Sort(list,2,6);
TASSERT(list.Size() == 7, "Sort() changed array size!\n");
TASSERT(list.PopFront() == 4, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 1, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 2, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 3, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 6, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 7, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 5, "Sort() didn't sort list properly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
// reverse from normal
struct SortComparatorTestFunctor
{
int operator () (const int& _a, const int& _b) const
{
if (_a < _b)
{
return 1;
}
else if (_b < _a)
{
return -1;
}
else
{
return 0;
}
}
};
static const char* test_Sort_Comparator()
{
ZArray<int> list;
list.PushBack(4);
list.PushBack(1);
list.PushBack(3);
list.PushBack(6);
list.PushBack(7);
list.PushBack(2);
list.PushBack(5);
ZArrayAlgo::Sort(list,SortComparatorTestFunctor());
TASSERT(list.Size() == 7, "Sort() changed array size!\n");
TASSERT(list.PopFront() == 7, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 6, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 5, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 4, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 3, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 2, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 1, "Sort() didn't sort list properly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
// ye olde bubble sorte
struct SortAlgorithmTestFunctor
{
//Functor operator () override
template <typename CF>
void operator () (CF& _comparator, int* _array, size_t _size)
{
if (_size == 0)
return;
bool keepGoing;
size_t i;
int temp;
do
{
keepGoing = false;
for (i = 1; i < _size; i++)
{
if ( _comparator(_array[i-1], _array[i]) > 0)
{
temp = _array[i];
_array[i] = _array[i-1];
_array[i-1] = temp;
keepGoing = true;
}
}
} while (keepGoing);
}
};
static const char* test_Sort_Comparator_Algorithm()
{
ZArray<int> list;
list.PushBack(4);
list.PushBack(1);
list.PushBack(3);
list.PushBack(6);
list.PushBack(7);
list.PushBack(2);
list.PushBack(5);
ZArrayAlgo::Sort(list, SortComparatorTestFunctor(), SortAlgorithmTestFunctor(), 0, list.Size());
TASSERT(list.Size() == 7, "Sort() changed array size!\n");
TASSERT(list.PopFront() == 7, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 6, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 5, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 4, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 3, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 2, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 1, "Sort() didn't sort list properly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Sort_Comparator_Algorithm_Region()
{
ZArray<int> list;
list.PushBack(4);
list.PushBack(1);
list.PushBack(3);
list.PushBack(6);
list.PushBack(7);
list.PushBack(2);
list.PushBack(5);
ZArrayAlgo::Sort(list,SortComparatorTestFunctor(), SortAlgorithmTestFunctor(),2,5);
TASSERT(list.Size() == 7, "Sort() changed array size!\n");
TASSERT(list.PopFront() == 4, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 1, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 7, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 6, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 3, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 2, "Sort() didn't sort list properly!\n");
TASSERT(list.PopFront() == 5, "Sort() didn't sort list properly!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Split()
{
ZArray<int> list;
list.PushBack(4);
list.PushBack(1);
list.PushBack(3);
list.PushBack(6);
list.PushBack(7);
list.PushBack(2);
list.PushBack(5);
ZArray<int> values;
values.PushBack(4);
ZArray< ZArray<int> > out = ZArrayAlgo::Split(list, values);
TASSERT( out.Size() == 1, "Split() 1 did not create an array with the correct number of sections!");
TASSERT( out[0].Size() == 6, "Split() 1 did not create correct size section!");
TASSERT( out[0].Front() == 1, "Split() 1 did not create correct front element!");
TASSERT( out[0].Back() == 5, "Split() 1 did not create correct back element!");
values.PushBack(6);
out = ZArrayAlgo::Split(list, values);
TASSERT( out.Size() == 2, "Split() 2 did not create an array with the correct number of sections!");
TASSERT( out[0].Size() == 2, "Split() 2 did not create correct size section 1!");
TASSERT( out[0].Front() == 1, "Split() 2 did not create correct front element on section 1!");
TASSERT( out[0].Back() == 3, "Split() 2 did not create correct back element on section 1!");
TASSERT( out[1].Size() == 3, "Split() 2 did not create correct size section 2!");
TASSERT( out[1].Front() == 7, "Split() 2 did not create correct front element on section 2!");
TASSERT( out[1].Back() == 5, "Split() 2 did not create correct back element on section 2!");
values.PushBack(5);
out = ZArrayAlgo::Split(list, values);
TASSERT( out.Size() == 2, "Split() 3 did not create an array with the correct number of sections!");
TASSERT( out[0].Size() == 2, "Split() 3 did not create correct size section 1!");
TASSERT( out[0].Front() == 1, "Split() 3 did not create correct front element on section 1!");
TASSERT( out[0].Back() == 3, "Split() 3 did not create correct back element on section 1!");
TASSERT( out[1].Size() == 2, "Split() 3 did not create correct size section 2!");
TASSERT( out[1].Front() == 7, "Split() 3 did not create correct front element on section 2!");
TASSERT( out[1].Back() == 2, "Split() 3 did not create correct back element on section 2!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Split_Count()
{
ZArray<int> list;
list.PushBack(4);
list.PushBack(1);
list.PushBack(3);
list.PushBack(6);
list.PushBack(7);
list.PushBack(2);
list.PushBack(5);
list.PushBack(1);
list.PushBack(7);
ZArray<int> values;
values.PushBack(1);
ZArray< ZArray<int> > out = ZArrayAlgo::Split(list, values, 1);
//Should create [ [4], [3, 6, 7, 2, 5, 1, 7] ]
TASSERT( out.Size() == 2, "Split() 1 did not create an array with the correct number of sections!");
TASSERT( out[0].Size() == 1, "Split() 1 did not create correct size section 1!");
TASSERT( out[0].Front() == 4, "Split() 1 did not create correct front element for section 1!");
TASSERT( out[0].Back() == 4, "Split() 1 did not create correct back element for section 1!");
TASSERT( out[1].Size() == 7, "Split() 1 did not create correct size section 2!");
TASSERT( out[1].Front() == 3, "Split() 1 did not create correct front element for section 2!");
TASSERT( out[1].Back() == 7, "Split() 1 did not create correct back element for section 2!");
values.PushBack(6);
out = ZArrayAlgo::Split(list, values, 2);
//Should create [ [4], [3], [7, 2, 5, 1, 7] ]
TASSERT( out.Size() == 3, "Split() 2 did not create an array with the correct number of sections!");
TASSERT( out[0].Size() == 1, "Split() 2 did not create correct size section 1!");
TASSERT( out[0].Front() == 4, "Split() 2 did not create correct front element for section 1!");
TASSERT( out[0].Back() == 4, "Split() 2 did not create correct back element for section 1!");
TASSERT( out[1].Size() == 1, "Split() 2 did not create correct size section 2!");
TASSERT( out[1].Front() == 3, "Split() 2 did not create correct front element for section 2!");
TASSERT( out[1].Back() == 3, "Split() 2 did not create correct back element for section 2!");
TASSERT( out[2].Size() == 5, "Split() 2 did not create correct size section 3!");
TASSERT( out[2].Front() == 7, "Split() 2 did not create correct front element for section 3!");
TASSERT( out[2].Back() == 7, "Split() 2 did not create correct back element for section 3!");
values.PushBack(5);
out = ZArrayAlgo::Split(list, values, 15);
//Should create [ [4], [3], [7, 2], [7] ]
TASSERT( out.Size() == 4, "Split() 3 did not create an array with the correct number of sections!");
TASSERT( out[0].Size() == 1, "Split() 3 did not create correct size section 1!");
TASSERT( out[0].Front() == 4, "Split() 3 did not create correct front element for section 1!");
TASSERT( out[0].Back() == 4, "Split() 3 did not create correct back element for section 1!");
TASSERT( out[1].Size() == 1, "Split() 3 did not create correct size section 2!");
TASSERT( out[1].Front() == 3, "Split() 3 did not create correct front element for section 2!");
TASSERT( out[1].Back() == 3, "Split() 3 did not create correct back element for section 2!");
TASSERT( out[2].Size() == 2, "Split() 3 did not create correct size section 3!");
TASSERT( out[2].Front() == 7, "Split() 3 did not create correct front element for section 3!");
TASSERT( out[2].Back() == 2, "Split() 3 did not create correct back element for section 3!");
TASSERT( out[3].Size() == 1, "Split() 3 did not create correct size section 4!");
TASSERT( out[3].Front() == 7, "Split() 3 did not create correct front element for section 4!");
TASSERT( out[3].Back() == 7, "Split() 3 did not create correct back element for section 4!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Split_Count_Region()
{
ZArray<int> list;
list.PushBack(4);
list.PushBack(1);
list.PushBack(3);
list.PushBack(6);
list.PushBack(7);
list.PushBack(2);
list.PushBack(5);
list.PushBack(1);
list.PushBack(7);
ZArray<int> values;
values.PushBack(1);
ZArray< ZArray<int> > out = ZArrayAlgo::Split(list, values, 1, 4, list.Size());
//Should create [ [7, 2, 5], [7] ]
TASSERT( out.Size() == 2, "Split() 1 did not create an array with the correct number of sections!");
TASSERT( out[0].Size() == 3, "Split() 1 did not create correct size section 1!");
TASSERT( out[0].Front() == 7, "Split() 1 did not create correct front element for section 1!");
TASSERT( out[0].Back() == 5, "Split() 1 did not create correct back element for section 1!");
TASSERT( out[1].Size() == 1, "Split() 1 did not create correct size section 2!");
TASSERT( out[1].Front() == 7, "Split() 1 did not create correct front element for section 2!");
TASSERT( out[1].Back() == 7, "Split() 1 did not create correct back element for section 2!");
values.PushBack(6);
out = ZArrayAlgo::Split(list, values, 2, 4, list.Size());
//Should create [ [7, 2, 5], [7] ]
TASSERT( out.Size() == 2, "Split() 2 did not create an array with the correct number of sections!");
TASSERT( out[0].Size() == 3, "Split() 2 did not create correct size section 1!");
TASSERT( out[0].Front() == 7, "Split() 2 did not create correct front element for section 1!");
TASSERT( out[0].Back() == 5, "Split() 2 did not create correct back element for section 1!");
TASSERT( out[1].Size() == 1, "Split() 2 did not create correct size section 2!");
TASSERT( out[1].Front() == 7, "Split() 2 did not create correct front element for section 2!");
TASSERT( out[1].Back() == 7, "Split() 2 did not create correct back element for section 2!");
values.PushBack(5);
out = ZArrayAlgo::Split(list, values, 15, 1, list.Size());
//Should create [ [3], [7, 2], [7] ]
TASSERT( out.Size() == 3, "Split() 3 did not create an array with the correct number of sections!");
TASSERT( out[0].Size() == 1, "Split() 3 did not create correct size section 1!");
TASSERT( out[0].Front() == 3, "Split() 3 did not create correct front element for section 1!");
TASSERT( out[0].Back() == 3, "Split() 3 did not create correct back element for section 1!");
TASSERT( out[1].Size() == 2, "Split() 3 did not create correct size section 2!");
TASSERT( out[1].Front() == 7, "Split() 3 did not create correct front element for section 2!");
TASSERT( out[1].Back() == 2, "Split() 3 did not create correct back element for section 2!");
TASSERT( out[2].Size() == 1, "Split() 3 did not create correct size section 3!");
TASSERT( out[2].Front() == 7, "Split() 3 did not create correct front element for section 3!");
TASSERT( out[2].Back() == 7, "Split() 3 did not create correct back element for section 3!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Sum()
{
ZArray<int> list;
ZArray<ArrayValueTestClass> list2;
int ans;
ArrayValueTestClass ans2;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ans = ZArrayAlgo::Sum(list, 10);
TASSERT (ans == 25, "Accumulate() failed to accumulate correctly on primitive list!\n");
list2.PushBack(1);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
ans2 = ZArrayAlgo::Sum(list2, ArrayValueTestClass(10));
TASSERT (ans2.val == 25, "Accumulate() failed to accumulate correctly on overridden list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Sum_Region()
{
ZArray<int> list;
ZArray<ArrayValueTestClass> list2;
int ans;
ArrayValueTestClass ans2;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
ans = ZArrayAlgo::Sum(list, 10, 1, 4);
TASSERT (ans == 19, "Accumulate() failed to accumulate correctly on primitive list!\n");
list2.PushBack(1);
list2.PushBack(2);
list2.PushBack(3);
list2.PushBack(4);
list2.PushBack(5);
ans2 = ZArrayAlgo::Sum(list2, ArrayValueTestClass(10), 1, 4);
TASSERT (ans2.val == 19, "Accumulate() failed to accumulate correctly on overridden list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_SwapElements()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
ZArrayAlgo::SwapElements(list, 1,2);
TASSERT( list.Size() == 3, "SwapElements changed list size!\n");
TASSERT( list.PopFront() == 1, "SwapElements corrupted list!\n");
TASSERT( list.PopFront() == 3, "SwapElements failed to swap elements in list!\n");
TASSERT( list.PopFront() == 2, "SwapElements failed to swap elements in list!\n");
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
ZArrayAlgo::SwapElements(list, 1,1);
TASSERT( list.Size() == 3, "SwapElements changed list size!\n");
TASSERT( list.PopFront() == 1, "SwapElements corrupted list!\n");
TASSERT( list.PopFront() == 2, "SwapElements failed to swap elements in list!\n");
TASSERT( list.PopFront() == 3, "SwapElements failed to swap elements in list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Unique()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
TASSERT( ZArrayAlgo::Unique(list) == 0, "Unique() claims removals on unique list!\n");
TASSERT( list.Size() == 3, "Unique() changed length of list!\n");
list.PushBack(2);
list.PushBack(3);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::Unique(list) == 4, "Unique() claims wrong number of removals on nonunique list!\n");
TASSERT( list.Size() == 5, "Unique() changed length of list to wrong value!\n");
TASSERT( list.PopFront() == 1, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 2, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 3, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 4, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 5, "Unique() put wrong value into list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* test_Unique_In_Region()
{
ZArray<int> list;
list.PushBack(1);
list.PushBack(2);
list.PushBack(3);
list.PushBack(2);
list.PushBack(3);
list.PushBack(2);
list.PushBack(3);
list.PushBack(4);
list.PushBack(5);
TASSERT( ZArrayAlgo::Unique(list, 1, 4) == 1, "Unique() claims wrong number of removals on nonunique list!\n");
TASSERT( list.Size() == 8, "Unique() changed length of list to wrong value!\n");
TASSERT( list.PopFront() == 1, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 2, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 3, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 3, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 2, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 3, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 4, "Unique() put wrong value into list!\n");
TASSERT( list.PopFront() == 5, "Unique() put wrong value into list!\n");
return ZTEST_SUCCESS;
}
/*************************************************************************/
Reference in New Issue View Git Blame Copy Permalink