609 lines
16 KiB
C++
609 lines
16 KiB
C++
#include "Testing/ContainersTesting.h"
|
|
|
|
#include "Containers/Containers.h"
|
|
#include "Miscellaneous/AssertionMacros.h"
|
|
|
|
NAMESPACE_REDCRAFT_BEGIN
|
|
NAMESPACE_MODULE_BEGIN(Redcraft)
|
|
NAMESPACE_MODULE_BEGIN(Utility)
|
|
|
|
NAMESPACE_BEGIN(Testing)
|
|
|
|
void TestContainers()
|
|
{
|
|
TestArray();
|
|
TestStaticArray();
|
|
TestArrayView();
|
|
TestBitset();
|
|
TestStaticBitset();
|
|
TestList();
|
|
}
|
|
|
|
NAMESPACE_UNNAMED_BEGIN
|
|
|
|
template <typename Allocator, size_t Capacity>
|
|
void TestArrayTemplate()
|
|
{
|
|
{
|
|
TArray<int32, Allocator> ArrayA;
|
|
TArray<int32, Allocator> ArrayB(4);
|
|
TArray<int32, Allocator> ArrayC(4, 4);
|
|
TArray<int32, Allocator> ArrayD(ArrayC);
|
|
TArray<int32, Allocator> ArrayE(MoveTemp(ArrayB));
|
|
TArray<int32, Allocator> ArrayF({ 0, 1, 2, 3 });
|
|
|
|
TArray<int32, Allocator> ArrayG;
|
|
TArray<int32, Allocator> ArrayH;
|
|
TArray<int32, Allocator> ArrayI;
|
|
|
|
ArrayG = ArrayD;
|
|
ArrayH = MoveTemp(ArrayE);
|
|
ArrayI = { 0, 1, 2, 3 };
|
|
|
|
always_check((ArrayC == TArray<int32, Allocator>({ 4, 4, 4, 4 })));
|
|
always_check((ArrayD == TArray<int32, Allocator>({ 4, 4, 4, 4 })));
|
|
always_check((ArrayG == TArray<int32, Allocator>({ 4, 4, 4, 4 })));
|
|
always_check((ArrayF == TArray<int32, Allocator>({ 0, 1, 2, 3 })));
|
|
always_check((ArrayI == TArray<int32, Allocator>({ 0, 1, 2, 3 })));
|
|
}
|
|
|
|
{
|
|
TArray<int32, Allocator> ArrayA = { 1, 2, 3 };
|
|
TArray<int32, Allocator> ArrayB = { 7, 8, 9, 10 };
|
|
TArray<int32, Allocator> ArrayC = { 1, 2, 3 };
|
|
|
|
always_check((!(ArrayA == ArrayB)));
|
|
always_check(( (ArrayA != ArrayB)));
|
|
always_check(( (ArrayA < ArrayB)));
|
|
always_check(( (ArrayA <= ArrayB)));
|
|
always_check((!(ArrayA > ArrayB)));
|
|
always_check((!(ArrayA >= ArrayB)));
|
|
|
|
always_check(( (ArrayA == ArrayC)));
|
|
always_check((!(ArrayA != ArrayC)));
|
|
always_check((!(ArrayA < ArrayC)));
|
|
always_check(( (ArrayA <= ArrayC)));
|
|
always_check((!(ArrayA > ArrayC)));
|
|
always_check(( (ArrayA >= ArrayC)));
|
|
}
|
|
|
|
{
|
|
TArray<int32, Allocator> Array = { 1, 2, 3 };
|
|
|
|
Array.Insert(Array.Begin() + 1, 2);
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 2, 2, 3 })));
|
|
|
|
Array.Insert(Array.End(), 2, 4);
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 2, 2, 3, 4, 4 })));
|
|
|
|
Array.Insert(Array.Begin(), { 1, 1, 4, 5, 1, 4 });
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 1, 4, 5, 1, 4, 1, 2, 2, 3, 4, 4 })));
|
|
|
|
Array.Emplace(Array.End(), 5);
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 1, 4, 5, 1, 4, 1, 2, 2, 3, 4, 4, 5 })));
|
|
|
|
Array.StableErase(Array.End() - 1);
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 1, 4, 5, 1, 4, 1, 2, 2, 3, 4, 4 })));
|
|
|
|
Array.StableErase(Array.End() - 2, Array.End());
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 1, 4, 5, 1, 4, 1, 2, 2, 3 })));
|
|
|
|
Array.Erase(Array.End() - 2);
|
|
always_check((Array.Num() == 9));
|
|
|
|
Array.Erase(Array.Begin(), Array.Begin() + 6);
|
|
always_check((Array.Num() == 3));
|
|
}
|
|
|
|
{
|
|
TArray<int32, Allocator> Array = { 1, 2, 3 };
|
|
|
|
Array.PushBack(4);
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 2, 3, 4 })));
|
|
|
|
Array.EmplaceBack(5);
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 2, 3, 4, 5 })));
|
|
|
|
Array.EmplaceBack(5) = 6;
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 2, 3, 4, 5, 6 })));
|
|
|
|
Array.PopBack();
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 2, 3, 4, 5 })));
|
|
|
|
Array.SetNum(4);
|
|
always_check((Array == TArray<int32, Allocator>({ 1, 2, 3, 4 })));
|
|
|
|
Array.Reserve(64);
|
|
always_check((Array.Num() == 4));
|
|
always_check((Array.Max() == 64 || Array.Max() == Capacity));
|
|
|
|
Array.Shrink();
|
|
always_check((Array.Num() == 4));
|
|
always_check((Array.Max() == 4 || Array.Max() == Capacity));
|
|
}
|
|
}
|
|
|
|
NAMESPACE_UNNAMED_END
|
|
|
|
void TestArray()
|
|
{
|
|
TestArrayTemplate<FHeapAllocator, 0>();
|
|
TestArrayTemplate<TInlineAllocator<8>, 8>();
|
|
TestArrayTemplate<TFixedAllocator<64>, 64>();
|
|
}
|
|
|
|
void TestStaticArray()
|
|
{
|
|
{
|
|
TStaticArray<int32, 4> ArrayA = { 0, 0, 0, 0 };
|
|
TStaticArray<int32, 4> ArrayB = { 0, 0, 0, 0 };
|
|
TStaticArray<int32, 4> ArrayC = { 4, 4, 4, 4 };
|
|
TStaticArray<int32, 4> ArrayD(ArrayC);
|
|
TStaticArray<int32, 4> ArrayE(MoveTemp(ArrayB));
|
|
TStaticArray<int32, 4> ArrayF = { 0, 1, 2, 3 };
|
|
|
|
TStaticArray<int32, 4> ArrayG;
|
|
TStaticArray<int32, 4> ArrayH;
|
|
TStaticArray<int32, 4> ArrayI;
|
|
|
|
ArrayG = ArrayD;
|
|
ArrayH = MoveTemp(ArrayE);
|
|
ArrayI = { 0, 1, 2, 3 };
|
|
|
|
always_check((ArrayC == TStaticArray<int32, 4>({ 4, 4, 4, 4 })));
|
|
always_check((ArrayD == TStaticArray<int32, 4>({ 4, 4, 4, 4 })));
|
|
always_check((ArrayG == TStaticArray<int32, 4>({ 4, 4, 4, 4 })));
|
|
always_check((ArrayF == TStaticArray<int32, 4>({ 0, 1, 2, 3 })));
|
|
always_check((ArrayI == TStaticArray<int32, 4>({ 0, 1, 2, 3 })));
|
|
}
|
|
|
|
{
|
|
TStaticArray ArrayA = { 1, 2, 3 };
|
|
TStaticArray ArrayC = { 1, 2, 3 };
|
|
|
|
always_check(( (ArrayA == ArrayC)));
|
|
always_check((!(ArrayA != ArrayC)));
|
|
always_check((!(ArrayA < ArrayC)));
|
|
always_check(( (ArrayA <= ArrayC)));
|
|
always_check((!(ArrayA > ArrayC)));
|
|
always_check(( (ArrayA >= ArrayC)));
|
|
}
|
|
|
|
{
|
|
int32 ArrayA[4] = { 1, 2, 3, 4 };
|
|
TStaticArray<int32, 4> ArrayB = ToArray(ArrayA);
|
|
auto [A, B, C, D] = ArrayB;
|
|
|
|
always_check(A == 1);
|
|
always_check(B == 2);
|
|
always_check(C == 3);
|
|
always_check(D == 4);
|
|
}
|
|
}
|
|
|
|
void TestArrayView()
|
|
{
|
|
{
|
|
int32 ArrayA[] = { 0, 0, 0, 0 };
|
|
TStaticArray ArrayB = { 4, 4, 4, 4 };
|
|
TArray ArrayC = { 0, 1, 2, 3 };
|
|
|
|
TArrayView<int32, 0> ViewA;
|
|
TArrayView<int32, 4> ViewB(ArrayA);
|
|
TArrayView<int32, 4> ViewC(ArrayB);
|
|
TArrayView<int32, 4> ViewD(ViewC);
|
|
TArrayView<int32, 4> ViewE(MoveTemp(ViewB));
|
|
TArrayView<int32, 4> ViewF(ArrayC);
|
|
|
|
TArrayView<int32> ViewG;
|
|
TArrayView<int32> ViewH;
|
|
TArrayView<int32> ViewI;
|
|
|
|
ViewG = ViewD;
|
|
ViewH = MoveTemp(ViewE);
|
|
ViewI = ArrayC;
|
|
|
|
always_check(ViewC == ArrayB);
|
|
always_check(ViewD == ArrayB);
|
|
always_check(ViewG == ArrayB);
|
|
always_check(ViewF == ArrayC);
|
|
always_check(ViewI == ArrayC);
|
|
}
|
|
|
|
{
|
|
int32 Array[] = { 0, 1, 2, 3 };
|
|
|
|
TArrayView<int32, 4> View = Array;
|
|
|
|
int32 First2[] = { 0, 1 };
|
|
always_check(View.First<2>() == First2);
|
|
always_check(View.First(2) == First2);
|
|
|
|
int32 Last2[] = { 2, 3 };
|
|
always_check(View.Last<2>() == Last2);
|
|
always_check(View.Last(2) == Last2);
|
|
|
|
int32 Subview2[] = { 1, 2 };
|
|
always_check((View.Subview<1, 2>() == Subview2));
|
|
always_check((View.Subview(1, 2) == Subview2));
|
|
}
|
|
|
|
{
|
|
int32 Array[] = { 0, 1, 2, 3 };
|
|
|
|
TArrayView<int32, 4> View = Array;
|
|
|
|
always_check(View.Num() == 4);
|
|
always_check(View.NumBytes() == 16);
|
|
|
|
TArrayView ViewBytes = View.AsBytes();
|
|
|
|
always_check(ViewBytes.Num() == 16);
|
|
always_check(ViewBytes.NumBytes() == 16);
|
|
}
|
|
}
|
|
|
|
void TestBitset()
|
|
{
|
|
{
|
|
FBitset BitsetA;
|
|
FBitset BitsetB(16);
|
|
FBitset BitsetC(16, 0b1010'0100'0100'0010);
|
|
FBitset BitsetD(BitsetC);
|
|
FBitset BitsetE(MoveTemp(BitsetB));
|
|
FBitset BitsetF({ true, false, true, false });
|
|
|
|
FBitset BitsetG;
|
|
FBitset BitsetH;
|
|
FBitset BitsetI;
|
|
|
|
BitsetG = BitsetD;
|
|
BitsetH = MoveTemp(BitsetE);
|
|
BitsetI = { true, false, true, false };
|
|
|
|
always_check((BitsetF == FBitset({ true, false, true, false })));
|
|
always_check((BitsetI == FBitset({ true, false, true, false })));
|
|
}
|
|
|
|
{
|
|
FBitset BitsetA(64, 0x0139'0239'0339'0439ull);
|
|
uint64 IntA = 0x0139'0239'0339'0439ull;
|
|
|
|
FBitset BitsetB(32, 0x017F'027Full);
|
|
uint32 IntB = 0x017F'027Full;
|
|
|
|
FBitset BitsetANDA = BitsetA; BitsetANDA &= BitsetB;
|
|
FBitset BitsetANDB = BitsetB; BitsetANDB &= BitsetA;
|
|
|
|
FBitset BitsetORA = BitsetA; BitsetORA &= BitsetB;
|
|
FBitset BitsetORB = BitsetB; BitsetORB &= BitsetA;
|
|
|
|
FBitset BitsetXORA = BitsetA; BitsetXORA &= BitsetB;
|
|
FBitset BitsetXORB = BitsetB; BitsetXORB &= BitsetA;
|
|
|
|
uint64 IntANDA = IntA; IntANDA &= IntB;
|
|
uint32 IntANDB = IntB; IntANDB &= IntA;
|
|
|
|
uint64 IntORA = IntA; IntORA &= IntB;
|
|
uint32 IntORB = IntB; IntORB &= IntA;
|
|
|
|
uint64 IntXORA = IntA; IntXORA &= IntB;
|
|
uint32 IntXORB = IntB; IntXORB &= IntA;
|
|
|
|
always_check((BitsetANDA.ToIntegral() == IntANDA));
|
|
always_check((BitsetANDB.ToIntegral() == IntANDB));
|
|
always_check((BitsetORA.ToIntegral() == IntORA));
|
|
always_check((BitsetORB.ToIntegral() == IntORB));
|
|
always_check((BitsetXORA.ToIntegral() == IntXORA));
|
|
always_check((BitsetXORB.ToIntegral() == IntXORB));
|
|
}
|
|
|
|
{
|
|
FBitset BitsetA(64, 0x0139'0239'0339'0439ull);
|
|
uint64 IntA = 0x0139'0239'0339'0439ull;
|
|
|
|
FBitset BitsetB(32, 0x017F'027Full);
|
|
uint32 IntB = 0x017F'027Full;
|
|
|
|
always_check(((BitsetA & BitsetB).ToIntegral() == (IntA & IntB)));
|
|
always_check(((BitsetA | BitsetB).ToIntegral() == (IntA | IntB)));
|
|
always_check(((BitsetA ^ BitsetB).ToIntegral() == (IntA ^ IntB)));
|
|
}
|
|
|
|
{
|
|
FBitset Bitset(64, 0x0139'0239'0339'0439ull);
|
|
uint64 Int = 0x0139'0239'0339'0439ull;
|
|
|
|
always_check(((Bitset << 40).ToIntegral() == (Int << 40)));
|
|
always_check(((Bitset >> 40).ToIntegral() == (Int >> 40)));
|
|
}
|
|
|
|
{
|
|
FBitset BitsetA(4, 0b0000ull);
|
|
FBitset BitsetB(4, 0b0101ull);
|
|
FBitset BitsetC(4, 0b1111ull);
|
|
|
|
always_check((!BitsetA.All() && !BitsetA.Any() && BitsetA.None()));
|
|
always_check((!BitsetB.All() && BitsetB.Any() && !BitsetB.None()));
|
|
always_check(( BitsetC.All() && BitsetC.Any() && !BitsetC.None()));
|
|
}
|
|
|
|
{
|
|
FBitset Bitset(16);
|
|
|
|
Bitset.Set();
|
|
|
|
always_check((Bitset.Count() == 16));
|
|
|
|
Bitset.Flip(8);
|
|
|
|
always_check((Bitset.Count() == 15));
|
|
|
|
Bitset.Flip(8);
|
|
|
|
always_check((Bitset.Count() == 16));
|
|
|
|
Bitset.Flip();
|
|
|
|
always_check((Bitset.Count() == 0));
|
|
|
|
Bitset.PushBack(true);
|
|
|
|
always_check((Bitset.Num() == 17));
|
|
always_check((Bitset.Count() == 1));
|
|
|
|
Bitset.PopBack();
|
|
|
|
always_check((Bitset.Num() == 16));
|
|
always_check((Bitset.Count() == 0));
|
|
|
|
Bitset.SetNum(32, true, true);
|
|
|
|
always_check((Bitset.Num() == 32));
|
|
always_check((Bitset.Count() == 16));
|
|
}
|
|
|
|
{
|
|
FBitset BitsetA(4);
|
|
FBitset BitsetB(4);
|
|
|
|
BitsetA[0] = true;
|
|
BitsetA[1] = false;
|
|
BitsetA[2] = true;
|
|
BitsetA[3] = false;
|
|
|
|
BitsetB[0] = true;
|
|
BitsetB[1] = false;
|
|
BitsetB[2] = true;
|
|
BitsetB[3] = false;
|
|
|
|
Swap(BitsetA, BitsetB);
|
|
|
|
always_check((GetTypeHash(BitsetA) == GetTypeHash(BitsetB)));
|
|
}
|
|
}
|
|
|
|
void TestStaticBitset()
|
|
{
|
|
{
|
|
TStaticBitset< 0> BitsetA;
|
|
TStaticBitset<16> BitsetB;
|
|
TStaticBitset<16> BitsetC(0b1010'0100'0100'0010);
|
|
TStaticBitset<16> BitsetD(BitsetC);
|
|
TStaticBitset<16> BitsetE(MoveTemp(BitsetB));
|
|
TStaticBitset< 4> BitsetF(0b0101);
|
|
|
|
TStaticBitset<16> BitsetG;
|
|
TStaticBitset<16> BitsetH;
|
|
TStaticBitset< 4> BitsetI;
|
|
|
|
BitsetG = BitsetD;
|
|
BitsetH = MoveTemp(BitsetE);
|
|
BitsetI = 0b0101;
|
|
|
|
always_check((BitsetF == TStaticBitset<4>(0b0101)));
|
|
always_check((BitsetI == TStaticBitset<4>(0b0101)));
|
|
}
|
|
|
|
{
|
|
TStaticBitset<32> BitsetA(0x0139'0239ull);
|
|
uint32 IntA = 0x0139'0239ull;
|
|
|
|
TStaticBitset<32> BitsetB(0x017F'027Full);
|
|
uint32 IntB = 0x017F'027Full;
|
|
|
|
TStaticBitset<32> BitsetANDA = BitsetA; BitsetANDA &= BitsetB;
|
|
TStaticBitset<32> BitsetANDB = BitsetB; BitsetANDB &= BitsetA;
|
|
|
|
TStaticBitset<32> BitsetORA = BitsetA; BitsetORA &= BitsetB;
|
|
TStaticBitset<32> BitsetORB = BitsetB; BitsetORB &= BitsetA;
|
|
|
|
TStaticBitset<32> BitsetXORA = BitsetA; BitsetXORA &= BitsetB;
|
|
TStaticBitset<32> BitsetXORB = BitsetB; BitsetXORB &= BitsetA;
|
|
|
|
uint32 IntANDA = IntA; IntANDA &= IntB;
|
|
uint32 IntANDB = IntB; IntANDB &= IntA;
|
|
|
|
uint32 IntORA = IntA; IntORA &= IntB;
|
|
uint32 IntORB = IntB; IntORB &= IntA;
|
|
|
|
uint32 IntXORA = IntA; IntXORA &= IntB;
|
|
uint32 IntXORB = IntB; IntXORB &= IntA;
|
|
|
|
always_check((BitsetANDA.ToIntegral() == IntANDA));
|
|
always_check((BitsetANDB.ToIntegral() == IntANDB));
|
|
always_check((BitsetORA.ToIntegral() == IntORA));
|
|
always_check((BitsetORB.ToIntegral() == IntORB));
|
|
always_check((BitsetXORA.ToIntegral() == IntXORA));
|
|
always_check((BitsetXORB.ToIntegral() == IntXORB));
|
|
}
|
|
|
|
{
|
|
TStaticBitset<32> BitsetA(0x0139'0239ull);
|
|
uint32 IntA = 0x0139'0239ull;
|
|
|
|
TStaticBitset<32> BitsetB(0x017F'027Full);
|
|
uint32 IntB = 0x017F'027Full;
|
|
|
|
always_check(((BitsetA & BitsetB).ToIntegral() == (IntA & IntB)));
|
|
always_check(((BitsetA | BitsetB).ToIntegral() == (IntA | IntB)));
|
|
always_check(((BitsetA ^ BitsetB).ToIntegral() == (IntA ^ IntB)));
|
|
}
|
|
|
|
{
|
|
TStaticBitset<64> Bitset(0x0139'0239'0339'0439ull);
|
|
uint64 Int = 0x0139'0239'0339'0439ull;
|
|
|
|
always_check(((Bitset << 40).ToIntegral() == (Int << 40)));
|
|
always_check(((Bitset >> 40).ToIntegral() == (Int >> 40)));
|
|
}
|
|
|
|
{
|
|
TStaticBitset<4> BitsetA(0b0000ull);
|
|
TStaticBitset<4> BitsetB(0b0101ull);
|
|
TStaticBitset<4> BitsetC(0b1111ull);
|
|
|
|
always_check((!BitsetA.All() && !BitsetA.Any() && BitsetA.None()));
|
|
always_check((!BitsetB.All() && BitsetB.Any() && !BitsetB.None()));
|
|
always_check(( BitsetC.All() && BitsetC.Any() && !BitsetC.None()));
|
|
}
|
|
|
|
{
|
|
TStaticBitset<16> Bitset;
|
|
|
|
Bitset.Set();
|
|
|
|
always_check((Bitset.Count() == 16));
|
|
|
|
Bitset.Flip(8);
|
|
|
|
always_check((Bitset.Count() == 15));
|
|
|
|
Bitset.Flip(8);
|
|
|
|
always_check((Bitset.Count() == 16));
|
|
|
|
Bitset.Flip();
|
|
|
|
always_check((Bitset.Count() == 0));
|
|
}
|
|
|
|
{
|
|
TStaticBitset<4> BitsetA;
|
|
TStaticBitset<4> BitsetB;
|
|
|
|
BitsetA[0] = true;
|
|
BitsetA[1] = false;
|
|
BitsetA[2] = true;
|
|
BitsetA[3] = false;
|
|
|
|
BitsetB[0] = true;
|
|
BitsetB[1] = false;
|
|
BitsetB[2] = true;
|
|
BitsetB[3] = false;
|
|
|
|
Swap(BitsetA, BitsetB);
|
|
|
|
always_check((GetTypeHash(BitsetA) == GetTypeHash(BitsetB)));
|
|
}
|
|
}
|
|
|
|
void TestList()
|
|
{
|
|
{
|
|
TList<int32> ListA;
|
|
TList<int32> ListB(4);
|
|
TList<int32> ListC(4, 4);
|
|
TList<int32> ListD(ListC);
|
|
TList<int32> ListE(MoveTemp(ListB));
|
|
TList<int32> ListF({ 0, 1, 2, 3 });
|
|
|
|
TList<int32> ListG;
|
|
TList<int32> ListH;
|
|
TList<int32> ListI;
|
|
|
|
ListG = ListD;
|
|
ListH = MoveTemp(ListE);
|
|
ListI = { 0, 1, 2, 3 };
|
|
|
|
always_check((ListC == TList<int32>({ 4, 4, 4, 4 })));
|
|
always_check((ListD == TList<int32>({ 4, 4, 4, 4 })));
|
|
always_check((ListG == TList<int32>({ 4, 4, 4, 4 })));
|
|
always_check((ListF == TList<int32>({ 0, 1, 2, 3 })));
|
|
always_check((ListI == TList<int32>({ 0, 1, 2, 3 })));
|
|
}
|
|
|
|
{
|
|
TList<int32> ListA = { 1, 2, 3 };
|
|
TList<int32> ListB = { 7, 8, 9, 10 };
|
|
TList<int32> ListC = { 1, 2, 3 };
|
|
|
|
always_check((!(ListA == ListB)));
|
|
always_check(( (ListA != ListB)));
|
|
always_check(( (ListA < ListB)));
|
|
always_check(( (ListA <= ListB)));
|
|
always_check((!(ListA > ListB)));
|
|
always_check((!(ListA >= ListB)));
|
|
|
|
always_check(( (ListA == ListC)));
|
|
always_check((!(ListA != ListC)));
|
|
always_check((!(ListA < ListC)));
|
|
always_check(( (ListA <= ListC)));
|
|
always_check((!(ListA > ListC)));
|
|
always_check(( (ListA >= ListC)));
|
|
}
|
|
|
|
{
|
|
TList<int32> List = { 1, 2, 3 };
|
|
|
|
List.Insert(++List.Begin(), 2);
|
|
always_check((List == TList<int32>({ 1, 2, 2, 3 })));
|
|
|
|
List.Insert(List.End(), 2, 4);
|
|
always_check((List == TList<int32>({ 1, 2, 2, 3, 4, 4 })));
|
|
|
|
List.Insert(List.Begin(), { 1, 1, 4, 5, 1, 4 });
|
|
always_check((List == TList<int32>({ 1, 1, 4, 5, 1, 4, 1, 2, 2, 3, 4, 4 })));
|
|
|
|
List.Emplace(List.End(), 5);
|
|
always_check((List == TList<int32>({ 1, 1, 4, 5, 1, 4, 1, 2, 2, 3, 4, 4, 5 })));
|
|
|
|
List.Erase(--List.End());
|
|
always_check((List == TList<int32>({ 1, 1, 4, 5, 1, 4, 1, 2, 2, 3, 4, 4 })));
|
|
|
|
List.Erase(----List.End(), List.End());
|
|
always_check((List == TList<int32>({ 1, 1, 4, 5, 1, 4, 1, 2, 2, 3 })));
|
|
}
|
|
|
|
{
|
|
TList<int32> List = { 1, 2, 3 };
|
|
|
|
List.PushBack(4);
|
|
always_check((List == TList<int32>({ 1, 2, 3, 4 })));
|
|
|
|
List.EmplaceBack(5);
|
|
always_check((List == TList<int32>({ 1, 2, 3, 4, 5 })));
|
|
|
|
List.EmplaceBack(5) = 6;
|
|
always_check((List == TList<int32>({ 1, 2, 3, 4, 5, 6 })));
|
|
|
|
List.PopBack();
|
|
always_check((List == TList<int32>({ 1, 2, 3, 4, 5 })));
|
|
|
|
List.EmplaceFront(1) = 0;
|
|
always_check((List == TList<int32>({ 0, 1, 2, 3, 4, 5 })));
|
|
|
|
List.PopFront();
|
|
always_check((List == TList<int32>({ 1, 2, 3, 4, 5 })));
|
|
|
|
List.SetNum(4);
|
|
always_check((List == TList<int32>({ 1, 2, 3, 4 })));
|
|
}
|
|
}
|
|
|
|
NAMESPACE_END(Testing)
|
|
|
|
NAMESPACE_MODULE_END(Utility)
|
|
NAMESPACE_MODULE_END(Redcraft)
|
|
NAMESPACE_REDCRAFT_END
|